Ist es möglich, Stanford Parser in NLTK zu verwenden? (Ich spreche nicht über Stanford POS.)

Beachten Sie, dass diese Antwort für NLTK v 3.0 und nicht für neuere Versionen gilt.

Versuchen Sie Folgendes in 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()

Ausgabe:

[Baum ('ROOT', [Baum ('S', [Baum ('INTJ', [Baum ('UH', ['Hallo'])]), Baum (',', [',']), Baum ('NP', [Baum ('PRP $', ['Mein']), Baum ('NN', ['Name'])]), Baum ('VP', [Baum ('VBZ', [) 'is']), Tree ('ADJP', [Tree ('JJ', ['Melroy'])])]), Tree ('.', ['.'])])]), Tree (' ROOT ', [Tree (' SBARQ ', [Tree (' WHNP ', [Tree (' WP ', [' What '])]), Tree (' SQ ', [Tree (' VBZ ', [' is ') ]), Baum ('NP', [Baum ('PRP $', ['dein']), Baum ('NN', ['Name'])])]), Baum ('.', ['? '])])])]

Anmerkung 1: In diesem Beispiel befinden sich sowohl die Parser- als auch die Modellgläser im selben Ordner.

Anmerkung 2:

• Der Dateiname des Stanford-Parsers lautet: stanford-parser.jar
• Der Dateiname der Stanford-Modelle lautet: stanford-parser-xxx-models.jar

Hinweis 3: Die Datei englishPCFG.ser.gz befindet sich in der Datei models.jar (/edu/stanford/nlp/models/lexparser/englishPCFG.ser.gz). Bitte verwenden Sie den Archivmanager, um die Datei models.jar zu entpacken.

Hinweis 4: Stellen Sie sicher, dass Sie Java JRE (Runtime Environment) 1.8 verwenden, das auch als Oracle JDK 8 bezeichnet wird. Andernfalls erhalten Sie: Nicht unterstützte major.minor-Version 52.0.

Installation

1. Laden Sie NLTK v3 von folgender Adresse herunter: https://github.com/nltk/nltk . Und installieren Sie NLTK:

   sudo python setup.py installieren

2. Sie können den NLTK-Downloader verwenden, um Stanford Parser mithilfe von Python abzurufen:

   import nltk
   nltk.download()

3. Probieren Sie mein Beispiel! (Vergessen Sie nicht, die JAR-Pfade und den Modellpfad zum ser.gz-Speicherort zu ändern.)

ODER:

1. Laden Sie NLTK v3 wie oben herunter und installieren Sie es.

2. Laden Sie die neueste Version von herunter (der aktuelle Dateiname lautet stanford-parser-full-2015-01-29.zip): http://nlp.stanford.edu/software/lex-parser.shtml#Download

3. Extrahieren Sie die Datei standford-parser-full-20xx-xx-xx.zip.

4. Erstellen Sie einen neuen Ordner (in meinem Beispiel 'Gläser'). Legen Sie die extrahierten Dateien in diesem JAR-Ordner ab: stanford-parser-3.xx-models.jar und stanford-parser.jar.

   Wie oben gezeigt, können Sie die Umgebungsvariablen (STANFORD_PARSER & STANFORD_MODELS) verwenden, um auf diesen Ordner "jars" zu verweisen. Ich verwende Linux. Wenn Sie also Windows verwenden, verwenden Sie bitte Folgendes: C: // Ordner // Gläser.

5. Öffnen Sie die Datei stanford-parser-3.xx-models.jar mit einem Archivmanager (7zip).

6. Durchsuchen Sie die JAR-Datei. edu / stanford / nlp / models / lexparser. Extrahieren Sie erneut die Datei 'englishPCFG.ser.gz'. Merken Sie sich den Speicherort, an dem Sie diese ser.gz-Datei extrahieren.

7. Beim Erstellen einer StanfordParser-Instanz können Sie den Modellpfad als Parameter angeben. Dies ist der vollständige Pfad zum Modell, in unserem Fall /location/of/englishPCFG.ser.gz.

8. Probieren Sie mein Beispiel! (Vergessen Sie nicht, die JAR-Pfade und den Modellpfad zum ser.gz-Speicherort zu ändern.)

Veraltete Antwort

Die unten stehende Antwort ist veraltet. Verwenden Sie die Lösung unter https://stackoverflow.com/a/51981566/610569 für NLTK v3.3 und höher.

BEARBEITET

Hinweis: Die folgende Antwort funktioniert nur bei:

• NLTK-Version> = 3.2.4
• Stanford Tools seit dem 20.04.2015 zusammengestellt
• Python 2.7, 3.4 und 3.5 (Python 3.6 wird noch nicht offiziell unterstützt)

Da sich beide Tools ziemlich schnell ändern und die API 3-6 Monate später möglicherweise sehr unterschiedlich aussieht. Bitte behandeln Sie die folgende Antwort als zeitlich und nicht als ewige Lösung.

Die neuesten Anweisungen zur Schnittstelle von Stanford NLP-Tools mit NLTK finden Sie immer unter https://github.com/nltk/nltk/wiki/Installing-Third-Party-Software.

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

Dann:

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

In Long:

Zunächst muss beachtet werden, dass die Stanford NLP-Tools in Java und NLTK in Python geschrieben sind . Die Art und Weise, wie NLTK das Tool verbindet, erfolgt über den Aufruf des Java-Tools über die Befehlszeilenschnittstelle.

Zweitens dieNLTK API für die Stanford NLP-Tools seit Version 3.1 erheblich geändert. Es ist daher ratsam, Ihr NLTK-Paket auf Version 3.1 zu aktualisieren.

Drittens umfasst die NLTKAPI für Stanford NLP Tools die einzelnen NLP-Tools, z. B. Stanford POS Tagger , Stanford NER Tagger und Stanford Parser .

Für den POS- und NER-Tagger wird das Stanford Core NLP-Paket NICHT umschlossen .

Für den Stanford Parser ist es ein Sonderfall, in dem sowohl der Stanford Parser als auch der Stanford Core NLP behandelt werden (persönlich habe ich letzteren nicht mit NLTK verwendet, ich würde lieber die Demonstration von @ dimazest auf http: //www.eecs verfolgen . qmul.ac.uk/~dm303/stanford-dependency-parser-nltk-and-anaconda.html )

Beachten Sie, dass ab NLTK v3.1, die STANFORD_JARund STANFORD_PARSERVariablen ist veraltet und nicht mehr verwendet

Länger:

SCHRITT 1

Angenommen, Sie haben Java ordnungsgemäß auf Ihrem Betriebssystem installiert.

Installieren / aktualisieren Sie jetzt Ihre NLTK-Version (siehe http://www.nltk.org/install.html ):

• Verwenden von pip :sudo pip install -U nltk
• Debian-Distribution (mit apt-get):sudo apt-get install python-nltk

Für Windows (Verwenden Sie die 32-Bit-Binärinstallation):

1. Installieren Sie Python 3.4: http://www.python.org/downloads/ (vermeiden Sie die 64-Bit-Versionen)
2. Installieren Sie Numpy (optional): http://sourceforge.net/projects/numpy/files/NumPy/ (die Version, die pythnon3.4 angibt)
3. Installieren Sie NLTK: http://pypi.python.org/pypi/nltk
4. Testinstallation: Start> Python34, dann import nltk eingeben

( Warum nicht 64 Bit? Siehe https://github.com/nltk/nltk/issues/1079 )

Überprüfen Sie dann aus Paranoia heraus Ihre nltkVersion in Python erneut:

from __future__ import print_function
import nltk
print(nltk.__version__)

Oder in der Kommandozeile:

python3 -c "import nltk; print(nltk.__version__)"

Stellen Sie sicher, dass Sie 3.1als Ausgabe sehen.

Überprüfen Sie für noch mehr Paranoia, ob alle Ihre bevorzugten Stanford NLP-Tools-API verfügbar sind:

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

( Hinweis : Die oben genannten Importe stellen NUR sicher, dass Sie eine korrekte NLTK-Version verwenden, die diese APIs enthält. Wenn beim Import keine Fehler angezeigt werden, bedeutet dies nicht, dass Sie die NLTK-API erfolgreich für die Verwendung der Stanford Tools konfiguriert haben.)

SCHRITT 2

Nachdem Sie überprüft haben, ob Sie die richtige Version von NLTK haben, die die erforderliche Schnittstelle für Stanford NLP-Tools enthält. Sie müssen alle erforderlichen Stanford NLP-Tools herunterladen und extrahieren.

TL; DR unter 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

In Windows / Mac:

• Laden Sie den Parser von http://nlp.stanford.edu/software/lex-parser.shtml#Download herunter und entpacken Sie ihn
• Laden Sie den FULL VERSION- Tagger von http://nlp.stanford.edu/software/tagger.shtml#Download herunter und entpacken Sie ihn
• Laden Sie den NER-Tagger von http://nlp.stanford.edu/software/CRF-NER.shtml#Download herunter und entpacken Sie ihn

SCHRITT 3

Richten Sie die Umgebungsvariablen so ein, dass NLTK den relevanten Dateipfad automatisch findet. Sie müssen folgende Variablen einstellen:

• Fügen Sie .jarder CLASSPATHUmgebungsvariablen die entsprechende Stanford NLP- Datei hinzu .

  • zB für die NER wird es sein stanford-ner-2015-04-20/stanford-ner.jar
  • zB für den POS wird es sein stanford-postagger-full-2015-04-20/stanford-postagger.jar
  • zB für den Parser wird es sein stanford-parser-full-2015-04-20/stanford-parser.jarund die Parser-Modell-JAR-Datei,stanford-parser-full-2015-04-20/stanford-parser-3.5.2-models.jar

• Fügen Sie der STANFORD_MODELSVariablen das entsprechende Modellverzeichnis hinzu (dh das Verzeichnis, in dem Sie die vorab trainierten Modelle speichern können).

  • zB für die NER wird es in sein stanford-ner-2015-04-20/classifiers/
  • zB für den POS wird es in sein stanford-postagger-full-2015-04-20/models/
  • Zum Beispiel für den Parser gibt es kein Modellverzeichnis.

Stellen Sie im Code sicher, dass nach dem STANFORD_MODELSVerzeichnis gesucht wird, bevor Sie den Modellnamen anhängen. Beachten Sie auch, dass die API automatisch versucht, die Betriebssystemumgebungen nach CLASSPATH zu durchsuchen )

Beachten Sie, dass ab NLTK v3.1 die STANFORD_JARVariablen veraltet sind und NICHT MEHR verwendet werden . Codefragmente in den folgenden Stackoverflow-Fragen funktionieren möglicherweise nicht:

• Stanford Dependency Parser Setup und NLTK
• nltk Schnittstelle zum Stanford Parser
• Probleme beim Importieren von Stanford Pos Tagger in nltk
• Stanford Entity Recognizer (ohne Gehäuse) in Python Nltk
• So verbessern Sie die Geschwindigkeit mit Stanford NLP Tagger und NLTK
• Wie kann ich das Stanford NLTK Python-Modul erhalten?
• Stanford Parser- und NLTK-Fenster
• Stanford Named Entity Recognizer (NER) -Funktionalität mit NLTK
• Der Stanford-Parser mit NLTK erzeugt eine leere Ausgabe
• Extrahieren Sie die Liste der Personen und Organisationen mit Stanford NER Tagger in NLTK
• Fehler beim Verwenden des Stanford POS Tagger in NLTK Python

TL; DR für STEP 3 unter 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

( Für Windows : Anweisungen zum Festlegen von Umgebungsvariablen finden Sie unter https://stackoverflow.com/a/17176423/610569. )

Sie MÜSSEN die Variablen wie oben festlegen, bevor Sie Python starten, dann:

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

Alternativ können Sie versuchen, die Umgebungsvariablen in Python hinzuzufügen, wie in den vorherigen Antworten vorgeschlagen, aber Sie können den Parser / Tagger auch direkt anweisen, den direkten Pfad zu initialisieren, in dem Sie die gespeichert haben .jar Datei und Ihre Modelle gespeichert haben.

Es ist NICHT erforderlich, die Umgebungsvariablen festzulegen, wenn Sie die folgende Methode verwenden, ABER wenn die API ihre Parameternamen ändert, müssen Sie sie entsprechend ändern. Aus diesem Grund ist es ratsamer, die Umgebungsvariablen festzulegen, als den Python-Code an die NLTK-Version anzupassen.

Zum Beispiel ( ohne Umgebungsvariablen festzulegen ):

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

Veraltete Antwort

Die unten stehende Antwort ist veraltet. Verwenden Sie die Lösung unter https://stackoverflow.com/a/51981566/610569 für NLTK v3.3 und höher.

Bearbeitet

Ab dem aktuellen Stanford-Parser (20.04.2015) hat sich die Standardausgabe für lexparser.shgeändert, sodass das folgende Skript nicht funktioniert.

Aber diese Antwort wird aus Gründen des Vermächtnisses aufbewahrt, sie wird immer noch funktionieren http://nlp.stanford.edu/software/stanford-parser-2012-11-12.zip .

Ursprüngliche Antwort

Ich schlage vor, Sie spielen nicht mit Jython, JPype. Lassen Sie Python Python-Sachen machen und lassen Sie Java Java-Sachen machen, und holen Sie sich die Stanford Parser-Ausgabe über die Konsole.

Nachdem Sie den Stanford Parser in Ihrem Home-Verzeichnis installiert haben ~/, verwenden Sie einfach dieses Python-Rezept, um die Analyse in flachen Klammern zu erhalten:

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

Ab NLTK v3.3, Benutzer sollten vermeiden , die Stanford NER oder POS - Tagger aus nltk.tagund vermeiden Stanford tokenizer / segmenter ausnltk.tokenize .

Verwenden Sie stattdessen die neue nltk.parse.corenlp.CoreNLPParserAPI.

Weitere Informationen finden Sie unter https://github.com/nltk/nltk/wiki/Stanford-CoreNLP-API-in-NLTK

(Vermeiden Sie die Antwort nur mit Links. Ich habe die Dokumente aus dem NLTK-Github-Wiki unten eingefügt.)

Aktualisieren Sie zunächst Ihr NLTK

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

Laden Sie dann die erforderlichen CoreNLP-Pakete herunter:

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 

Englisch

stanford-corenlp-full-2018-02-27Starten Sie den Server noch im Verzeichnis:

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

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

Chinesisch

Starten Sie den Server ein wenig anders, immer noch aus dem Verzeichnis `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

In 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', ['。'])])])]

Arabisch

Starten Sie den Server:

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

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

Französisch

Starten Sie den Server:

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

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

Deutsche

Starten Sie den Server:

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

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

Spanisch

Starten Sie den Server:

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

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

Es gibt eine Python-Schnittstelle für Stanford Parser

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

Die Stanford Core NLP-Softwareseite enthält eine Liste der Python-Wrapper:

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

Wenn ich mich gut erinnere, ist der Stanford-Parser eine Java-Bibliothek, daher muss auf Ihrem Server / Computer ein Java-Interpreter ausgeführt werden.

Ich habe es einmal als Server benutzt, kombiniert mit einem PHP-Skript. Das Skript verwendete die exec () - Funktion von php, um einen Befehlszeilenaufruf an den Parser zu senden:

<?php

exec( "java -cp /pathTo/stanford-parser.jar -mx100m edu.stanford.nlp.process.DocumentPreprocessor /pathTo/fileToParse > /pathTo/resultFile 2>/dev/null" );

?>

Ich erinnere mich nicht an alle Details dieses Befehls. Er öffnete im Grunde die Datei ToParse, analysierte sie und schrieb die Ausgabe in die Ergebnisdatei. PHP würde dann die Ergebnisdatei zur weiteren Verwendung öffnen.

Das Ende des Befehls leitet den ausführlichen Parser an NULL weiter, um zu verhindern, dass unnötige Befehlszeileninformationen das Skript stören.

Ich weiß nicht viel über Python, aber es gibt möglicherweise eine Möglichkeit, Befehlszeilenaufrufe zu tätigen.

Es ist vielleicht nicht die genaue Route, auf die Sie gehofft haben, aber hoffentlich gibt es Ihnen Inspiration. Viel Glück.

Beachten Sie, dass diese Antwort für NLTK v 3.0 und nicht für neuere Versionen gilt.

Hier ist eine Anpassung des Codes von gefahr98, der mit nltk3.0.0 auf windoze und vermutlich auch auf den anderen Plattformen funktioniert. Passen Sie die Verzeichnisnamen entsprechend Ihrem Setup an:

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

Beachten Sie, dass sich der Parsing-Befehl geändert hat (siehe Quellcode unter www.nltk.org/_modules/nltk/parse/stanford.html) und dass Sie die Variable JAVAHOME definieren müssen. Ich habe versucht, die Grammatikdatei vor Ort im Glas zu lesen, habe dies aber bisher nicht getan.

Mit der Ausgabe von Stanford Parsers können Sie einen Baum in nltk (nltk.tree.Tree) erstellen.

Angenommen, der Stanford-Parser gibt Ihnen eine Datei, in der es für jeden Satz genau einen Analysebaum gibt. Dann funktioniert dieses Beispiel, obwohl es möglicherweise nicht sehr pythonisch aussieht:

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)

Beachten Sie, dass diese Antwort für NLTK v 3.0 und nicht für neuere Versionen gilt.

Da niemand wirklich erwähnt hat und es mich irgendwie sehr beunruhigt hat, gibt es hier eine alternative Möglichkeit, den Stanford-Parser in Python zu verwenden:

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)

Auf diese Weise müssen Sie sich keine Sorgen mehr um den Pfad machen.

Für diejenigen, die es unter Ubuntu nicht richtig verwenden oder den Code in Eclipse ausführen können.

Ich bin auf einem Windows-Computer und Sie können den Parser einfach normal ausführen, wie Sie es über den Befehl tun, aber wie in einem anderen Verzeichnis, sodass Sie die Datei lexparser.bat nicht bearbeiten müssen. Geben Sie einfach den vollständigen Pfad ein.

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

Der schwierige Teil für mich war zu erkennen, wie man ein Java-Programm von einem anderen Pfad aus ausführt. Es muss einen besseren Weg geben, aber das funktioniert.

Beachten Sie, dass diese Antwort für NLTK v 3.0 und nicht für neuere Versionen gilt.

Ein kleines Update (oder einfach eine Alternative) zu der umfassenden Antwort von gefahr89 zur Verwendung von Stanford Parser in NLTK und Python

Mit stanford-parser-full-2015-04-20, JRE 1.8 und nltk 3.0.4 (Python 2.7.6) müssen Sie die englische Datei PCFG.ser.gz anscheinend nicht mehr aus stanford-parser-xxx-Modellen extrahieren .jar oder Einrichten einer 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()

Beachten Sie, dass diese Antwort für NLTK v 3.0 und nicht für neuere Versionen gilt.

Hier ist die Windows-Version von Alvas 'Antwort

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)

ANMERKUNGEN:

• In müssen lexparser.bat Sie alle Pfade in absolute Pfade ändern, um Java-Fehler wie "Klasse nicht gefunden" zu vermeiden.

• Ich empfehle Ihnen dringend, diese Methode unter Windows anzuwenden, da ich mehrere Antworten auf der Seite ausprobiert habe und alle Methoden, mit denen Python mit Java kommuniziert, fehlschlagen.

• Ich möchte von Ihnen hören, wenn Sie unter Windows erfolgreich sind, und Sie können mir sagen, wie Sie all diese Probleme überwinden.

• Durchsuchen Sie den Python-Wrapper nach Stanford CoreNLP, um die Python-Version zu erhalten

Ich habe viele Stunden gebraucht und endlich eine einfache Lösung für Windows-Benutzer gefunden. Grundsätzlich ist es eine zusammengefasste Version einer vorhandenen Antwort von alvas, die jedoch (hoffentlich) für diejenigen, die neu in Stanford NLP sind und Windows-Benutzer sind, leicht zu befolgen ist.

1) Laden Sie das Modul herunter, das Sie verwenden möchten, z. B. NER, POS usw. In meinem Fall wollte ich NER verwenden, also habe ich das Modul von http://nlp.stanford.edu/software/stanford-ner-2015- heruntergeladen. 04-20.zip

2) Entpacken Sie die Datei.

3) Legen Sie die Umgebungsvariablen (classpath und stanford_modules) aus dem entpackten Ordner fest.

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) Stellen Sie die Umgebungsvariablen für JAVA so ein, wie Sie JAVA installiert haben. für mich war es unten

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

5) Importieren Sie das gewünschte Modul

from nltk.tag import StanfordNERTagger

6) Rufen Sie das vorab trainierte Modell auf, das sich im Klassifikatorordner im entpackten Ordner befindet. Fügen Sie am Ende ".gz" für die Dateierweiterung hinzu. Für mich war das Modell, das ich verwenden wollteenglish.all.3class.distsim.crf.ser

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

7) Führen Sie nun den Parser aus !! und wir sind fertig !!

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

Veraltete Antwort

Die unten stehende Antwort ist veraltet. Verwenden Sie die Lösung unter https://stackoverflow.com/a/51981566/610569 für NLTK v3.3 und höher.

BEARBEITET

Hinweis: Die folgende Antwort funktioniert nur bei:

• NLTK-Version == 3.2.5
• Stanford Tools seit dem 31.10.2016 zusammengestellt
• Python 2.7, 3.5 und 3.6

Da sich beide Tools ziemlich schnell ändern und die API 3-6 Monate später möglicherweise sehr unterschiedlich aussieht. Bitte behandeln Sie die folgende Antwort als zeitlich und nicht als ewige Lösung.

Die neuesten Anweisungen zur Schnittstelle von Stanford NLP-Tools mit NLTK finden Sie immer unter https://github.com/nltk/nltk/wiki/Installing-Third-Party-Software.

TL; DR

Der folgende Code stammt von https://github.com/nltk/nltk/pull/1735#issuecomment-306091826

Im 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

In 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

Weitere Informationen zur Stanford-API finden Sie unter http://www.nltk.org/_modules/nltk/parse/corenlp.html . Schauen Sie sich die Docstrings an!

Beachten Sie, dass diese Antwort für NLTK v 3.0 und nicht für neuere Versionen gilt.

Ich kann dies aufgrund des guten Rufs nicht als Kommentar hinterlassen, aber da ich einige Zeit damit verbracht habe, dies zu lösen, möchte ich lieber mein Problem / meine Lösung teilen, damit dieser Parser in NLTK funktioniert.

In der ausgezeichneten Antwort von alvas wird erwähnt, dass:

Zum Beispiel für den Parser gibt es kein Modellverzeichnis.

Dies führte mich fälschlicherweise zu:

• Sei nicht vorsichtig mit dem Wert, den ich lege STANFORD_MODELS (und kümmere dich nur um meinen CLASSPATH)
• lass ../path/tostanford-parser-full-2015-2012-09/models directory* praktisch leer * (oder mit einer JAR-Datei, deren Name nicht mit nltk regex übereinstimmt)!

Wenn das OP, wie ich, nur den Parser verwenden wollte, kann es verwirrend sein, dass beim Herunterladen von nichts anderem (kein POStagger, kein NER, ...) und Befolgen all dieser Anweisungen immer noch eine Fehlermeldung angezeigt wird.

Letztendlich CLASSPATHwürde ich für jeden Fall (folgende Beispiele und Erklärungen in den Antworten aus diesem Thread) immer noch den Fehler erhalten:

NLTK konnte keinen Stanford-Parser finden - (\ d +) (. (\ D +)) + - models.jar! Legen Sie die Umgebungsvariable CLASSPATH fest. Weitere Informationen zum Stanford-Parser - (\ d +) (. (\ D +)) + - models.jar,

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

ODER:

NLTK konnte stanford-parser.jar nicht finden! Legen Sie die Umgebungsvariable CLASSPATH fest. Weitere Informationen zu stanford-parser.jar finden Sie unter: http://nlp.stanford.edu/software/lex-parser.shtml

Obwohl , was wichtig ist, konnte ich richtig laden und verwenden Sie den Parser , wenn ich die Funktion mit allen Argumenten und Pfad vollständig spezifiziert, wie in genannt:

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)

Lösung nur für Parser:

Daher kam der Fehler von NLTKund wie es nach Jars sucht, die die bereitgestellten STANFORD_MODELSund CLASSPATHUmgebungsvariablen verwenden. Um dies zu lösen, muss sich das *-models.jarmit der richtigen Formatierung (um dem NLTKregulären Ausdruck im Code zu entsprechen, also kein -corenlp -.... jar) in dem durch bezeichneten Ordner befinden STANFORD_MODELS.

Ich habe nämlich zuerst erstellt:

mkdir stanford-parser-full-2015-12-09/models

Dann hinzugefügt in .bashrc:

export STANFORD_MODELS=/path/to/stanford-parser-full-2015-12-09/models

Und schließlich durch Kopieren stanford-parser-3.6.0-models.jar(oder entsprechende Version) in:

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

Ich könnte StanfordParsermit dem Klassiker CLASSPATH, der darauf hinweist, reibungslos in Python laden stanford-parser.jar. Als solches können Sie StanfordParserohne Parameter aufrufen , die Standardeinstellung funktioniert nur.

Ich benutze nltk Version 3.2.4. Und der folgende Code hat bei mir funktioniert.

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)

Ausgabe:

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

Eine neue Entwicklung des Stanford-Parsers, der auf einem neuronalen Modell basiert und mit Tensorflow trainiert wurde, wurde kürzlich zur Verwendung als Python-API zur Verfügung gestellt. Dieses Modell soll weitaus genauer sein als das Java-basierte Moel. Sie können sich sicher in eine NLTK-Pipeline integrieren.

Link zum Parser. Das Repository enthält vorab trainierte Parser-Modelle für 53 Sprachen.