Ist es möglich, Stanford Parser in NLTK zu verwenden? (Ich spreche nicht über Stanford POS.)
Ist es möglich, Stanford Parser in NLTK zu verwenden? (Ich spreche nicht über Stanford POS.)
Antworten:
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:
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.
Laden Sie NLTK v3 von folgender Adresse herunter: https://github.com/nltk/nltk . Und installieren Sie NLTK:
sudo python setup.py installieren
Sie können den NLTK-Downloader verwenden, um Stanford Parser mithilfe von Python abzurufen:
import nltk
nltk.download()
Probieren Sie mein Beispiel! (Vergessen Sie nicht, die JAR-Pfade und den Modellpfad zum ser.gz-Speicherort zu ändern.)
ODER:
Laden Sie NLTK v3 wie oben herunter und installieren Sie es.
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
Extrahieren Sie die Datei standford-parser-full-20xx-xx-xx.zip.
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.
Öffnen Sie die Datei stanford-parser-3.xx-models.jar mit einem Archivmanager (7zip).
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.
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.
Probieren Sie mein Beispiel! (Vergessen Sie nicht, die JAR-Pfade und den Modellpfad zum ser.gz-Speicherort zu ändern.)
nltk.parse.stanford
? Ich habe nur nltk.tag.stanford
in NLTK 2.0.4
.
AttributeError: 'StanfordParser' object has no attribute 'raw_batch_parse'
raw_parse_sents()
for line in sentences: for sentence in line: sentence.draw()
Sie können draw () nur für ein Tree-Objekt ausführen;)
NLTK official 3rd party tools
Dokumentation zu befolgen.
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.
Hinweis: Die folgende Antwort funktioniert nur bei:
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.
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'])])]
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 NLTK
API 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_JAR
und STANFORD_PARSER
Variablen ist veraltet und nicht mehr verwendet
Angenommen, Sie haben Java ordnungsgemäß auf Ihrem Betriebssystem installiert.
Installieren / aktualisieren Sie jetzt Ihre NLTK-Version (siehe http://www.nltk.org/install.html ):
sudo pip install -U nltk
sudo apt-get install python-nltk
Für Windows (Verwenden Sie die 32-Bit-Binärinstallation):
( Warum nicht 64 Bit? Siehe https://github.com/nltk/nltk/issues/1079 )
Überprüfen Sie dann aus Paranoia heraus Ihre nltk
Version 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.1
als 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.)
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:
Richten Sie die Umgebungsvariablen so ein, dass NLTK den relevanten Dateipfad automatisch findet. Sie müssen folgende Variablen einstellen:
Fügen Sie .jar
der CLASSPATH
Umgebungsvariablen die entsprechende Stanford NLP- Datei hinzu .
stanford-ner-2015-04-20/stanford-ner.jar
stanford-postagger-full-2015-04-20/stanford-postagger.jar
stanford-parser-full-2015-04-20/stanford-parser.jar
und die Parser-Modell-JAR-Datei,stanford-parser-full-2015-04-20/stanford-parser-3.5.2-models.jar
Fügen Sie der STANFORD_MODELS
Variablen das entsprechende Modellverzeichnis hinzu (dh das Verzeichnis, in dem Sie die vorab trainierten Modelle speichern können).
stanford-ner-2015-04-20/classifiers/
stanford-postagger-full-2015-04-20/models/
Stellen Sie im Code sicher, dass nach dem STANFORD_MODELS
Verzeichnis 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_JAR
Variablen veraltet sind und NICHT MEHR verwendet werden . Codefragmente in den folgenden Stackoverflow-Fragen funktionieren möglicherweise nicht:
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)
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.
Ab dem aktuellen Stanford-Parser (20.04.2015) hat sich die Standardausgabe für lexparser.sh
geä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 .
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
len(i.strip()) > 0
ein Indexfehler aufgetreten ist. Ich denke, meine Parser-Ausgabe hatte mindestens eine Zeile, die nur aus Leerzeichen bestand.
'
s enthält , werden einige seltsame Fehler angezeigt. Es gibt bessere Möglichkeiten , Dinge auf der Kommandozeile aufzurufen
Ab NLTK v3.3, Benutzer sollten vermeiden , die Stanford NER oder POS - Tagger aus nltk.tag
und vermeiden Stanford tokenizer / segmenter ausnltk.tokenize
.
Verwenden Sie stattdessen die neue nltk.parse.corenlp.CoreNLPParser
API.
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
stanford-corenlp-full-2018-02-27
Starten 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')]
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', ['。'])])])]
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')]
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')]
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')]
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')]
list(parser.raw_parse(text))
oder list(parser.parse(parser.tokenize(text))
. Das Beispiel wurde korrigiert;)
Es gibt eine Python-Schnittstelle für Stanford Parser
Die Stanford Core NLP-Softwareseite enthält eine Liste der Python-Wrapper:
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())
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.
Hinweis: Die folgende Antwort funktioniert nur bei:
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.
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:
STANFORD_MODELS
(und kümmere dich nur um meinen CLASSPATH
)../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 CLASSPATH
wü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)
Daher kam der Fehler von NLTK
und wie es nach Jars sucht, die die bereitgestellten STANFORD_MODELS
und CLASSPATH
Umgebungsvariablen verwenden. Um dies zu lösen, muss sich das *-models.jar
mit der richtigen Formatierung (um dem NLTK
regulä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 StanfordParser
mit dem Klassiker CLASSPATH
, der darauf hinweist, reibungslos in Python laden stanford-parser.jar
. Als solches können Sie StanfordParser
ohne 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.