94 votes

ThanaDaray avatar

Comment utiliser le parseur de Stanford dans NLTK en utilisant Python ?

Demandé el 14 de Décembre, 2012
Quand la question a-t-elle été
106473 affichage
Nombre de visites la question a
5 Réponses
Nombre de réponses aux questions
Résolu
Situation réelle de la question

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

Demandé el 14 de Décembre, 2012 par ThanaDaray

Réponses

Trop de publicités?

94voto

danger89 avatar
danger89 Points 329

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()

Sortie :

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

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

Note 2 :

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

Note 3 : Le fichier englishPCFG.ser.gz se trouve à l'adresse suivante à l'intérieur de le fichier models.jar (/edu/stanford/nlp/models/lexparser/englishPCFG.ser.gz). Veuillez utiliser un gestionnaire d'archives pour "décompresser" le fichier models.jar.

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

Installation

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

    sudo python setup.py install

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

    import nltk
nltk.download()

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

OU :

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

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

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

  4. Créez un nouveau dossier ('jars' dans mon exemple). Placez les fichiers extraits dans ce dossier jar : stanford-parser-3.x.x-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, utilisez quelque chose comme : C://dossier//jars.

  5. Ouvrez le fichier stanford-parser-3.x.x-models.jar en utilisant un gestionnaire d'archives (7zip).

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

  7. Lors de la création d'une instance de StanfordParser, vous pouvez fournir le chemin du modèle comme paramètre. Il s'agit du 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 du jar et de changer le chemin du modèle à l'emplacement du ser.gz)

Répondu el 8 de Mars, 2014 par danger89 (329 Points )

78voto

alvas avatar
alvas Points 4333

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 plus.

EDITED

Remarque : la réponse suivante ne fonctionne que sur :

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

Comme les deux outils évoluent assez rapidement, l'API peut être très différente 3 à 6 mois plus tard. Veuillez considérer la réponse suivante comme temporaire 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'interfacer les outils NLP de Stanford en utilisant NLTK !

TL;DR

cd $HOME

# Update / Install NLTK
pip install -U nltk

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

export STANFORDTOOLSDIR=$HOME

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

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

Ensuite :

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

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

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

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

Dans Long :

Tout d'abord on doit noter que Les outils NLP de Stanford sont écrits en Java. y NLTK est écrit en Python . La façon dont NLTK s'interface avec l'outil est d'appeler l'outil Java via l'interface de ligne de commande.

Ensuite, le NLTK L'API des outils NLP de Stanford a beaucoup changé depuis la version 3.1. Il est donc conseillé de mettre à jour votre paquetage NLTK à la version 3.1.

Troisièmement, le NLTK L'API des outils NLP de Stanford s'articule autour des outils NLP individuels, par exemple Tagueur POS de Stanford , Tagger NER de Stanford , Analyseur de Stanford .

Pour l'étiqueteur POS et NER, c'est N'EST PAS s'enroulent autour de la Paquet Stanford Core NLP .

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

Notez qu'à partir de NLTK v3.1, l'attribut STANFORD_JAR y STANFORD_PARSER est obsolète et n'est PLUS utilisée.

En plus long :

ÉTAPE 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 de NLTK (voir http://www.nltk.org/install.html ) :

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

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

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

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

Ensuite, par paranoïa, revérifiez votre nltk version dans 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 tous vos outils API Stanford NLP préférés 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 UNIQUEMENT assurez-vous que vous utilisez une version correcte de NLTK qui contient ces APIs. Le fait de ne pas voir d'erreurs dans l'importation ne signifie pas que vous avez configuré avec succès l'API NLTK pour utiliser les outils Stanford).

ÉTAPE 2

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

TL;DR dans 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 :

ÉTAPE 3

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

  • Ajoutez la PNL appropriée de Stanford .jar vers le fichier CLASSPATH variable d'environnement.

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

  • Ajoutez le répertoire de modèle approprié au répertoire STANFORD_MODELS (c'est-à-dire le répertoire où vous pouvez trouver l'endroit où sont sauvegardés les modèles pré-entraînés)

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

Dans le code, voyez qu'il recherche l'élément STANFORD_MODELS avant d'ajouter le nom du modèle. Vous pouvez également constater que l'API tente automatiquement de rechercher dans les environnements du système d'exploitation les éléments suivants `CLASSPATH )

Notez qu'à partir de NLTK v3.1, l'attribut STANFORD_JAR est obsolète et n'est PLUS utilisée. . Les extraits de code trouvés dans les questions Stackoverflow suivantes peuvent 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 relatives à la définition des variables d'environnement)

Vous MUST 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 les réponses précédentes l'ont suggéré, mais vous pouvez aussi dire directement à l'analyseur/traceur de s'initialiser au chemin direct où vous avez conservé 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 modifie les noms de ses 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 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)
Répondu el 6 de Décembre, 2015 par alvas (4333 Points )

25voto

alvas avatar
alvas Points 4333

A partir de NLTK v3.3, les utilisateurs doivent éviter le NER de Stanford ou les tagueurs POS de nltk.tag et éviter Stanford tokenizer/segmenter de 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

(Pour éviter de ne répondre que par un lien, j'ai collé les documents du wiki github de NLTK ci-dessous).

D'abord, mettez à 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 stanford-corenlp-full-2018-02-27 démarrez le serveur :

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

Puis en Python :

>>> from nltk.parse import CoreNLPParser

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

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

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

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

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

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

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

Chinois

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

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

En Python :

>>> parser = CoreNLPParser('http://localhost:9001')
>>> list(parser.tokenize(u''))
['', '', '', '']

>>> list(parser.parse(parser.tokenize(u'')))
[Tree('ROOT', [Tree('IP', [Tree('IP', [Tree('NP', [Tree('NN', [''])]), Tree('VP', [Tree('VE', ['']), Tree('NP', [Tree('NN', [''])])])]), Tree('PU', [''])])])]

Arabe

Démarrez le serveur :

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

En Python :

>>> from nltk.parse import CoreNLPParser
>>> parser = CoreNLPParser('http://localhost:9005')
>>> text = u' '

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

# Tokenizer / Segmenter.
>>> list(parser.tokenize(text))
['', '']

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

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

Français

Démarrez le serveur :

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

En Python :

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

Allemand

Démarrez le serveur :

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

En Python :

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

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

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

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

Espagnol

Démarrez le serveur :

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

En Python :

>>> pos_tagger = CoreNLPParser('http://localhost:9003', tagtype='pos')
>>> pos_tagger.tag(u'Barack Obama salió con Michael Jackson .'.split())
[('Barack', 'PROPN'), ('Obama', 'PROPN'), ('salió', 'VERB'), ('con', 'ADP'), ('Michael', 'PROPN'), ('Jackson', 'PROPN'), ('.', 'PUNCT')]
>>> ner_tagger = CoreNLPParser('http://localhost:9003', tagtype='ner')
>>> ner_tagger.tag(u'Barack Obama salió con Michael Jackson .'.split())
[('Barack', 'PERSON'), ('Obama', 'PERSON'), ('salió', 'O'), ('con', 'O'), ('Michael', 'PERSON'), ('Jackson', 'PERSON'), ('.', 'O')]
Répondu el 23 de Août, 2018 par alvas (4333 Points )

23voto

alvas avatar
alvas Points 4333

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 plus.

Modifié

À partir de l'analyseur syntaxique Stanford actuel (2015-04-20), la sortie par défaut de l'option lexparser.sh a changé, donc le script ci-dessous ne fonctionnera pas.

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

Réponse originale

Je vous suggère de ne pas jouer avec Jython, JPype. Laissez python faire des trucs python et laissez java faire des trucs java, obtenez la sortie de l'analyseur Stanford dans la console.

Après avoir installé le Analyseur de Stanford dans votre répertoire personnel ~/ il suffit d'utiliser cette recette python pour obtenir la parse 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
Répondu el 17 de Janvier, 2013 par alvas (4333 Points )

7voto

Rohith avatar
Rohith Points 1071

Il existe une interface python pour l'analyseur syntaxique stanford.

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

Répondu el 18 de Décembre, 2012 par Rohith (1071 Points )

Questions en vedette

Top Tags

Dans notre réseau

Prograide.com

Prograide est une communauté de développeurs qui cherche à élargir la connaissance de la programmation au-delà de l'anglais.
Pour cela nous avons les plus grands doutes résolus en français et vous pouvez aussi poser vos propres questions ou résoudre celles des autres.

Powered by:

Yandex
X