public static <T, S extends AbstractNode<T,S>> void addItself(S tree, ValueSetMap<S, S> mapOriginalToGenerated) { for (S node : TreeIterator.iterableTree(tree)) { mapOriginalToGenerated.put(node, node); } }
private void addLemmasOfTextFromTree(S tree) { for (S node : TreeIterator.iterableTree(tree)) { lemmasOfText_lowerCase.add(InfoGetFields.getLemma(node.getInfo()).toLowerCase()); } }
private Map<String,S> getLemmasOfTree(S tree) { Map<String,S> ret = new LinkedHashMap<>(); for (S node : TreeIterator.iterableTree(tree)) { String lemma = InfoGetFields.getLemma(node.getInfo()); if (!(ret.containsKey(lemma))) { ret.put(lemma,node); } } return ret; }
private void init() throws CoreferenceResolutionException { if (trees.size()==0) {throw new CoreferenceResolutionException("No trees");} mapNodeToItsTree = new LinkedHashMap<>(); for (S tree : trees) { for (S node : TreeIterator.iterableTree(tree)) { mapNodeToItsTree.put(node, tree); } } depthMaps = new LinkedHashMap<>(); for (S tree : trees) { depthMaps.put(tree, ArkreffilesUtils.mapNodesToDepth(tree)); } }
public static Set<String> constructSetLemmasLowerCase(TreeAndParentMap<ExtendedInfo, ExtendedNode> tree) { Set<String> ret = new LinkedHashSet<String>(); for (ExtendedNode node : TreeIterator.iterableTree(tree.getTree())) { String lemma = InfoGetFields.getLemma(node.getInfo()); if (lemma.length()>0) { ret.add(lemma.toLowerCase()); } } return ret; }
public void annotate() throws AnnotatorException { mapOriginalToAnnotated = new SimpleBidirectionalMap<ExtendedNode, ExtendedNode>(); for (ExtendedNode node : TreeIterator.iterableTree(this.tree)) { mapOriginalToAnnotated.put(node, node); } annotated=true; }
public static <T extends Info, S extends AbstractNode<T,S>> Map<String,S> mapIdToNode(S tree) throws TeEngineMlException { Map<String,S> ret = new LinkedHashMap<String, S>(); for (S node : TreeIterator.iterableTree(tree)) { String id = node.getInfo().getId(); if (null==id) throw new TeEngineMlException("Null id"); ret.put(id,node); } return ret; }
private List<S> generateAllNodeList() throws CoreferenceResolutionException { List<S> allNodesList = new LinkedList<>(); for (S tree : trees) { Map<Integer, S> mapBySerial = new LinkedHashMap<>(); for (S node : TreeIterator.iterableTree(tree)) { if (node.getAntecedent()==null) { int serial = InfoGetFields.getSerial(node.getInfo()); if (mapBySerial.containsKey(serial)) {throw new CoreferenceResolutionException("Malformed input. The parse tree has more than one node with the serial "+serial);} mapBySerial.put(serial, node); } } List<Integer> serials = new ArrayList<>(mapBySerial.size()); serials.addAll(mapBySerial.keySet()); Collections.sort(serials); for (Integer serialKey : serials) { allNodesList.add(mapBySerial.get(serialKey)); } } return allNodesList; }
private void fillMapHypothesisNodesToLemmas() throws LemmatizerException { this.mapHypothesisNodesToLemmas = new LinkedHashMap<ExtendedNode, Set<String>>(); for (ExtendedNode hypothesisNode : TreeIterator.iterableTree(hypothesisTree.getTree())) { Set<String> lemmas = new LinkedHashSet<String>(); String hypothesisLemma = InfoGetFields.getLemma(hypothesisNode.getInfo()); ImmutableList<String> fromLemmatizer = getLemmas(hypothesisLemma); for (String lemmaFromLemmatizer : fromLemmatizer) { lemmas.add(lemmaFromLemmatizer); } mapHypothesisNodesToLemmas.put(hypothesisNode, lemmas); } }
public void identify() throws PredicateArgumentIdentificationException { Set<S> predicateHeads = new LinkedHashSet<>(); for (S node : TreeIterator.iterableTree(tree.getTree())) { if (hasCopula(node)) { predicateHeads.add(node); } } copularPredicates = new LinkedHashSet<>(); for (S head : predicateHeads) { copularPredicates.add(new Predicate<I, S>(getInternalNodes(head), head)); } }
private Map<ExtendedNode, List<String>> buildMapForTree(TreeAndParentMap<ExtendedInfo,ExtendedNode> tree) { Map<ExtendedNode, List<String>> ret = new LinkedHashMap<ExtendedNode, List<String>>(); for (ExtendedNode node : TreeIterator.iterableTree(tree.getTree())) { String lemma = InfoGetFields.getLemma(node.getInfo()); List<String> lemmaAsList = StringUtil.stringToWords(lemma); if (lemmaAsList.size()>0) { ret.put(node, lemmaAsList); } } return ret; }
public void map() { mapIdToLemma = new LinkedHashMap<SrlPredicateId, String>(); for (ExtendedNode node : TreeIterator.iterableTree(tree)) { SrlPredicateId id = ExtendedInfoGetFields.getSrlPredicateId(node.getInfo()); if (id != null) { mapIdToLemma.put(id,InfoGetFields.getLemma(node.getInfo())); } } }
public static <T extends Info, S extends AbstractNode<T,S>> Map<String,S> mapVarIdToNode(S tree) { Map<String,S> ret = new LinkedHashMap<String, S>(); for (S node : TreeIterator.iterableTree(tree)) { if (InfoGetFields.isVariable(node.getInfo())) { Integer varIdInteger = node.getInfo().getNodeInfo().getVariableId(); String varId = varIdInteger.toString(); ret.put(varId,node); } } return ret; }
private void buildMap() { mapHypothesisNodesToText = new SimpleValueSetMap<>(); for (ExtendedNode hypothesisNode : TreeIterator.iterableTree(HypothesisTree.getTree())) { for (ExtendedNode textNode : TreeIterator.iterableTree(textTree.getTree())) { if (lemmaOfNode_lowerCase(hypothesisNode).equals(lemmaOfNode_lowerCase(textNode))) { mapHypothesisNodesToText.put(hypothesisNode, textNode); } } } }
private List<S> findEndpoints() { List<S> ret = new LinkedList<>(); for (S node : TreeIterator.iterableTree(tree)) { SimplerCanonicalPosTag pos = SimplerPosTagConvertor.simplerPos(InfoGetFields.getCanonicalPartOfSpeech(node.getInfo())); if ( (pos.equals(SimplerCanonicalPosTag.NOUN)) || (pos.equals(SimplerCanonicalPosTag.PRONOUN)) ) { ret.add(node); } } return ret; }
private StringBuffer printCoreferenceDiagnosis() throws TreeCoreferenceInformationException { StringBuffer sb = new StringBuffer(); sb.append("Printing coreference information..."); for (Integer corefGroup : coreferenceExtendedInformation.getAllExistingGroupIds()) { sb.append("\n"); sb.append("Coref group: ").append(corefGroup).append('\n'); for (ExtendedNode node : coreferenceExtendedInformation.getGroup(corefGroup)) { sb.append('[').append(node.getInfo().getId()).append(']'); sb.append(InfoGetFields.getLemma(node.getInfo())).append(", "); } } sb.append("\n"); sb.append("Printing coref information in the nodes...\n"); for (ExtendedNode node : TreeIterator.iterableTree(textTree.getTree())) { sb.append('[').append(node.getInfo().getId()).append(']'); sb.append(InfoGetFields.getLemma(node.getInfo())); sb.append(": "); sb.append(ExtendedInfoGetFields.getCorefGroupId(node.getInfo())); sb.append("\n"); } return sb; }
for (ExtendedNode hypothesisNode : TreeIterator.iterableTree(hypothesis.getTree())) for (ExtendedNode textNode : TreeIterator.iterableTree(text.getTree()))
private void setLeaves() { for (BasicNode node : TreeIterator.iterableTree(tree)) { if (InfoGetFields.isVariable(node.getInfo())) { Integer varId = node.getInfo().getNodeInfo().getVariableId(); if (this.mapVariableIdToLeftRight.get(varId).booleanValue()) { this.leftVariableNode = node; } else { this.rightVariableNode = node; } } } }
private void buildContentLemmasOfHypothesis() { Set<S> hypothesisPredicateNodes = getPredicateNodes(hypothesisStructures); contentLemmasOfHypothesisNonPredicates_lowerCase = contentLemmasOfNodes_lowerCase(TreeIterator.iterableTree(hypothesisTree.getTree()),hypothesisPredicateNodes); contentLemmasOfHypothesisPredicates_lowerCase = contentLemmasOfNodes_lowerCase(hypothesisPredicateNodes); }
/** * Finds the nominal predicates in the parse tree. */ public void identify() { predicateHeads = new LinkedHashSet<S>(); for (S node : TreeIterator.iterableTree(tree.getTree())) { if (SimplerCanonicalPosTag.NOUN.equals(SimplerPosTagConvertor.simplerPos(InfoGetFields.getCanonicalPartOfSpeech(node.getInfo())))) { if (nomlexMap.keySet().contains(InfoGetFields.getLemma(node.getInfo()).trim().toLowerCase(Locale.ENGLISH))) { predicateHeads.add(node); } } } }