/** * @param treeRoot * @param mapNodeToId * @param nodeToConllStringConvertor * @return * @throws ConllConverterException */ private static <I extends Info, N extends AbstractNode<I, N>> String treeToConll(N treeRoot, Map<N, Integer> mapNodeToId, TreeConllStringConverter<I, N> nodeToConllStringConvertor) throws ConllConverterException { Map<N, N> nodeToParentMap = AbstractNodeUtils.parentMap(treeRoot); StringBuilder conllStr = new StringBuilder(); if (treeRoot != null) { conllStr.append(nodeToConll(treeRoot, mapNodeToId , nodeToParentMap, nodeToConllStringConvertor)); conllStr.append('\n'); } return conllStr.toString(); }
private static void mapItself(BidirectionalMap<ExtendedNode, ExtendedNode> map, ExtendedNode tree) { for (ExtendedNode node : AbstractNodeUtils.treeToLinkedHashSet(tree)) { map.put(node,node); } }
public BasicNode getParseTree() throws ParserRunException { if (null == this.root) throw new ParserRunException("Tree does not exist. Did you forget calling parse() method?"); this.rootOfImmutable = AbstractNodeUtils.copyTree(root, new BasicNodeConstructor()); return this.rootOfImmutable; }
@Override public void find() throws OperationException { specs = new LinkedHashSet<SubstitutionSubtreeSpecification>(); nodesAndTheirAntecedent = new LinkedHashMap<ExtendedNode, ExtendedNode>(); mapNodeToThoseWhoHaveItAsAntecedent = new SimpleValueSetMap<ExtendedNode, ExtendedNode>(); Set<ExtendedNode> nodes = AbstractNodeUtils.treeToLinkedHashSet(textTree.getTree()); for (ExtendedNode node : nodes) { if (node.getAntecedent()!=null) { ExtendedNode antecedent = AbstractNodeUtils.getDeepAntecedentOf(node); nodesAndTheirAntecedent.put(node,antecedent); mapNodeToThoseWhoHaveItAsAntecedent.put(antecedent, node); } } for (ExtendedNode nodeThatHasAntecedent : nodesAndTheirAntecedent.keySet()) { specs.add(new SubstitutionSubtreeSpecification(nodeThatHasAntecedent, nodesAndTheirAntecedent.get(nodeThatHasAntecedent))); } if (parser.equals(PARSER.EASYFIRST)) { addCopyForRefRelation(); } }
Set<BasicConstructionNode> extraNodes = AbstractNodeUtils.treeToLinkedHashSet(root); extraNodes.removeAll(orderedNodes); Map<BasicConstructionNode, BasicConstructionNode> parentMap = AbstractNodeUtils.parentMap(root); BasicConstructionNode dependencyChildNode = AbstractNodeUtils.getDeepAntecedentOf(node); Token dependencyChildToken = AbstractNodeCASUtils.nodeToToken(tokenAnnotations, dependencyChildNode);
private Integer findMax() { Integer max = null; for (ExtendedNode tree : trees) { for (ExtendedNode node : AbstractNodeUtils.treeToSet(tree)) { Integer corefId = getCorefIdOfNode(node); if (corefId!=null) { if (null==max) max = corefId; else { if (max.intValue()<corefId.intValue()) { max = corefId; } } } } } return max; }
List<ExtendedNode> nodes = AbstractNodeUtils.treeToList(ttResult); for (ExtendedNode child : AbstractNodeUtils.treeToList(node)){ ExtendedNode toAdd =AbstractNodeUtils.getDeepAntecedentOf(child); int curId = node.getInfo().getNodeInfo().getSerial()-1; subtree.add(toAdd);
public static <T, S extends AbstractNode<T, S>> void integrateParserAntecedentToCoreference(List<S> textTrees, TreeCoreferenceInformation<S> coreferenceInformation) throws TreeCoreferenceInformationException { for (S tree : textTrees) { for (S node : TreeIterator.iterableTree(tree)) { if (!coreferenceInformation.isNodeExist(node)) { if (node.getAntecedent()!=null) { S deepAntecedent = AbstractNodeUtils.getDeepAntecedentOf(node); if (coreferenceInformation.isNodeExist(deepAntecedent)) { Integer deepAntecedentGroupId = coreferenceInformation.getIdOf(deepAntecedent); coreferenceInformation.addNodeToGroup(deepAntecedentGroupId, node); } } } } } }
if (!AbstractNodeUtils.isLeaf(node)) { for (S child: node.getChildren()) { List<S> currentChildDependencyPaths = new ArrayList<S>();
@Override protected void generateTheTree() throws OperationException { affectedNodes = new LinkedHashSet<ExtendedNode>(); //BidirectionalMap<AbstractNode<Info,?>, EnglishNode> copyMap = AbstractNodeUtils.copyTreeReturnMap(textTree.getTree(), new EnglishNodeConstructor()); BidirectionalMap<ExtendedNode, ExtendedNode> copyMap = AbstractNodeUtils.strictTypeCopyTree(textTree.getTree(), new ExtendedNodeConstructor()); ExtendedNode duplicatedNode = new ExtendedNode(new ExtendedInfo(new DefaultInfo(nodeToMove.getInfo().getId(), nodeToMove.getInfo().getNodeInfo(), this.newEdgeInfo), nodeToMove.getInfo().getAdditionalNodeInformation()) ); ExtendedNode parentInGeneratedTree = copyMap.leftGet(newParent); parentInGeneratedTree.addChild(duplicatedNode); if (nodeToMove.getAntecedent()!=null) { ExtendedNode antecedentInOriginal = nodeToMove.getAntecedent(); ExtendedNode antecedentInGenerated = copyMap.leftGet(antecedentInOriginal); duplicatedNode.setAntecedent(antecedentInGenerated); } affectedNodes.add(duplicatedNode); this.generatedTree = copyMap.leftGet(textTree.getTree()); this.mapOriginalToGenerated = new SimpleValueSetMap<ExtendedNode, ExtendedNode>(); for (ExtendedNode originalNode : copyMap.leftSet()) { mapOriginalToGenerated.put(originalNode,copyMap.leftGet(originalNode)); } mapOriginalToGenerated.put(nodeToMove,duplicatedNode); }
private void insertNodesToCoreferenceInformation() throws TreeCoreferenceInformationException { for (ExtendedNode tree : trees) { for (ExtendedNode node : AbstractNodeUtils.treeToSet(tree)) { Integer corefId = getCorefIdOfNode(node); if (corefId!=null) { coreferenceInformation.addNodeToGroup(corefId,node); } } } }
private static void addNeToAntecedents(BasicConstructionNode mutableParseTree) { for (BasicConstructionNode mutableNode : TreeIterator.iterableTree(mutableParseTree)) { if (mutableNode.getAntecedent()!=null) { BasicConstructionNode antecedent = AbstractNodeUtils.getDeepAntecedentOf(mutableNode); if (antecedent.getInfo().getNodeInfo().getNamedEntityAnnotation()!=null) { NamedEntity ne = antecedent.getInfo().getNodeInfo().getNamedEntityAnnotation(); Info newInfo = new DefaultInfo(mutableNode.getInfo().getId(), new DefaultNodeInfo(mutableNode.getInfo().getNodeInfo().getWord(), mutableNode.getInfo().getNodeInfo().getWordLemma(), mutableNode.getInfo().getNodeInfo().getSerial(), ne, mutableNode.getInfo().getNodeInfo().getSyntacticInfo()), mutableNode.getInfo().getEdgeInfo()); mutableNode.setInfo(newInfo); } } } }
/** * Adds a list of all dependency paths from the given node or a descendant of it, to a descendant node. * @param root [INPUT] the common ancestor of all the dependency paths that will be created. * @param currentDependencyPaths [OUTPUT] the dependency paths. */ protected void addDependencyPaths(S node, List<S> currentDependencyPaths) { // 1. Add all dependency paths from the given root: if (startNodePredicate.evaluate(node.getInfo())) currentDependencyPaths.addAll(dependencyPathsFromNode(node)); // 2. Recursively add all dependency paths from each child of root: if (!AbstractNodeUtils.isLeaf(node)) for (S child: node.getChildren()) addDependencyPaths(child, currentDependencyPaths); }
/** * Given a sub-tree - returns all its nodes as a list, sorted by their "serial" * * @param <T> The information on each node (e.g. ac.biu.nlp.nlp.instruments.parse.representation.english.Info) * @param <S> The nodes (e.g. EnglishNode) * @param tree The given sub-tree. * @return The nodes of the sub-tree as a sorted list (sorted by "serial" field of the nodes). */ public static <T extends Info, S extends AbstractNode<T,S>> List<S> treeToList(S tree) { Set<S> set = AbstractNodeUtils.treeToLinkedHashSet(tree); List<S> list = new ArrayList<S>(set.size()); list.addAll(set); Collections.sort(list, new BySerialComparator<T,S>()); return list; }
private void init() throws TeEngineMlException { this.parentMap = AbstractNodeUtils.parentMap(tree); lca = new LeastCommonAncestor<I, S>(tree); try { lca.compute(); } catch (LeastCommonAncestorException e) { throw new TeEngineMlException("Failed to initialize TemplatesFromTree. See nested exception",e); } }
private void constructSetOfLemmas() throws TeEngineMlException { lemmas = new LinkedHashSet<LemmaAndPos>(); for (ExtendedNode node : AbstractNodeUtils.treeToSet(treeAndParentMap.getTree())) { if (InfoObservations.infoHasLemma(node.getInfo())) { String lemma = InfoGetFields.getLemma(node.getInfo()); PartOfSpeech pos = InfoGetFields.getPartOfSpeechObject(node.getInfo()); LemmaAndPos lemmaAndPos = new LemmaAndPos(lemma, pos); lemmas.add(lemmaAndPos); } } }
public BasicNode getParseTree() throws ParserRunException { if (null==this.root) throw new ParserRunException("Tree does not exist. Did you forget calling parse() method?"); this.rootOfImmutable = AbstractNodeUtils.copyTree(root, new BasicNodeConstructor()); return this.rootOfImmutable; }
/** * Adds a list of all dependency paths from the given root node to a descendant node, that pass through the given current node. * @param root [INPUT] the common ancestor of all the dependency paths that will be created. * @param currentNode [INPUT] one of the descendants of root. * @param pathFromCurrentNodeToRoot [INPUT] list of info's on the dependency path from the currentNode to the root. * @param currentDependencyPaths [OUTPUT] list of node's - dependency paths from the root to a descendant node. */ protected void addDependencyPathsFromNodeThroughDescendant(S root, S currentNode, List<T> pathFromCurrentNodeToRoot, List<S> currentDependencyPaths) { // 1. Prepend the current node to the current path: pathFromCurrentNodeToRoot.add(0, currentNode.getInfo()); // 2. If the current path is complete - add it to the list of all paths: if (endNodePredicate.evaluate(currentNode.getInfo()) && pathFromCurrentNodeToRoot.size()>1) { //System.out.println("\tfound a path - add it to the list"); if (!filterPathsWithOnlyStopwords || !isListContainsOnlyStopwords(pathFromCurrentNodeToRoot)) { S newDependencyPath = AbstractNodeBuildUtils.buildTreeFromLeafToRoot(pathFromCurrentNodeToRoot, this.nodeConstructor); currentDependencyPaths.add(newDependencyPath); } } // 3. Whether the current path is complete or not - recursively add the paths through each of the children of the current node: if (!AbstractNodeUtils.isLeaf(currentNode) && (pathFromCurrentNodeToRoot.size()==1 || !stopNodePredicate.evaluate(currentNode.getInfo()))) { for (S child: currentNode.getChildren()) { addDependencyPathsFromNodeThroughDescendant(root, child, pathFromCurrentNodeToRoot, currentDependencyPaths); } } // 4. Cleanup - after adding all possible paths through the current node, remove the current node from the current path. pathFromCurrentNodeToRoot.remove(0); }
public static double missingNodesPortion(TreeAndParentMap<ExtendedInfo,ExtendedNode> text, TreeAndParentMap<ExtendedInfo,ExtendedNode> hypothesis) { int totalNumberOfNodes = AbstractNodeUtils.treeToLinkedHashSet(hypothesis.getTree()).size(); int numberOfMissingNodes = findNodesNoMatch(text, hypothesis).size(); return ((double)numberOfMissingNodes)/((double)totalNumberOfNodes); }
List<DefaultCooccurrence<String>> coOccurrences = new LinkedList<DefaultCooccurrence<String>>(); try { Map<BasicNode, BasicNode> child2parent = AbstractNodeUtils.parentMap(root); for (Entry<BasicNode,BasicNode> entry : child2parent.entrySet()) { BasicNode childNode = entry.getKey();