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; }
/** * 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()); } }
scoredFeatures.add(new ScoredObject<>(featureIndex.get(i), scores[i])); Index<F> newFeatureIndex = new HashIndex<>(); for (int i = 0; i < scoredFeatures.size() && i < numFeatures; i++) { newFeatureIndex.add(scoredFeatures.get(i).object());
/** TODO: return more if this used a beam */ @Override public List<ScoredObject<Tree>> getKBestPCFGParses(int kbestPCFG) { ScoredObject<Tree> parse = new ScoredObject<>(debinarized, finalState.score); return Collections.singletonList(parse); }
/** * Return the best parse of the sentence most recently parsed. * * @return The best (highest score) tree */ public Tree getBestParse() { return nGoodTrees.get(0).object(); }
public double getBestScore() { return nGoodTrees.get(0).score(); }
curParses.add(curParse = new ScoredObject<Tree>(null, score)); } else { curParse.setObject(Trees.readTree(line)); curParse = null; parsesExpected--;
/** TODO: if this is a beam, return all equal parses */ @Override public List<ScoredObject<Tree>> getBestPCFGParses() { ScoredObject<Tree> parse = new ScoredObject<>(debinarized, finalState.score); return Collections.singletonList(parse); }
@Override public Tree getBestParse() { if (scoredTrees == null || scoredTrees.isEmpty()) { return null; } return scoredTrees.get(0).object(); }
@Override public double getPCFGScore() { if (scoredTrees == null || scoredTrees.isEmpty()) { throw new AssertionError(); } return scoredTrees.get(0).score(); }
scoredFeatures.add(new ScoredObject<>(featureIndex.get(i), scores[i])); Index<F> newFeatureIndex = new HashIndex<>(); for (int i = 0; i < scoredFeatures.size() && i < numFeatures; i++) { newFeatureIndex.add(scoredFeatures.get(i).object());
/** * 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; }
/** * Return the list of k "good" parses of the sentence most recently parsed. * (The first is guaranteed to be the best, but later ones are only * guaranteed the best subject to the possibilities that disappear because * the PCFG/Dep charts only store the best over each span.) * * @return The list of k best trees */ public List<ScoredObject<Tree>> getKGoodParses(int k) { List<ScoredObject<Tree>> nGoodTreesList = new ArrayList<>(op.testOptions.printFactoredKGood); for (Edge e : nGoodTrees) { nGoodTreesList.add(new ScoredObject<>(extractParse(e), e.iScore)); } return nGoodTreesList; }
public Tree getBestParse(List<? extends HasWord> sentence) { ScoredObject<Tree> scoredParse = getBestScoredParse(sentence); return (scoredParse != null)? scoredParse.object():null; }
@Override public List<ScoredObject<Tree>> getBestPCFGParses() { if (scoredTrees == null || scoredTrees.isEmpty()) { throw new AssertionError(); } List<ScoredObject<Tree>> equalTrees = Generics.newArrayList(); double score = scoredTrees.get(0).score(); int treePos = 0; while (treePos < scoredTrees.size() && scoredTrees.get(treePos).score() == score) { equalTrees.add(scoredTrees.get(treePos)); } return equalTrees; }
/** * 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(); }
/** Get a complete set of the maximally scoring parses for a sentence, * rather than one chosen at random. This set may be of size 1 or larger. * * @return All the equal best parses for a sentence, with each * accompanied by its score */ @Override public List<ScoredObject<Tree>> getBestParses() { int start = 0; int end = length; int goal = stateIndex.indexOf(goalStr); double bestScore = iScore[start][end][goal]; List<Tree> internalTrees = extractBestParses(goal, start, end); //System.out.println("Got internal best parse..."); // for (Tree internalTree : internalTrees) { // restoreUnaries(internalTree); // } //System.out.println("Restored unaries..."); List<ScoredObject<Tree>> scoredTrees = new ArrayList<>(internalTrees.size()); for (Tree tr : internalTrees) { scoredTrees.add(new ScoredObject<>(tr, bestScore)); } return scoredTrees; //TreeTransformer debinarizer = BinarizerFactory.getDebinarizer(); //return debinarizer.transformTree(internalTree); }