Comment obtenir l'arbre de dépendance avec spaCy?

si quelqu'un veut voir facilement l'arbre des dépendances produit par spacy, une solution serait de le convertir en une" 151970920 nltk.tree.Tree et d'utiliser la nltk.tree.Tree.pretty_print méthode. Voici un exemple:

import spacy
from nltk import Tree


en_nlp = spacy.load('en')

doc = en_nlp("The quick brown fox jumps over the lazy dog.")

def to_nltk_tree(node):
    if node.n_lefts + node.n_rights > 0:
        return Tree(node.orth_, [to_nltk_tree(child) for child in node.children])
    else:
        return node.orth_


[to_nltk_tree(sent.root).pretty_print() for sent in doc.sents]

sortie:

                jumps                  
  ________________|____________         
 |    |     |     |    |      over     
 |    |     |     |    |       |        
 |    |     |     |    |      dog      
 |    |     |     |    |    ___|____    
The quick brown  fox   .  the      lazy

modifier: pour changer la représentation de token vous pouvez faire ceci:

def tok_format(tok):
    return "_".join([tok.orth_, tok.tag_])


def to_nltk_tree(node):
    if node.n_lefts + node.n_rights > 0:
        return Tree(tok_format(node), [to_nltk_tree(child) for child in node.children])
    else:
        return tok_format(node)

qui se traduit par:

                         jumps_VBZ                           
   __________________________|___________________             
  |       |        |         |      |         over_IN        
  |       |        |         |      |            |            
  |       |        |         |      |          dog_NN        
  |       |        |         |      |     _______|_______     
The_DT quick_JJ brown_JJ   fox_NN  ._. the_DT         lazy_JJ

l'arbre n'est pas un objet en soi; il suffit de le parcourir à travers les relations entre les jetons. C'est pourquoi les docs parler de naviguer dans l'arbre, mais pas "arriver".

D'abord, analysons quelques textes pour obtenir un Doc objet:

>>> import spacy
>>> nlp = spacy.load('en')
>>> doc = nlp('First, I wrote some sentences. Then spaCy parsed them. Hooray!')

doc est un Sequence de Token objets:

>>> doc[0]
First
>>> doc[1]
,
>>> doc[2]
I
>>> doc[3]
wrote

mais il n'a pas un seul jeton de racine. Nous avons analysé un texte composé de trois phrases, donc il y a trois arbres distincts, chacun avec sa propre racine. Si nous voulons commencer notre analyse à partir de la racine de chaque phrase, il vous aidera à obtenir les phrases comme des objets distincts, d'abord. Heureusement, doc nous les expose via la .sents propriété:

>>> sentences = list(doc.sents)
>>> for sentence in sentences:
...     print(sentence)
... 
First, I wrote some sentences.
Then spaCy parsed them.
Hooray!

chacune de ces phrases est une Span avec une propriété .root pointant vers son jeton racine. Habituellement, le jeton de racine sera le verbe principal de la phrase (bien que cela ne soit pas nécessairement vrai pour les structures de phrase inhabituelles, telles que les phrases sans verbe):

>>> for sentence in sentences:
...     print(sentence.root)
... 
wrote
parsed
Hooray

avec le jeton racine trouvé, nous pouvons naviguer le long de l'arbre via la propriété .children de chaque jeton. Par exemple, trouvons le sujet et l'objet du verbe dans la première phrase. La .dep_ propriété de chaque jeton d'enfant décrit sa relation avec son parent ; par exemple un dep_ de 'nsubj' signifie qu'un jeton est le sujet nominal de son parent.

>>> root_token = sentences[0].root
>>> for child in root_token.children:
...     if child.dep_ == 'nsubj':
...         subj = child
...     if child.dep_ == 'dobj':
...         obj = child
... 
>>> subj
I
>>> obj
sentences

nous pouvons également continuer à descendre l'arbre en regardant l'un des enfants de ces Tokens:

>>> list(obj.children)
[some]

ainsi avec les propriétés ci-dessus, vous pouvez naviguer dans l'arbre entier. Si vous souhaitez visualiser certains arbres de dépendances par exemple des phrases pour vous aider à comprendre la structure, je vous recommande de jouer avec displaCy .

j'avais aussi besoin de le faire en dessous du code complet:

import sys
def showTree(sent):
    def __showTree(token):
        sys.stdout.write("{")
        [__showTree(t) for t in token.lefts]
        sys.stdout.write("%s->%s(%s)" % (token,token.dep_,token.tag_))
        [__showTree(t) for t in token.rights]
        sys.stdout.write("}")
    return __showTree(sent.root)

et si vous voulez l'espacement pour le terminal:

def showTree(sent):
    def __showTree(token, level):
        tab = "\t" * level
        sys.stdout.write("\n%s{" % (tab))
        [__showTree(t, level+1) for t in token.lefts]
        sys.stdout.write("\n%s\t%s [%s] (%s)" % (tab,token,token.dep_,token.tag_))
        [__showTree(t, level+1) for t in token.rights]
        sys.stdout.write("\n%s}" % (tab))
    return __showTree(sent.root, 1)

vous pouvez utiliser la bibliothèque ci-dessous pour voir votre arbre de dépendances, il a trouvé extrêmement utile!

from spacy import displacy

nlp = spacy.load('en')
doc = nlp(u'This is a sentence.')
displacy.serve(doc, style='dep')

je n'ai pas suffisamment de connaissances sur l'analyse encore. Toutefois, les résultats de mon étude documentaire ont permis de savoir que spaCy possède un algorithme d'analyse de la dépendance par déplacement-réduction. Cela analyse la question / phrase, ce qui donne un arbre d'analyse. Pour visualiser cela, vous pouvez utiliser la DisplaCy, combinaison de CSS et Javascript, fonctionne avec Python et Cython. En outre, vous pouvez analyser en utilisant la bibliothèque SpaCy, et importer la boîte à outils du langage naturel (NLTK). Espérons que cette aide