@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'); }
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); } } }
@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; }
/** * 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) { // 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 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; }
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); }
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); } } } }
/** * Pretty printers */ public static String printEdges(Iterable<SemanticGraphEdge> edges) { StringWriter buf = new StringWriter(); for (SemanticGraphEdge edge : edges) { buf.append("\t"); buf.append(edge.getRelation().toString()); buf.append("("); buf.append(edge.getGovernor().toString()); buf.append(", "); buf.append(edge.getDependent().toString()); buf.append(")\n"); } return buf.toString(); }
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; }
/** * 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; }
@Override public boolean equals(Object o) { if (this == o) return true; if (!(o instanceof SemanticGraphEdge)) return false; final SemanticGraphEdge semanticGraphEdge = (SemanticGraphEdge) o; if (relation != null) { boolean retFlag = relation.equals(semanticGraphEdge.relation); boolean govMatch = getGovernor().equals(semanticGraphEdge.getGovernor()); boolean depMatch = getDependent().equals(semanticGraphEdge.getDependent()); boolean matched = retFlag && govMatch && depMatch; return matched; } // if (relation != null ? !relation.equals(semanticGraphEdge.relation) : semanticGraphEdge.relation != null) return false; return super.equals(o); }
/** * Strips aux and mark edges when we are splitting into a clause. * * @param toModify The tree we are stripping the edges from. */ private static void stripAuxMark(SemanticGraph toModify) { List<SemanticGraphEdge> toClean = new ArrayList<>(); for (SemanticGraphEdge edge : toModify.outgoingEdgeIterable(toModify.getFirstRoot())) { String rel = edge.getRelation().toString(); if (("aux".equals(rel) || "mark".equals(rel)) && !toModify.outgoingEdgeIterator(edge.getDependent()).hasNext()) { toClean.add(edge); } } for (SemanticGraphEdge edge : toClean) { toModify.removeEdge(edge); toModify.removeVertex(edge.getDependent()); } }
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; } }
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; }
@Override public Optional<State> applyTo(SemanticGraph tree, State source, SemanticGraphEdge outgoingEdge, SemanticGraphEdge subjectOrNull, SemanticGraphEdge objectOrNull) { return Optional.of(new State( outgoingEdge, subjectOrNull == null ? source.subjectOrNull : subjectOrNull, subjectOrNull == null ? (source.distanceFromSubj + 1) : 0, objectOrNull == null ? source.objectOrNull : objectOrNull, source.thunk.andThen(toModify -> { assert Util.isTree(toModify); simpleClause(toModify, outgoingEdge); addSubtree(toModify, outgoingEdge.getDependent(), "nsubjpass", tree, outgoingEdge.getGovernor(), Collections.singleton(outgoingEdge)); // addWord(toModify, outgoingEdge.getDependent(), "auxpass", mockNode(outgoingEdge.getDependent().backingLabel(), "is", "VBZ")); assert Util.isTree(toModify); }), true )); } });
/** * 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); }
/** * This creates a new graph based off the given, but uses the existing nodes objects. */ public static SemanticGraph duplicateKeepNodes(SemanticGraph sg) { SemanticGraph retSg = new SemanticGraph(); for (IndexedWord node : sg.vertexSet()) { retSg.addVertex(node); } retSg.setRoots(sg.getRoots()); for (SemanticGraphEdge edge : sg.edgeIterable()) { retSg.addEdge(edge.getGovernor(), edge.getDependent(), edge.getRelation(), edge.getWeight(), edge.isExtra()); } return retSg; }