python - guia - ¿Cómo obtener el árbol de dependencias con SpaCy?

qgis manual

Question

He estado tratando de encontrar cómo obtener el árbol de dependencias con spaCy pero no encuentro nada sobre cómo obtener el árbol, solo sobre cómo navegar el árbol .

Answer 1

Aún no tengo suficiente conocimiento sobre el análisis sintáctico. Sin embargo, el resultado de mi estudio de literatura ha resultado en saber que spaCy tiene un algoritmo de análisis de dependencia shift-reduce. Esto analiza la pregunta / oración, lo que da como resultado un árbol de análisis sintáctico. Para visualizar esto, puede usar DisplaCy, combinación de CSS y Javascript, funciona con Python y Cython. Además, puede analizar utilizando la biblioteca SpaCy e importar el kit de herramientas de lenguaje natural (NLTK). Espero que esto ayude

Answer 2

El árbol no es un objeto en sí mismo; simplemente navega por las relaciones entre tokens. Es por eso que los documentos hablan de navegar el árbol, pero no de "obtenerlo".

Primero, analicemos un texto para obtener un objeto Doc :

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

doc es una Sequence de objetos Token :

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

Pero no tiene un solo token de raíz. Analizamos un texto compuesto por tres oraciones, por lo que hay tres árboles distintos, cada uno con su propia raíz. Si queremos comenzar nuestro análisis sintáctico desde la raíz de cada oración, primero será útil obtener las oraciones como objetos distintos. Afortunadamente, el doc expone a nosotros a través de la propiedad .sents :

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

Cada una de estas oraciones es un Span con una propiedad .root apunta a su token de raíz. Por lo general, el token de raíz será el verbo principal de la oración (aunque esto puede no ser cierto para las estructuras de oraciones inusuales, como las oraciones sin un verbo):

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

Con el token de raíz encontrado, podemos navegar por el árbol a través de la propiedad .children de cada token. Por ejemplo, busquemos el sujeto y el objeto del verbo en la primera oración. La propiedad .dep_ de cada token de niño describe su relación con su padre ; por ejemplo, un dep_ de ''nsubj'' significa que un token es el sujeto nominal de su padre.

>>> 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

También podemos seguir descendiendo por el árbol al ver a uno de estos hijos de tokens:

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

Por lo tanto, con las propiedades anteriores, puede navegar por todo el árbol. Si desea visualizar algunos árboles de dependencia, por ejemplo, oraciones que lo ayuden a comprender la estructura, le recomiendo jugar con displaCy .

Answer 3

Puede usar la biblioteca a continuación para ver su árbol de dependencias, ¡lo encontró extremadamente útil!

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

Answer 4

Resulta que el árbol está disponible a través de los tokens en un documento.

¿Te gustaría encontrar la raíz del árbol? Puedes ir a través del documento:

def find_root(docu):
for token in docu:
if token.head is token:
return token

Para navegar en el árbol, los tokens tienen API para pasar a los niños

Answer 5

También necesitaba hacerlo debajo del código completo:

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)

Y si quieres espacio para la 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)

Answer 6

En caso de que alguien quiera ver fácilmente el árbol de dependencias producido por spacy, una solución sería convertirlo a nltk.tree.Tree y usar el método nltk.tree.Tree.pretty_print . Aquí hay un ejemplo:

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]

Salida:

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

Editar: para cambiar la representación del token puede hacer esto:

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)

Lo que resulta en:

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