Est-il possible d'utiliser Stanford Parser dans NLTK? (Je ne parle pas de Stanford POS.)

Notez que cette réponse s'applique à NLTK v 3.0 et non aux versions plus récentes.

Bien sûr, essayez ce qui suit en Python:

import os
from nltk.parse import stanford
os.environ['STANFORD_PARSER'] = '/path/to/standford/jars'
os.environ['STANFORD_MODELS'] = '/path/to/standford/jars'

parser = stanford.StanfordParser(model_path="/location/of/the/englishPCFG.ser.gz")
sentences = parser.raw_parse_sents(("Hello, My name is Melroy.", "What is your name?"))
print sentences

# GUI
for line in sentences:
    for sentence in line:
        sentence.draw()

Production:

[Tree ('ROOT', [Tree ('S' ', [Tree (' INTJ '', [Tree ('UH' ', [' Hello '])]), Tree (', ', [', ']), Tree ('NP', [Tree ('PRP $' ', [' My ']), Tree (' NN ', [' name '])]), Tree (' VP ', [Tree (' VBZ ', [ 'est']), Tree ('ADJP', [Tree ('JJ', ['Melroy'])])]), Tree ('.', ['.'])])]), Tree (' ROOT ', [Tree (' SBARQ ', [Tree (' WHNP ', [Tree (' WP '', ['What'])]), Tree ('SQ', [Tree ('VBZ', ['is' ]), Tree ('NP', [Tree ('PRP $', ['your']), Tree ('NN', ['name'])])]), Tree ('.', ['? '])])])]

Remarque 1: Dans cet exemple, l'analyseur et les fichiers JAR du modèle se trouvent dans le même dossier.

Note 2:

• Le nom de fichier de stanford parser est: stanford-parser.jar
• Le nom de fichier des modèles stanford est: stanford-parser-xxx-models.jar

Remarque 3: Le fichier englishPCFG.ser.gz se trouve dans le fichier models.jar (/edu/stanford/nlp/models/lexparser/englishPCFG.ser.gz). Veuillez utiliser le gestionnaire d'archives come pour «décompresser» le fichier models.jar.

Remarque 4: assurez-vous que vous utilisez Java JRE (Runtime Environment) 1.8 également connu sous le nom d'Oracle JDK 8. Sinon, vous obtiendrez: Unsupported major.minor version 52.0.

Installation

1. Téléchargez NLTK v3 depuis: https://github.com/nltk/nltk . Et installez NLTK:

   installation sudo python setup.py

2. Vous pouvez utiliser le téléchargeur NLTK pour obtenir Stanford Parser, en utilisant Python:

   import nltk
   nltk.download()
   

3. Essayez mon exemple! (n'oubliez pas de changer les chemins de jar et de changer le chemin du modèle à l'emplacement ser.gz)

OU:

1. Téléchargez et installez NLTK v3, comme ci-dessus.

2. Téléchargez la dernière version sur ( le nom de fichier de la version actuelle est stanford-parser-full-2015-01-29.zip): http://nlp.stanford.edu/software/lex-parser.shtml#Download

3. Extrayez le fichier standford-parser-full-20xx-xx-xx.zip.

4. Créez un nouveau dossier ('jars' dans mon exemple). Placez les fichiers extraits dans ce dossier jar: stanford-parser-3.xx-models.jar et stanford-parser.jar.

   Comme indiqué ci-dessus, vous pouvez utiliser les variables d'environnement (STANFORD_PARSER & STANFORD_MODELS) pour pointer vers ce dossier 'jars'. J'utilise Linux, donc si vous utilisez Windows, veuillez utiliser quelque chose comme: C: // dossier // jars.

5. Ouvrez le fichier stanford-parser-3.xx-models.jar à l'aide d'un gestionnaire d'archives (7zip).

6. Naviguez dans le fichier jar; edu / stanford / nlp / models / lexparser. Encore une fois, extrayez le fichier appelé «englishPCFG.ser.gz». Souvenez-vous de l'emplacement où vous extrayez ce fichier ser.gz.

7. Lors de la création d'une instance StanfordParser, vous pouvez fournir le chemin du modèle en tant que paramètre. C'est le chemin complet vers le modèle, dans notre cas /location/of/englishPCFG.ser.gz.

8. Essayez mon exemple! (n'oubliez pas de changer les chemins de jar et de changer le chemin du modèle à l'emplacement ser.gz)

Réponse obsolète

La réponse ci-dessous est obsolète, veuillez utiliser la solution sur https://stackoverflow.com/a/51981566/610569 pour NLTK v3.3 et supérieur.

ÉDITÉ

Remarque: La réponse suivante ne fonctionnera que sur:

• Version NLTK> = 3.2.4
• Stanford Tools compilé depuis le 20/04/2015
• Python 2.7, 3.4 et 3.5 (Python 3.6 n'est pas encore officiellement pris en charge)

Comme les deux outils changent assez rapidement et que l'API peut sembler très différente 3 à 6 mois plus tard. Veuillez traiter la réponse suivante comme une solution temporelle et non éternelle.

Référez-vous toujours à https://github.com/nltk/nltk/wiki/Installing-Third-Party-Software pour les dernières instructions sur la façon d'interfacer les outils de Stanford NLP en utilisant NLTK !!

TL; DR

cd $HOME

# Update / Install NLTK
pip install -U nltk

# Download the Stanford NLP tools
wget http://nlp.stanford.edu/software/stanford-ner-2015-04-20.zip
wget http://nlp.stanford.edu/software/stanford-postagger-full-2015-04-20.zip
wget http://nlp.stanford.edu/software/stanford-parser-full-2015-04-20.zip
# Extract the zip file.
unzip stanford-ner-2015-04-20.zip 
unzip stanford-parser-full-2015-04-20.zip 
unzip stanford-postagger-full-2015-04-20.zip


export STANFORDTOOLSDIR=$HOME

export CLASSPATH=$STANFORDTOOLSDIR/stanford-postagger-full-2015-04-20/stanford-postagger.jar:$STANFORDTOOLSDIR/stanford-ner-2015-04-20/stanford-ner.jar:$STANFORDTOOLSDIR/stanford-parser-full-2015-04-20/stanford-parser.jar:$STANFORDTOOLSDIR/stanford-parser-full-2015-04-20/stanford-parser-3.5.2-models.jar

export STANFORD_MODELS=$STANFORDTOOLSDIR/stanford-postagger-full-2015-04-20/models:$STANFORDTOOLSDIR/stanford-ner-2015-04-20/classifiers

Ensuite:

>>> from nltk.tag.stanford import StanfordPOSTagger
>>> st = StanfordPOSTagger('english-bidirectional-distsim.tagger')
>>> st.tag('What is the airspeed of an unladen swallow ?'.split())
[(u'What', u'WP'), (u'is', u'VBZ'), (u'the', u'DT'), (u'airspeed', u'NN'), (u'of', u'IN'), (u'an', u'DT'), (u'unladen', u'JJ'), (u'swallow', u'VB'), (u'?', u'.')]

>>> from nltk.tag import StanfordNERTagger
>>> st = StanfordNERTagger('english.all.3class.distsim.crf.ser.gz') 
>>> st.tag('Rami Eid is studying at Stony Brook University in NY'.split())
[(u'Rami', u'PERSON'), (u'Eid', u'PERSON'), (u'is', u'O'), (u'studying', u'O'), (u'at', u'O'), (u'Stony', u'ORGANIZATION'), (u'Brook', u'ORGANIZATION'), (u'University', u'ORGANIZATION'), (u'in', u'O'), (u'NY', u'O')]


>>> from nltk.parse.stanford import StanfordParser
>>> parser=StanfordParser(model_path="edu/stanford/nlp/models/lexparser/englishPCFG.ser.gz")
>>> list(parser.raw_parse("the quick brown fox jumps over the lazy dog"))
[Tree('ROOT', [Tree('NP', [Tree('NP', [Tree('DT', ['the']), Tree('JJ', ['quick']), Tree('JJ', ['brown']), Tree('NN', ['fox'])]), Tree('NP', [Tree('NP', [Tree('NNS', ['jumps'])]), Tree('PP', [Tree('IN', ['over']), Tree('NP', [Tree('DT', ['the']), Tree('JJ', ['lazy']), Tree('NN', ['dog'])])])])])])]

>>> from nltk.parse.stanford import StanfordDependencyParser
>>> dep_parser=StanfordDependencyParser(model_path="edu/stanford/nlp/models/lexparser/englishPCFG.ser.gz")
>>> print [parse.tree() for parse in dep_parser.raw_parse("The quick brown fox jumps over the lazy dog.")]
[Tree('jumps', [Tree('fox', ['The', 'quick', 'brown']), Tree('dog', ['over', 'the', 'lazy'])])]

En long:

Tout d'abord , il faut noter que les outils de Stanford NLP sont écrits en Java et NLTK est écrit en Python . La façon dont NLTK interagit avec l'outil consiste à appeler l'outil Java via l'interface de ligne de commande.

Deuxièmement , l' NLTKAPI des outils PNL de Stanford a beaucoup changé depuis la version 3.1. Il est donc conseillé de mettre à jour votre package NLTK vers la v3.1.

Troisièmement , l' NLTKAPI de Stanford NLP Tools s'enroule autour des outils PNL individuels, par exemple Stanford POS tagger , Stanford NER Tagger , Stanford Parser .

Pour le tagger POS et NER, il N'enroule PAS le package PNL Stanford Core .

Pour le Stanford Parser, c'est un cas particulier où il englobe à la fois le Stanford Parser et le Stanford Core NLP (personnellement, je n'ai pas utilisé ce dernier en utilisant NLTK, je préférerais suivre la démonstration de @ dimazest sur http: //www.eecs. qmul.ac.uk/~dm303/stanford-dependency-parser-nltk-and-anaconda.html )

Notez qu'à partir de NLTK v3.1, les variables STANFORD_JARet STANFORD_PARSERsont obsolètes et ne sont PLUS utilisées

En plus:

ÉTAPE 1

En supposant que vous avez correctement installé Java sur votre système d'exploitation.

Maintenant, installez / mettez à jour votre version NLTK (voir http://www.nltk.org/install.html ):

• Utilisation de pip :sudo pip install -U nltk
• Debian distro (en utilisant apt-get):sudo apt-get install python-nltk

Pour Windows (utilisez l'installation binaire 32 bits):

1. Installez Python 3.4: http://www.python.org/downloads/ (évitez les versions 64 bits)
2. Installez Numpy (facultatif): http://sourceforge.net/projects/numpy/files/NumPy/ (la version qui spécifie pythnon3.4)
3. Installez NLTK: http://pypi.python.org/pypi/nltk
4. Tester l'installation: Démarrer> Python34, puis tapez import nltk

( Pourquoi pas 64 bits? Voir https://github.com/nltk/nltk/issues/1079 )

Puis par paranoïa, revérifiez votre nltkversion à l'intérieur de python:

from __future__ import print_function
import nltk
print(nltk.__version__)

Ou sur la ligne de commande:

python3 -c "import nltk; print(nltk.__version__)"

Assurez-vous que vous voyez 3.1comme la sortie.

Pour encore plus de paranoïa, vérifiez que toutes vos API d'outils de PNL de Stanford préférées sont disponibles:

from nltk.parse.stanford import StanfordParser
from nltk.parse.stanford import StanfordDependencyParser
from nltk.parse.stanford import StanfordNeuralDependencyParser
from nltk.tag.stanford import StanfordPOSTagger, StanfordNERTagger
from nltk.tokenize.stanford import StanfordTokenizer

( Remarque : les importations ci-dessus garantiront UNIQUEMENT que vous utilisez une version NLTK correcte contenant ces API. Ne pas voir d'erreurs dans l'importation ne signifie pas que vous avez correctement configuré l'API NLTK pour utiliser les outils de Stanford)

ÉTAPE 2

Maintenant que vous avez vérifié que vous disposez de la version correcte de NLTK qui contient l'interface des outils Stanford NLP nécessaire. Vous devez télécharger et extraire tous les outils NLP Stanford nécessaires.

TL; DR , sous Unix:

cd $HOME

# Download the Stanford NLP tools
wget http://nlp.stanford.edu/software/stanford-ner-2015-04-20.zip
wget http://nlp.stanford.edu/software/stanford-postagger-full-2015-04-20.zip
wget http://nlp.stanford.edu/software/stanford-parser-full-2015-04-20.zip
# Extract the zip file.
unzip stanford-ner-2015-04-20.zip 
unzip stanford-parser-full-2015-04-20.zip 
unzip stanford-postagger-full-2015-04-20.zip

Sous Windows / Mac:

• Téléchargez et décompressez l'analyseur à partir de http://nlp.stanford.edu/software/lex-parser.shtml#Download
• Téléchargez et décompressez le tagger FULL VERSION depuis http://nlp.stanford.edu/software/tagger.shtml#Download
• Téléchargez et unizp le tagger NER à partir de http://nlp.stanford.edu/software/CRF-NER.shtml#Download

ÉTAPE 3

Configurez les variables d'environnement de sorte que NLTK puisse trouver automatiquement le chemin du fichier approprié. Vous devez définir les variables suivantes:

• Ajoutez le .jarfichier NLP Stanford approprié à la CLASSPATHvariable d'environnement.

  • par exemple pour le NER, ce sera stanford-ner-2015-04-20/stanford-ner.jar
  • par exemple pour le POS, ce sera stanford-postagger-full-2015-04-20/stanford-postagger.jar
  • par exemple pour l'analyseur, ce sera stanford-parser-full-2015-04-20/stanford-parser.jarle fichier jar et le modèle de l'analyseur,stanford-parser-full-2015-04-20/stanford-parser-3.5.2-models.jar

• Ajoutez le répertoire de modèle approprié à la STANFORD_MODELSvariable (c'est-à-dire le répertoire où vous pouvez trouver où les modèles pré-entraînés sont enregistrés)

  • par exemple pour le NER, ce sera dans stanford-ner-2015-04-20/classifiers/
  • par exemple pour le POS, ce sera dans stanford-postagger-full-2015-04-20/models/
  • par exemple pour l'analyseur, il n'y aura pas de répertoire de modèle.

Dans le code, voyez qu'il recherche le STANFORD_MODELSrépertoire avant d'ajouter le nom du modèle. Voir aussi que, l'API essaie également automatiquement de rechercher dans les environnements OS pour le `CLASSPATH )

Notez qu'à partir de NLTK v3.1, les STANFORD_JARvariables sont obsolètes et ne sont PLUS utilisées . Les extraits de code trouvés dans les questions Stackoverflow suivantes peuvent ne pas fonctionner:

• Configuration de l'analyseur de dépendances de Stanford et NLTK
• interface nltk vers l'analyseur de Stanford
• problème lors de l'importation de stanford pos tagger dans nltk
• Reconnaissance d'entité Stanford (sans casse) en Python Nltk
• Comment améliorer la vitesse avec Stanford NLP Tagger et NLTK
• Comment puis-je obtenir le module python stanford NLTK?
• Fenêtres Stanford Parser et NLTK
• Fonctionnalité de Stanford Named Entity Recognizer (NER) avec NLTK
• L'analyseur de Stanford avec NLTK produit une sortie vide
• Extraire la liste des personnes et des organisations utilisant Stanford NER Tagger dans NLTK
• Erreur lors de l'utilisation de Stanford POS Tagger dans NLTK Python

TL; DR pour STEP 3 sur Ubuntu

export STANFORDTOOLSDIR=/home/path/to/stanford/tools/

export CLASSPATH=$STANFORDTOOLSDIR/stanford-postagger-full-2015-04-20/stanford-postagger.jar:$STANFORDTOOLSDIR/stanford-ner-2015-04-20/stanford-ner.jar:$STANFORDTOOLSDIR/stanford-parser-full-2015-04-20/stanford-parser.jar:$STANFORDTOOLSDIR/stanford-parser-full-2015-04-20/stanford-parser-3.5.2-models.jar

export STANFORD_MODELS=$STANFORDTOOLSDIR/stanford-postagger-full-2015-04-20/models:$STANFORDTOOLSDIR/stanford-ner-2015-04-20/classifiers

( Pour Windows : voir https://stackoverflow.com/a/17176423/610569 pour obtenir des instructions sur la définition des variables d'environnement)

Vous DEVEZ définir les variables comme ci-dessus avant de démarrer python, puis:

>>> from nltk.tag.stanford import StanfordPOSTagger
>>> st = StanfordPOSTagger('english-bidirectional-distsim.tagger')
>>> st.tag('What is the airspeed of an unladen swallow ?'.split())
[(u'What', u'WP'), (u'is', u'VBZ'), (u'the', u'DT'), (u'airspeed', u'NN'), (u'of', u'IN'), (u'an', u'DT'), (u'unladen', u'JJ'), (u'swallow', u'VB'), (u'?', u'.')]

>>> from nltk.tag import StanfordNERTagger
>>> st = StanfordNERTagger('english.all.3class.distsim.crf.ser.gz') 
>>> st.tag('Rami Eid is studying at Stony Brook University in NY'.split())
[(u'Rami', u'PERSON'), (u'Eid', u'PERSON'), (u'is', u'O'), (u'studying', u'O'), (u'at', u'O'), (u'Stony', u'ORGANIZATION'), (u'Brook', u'ORGANIZATION'), (u'University', u'ORGANIZATION'), (u'in', u'O'), (u'NY', u'O')]


>>> from nltk.parse.stanford import StanfordParser
>>> parser=StanfordParser(model_path="edu/stanford/nlp/models/lexparser/englishPCFG.ser.gz")
>>> list(parser.raw_parse("the quick brown fox jumps over the lazy dog"))
[Tree('ROOT', [Tree('NP', [Tree('NP', [Tree('DT', ['the']), Tree('JJ', ['quick']), Tree('JJ', ['brown']), Tree('NN', ['fox'])]), Tree('NP', [Tree('NP', [Tree('NNS', ['jumps'])]), Tree('PP', [Tree('IN', ['over']), Tree('NP', [Tree('DT', ['the']), Tree('JJ', ['lazy']), Tree('NN', ['dog'])])])])])])]

Vous pouvez également essayer d'ajouter les variables d'environnement à l'intérieur de python, comme l'ont suggéré les réponses précédentes, mais vous pouvez également dire directement à l'analyseur / tagueur de s'initialiser sur le chemin direct où vous avez conservé le .jarfichier et vos modèles.

Il n'est PAS nécessaire de définir les variables d'environnement si vous utilisez la méthode suivante MAIS lorsque l'API change ses noms de paramètres, vous devrez changer en conséquence. C'est pourquoi il est PLUS conseillé de définir les variables d'environnement que de modifier votre code python pour l'adapter à la version NLTK.

Par exemple ( sans définir de variables d'environnement ):

# POS tagging:

from nltk.tag import StanfordPOSTagger

stanford_pos_dir = '/home/alvas/stanford-postagger-full-2015-04-20/'
eng_model_filename= stanford_pos_dir + 'models/english-left3words-distsim.tagger'
my_path_to_jar= stanford_pos_dir + 'stanford-postagger.jar'

st = StanfordPOSTagger(model_filename=eng_model_filename, path_to_jar=my_path_to_jar) 
st.tag('What is the airspeed of an unladen swallow ?'.split())


# NER Tagging:
from nltk.tag import StanfordNERTagger

stanford_ner_dir = '/home/alvas/stanford-ner/'
eng_model_filename= stanford_ner_dir + 'classifiers/english.all.3class.distsim.crf.ser.gz'
my_path_to_jar= stanford_ner_dir + 'stanford-ner.jar'

st = StanfordNERTagger(model_filename=eng_model_filename, path_to_jar=my_path_to_jar) 
st.tag('Rami Eid is studying at Stony Brook University in NY'.split())

# Parsing:
from nltk.parse.stanford import StanfordParser

stanford_parser_dir = '/home/alvas/stanford-parser/'
eng_model_path = stanford_parser_dir  + "edu/stanford/nlp/models/lexparser/englishRNN.ser.gz"
my_path_to_models_jar = stanford_parser_dir  + "stanford-parser-3.5.2-models.jar"
my_path_to_jar = stanford_parser_dir  + "stanford-parser.jar"

parser=StanfordParser(model_path=eng_model_path, path_to_models_jar=my_path_to_models_jar, path_to_jar=my_path_to_jar)

Réponse obsolète

La réponse ci-dessous est obsolète, veuillez utiliser la solution sur https://stackoverflow.com/a/51981566/610569 pour NLTK v3.3 et supérieur.

Édité

À partir de l'analyseur de Stanford actuel (20/04/2015), la sortie par défaut pour le lexparser.sha changé et le script ci-dessous ne fonctionnera pas.

Mais cette réponse est conservée pour l'héritage, elle fonctionnera toujours avec http://nlp.stanford.edu/software/stanford-parser-2012-11-12.zip .

Réponse originale

Je vous suggère de ne pas jouer avec Jython, JPype. Laisser python faire des trucs python et laisser java faire des trucs java, obtenir la sortie de Stanford Parser via la console.

Après avoir installé le Stanford Parser dans votre répertoire personnel ~/, utilisez simplement cette recette python pour obtenir l'analyse entre crochets plats:

import os
sentence = "this is a foo bar i want to parse."

os.popen("echo '"+sentence+"' > ~/stanfordtemp.txt")
parser_out = os.popen("~/stanford-parser-2012-11-12/lexparser.sh ~/stanfordtemp.txt").readlines()

bracketed_parse = " ".join( [i.strip() for i in parser_out if i.strip()[0] == "("] )
print bracketed_parse

À partir de NLTK v3.3, les utilisateurs doivent éviter les marqueurs Stanford NER ou POS nltk.taget éviter le tokenizer / segmenter Stanford nltk.tokenize.

Utilisez plutôt la nouvelle nltk.parse.corenlp.CoreNLPParserAPI.

Veuillez consulter https://github.com/nltk/nltk/wiki/Stanford-CoreNLP-API-in-NLTK

(En évitant la réponse aux liens uniquement, j'ai collé les documents du wiki NLTK github ci-dessous)

Tout d'abord, mettez à jour votre NLTK

pip3 install -U nltk # Make sure is >=3.3

Ensuite, téléchargez les packages CoreNLP nécessaires:

cd ~
wget http://nlp.stanford.edu/software/stanford-corenlp-full-2018-02-27.zip
unzip stanford-corenlp-full-2018-02-27.zip
cd stanford-corenlp-full-2018-02-27

# Get the Chinese model 
wget http://nlp.stanford.edu/software/stanford-chinese-corenlp-2018-02-27-models.jar
wget https://raw.githubusercontent.com/stanfordnlp/CoreNLP/master/src/edu/stanford/nlp/pipeline/StanfordCoreNLP-chinese.properties 

# Get the Arabic model
wget http://nlp.stanford.edu/software/stanford-arabic-corenlp-2018-02-27-models.jar
wget https://raw.githubusercontent.com/stanfordnlp/CoreNLP/master/src/edu/stanford/nlp/pipeline/StanfordCoreNLP-arabic.properties 

# Get the French model
wget http://nlp.stanford.edu/software/stanford-french-corenlp-2018-02-27-models.jar
wget https://raw.githubusercontent.com/stanfordnlp/CoreNLP/master/src/edu/stanford/nlp/pipeline/StanfordCoreNLP-french.properties 

# Get the German model
wget http://nlp.stanford.edu/software/stanford-german-corenlp-2018-02-27-models.jar
wget https://raw.githubusercontent.com/stanfordnlp/CoreNLP/master/src/edu/stanford/nlp/pipeline/StanfordCoreNLP-german.properties 


# Get the Spanish model
wget http://nlp.stanford.edu/software/stanford-spanish-corenlp-2018-02-27-models.jar
wget https://raw.githubusercontent.com/stanfordnlp/CoreNLP/master/src/edu/stanford/nlp/pipeline/StanfordCoreNLP-spanish.properties 

Anglais

Toujours dans le stanford-corenlp-full-2018-02-27répertoire, démarrez le serveur:

java -mx4g -cp "*" edu.stanford.nlp.pipeline.StanfordCoreNLPServer \
-preload tokenize,ssplit,pos,lemma,ner,parse,depparse \
-status_port 9000 -port 9000 -timeout 15000 & 

Puis en Python:

>>> from nltk.parse import CoreNLPParser

# Lexical Parser
>>> parser = CoreNLPParser(url='http://localhost:9000')

# Parse tokenized text.
>>> list(parser.parse('What is the airspeed of an unladen swallow ?'.split()))
[Tree('ROOT', [Tree('SBARQ', [Tree('WHNP', [Tree('WP', ['What'])]), Tree('SQ', [Tree('VBZ', ['is']), Tree('NP', [Tree('NP', [Tree('DT', ['the']), Tree('NN', ['airspeed'])]), Tree('PP', [Tree('IN', ['of']), Tree('NP', [Tree('DT', ['an']), Tree('JJ', ['unladen'])])]), Tree('S', [Tree('VP', [Tree('VB', ['swallow'])])])])]), Tree('.', ['?'])])])]

# Parse raw string.
>>> list(parser.raw_parse('What is the airspeed of an unladen swallow ?'))
[Tree('ROOT', [Tree('SBARQ', [Tree('WHNP', [Tree('WP', ['What'])]), Tree('SQ', [Tree('VBZ', ['is']), Tree('NP', [Tree('NP', [Tree('DT', ['the']), Tree('NN', ['airspeed'])]), Tree('PP', [Tree('IN', ['of']), Tree('NP', [Tree('DT', ['an']), Tree('JJ', ['unladen'])])]), Tree('S', [Tree('VP', [Tree('VB', ['swallow'])])])])]), Tree('.', ['?'])])])]

# Neural Dependency Parser
>>> from nltk.parse.corenlp import CoreNLPDependencyParser
>>> dep_parser = CoreNLPDependencyParser(url='http://localhost:9000')
>>> parses = dep_parser.parse('What is the airspeed of an unladen swallow ?'.split())
>>> [[(governor, dep, dependent) for governor, dep, dependent in parse.triples()] for parse in parses]
[[(('What', 'WP'), 'cop', ('is', 'VBZ')), (('What', 'WP'), 'nsubj', ('airspeed', 'NN')), (('airspeed', 'NN'), 'det', ('the', 'DT')), (('airspeed', 'NN'), 'nmod', ('swallow', 'VB')), (('swallow', 'VB'), 'case', ('of', 'IN')), (('swallow', 'VB'), 'det', ('an', 'DT')), (('swallow', 'VB'), 'amod', ('unladen', 'JJ')), (('What', 'WP'), 'punct', ('?', '.'))]]


# Tokenizer
>>> parser = CoreNLPParser(url='http://localhost:9000')
>>> list(parser.tokenize('What is the airspeed of an unladen swallow?'))
['What', 'is', 'the', 'airspeed', 'of', 'an', 'unladen', 'swallow', '?']

# POS Tagger
>>> pos_tagger = CoreNLPParser(url='http://localhost:9000', tagtype='pos')
>>> list(pos_tagger.tag('What is the airspeed of an unladen swallow ?'.split()))
[('What', 'WP'), ('is', 'VBZ'), ('the', 'DT'), ('airspeed', 'NN'), ('of', 'IN'), ('an', 'DT'), ('unladen', 'JJ'), ('swallow', 'VB'), ('?', '.')]

# NER Tagger
>>> ner_tagger = CoreNLPParser(url='http://localhost:9000', tagtype='ner')
>>> list(ner_tagger.tag(('Rami Eid is studying at Stony Brook University in NY'.split())))
[('Rami', 'PERSON'), ('Eid', 'PERSON'), ('is', 'O'), ('studying', 'O'), ('at', 'O'), ('Stony', 'ORGANIZATION'), ('Brook', 'ORGANIZATION'), ('University', 'ORGANIZATION'), ('in', 'O'), ('NY', 'STATE_OR_PROVINCE')]

chinois

Démarrez le serveur un peu différemment, toujours à partir du répertoire `stanford-corenlp-full-2018-02-27:

java -Xmx4g -cp "*" edu.stanford.nlp.pipeline.StanfordCoreNLPServer \
-serverProperties StanfordCoreNLP-chinese.properties \
-preload tokenize,ssplit,pos,lemma,ner,parse \
-status_port 9001  -port 9001 -timeout 15000

En Python:

>>> parser = CoreNLPParser('http://localhost:9001')
>>> list(parser.tokenize(u'我家没有电脑。'))
['我家', '没有', '电脑', '。']

>>> list(parser.parse(parser.tokenize(u'我家没有电脑。')))
[Tree('ROOT', [Tree('IP', [Tree('IP', [Tree('NP', [Tree('NN', ['我家'])]), Tree('VP', [Tree('VE', ['没有']), Tree('NP', [Tree('NN', ['电脑'])])])]), Tree('PU', ['。'])])])]

arabe

Démarrez le serveur:

java -Xmx4g -cp "*" edu.stanford.nlp.pipeline.StanfordCoreNLPServer \
-serverProperties StanfordCoreNLP-arabic.properties \
-preload tokenize,ssplit,pos,parse \
-status_port 9005  -port 9005 -timeout 15000

En Python:

>>> from nltk.parse import CoreNLPParser
>>> parser = CoreNLPParser('http://localhost:9005')
>>> text = u'انا حامل'

# Parser.
>>> parser.raw_parse(text)
<list_iterator object at 0x7f0d894c9940>
>>> list(parser.raw_parse(text))
[Tree('ROOT', [Tree('S', [Tree('NP', [Tree('PRP', ['انا'])]), Tree('NP', [Tree('NN', ['حامل'])])])])]
>>> list(parser.parse(parser.tokenize(text)))
[Tree('ROOT', [Tree('S', [Tree('NP', [Tree('PRP', ['انا'])]), Tree('NP', [Tree('NN', ['حامل'])])])])]

# Tokenizer / Segmenter.
>>> list(parser.tokenize(text))
['انا', 'حامل']

# POS tagg
>>> pos_tagger = CoreNLPParser('http://localhost:9005', tagtype='pos')
>>> list(pos_tagger.tag(parser.tokenize(text)))
[('انا', 'PRP'), ('حامل', 'NN')]


# NER tag
>>> ner_tagger = CoreNLPParser('http://localhost:9005', tagtype='ner')
>>> list(ner_tagger.tag(parser.tokenize(text)))
[('انا', 'O'), ('حامل', 'O')]

français

Démarrez le serveur:

java -Xmx4g -cp "*" edu.stanford.nlp.pipeline.StanfordCoreNLPServer \
-serverProperties StanfordCoreNLP-french.properties \
-preload tokenize,ssplit,pos,parse \
-status_port 9004  -port 9004 -timeout 15000

En Python:

>>> parser = CoreNLPParser('http://localhost:9004')
>>> list(parser.parse('Je suis enceinte'.split()))
[Tree('ROOT', [Tree('SENT', [Tree('NP', [Tree('PRON', ['Je']), Tree('VERB', ['suis']), Tree('AP', [Tree('ADJ', ['enceinte'])])])])])]
>>> pos_tagger = CoreNLPParser('http://localhost:9004', tagtype='pos')
>>> pos_tagger.tag('Je suis enceinte'.split())
[('Je', 'PRON'), ('suis', 'VERB'), ('enceinte', 'ADJ')]

allemand

Démarrez le serveur:

java -Xmx4g -cp "*" edu.stanford.nlp.pipeline.StanfordCoreNLPServer \
-serverProperties StanfordCoreNLP-german.properties \
-preload tokenize,ssplit,pos,ner,parse \
-status_port 9002  -port 9002 -timeout 15000

En Python:

>>> parser = CoreNLPParser('http://localhost:9002')
>>> list(parser.raw_parse('Ich bin schwanger'))
[Tree('ROOT', [Tree('NUR', [Tree('S', [Tree('PPER', ['Ich']), Tree('VAFIN', ['bin']), Tree('AP', [Tree('ADJD', ['schwanger'])])])])])]
>>> list(parser.parse('Ich bin schwanger'.split()))
[Tree('ROOT', [Tree('NUR', [Tree('S', [Tree('PPER', ['Ich']), Tree('VAFIN', ['bin']), Tree('AP', [Tree('ADJD', ['schwanger'])])])])])]


>>> pos_tagger = CoreNLPParser('http://localhost:9002', tagtype='pos')
>>> pos_tagger.tag('Ich bin schwanger'.split())
[('Ich', 'PPER'), ('bin', 'VAFIN'), ('schwanger', 'ADJD')]

>>> pos_tagger = CoreNLPParser('http://localhost:9002', tagtype='pos')
>>> pos_tagger.tag('Ich bin schwanger'.split())
[('Ich', 'PPER'), ('bin', 'VAFIN'), ('schwanger', 'ADJD')]

>>> ner_tagger = CoreNLPParser('http://localhost:9002', tagtype='ner')
>>> ner_tagger.tag('Donald Trump besuchte Angela Merkel in Berlin.'.split())
[('Donald', 'PERSON'), ('Trump', 'PERSON'), ('besuchte', 'O'), ('Angela', 'PERSON'), ('Merkel', 'PERSON'), ('in', 'O'), ('Berlin', 'LOCATION'), ('.', 'O')]

Espagnol

Démarrez le serveur:

java -Xmx4g -cp "*" edu.stanford.nlp.pipeline.StanfordCoreNLPServer \
-serverProperties StanfordCoreNLP-spanish.properties \
-preload tokenize,ssplit,pos,ner,parse \
-status_port 9003  -port 9003 -timeout 15000

En Python:

>>> pos_tagger = CoreNLPParser('http://localhost:9003', tagtype='pos')
>>> pos_tagger.tag(u'Barack Obama salió con Michael Jackson .'.split())
[('Barack', 'PROPN'), ('Obama', 'PROPN'), ('salió', 'VERB'), ('con', 'ADP'), ('Michael', 'PROPN'), ('Jackson', 'PROPN'), ('.', 'PUNCT')]
>>> ner_tagger = CoreNLPParser('http://localhost:9003', tagtype='ner')
>>> ner_tagger.tag(u'Barack Obama salió con Michael Jackson .'.split())
[('Barack', 'PERSON'), ('Obama', 'PERSON'), ('salió', 'O'), ('con', 'O'), ('Michael', 'PERSON'), ('Jackson', 'PERSON'), ('.', 'O')]

Il existe une interface python pour l'analyseur de Stanford

http://projects.csail.mit.edu/spatial/Stanford_Parser

La page du logiciel Stanford Core NLP contient une liste de wrappers python:

http://nlp.stanford.edu/software/corenlp.shtml#Extensions

Si je me souviens bien, l'analyseur de Stanford est une bibliothèque java, donc vous devez avoir un interpréteur Java fonctionnant sur votre serveur / ordinateur.

Je l'ai utilisé une fois sur un serveur, combiné avec un script php. Le script a utilisé la fonction exec () de php pour faire un appel en ligne de commande à l'analyseur comme ceci:

<?php

exec( "java -cp /pathTo/stanford-parser.jar -mx100m edu.stanford.nlp.process.DocumentPreprocessor /pathTo/fileToParse > /pathTo/resultFile 2>/dev/null" );

?>

Je ne me souviens pas de tous les détails de cette commande, elle a essentiellement ouvert le fileToParse, l'a analysé et écrit la sortie dans le resultFile. PHP ouvrirait alors le fichier de résultat pour une utilisation ultérieure.

La fin de la commande dirige l'analyseur détaillé vers NULL, pour éviter que des informations de ligne de commande inutiles ne perturbent le script.

Je ne sais pas grand-chose sur Python, mais il pourrait y avoir un moyen de faire des appels en ligne de commande.

Ce n'est peut-être pas l'itinéraire exact que vous espériez, mais j'espère que cela vous donnera de l'inspiration. Bonne chance.

Notez que cette réponse s'applique à NLTK v 3.0 et non aux versions plus récentes.

Voici une adaptation du code de danger98 qui fonctionne avec nltk3.0.0 sur windoze, et probablement les autres plates-formes également, ajustez les noms de répertoire en fonction de votre configuration:

import os
from nltk.parse import stanford
os.environ['STANFORD_PARSER'] = 'd:/stanford-parser'
os.environ['STANFORD_MODELS'] = 'd:/stanford-parser'
os.environ['JAVAHOME'] = 'c:/Program Files/java/jre7/bin'

parser = stanford.StanfordParser(model_path="d:/stanford-grammars/englishPCFG.ser.gz")
sentences = parser.raw_parse_sents(("Hello, My name is Melroy.", "What is your name?"))
print sentences

Notez que la commande d'analyse a changé (voir le code source sur www.nltk.org/_modules/nltk/parse/stanford.html) et que vous devez définir la variable JAVAHOME. J'ai essayé de le faire lire le fichier de grammaire in situ dans le jar, mais je n'ai pas réussi jusqu'à présent à le faire.

Vous pouvez utiliser la sortie de Stanford Parsers pour créer une arborescence dans nltk (nltk.tree.Tree).

En supposant que l'analyseur de Stanford vous donne un fichier dans lequel il y a exactement un arbre d'analyse pour chaque phrase. Ensuite, cet exemple fonctionne, même s'il ne semble pas très pythonique:

f = open(sys.argv[1]+".output"+".30"+".stp", "r")
parse_trees_text=[]
tree = ""
for line in f:
  if line.isspace():
    parse_trees_text.append(tree)
tree = ""
  elif "(. ...))" in line:
#print "YES"
tree = tree+')'
parse_trees_text.append(tree)
tree = ""
  else:
tree = tree + line

parse_trees=[]
for t in parse_trees_text:
  tree = nltk.Tree(t)
  tree.__delitem__(len(tree)-1) #delete "(. .))" from tree (you don't need that)
  s = traverse(tree)
  parse_trees.append(tree)

Notez que cette réponse s'applique à NLTK v 3.0 et non aux versions plus récentes.

Puisque personne ne l'a vraiment mentionné et que cela m'a beaucoup perturbé, voici une autre façon d'utiliser l'analyseur Stanford en python:

stanford_parser_jar = '../lib/stanford-parser-full-2015-04-20/stanford-parser.jar'
stanford_model_jar = '../lib/stanford-parser-full-2015-04-20/stanford-parser-3.5.2-models.jar'    
parser = StanfordParser(path_to_jar=stanford_parser_jar, 
                        path_to_models_jar=stanford_model_jar)

de cette façon, vous n'avez plus à vous soucier du chemin.

Pour ceux qui ne peuvent pas l'utiliser correctement sur Ubuntu ou exécuter le code dans Eclipse.

Je suis sur une machine Windows et vous pouvez simplement exécuter l'analyseur normalement comme vous le faites à partir de la commande, mais comme dans un répertoire différent afin que vous n'ayez pas besoin d'éditer le fichier lexparser.bat. Mettez simplement le chemin complet.

cmd = r'java -cp \Documents\stanford_nlp\stanford-parser-full-2015-01-30 edu.stanford.nlp.parser.lexparser.LexicalizedParser -outputFormat "typedDependencies" \Documents\stanford_nlp\stanford-parser-full-2015-01-30\stanford-parser-3.5.1-models\edu\stanford\nlp\models\lexparser\englishFactored.ser.gz stanfordtemp.txt'
parse_out = os.popen(cmd).readlines()

La partie la plus délicate pour moi était de comprendre comment exécuter un programme java à partir d'un chemin différent. Il doit y avoir un meilleur moyen, mais cela fonctionne.

Notez que cette réponse s'applique à NLTK v 3.0 et non aux versions plus récentes.

Une légère mise à jour (ou simplement une alternative) sur la réponse complète de danger89 sur l'utilisation de Stanford Parser dans NLTK et Python

Avec stanford-parser-full-2015-04-20, JRE 1.8 et nltk 3.0.4 (python 2.7.6), il semble que vous n'ayez plus besoin d'extraire le fichier englishPCFG.ser.gz de stanford-parser-xxx-models .jar ou configurer n'importe quel os.environ

from nltk.parse.stanford import StanfordParser

english_parser = StanfordParser('path/stanford-parser.jar', 'path/stanford-parser-3.5.2-models.jar')

s = "The real voyage of discovery consists not in seeking new landscapes, but in having new eyes."

sentences = english_parser.raw_parse_sents((s,))
print sentences #only print <listiterator object> for this version

#draw the tree
for line in sentences:
    for sentence in line:
        sentence.draw()

Notez que cette réponse s'applique à NLTK v 3.0 et non aux versions plus récentes.

Voici la version Windows de la réponse d'alvas

sentences = ('. '.join(['this is sentence one without a period','this is another foo bar sentence '])+'.').encode('ascii',errors = 'ignore')
catpath =r"YOUR CURRENT FILE PATH"

f = open('stanfordtemp.txt','w')
f.write(sentences)
f.close()

parse_out = os.popen(catpath+r"\nlp_tools\stanford-parser-2010-08-20\lexparser.bat "+catpath+r"\stanfordtemp.txt").readlines()

bracketed_parse = " ".join( [i.strip() for i in parse_out if i.strip() if i.strip()[0] == "("] )
bracketed_parse = "\n(ROOT".join(bracketed_parse.split(" (ROOT")).split('\n')
aa = map(lambda x :ParentedTree.fromstring(x),bracketed_parse)

REMARQUES:

• Dans lexparser.bat vous devez changer tous les chemins en chemin absolu pour éviter les erreurs java telles que "classe non trouvée"

• Je vous recommande fortement d'appliquer cette méthode sous Windows car j'ai essayé plusieurs réponses sur la page et toutes les méthodes de communication python avec Java échouent.

• Je souhaite avoir de vos nouvelles si vous réussissez sur Windows et souhaitez que vous puissiez me dire comment vous surmontez tous ces problèmes.

• rechercher dans le wrapper python stanford coreNLP pour obtenir la version python

J'ai mis de nombreuses heures et j'ai finalement trouvé une solution simple pour les utilisateurs de Windows. Fondamentalement, sa version résumée d'une réponse existante par alvas, mais facile à suivre (espérons-le) pour ceux qui sont nouveaux dans la PNL de Stanford et sont des utilisateurs de Windows.

1) Téléchargez le module que vous souhaitez utiliser, tel que NER, POS etc. Dans mon cas, je voulais utiliser NER, j'ai donc téléchargé le module à partir de http://nlp.stanford.edu/software/stanford-ner-2015- 04-20.zip

2) Décompressez le fichier.

3) Définissez les variables d'environnement (classpath et stanford_modules) à partir du dossier décompressé.

import os
os.environ['CLASSPATH'] = "C:/Users/Downloads/stanford-ner-2015-04-20/stanford-ner.jar"
os.environ['STANFORD_MODELS'] = "C:/Users/Downloads/stanford-ner-2015-04-20/classifiers/"

4) définissez les variables d'environnement pour JAVA, comme là où vous avez installé JAVA. pour moi c'était en dessous

os.environ['JAVAHOME'] = "C:/Program Files/Java/jdk1.8.0_102/bin/java.exe"

5) importez le module de votre choix

from nltk.tag import StanfordNERTagger

6) appelez le modèle pré-entraîné qui est présent dans le dossier classifier dans le dossier décompressé. ajoutez ".gz" à la fin pour l'extension de fichier. pour moi, le modèle que je voulais utiliser étaitenglish.all.3class.distsim.crf.ser

st = StanfordNERTagger('english.all.3class.distsim.crf.ser.gz')

7) Maintenant, exécutez l'analyseur !! et nous avons terminé !!

st.tag('Rami Eid is studying at Stony Brook University in NY'.split())

Réponse obsolète

La réponse ci-dessous est obsolète, veuillez utiliser la solution sur https://stackoverflow.com/a/51981566/610569 pour NLTK v3.3 et supérieur.

ÉDITÉ

Remarque: La réponse suivante ne fonctionnera que sur:

• Version NLTK == 3.2.5
• Stanford Tools compilé depuis le 2016-10-31
• Python 2.7, 3.5 et 3.6

Comme les deux outils changent assez rapidement et que l'API peut sembler très différente 3 à 6 mois plus tard. Veuillez traiter la réponse suivante comme une solution temporelle et non éternelle.

Référez-vous toujours à https://github.com/nltk/nltk/wiki/Installing-Third-Party-Software pour les dernières instructions sur la façon d'interfacer les outils de Stanford NLP en utilisant NLTK !!

TL; DR

Le code suivant provient de https://github.com/nltk/nltk/pull/1735#issuecomment-306091826

Dans le terminal:

wget http://nlp.stanford.edu/software/stanford-corenlp-full-2016-10-31.zip
unzip stanford-corenlp-full-2016-10-31.zip && cd stanford-corenlp-full-2016-10-31

java -mx4g -cp "*" edu.stanford.nlp.pipeline.StanfordCoreNLPServer \
-preload tokenize,ssplit,pos,lemma,parse,depparse \
-status_port 9000 -port 9000 -timeout 15000

En Python:

>>> from nltk.tag.stanford import CoreNLPPOSTagger, CoreNLPNERTagger
>>> from nltk.parse.corenlp import CoreNLPParser

>>> stpos, stner = CoreNLPPOSTagger(), CoreNLPNERTagger()

>>> stpos.tag('What is the airspeed of an unladen swallow ?'.split())
[(u'What', u'WP'), (u'is', u'VBZ'), (u'the', u'DT'), (u'airspeed', u'NN'), (u'of', u'IN'), (u'an', u'DT'), (u'unladen', u'JJ'), (u'swallow', u'VB'), (u'?', u'.')]

>>> stner.tag('Rami Eid is studying at Stony Brook University in NY'.split())
[(u'Rami', u'PERSON'), (u'Eid', u'PERSON'), (u'is', u'O'), (u'studying', u'O'), (u'at', u'O'), (u'Stony', u'ORGANIZATION'), (u'Brook', u'ORGANIZATION'), (u'University', u'ORGANIZATION'), (u'in', u'O'), (u'NY', u'O')]


>>> parser = CoreNLPParser(url='http://localhost:9000')

>>> next(
...     parser.raw_parse('The quick brown fox jumps over the lazy dog.')
... ).pretty_print()  # doctest: +NORMALIZE_WHITESPACE
                     ROOT
                      |
                      S
       _______________|__________________________
      |                         VP               |
      |                _________|___             |
      |               |             PP           |
      |               |     ________|___         |
      NP              |    |            NP       |
  ____|__________     |    |     _______|____    |
 DT   JJ    JJ   NN  VBZ   IN   DT      JJ   NN  .
 |    |     |    |    |    |    |       |    |   |
The quick brown fox jumps over the     lazy dog  .

>>> (parse_fox, ), (parse_wolf, ) = parser.raw_parse_sents(
...     [
...         'The quick brown fox jumps over the lazy dog.',
...         'The quick grey wolf jumps over the lazy fox.',
...     ]
... )

>>> parse_fox.pretty_print()  # doctest: +NORMALIZE_WHITESPACE
                     ROOT
                      |
                      S
       _______________|__________________________
      |                         VP               |
      |                _________|___             |
      |               |             PP           |
      |               |     ________|___         |
      NP              |    |            NP       |
  ____|__________     |    |     _______|____    |
 DT   JJ    JJ   NN  VBZ   IN   DT      JJ   NN  .
 |    |     |    |    |    |    |       |    |   |
The quick brown fox jumps over the     lazy dog  .

>>> parse_wolf.pretty_print()  # doctest: +NORMALIZE_WHITESPACE
                     ROOT
                      |
                      S
       _______________|__________________________
      |                         VP               |
      |                _________|___             |
      |               |             PP           |
      |               |     ________|___         |
      NP              |    |            NP       |
  ____|_________      |    |     _______|____    |
 DT   JJ   JJ   NN   VBZ   IN   DT      JJ   NN  .
 |    |    |    |     |    |    |       |    |   |
The quick grey wolf jumps over the     lazy fox  .

>>> (parse_dog, ), (parse_friends, ) = parser.parse_sents(
...     [
...         "I 'm a dog".split(),
...         "This is my friends ' cat ( the tabby )".split(),
...     ]
... )

>>> parse_dog.pretty_print()  # doctest: +NORMALIZE_WHITESPACE
        ROOT
         |
         S
  _______|____
 |            VP
 |    ________|___
 NP  |            NP
 |   |         ___|___
PRP VBP       DT      NN
 |   |        |       |
 I   'm       a      dog

Veuillez consulter http://www.nltk.org/_modules/nltk/parse/corenlp.html pour plus d'informations sur l'API de Stanford. Jetez un œil aux docstrings!

Notez que cette réponse s'applique à NLTK v 3.0 et non aux versions plus récentes.

Je ne peux pas laisser cela comme un commentaire à cause de la réputation, mais comme j'ai passé (perdu?) Un peu de temps à résoudre cela, je préférerais partager mon problème / solution pour que cet analyseur fonctionne en NLTK.

Dans l' excellente réponse d'alvas , il est mentionné que:

par exemple pour l'analyseur, il n'y aura pas de répertoire de modèle.

Cela m'a conduit à tort à:

• pas faire attention à la valeur que je mets à STANFORD_MODELS (et ne se soucient de ma CLASSPATH)
• laissez ../path/tostanford-parser-full-2015-2012-09/models directory* pratiquement vide * (ou avec un fichier jar dont le nom ne correspond pas à nltk regex)!

Si l'OP, comme moi, voulait juste utiliser l'analyseur, il peut être déroutant qu'en ne téléchargeant rien d'autre (pas de POStagger, pas de NER, ...) et en suivant toutes ces instructions, nous obtenons toujours une erreur.

Finalement, pour tout élément CLASSPATHdonné (exemples et explications suivants dans les réponses de ce fil), j'obtiendrais toujours l'erreur:

NLTK n'a pas pu trouver stanford-parser - (\ d +) (. (\ D +)) + - models.jar! Définissez la variable d'environnement CLASSPATH. Pour plus d'informations, sur stanford-parser - (\ d +) (. (\ D +)) + - models.jar,

voir: http://nlp.stanford.edu/software/lex-parser.shtml

OU:

NLTK n'a pas pu trouver stanford-parser.jar! Définissez la variable d'environnement CLASSPATH. Pour plus d'informations, sur stanford-parser.jar, voir: http://nlp.stanford.edu/software/lex-parser.shtml

Cependant , surtout, je pourrais charger et utiliser correctement l'analyseur si j'appelais la fonction avec tous les arguments et le chemin entièrement spécifiés, comme dans:

stanford_parser_jar = '../lib/stanford-parser-full-2015-04-20/stanford-parser.jar'
stanford_model_jar = '../lib/stanford-parser-full-2015-04-20/stanfor-parser-3.5.2-models.jar'    
parser = StanfordParser(path_to_jar=stanford_parser_jar, 
                    path_to_models_jar=stanford_model_jar)

Solution pour l'analyseur seul:

Par conséquent, l'erreur est venue de NLTKet comment il recherche les fichiers JAR en utilisant les variables d'environnement STANFORD_MODELSet fournies CLASSPATH. Pour résoudre ce problème, le *-models.jar, avec le formatage correct (pour correspondre à l'expression NLTKrégulière dans le code, donc pas de -corenlp -.... jar) doit être situé dans le dossier désigné parSTANFORD_MODELS .

A savoir, j'ai d'abord créé:

mkdir stanford-parser-full-2015-12-09/models

Puis ajouté dans .bashrc:

export STANFORD_MODELS=/path/to/stanford-parser-full-2015-12-09/models

Et enfin, en copiant stanford-parser-3.6.0-models.jar(ou la version correspondante), dans:

path/to/stanford-parser-full-2015-12-09/models/

Je pourrais arriver StanfordParserà charger en douceur en python avec le classique CLASSPATHqui pointe vers stanford-parser.jar. En fait, en tant que tel, vous pouvez appeler StanfordParsersans paramètres, la valeur par défaut fonctionnera simplement.

J'utilise la version 3.2.4 de nltk. Et le code suivant a fonctionné pour moi.

from nltk.internals import find_jars_within_path
from nltk.tag import StanfordPOSTagger
from nltk import word_tokenize

# Alternatively to setting the CLASSPATH add the jar and model via their 
path:
jar = '/home/ubuntu/stanford-postagger-full-2017-06-09/stanford-postagger.jar'
model = '/home/ubuntu/stanford-postagger-full-2017-06-09/models/english-left3words-distsim.tagger'

pos_tagger = StanfordPOSTagger(model, jar)

# Add other jars from Stanford directory
stanford_dir = pos_tagger._stanford_jar.rpartition('/')[0]
stanford_jars = find_jars_within_path(stanford_dir)
pos_tagger._stanford_jar = ':'.join(stanford_jars)

text = pos_tagger.tag(word_tokenize("Open app and play movie"))
print(text)

Production:

[('Open', 'VB'), ('app', 'NN'), ('and', 'CC'), ('play', 'VB'), ('movie', 'NN')]

Un nouveau développement de l'analyseur de Stanford basé sur un modèle neuronal, formé à l'aide de Tensorflow, est très récemment mis à disposition pour être utilisé comme API python. Ce modèle est censé être beaucoup plus précis que le moel basé sur Java. Vous pouvez certainement intégrer un pipeline NLTK.

Lien vers l'analyseur. Le référentiel contient des modèles d'analyseurs pré-entraînés pour 53 langues.