public SemanticGraphEdge addEdge(SemanticGraphEdge edge) { SemanticGraphEdge newEdge = new SemanticGraphEdge(edge.getGovernor(), edge.getDependent(), edge.getRelation(), edge.getWeight(), edge.isExtra()); graph.add(edge.getGovernor(), edge.getDependent(), newEdge); return newEdge; }
public SemanticGraphEdge(SemanticGraphEdge e) { this(e.getSource(), e.getTarget(), e.getRelation(), e.getWeight(), e.isExtra()); }
/** * Returns an ordered list of edges in the graph. * This creates and sorts a list, so prefer edgeIterable(). * * @return A ordered list of edges in the graph. */ public List<SemanticGraphEdge> edgeListSorted() { ArrayList<SemanticGraphEdge> edgeList = new ArrayList<>(); for (SemanticGraphEdge edge : edgeIterable()) { edgeList.add(edge); } edgeList.sort(SemanticGraphEdge.orderByTargetComparator()); return edgeList; }
@Override public String toString() { if (!printOnlyRelation) { return getSource() + " -> " + getTarget() + " (" + getRelation() + ")"; } else { return getRelation().toString(); } }
public static List<String> dependencyPathAsList(List<SemanticGraphEdge> edgePath, IndexedWord node, boolean generalize) { if(edgePath == null) return null; List<String> path = new ArrayList<>(); for (SemanticGraphEdge edge : edgePath) { IndexedWord nextNode; GrammaticalRelation relation; if (generalize) { relation = generalizeRelation(edge.getRelation()); } else { relation = edge.getRelation(); } if (node.equals(edge.getDependent())) { String v = (relation + "->").intern(); path.add(v); nextNode = edge.getGovernor(); } else { String v = ("<-" + relation).intern(); path.add(v); nextNode = edge.getDependent(); } node = nextNode; } return path; }
@Override public boolean prerequisitesMet(SemanticGraph originalTree, SemanticGraphEdge edge) { // Don't split into anything but verbs or nouns char tag = edge.getDependent().tag().charAt(0); if (tag != 'V' && tag != 'N') { return false; } for (SemanticGraphEdge grandchild : originalTree.outgoingEdgeIterable(edge.getDependent())) { if (grandchild.getRelation().toString().contains("subj")) { return false; } } return true; }
private void recToString(IndexedWord curr, CoreLabel.OutputFormat wordFormat, StringBuilder sb, int offset, Set<IndexedWord> used) { used.add(curr); List<SemanticGraphEdge> edges = outgoingEdgeList(curr); Collections.sort(edges); for (SemanticGraphEdge edge : edges) { IndexedWord target = edge.getTarget(); sb.append(space(2 * offset)).append("-> ").append(target.toString(wordFormat)).append(" (").append(edge.getRelation()).append(")\n"); if (!used.contains(target)) { // recurse recToString(target, wordFormat, sb, offset + 1, used); } } }
/** * Given a governor, dependent, and the relation between them, returns the * SemanticGraphEdge object of that arc if it exists, otherwise returns null. */ public SemanticGraphEdge getEdge(IndexedWord gov, IndexedWord dep, GrammaticalRelation reln) { Collection<SemanticGraphEdge> edges = getAllEdges(gov, dep); if (edges != null) { for (SemanticGraphEdge edge : edges) { if (!edge.getSource().equals(gov)) continue; if ((edge.getRelation().equals(reln))) { return edge; } } } return null; }
/** * Given an iterable set of edges, returns the set of vertices covered by these edges. * * Note: CDM changed the return of this from a List to a Set in 2011. This seemed more * sensible. Hopefully it doesn't break anything.... */ private static Set<IndexedWord> getVerticesFromEdgeSet(Iterable<SemanticGraphEdge> edges) { Set<IndexedWord> retSet = Generics.newHashSet(); for (SemanticGraphEdge edge : edges) { retSet.add(edge.getGovernor()); retSet.add(edge.getDependent()); } return retSet; }
@Override public boolean prerequisitesMet(SemanticGraph originalTree, SemanticGraphEdge edge) { // Only valid if there's a single nontrivial outgoing edge from a node. Otherwise it's a whole can of worms. Iterator<SemanticGraphEdge> iter = originalTree.outgoingEdgeIterable(edge.getGovernor()).iterator(); if (!iter.hasNext()) { return false; // what? } boolean nontrivialEdge = false; while (iter.hasNext()) { SemanticGraphEdge outEdge = iter.next(); switch (outEdge.getRelation().toString()) { case "nn": case "amod": break; default: if (nontrivialEdge) { return false; } nontrivialEdge = true; } } return true; }
public double subjDeletionProbability(SemanticGraphEdge edge, Iterable<SemanticGraphEdge> neighbors) { // Get information about the neighbors // (in a totally not-creepy-stalker sort of way) for (SemanticGraphEdge neighbor : neighbors) { if (neighbor != edge) { String neighborRel = neighbor.getRelation().toString(); if (neighborRel.contains("subj")) { return 1.0; } } } return 0.0; }
private static void demoteQmodParentHelper(SemanticGraph sg, IndexedWord gov, IndexedWord oldHead) { if (!sg.getRoots().contains(oldHead)) { IndexedWord parent = sg.getParent(oldHead); if (parent == null) { return; } SemanticGraphEdge edge = sg.getEdge(parent, oldHead); sg.addEdge(parent, gov, edge.getRelation(), edge.getWeight(), edge.isExtra()); sg.removeEdge(edge); } else { sg.getRoots().remove(oldHead); sg.addRoot(gov); } //temporary relation to keep the graph connected sg.addEdge(gov, oldHead, DEPENDENT, Double.NEGATIVE_INFINITY, false); sg.removeEdge(sg.getEdge(oldHead, gov)); }
private static void addConjToReln(SemanticGraph sg, IndexedWord gov, List<IndexedWord> conjDeps, IndexedWord ccDep) { for (IndexedWord conjDep : conjDeps) { SemanticGraphEdge edge = sg.getEdge(gov, conjDep); if (edge.getRelation() == CONJUNCT || conjDep.index() > ccDep.index()) { edge.setRelation(conjValue(ccDep, sg)); } } }
@Override public boolean prerequisitesMet(SemanticGraph originalTree, SemanticGraphEdge edge) { char tag = edge.getDependent().tag().charAt(0); return !(tag != 'V' && tag != 'N' && tag != 'J' && tag != 'P' && tag != 'D'); }
/** * Returns the yield of a node, i.e., all descendents of the node. * * @param word The word acting as the root of the constituent we are finding. */ public List<IndexedWord> yield(IndexedWord word) { List<IndexedWord> yield = new LinkedList<>(); Stack<IndexedWord> fringe = new Stack<>(); fringe.push(word); while ( ! fringe.isEmpty()) { IndexedWord parent = fringe.pop(); yield.add(parent); for (SemanticGraphEdge edge : outgoingEdgeIterable(parent)) { if (!edge.isExtra()) { fringe.push(edge.getDependent()); } } } Collections.sort(yield); return yield; }
/** The head of the subject of this relation triple. */ @Override public CoreLabel subjectHead() { if (subject.size() == 1) { return subject.get(0); } Span subjectSpan = Span.fromValues(subject.get(0).index(), subject.get(subject.size() - 1).index()); for (int i = subject.size() - 1; i >= 0; --i) { for (SemanticGraphEdge edge : sourceTree.incomingEdgeIterable(new IndexedWord(subject.get(i)))) { if (edge.getGovernor().index() < subjectSpan.start() || edge.getGovernor().index() >= subjectSpan.end()) { return subject.get(i); } } } return subject.get(subject.size() - 1); }
@Override IndexedWord followEdge(SemanticGraphEdge edge) { return edge.getSource(); }
public IndexedWord getDependent() { return getTarget(); }
public SemanticGraphEdge addEdge(IndexedWord s, IndexedWord d, GrammaticalRelation reln, double weight, boolean isExtra) { SemanticGraphEdge newEdge = new SemanticGraphEdge(s, d, reln, weight, isExtra); graph.add(s, d, newEdge); return newEdge; }