web-dev-qa-db-fra.com

Comment puis-je effectuer une analyse de dépendance dans NLTK?

En parcourant le livre NLTK, il n'est pas clair comment générer un arbre de dépendance à partir d'une phrase donnée.

La section pertinente du livre: sous-chapitre sur la grammaire des dépendances donne un exemple de figure mais il ne montre pas comment analyser une phrase pour arriver à ces relations - ou peut-être que je manque quelque chose de fondamental dans la PNL?

EDIT: Je veux quelque chose de similaire à ce que le analyseur stanford : étant donné une phrase "J'ai tiré sur un éléphant dans mon sommeil" , il devrait renvoyer quelque chose comme:

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)
pythonnlpgrammarnltk
32
MrD

Nous pouvons utiliser Stanford Parser de NLTK.

Exigences

Vous devez télécharger deux choses depuis leur site Web:

  1. analyseur Stanford CoreNLP .
  2. modèle de langue pour la langue souhaitée (par exemple modèle de langue anglaise )

Avertissement!

Assurez-vous que la version de votre modèle de langue correspond à votre version de l'analyseur Stanford CoreNLP!

La version actuelle de CoreNLP au 22 mai 2018 est 3.9.1.

Après avoir téléchargé les deux fichiers, extrayez le fichier Zip où vous le souhaitez.

Code Python

Ensuite, chargez le modèle et utilisez-le via NLTK

from nltk.parse.stanford import StanfordDependencyParser

path_to_jar = 'path_to/stanford-parser-full-2014-08-27/stanford-parser.jar'
path_to_models_jar = 'path_to/stanford-parser-full-2014-08-27/stanford-parser-3.4.1-models.jar'

dependency_parser = StanfordDependencyParser(path_to_jar=path_to_jar, path_to_models_jar=path_to_models_jar)

result = dependency_parser.raw_parse('I shot an elephant in my sleep')
dep = result.next()

list(dep.triples())

Production

La sortie de la dernière ligne est:

[((u'shot', u'VBD'), u'nsubj', (u'I', u'PRP')),
 ((u'shot', u'VBD'), u'dobj', (u'elephant', u'NN')),
 ((u'elephant', u'NN'), u'det', (u'an', u'DT')),
 ((u'shot', u'VBD'), u'prep', (u'in', u'IN')),
 ((u'in', u'IN'), u'pobj', (u'sleep', u'NN')),
 ((u'sleep', u'NN'), u'poss', (u'my', u'PRP$'))]

Je pense que c'est ce que tu veux.

78
ywat

Si vous avez besoin de meilleures performances, alors spacy ( https://spacy.io/ ) est le meilleur choix. L'utilisation est très simple:

import spacy

nlp = spacy.load('en')
sents = nlp(u'A woman is walking through the door.')

Vous obtiendrez un arbre de dépendance en sortie, et vous pourrez extraire très facilement toutes les informations dont vous avez besoin. Vous pouvez également définir vos propres pipelines personnalisés. Voir plus sur leur site Web.

https://spacy.io/docs/usage/

7
Aleksandar Jovanovic

Je pense que vous pouvez utiliser un analyseur de dépendance basé sur un corpus au lieu de celui basé sur la grammaire que NLTK fournit.

Faire une analyse de dépendance basée sur un corpus sur une petite quantité de texte même en Python n'est pas idéal en termes de performances. Donc en NLTK, ils fournissent un wrapper to - MaltParser , un analyseur de dépendances basé sur un corpus.

Vous pourriez trouver cette autre question sur représentation RDF des phrases pertinente.

7
Neodawn

Si vous voulez être sérieux au sujet de l'analyse de dépendance, n'utilisez pas le NLTK, tous les algorithmes sont datés et lents. Essayez quelque chose comme ceci: https://spacy.io/

3
CpILL

Pour utiliser Stanford Parser de NLTK

1) Exécutez CoreNLP Server sur localhost
Téléchargez Stanford CoreNLP ici (et aussi le fichier modèle pour votre langue). Le serveur peut être démarré en exécutant la commande suivante (plus de détails ici )

# Run the server using all jars in the current directory (e.g., the CoreNLP home directory)
Java -mx4g -cp "*" edu.stanford.nlp.pipeline.StanfordCoreNLPServer -port 9000 -timeout 15000

ou par l'API NLTK (besoin de configurer le CORENLP_HOME variable d'environnement en premier)

os.environ["CORENLP_HOME"] = "dir"
client = corenlp.CoreNLPClient()
# do something
client.stop()

2) Appelez l'analyseur de dépendance à partir de NLTK 

>>> from nltk.parse.corenlp import CoreNLPDependencyParser
>>> dep_parser = CoreNLPDependencyParser(url='http://localhost:9000')
>>> parse, = dep_parser.raw_parse(
...     'The quick brown fox jumps over the lazy dog.'
... )
>>> print(parse.to_conll(4))  
The     DT      4       det
quick   JJ      4       amod
brown   JJ      4       amod
fox     NN      5       nsubj
jumps   VBZ     0       ROOT
over    IN      9       case
the     DT      9       det
lazy    JJ      9       amod
dog     NN      5       nmod
.       .       5       punct

Voir détail documentation ici , également cette question NLTK CoreNLPDependencyParser: Échec de l'établissement de la connexion .

2
dontloo

D'après la documentation de Stanford Parser: "les dépendances peuvent être obtenues en utilisant notre logiciel [...] sur des arborescences de structures de phrases en utilisant la classe EnglishGrammaticalStructure disponible dans le package de l'analyseur." http://nlp.stanford.edu/software/stanford-dependencies.shtml

Le manuel des dépendances mentionne également: "Ou notre outil de conversion peut convertir la sortie d'autres analyseurs de circonscription en représentation de Stanford Dependencies." http://nlp.stanford.edu/software/dependencies_manual.pdf

Aucune fonctionnalité ne semble actuellement implémentée dans NLTK.

1
Josep Valls

Un peu tard pour la fête, mais je voulais ajouter un exemple de code avec SpaCy qui vous donne la sortie souhaitée:

import spacy
nlp = spacy.load("en_core_web_sm")
doc = nlp("I shot an elephant in my sleep")
for token in doc:
    print("{2}({3}-{6}, {0}-{5})".format(token.text, token.tag_, token.dep_, token.head.text, token.head.tag_, token.i+1, token.head.i+1))

Et voici la sortie, très similaire à la sortie souhaitée:

nsubj(shot-2, I-1)
ROOT(shot-2, shot-2)
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)

J'espère que cela pourra aider!

0
cheevahagadog