/** 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); }
/** 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); }
/** * 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; }
/** 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); }
private Collection<ScoredObject<Integer>> findHighestScoringTransitions(State state, List<String> features, boolean requireLegal, int numTransitions, List<ParserConstraint> constraints) { float[] scores = new float[transitionIndex.size()]; for (String feature : features) { Weight weight = featureWeights.get(feature); if (weight == null) { // Features not in our index are ignored continue; } weight.score(scores); } PriorityQueue<ScoredObject<Integer>> queue = new PriorityQueue<>(numTransitions + 1, ScoredComparator.ASCENDING_COMPARATOR); for (int i = 0; i < scores.length; ++i) { if (!requireLegal || transitionIndex.get(i).isLegal(state, constraints)) { queue.add(new ScoredObject<>(i, scores[i])); if (queue.size() > numTransitions) { queue.poll(); } } } return queue; }
} else { curParse = new ScoredObject<>(Trees.readTree(line), score); curParses.add(curParse); curParse = null;
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; }
/** Get the exact k best parses for the sentence. * * @param k The number of best parses to return * @return The exact k best parses for the sentence, with * each accompanied by its score (typically a * negative log probability). */ @Override public List<ScoredObject<Tree>> getKBestParses(int k) { cand = Generics.newHashMap(); dHat = Generics.newHashMap(); int start = 0; int end = length; int goal = stateIndex.indexOf(goalStr); Vertex v = new Vertex(goal, start, end); List<ScoredObject<Tree>> kBestTrees = new ArrayList<>(); for (int i = 1; i <= k; i++) { Tree internalTree = getTree(v, i, k); if (internalTree == null) { break; } // restoreUnaries(internalTree); kBestTrees.add(new ScoredObject<>(internalTree, dHat.get(v).get(i - 1).score)); } return kBestTrees; }
scoredFeatures.add(new ScoredObject<>(featureIndex.get(i), scores[i]));
/** * 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; }
/** * 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(); }
ScoredObject<Tree> so = new ScoredObject<>(tree, score); List<ScoredObject<Tree>> trees = new ArrayList<>(1); trees.add(so); ScoredObject<Tree> so = new ScoredObject<>(tree, score); List<ScoredObject<Tree>> trees = new ArrayList<>(1); trees.add(so);
bestmatches.add(new ScoredObject<>(Pair.makePair(subtrees.get(i).first(), subtrees.get(j).first()), normF)); if (bestmatches.size() > 100) { bestmatches.poll();
bestModels.add(new ScoredObject<>(new PerceptronModel(this), labelF1)); if (bestModels.size() > op.trainOptions().averagedModels) { bestModels.poll();
/** 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); }
/** TODO: return more if this used a beam */ @Override public List<ScoredObject<Tree>> getKBestPCFGParses(int kbestPCFG) { ScoredObject<Tree> parse = new ScoredObject<Tree>(debinarized, finalState.score); return Collections.singletonList(parse); }
/** 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); }
/** TODO: if this is a beam, return all equal parses */ @Override public List<ScoredObject<Tree>> getBestPCFGParses() { ScoredObject<Tree> parse = new ScoredObject<Tree>(debinarized, finalState.score); return Collections.singletonList(parse); }
/** 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); }