/** * Return the best parse of the sentence most recently parsed. * * @return The best (highest score) tree */ public Tree getBestParse() { return nGoodTrees.get(0).object(); }
@Override public Tree getBestParse() { if (scoredTrees == null || scoredTrees.isEmpty()) { return null; } return scoredTrees.get(0).object(); }
public Tree getBestParse(List<? extends HasWord> sentence) { ScoredObject<Tree> scoredParse = getBestScoredParse(sentence); return (scoredParse != null)? scoredParse.object():null; }
/** * Print scored parse trees for one sentence in format used by Charniak parser. * * @param pw - printwriter * @param id - sentence id * @param trees - trees to output */ public static void printScoredTrees(PrintWriter pw, int id, List<ScoredObject<Tree>> trees) { pw.println(trees.size() + "\t" + id); for (ScoredObject<Tree> scoredTree:trees) { pw.println(scoredTree.score()); pw.println(scoredTree.object()); } }
List<ScoredObject<Tree>> rerank(List<? extends HasWord> sentence, List<ScoredObject<Tree>> bestKParses) { this.rerankerQuery = reranker.process(sentence); List<ScoredObject<Tree>> reranked = new ArrayList<>(); for (ScoredObject<Tree> scoredTree : bestKParses) { double score = scoredTree.score(); try { score = op.baseParserWeight * score + rerankerQuery.score(scoredTree.object()); } catch (NoSuchParseException e) { score = Double.NEGATIVE_INFINITY; } reranked.add(new ScoredObject<>(scoredTree.object(), score)); } Collections.sort(reranked, ScoredComparator.DESCENDING_COMPARATOR); return reranked; }
for (ScoredObject<Tree> tp : trees) { ii++; Tree t = tp.object(); double score = tp.score();
static public List<Tree> getTopParsesForOneTree(LexicalizedParser parser, int dvKBest, Tree tree, TreeTransformer transformer) { ParserQuery pq = parser.parserQuery(); List<Word> sentence = tree.yieldWords(); // Since the trees are binarized and otherwise manipulated, we // need to chop off the last word in order to remove the end of // sentence symbol if (sentence.size() <= 1) { return null; } sentence = sentence.subList(0, sentence.size() - 1); if (!pq.parse(sentence)) { log.info("Failed to use the given parser to reparse sentence \"" + sentence + "\""); return null; } List<Tree> parses = new ArrayList<>(); List<ScoredObject<Tree>> bestKParses = pq.getKBestPCFGParses(dvKBest); for (ScoredObject<Tree> so : bestKParses) { Tree result = so.object(); if (transformer != null) { result = transformer.transformTree(result); } parses.add(result); } return parses; }
Index<F> newFeatureIndex = new HashIndex<>(); for (int i = 0; i < scoredFeatures.size() && i < numFeatures; i++) { newFeatureIndex.add(scoredFeatures.get(i).object());
/** * Parse a Sentence. It is assumed that when this is called, the pparser * has already been called to parse the sentence. * * @param words The list of words to parse. * @return true iff it could be parsed */ public boolean parse(List<? extends HasWord> words) { nGoodTrees.clear(); int numParsesToConsider = numToFind * op.testOptions.fastFactoredCandidateMultiplier + op.testOptions.fastFactoredCandidateAddend; if (pparser.hasParse()) { List<ScoredObject<Tree>> pcfgBest = pparser.getKBestParses(numParsesToConsider); Beam<ScoredObject<Tree>> goodParses = new Beam<>(numToFind); for (ScoredObject<Tree> candidate : pcfgBest) { if (Thread.interrupted()) { throw new RuntimeInterruptedException(); } double depScore = depScoreTree(candidate.object()); ScoredObject<Tree> x = new ScoredObject<>(candidate.object(), candidate.score() + depScore); goodParses.add(x); } nGoodTrees = goodParses.asSortedList(); } return ! nGoodTrees.isEmpty(); }
/** * Returns the trees (and scores) corresponding to the * k-best derivations of the sentence. This cannot be * a Counter because frequently there will be multiple * derivations which lead to the same parse tree. * * @param k The number of best parses to return * @return The list of trees with their scores (log prob). */ public List<ScoredObject<Tree>> getKBestPCFGParses(int k) { if (pparser == null) { return null; } List<ScoredObject<Tree>> binaryTrees = pparser.getKBestParses(k); if (binaryTrees == null) { return null; } List<ScoredObject<Tree>> trees = new ArrayList<>(k); for (ScoredObject<Tree> p : binaryTrees) { Tree t = debinarizer.transformTree(p.object()); t = subcategoryStripper.transformTree(t); restoreOriginalWords(t); trees.add(new ScoredObject<>(t, p.score())); } return trees; }
public List<ScoredObject<Tree>> getKGoodFactoredParses(int k) { if (bparser == null || parseSkipped) { return null; } List<ScoredObject<Tree>> binaryTrees = bparser.getKGoodParses(k); if (binaryTrees == null) { return null; } List<ScoredObject<Tree>> trees = new ArrayList<>(k); for (ScoredObject<Tree> tp : binaryTrees) { Tree t = debinarizer.transformTree(tp.object()); if (op.nodePrune) { NodePruner np = new NodePruner(pparser, debinarizer); t = np.prune(t); } t = subcategoryStripper.transformTree(t); restoreOriginalWords(t); trees.add(new ScoredObject<>(t, tp.score())); } return trees; }
Transition transition = parser.model.transitionIndex.get(predictedTransition.object()); State newState = transition.apply(state, predictedTransition.score());
for (ScoredObject<Tree> so : scoredObjects) { Tree tree = so.object(); tree.setScore(so.score() % -10000.0); trees.add(tree);
throw new AssertionError("Did not find a legal transition"); int predictedNum = prediction.object(); Transition predicted = transitionIndex.get(predictedNum); OracleTransition gold = oracle.goldTransition(index, state); Collection<ScoredObject<Integer>> stateTransitions = findHighestScoringTransitions(currentState, features, true, op.trainOptions().beamSize, null); for (ScoredObject<Integer> transition : stateTransitions) { State newState = transitionIndex.get(transition.object()).apply(currentState, transition.score()); newAgenda.add(newState); if (newAgenda.size() > op.trainOptions().beamSize) { highestScoringTransitionFromGoldState = transitionIndex.get(transition.object()); highestScoreFromGoldState = transition.score(); int transitionNum = transitionIndex.indexOf(transition); List<String> features = featureFactory.featurize(state); int predictedNum = findHighestScoringTransition(state, features, false).object(); Transition predicted = transitionIndex.get(predictedNum); if (transitionNum == predictedNum) {
for (ScoredObject<Tree> sot : parses) { iii++; Tree tb = sot.object(); Tree tbd = debinarizer.transformTree(tb); tbd = subcategoryStripper.transformTree(tbd); i++; pwOut.println("PCFG Parse #" + i + " with score " + tp.score()); Tree tbd = tp.object(); tbd.pennPrint(pwOut); Tree tbtr = collinizer.transformTree(tbd); ii++; pwOut.println("Factored Parse #" + ii + " with score " + tp.score()); Tree tbd = tp.object(); tbd.pennPrint(pwOut); Tree tbtr = collinizer.transformTree(tbd); int kbest = Math.min(op.testOptions.evalPCFGkBest, kbestPCFGTrees.size()); for (ScoredObject<Tree> guess : kbestPCFGTrees.subList(0, kbest)) { transGuesses.add(collinizer.transformTree(guess.object()));
/** * Return the best parse of the sentence most recently parsed. * * @return The best (highest score) tree */ public Tree getBestParse() { return nGoodTrees.get(0).object(); }
/** * Return the best parse of the sentence most recently parsed. * * @return The best (highest score) tree */ public Tree getBestParse() { return nGoodTrees.get(0).object(); }
/** * Return the best parse of the sentence most recently parsed. * * @return The best (highest score) tree */ public Tree getBestParse() { return nGoodTrees.get(0).object(); }
@Override public Tree getBestParse() { if (scoredTrees == null || scoredTrees.isEmpty()) { return null; } return scoredTrees.get(0).object(); }