Stanford Parser et NLTK

Question

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

danger89 · Answer

Notez que cette réponse s’applique à NLTK v 3.0 et non aux versions les 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 ('UH', ['Bonjour'];]))], Arbre (',', ', [', '] Arbre ('NP', [Arbre ('PRP $', ['Mon']), Arbre ('NN', ['Nom'])], Arbre ('VP', [Arbre ('VBZ', [ 'est']), Arbre ('ADJP', [Arbre ('JJ', ['Melroy'])])]), Arbre ('.', ['.'] '])]), Arbre (' ROOT ', [Arbre (' SBARQ ', [Arbre (' WHNP ', [Arbre (' WP ', [' Quoi ''])]]), Arbre ('SQ', [Arbre ('VBZ', ['est' ]), Arbre ('NP', [Arbre ('PRP $', ['votre'])), Arbre ('NN', ['Nom'])]]], Arbre ('.', ['?? ']]]]]]]

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

Note 2:

Le nom du fichier de l'analyseur stanford est: stanford-parser.jar
Le nom du fichier de modèles stanford est: stanford-parser-x.x.x-models.jar

Remarque 3: Le fichier englishPCFG.ser.gz est disponible à l'intérieur le fichier models.jar (/edu/stanford/nlp/models/lexparser/englishPCFG.ser.gz). Veuillez utiliser le gestionnaire d’archives pour décompresser le fichier models.jar.

Remarque 4: Assurez-vous d'utiliser Java JRE (environnement d'exécution)) 1.8 également appelé Oracle JDK 8. Sinon, vous obtiendrez: Major.minor version 52.0 non prise en charge.

Installation

Téléchargez NLTK v3 à partir de: https://github.com/nltk/nltk . Et installez NLTK:

Sudo python setup.py install
Vous pouvez utiliser le téléchargeur NLTK pour obtenir Stanford Parser, en utilisant Python:
```
import nltk nltk.download() 
```
Essayez mon exemple! (n'oubliez pas de changer les chemins des fichiers JAR et de changer le chemin du modèle à l'emplacement ser.gz)

OU:

Téléchargez et installez NLTK v3, comme ci-dessus.
Téléchargez la dernière version de ( version actuelle le nom du fichier est stanford-parser-full-2015-01-29.Zip): http://nlp.stanford.edu/software/Lex-parser.shtml#Download
Extrayez le fichier standford-parser-full-20xx-xx-xx.Zip.
Créez un nouveau dossier ("jars" dans mon exemple). Placez les fichiers extraits dans ce dossier JAR: stanford-parser-3.x.x-models.jar et stanford-parser.jar.

Comme indiqué ci-dessus, vous pouvez utiliser les variables d'environnement (STANFORD_PARSER & STANFORD_MODELS) pour désigner ce dossier "jars". J'utilise Linux, donc si vous utilisez Windows, veuillez utiliser quelque chose comme: C: // dossier // jars.
Ouvrez le fichier stanford-parser-3.x.x-models.jar à l’aide d’un gestionnaire d’archives (7Zip).
Parcourez le fichier jar; edu/stanford/nlp/models/lexparser. Encore une fois, extrayez le fichier appelé 'englishPCFG.ser.gz'. N'oubliez pas l'emplacement où vous extrayez ce fichier ser.gz.
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 du modèle, dans notre cas /location/of/englishPCFG.ser.gz.
Essayez mon exemple! (n'oubliez pas de changer les chemins des fichiers JAR et de changer le chemin du modèle à l'emplacement ser.gz)

alvas · Answer

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 versions ultérieures.

ÉDITÉ

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

Version NLTK> = 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 changent assez rapidement et que l'API peut paraître très différente 3-6 mois plus tard Veuillez traiter 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 obtenir les dernières instructions sur la manière d'interagir avec Stanford NLP outils 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 PNL de Stanford sont écrits en Java et NLTK est écrit en Python . La manière dont NLTK assure l'interface entre l'outil est via l'appel de l'outil Java via l'interface de ligne de commande.

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

Troisièmement , l’API NLTK de Stanford NLP Tools s’enroule autour des outils individuels de la PNL, par exemple étiqueteur POS Stanford , étiqueteur Stanford NER , analyseur Stanford .

Pour les étiqueteurs POS et NER, il NE CONTINUE PAS autour du paquet Stanford Core .

Pour Stanford Parser, il s’agit d’un cas particulier qui englobe à la fois le Stanford Parser et le PNL de Stanford Core (personnellement, je n’ai pas utilisé ce dernier avec 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, le STANFORD_JAR et STANFORD_PARSER variables est obsolète et plus utilisé

En plus:

ÉTAPE 1

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

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

Utilisation de pip : Sudo pip install -U nltk
Distribution Debian (en utilisant apt-get): Sudo apt-get install python-nltk

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

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

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

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

Pour encore plus de paranoïa, vérifiez que toutes vos API d’outils de PNL 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 seront [~ # ~] uniquement [~ # ~] assurez-vous que vous utilisez une version NLTK correcte contenant ces API. Ne pas voir les erreurs lors de l'importation ne signifie pas que vous avez correctement configuré l'API NLTK pour utiliser les outils Stanford).

ÉTAPE 2

Maintenant que vous avez vérifié que vous disposez de la version correcte de NLTK contenant l’interface nécessaire pour les outils de PNL de Stanford. Vous devez télécharger et extraire tous les outils nécessaires de la PNL de Stanford.

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 depuis http://nlp.stanford.edu/software/Lex-parser.shtml#Download
Téléchargez et identifiez le VERSION COMPLÈTE de http://nlp.stanford.edu/software/tagger.shtml#Download
Téléchargez et identifiez le marqueur NER 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 correspondant. Vous devez définir les variables suivantes:

Ajoutez le fichier de PNL Stanford approprié .jar fichier dans la variable d’environnement CLASSPATH.
- par exemple. pour le NER, ce sera stanford-ner-2015-04-20/stanford-ner.jar
- par exemple. pour le point de vente, 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.jar et le fichier jar du modèle d'analyse, stanford-parser-full-2015-04-20/stanford-parser-3.5.2-models.jar
Ajoutez le répertoire de modèle approprié au fichier STANFORD_MODELS variable (c’est-à-dire le répertoire où vous pouvez trouver où les modèles pré-formés sont enregistrés)
- par exemple. pour le NER, ce sera dans stanford-ner-2015-04-20/classifiers/
- par exemple. pour le point de vente, ce sera dans stanford-postagger-full-2015-04-20/models/
- par exemple. pour l'analyseur, il n'y aura pas de répertoire modèle.

Dans le code, voyez qu'il cherche le STANFORD_MODELS répertoire avant d’ajouter le nom du modèle. Voir également que, l'API essaie également automatiquement de rechercher les environnements de système d'exploitation pour le `CLASSPATH )

Notez qu'à partir de NLTK v3.1, le STANFORD_JAR variables est obsolète et NO LONGER n'est plus utilisé . Les extraits de code trouvés dans les questions Stackoverflow suivantes peuvent ne pas fonctionner:

TL; DR pour STEP 3 sous 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 de 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 dans python, comme suggéré dans les réponses précédentes, mais vous pouvez également demander directement à l’analyseur/tagueur de s’initialiser sur le chemin direct dans lequel vous avez conservé le .jar fichier 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 modifie son paramètre. noms, 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 de 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)

alvas · Answer

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 versions ultérieures.

Édité

Depuis l'analyseur Stanford actuel (2015-04-20), la sortie par défaut pour le lexparser.sh a changé et le script ci-dessous ne fonctionnera pas.

Mais cette réponse est conservée pour des raisons d'héritage, elle fonctionnera toujours avec http://nlp.stanford.edu/software/stanford-parser-2012-11-12.Zip bien que.

Réponse originale

Je suggère que vous ne plaisante pas avec Jython, JPype. Laissez python faire python) et laisser Java faire Java Stanford Parser en sortie via la console.

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

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

alvas · Answer

À partir de la version 3.3 de NLTK, les utilisateurs doivent éviter les balises Stanford NER ou POS de nltk.tag, et éviter le tokenizer/segmenter de Stanford de nltk.tokenize.

Utilisez plutôt le nouveau nltk.parse.corenlp.CoreNLPParser API.

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

(Pour éviter la réponse par lien uniquement, j'ai collé les documents du wiki github NLTK 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-27 ré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é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')]

silverasm · Answer

La page du logiciel de traitement de la PNL de Stanford Core contient la liste des wrappers python:

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

Rohith · Answer

Il y a une interface python pour l’analyseur Stanford

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

bob dope · Answer

Si je me souviens bien, l'analyseur syntaxique de Stanford est une bibliothèque Java, vous devez donc disposer d'un interpréteur Java s'exécutant sur votre serveur/ordinateur).

Je l'ai utilisé une fois un serveur, combiné avec un script php. Le script utilisait la fonction exec () de php pour effectuer 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 fichier, l'a analysé et l'a écrit dans le résultat. PHP ouvrirait alors le fichier de résultat pour une utilisation ultérieure.

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

Je ne connais pas grand chose à propos de 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 inspirera. Bonne chance.

Avery Andrews · Answer

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 vraisemblablement avec les autres plates-formes, 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 à l'adresse 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 bocal, mais je n'ai pas réussi jusqu'à présent à le faire.

Sadik · Answer

Vous pouvez utiliser la sortie des analyseurs Stanford pour créer un arbre dans nltk (nltk.tree.Tree).

En supposant que l'analyseur 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 n'a pas l'air 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)

Zhong Zhu · Answer

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

Comme personne ne l’a vraiment mentionné et que cela m’inquiète beaucoup, 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 besoin de vous soucier du chemin.

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

Ted Petrou · Answer

Je suis sur une machine Windows et vous pouvez simplement exécuter l'analyseur normalement comme vous le faites à l'aide de la commande, mais comme dans un répertoire différent, de sorte que vous n'avez pas besoin de modifier le fichier lexparser.bat. Il suffit de mettre dans 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
lp\models\lexparser\englishFactored.ser.gz stanfordtemp.txt' parse_out = os.popen(cmd).readlines()

La partie délicate pour moi était de savoir comment exécuter un programme Java à partir d’un autre chemin. Il doit y avoir un meilleur moyen, mais cela fonctionne.

SYK · Answer

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 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 qu'il ne soit plus nécessaire d'extraire le fichier englishPCFG.ser.gz de stanford-parser-xxx-models .jar ou mettre en place un 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()

redreamality · Answer

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"
lp_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 = "
(ROOT".join(bracketed_parse.split(" (ROOT")).split('
') aa = map(lambda x :ParentedTree.fromstring(x),bracketed_parse)

NOTES:

Dans lexparser.bat vous devez modifier tous les chemins en un 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 que toutes les méthodes communiquent python avec Java échoue.
souhaite avoir de vos nouvelles si vous réussissez sur Windows et si vous voulez pouvoir me dire comment vous avez surmonté tous ces problèmes.
search python wrapper pour que stanford coreNLP obtienne le python version

H. Rev. · Answer

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

Je ne peux pas laisser cela comme un commentaire à cause de ma réputation, mais puisque j'ai passé (perdu?) Du temps à le résoudre, 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 de répertoire modèle.

Cela m'a conduit à tort à:

ne faites pas attention à la valeur que j'ai mise dans STANFORD_MODELS (et ne vous souciez que de mon CLASSPATH)
leave ../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 le PO, comme moi, souhaitait simplement utiliser l'analyseur, il pourrait être déroutant de ne pas télécharger quoi que ce soit d'autre (pas de POStagger, pas de NER, ...) et de suivre toutes ces instructions, nous obtenons toujours une erreur.

Finalement, pour tout CLASSPATH donné (exemples suivants et explications dans les réponses de ce fil), j'obtiendrais quand même l'erreur:

Stnford-parser n'a pas pu trouver NLTK \ 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

Bien que, surtout, je pourrais charger et utiliser correctement 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 il recherche les fichiers jar à l'aide des variables d'environnement STANFORD_MODELS Et CLASSPATH fournies. Pour résoudre ceci, le *-models.jar, Avec le formatage correct (pour correspondre à la regex dans le code NLTK, donc no -corenlp -.... jar) doit être situé dans le dossier désigné par STANFORD_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 faire en sorte que StanfordParser se charge facilement dans python avec le classique CLASSPATH qui pointe vers stanford-parser.jar.) En fait, vous pouvez appeler StanfordParser sans paramètres, la valeur par défaut ne fonctionnera que.

Enthusiast · Answer

J'ai pris de nombreuses heures et j'ai finalement trouvé une solution simple pour les utilisateurs de Windows. Fondamentalement, sa version résumée d'un réponse existante par alvas, mais elle est facile à suivre (espérons-le) pour ceux qui découvrent stanford NLP et qui utilisent 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 dans le cas où vous avez Java installé. Pour moi, c'était ci-dessous

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

5) importez le module souhaité

from nltk.tag import StanfordNERTagger

6) appelez le modèle pré-entraîné qui est présent dans le dossier classifier du dossier décompressé. ajoutez ".gz" à la fin pour l'extension du 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) Exécutez maintenant l'analyseur !! et nous avons fini !!

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

alvas · Answer

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 versions ultérieures.

É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 paraître très différente 3 à 6 mois plus tard. Veuillez traiter la réponse suivante comme temporelle et non comme une solution éternelle.

Reportez-vous toujours à https://github.com/nltk/nltk/wiki/Installing-Third-Party-Software pour obtenir les dernières instructions sur la manière de relier les outils Stanford NLP à l'aide de NLTK!

TL; DR

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

En 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. Regardez les docstrings!

Aditi · Answer

J'utilise nltk version 3.2.4. 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)

Sortie:

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