Stanford Parser et NLTK

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

Voir aussi: gist.github.com/alvations/e1df0ba227e542955a8a
Ce lien doit être plus visible. Peut-être le sommet réponse devrait être modifié afin de le mentionner?
Juste une note de côté ici les gars. Assurez-vous que Java est à jour pour Stanford PNL et JAVA_HOME est mis en place correctement. Parfois, les gens pourraient obtenir "bizarre" des erreurs qui pourraient être dues à cette.
Pour NLTK v3.3, voir stackoverflow.com/a/51981566/610569

InformationsquelleAutor ThanaDaray | 2012-12-14

85

Noter que cette réponse s'applique à NLTK v 3.0, et de ne pas les versions plus récentes.

Sûr, essayez les solutions suivantes dans 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()
```
De sortie:

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

Note 1:
Dans cet exemple, les deux analyseur & modèle pots sont dans le même dossier.

Note 2:
- Nom de fichier de stanford parser est: stanford-parser.jar
- Nom de fichier de stanford modèles: stanford-parser-x.x.x-models.jar
Note 3:
L'englishPCFG.ser.gz le fichier peut être trouvé à l'intérieur de l'models.jar fichier (/edu/stanford/nlp/models/lexparser/englishPCFG.ser.gz). Veuillez utiliser venir gestionnaire d'archives pour décompresser l'models.jar fichier.

Note 4:
Assurez-vous que vous utilisez Java JRE (Runtime Environment) 1.8 aussi connu comme Oracle JDK 8. Autrement, vous obtiendrez: non pris en charge majeure.version mineure 52.0.

Installation
1. Télécharger NLTK v3 à partir de: https://github.com/nltk/nltk. Et installer NLTK:
  
  sudo python setup.py installer
2. Vous pouvez utiliser le NLTK downloader pour obtenir Stanford Parser, à l'aide de Python:
```
import nltk
nltk.download()
```
3. Essayer mon exemple! (n'oubliez pas le changement du pot de chemins et de modifier le modèle de chemin d'accès à la ser.gz emplacement)
OU:
1. Télécharger et installer NLTK v3, comme ci-dessus.
2. Télécharger la dernière version de (version actuelle nom de fichier est stanford-parser-full-2015-01-29.zip):
  http://nlp.stanford.edu/software/lex-parser.shtml#Download
3. Extrait de l'standford-parser-full-20xx-xx-xx.zip.
4. Créer un nouveau dossier (les pots de " dans mon exemple). Placer 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 cette 'pots' dossier. Je suis sous Linux, donc si vous utilisez Windows, veuillez utiliser quelque chose comme: C://folder//jars.
5. Ouvrir la stanford-parser-3.x.x-models.jar à l'aide d'un gestionnaire d'Archives (7zip).
6. Parcourir à l'intérieur du fichier jar; edu/stanford/pnl/modèles/lexparser. Encore une fois, extraire le fichier nommé 'englishPCFG.ser.gz'. Rappelez-vous l'emplacement où vous avez extrait de ce ser.gz fichier.
7. Lors de la création d'un StanfordParser exemple, vous pouvez fournir le modèle de chemin en tant que paramètre. C'est le chemin complet du modèle, dans notre cas /location/of/englishPCFG.ser.gz.
8. Essayer mon exemple! (n'oubliez pas le changement du pot de chemins et de modifier le modèle de chemin d'accès à la ser.gz emplacement)
- Elle donne une erreur pour moi. nom d'importation de stanford pas trouvé.
- La version de la nltk ajouté nltk.parse.stanford? Je n'ai que nltk.tag.stanford dans NLTK 2.0.4.
- AttributeError: 'StanfordParser' object has no attribute 'raw_batch_parse'
- Je ne trouve pas le module nltk.l'analyser.stanford soit.
- télécharger nltk 3.0 à partir de ici @Nick Retallack: il doit être modifié pour raw_parse_sents()
- Il me donne le texte suivant: "Erreur: impossible de trouver ou charger la classe principale de edu.stanford.la pnl.analyseur.lexparser.LexicalizedParser"
- J'ai ajouté un plus à expliquer comment. Voir la version mise à jour ci-dessus. Vous n'avez pas besoin d'aller à la page github. Et je ne peux toujours utiliser le raw_batch_parse, ce qui vous permet d'analyser plusieurs phrases en un seul appel.
- où aimeriez-vous que pour trouver le draw méthode? J'utilise la dernière version de NLTK, mais il ne semble pas avoir cette mise en œuvre. Connaissez-vous des alternatives?
- Ok, vous avez raison. NLTK les changements de la fonction: raw_parse_sents(). Voir la Documentation: nltk.org/_modules/nltk/parse/stanford.html Si vous utilisez le raw_parse() vous allez récupérer une iter(Arbre) comme valeur de retour. Sens l'exemple ci-dessus de draw() devrait fonctionner. Si vous utilisez le raw_parse_sents(), vous avez besoin d'une double boucle apparemment ; c'est au retour d'une iter(iter(Arbre)). Donc le code exemple: for line in sentences: for sentence in line: sentence.draw() Vous ne pouvez exécuter draw() sur un objet de l'Arborescence 😉
- désolé pour écraser votre réponse à la note modifiée. Récemment, les gens ont été se plaindre de la Stanford de la Dépendance de l'analyseur est que récemment ajoutés depuis NLTK v3.1 et je pense qu'ils ont été dupliquer quelques bouts de code ici et là de l'obsolète réponses ici. Afin de réduire au minimum la confusion, j'ai pensé qu'il est préférable d'ajouter des avertissements à ici toutes les réponses en ce qui concerne en suivant les instructions à partir de NLTK official 3rd party tools de la documentation.
- Peut-être que je devrais mettre à jour la réponse accordantly, il utilise maintenant des variables d'environnement?
- Oui, c'est à l'aide de variables d'environnement, mais ils sont différents. Pour l'analyseur, il faut STANFORDTOOLSDIR être dans CLASSPATH pour l'analyseur jarfiles et la parser_model jarfiles, par exemple export CLASSPATH=$STANFORDTOOLSDIR/stanford-parser-full-2015-04-20/stanford-parser.jar:$STANFORDTOOLSDIR/stanford-parser-full-2015-04-20/stanford-parser-3.5.2-models.jar
- C'est la réponse qui a effectivement travaillé! Je ne sais pas pourquoi ce n'est pas la accepté de Répondre Merci @danger89
- Salut merci maq, je ne sais pas pourquoi ce n'est pas la accepté de répondre ><
InformationsquelleAutor danger89

Obsolète Réponse

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

ÉDITÉ

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

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

À la fois comme outils de changements assez rapidement et l'API peut paraître très différents de 3 à 6 mois plus tard. Merci de traiter la réponse suivante temporelle et pas une éternelle correctif.

Toujours se référer à https://github.com/nltk/nltk/wiki/Installing-Third-Party-Software pour la dernière instruction sur la façon d'interface Stanford PNL outils à l'aide de NLTK!!

TL;DR

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

Alors:

>>> 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 Stanford PNL outils sont écrits en Java et NLTK est écrit en Python. La façon NLTK est à l'interface de l'outil est par l'appel de l'outil Java par le biais de l'interface de ligne de commande.

Deuxièmement, le NLTK API pour le Stanford des outils de TALN ont vraiment changé depuis la version 3.1. Il est donc conseillé de mettre à jour votre NLTK paquet v3.1.

Troisièmement, le NLTK API Stanford, des Outils de TALN s'enroule autour de la personne des outils de TALN, par exemple Stanford POS tagger, Stanford NER Tagger, Stanford Parser.

Pour le POS et le TNS tagger, il NE PAS s'enrouler autour de la Stanford de Base de la PNL paquet.

Pour le Stanford Parser, c'est un cas particulier où il s'enroule autour de la Stanford et l'Analyseur de Stanford de Base de la PNL (personnellement, je n'ai pas utilisé celui-ci en utilisant NLTK, je préfère suivre @dimazest démonstration sur http://www.eecs.qmul.ac.uk/~dm303/stanford-dependency-parser-nltk-and-anaconda.html )

Noter que NLTK v3.1, la STANFORD_JAR et STANFORD_PARSER variables est obsolète et N'est PLUS utilisé

En Plus:

ÉTAPE 1

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

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

Utilisation de pip: sudo pip install -U nltk
Debian, distro (avec apt-get): sudo apt-get install python-nltk

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

Installer Python 3.4: http://www.python.org/downloads/ (éviter les versions 64 bits)
Installer Numpy (facultatif): http://sourceforge.net/projects/numpy/files/NumPy/ (la version qui spécifie pythnon3.4)
Installer NLTK: http://pypi.python.org/pypi/nltk
Installation de Test: Start>Python34, puis tapez importer nltk

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

Puis de la paranoïa, vérifiez votre nltk à l'intérieur de la version 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 de voir 3.1 que la sortie.

Pour encore plus de paranoïa, vérifiez que tous vos favori Stanford des outils de TALN API 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 sera SEULEMENT assurez-vous d'utiliser un bon NLTK version qui contient ces Api. Ne pas voir les erreurs dans l'importation ne signifie pas que vous avez correctement configuré les NLTK API à utiliser le Stanford Outils)

ÉTAPE 2

Maintenant que vous avez vérifié que vous avez la bonne version de NLTK que contient le nécessaire Stanford PNL outils de l'interface. Vous devez télécharger et extraire tout le nécessaire Stanford des outils de TALN.

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

Dans Windows /Mac:

Téléchargez et décompressez l'analyseur de http://nlp.stanford.edu/software/lex-parser.shtml#Download
Télécharger et unizp la VERSION COMPLÈTE marqueur http://nlp.stanford.edu/software/tagger.shtml#Download
Télécharger et unizp le TNS marqueur http://nlp.stanford.edu/software/CRF-NER.shtml#Download

ÉTAPE 3

Configurer les variables d'environnement telles que NLTK peut trouver le chemin d'accès au fichier automatiquement. Vous devez définir les variables suivantes:

Ajouter approprié Stanford PNL .jar fichier à la CLASSPATH variable d'environnement.
- par exemple, pour les TNS, il sera stanford-ner-2015-04-20/stanford-ner.jar
- par exemple, pour le point de vente, il sera stanford-postagger-full-2015-04-20/stanford-postagger.jar
- par exemple, pour l'analyseur, il sera stanford-parser-full-2015-04-20/stanford-parser.jar et le modèle d'analyseur de fichier jar, stanford-parser-full-2015-04-20/stanford-parser-3.5.2-models.jar
Ajouter le modèle approprié répertoire de la STANFORD_MODELS variable (c'est à dire le répertoire où vous pouvez trouver où la pré-formés modèles sont sauvegardés)
- par exemple, pour les TNS, il sera dans stanford-ner-2015-04-20/classifiers/
- par exemple, pour le point de vente, il sera dans stanford-postagger-full-2015-04-20/models/
- par exemple, pour l'Analyseur, il n'y aura pas un modèle de répertoire.

Dans le code, voir ce qu'il recherche l' STANFORD_MODELS répertoire avant d'ajouter le nom du modèle. Voir que, l'API a également automatiquement essaie de rechercher les environnements d'OS pour la `CLASSPATH)

Noter que NLTK v3.1, la STANFORD_JAR variables est obsolète et N'est PLUS utilisé. Des extraits de Code dans les Stackoverflow questions risquent de ne pas fonctionner:

TL;DR pour l'ÉTAPE 3 sur Ubuntu

export STANFORDTOOLSDIR=/home/path/to/stanford/tools/
export CLASSPATH=$STANFORDTOOLSDIR/stanford-postagger-full-2015-04-20/stanford-postagger.jar:$STANFORDTOOLSDIR/stanford-ner-2015-04-20/stanford-ner.jar:$STANFORDTOOLSDIR/stanford-parser-full-2015-04-20/stanford-parser.jar:$STANFORDTOOLSDIR/stanford-parser-full-2015-04-20/stanford-parser-3.5.2-models.jar
export STANFORD_MODELS=$STANFORDTOOLSDIR/stanford-postagger-full-2015-04-20/models:$STANFORDTOOLSDIR/stanford-ner-2015-04-20/classifiers

(Pour Windows: Voir https://stackoverflow.com/a/17176423/610569 pour les instructions de configuration des variables d'environnement)

Vous DOIT définir les variables comme ci-dessus avant de commencer 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'])])])])])])]

Sinon, vous pouvez essayer d'ajouter les variables d'environnement à l'intérieur de python, comme les réponses précédentes ont suggéré, mais vous pouvez aussi directement dire l'analyseur/tagger pour initialiser le chemin direct où vous avez gardé 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 de ses changements de noms de paramètres, vous aurez besoin de changer en conséquence. C'est pourquoi il est PLUS judicieux de définir les variables d'environnement que de modifier votre code python pour répondre à la NLTK version.

Par exemple (sans définir toutes les 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)

InformationsquelleAutor alvas

22

Obsolète Réponse

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

Édité

De l'Stanford parser (2015-04-20), la sortie par défaut de la lexparser.sh a modifié le script ci-dessous ne fonctionnera pas.

Mais cette réponse est conservé pour l'héritage souci, il faudra encore travailler avec http://nlp.stanford.edu/software/stanford-parser-2012-11-12.zip bien.

Réponse Originale À Cette Question

Je vous suggère de ne pas jouer avec Jython, JPype. Laissez python n'python trucs et laissez java java, obtenir le Stanford Parser la sortie par le biais de la console.

Après que vous avez installé le Stanford Parser dans votre répertoire home ~/, il suffit d'utiliser cette python recette pour obtenir le plat entre crochets analyser:
```
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
```
- Cela a fonctionné pour moi sauf que j'ai besoin d'ajouter une condition pour vérifier len(i.strip()) > 0 sinon j'ai eu une erreur d'index. Je suppose que mon analyseur de sortie a au moins une ligne qui a été purement espaces.
- vous pouvez également utiliser ce wrapper python pour stanford corenlp outils, bitbucket.org/torotoki/corenlp-python
- Soyez prudent avec cela. Si votre entrée contient tout 's, vous obtiendrez des erreurs étranges. Il y a solutions pour appeler les choses sur la ligne de commande
InformationsquelleAutor alvas
7

Il y a python interface pour le stanford parser

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

InformationsquelleAutor Rohith
7

La Stanford de Base de la PNL logiciel page présente une liste des wrappers python:

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

InformationsquelleAutor silverasm
6

Si je me souviens bien, le Stanford parser est une bibliothèque java, par conséquent, vous devez disposer d'un interprète de Java en cours d'exécution sur votre serveur/ordinateur.

Je l'ai utilisé une fois un serveur, combiné avec un script php. Le script php exec() de la fonction d'une commande de ligne de l'appel à l'analyseur de la sorte:
```
<?php
exec( "java -cp /pathTo/stanford-parser.jar -mx100m edu.stanford.nlp.process.DocumentPreprocessor /pathTo/fileToParse > /pathTo/resultFile 2>/dev/null" );
?>
```
Je ne me souviens pas de tous les détails de cette commande, il a ouvert la fileToParse, analysé, et a écrit la sortie dans le resultFile. PHP serait alors d'ouvrir le fichier de résultat pour une utilisation ultérieure.

La fin de la commande indique à l'analyseur est détaillé à la valeur NULL, pour éviter de ligne de commande informations de déranger le script.

Je ne sais pas beaucoup sur Python, mais il y a peut-être un moyen de faire des appels de ligne de commande.

Il pourrait ne pas être l'itinéraire exact que vous avez été, mais j'espère que ça va vous donner un peu d'inspiration. Le meilleur de la chance.

InformationsquelleAutor bob dope
6

Noter que cette réponse s'applique à NLTK v 3.0, et de ne pas les versions plus récentes.

Ici est une adaptation de danger98 du code qui fonctionne avec nltk3.0.0 sur windoze, et sans doute les autres plates-formes ainsi, adapter 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
```
Noter que le traitement de la commande a changé (voir le code source à la http://www.nltk.org/_modules/nltk/parse/stanford.html), et que vous avez besoin de définir la JAVAHOME variable. J'ai essayé de le faire lire le fichier de grammaire in situ dans le pot, mais ont jusqu'à présent échoué à le faire.
- Je suis de 1989 pas 98, mais merci pour votre exemple 😉
InformationsquelleAutor Avery Andrews
4

Vous pouvez utiliser le Stanford Analyseurs de sortie pour créer un Arbre dans nltk (nltk.d'arbre en arbre.De l'arbre).

En supposant que le stanford parser vous donne un fichier dans lequel il y a exactement un arbre d'analyse pour chaque phrase.
Alors que cet exemple fonctionne, même si cela peut sembler très pythonic:
```
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)
```
- +1 pour laisser java java et python n'python choses. En fonction de comment vous appelez la commande java et les options, l'analyse du fichier de sortie à partir de stanford parser peuvent être différentes. Il serait bon si vous aussi vous avez ajouté des détails sur la façon dont vous l'avez appelé le Stanford Parser pour obtenir votre fichier de sortie.
InformationsquelleAutor Sadik
3

Je suis sur une machine windows, et vous pouvez simplement utiliser l'analyseur normalement comme vous le faites à partir de la commande de ce type, mais comme dans un répertoire différent de sorte que vous n'avez pas besoin de modifier le lexparser.le fichier bat. Il suffit de mettre dans le chemin d'accès complet.
```
cmd = r'java -cp \Documents\stanford_nlp\stanford-parser-full-2015-01-30 edu.stanford.nlp.parser.lexparser.LexicalizedParser -outputFormat "typedDependencies" \Documents\stanford_nlp\stanford-parser-full-2015-01-30\stanford-parser-3.5.1-models\edu\stanford\nlp\models\lexparser\englishFactored.ser.gz stanfordtemp.txt'
parse_out = os.popen(cmd).readlines()
```
La partie la plus délicate pour moi a été de réaliser comment faire pour exécuter un programme java à partir d'un chemin d'accès différent. Il doit y avoir une meilleure façon, mais cela fonctionne.

InformationsquelleAutor Ted Petrou
3

Noter que cette réponse s'applique à NLTK v 3.0, et de ne pas les versions plus récentes.

Une légère mise à jour (ou tout simplement de rechange) sur danger89 globale de réponse sur l'utilisation de Stanford Parser en NLTK et Python

Avec stanford parser-plein-2015-04-20, JRE 1,8 et nltk 3.0.4 (python 2.7.6), il semble que vous n'avez plus besoin d'extraire le englishPCFG.ser.gz à partir de stanford-parser-x.x.x-models.jar ou la mise en place de 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()
```
InformationsquelleAutor SYK
3

Noter que cette réponse s'applique à NLTK v 3.0, et de ne pas les versions plus récentes.

Ici est la version windows de alvas la réponse de
```
sentences = ('. '.join(['this is sentence one without a period','this is another foo bar sentence '])+'.').encode('ascii',errors = 'ignore')
catpath =r"YOUR CURRENT FILE PATH"
f = open('stanfordtemp.txt','w')
f.write(sentences)
f.close()
parse_out = os.popen(catpath+r"\nlp_tools\stanford-parser-2010-08-20\lexparser.bat "+catpath+r"\stanfordtemp.txt").readlines()
bracketed_parse = " ".join( [i.strip() for i in parse_out if i.strip() if i.strip()[0] == "("] )
bracketed_parse = "\n(ROOT".join(bracketed_parse.split(" (ROOT")).split('\n')
aa = map(lambda x :ParentedTree.fromstring(x),bracketed_parse)
```
NOTES:
- Dans lexparser.bat vous avez besoin de changer tous les chemins en chemin absolu pour éviter la java des erreurs telles que "la classe n'est pas trouvé"
- Je vous recommande vivement d'appliquer cette méthode sous windows depuis que j'ai Essayé plusieurs réponses sur la page et toutes les méthodes communique python avec Java échoue.
- souhait de vous entendre si vous réussissez sur windows et souhaitez vous pouvez me dire comment vous surmonter tous ces problèmes.
- de recherche wrapper python pour stanford coreNLP pour obtenir la version de python
InformationsquelleAutor redreamality
3

Noter que cette réponse s'applique à NLTK v 3.0, et de ne pas les versions plus récentes.

Depuis, personne n'a vraiment mentionné et c'est quelque chose me préoccupait beaucoup, ici, c'est une autre façon d'utiliser Stanford parser en python:
```
stanford_parser_jar = '../lib/stanford-parser-full-2015-04-20/stanford-parser.jar'
stanford_model_jar = '../lib/stanford-parser-full-2015-04-20/stanford-parser-3.5.2-models.jar'    
parser = StanfordParser(path_to_jar=stanford_parser_jar, 
path_to_models_jar=stanford_model_jar)
```
de cette façon, vous n'avez pas besoin de s'inquiéter à propos de la voie plus rien.

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

InformationsquelleAutor Zhong Zhu
2

J'ai pris plusieurs heures et a finalement trouvé une solution simple pour les utilisateurs de Windows. Fondamentalement sa version résumée d'un réponse existant par alvas, mais facile à suivre(espérons-le) pour ceux qui sont nouveaux à stanford la PNL et sont de la Fenêtre utilisateurs.

1) Télécharger le module que vous souhaitez utiliser, tels que les TNS, POS etc. Dans mon cas, j'ai voulu utiliser le TNS, donc j'ai téléchargé le module de http://nlp.stanford.edu/software/stanford-ner-2015-04-20.zip

2) Décompressez le fichier.

3) Définir 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éfinir les variables d'environnement JAVA, là où vous avez installé JAVA. pour moi, c'était en dessous de
```
os.environ['JAVAHOME'] = "C:/Program Files/Java/jdk1.8.0_102/bin/java.exe"
```
5) importer le module que vous souhaitez
```
from nltk.tag import StanfordNERTagger
```
6) appel de la pré-entraîné modèle qui est présent dans le classificateur dossier dans le dossier dézippé. ajouter ".gz" à la fin de l'extension de fichier. pour moi le modèle que je voulais utiliser, a été english.all.3class.distsim.crf.ser
```
st = StanfordNERTagger('english.all.3class.distsim.crf.ser.gz')
```
7) Maintenant exécuter l'analyseur!! et nous sommes en fait!!!!
```
st.tag('Rami Eid is studying at Stony Brook University in NY'.split())
```
- Voir gist.github.com/alvations/0ed8641d7d2e1941b9f9 et gist.github.com/alvations/e1df0ba227e542955a8a
InformationsquelleAutor Enthusiast

Obsolète Réponse

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

ÉDITÉ

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

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

Toujours se référer à https://github.com/nltk/nltk/wiki/Installing-Third-Party-Software pour la dernière instruction sur la façon d'interface Stanford PNL outils à l'aide de NLTK!!

TL;DR

La suite du code vient 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 jeter un oeil à http://www.nltk.org/_modules/nltk/parse/corenlp.html pour plus d'informations sur le Stanford API. Jetez un oeil à la docstrings!

InformationsquelleAutor alvas

2

Noter que cette réponse s'applique à NLTK v 3.0, et de ne pas les versions plus récentes.

Je ne peux pas laisser cela comme un commentaire en raison de la réputation, mais depuis que j'ai passé (perdu?) certains de temps à résoudre ce que je préfère partager mon problème/solution pour obtenir cet analyseur de travailler dans NLTK.

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

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

Ce qui m'a conduit à tort à:
- pas attention à la valeur que j'ai mis à STANFORD_MODELS (et ne se soucient que mon CLASSPATH)
- laisser ../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, je voulais juste utiliser l'analyseur, il peut être source de confusion que lorsqu'il n'est pas télécharger quoi que ce soit d'autre (pas de POStagger, aucun PARTENAIRE,...) et de suivre toutes ces instructions, nous obtenons toujours une erreur.

Finalement, pour tout CLASSPATH donné (à la suite des exemples et des explications dans les réponses de ce fil) je reçois toujours le message d'erreur:

NLTK n'a pas pu trouver de 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éfinir le CLASSPATH
variable d'environnement. Pour plus d'informations sur stanford-parser.jar,
voir: http://nlp.stanford.edu/software/lex-parser.shtml

Si, important, j'ai pu charger correctement et d'utiliser l'analyseur si j'appelle la fonction avec tous les arguments et le chemin d'accès entièrement spécifié, 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 Parser seul:

Donc l'erreur vient de NLTK et comment il est à la recherche pour les bocaux à l'aide de l'fournis STANFORD_MODELS et CLASSPATH variables d'environnement. Pour résoudre cela,*-models.jar, avec la mise en forme correcte (pour correspondre à la regex dans NLTK code, donc pas de -corenlp-....jar) doit être situé dans le dossier désigné par STANFORD_MODELS.

À savoir, j'ai d'abord créé:
```
mkdir stanford-parser-full-2015-12-09/models
```
Ensuite ajouté dans .bashrc:
```
export STANFORD_MODELS=/path/to/stanford-parser-full-2015-12-09/models
```
Et enfin, par la copie de stanford-parser-3.6.0-models.jar (ou version correspondante), dans:
```
path/to/stanford-parser-full-2015-12-09/models/
```
J'ai pu obtenir StanfordParser à la charge en douceur en python, avec la classique CLASSPATH que les points de stanford-parser.jar. En fait, en tant que tel, vous pouvez appeler StanfordParser sans paramètres, la valeur par défaut d'un travail juste.

InformationsquelleAutor H. Rev.

Je suis en utilisant nltk version 3.2.4. Et suivants du code a fonctionné pour moi.

from nltk.internals import find_jars_within_path
from nltk.tag import StanfordPOSTagger
from nltk import word_tokenize
# Alternatively to setting the CLASSPATH add the jar and model via their 
path:
jar = '/home/ubuntu/stanford-postagger-full-2017-06-09/stanford-postagger.jar'
model = '/home/ubuntu/stanford-postagger-full-2017-06-09/models/english-left3words-distsim.tagger'
pos_tagger = StanfordPOSTagger(model, jar)
# Add other jars from Stanford directory
stanford_dir = pos_tagger._stanford_jar.rpartition('/')[0]
stanford_jars = find_jars_within_path(stanford_dir)
pos_tagger._stanford_jar = ':'.join(stanford_jars)
text = pos_tagger.tag(word_tokenize("Open app and play movie"))
print(text)

De sortie:

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

Je pense que c'est le marqueur et pas l'analyseur

InformationsquelleAutor Aditi

Vous devez vous connecter pour publier un commentaire.

Installation

Obsolète Réponse

ÉDITÉ

TL;DR

En Long:

En Plus:

ÉTAPE 1

ÉTAPE 2

ÉTAPE 3

Obsolète Réponse

Édité

Réponse Originale À Cette Question

Obsolète Réponse

ÉDITÉ

TL;DR

Solution pour Parser seul: