Stanford Parser et NLTK

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

81
demandé sur Peter O. 2012-12-14 21:12:20

17 réponses

notez que cette réponse s'applique à NLTK V 3.0, et non à des 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()

sortie:

[Arbre('ROOT', [Arbre('S', [Arbre('INTJ', [Arbre('EUH', ['Bonjour'])]), Arbre(',', [',']), Arbre('NP', [Arbre('PRP$', ['Mon']), l'Arbre ("NN", ['nom'])]), l'Arbre('VP', [Arbre('VBZ', ['']), l'Arbre('ADJP', [Arbre('JJ', ['Melroy'])])]), L'Arbre('.", [".'])])]), Arbre('ROOT', [Tree('SBARQ'), [Arbre('WHNP', [Arbre('WP', ['Ce'])]), l'Arbre('SQ', [Arbre('VBZ', ['']), l'Arbre('NP', [Arbre('PRP$', ['votre']), l'Arbre('NN', ['nom'])])]), Arbre.'(', [ ' ?'])])])]

Note 1: Dans cet exemple, les deux jarres parser et model sont dans le même dossier.

Note 2:

  • nom de Fichier de stanford parser est: stanford parser.pot
  • nom de fichier de stanford models: stanford-parser-X. x.x-models.jar

Note 3: The englishPCFG.ser.gz fichier peut être trouvé à l'intérieur les modèles.fichier jar (/edu/stanford/pnl/modèles/lexparser/englishPCFG.ser.gz). Veuillez utiliser venir gestionnaire d'archives pour décompresser les modèles.fichier jar.

Note 4: Soyez sûr que vous êtes utilisant Java JRE (Runtime Environment) 1.8 également connu sous le nom D'Oracle JDK 8. Sinon vous obtiendrez: major non supporté.version mineure 52.0.

Installation

  1. télécharger NLTK v3 à partir de: https://github.com/nltk/nltk . Et installer NLTK:

    sudo python setup.py installer

  2. vous pouvez utiliser le NLTK downloader pour obtenir Stanford Parser, en utilisant Python: 

    import nltk
nltk.download()

  3. Essayez mon exemple! (n'oubliez pas de changer les chemins jar et de changer le chemin model vers le ser.gz emplacement)

OU:

  1. télécharger et installer NLTK v3, comme ci-dessus.

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

  3. extrait du standford-parser-full-20xx-xx-xx.zip.

  4. créer un nouveau dossier ('jars' dans mon exemple). Placer les fichiers extraits dans ce dossier jar: stanford parser-3.x.x-modèles.jar et stanford-parser.pot.

    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 s'il vous plaît utilisez quelque chose comme: C://folder//jars.

  5. Ouvrir le stanford parser-3.x.x-modèles.bocal à l'aide d'un gestionnaire d'Archives (7zip).

  6. parcourir le fichier jar; edu/stanford/nlp/models/lexparser. Encore une fois, extraire le fichier appelé " englishPCFG.ser.gz'. Rappelez-vous l'endroit où vous extrayez ce sérum.fichier gz.

  7. lors de la création d'une instance StanfordParser, vous pouvez fournir le chemin du modèle comme 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 jar et de changer le chemin model vers le ser.gz emplacement)

74
répondu danger89 2018-08-23 20:56:11

Réponse Dépréciée

la réponse ci-dessous est dépréciée, s'il vous plaît utiliser la solution sur https://stackoverflow.com/a/51981566/610569 pour NLTK v3.3 et plus.

EDITED

Note: la réponse suivante ne fonctionnera que sur:

  • NLTK version > = 3.2.4
  • Stanford Tools compilé depuis le 2015-04-20
  • Python 2.7, 3.4 et 3.5 (Python 3.6 n'est pas encore officiellement supporté)

comme les deux outils change assez rapidement et L'API pourrait sembler très différent 3-6 mois plus tard. Veuillez considérer la réponse suivante comme temporelle et non comme une solution éternelle.

toujours se référer à https://github.com/nltk/nltk/wiki/Installing-Third-Party-Software pour la dernière instruction sur la façon de interface Stanford NLP tools using 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

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'])])])])])])]

>>> 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 NLP de Stanford sont écrits en Java et NLTK est écrit en Python . La façon dont NLTK interface l'outil est par l'intermédiaire de L'appel L'outil Java par l'intermédiaire de l'interface de ligne de commande.

Deuxièmement , L'API NLTK des outils NLP de Stanford a beaucoup changé depuis la version 3.1. Il est donc conseillé de mettre à jour votre paquet NLTK en v3.1.

Troisièmement , le NLTK API à Stanford, les outils de la NLP enveloppent les outils individuels de la NLP, par exemple Stanford POS tagger , Stanford NER Tagger , Stanford Parser .

pour le POS et le NER tagger, il ne fait pas envelopper le Stanford Core NLP package .

pour le Stanford Parser, c'est un cas spécial où il enveloppe autour du Stanford Parser et du 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 )

noter qu'à partir de NLTK v3.1, Les variables STANFORD_JAR et STANFORD_PARSER est déprécié et N'est plus utilisé

En Plus Long:



STEP 1

en supposant que vous avez installé Java de manière appropriée sur votre système D'exploitation.

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

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

Pour Windows (Utiliser le binaire de 32 bits de l'installation):

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

( pourquoi pas 64 bit? voir https://github.com/nltk/nltk/issues/1079 )

alors hors de la paranoïa, revérifiez votre nltk version à l'intérieur 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.1 comme la sortie.

pour encore plus de paranoïa, vérifiez que tous vos outils NLP préférés de Stanford 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

( Note : les importations ci-dessus seront seulement s'assurer que vous utilisez une version NLTK correcte qui contient ces API. Ne pas voir d'erreurs dans l'import ne signifie pas que vous avez configuré avec succès L'API NLTK pour utiliser les outils de Stanford)

l'ÉTAPE 2

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

TL; DR , in 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

Dans Windows / Mac:

étape 3

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

  • ajouter le fichier Stanford NLP .jar à la variable d'environnement CLASSPATH .

    • p.ex. pour le TNI, il sera stanford-ner-2015-04-20/stanford-ner.jar
    • p.ex. pour le POS, il sera stanford-postagger-full-2015-04-20/stanford-postagger.jar
    • p.ex. pour l'analyseur, il sera stanford-parser-full-2015-04-20/stanford-parser.jar et le fichier JAR de l'analyseur, stanford-parser-full-2015-04-20/stanford-parser-3.5.2-models.jar

  • ajouter le répertoire de modèles approprié à la variable STANFORD_MODELS (c.-à-d. le répertoire où vous pouvez trouver où les modèles pré-formés sont enregistrés)

    • p.ex. pour le TNI, il sera dans stanford-ner-2015-04-20/classifiers/
    • p.ex. pour le POS, il sera dans stanford-postagger-full-2015-04-20/models/
    • par exemple pour L'Analyseur, il n'y aura pas de répertoire model.

dans le code, voir qu'il recherche le répertoire STANFORD_MODELS avant d'ajouter le nom de modèle. Voir aussi que l'API essaie aussi automatiquement de rechercher les environnements OS pour le "CLASSPATH )

noter qu'à partir de NLTK v3.1, Les variables STANFORD_JAR sont dépréciées et ne sont plus utilisées . Les snippets de Code trouvés dans les questions suivantes de Stackoverflow pourraient ne pas fonctionner:

TL;DR pour l'ÉTAPE 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 les instructions de configuration des variables d'environnement)

vous doit définissez 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'])])])])])])]

Alternativement, vous pouvez essayer d'ajouter les variables d'environnement à l'intérieur de python, comme les réponses précédentes l'ont suggéré, mais vous pouvez aussi dire directement au parser/tagger d'initialiser au chemin direct où vous avez gardé le fichier .jar 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 son nom de paramètre, vous devrez changer en conséquence. c'est pourquoi il est préférable de définir les variables d'environnement plutôt 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)
71
répondu alvas 2018-08-23 08:44:43

Réponse Dépréciée

la réponse ci-dessous est dépréciée, s'il vous plaît utiliser la solution sur https://stackoverflow.com/a/51981566/610569 pour NLTK v3.3 et plus.

Édité

à partir de L'actuel Stanford parser (2015-04-20), la sortie par défaut pour le lexparser.sh a changé de sorte que le script ci-dessous ne fonctionnera pas.

mais cette réponse est conservée pour héritage saké, ça marchera toujours avec http://nlp.stanford.edu/software/stanford-parser-2012-11-12.zip .

Réponse Originale À Cette Question

je vous conseille de ne pas jouer avec Jython, JPype. Laisser python faire des trucs python et laisser java faire des trucs java, obtenir la sortie Stanford Parser à travers la console.

après avoir installé le Stanford Parser dans votre répertoire personnel ~/ , il suffit d'utiliser cette recette de python pour obtenir le parse entre crochets plat: 

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
21
répondu alvas 2018-08-23 08:44:57

As of NLTK v3.3, les utilisateurs doivent éviter les poignards Stanford NER ou POS de nltk.tag , et éviter Stanford tokenizer/segmenter de nltk.tokenize .

utilisez plutôt la nouvelle API nltk.parse.corenlp.CoreNLPParser .

s'il vous Plaît voir https://github.com/nltk/nltk/wiki/Stanford-CoreNLP-API-in-NLTK

(éviter le lien seulement la réponse, je l'ai collé les docs de NLTK github wiki ci-dessous)

tout D'abord, mettre à jour votre NLTK 

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

téléchargez ensuite les paquets 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 répertoire stanford-corenlp-full-2018-02-27 , démarrer 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émarrer le serveur un peu différemment, toujours du "stanford-corenlp-full-2018-02-27 répertoire: 

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émarrer 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émarrer 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émarrer 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émarrer 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')]
8
répondu alvas 2018-09-18 00:52:46

il y a une interface python pour stanford parser

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

7
répondu Rohith 2012-12-18 18:16:21

la page du logiciel NLP de Stanford Core contient une liste de paquets python:

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

7
répondu silverasm 2013-08-21 19:28:10

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

je l'ai utilisé une fois 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 suit: 

<?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, il a essentiellement ouvert le fileToParse, l'a analysé, et a écrit la sortie dans le fichier resultFile. PHP ouvrirait alors le fichier de résultat pour une utilisation ultérieure.

la fin de la commande dirige le verbose de L'analyseur vers NULL, pour éviter que des informations en 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 la route exacte que vous espériez, mais j'espère qu'elle vous inspirera. Le meilleur de la chance.

6
répondu bob dope 2012-12-14 17:25:37

notez que cette réponse s'applique à NLTK V 3.0, et non à des versions plus récentes.

voici une adaptation du code de danger98 qui fonctionne avec nltk3.0.0 sur windoze, et probablement aussi sur les autres plateformes, ajustez les noms de répertoires 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 à www.nltk.org/_modules/nltk/parse/stanford.html), et que vous devez définir le JAVAHOME variable. J'ai essayé de le faire lire le fichier grammatical in situ dans le bocal, mais je ne l'ai pas fait jusqu'à présent.

6
répondu Avery Andrews 2018-08-23 21:04:37

vous pouvez utiliser la sortie Stanford Parsers pour créer un arbre dans nltk (nltk.arbre.Arbre.)

en supposant que l'analyseur de stanford vous donne un fichier dans lequel il y a exactement un arbre d'analyse pour chaque phrase. Alors cet exemple fonctionne, bien qu'il puisse ne pas sembler 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)
4
répondu Sadik 2013-08-01 16:11:06

je suis sur une machine windows et vous pouvez simplement exécuter l'analyseur normalement comme vous le faites à partir de la commande comme dans un répertoire différent de sorte que vous n'avez pas besoin d'éditer le lexparser.le fichier bat. Il suffit de mettre dans le chemin d'accès 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 délicate pour moi était de réaliser comment exécuter un programme java à partir d'un chemin différent. Il doit y avoir un meilleur moyen, mais ça marche.

3
répondu Ted Petrou 2015-03-06 16:30:57

notez que cette réponse s'applique à NLTK V 3.0, et non à des versions plus récentes.

une légère mise à jour (ou simplement alternative) sur la réponse complète de danger89 sur L'utilisation de Stanford Parser en 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 l'englishPCFG.ser.gz de stanford-parser-X. x.x-models.jar ou la mise en place de n'importe quel os.environ 151920920" 

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()
3
répondu SYK 2018-08-23 20:59:30

notez que cette réponse s'applique à NLTK V 3.0, et non à des versions plus récentes.

Voici la version windows de la réponse de 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)

NOTES:

  • Dans lexparser.bat vous avez besoin de changer tous les chemins en chemin absolu pour éviter la java des erreurs comme "class not found",

  • je vous recommande fortement de appliquer cette méthode sous windows puisque j'ai essayé plusieurs réponses sur la page et toutes les méthodes communique python avec Java échoue.

  • j'aimerais avoir de vos nouvelles si vous réussissez sur windows et si vous pouvez me dire comment vous surmontez tous ces problèmes.

  • recherche wrapper python pour stanford coreNLP pour obtenir la version de python

3
répondu redreamality 2018-08-23 20:59:47

notez que cette réponse s'applique à NLTK V 3.0, et non à des versions plus récentes.

puisque personne ne l'a vraiment mentionné et que cela me trouble beaucoup, voici une autre façon d'utiliser Stanford parser 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.

3
répondu Zhong Zhu 2018-08-23 21:00:08

j'ai pris de nombreuses heures et finalement trouvé une solution simple pour les utilisateurs de Windows. Essentiellement sa version résumée d'une réponse existante par alvas, mais rendue facile à suivre(espérons) pour ceux qui sont nouveaux à stanford NLP et sont des utilisateurs de fenêtre.

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

2) décompresse le fichier.

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

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 dans où vous avez installé JAVA. pour moi, il était en dessous de 

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

5) importer le module que vous voulez 

from nltk.tag import StanfordNERTagger

6) appelez le modèle pré-formé qui est présent dans le dossier classifier dans le dossier unzipped. ajouter." gz" à la fin de l'extension de fichier. pour moi, le modèle que je voulais utiliser était english.all.3class.distsim.crf.ser 

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

7) maintenant, exécutez l'analyseur!! et nous sommes de fait!! 

st.tag('Rami Eid is studying at Stony Brook University in NY'.split())
2
répondu Enthusiast 2017-05-23 12:26:35

Réponse Dépréciée

la réponse ci-dessous est dépréciée, s'il vous plaît utiliser la solution sur https://stackoverflow.com/a/51981566/610569 pour NLTK v3.3 et plus.

EDITED

Note: la réponse suivante ne fonctionnera que sur:

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

comme les deux outils change assez rapidement et L'API pourrait sembler très différent 3-6 mois plus tard. Veuillez considérer la réponse suivante comme temporelle et non comme une solution éternelle.

réfère Toujours à https://github.com/nltk/nltk/wiki/Installing-Third-Party-Software pour la dernière instruction sur la façon d'interface Stanford PNL outils à l'aide de 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

s'il vous Plaît prendre un coup d'oeil à http://www.nltk.org/_modules/nltk/parse/corenlp.html pour plus d'informations sur le Stanford API. Jetez un oeil à la docstrings!

2
répondu alvas 2018-08-23 08:47:03

notez que cette réponse s'applique à NLTK V 3.0, et non à des versions plus récentes.

Je ne peux pas laisser cela comme un commentaire en raison de la réputation, mais puisque je dépense (gaspillé? je préférerais partager mon problème / solution pour que cet analyseur fonctionne en NLTK.

Dans le excellent réponse de alvas , il est mentionné que:

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

cela m'a conduit à tort à:

  • ne faites pas attention à la valeur que j'ai mise à STANFORD_MODELS (et ne vous souciez que de mon CLASSPATH )
  • quitter ../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 tous ces conseils, nous obtenons toujours une erreur.

éventuellement, pour n'importe quel CLASSPATH donné (exemples suivants et explications dans les réponses à partir de ce fil) je recevrais toujours l'erreur:

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

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

ou:

NLTK n'a pas pu trouver stanford-parser.bocal! Définir le chemin de classe variable d'environnement. Pour plus d'information, sur stanford-parser.pot, voir: http://nlp.stanford.edu/software/lex-parser.shtml

bien que , il est important de noter que je pourrais correctement charger et utiliser l'analyseur si j'appelais la fonction avec tous les arguments et le chemin complètement 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 analyseur seul:

par conséquent, l'erreur provient de NLTK et de la façon dont elle recherche les bocaux en utilisant les variables d'environnement STANFORD_MODELS et CLASSPATH fournies. Pour résoudre cela, le *-models.jar , avec le formatage correct (pour correspondre à la regex dans NLTK de code, de sorte que personne ne corenlp-....jar) doit être situé dans le dossier désigné par STANFORD_MODELS .

à savoir, j'ai créé la première: 

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), en: 

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

j'ai pu obtenir StanfordParser pour charger en douceur en python, avec le classique CLASSPATH ça indique stanford-parser.jar . En fait, comme tel, vous pouvez appeler StanfordParser sans paramètres, la valeur par défaut ne fera que fonctionner.

2
répondu H. Rev. 2018-08-23 21:01:06

j'utilise la version 3.2.4 de nltk. Et suivre le code 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)

sortie: 

[('Open', 'VB'), ('app', 'NN'), ('and', 'CC'), ('play', 'VB'), ('movie', 'NN')]
2
répondu Aditi 2018-08-23 21:02:02