/** * Checks for outgoing edges of the node, in the given graph, which contain * the given relation. Relations are matched on if they are GrammaticalRelation * objects or strings. */ public static List<SemanticGraphEdge> outgoingEdgesWithReln(IndexedWord node, SemanticGraph sg, GrammaticalRelation reln) { return edgesWithReln(sg.outgoingEdgeIterable(node), reln); }
public List<SemanticGraphEdge> outgoingEdgeList(IndexedWord v) { return CollectionUtils.toList(outgoingEdgeIterable(v)); }
public static void getSubTreeEdgesHelper(IndexedWord vertice, SemanticGraph sg, Set<SemanticGraphEdge> tabuEdges) { for (SemanticGraphEdge edge : sg.outgoingEdgeIterable(vertice)) { if (!tabuEdges.contains(edge)) { IndexedWord dep = edge.getDependent(); tabuEdges.add(edge); getSubTreeEdgesHelper(dep, sg, tabuEdges); } } }
/** * Given a set of vertices from the same graph, returns the set of all edges between these * vertices. */ public static Set<SemanticGraphEdge> allEdgesInSet(Iterable<IndexedWord> vertices, SemanticGraph sg) { Set<SemanticGraphEdge> edges = Generics.newHashSet(); for (IndexedWord v1 : vertices) { for (SemanticGraphEdge edge : sg.outgoingEdgeIterable(v1)) { edges.add(edge); } for (SemanticGraphEdge edge : sg.incomingEdgeIterable(v1)) { edges.add(edge); } } return edges; }
private static final ArgumentSequence getOrphanGovSequence(SemanticGraph sg, IndexedWord orphanGov) { List<IndexedWord> seq = new LinkedList<>(); seq.add(orphanGov); for (SemanticGraphEdge edge : sg.outgoingEdgeIterable(orphanGov)) { if (isModifier(edge)) { seq.addAll(sg.yield(edge.getDependent())); } } Collections.sort(seq); return new ArgumentSequence(orphanGov, seq); }
/** * Since graphs can be have preps collapsed, finds all the immediate children of this node * that are linked by a collapsed preposition edge. */ public static List<IndexedWord> getChildrenWithPrepC(SemanticGraph sg, IndexedWord vertex) { List<IndexedWord> ret = new ArrayList<>(); // Collection<GrammaticalRelation> prepCs = EnglishGrammaticalRelations.getPrepsC(); // for (SemanticGraphEdge edge : sg.outgoingEdgesOf(vertex)) { // if (prepCs.contains(edge.getRelation())) for (SemanticGraphEdge edge : sg.outgoingEdgeIterable(vertex)) { if (edge.getRelation().toString().startsWith("prep")) ret.add(edge.getDependent()); } return ret; }
/** * Does the given {@code vertex} have at least one child with the given {@code reln}? */ public boolean hasChildWithReln(IndexedWord vertex, GrammaticalRelation reln) { if (!containsVertex(vertex)) { throw new IllegalArgumentException(); } for (SemanticGraphEdge edge : outgoingEdgeIterable(vertex)) { if (edge.getRelation().equals(reln)) { return true; } } return false; }
@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; }
@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; }
protected static void crawl(IndexedWord vertex, SemanticGraph sg, Set<IndexedWord> seenVerts) { seenVerts.add(vertex); for (SemanticGraphEdge edge : sg.incomingEdgeIterable(vertex)) { IndexedWord gov = edge.getGovernor(); if (!seenVerts.contains(gov)) { crawl(gov, sg, seenVerts); } } for (SemanticGraphEdge edge : sg.outgoingEdgeIterable(vertex)) { IndexedWord dep = edge.getDependent(); if (!seenVerts.contains(dep)) { crawl(dep, sg, seenVerts); } } }
private static final boolean isArgument(SemanticGraph sg, SemanticGraphEdge edge) { boolean matches = ARGUMENT_PATTERN.matcher(edge.getRelation().toString()).matches(); if (matches) { for (SemanticGraphEdge edge2 : sg.outgoingEdgeIterable(edge.getDependent())) { if (edge2.getRelation().equals(UniversalEnglishGrammaticalRelations.ORPHAN)) { return false; } } return true; } else { return false; } }
private static final boolean isClausalArgument(SemanticGraph sg, SemanticGraphEdge edge) { boolean matches = CLAUSAL_ARGUMENT_PATTERN.matcher(edge.getRelation().toString()).matches(); if (matches) { for (SemanticGraphEdge edge2 : sg.outgoingEdgeIterable(edge.getDependent())) { if (edge2.getRelation().equals(UniversalEnglishGrammaticalRelations.ORPHAN)) { return false; } } return true; } else { return false; } }
private static final List<ArgumentSequence> getGappedConjunctArguments(SemanticGraph sg, IndexedWord orphanGov) { List<ArgumentSequence> arguments = new LinkedList<>(); for (SemanticGraphEdge edge : sg.outgoingEdgeIterable(orphanGov)) { if (edge.getRelation().equals(UniversalEnglishGrammaticalRelations.ORPHAN)) { ArgumentSequence seq = new ArgumentSequence(edge.getDependent(), sg.yield(edge.getDependent())); arguments.add(seq); } } arguments.add(getOrphanGovSequence(sg, orphanGov)); arguments.sort((arg1, arg2) -> arg1.head.compareTo(arg2.head)); return arguments; }
/** * Returns a list of pairs of a relation name and the child * IndexedFeatureLabel that bears that relation. */ public List<Pair<GrammaticalRelation, IndexedWord>> childPairs(IndexedWord vertex) { if (!containsVertex(vertex)) { throw new IllegalArgumentException(); } List<Pair<GrammaticalRelation, IndexedWord>> childPairs = Generics.newArrayList(); for (SemanticGraphEdge e : outgoingEdgeIterable(vertex)) { childPairs.add(new Pair<>(e.getRelation(), e.getTarget())); } return childPairs; }
/** * Returns a set of all children bearing a certain grammatical relation, or * an empty set if none. */ public Set<IndexedWord> getChildrenWithReln(IndexedWord vertex, GrammaticalRelation reln) { if (vertex.equals(IndexedWord.NO_WORD)) return Collections.emptySet(); if (!containsVertex(vertex)) throw new IllegalArgumentException(); Set<IndexedWord> childList = wordMapFactory.newSet(); for (SemanticGraphEdge edge : outgoingEdgeIterable(vertex)) { if (edge.getRelation().equals(reln)) { childList.add(edge.getTarget()); } } return childList; }
/** * Does the given {@code vertex} have at least one child with the given {@code reln} and the lemma {@code childLemma}? */ public boolean hasChild(IndexedWord vertex, GrammaticalRelation reln, String childLemma) { if (!containsVertex(vertex)) { throw new IllegalArgumentException(); } for (SemanticGraphEdge edge : outgoingEdgeIterable(vertex)) { if (edge.getRelation().equals(reln)) { if (edge.getTarget().get(CoreAnnotations.LemmaAnnotation.class).equals(childLemma)) { return true; } } } return false; }
private static final List<List<ArgumentSequence>> getFullConjunctArgumentsHelper(SemanticGraph sg, IndexedWord conjGov, IndexedWord orphanGov) { List<List<ArgumentSequence>> arguments = new LinkedList<>(); for (SemanticGraphEdge edge : sg.outgoingEdgeIterable(conjGov)) { if (isArgument(sg, edge) && edge.getDependent().pseudoPosition() < orphanGov.pseudoPosition()) { List<ArgumentSequence> argumentVariants = new LinkedList<>(); ArgumentSequence seq = new ArgumentSequence(edge.getDependent(), sg.yield(edge.getDependent())); argumentVariants.add(seq); getArgumentSubsequences(sg, edge.getDependent(), argumentVariants); arguments.add(argumentVariants); } } arguments.sort((arg1, arg2) -> arg1.get(0).head.index() - arg2.get(0).head.index()); return arguments; }
/** * Mostly just an alias, but make sure our featurizer is serializable! */ public interface Featurizer extends Function<Triple<ClauseSplitterSearchProblem.State, ClauseSplitterSearchProblem.Action, ClauseSplitterSearchProblem.State>, Counter<String>>, Serializable { boolean isSimpleSplit(Counter<String> feats); }
/** * Returns the first IndexedFeatureLabel bearing a certain grammatical * relation, or null if none. */ public IndexedWord getChildWithReln(IndexedWord vertex, GrammaticalRelation reln) { if (vertex.equals(IndexedWord.NO_WORD)) return null; if (!containsVertex(vertex)) throw new IllegalArgumentException(); for (SemanticGraphEdge edge : outgoingEdgeIterable(vertex)) { if (edge.getRelation().equals(reln)) { return edge.getTarget(); } } return null; }
private static final void getArgumentSubsequences(SemanticGraph sg, IndexedWord currentHead, List<ArgumentSequence> currentSequences) { for (SemanticGraphEdge edge : sg.outgoingEdgeIterable(currentHead)) { if (isArgument(sg, edge)) { ArgumentSequence seq = new ArgumentSequence(edge.getDependent(), sg.yield(edge.getDependent())); currentSequences.add(seq); if (isClausalArgument(sg, edge)) { //TODO: maybe use isArgument here? getArgumentSubsequences(sg, edge.getDependent(), currentSequences); } } } }