Пример #1
0
 private ArrayList<String> getChildrenFeat1(ArrayList<FeaturizedToken> childrenObjectList) {
   ArrayList<String> childrenFeat1 = new ArrayList<String>();
   for (FeaturizedToken child : childrenObjectList) {
     childrenFeat1.add(child.getFeat6().get(0));
   }
   return childrenFeat1;
 }
Пример #2
0
  private void addZhaoSupervisedCombinedFeats(
      FeaturizedToken pred,
      FeaturizedToken arg,
      ArrayList<String> feats,
      ArrayList<FeaturizedToken> dependencyPathObjectList,
      ArrayList<FeaturizedToken> linePathCoNLL,
      List<Pair<Integer, Dir>> dpPathArg) {
    // ------- Combined features (supervised) -------
    String feat;
    // a.lemma + p.lemma
    feat = arg.getLemma() + "_" + pred.getLemma();
    feats.add(feat);
    // (a:p|dpPath.dprel) + p.FEAT1
    // a:p|dpPath.lemma.seq
    // a:p|dpPath.lemma.bag
    ArrayList<String> depRelPath = new ArrayList<String>();
    ArrayList<String> depRelPathLemma = new ArrayList<String>();
    for (FeaturizedToken t : dependencyPathObjectList) {
      depRelPath.add(t.getDeprel());
      depRelPathLemma.add(t.getLemma());
    }

    feat = buildString(depRelPath) + pred.getFeat6().get(0);
    feats.add(feat);
    feat = buildString(depRelPathLemma);
    feats.add(feat);
    ArrayList<String> depRelPathLemmaBag = bag(depRelPathLemma);
    feat = buildString(depRelPathLemmaBag);
    feats.add(feat);
    // a:p|linePath.FEAT1.bag
    // a:p|linePath.lemma.seq
    // a:p|linePath.dprel.seq
    ArrayList<String> linePathFeat = new ArrayList<String>();
    ArrayList<String> linePathLemma = new ArrayList<String>();
    ArrayList<String> linePathDeprel = new ArrayList<String>();
    for (FeaturizedToken t : linePathCoNLL) {
      linePathFeat.add(t.getFeat6().get(0));
      linePathLemma.add(t.getLemma());
      linePathDeprel.add(t.getDeprel());
    }
    ArrayList<String> linePathFeatBag = bag(linePathFeat);
    feat = buildString(linePathFeatBag);
    feats.add(feat);
    feat = buildString(linePathLemma);
    feats.add(feat);
    feat = buildString(linePathDeprel);
    feats.add(feat);
    ArrayList<String> dpPathLemma = new ArrayList<String>();
    for (Pair<Integer, Dir> dpP : dpPathArg) {
      dpPathLemma.add(getFeatureObject(dpP.get1()).getLemma());
    }
    // a:p|dpPathArgu.lemma.seq
    feat = buildString(dpPathLemma);
    feats.add(feat);
    // a:p|dpPathArgu.lemma.bag
    feat = buildString(bag(dpPathLemma));
    feats.add(feat);
  }
Пример #3
0
 private void addZhaoUnsupervisedArgFeats(
     FeaturizedToken arg,
     FeaturizedToken argNext,
     FeaturizedToken argLast,
     ArrayList<FeaturizedToken> argChildrenObjectList,
     ArrayList<String> feats) {
   // ------- Argument features (unsupervised) -------
   String feat;
   // a.lm.form
   feat = getFeatureObject(arg.getFarLeftChild()).getForm();
   feats.add(feat);
   // a_1.form
   feat = argLast.getForm();
   feats.add(feat);
   // a.form + a1.form
   feat = arg.getForm() + "_" + argNext.getForm();
   feats.add(feat);
   // a.form + a.children.pos
   ArrayList<String> argChildrenPos = new ArrayList<String>();
   for (FeaturizedToken child : argChildrenObjectList) {
     argChildrenPos.add(child.getPos());
   }
   feat = arg.getForm() + "_" + buildString(argChildrenPos);
   feats.add(feat);
   // a1.pos + a.pos.seq
   feat = argNext.getPos() + "_" + arg.getPos();
   feats.add(feat);
 }
Пример #4
0
 private void getThirdThirdSupArgFeats(
     FeaturizedToken pred,
     FeaturizedToken arg,
     FeaturizedToken predLast,
     FeaturizedToken predNext,
     FeaturizedToken argLast,
     FeaturizedToken argNext,
     FeaturizedToken argParent,
     ArrayList<FeaturizedToken> argChildrenObjectList,
     ArrayList<String> feats) {
   String feat;
   // a.lowSupportVerb.lemma
   feats.add(getFeatureObject(arg.getLowSupportNoun()).getLemma());
   // a.lemma + a.h.form
   feats.add(arg.getLemma() + "_" + argParent.getForm());
   // a.lemma + a.pphead.form
   feats.add(arg.getLemma() + "_" + getFeatureObject(arg.getParent()).getForm());
   // a1.lemma
   feats.add(argNext.getLemma());
   // a.pos + a.children.dprel.bag
   ArrayList<String> argChildrenDeprel = new ArrayList<String>();
   for (FeaturizedToken child : argChildrenObjectList) {
     argChildrenDeprel.add(child.getDeprel());
   }
   ArrayList<String> argChildrenDeprelBag = bag(argChildrenDeprel);
   feat = arg.getPos() + buildString(argChildrenDeprelBag);
   feats.add(feat);
 }
Пример #5
0
 protected ArrayList<FeaturizedToken> getFeatureObjectList(List<Pair<Integer, Dir>> path) {
   ArrayList<FeaturizedToken> pathObjectList = new ArrayList<FeaturizedToken>();
   for (Pair<Integer, Dir> p : path) {
     FeaturizedToken newFeatureObject = getFeatureObject(p.get1());
     // Adding directionality here, given the type of path.
     // These serve as additional features following Bjorkelund.
     newFeatureObject.setDirection(p.get2());
     pathObjectList.add(newFeatureObject);
   }
   return pathObjectList;
 }
Пример #6
0
 private void getFirstThirdSupArgFeats(
     FeaturizedToken pred,
     FeaturizedToken arg,
     FeaturizedToken predLast,
     FeaturizedToken predNext,
     FeaturizedToken argLast,
     FeaturizedToken argNext,
     FeaturizedToken argParent,
     ArrayList<FeaturizedToken> argChildrenObjectList,
     ArrayList<String> feats) {
   String feat;
   List<String> argFeats = arg.getFeat6();
   String a1;
   String a2;
   String a3;
   String a4;
   String a5;
   String a6;
   a1 = argFeats.get(0);
   a2 = argFeats.get(1);
   a3 = argFeats.get(2);
   a4 = argFeats.get(3);
   a5 = argFeats.get(4);
   a6 = argFeats.get(5);
   List<String> argLastFeats = argLast.getFeat6();
   // String last_a1 = argLastFeats.get(0);
   String last_a2 = argLastFeats.get(1);
   List<String> argNextFeats = argNext.getFeat6();
   // String next_a1 = argNextFeats.get(0);
   // String next_a2 = argNextFeats.get(1);
   String next_a3 = argNextFeats.get(2);
   // a.FEAT1 + a.FEAT3 + a.FEAT4 + a.FEAT5 + a.FEAT6
   feat = a1 + "_" + a3 + "_" + a4 + "_" + a5 + "_" + a6;
   feats.add(feat);
   // a_1.FEAT2 + a.FEAT2
   feat = last_a2 + "_" + a2;
   feats.add(feat);
   // a.FEAT3 + a1.FEAT3
   feat = a3 + "_" + next_a3;
   feats.add(feat);
   // a.FEAT3 + a.h.FEAT3
   feat = argParent.getFeat6().get(2);
   feats.add(feat);
   // a.children.FEAT1.noDup
   ArrayList<String> argChildrenFeat1 = getChildrenFeat1(argChildrenObjectList);
   ArrayList<String> argChildrenFeat1NoDup = noDup(argChildrenFeat1);
   feat = buildString(argChildrenFeat1NoDup);
   feats.add(feat);
   // a.children.FEAT3.bag
   ArrayList<String> argChildrenFeat3 = getChildrenFeat3(argChildrenObjectList);
   ArrayList<String> argChildrenFeat3Bag = bag(argChildrenFeat3);
   feat = buildString(argChildrenFeat3Bag);
   feats.add(feat);
 }
Пример #7
0
 // ---------- Bjorkelund et al, CoNLL2009 features. ----------
 public void addBjorkelundSenseFeatures(int idx, ArrayList<String> feats) {
   FeaturizedToken pred = getFeatureObject(idx);
   FeaturizedToken predParent = getFeatureObject(pred.getParent());
   ArrayList<Integer> predChildren = pred.getChildren();
   // PredWord, PredPOS, PredDeprel, PredFeats
   addBjorkelundGenericFeatures(idx, feats, "Pred");
   // predParentWord, predParentPOS, predParentFeats
   addBjorkelundPredParentFeatures(predParent, feats);
   // ChildDepSet, ChildWordSet, ChildPOSSet
   addBjorkelundPredChildFeatures(predChildren, feats);
   // TODO: DepSubCat: the subcategorization frame of the predicate, e.g. OBJ+OPRD+SUB.
 }
Пример #8
0
 private void addBjorkelundDependentFeats(
     FeaturizedToken dependent, ArrayList<String> feats, String dir) {
   String feat;
   // LeftWord, RightWord
   feat = dependent.getForm();
   feats.add(dir + "Word:" + feat);
   // LeftPOS, RightPOS
   feat = dependent.getPos();
   feats.add(dir + "POS:" + feat);
   // LeftFeats, RightFeats
   feat = buildString(dependent.getFeat());
   feats.add(dir + "Feats:" + feat);
 }
Пример #9
0
 private void addBjorkelundPredParentFeatures(
     FeaturizedToken predParent, ArrayList<String> feats) {
   String feat;
   // PredParentWord
   feat = predParent.getForm();
   feats.add("PredParentWord:" + feat);
   // PredParentPOS
   feat = predParent.getPos();
   feats.add("PredParentPos:" + feat);
   // PredParentFeats
   feat = buildString(predParent.getFeat());
   feats.add("PredParentFeats:" + feat);
 }
Пример #10
0
 private void addZhaoUnsupervisedSenseFeats(
     FeaturizedToken p, FeaturizedToken p1, FeaturizedToken pm1, ArrayList<String> feats) {
   String feat;
   // p.form
   feat = p.getForm();
   feats.add(feat);
   // p.form−1 + p.form
   feat = pm1.getForm() + p.getForm();
   feats.add(feat);
   // p.form + p.form1
   feat = p.getForm() + p1.getForm();
   feats.add(feat);
 }
Пример #11
0
 private void addBjorkelundSiblingFeats(
     FeaturizedToken argSibling, ArrayList<String> feats, String dir) {
   String feat;
   // LeftSiblingWord, RightSiblingWord
   feat = argSibling.getForm();
   feats.add(dir + "SiblingWord:" + feat);
   // LeftSiblingPOS, RightSiblingPOS
   feat = argSibling.getPos();
   feats.add(dir + "SiblingPos:" + feat);
   // LeftSiblingFeats, RightSiblingFeats
   feat = buildString(argSibling.getFeat());
   feats.add(dir + "SiblingFeats:" + feat);
 }
Пример #12
0
 private void addZhaoSupervisedSenseFeats(
     FeaturizedToken p, FeaturizedToken p1, ArrayList<String> feats) {
   String feat;
   // p.lm.pos
   feat = getFeatureObject(p.getFarLeftChild()).getPos();
   feats.add(feat);
   // p.rm.pos
   feat = getFeatureObject(p.getFarRightChild()).getPos();
   feats.add(feat);
   // p.lemma
   feat = p.getLemma();
   feats.add(feat);
   // p.lemma + p.lemma1
   feat = p.getLemma() + p1.getLemma();
   feats.add(feat);
   // p.lemma + p.children.dprel.noDup
   ArrayList<String> depRelChildren = new ArrayList<String>();
   ArrayList<FeaturizedToken> pChildren = getFeatureObjectList(p.getChildren());
   for (FeaturizedToken child : pChildren) {
     depRelChildren.add(child.getDeprel());
   }
   feat = buildString(noDup(depRelChildren));
   feats.add(feat);
   // Er...what?  Sense given for sense prediction?
   // p.lemma + p.currentSense
 }
Пример #13
0
 private void addZhaoUnsupervisedPredFeats(
     FeaturizedToken pred,
     FeaturizedToken predLast,
     FeaturizedToken predNext,
     ArrayList<String> feats) {
   // ------- Predicate features (unsupervised) -------
   String feat12;
   // p.pos_1 + p.pos
   feat12 = predLast.getPos() + "_" + pred.getPos();
   feats.add(feat12);
   String feat13;
   // p.pos1
   feat13 = predNext.getPos();
   feats.add(feat13);
 }
Пример #14
0
 // ---------- Meg's Dependency Path features. ----------
 public void addLexicalDependencyPathFeatures(int pidx, int aidx, ArrayList<String> feats) {
   FeaturizedToken predObject = getFeatureObject(pidx);
   FeaturizedToken argObject = getFeatureObject(aidx);
   FeaturizedTokenPair predArgPathObject = getFeatureObject(pidx, aidx);
   List<Pair<Integer, Dir>> dependencyPath = predArgPathObject.getDependencyPath();
   String feat;
   ArrayList<String> depRelPathWord = new ArrayList<String>();
   ArrayList<FeaturizedToken> dependencyPathObjectList = getFeatureObjectList(dependencyPath);
   for (FeaturizedToken t : dependencyPathObjectList) {
     depRelPathWord.add(t.getForm());
   }
   feat = buildString(depRelPathWord);
   feats.add(feat);
   feat = buildString(bag(depRelPathWord));
   feats.add(feat);
 }
Пример #15
0
 private void addBjorkelundGenericFeatures(int idx, ArrayList<String> feats, String type) {
   String feat;
   FeaturizedToken bjorkWord = getFeatureObject(idx);
   // ArgWord, PredWord
   feat = bjorkWord.getForm();
   feats.add(type + ":" + feat);
   // ArgPOS, PredPOS,
   feat = bjorkWord.getPos();
   feats.add(type + ":" + feat);
   // ArgFeats, PredFeats
   feat = buildString(bjorkWord.getFeat());
   feats.add(type + ":" + feat);
   // ArgDeprel, PredDeprel
   feat = bjorkWord.getDeprel();
   feats.add(type + ":" + feat);
 }
Пример #16
0
  public void addZhaoPairFeatures(int pidx, int aidx, ArrayList<String> feats) {
    /* NOTE:  Not sure about they're "Semantic Connection" features.
     * What do they correspond to in CoNLL data?
     * From paper: "This includes semantic head (semhead), left(right) farthest(nearest)
     * semantic child (semlm, semln, semrm, semrn).
     * We say a predicate is its argument's semantic head, and the latter is the former's child.
     * Features related to this type may track the current semantic parsing status."
     * If a semantic predicate is given, then the SRL task is moot... */

    FeaturizedToken pred = getFeatureObject(pidx);
    FeaturizedToken arg = getFeatureObject(aidx);
    FeaturizedTokenPair predArgPair = getFeatureObject(pidx, aidx);
    FeaturizedToken predLast = getFeatureObject(pidx - 1);
    FeaturizedToken predNext = getFeatureObject(pidx + 1);
    // FeatureObject predParent = getFeatureObject(pred.getParent());
    FeaturizedToken argLast = getFeatureObject(aidx - 1);
    FeaturizedToken argNext = getFeatureObject(aidx + 1);
    FeaturizedToken argParent = getFeatureObject(arg.getParent());

    ArrayList<Integer> predChildren = pred.getChildren();
    ArrayList<Integer> argChildren = arg.getChildren();
    List<Pair<Integer, Dir>> dependencyPath = predArgPair.getDependencyPath();

    // Initialize Path structures.
    // List<Pair<Integer, Dir>> dpPathPred = predArgPair.getDpPathPred();
    List<Pair<Integer, Dir>> dpPathArg = predArgPair.getDpPathArg();
    ArrayList<Integer> linePath = predArgPair.getLinePath();

    ArrayList<FeaturizedToken> predChildrenObjectList = getFeatureObjectList(predChildren);
    ArrayList<FeaturizedToken> argChildrenObjectList = getFeatureObjectList(argChildren);
    ArrayList<FeaturizedToken> dependencyPathObjectList = getFeatureObjectList(dependencyPath);
    ArrayList<FeaturizedToken> linePathCoNLL = getFeatureObjectList(linePath);

    // Add the supervised features
    if (prm.withSupervision) {
      addZhaoSupervisedPredFeats(pred, arg, predLast, predNext, predChildrenObjectList, feats);
      addZhaoSupervisedArgFeats(
          pred, arg, predLast, predNext, argLast, argNext, argParent, argChildrenObjectList, feats);
      addZhaoSupervisedCombinedFeats(
          pred, arg, feats, dependencyPathObjectList, linePathCoNLL, dpPathArg);
    }

    // Add the unsupervised features
    addZhaoUnsupervisedPredFeats(pred, predLast, predNext, feats);
    addZhaoUnsupervisedArgFeats(arg, argLast, argNext, argChildrenObjectList, feats);
    addZhaoUnsupervisedCombinedFeats(linePath, linePathCoNLL, feats);
  }
Пример #17
0
 private void addZhaoUnsupervisedCombinedFeats(
     ArrayList<Integer> linePath,
     ArrayList<FeaturizedToken> linePathCoNLL,
     ArrayList<String> feats) {
   // ------- Combined features (unsupervised) -------
   String feat;
   // a:p|linePath.distance
   feat = Integer.toString(linePath.size());
   feats.add(feat);
   // a:p|linePath.form.seq
   ArrayList<String> linePathForm = new ArrayList<String>();
   for (FeaturizedToken t : linePathCoNLL) {
     linePathForm.add(t.getForm());
   }
   feat = buildString(linePathForm);
   feats.add(feat);
 }
Пример #18
0
  public void addBjorkelundPairFeatures(int pidx, int aidx, ArrayList<String> feats) {
    /* From Bjorkelund et al, CoNLL 2009.
     * Prefixes:
     * Pred:  the predicate
     * PredParent:  the parent of the predicate
     * Arg:  the argument
     * Left:  the leftmost dependent of the argument
     * Right:   the rightmost dependent of the argument
     * LeftSibling:  the left sibling of the argument
     * RightSibling:  the right sibling of the argument
     */
    String feat;
    FeaturizedToken pred = getFeatureObject(pidx);
    FeaturizedToken arg = getFeatureObject(aidx);
    FeaturizedTokenPair predArgPair = getFeatureObject(pidx, aidx);
    FeaturizedToken predParent = getFeatureObject(pred.getParent());
    ArrayList<Integer> predChildren = pred.getChildren();
    FeaturizedToken argLeftSibling = getFeatureObject(arg.getNearLeftSibling());
    FeaturizedToken argRightSibling = getFeatureObject(arg.getNearRightSibling());
    FeaturizedToken argLeftDependent = getFeatureObject(arg.getFarLeftChild());
    FeaturizedToken argRightDependent = getFeatureObject(arg.getFarRightChild());

    // PredWord, PredPOS, PredFeats, PredDeprel
    addBjorkelundGenericFeatures(pidx, feats, "Pred");
    // ArgWord, ArgPOS, ArgFeats, ArgDeprel
    addBjorkelundGenericFeatures(aidx, feats, "Arg");
    // PredParentWord, PredParentPOS, PredParentFeats
    addBjorkelundPredParentFeatures(predParent, feats);
    // ChildDepSet, ChildWordSet, ChildPOSSet
    addBjorkelundPredChildFeatures(predChildren, feats);
    // LeftWord, LeftPOS, LeftFeats
    addBjorkelundDependentFeats(argLeftDependent, feats, "Left");
    // RightWord, RightPOS, RightFeats
    addBjorkelundDependentFeats(argRightDependent, feats, "Right");
    // LeftSiblingWord, LeftSiblingPOS, LeftSiblingFeats
    addBjorkelundSiblingFeats(argLeftSibling, feats, "Left");
    // RightSiblingWord, RightSiblingPOS, RightSiblingFeats
    addBjorkelundSiblingFeats(argRightSibling, feats, "Right");
    // DeprelPath, POSPath
    addBjorkelundPathFeats(predArgPair, feats);
    // Position
    addBjorkelundPositionFeat(pidx, aidx, feats);

    // PredLemma
    feat = pred.getLemma();
    feats.add("PredLemma:" + feat);
    // TODO: Sense: the value of the Pred column, e.g. plan.01.
    // TODO: DepSubCat: the subcategorization frame of the predicate, e.g. OBJ+OPRD+SUB.
  }
Пример #19
0
 private void addBjorkelundPathFeats(FeaturizedTokenPair predArgPair, ArrayList<String> feats) {
   String feat;
   List<Pair<Integer, Dir>> dependencyPath = predArgPair.getDependencyPath();
   // DeprelPath: the path from predicate to argument concatenating dependency labels with the
   // direction of the edge, e.g. OBJ↑OPRD↓SUB↓.
   ArrayList<String> depRelPath = new ArrayList<String>();
   // POSPath: same as DeprelPath, but dependency labels are exchanged for POS tags, e.g.
   // NN↑NNS↓NNP↓.
   ArrayList<String> posPath = new ArrayList<String>();
   ArrayList<FeaturizedToken> dependencyPathObjectList = getFeatureObjectList(dependencyPath);
   for (int i = 0; i < dependencyPathObjectList.size(); i++) {
     FeaturizedToken t = dependencyPathObjectList.get(i);
     depRelPath.add(t.getDeprel() + ":" + dependencyPath.get(i).get2());
     posPath.add(t.getPos() + ":" + dependencyPath.get(i).get2());
   }
   feat = buildString(depRelPath);
   feats.add("DeprelPath:" + feat);
   feat = buildString(posPath);
   feats.add("PosPath:" + feat);
 }
Пример #20
0
  // ---------- Naradowsky et al.'s 2011 ACL features. ----------
  public void addNaradowskySenseFeatures(int idx, ArrayList<String> feats) {
    String word = sent.getWord(idx);
    String wordForm = decideForm(word, idx);
    String wordPos = sent.getPosTag(idx);
    String wordLemma = sent.getLemma(idx);

    feats.add("head_" + wordForm + "_word");
    feats.add("head_" + wordLemma + "_lemma");
    feats.add("head_" + wordPos + "_tag");
    feats.add("head_" + wordForm + "_" + wordPos + "_wordtag");
    String cap;
    if (FeaturizedToken.capitalized(wordForm)) {
      cap = "UC";
    } else {
      cap = "LC";
    }
    feats.add("head_" + cap + "_caps");
  }
Пример #21
0
 private void getSecondThirdSupArgFeats(
     FeaturizedToken pred,
     FeaturizedToken arg,
     FeaturizedToken predLast,
     FeaturizedToken predNext,
     FeaturizedToken argLast,
     FeaturizedToken argNext,
     FeaturizedToken argParent,
     ArrayList<FeaturizedToken> argChildrenObjectList,
     ArrayList<String> feats) {
   FeaturizedToken argLm = getFeatureObject(arg.getFarLeftChild());
   FeaturizedToken argRm = getFeatureObject(arg.getFarRightChild());
   FeaturizedToken argRn = getFeatureObject(arg.getNearRightChild());
   // FeatureObject argLn = getFeatureObject(arg.getNearLeftChild());
   String feat;
   // a.h.lemma
   feats.add(argParent.getLemma());
   // a.lm.dprel + a.form
   feats.add(argLm.getDeprel() + "_" + arg.getForm());
   // a.lm_1.lemma
   feats.add(getFeatureObject(argLast.getFarLeftChild()).getLemma());
   // a.lmn.pos (n=0,1)
   feats.add(argLm.getPos());
   feats.add(getFeatureObject(argNext.getFarLeftChild()).getPos());
   // a.noFarChildren.pos.bag + a.rm.form
   ArrayList<Integer> noFarChildren = arg.getNoFarChildren();
   ArrayList<String> noFarChildrenPos = new ArrayList<String>();
   for (Integer i : noFarChildren) {
     noFarChildrenPos.add(getFeatureObject(i).getPos());
   }
   ArrayList<String> argNoFarChildrenBag = bag(noFarChildrenPos);
   feat = buildString(argNoFarChildrenBag) + argRm.getForm();
   feats.add(feat);
   // a.pphead.lemma
   feats.add(getFeatureObject(arg.getParent()).getLemma());
   // a.rm.dprel + a.form
   feats.add(argRm.getDeprel() + "_" + arg.getForm());
   // a.rm_1.form
   feats.add(getFeatureObject(argLast.getFarRightChild()).getForm());
   // a.rm.lemma
   feats.add(argRm.getLemma());
   // a.rn.dprel + a.form
   feats.add(argRn.getDeprel() + "_" + arg.getForm());
 }
Пример #22
0
  private void addZhaoSupervisedPredFeats(
      FeaturizedToken pred,
      FeaturizedToken arg,
      FeaturizedToken predLast,
      FeaturizedToken predNext,
      ArrayList<FeaturizedToken> predChildrenObjectList,
      ArrayList<String> feats) {
    // ------- Predicate features (supervised) -------

    // NOTE: We cannot include these features in our model since they would have
    // to use the gold predicate sense.
    //
    //        // p.currentSense + p.lemma
    //        feats.add(pred.getSense() + "_" + pred.getLemma());
    //        // p.currentSense + p.pos
    //        feats.add(pred.getSense() + "_" + pred.getPos());
    //        // p.currentSense + a.pos
    //        feats.add(pred.getSense() + "_" + arg.getPos());

    // p_1.FEAT1
    feats.add(predLast.getFeat6().get(0));
    // p.FEAT2
    feats.add(pred.getFeat6().get(1));
    // p1.FEAT3
    feats.add(predNext.getFeat6().get(2));
    // NOTE:  This is supposed to be p.semrm.semdprel  What is this?
    // I'm not sure.  Here's just a guess.
    feats.add(getFeatureObject(pred.getFarRightChild()).getDeprel());
    // p.lm.dprel
    feats.add(getFeatureObject(pred.getFarLeftChild()).getDeprel());
    // p.form + p.children.dprel.bag
    ArrayList<String> predChildrenDeprel = new ArrayList<String>();
    for (FeaturizedToken child : predChildrenObjectList) {
      predChildrenDeprel.add(child.getDeprel());
    }
    String bagDepPredChildren = buildString(bag(predChildrenDeprel));
    feats.add(pred.getForm() + "_" + bagDepPredChildren);
    // p.lemma_n (n = -1, 0)
    feats.add(predLast.getLemma());
    feats.add(pred.getLemma());
    // p.lemma + p.lemma1
    feats.add(pred.getLemma() + "_" + predNext.getLemma());
    // p.pos + p.children.dprel.bag
    feats.add(pred.getPos() + "_" + bagDepPredChildren);
  }