Java OriginalTextAnnotation类代码示例

import edu.stanford.nlp.ling.CoreAnnotations.OriginalTextAnnotation; //导入依赖的package包/类
/**
 *
 */
public TokenizedCoreLabelWrapper(final CoreLabel cl) {
  this.value = cl.get(ValueAnnotation.class);
  this.text = cl.get(TextAnnotation.class);
  LOGGER.trace("Wrapping token text: {}", this.text);
  this.originalText = cl.get(OriginalTextAnnotation.class);
  this.before = cl.get(BeforeAnnotation.class);
  this.after = cl.get(AfterAnnotation.class);

  this.startSentenceOffset = cl.get(CharacterOffsetBeginAnnotation.class);
  this.endSentenceOffset = cl.get(CharacterOffsetEndAnnotation.class);

  this.startOffset = Optional.ofNullable(cl.get(TokenBeginAnnotation.class));
  this.endOffset = Optional.ofNullable(cl.get(TokenEndAnnotation.class));
  LOGGER.trace("TokenBegin: {}", this.startOffset);
  LOGGER.trace("TokenEnd: {}", this.endOffset);

  this.idx = cl.get(IndexAnnotation.class);
  this.sentenceIdx = cl.get(SentenceIndexAnnotation.class);
  LOGGER.trace("Got sentence idx: {}", this.sentenceIdx);
}
 

import edu.stanford.nlp.ling.CoreAnnotations.OriginalTextAnnotation; //导入依赖的package包/类
/** Make the next token.
 *
 *  @param txt What the token should be
 *  @param originalText The original String that got transformed into txt
 */
private Object getNext(String txt, String originalText) {
  if (tokenFactory == null) {
    throw new RuntimeException(this.getClass().getName() + ": Token factory is null.");
  }
  if (invertible) {
    //String str = prevWordAfter.toString();
    //prevWordAfter.setLength(0);
    CoreLabel word = (CoreLabel) tokenFactory.makeToken(txt, yychar, yylength());
    word.set(OriginalTextAnnotation.class, originalText);
    //word.set(BeforeAnnotation.class, str);
    //prevWord.set(AfterAnnotation.class, str);
    //prevWord = word;
    return word;
  } else {
    return tokenFactory.makeToken(txt, yychar, yylength());
  }
}
 

import edu.stanford.nlp.ling.CoreAnnotations.OriginalTextAnnotation; //导入依赖的package包/类
public Mention buildMention(Annotation annotation, int sentId,
		int startToken, int endToken) {
	CoreMap sentAnn = annotation.get(SentencesAnnotation.class).get(sentId);
	List<CoreLabel> tokens = sentAnn.get(TokensAnnotation.class);
	// create a Mention object
	Mention.Builder m = Mention.newBuilder();
	m.setStart(startToken);
	m.setEnd(endToken);
	for (int i = 0; i < tokens.size(); i++) {
		m.addTokens(tokens.get(i).get(OriginalTextAnnotation.class));
		m.addPosTags(tokens.get(i).get(PartOfSpeechAnnotation.class));
	}
	m.setEntityName("");
	m.setFileid("on-the-fly");
	m.setSentid(sentId);

	// dependency
	String depStr = StanfordDependencyResolver.getString(sentAnn);
	if (depStr != null) {
		for (String d : depStr.split("\t")) {
			Matcher match = Preprocessing.depPattern.matcher(d);
			if (match.find()) {
				m.addDeps(Dependency.newBuilder().setType(match.group(1))
						.setGov(Integer.parseInt(match.group(3)) - 1)
						.setDep(Integer.parseInt(match.group(5)) - 1)
						.build());
			} else {

			}
		}
	}
	return m.build();
}
 

import edu.stanford.nlp.ling.CoreAnnotations.OriginalTextAnnotation; //导入依赖的package包/类
public Mention buildMention(Annotation annotation, int sentId, int startToken, int endToken) {
	CoreMap sentAnn = annotation.get(SentencesAnnotation.class).get(sentId);
	List<CoreLabel> tokens = sentAnn.get(TokensAnnotation.class);
	// create a Mention object
	Mention.Builder m = Mention.newBuilder();
	m.setStart(startToken);
	m.setEnd(endToken);
	for (int i = 0; i < tokens.size(); i++) {
		m.addTokens(tokens.get(i).get(OriginalTextAnnotation.class));
		m.addPosTags(tokens.get(i).get(PartOfSpeechAnnotation.class));
	}
	m.setEntityName("");
	m.setFileid("on-the-fly");
	m.setSentid(sentId);

	// dependency
	String depStr = StanfordDependencyResolver.getString(sentAnn);
	if (depStr != null) {
		for (String d : depStr.split("\t")) {
			Matcher match = Preprocessing.depPattern.matcher(d);
			if (match.find()) {
				m.addDeps(
						Dependency.newBuilder().setType(match.group(1)).setGov(Integer.parseInt(match.group(3)) - 1)
								.setDep(Integer.parseInt(match.group(5)) - 1).build());
			} else {

			}
		}
	}
	return m.build();
}
 

import edu.stanford.nlp.ling.CoreAnnotations.OriginalTextAnnotation; //导入依赖的package包/类
@Override
public SymmetricalWordAlignment process(Sequence<IString> inputSequence) {
  List<CoreLabel> labeledTokens = ProcessorTools.toCharacterSequence(inputSequence);
  labeledTokens = classifier.classify(labeledTokens);
  List<CoreLabel> outputTokens = ProcessorTools.toPostProcessedSequence(labeledTokens);
  List<String> outputStrings = new ArrayList<>();
  for (CoreLabel label : outputTokens) {
    outputStrings.add(label.word());
  }
  Sequence<IString> outputSequence = IStrings.toIStringSequence(outputStrings);
  SymmetricalWordAlignment alignment = new SymmetricalWordAlignment(inputSequence, outputSequence);
  
  // Reconstruct the alignment by iterating over the target
  for (int outputIndex = 0, inputIndex = 0, outputSize = outputTokens.size(), inputSize = inputSequence.size(); 
      outputIndex < outputSize && inputIndex < inputSize; ++outputIndex) {
    String outputToken = outputTokens.get(outputIndex).get(OriginalTextAnnotation.class);
    String inputCandidate = inputSequence.get(inputIndex).toString();
    if (outputToken.equals(inputCandidate)) {
      // Unigram alignment
      alignment.addAlign(inputIndex, outputIndex);
      ++inputIndex;
      
    } else {
      // one-to-many alignment (output-to-input)
      String[] originalTokens = outputToken.split("\\s+");
      int newInputIndex = findSubsequenceStart(originalTokens, inputSequence, inputIndex);
      if (newInputIndex < 0) {
        System.err.printf("Unable to find |%s| in |%s|%n", outputToken, inputSequence.toString());
      } else {
        inputIndex = newInputIndex;
        for (int i = 0; i < originalTokens.length; ++i) {
          alignment.addAlign(inputIndex, outputIndex);
          ++inputIndex;
        }
      }
    }
  }
  return alignment;
}
 

import edu.stanford.nlp.ling.CoreAnnotations.OriginalTextAnnotation; //导入依赖的package包/类
/**
 * Make the next token.
 * 
 * @param txt
 *          What the token should be
 * @param current
 *          The original String that got transformed into txt
 */
private Object getNext(String txt, String current) {
  if (invertible) {
    CoreLabel word = (CoreLabel) tokenFactory.makeToken(txt, yychar, yylength());
    word.set(OriginalTextAnnotation.class, current);
    word.set(BeforeAnnotation.class, prevWord.getString(AfterAnnotation.class));
    prevWord = word;
    return word;
  } else {
    return tokenFactory.makeToken(txt, yychar, yylength());
  }
}
 

import edu.stanford.nlp.ling.CoreAnnotations.OriginalTextAnnotation; //导入依赖的package包/类
public NGram(String[] originalForms, String[] lemmas) {
  for (int i = 0; i < originalForms.length; ++i) {
    CoreLabel cl = new CoreLabel();
    cl.set(TextAnnotation.class, originalForms[i]);
    cl.set(OriginalTextAnnotation.class, originalForms[i]);
    cl.set(LemmaAnnotation.class, lemmas[i]);
    cl.set(PartOfSpeechAnnotation.class, "dummy");
    add(cl);
  }
  setNormalizedForm();
}
 

import edu.stanford.nlp.ling.CoreAnnotations.OriginalTextAnnotation; //导入依赖的package包/类
/** Make the next token.
 *  @param txt What the token should be
 *  @param originalText The original String that got transformed into txt
 */
private Object getNext(String txt, String originalText) {
  if (invertible) {
    String str = prevWordAfter.toString();
    prevWordAfter.setLength(0);
    CoreLabel word = (CoreLabel) tokenFactory.makeToken(txt, yychar, yylength());
    word.set(OriginalTextAnnotation.class, originalText);
    word.set(BeforeAnnotation.class, str);
    prevWord.set(AfterAnnotation.class, str);
    prevWord = word;
    return word;
  } else {
    return tokenFactory.makeToken(txt, yychar, yylength());
 }
}
 

import edu.stanford.nlp.ling.CoreAnnotations.OriginalTextAnnotation; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
public void setOriginalText(String originalText) {
  set(CoreAnnotations.OriginalTextAnnotation.class, originalText);
}
 

import edu.stanford.nlp.ling.CoreAnnotations.OriginalTextAnnotation; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
public String originalText() {
  return getString(OriginalTextAnnotation.class);
}