Java TregexPattern.compile方法代码示例

import edu.stanford.nlp.trees.tregex.TregexPattern; //导入方法依赖的package包/类
@Override
protected void compile() {
  super.compile();
  by1 = TregexPattern
      .compile("VP <-1 (PP <<, /by|via|through/ <2 (S <1 (VP <1 VBG=tr)))");
  
  by2 = TregexPattern
      .compile("VP <-1 (PP <<, /by|via|through/ <2 (S <1 ADVP <2 (VP <1 VBG=tr)))");
  
  by3 = TregexPattern
          .compile("VP <-1 (PP <<, /by|via|through/ <2 (S <1 (VP <1 ADVP <2 VBG=tr)))");
  
  by4 = TregexPattern
      .compile("VP <-1 (NP <- (PP <<, /by|via|through/ <2 (NP <+(NP) (NN=tr <, /ing$/))))");
  
  by5 = TregexPattern.compile("VP <-1  (PP <<, /by|via|through/ <2 (NP <+(NP) (NN=tr <, /ing$/)))");
  
  
  by6 = TregexPattern
          .compile("VP <-1 (PP <1 ADVP <2 (IN <<, /by|via|through/) <3 (S <1 (VP <1 VBG=tr)))");
}
 

import edu.stanford.nlp.trees.tregex.TregexPattern; //导入方法依赖的package包/类
@Override
protected void compile() {
  super.compile();
  //vadj = TregexPattern.compile("VP <1 /VB.*/ <2 (ADJP=tr)");
  
  // a is JJ
  vadjs = new ArrayList<TregexPattern>();
  vadj = TregexPattern.compile("VP <1 AUX < ADJP|VP=tr");
  vadjs.add(vadj);
  //vadj = TregexPattern.compile("VP <1 AUX < ADVP < ADJP|VP=tr");
  //vadjs.add(vadj);
  vadj = TregexPattern.compile("VP=tr <1 VBN");
  vadjs.add(vadj);
  vadj = TregexPattern.compile("VBN|JJ=tr");
  vadjs.add(vadj);
}
 

import edu.stanford.nlp.trees.tregex.TregexPattern; //导入方法依赖的package包/类
protected void extractNPorPRP(CoreMap s, List<Mention> mentions, Set<IntPair> mentionSpanSet, Set<IntPair> namedEntitySpanSet) {
  List<CoreLabel> sent = s.get(CoreAnnotations.TokensAnnotation.class);
  Tree tree = s.get(TreeCoreAnnotations.TreeAnnotation.class);
  tree.indexLeaves();
  SemanticGraph dependency = s.get(SemanticGraphCoreAnnotations.CollapsedDependenciesAnnotation.class);

  final String mentionPattern = "/^(?:NP|PRP)/";
  TregexPattern tgrepPattern = TregexPattern.compile(mentionPattern);
  TregexMatcher matcher = tgrepPattern.matcher(tree);
  while (matcher.find()) {
    Tree t = matcher.getMatch();
    List<Tree> mLeaves = t.getLeaves();
    int beginIdx = ((CoreLabel)mLeaves.get(0).label()).get(CoreAnnotations.IndexAnnotation.class)-1;
    int endIdx = ((CoreLabel)mLeaves.get(mLeaves.size()-1).label()).get(CoreAnnotations.IndexAnnotation.class);
    IntPair mSpan = new IntPair(beginIdx, endIdx);
    if(!mentionSpanSet.contains(mSpan) && !insideNE(mSpan, namedEntitySpanSet)) {
      int mentionID = assignIds? ++maxID:-1;
      Mention m = new Mention(mentionID, beginIdx, endIdx, dependency, new ArrayList<CoreLabel>(sent.subList(beginIdx, endIdx)), t);
      mentions.add(m);
      mentionSpanSet.add(mSpan);
    }
  }
}
 

import edu.stanford.nlp.trees.tregex.TregexPattern; //导入方法依赖的package包/类
/** Find syntactic pattern in a sentence by tregex */
private void findTreePattern(Tree tree, String pattern, Set<Pair<Integer, Integer>> foundPairs) {
  try {
    TregexPattern tgrepPattern = TregexPattern.compile(pattern);
    TregexMatcher m = tgrepPattern.matcher(tree);
    while (m.find()) {
      Tree t = m.getMatch();
      Tree np1 = m.getNode("m1");
      Tree np2 = m.getNode("m2");
      Tree np3 = null;
      if(pattern.contains("m3")) np3 = m.getNode("m3");
      addFoundPair(np1, np2, t, foundPairs);
      if(np3!=null) addFoundPair(np2, np3, t, foundPairs);
    }
  } catch (Exception e) {
    // shouldn't happen....
    throw new RuntimeException(e);
  }
}
 

import edu.stanford.nlp.trees.tregex.TregexPattern; //导入方法依赖的package包/类
public ArabicTreeNormalizer(boolean retainNPTmp, boolean markPRDverb, boolean changeNoLabels,
    boolean retainNPSbj, boolean retainPPClr) {
  super(new ArabicTreebankLanguagePack());
  this.retainNPTmp = retainNPTmp;
  this.retainNPSbj = retainNPSbj;
  this.markPRDverb = markPRDverb;
  this.changeNoLabels = changeNoLabels;
  this.retainPPClr = retainPPClr;

  rootLabel = tlp.startSymbol();

  prdVerbPattern  = TregexPattern.compile("/^V[^P]/ > VP $ /-PRD$/=prd");

  prdPattern = Pattern.compile("^[A-Z]+-PRD");

  //Marks NP subjects that *do not* occur in verb-initial clauses
  npSbjPattern = TregexPattern.compile("/^NP-SBJ/ !> @VP");

  emptyFilter = new ArabicEmptyFilter();
}
 

import edu.stanford.nlp.trees.tregex.TregexPattern; //导入方法依赖的package包/类
public List<String> evaluateTregexPattern(String parseTree, String tregexPattern)
{
    List<String> foundMatches = new ArrayList<String>();

    TregexPattern pattern = TregexPattern.compile(tregexPattern);
    TregexMatcher matches = pattern.matcher(Tree.valueOf(parseTree));
    Set<String> nodes = matches.getNodeNames();
    while (matches.find())
    {
        foundMatches.add(matches.getMatch().pennString());
        for (String node : nodes)
        {
            foundMatches.add(matches.getNode(node).pennString());
        }
    }

    return foundMatches;
}
 

import edu.stanford.nlp.trees.tregex.TregexPattern; //导入方法依赖的package包/类
public ArabicTreeNormalizer(boolean retainNPTmp, boolean markPRDverb, boolean changeNoLabels,
    boolean retainNPSbj, boolean retainPPClr) {
  super(new ArabicTreebankLanguagePack());
  this.retainNPTmp = retainNPTmp;
  this.retainNPSbj = retainNPSbj;
  this.markPRDverb = markPRDverb;
  this.changeNoLabels = changeNoLabels;
  this.retainPPClr = retainPPClr;

  rootLabel = tlp.startSymbol();

  prdVerbPattern  = TregexPattern.compile("/^V[^P]/ > VP $ /-PRD$/=prd");
  
  prdPattern = Pattern.compile("^[A-Z]+-PRD");
  
  //Marks NP subjects that *do not* occur in verb-initial clauses
  npSbjPattern = TregexPattern.compile("/^NP-SBJ/ !> @VP");
  
  emptyFilter = new ArabicEmptyFilter();
}
 

import edu.stanford.nlp.trees.tregex.TregexPattern; //导入方法依赖的package包/类
public Optional<String> findHeadVerb(Tree parseTree) {
	TregexPattern pattern = TregexPattern.compile("ROOT <<: (__ < (VP=vp [ <+(VP) (VP=lowestvp !< VP) | ==(VP=lowestvp !< VP) ]))");
	TregexMatcher matcher = pattern.matcher(parseTree);
	while (matcher.findAt(parseTree)) {
		Tree lowestvp = matcher.getNode("lowestvp");

		return Optional.of(ParseTreeExtractionUtils.getContainingWords(lowestvp).get(0).word());
	}
	return Optional.empty();
}
 

import edu.stanford.nlp.trees.tregex.TregexPattern; //导入方法依赖的package包/类
/**
 * Extract chunks. 
 * 
 * @param tree
 * @return
 */
static int[] getChunkVector(Tree tree) {
  String[] iobVector = new String[tree.yield().size()];
  Arrays.fill(iobVector, "O");
  
  // NOTE: The order in which these patterns are applied is important.
  
  // Base XPs
  TregexPattern baseXPPattern = TregexPattern.compile("__ < (__ < (__ !< __)) !< (__ < (__ < __))");
  
  // Non-recursive NPs
  TregexPattern NPPattern = TregexPattern.compile("@NP < (__ $ __) !<< (@NP < (__ $ __)) !<< @PP");

  // Non-recursive PPs
  TregexPattern PPattern = TregexPattern.compile("@PP !<< @PP");
  
  TregexMatcher tregexMatcher = baseXPPattern.matcher(tree);
  CoreNLPToJSON.fillVectorWithYield(iobVector, tregexMatcher);
  
  tregexMatcher = NPPattern.matcher(tree);
  CoreNLPToJSON.fillVectorWithYield(iobVector, tregexMatcher);
  
  tregexMatcher = PPattern.matcher(tree);
  CoreNLPToJSON.fillVectorWithYield(iobVector, tregexMatcher);
  
  int[] indexVector = CoreNLPToJSON.iobToIndices(iobVector);
  return indexVector;
}
 

import edu.stanford.nlp.trees.tregex.TregexPattern; //导入方法依赖的package包/类
@Override
protected void compile() {
  super.compile();
  
  // trigger extraction is done in tree regular expression
  // Q: how to leverage work between tregex and procedure?
  through1 = TregexPattern
      .compile("VP <1 /VB.*/ <-1 (PP <<, /^through|via|by$/ <2 (NP <1 (NP << (NN=tr < /ion/)) ! << /PRP/ ))");
  through2 = TregexPattern
      .compile("VP <1 /VB.*/ <-1 (PP <<, /^through|via|by$/ <2 (NP << (NN=tr < /ion/)) ! << /PRP/ )");
  
  through3 = TregexPattern
          .compile("VP <1 /VB.*/ < ((PP <<, /^through|via|by$/ <2 (NP << (NN=tr < /ion/)) !<< /PRP/ ) $+ /,|\\./)");
}
 

import edu.stanford.nlp.trees.tregex.TregexPattern; //导入方法依赖的package包/类
protected List<Entity> getCandidates(Entity entity, Treebank treebank, boolean intraSentence)
{
 List<Entity> entityList = new ArrayList<Entity>();
 
 for(Tree tree : treebank)
 {
  List<Tree> leaves = tree.getLeaves();
  OffsetLabel first = (OffsetLabel) leaves.get(0).label();
  OffsetLabel last = (OffsetLabel) leaves.get(leaves.size() - 1).label();
  int start = first.beginPosition();
  int end = last.endPosition();
  
  TregexPattern np = TregexPattern.compile("NP|NNP|NNPS|NN|NNS");
  TregexMatcher m = np.matcher(tree);
  while(m.find())
  {
	  Tree npTree = m.getMatch();
	  List<Token> tokens = Utils.getTokens(tree, npTree);

	  if(!npTree.isLeaf())
	  {
		  Entity candidate = new Entity("",npTree.nodeString(),tokens);
  
			if (entity.from() > candidate.to()) {
				if (intraSentence) {
					if ((entity.from() > start) && (entity.to() < end))
						entityList.add(candidate);
				} else
					entityList.add(candidate);
			}
	  }
  } 
 }
 return entityList;
}
 

import edu.stanford.nlp.trees.tregex.TregexPattern; //导入方法依赖的package包/类
public ArabicTreeNormalizer(boolean retainNPTmp, boolean markPRDverb, boolean changeNoLabels,
    boolean retainNPSbj, boolean retainPPClr) {
  super(new ArabicTreebankLanguagePack());
  this.retainNPTmp = retainNPTmp;
  this.retainNPSbj = retainNPSbj;
  this.markPRDverb = markPRDverb;
  this.changeNoLabels = changeNoLabels;
  this.retainPPClr = retainPPClr;

  rootLabel = tlp.startSymbol();

  try {
    prdVerbPattern  = TregexPattern.compile("/^V[^P]/ > VP $ /-PRD$/=prd");

    prdPattern = Pattern.compile("^[A-Z]+-PRD");

    //Marks NP subjects that *do not* occur in verb-initial clauses
    npSbjPattern = TregexPattern.compile("/^NP-SBJ/ !> @VP");

  } catch(ParseException e) {
    e.printStackTrace();
    throw new RuntimeException();
  }

  emptyFilter = new ArabicEmptyFilter();
  lexMapper = new DefaultLexicalMapper();
}
 

import edu.stanford.nlp.trees.tregex.TregexPattern; //导入方法依赖的package包/类
/**
 * Parses a tsurgeon script text input and compiles all operations in the
 * file into one tsurgeon pattern.
 *
 * @param reader File to read patterns from
 * @return A pair of a tregex and tsurgeon pattern read from a file
 * @throws IOException If any IO problem
 */
public static Pair<TregexPattern, TsurgeonPattern> getOperationFromReader(BufferedReader reader) throws IOException {
  String patternString = getPatternFromFile(reader);
  TregexPattern matchPattern;
  try {
    matchPattern = TregexPattern.compile(patternString);
  } catch (edu.stanford.nlp.trees.tregex.ParseException e) {
    System.err.println("Error parsing your tregex pattern:\n" + patternString);
    throw new RuntimeException(e);
  }

  TsurgeonPattern collectedPattern = getTsurgeonOperationsFromReader(reader);
  return new Pair<TregexPattern,TsurgeonPattern>(matchPattern,collectedPattern);
}
 

import edu.stanford.nlp.trees.tregex.TregexPattern; //导入方法依赖的package包/类
/** Extract enumerations (A, B, and C) */
protected void extractEnumerations(CoreMap s, List<Mention> mentions, Set<IntPair> mentionSpanSet, Set<IntPair> namedEntitySpanSet){
  List<CoreLabel> sent = s.get(CoreAnnotations.TokensAnnotation.class);
  Tree tree = s.get(TreeCoreAnnotations.TreeAnnotation.class);
  SemanticGraph dependency = s.get(SemanticGraphCoreAnnotations.CollapsedDependenciesAnnotation.class);

  final String mentionPattern = "NP < (/^(?:NP|NNP|NML)/=m1 $.. (/^CC|,/ $.. /^(?:NP|NNP|NML)/=m2))";
  TregexPattern tgrepPattern = TregexPattern.compile(mentionPattern);
  TregexMatcher matcher = tgrepPattern.matcher(tree);
  Map<IntPair, Tree> spanToMentionSubTree = Generics.newHashMap();
  while (matcher.find()) {
    matcher.getMatch();
    Tree m1 = matcher.getNode("m1");
    Tree m2 = matcher.getNode("m2");

    List<Tree> mLeaves = m1.getLeaves();
    int beginIdx = ((CoreLabel)mLeaves.get(0).label()).get(CoreAnnotations.IndexAnnotation.class)-1;
    int endIdx = ((CoreLabel)mLeaves.get(mLeaves.size()-1).label()).get(CoreAnnotations.IndexAnnotation.class);
    spanToMentionSubTree.put(new IntPair(beginIdx, endIdx), m1);

    mLeaves = m2.getLeaves();
    beginIdx = ((CoreLabel)mLeaves.get(0).label()).get(CoreAnnotations.IndexAnnotation.class)-1;
    endIdx = ((CoreLabel)mLeaves.get(mLeaves.size()-1).label()).get(CoreAnnotations.IndexAnnotation.class);
    spanToMentionSubTree.put(new IntPair(beginIdx, endIdx), m2);
  }

  for(IntPair mSpan : spanToMentionSubTree.keySet()){
    if(!mentionSpanSet.contains(mSpan) && !insideNE(mSpan, namedEntitySpanSet)) {
      int mentionID = assignIds? ++maxID:-1;
      Mention m = new Mention(mentionID, mSpan.get(0), mSpan.get(1), dependency,
                              new ArrayList<CoreLabel>(sent.subList(mSpan.get(0), mSpan.get(1))), spanToMentionSubTree.get(mSpan));
      mentions.add(m);
      mentionSpanSet.add(mSpan);
    }
  }
}
 

import edu.stanford.nlp.trees.tregex.TregexPattern; //导入方法依赖的package包/类
private static boolean checkPleonastic(Mention m, Tree tree, String pattern) {
  try {
    TregexPattern tgrepPattern = TregexPattern.compile(pattern);
    TregexMatcher matcher = tgrepPattern.matcher(tree);
    while (matcher.find()) {
      Tree np1 = matcher.getNode("m1");
      if (((CoreLabel)np1.label()).get(CoreAnnotations.BeginIndexAnnotation.class)+1 == m.headWord.get(CoreAnnotations.IndexAnnotation.class)) {
        return true;
      }
    }
  } catch (Exception e) {
    e.printStackTrace();
  }
  return false;
}