Est-il possible d'utiliser Stanford Parser dans NLTK? (Je ne parle pas de Stanford POS.)
Est-il possible d'utiliser Stanford Parser dans NLTK? (Je ne parle pas de Stanford POS.)
Réponses:
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:
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.
Téléchargez NLTK v3 depuis: https://github.com/nltk/nltk . Et installez NLTK:
installation sudo python setup.py
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 de 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 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
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.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.
Ouvrez le fichier stanford-parser-3.xx-models.jar à l'aide d'un gestionnaire d'archives (7zip).
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.
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.
Essayez mon exemple! (n'oubliez pas de changer les chemins de jar et de changer le chemin du modèle à l'emplacement ser.gz)
nltk.parse.stanford
? Je n'ai que nltk.tag.stanford
dans NLTK 2.0.4
.
AttributeError: 'StanfordParser' object has no attribute 'raw_batch_parse'
raw_parse_sents()
for line in sentences: for sentence in line: sentence.draw()
vous ne pouvez exécuter draw () que sur un objet Tree;)
NLTK official 3rd party tools
documentation.
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.
Remarque: La réponse suivante ne fonctionnera que sur:
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 !!
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'])])]
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' NLTK
API 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' NLTK
API 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_JAR
et STANFORD_PARSER
sont obsolètes et ne sont PLUS utilisées
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 ):
sudo pip install -U nltk
sudo apt-get install python-nltk
Pour Windows (utilisez l'installation binaire 32 bits):
( Pourquoi pas 64 bits? Voir https://github.com/nltk/nltk/issues/1079 )
Puis par paranoïa, revérifiez votre nltk
version à 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 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)
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:
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 .jar
fichier NLP Stanford approprié à la CLASSPATH
variable d'environnement.
stanford-ner-2015-04-20/stanford-ner.jar
stanford-postagger-full-2015-04-20/stanford-postagger.jar
stanford-parser-full-2015-04-20/stanford-parser.jar
le 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_MODELS
variable (c'est-à-dire le répertoire où vous pouvez trouver où les modèles pré-entraînés sont enregistrés)
stanford-ner-2015-04-20/classifiers/
stanford-postagger-full-2015-04-20/models/
Dans le code, voyez qu'il recherche le STANFORD_MODELS
ré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_JAR
variables sont obsolètes et ne sont PLUS utilisées . Les extraits de code trouvés dans les questions Stackoverflow suivantes peuvent ne pas fonctionner:
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 .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 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)
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.
À partir de l'analyseur de Stanford actuel (20/04/2015), 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 l'héritage, elle fonctionnera toujours avec http://nlp.stanford.edu/software/stanford-parser-2012-11-12.zip .
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
len(i.strip()) > 0
sinon j'ai eu une erreur d'index. Je suppose que la sortie de mon analyseur avait au moins une ligne qui était purement un espace blanc.
'
s, vous obtiendrez des erreurs étranges. Il existe de meilleures façons d'appeler les choses sur la ligne de commande
À partir de NLTK v3.3, les utilisateurs doivent éviter les marqueurs Stanford NER ou POS nltk.tag
et éviter le tokenizer / segmenter Stanford nltk.tokenize
.
Utilisez plutôt la nouvelle nltk.parse.corenlp.CoreNLPParser
API.
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
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')]
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', ['。'])])])]
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')]
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')]
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')]
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')]
list(parser.raw_parse(text))
ou list(parser.parse(parser.tokenize(text))
. Correction de l'exemple;)
Il existe une interface python pour l'analyseur de Stanford
La page du logiciel Stanford Core NLP contient une liste de wrappers python:
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())
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.
Remarque: La réponse suivante ne fonctionnera que sur:
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 !!
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 à:
STANFORD_MODELS
(et ne se soucient de ma CLASSPATH
)../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 CLASSPATH
donné (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)
Par conséquent, l'erreur est venue de NLTK
et comment il recherche les fichiers JAR en utilisant les variables d'environnement STANFORD_MODELS
et fournies CLASSPATH
. Pour résoudre ce problème, le *-models.jar
, avec le formatage correct (pour correspondre à l'expression NLTK
ré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 CLASSPATH
qui pointe vers stanford-parser.jar
. En fait, en tant que tel, vous pouvez appeler StanfordParser
sans 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.