如何根据依赖解析器的输出创建一棵树？

我试图从依赖解析器的输出中创建一棵树（嵌套字典）。这句话是“我在睡梦中射杀了一头大象”。我能够获得链接中所述的输出：如何在 NLTK 中进行依存解析？ https://stackoverflow.com/questions/7443330/how-do-i-do-dependency-parsing-in-nltk

nsubj(shot-2, I-1)
det(elephant-4, an-3)
dobj(shot-2, elephant-4)
prep(shot-2, in-5)
poss(sleep-7, my-6)
pobj(in-5, sleep-7)

为了将此元组列表转换为嵌套字典，我使用了以下链接：如何将Python的元组列表转换为树？ https://stackoverflow.com/questions/39495924/how-to-convert-python-list-of-tuples-into-tree

def build_tree(list_of_tuples):
    all_nodes = {n[2]:((n[0], n[1]),{}) for n in list_of_tuples}
    root = {}    
    print all_nodes
    for item in list_of_tuples:
        rel, gov,dep = item
        if gov is not 'ROOT':
            all_nodes[gov][1][dep] = all_nodes[dep]
        else:
            root[dep] = all_nodes[dep]
    return root

输出如下：

{'shot': (('ROOT', 'ROOT'),
  {'I': (('nsubj', 'shot'), {}),
   'elephant': (('dobj', 'shot'), {'an': (('det', 'elephant'), {})}),
   'sleep': (('nmod', 'shot'),
    {'in': (('case', 'sleep'), {}), 'my': (('nmod:poss', 'sleep'), {})})})}

为了找到根到叶路径，我使用了以下链接：从嵌套字典树中将根返回到特定叶子 https://stackoverflow.com/questions/47302382/return-root-to-specific-leaf-from-a-nested-dictionary-tree

[制作树和查找路径是两件独立的事情]第二个目标是像完成的那样找到根到叶节点的路径从嵌套字典树中将根返回到特定叶子 https://stackoverflow.com/questions/47302382/return-root-to-specific-leaf-from-a-nested-dictionary-tree%5D。 但我想得到根到叶（依赖关系路径） 因此，例如，当我调用 recurse_category(categories, 'an') 时，其中categories 是嵌套树结构，'an' 是树中的单词，我应该得到ROOT-nsubj-dobj（依赖关系直到根）作为输出。

首先，如果您只是使用斯坦福 CoreNLP 依赖解析器的预训练模型，则应该使用CoreNLPDependencyParser from nltk.parse.corenlp并避免使用旧的nltk.parse.stanford界面。

See 斯坦福解析器和 NLTK https://stackoverflow.com/questions/13883277/stanford-parser-and-nltk/51981566#51981566

下载并在终端中运行 Java 服务器后，在 Python 中：

>>> from nltk.parse.corenlp import CoreNLPDependencyParser
>>> dep_parser = CoreNLPDependencyParser(url='http://localhost:9000')
>>> sent = "I shot an elephant with a banana .".split()
>>> parses = list(dep_parser.parse(sent))
>>> type(parses[0])
<class 'nltk.parse.dependencygraph.DependencyGraph'>

现在我们看到解析的类型DependencyGraph from nltk.parse.dependencygraph https://github.com/nltk/nltk/blob/develop/nltk/parse/dependencygraph.py#L36 https://github.com/nltk/nltk/blob/develop/nltk/parse/dependencygraph.py#L36

要转换DependencyGraph to a nltk.tree.Tree通过简单地做来反对DependencyGraph.tree():

>>> parses[0].tree()
Tree('shot', ['I', Tree('elephant', ['an']), Tree('banana', ['with', 'a']), '.'])

>>> parses[0].tree().pretty_print()
          shot                  
  _________|____________         
 |   |  elephant      banana    
 |   |     |       _____|_____   
 I   .     an    with         a 

要将其转换为括号解析格式：

>>> print(parses[0].tree())
(shot I (elephant an) (banana with a) .)

如果您正在寻找依赖三元组：

>>> [(governor, dep, dependent) for governor, dep, dependent in parses[0].triples()]
[(('shot', 'VBD'), 'nsubj', ('I', 'PRP')), (('shot', 'VBD'), 'dobj', ('elephant', 'NN')), (('elephant', 'NN'), 'det', ('an', 'DT')), (('shot', 'VBD'), 'nmod', ('banana', 'NN')), (('banana', 'NN'), 'case', ('with', 'IN')), (('banana', 'NN'), 'det', ('a', 'DT')), (('shot', 'VBD'), 'punct', ('.', '.'))]

>>> for governor, dep, dependent in parses[0].triples():
...     print(governor, dep, dependent)
... 
('shot', 'VBD') nsubj ('I', 'PRP')
('shot', 'VBD') dobj ('elephant', 'NN')
('elephant', 'NN') det ('an', 'DT')
('shot', 'VBD') nmod ('banana', 'NN')
('banana', 'NN') case ('with', 'IN')
('banana', 'NN') det ('a', 'DT')
('shot', 'VBD') punct ('.', '.')

在 CONLL 格式中：

>>> print(parses[0].to_conll(style=10))
1   I   I   PRP PRP _   2   nsubj   _   _
2   shot    shoot   VBD VBD _   0   ROOT    _   _
3   an  a   DT  DT  _   4   det _   _
4   elephant    elephant    NN  NN  _   2   dobj    _   _
5   with    with    IN  IN  _   7   case    _   _
6   a   a   DT  DT  _   7   det _   _
7   banana  banana  NN  NN  _   2   nmod    _   _
8   .   .   .   .   _   2   punct   _   _