Java PaddedList类代码示例

import edu.stanford.nlp.util.PaddedList; //导入依赖的package包/类
/**
 * Extracts all the features from the input data at a certain index.
 *
 * @param cInfo The complete data set as a List of WordInfo
 * @param loc  The index at which to extract features.
 */
public Collection<String> getCliqueFeatures(PaddedList<IN> cInfo, int loc, Clique clique) {
  Collection<String> features = new HashSet<>();

  if (clique == cliqueC) {
    addAllInterningAndSuffixing(features, featuresC(cInfo, loc), "C");
  } else if (clique == cliqueCpC) {
    addAllInterningAndSuffixing(features, featuresCpC(cInfo, loc), "CpC");
  } 
  //    else if (clique == cliqueCp2C) {
  //      addAllInterningAndSuffixing(features, featuresCp2C(cInfo, loc), "Cp2C");
  //    } else if (clique == cliqueCp3C) {
  //      addAllInterningAndSuffixing(features, featuresCp3C(cInfo, loc), "Cp3C");
  //    }

  return features;
}
 

import edu.stanford.nlp.util.PaddedList; //导入依赖的package包/类
private Collection<String> featuresCpC(PaddedList<IN> cInfo, int loc) {
  Collection<String> features = new ArrayList<>();

  // Caused overfitting.
  //    CoreLabel c = cInfo.get(loc);
  //    CoreLabel p = cInfo.get(loc - 1);
  //    CoreLabel n = cInfo.get(loc + 1);
  //    
  //    String charc = c.get(CoreAnnotations.CharAnnotation.class);
  //    String charp = p.get(CoreAnnotations.CharAnnotation.class);
  //    String charn = n.get(CoreAnnotations.CharAnnotation.class);
  //
  //    addCharacterClassFeatures(features, charp, "-p");
  //    addCharacterClassFeatures(features, charn, "-n");
  //    addCharacterClassFeatures(features, charc, "-c");

  // Indicator transition feature
  features.add("cliqueCpC");

  return features;
}
 

import edu.stanford.nlp.util.PaddedList; //导入依赖的package包/类
private void distSimAnnotate(PaddedList<IN> info) {
  for (CoreLabel fl : info) {
    if (fl.has(CoreAnnotations.DistSimAnnotation.class)) { return; }
    String word = getWord(fl);
    if ( ! flags.casedDistSim) {
      word = word.toLowerCase();
    }
    if (flags.numberEquivalenceDistSim) {
      word = WordShapeClassifier.wordShape(word, WordShapeClassifier.WORDSHAPEDIGITS);
    }
    String distSim = lexicon.get(word);
    if (distSim == null) {
      distSim = flags.unknownWordDistSimClass;
    }
    fl.set(CoreAnnotations.DistSimAnnotation.class, distSim);
  }
}
 

import edu.stanford.nlp.util.PaddedList; //导入依赖的package包/类
@Override
public CRFDatum<List<String>, CRFLabel> makeDatum(List<IN> info, int loc, FeatureFactory<IN> featureFactory) {

  pad.set(CoreAnnotations.AnswerAnnotation.class, flags.backgroundSymbol);
  PaddedList<IN> pInfo = new PaddedList<IN>(info, pad);

  List<List<String>> features = new ArrayList<List<String>>();
  Collection<Clique> done = Generics.newHashSet();
  for (int i = 0; i < windowSize; i++) {
    List<String> featuresC = new ArrayList<String>();
    List<Clique> windowCliques = featureFactory.getCliques(i, 0);
    windowCliques.removeAll(done);
    done.addAll(windowCliques);
    for (Clique c : windowCliques) {
      featuresC.addAll(featureFactory.getCliqueFeatures(pInfo, loc, c));
      if(testTime && i==0)
        // this feature is only present at test time and only appears
        // in cliques of size 1 (i.e., cliques with window=0)
        featuresC.add(BIAS);
    }
    features.add(featuresC);
  }

  int[] labels = new int[windowSize];
  for (int i = 0; i < windowSize; i++) {
    String answer = pInfo.get(loc + i - windowSize + 1).get(CoreAnnotations.AnswerAnnotation.class);
    labels[i] = classIndex.indexOf(answer);
  }

  return new CRFDatum<List<String>, CRFLabel>(features, new CRFLabel(labels), null);
}
 

import edu.stanford.nlp.util.PaddedList; //导入依赖的package包/类
private Collection<String> occurrencePatterns(PaddedList<IN> cInfo, int loc) {
  // features on last Cap
  String word = getWord(cInfo.get(loc));
  String nWord = getWord(cInfo.get(loc + reverse(1)));
  CoreLabel p = cInfo.get(loc - reverse(1));
  String pWord = getWord(p);
  // System.err.println(word+" "+nWord);
  if (!(isNameCase(word) && noUpperCase(nWord) && hasLetter(nWord) && hasLetter(pWord) && p != cInfo.getPad())) {
    return Collections.singletonList("NO-OCCURRENCE-PATTERN");
  }
  // System.err.println("LOOKING");
  Set<String> l = Generics.newHashSet();
  if (cInfo.get(loc - reverse(1)).getString(CoreAnnotations.PartOfSpeechAnnotation.class) != null && isNameCase(pWord) && cInfo.get(loc - reverse(1)).getString(CoreAnnotations.PartOfSpeechAnnotation.class).equals("NNP")) {
    for (int jump = 3; jump < 150; jump++) {
      if (getWord(cInfo.get(loc + reverse(jump))).equals(word)) {
        if (getWord(cInfo.get(loc + reverse(jump - 1))).equals(pWord)) {
          l.add("XY-NEXT-OCCURRENCE-XY");
        } else {
          l.add("XY-NEXT-OCCURRENCE-Y");
        }
      }
    }
    for (int jump = -3; jump > -150; jump--) {
      if (getWord(cInfo.get(loc + reverse(jump))).equals(word)) {
        if (getWord(cInfo.get(loc + reverse(jump - 1))).equals(pWord)) {
          l.add("XY-PREV-OCCURRENCE-XY");
        } else {
          l.add("XY-PREV-OCCURRENCE-Y");
        }
      }
    }
  } else {
    for (int jump = 3; jump < 150; jump++) {
      if (getWord(cInfo.get(loc + reverse(jump))).equals(word)) {
        if (isNameCase(getWord(cInfo.get(loc + reverse(jump - 1)))) && (cInfo.get(loc + reverse(jump - 1))).getString(CoreAnnotations.PartOfSpeechAnnotation.class).equals("NNP")) {
          l.add("X-NEXT-OCCURRENCE-YX");
          // System.err.println(getWord(cInfo.get(loc+reverse(jump-1))));
        } else if (isNameCase(getWord(cInfo.get(loc + reverse(jump + 1)))) && (cInfo.get(loc + reverse(jump + 1))).getString(CoreAnnotations.PartOfSpeechAnnotation.class).equals("NNP")) {
          // System.err.println(getWord(cInfo.get(loc+reverse(jump+1))));
          l.add("X-NEXT-OCCURRENCE-XY");
        } else {
          l.add("X-NEXT-OCCURRENCE-X");
        }
      }
    }
    for (int jump = -3; jump > -150; jump--) {
      if (getWord(cInfo.get(loc + jump)) != null && getWord(cInfo.get(loc + jump)).equals(word)) {
        if (isNameCase(getWord(cInfo.get(loc + reverse(jump + 1)))) && (cInfo.get(loc + reverse(jump + 1))).getString(CoreAnnotations.PartOfSpeechAnnotation.class).equals("NNP")) {
          l.add("X-PREV-OCCURRENCE-YX");
          // System.err.println(getWord(cInfo.get(loc+reverse(jump+1))));
        } else if (isNameCase(getWord(cInfo.get(loc + reverse(jump - 1)))) && cInfo.get(loc + reverse(jump - 1)).getString(CoreAnnotations.PartOfSpeechAnnotation.class).equals("NNP")) {
          l.add("X-PREV-OCCURRENCE-XY");
          // System.err.println(getWord(cInfo.get(loc+reverse(jump-1))));
        } else {
          l.add("X-PREV-OCCURRENCE-X");
        }
      }
    }
  }
  /*
  if (!l.isEmpty()) {
    System.err.println(pWord+" "+word+" "+nWord+" "+l);
  }
  */
  return l;
}
 

import edu.stanford.nlp.util.PaddedList; //导入依赖的package包/类
/**
 * This method returns a {@link Collection} of the features
 * calculated for the word at the specified position in info (the list of
 * words) for the specified {@link Clique}.
 * It should return the actual features, <b>NOT</b> wrapped in a
 * {@link Features} object, as the wrapping
 * will be done automatically.
 * Because it takes a {@link PaddedList} you don't
 * need to worry about indices which are outside of the list.
 *
 * @param info A PaddedList of the feature-value pairs
 * @param position The current position to extract features at
 * @param clique The particular clique for which to extract features. It
 *     should be a member of the knownCliques list.
 * @return A {@link Collection} of the features
 *     calculated for the word at the specified position in info.
 */
public abstract Collection<String> getCliqueFeatures(PaddedList<IN> info, int position, Clique clique);