Czy można używać Stanford Parser w NLTK? (Nie mówię o Stanford POS.)
Czy można używać Stanford Parser w NLTK? (Nie mówię o Stanford POS.)
Odpowiedzi:
Zauważ, że ta odpowiedź dotyczy NLTK v 3.0, a nie nowszych wersji.
Jasne, spróbuj wykonać następujące czynności w Pythonie:
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()
Wynik:
[Drzewo ('ROOT', [Drzewo ('S', [Drzewo ('INTJ', [Drzewo ('UH', ['Witaj'])]), Drzewo (',', [',']), Drzewo ('NP', [Drzewo ('PRP $', ['My']), Drzewo ('NN', ['nazwa'])]), Drzewo ('VP', [Drzewo ('VBZ', [ 'is']), Drzewo ('ADJP', [Drzewo ('JJ', ['Melroy'])])]), Drzewo ('.', ['.'])])]), Drzewo (' ROOT ', [Drzewo (' SBARQ ', [Drzewo (' WHNP ', [Drzewo (' WP ', [' Co '])]), Drzewo (' SQ ', [Drzewo (' VBZ ', [' to ' ]), Drzewo ('NP', [Drzewo ('PRP $', ['twoje']), Drzewo ('NN', ['nazwa'])])]), Drzewo ('.', ['? '])])])]
Uwaga 1: W tym przykładzie zarówno parser, jak i słoiki modelu znajdują się w tym samym folderze.
Uwaga 2:
Uwaga 3: Plik englishPCFG.ser.gz można znaleźć w pliku models.jar (/edu/stanford/nlp/models/lexparser/englishPCFG.ser.gz). Proszę użyć menedżera archiwum come, aby „rozpakować” plik models.jar.
Uwaga 4: Upewnij się, że używasz środowiska Java JRE (Runtime Environment) 1.8, znanego również jako Oracle JDK 8. W przeciwnym razie otrzymasz: Nieobsługiwaną wersję major.minor 52.0.
Pobierz NLTK v3 z: https://github.com/nltk/nltk . I zainstaluj NLTK:
sudo python setup.py install
Możesz użyć narzędzia do pobierania NLTK, aby pobrać Stanford Parser, używając Pythona:
import nltk
nltk.download()
Wypróbuj mój przykład! (nie zapomnij o zmianie ścieżek jar i zmień ścieżkę modelu do lokalizacji ser.gz)
LUB:
Pobierz i zainstaluj NLTK v3, tak samo jak powyżej.
Pobierz najnowszą wersję z ( nazwa pliku aktualnej wersji to stanford-parser-full-2015-01-29.zip): http://nlp.stanford.edu/software/lex-parser.shtml#Download
Wypakuj standford-parser-full-20xx-xx-xx.zip.
Utwórz nowy folder (w moim przykładzie „jars”). Umieść wyodrębnione pliki w tym folderze jar: stanford-parser-3.xx-models.jar i stanford-parser.jar.
Jak pokazano powyżej, możesz użyć zmiennych środowiskowych (STANFORD_PARSER i STANFORD_MODELS), aby wskazać ten folder „jars”. Używam Linuksa, więc jeśli używasz Windowsa, użyj czegoś takiego jak: C: // folder // jars.
Otwórz plik stanford-parser-3.xx-models.jar za pomocą programu Archive Manager (7zip).
Przeglądaj zawartość pliku jar; edu / stanford / nlp / models / lexparser. Ponownie wyodrębnij plik o nazwie „englishPCFG.ser.gz”. Zapamiętaj lokalizację, w której wypakowujesz ten plik ser.gz.
Podczas tworzenia instancji StanfordParser można podać ścieżkę modelu jako parametr. To jest pełna ścieżka do modelu, w naszym przypadku /location/of/englishPCFG.ser.gz.
Wypróbuj mój przykład! (nie zapomnij o zmianie ścieżek jar i zmień ścieżkę modelu do lokalizacji ser.gz)
nltk.parse.stanford
? Mam tylko nltk.tag.stanford
w 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()
Draw () można wykonać tylko na obiekcie Tree;)
NLTK official 3rd party tools
dokumentacji.
Poniższa odpowiedź jest przestarzała. Skorzystaj z rozwiązania pod adresem https://stackoverflow.com/a/51981566/610569 dla NLTK w wersji 3.3 i nowszych.
Uwaga: następująca odpowiedź będzie działać tylko na:
Ponieważ oba narzędzia zmieniają się dość szybko, a interfejs API może wyglądać zupełnie inaczej 3-6 miesięcy później. Proszę potraktować następującą odpowiedź jako tymczasową, a nie wieczną poprawkę.
Zawsze patrz https://github.com/nltk/nltk/wiki/Installing-Third-Party-Software, aby uzyskać najnowsze instrukcje dotyczące interfejsu narzędzi NLP Stanforda za pomocą NLTK !!
cd $HOME
# Update / Install NLTK
pip install -U nltk
# Download the Stanford NLP tools
wget http://nlp.stanford.edu/software/stanford-ner-2015-04-20.zip
wget http://nlp.stanford.edu/software/stanford-postagger-full-2015-04-20.zip
wget http://nlp.stanford.edu/software/stanford-parser-full-2015-04-20.zip
# Extract the zip file.
unzip stanford-ner-2015-04-20.zip
unzip stanford-parser-full-2015-04-20.zip
unzip stanford-postagger-full-2015-04-20.zip
export STANFORDTOOLSDIR=$HOME
export CLASSPATH=$STANFORDTOOLSDIR/stanford-postagger-full-2015-04-20/stanford-postagger.jar:$STANFORDTOOLSDIR/stanford-ner-2015-04-20/stanford-ner.jar:$STANFORDTOOLSDIR/stanford-parser-full-2015-04-20/stanford-parser.jar:$STANFORDTOOLSDIR/stanford-parser-full-2015-04-20/stanford-parser-3.5.2-models.jar
export STANFORD_MODELS=$STANFORDTOOLSDIR/stanford-postagger-full-2015-04-20/models:$STANFORDTOOLSDIR/stanford-ner-2015-04-20/classifiers
Następnie:
>>> 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'])])]
Po pierwsze , należy zauważyć, że narzędzia Stanford NLP są napisane w Javie, a NLTK w Pythonie . Sposób, w jaki NLTK łączy się z narzędziem, polega na wywołaniu narzędzia Java za pośrednictwem interfejsu wiersza poleceń.
Po drugie , plikNLTK
API do narzędzi Stanford NLP zmieniło się całkiem sporo od wersji 3.1. Dlatego zaleca się zaktualizowanie pakietu NLTK do wersji 3.1.
Po trzecie , NLTK
API do Stanford NLP Tools obejmuje poszczególne narzędzia NLP, np. Stanford POS tagger , Stanford NER Tagger , Stanford Parser .
W przypadku taggera POS i NER NIE OWIJ SIĘ on wokół pakietu Stanford Core NLP .
W przypadku Stanford Parser jest to szczególny przypadek, w którym obejmuje on zarówno Stanford Parser, jak i Stanford Core NLP (osobiście nie korzystałem z tego ostatniego przy użyciu NLTK, wolałbym raczej śledzić demonstrację @ dimazest na http: //www.eecs. qmul.ac.uk/~dm303/stanford-dependency-parser-nltk-and-anaconda.html )
Zwróć uwagę, że od wersji NLTK 3.1 STANFORD_JAR
STANFORD_PARSER
zmienne i są przestarzałe i NIE JUŻ JESZCZE używane
Zakładając, że poprawnie zainstalowałeś Javę w swoim systemie operacyjnym.
Teraz zainstaluj / zaktualizuj swoją wersję NLTK (patrz http://www.nltk.org/install.html ):
sudo pip install -U nltk
sudo apt-get install python-nltk
Dla Windowsa (użyj 32-bitowej instalacji binarnej):
( Dlaczego nie 64-bitowy? Zobacz https://github.com/nltk/nltk/issues/1079 )
Następnie wyjdź z paranoi i sprawdź ponownie swoją nltk
wersję w Pythonie:
from __future__ import print_function
import nltk
print(nltk.__version__)
Lub w wierszu poleceń:
python3 -c "import nltk; print(nltk.__version__)"
Upewnij się, że widzisz 3.1
jako wynik.
Aby uzyskać jeszcze więcej paranoi, sprawdź, czy dostępne są wszystkie Twoje ulubione API narzędzi NLP Stanforda:
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
( Uwaga : powyższy import zapewni TYLKO , że używasz poprawnej wersji NLTK, która zawiera te interfejsy API. Brak błędów w imporcie nie oznacza, że pomyślnie skonfigurowałeś NLTK API do korzystania z narzędzi Stanford)
Teraz, gdy sprawdziłeś, że masz poprawną wersję NLTK, która zawiera niezbędny interfejs narzędzi Stanford NLP. Musisz pobrać i rozpakować wszystkie niezbędne narzędzia Stanford NLP.
TL; DR , w systemie 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
W systemie Windows / Mac:
Skonfiguruj zmienne środowiskowe tak, aby NLTK mógł automatycznie znaleźć odpowiednią ścieżkę do pliku. Musisz ustawić następujące zmienne:
Dodaj odpowiedni .jar
plik NLP Stanforda do CLASSPATH
zmiennej środowiskowej.
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
plik jar modelu parsera,stanford-parser-full-2015-04-20/stanford-parser-3.5.2-models.jar
Dodaj odpowiedni katalog modelu do STANFORD_MODELS
zmiennej (tj. Katalog, w którym można znaleźć miejsce, w którym zapisano wstępnie wytrenowane modele)
stanford-ner-2015-04-20/classifiers/
stanford-postagger-full-2015-04-20/models/
W kodzie zobacz, że wyszukuje STANFORD_MODELS
katalog przed dołączeniem nazwy modelu. Zobacz również, że interfejs API próbuje również automatycznie przeszukiwać środowiska systemu operacyjnego pod kątem `` CLASSPATH )
Należy zauważyć, że od wersji NLTK 3.1 STANFORD_JAR
zmienne są przestarzałe i NIE są już używane . Fragmenty kodu znalezione w następujących pytaniach Stackoverflow mogą nie działać:
TL; DR dla STEP 3 na 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
( W przypadku systemu Windows : zobacz https://stackoverflow.com/a/17176423/610569, aby uzyskać instrukcje dotyczące ustawiania zmiennych środowiskowych)
Państwo musi ustawić zmienne jak wyżej, przed rozpoczęciem Pythona, a następnie:
>>> 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'])])])])])])]
Alternatywnie, możesz spróbować dodać zmienne środowiskowe w pythonie, jak sugerowały poprzednie odpowiedzi, ale możesz również bezpośrednio powiedzieć parserowi / taggerowi, aby zainicjował się do bezpośredniej ścieżki, w której trzymałeś .jar
plik i modele.
Nie ma potrzeby ustawiania zmiennych środowiskowych, jeśli używasz następującej metody, ALE gdy interfejs API zmienia nazwy parametrów, będziesz musiał odpowiednio zmienić. Dlatego BARDZIEJ wskazane jest ustawienie zmiennych środowiskowych niż modyfikowanie kodu Pythona w celu dostosowania do wersji NLTK.
Na przykład ( bez ustawiania żadnych zmiennych środowiskowych ):
# 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)
Poniższa odpowiedź jest przestarzała. Skorzystaj z rozwiązania pod adresem https://stackoverflow.com/a/51981566/610569 dla NLTK w wersji 3.3 i nowszych.
Od obecnego parsera Stanforda (20.04.2015) domyślne dane wyjściowe dla programu lexparser.sh
uległy zmianie, więc poniższy skrypt nie będzie działał.
Ale ta odpowiedź została zachowana ze względu na dziedzictwo, ale nadal będzie działać z http://nlp.stanford.edu/software/stanford-parser-2012-11-12.zip .
Radzę nie zadzierać z Jythonem, JPype. Pozwól pythonowi robić rzeczy w Pythonie i pozwól java robić rzeczy java, pobierz dane wyjściowe Stanford Parser za pośrednictwem konsoli.
Po zainstalowaniu parsera Stanforda w swoim katalogu domowym ~/
, po prostu użyj tego przepisu w Pythonie, aby uzyskać płaską analizę w nawiasach kwadratowych:
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
przeciwnym razie wystąpił błąd indeksu. Wydaje mi się, że wyjście mojego parsera zawierało co najmniej jedną linię, która była czysto białą.
'
s, pojawią się dziwne błędy. Są lepsze sposoby na wywoływanie rzeczy z wiersza poleceń
Począwszy od NLTK v3.3, użytkownicy powinni unikać tych taggers Stanford NER lub z POS nltk.tag
i uniknąć Stanford tokenizer / z segmentacji nltk.tokenize
.
Zamiast tego użyj nowego nltk.parse.corenlp.CoreNLPParser
interfejsu API.
Zobacz https://github.com/nltk/nltk/wiki/Stanford-CoreNLP-API-in-NLTK
(Unikam odpowiedzi tylko z linkiem, wklejałem dokumenty z NLTK na github wiki poniżej)
Najpierw zaktualizuj swoje NLTK
pip3 install -U nltk # Make sure is >=3.3
Następnie pobierz niezbędne pakiety CoreNLP:
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
Pozostając w stanford-corenlp-full-2018-02-27
katalogu, uruchom serwer:
java -mx4g -cp "*" edu.stanford.nlp.pipeline.StanfordCoreNLPServer \
-preload tokenize,ssplit,pos,lemma,ner,parse,depparse \
-status_port 9000 -port 9000 -timeout 15000 &
Następnie w Pythonie:
>>> 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')]
Uruchom serwer trochę inaczej, nadal z katalogu `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
W Pythonie:
>>> 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', ['。'])])])]
Uruchom serwer:
java -Xmx4g -cp "*" edu.stanford.nlp.pipeline.StanfordCoreNLPServer \
-serverProperties StanfordCoreNLP-arabic.properties \
-preload tokenize,ssplit,pos,parse \
-status_port 9005 -port 9005 -timeout 15000
W Pythonie:
>>> 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')]
Uruchom serwer:
java -Xmx4g -cp "*" edu.stanford.nlp.pipeline.StanfordCoreNLPServer \
-serverProperties StanfordCoreNLP-french.properties \
-preload tokenize,ssplit,pos,parse \
-status_port 9004 -port 9004 -timeout 15000
W Pythonie:
>>> 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')]
Uruchom serwer:
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
W Pythonie:
>>> 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')]
Uruchom serwer:
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
W Pythonie:
>>> 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))
lub list(parser.parse(parser.tokenize(text))
. Poprawiono przykład;)
Istnieje interfejs Pythona dla parsera Stanforda
Na stronie oprogramowania Stanford Core NLP znajduje się lista opakowań Pythona:
Jeśli dobrze pamiętam, parser Stanforda jest biblioteką java, dlatego na serwerze / komputerze musi być uruchomiony interpreter języka Java.
Użyłem go kiedyś jako serwer, w połączeniu ze skryptem php. Skrypt użył funkcji exec () php, aby wywołać parser w wierszu poleceń w następujący sposób:
<?php
exec( "java -cp /pathTo/stanford-parser.jar -mx100m edu.stanford.nlp.process.DocumentPreprocessor /pathTo/fileToParse > /pathTo/resultFile 2>/dev/null" );
?>
Nie pamiętam wszystkich szczegółów tego polecenia, w zasadzie otworzyło ono plik fileToParse, przeanalizowało go i zapisało dane wyjściowe w resultFile. PHP otworzy następnie plik wynikowy do dalszego użytku.
Koniec polecenia kieruje informacje szczegółowe parsera do wartości NULL, aby niepotrzebne informacje wiersza poleceń nie zakłócały skryptu.
Nie wiem zbyt wiele o Pythonie, ale może istnieć sposób na wywołanie wiersza poleceń.
Może nie jest to dokładna trasa, na którą liczyłeś, ale miejmy nadzieję, że da ci inspirację. Powodzenia.
Zauważ, że ta odpowiedź dotyczy NLTK v 3.0, a nie nowszych wersji.
Oto adaptacja kodu niebezpieczeństwa98, który działa z nltk3.0.0 na windoze i przypuszczalnie również na innych platformach, dostosuj nazwy katalogów odpowiednio do twojej konfiguracji:
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
Zauważ, że polecenie parsowania uległo zmianie (zobacz kod źródłowy na www.nltk.org/_modules/nltk/parse/stanford.html) i musisz zdefiniować zmienną JAVAHOME. Próbowałem go zmusić do odczytania pliku gramatyki in situ w słoiku, ale jak dotąd nie udało mi się to.
Możesz użyć danych wyjściowych Stanford Parsers, aby utworzyć drzewo w nltk (nltk.tree.Tree).
Zakładając, że parser Stanford daje plik, w którym na każde zdanie przypada dokładnie jedno drzewo analizy. Wtedy ten przykład działa, choć może nie wyglądać zbyt pythonowo:
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)
Zauważ, że ta odpowiedź dotyczy NLTK v 3.0, a nie nowszych wersji.
Ponieważ nikt tak naprawdę nie wspomniał i jakoś bardzo mnie to niepokoiło, oto alternatywny sposób użycia parsera Stanforda w Pythonie:
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)
w ten sposób nie musisz już martwić się o ścieżkę.
Dla tych, którzy nie mogą go poprawnie używać na Ubuntu lub uruchomić kodu w Eclipse.
Jestem na komputerze z systemem Windows i możesz po prostu uruchomić parser normalnie, tak jak robisz to z polecenia, ale tak jak w innym katalogu, więc nie musisz edytować pliku lexparser.bat. Po prostu wprowadź pełną ścieżkę.
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()
Najtrudniejsze dla mnie było uświadomienie sobie, jak uruchomić program Java z innej ścieżki. Musi być lepszy sposób, ale to działa.
Zauważ, że ta odpowiedź dotyczy NLTK v 3.0, a nie nowszych wersji.
Niewielka aktualizacja (lub po prostu alternatywa) kompleksowej odpowiedzi niebezpieczeństwa89 na temat używania Stanford Parser w NLTK i Pythonie
W przypadku stanford-parser-full-2015-04-20, JRE 1.8 i nltk 3.0.4 (python 2.7.6) wydaje się, że nie trzeba już wyodrębniać pliku englishPCFG.ser.gz ze stanford-parser-xxx-models .jar lub konfigurowanie dowolnego 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()
Zauważ, że ta odpowiedź dotyczy NLTK v 3.0, a nie nowszych wersji.
Oto odpowiedź alvas w wersji Windows
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)
UWAGI:
W lexparser.bat
musisz zmienić wszystkie ścieżki na ścieżki bezwzględne, aby uniknąć błędów Java, takich jak „nie znaleziono klasy”
Zdecydowanie zalecam stosowanie tej metody w systemie Windows, ponieważ próbowałem kilku odpowiedzi na stronie i wszystkie metody komunikują się w języku Python z Javą.
Chciałbym usłyszeć od Ciebie, jeśli odniesiesz sukces w oknach i chciałbym, abyś mógł mi powiedzieć, jak pokonałeś wszystkie te problemy.
wyszukaj opakowanie języka Python dla stanford coreNLP, aby uzyskać wersję Pythona
Zajęło mi to wiele godzin i wreszcie znalazłem proste rozwiązanie dla użytkowników Windowsa. Zasadniczo jest to podsumowana wersja istniejącej odpowiedzi od alvas, ale łatwa do naśladowania (miejmy nadzieję) dla tych, którzy są nowicjuszami w STANFORD NLP i są użytkownikami Windows.
1) Pobierz moduł, którego chcesz użyć, taki jak NER, POS itp. W moim przypadku chciałem użyć NER, więc pobrałem moduł ze strony http://nlp.stanford.edu/software/stanford-ner-2015- 04-20.zip
2) Rozpakuj plik.
3) Ustaw zmienne środowiskowe (classpath i stanford_modules) z rozpakowanego folderu.
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) ustaw zmienne środowiskowe dla JAVA, tak jak tam, gdzie masz zainstalowaną JAVĘ. dla mnie to było poniżej
os.environ['JAVAHOME'] = "C:/Program Files/Java/jdk1.8.0_102/bin/java.exe"
5) zaimportuj wybrany moduł
from nltk.tag import StanfordNERTagger
6) wywołaj wstępnie wytrenowany model, który znajduje się w folderze klasyfikatora w rozpakowanym folderze. dodaj na końcu ".gz" dla rozszerzenia pliku. dla mnie model, którego chciałem użyć, byłenglish.all.3class.distsim.crf.ser
st = StanfordNERTagger('english.all.3class.distsim.crf.ser.gz')
7) Teraz uruchom parser !! i gotowe !!
st.tag('Rami Eid is studying at Stony Brook University in NY'.split())
Poniższa odpowiedź jest przestarzała. Skorzystaj z rozwiązania pod adresem https://stackoverflow.com/a/51981566/610569 dla NLTK w wersji 3.3 i nowszych.
Uwaga: następująca odpowiedź będzie działać tylko na:
Ponieważ oba narzędzia zmieniają się dość szybko, a interfejs API może wyglądać zupełnie inaczej 3-6 miesięcy później. Proszę potraktować następującą odpowiedź jako tymczasową, a nie wieczną poprawkę.
Zawsze patrz https://github.com/nltk/nltk/wiki/Installing-Third-Party-Softwareuzyskać najnowsze instrukcje dotyczące interfejsu narzędzi NLP Stanforda za pomocą NLTK !!
Poniższy kod pochodzi z https://github.com/nltk/nltk/pull/1735#issuecomment-306091826
W terminalu:
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
W Pythonie:
>>> 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
Więcej informacji o interfejsie API Stanforda można znaleźć pod adresem http://www.nltk.org/_modules/nltk/parse/corenlp.html . Spójrz na dokumenty!
Zauważ, że ta odpowiedź dotyczy NLTK v 3.0, a nie nowszych wersji.
Nie mogę zostawić tego jako komentarza ze względu na reputację, ale ponieważ spędziłem (straciłem?) Trochę czasu na rozwiązywaniu tego, wolałbym podzielić się swoim problemem / rozwiązaniem, aby ten parser działał w NLTK.
W doskonałej odpowiedzi od alvas wspomina się, że:
np. dla Parsera nie będzie katalogu modeli.
To doprowadziło mnie niesłusznie do:
STANFORD_MODELS
(i dbam tylko o moje CLASSPATH
)../path/tostanford-parser-full-2015-2012-09/models directory
* praktycznie puste * (lub z plikiem jar, którego nazwa nie pasuje do wyrażenia regularnego nltk)!Jeśli OP, tak jak ja, chciał po prostu użyć parsera, może być mylące, że gdy nie pobiera niczego innego (bez POStaggera, bez NER, ...) i postępuje zgodnie z tymi wszystkimi instrukcjami, nadal otrzymujemy błąd.
Ostatecznie dla dowolnego CLASSPATH
podanego (następujące przykłady i wyjaśnienia w odpowiedziach z tego wątku) nadal otrzymywałbym błąd:
NLTK nie mógł znaleźć parsera stanforda - (\ d +) (. (\ D +)) + - models.jar! Ustaw zmienną środowiskową CLASSPATH. Więcej informacji na temat stanford-parser - (\ d +) (. (\ D +)) + - models.jar,
zobacz: http://nlp.stanford.edu/software/lex-parser.shtml
LUB:
NLTK nie może znaleźć pliku stanford-parser.jar! Ustaw zmienną środowiskową CLASSPATH. Więcej informacji można znaleźć na stronie stanford-parser.jar: http://nlp.stanford.edu/software/lex-parser.shtml
Chociaż , co ważne, mógłbym poprawnie załadować i użyć parsera, gdybym wywołał funkcję ze wszystkimi argumentami i ścieżką w pełni określoną, jak w:
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)
Dlatego błąd pochodzi NLTK
i jak szuka plików jar przy użyciu podanych STANFORD_MODELS
i CLASSPATH
zmiennych środowiskowych. Aby rozwiązać ten problem *-models.jar
, z odpowiednim formatowaniem (aby dopasować wyrażenie regularne w NLTK
kodzie, więc bez -corenlp -.... jar) musi znajdować się w folderze wskazanym przez STANFORD_MODELS
.
Mianowicie najpierw stworzyłem:
mkdir stanford-parser-full-2015-12-09/models
Następnie dodano .bashrc
:
export STANFORD_MODELS=/path/to/stanford-parser-full-2015-12-09/models
I wreszcie, kopiując stanford-parser-3.6.0-models.jar
(lub odpowiednią wersję) do:
path/to/stanford-parser-full-2015-12-09/models/
Mogłem StanfordParser
płynnie ładować w Pythonie z klasycznym, na CLASSPATH
który wskazuje stanford-parser.jar
. Właściwie jako taki możesz wywołać StanfordParser
bez parametrów, ustawienie domyślne po prostu zadziała.
Używam nltk w wersji 3.2.4. Poniższy kod zadziałał dla mnie.
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)
Wynik:
[('Open', 'VB'), ('app', 'NN'), ('and', 'CC'), ('play', 'VB'), ('movie', 'NN')]
Nowy rozwój parsera Stanford oparty na modelu neuronowym, wyszkolony przy użyciu Tensorflow, został niedawno udostępniony do wykorzystania jako API języka Python. Model ten ma być znacznie dokładniejszy niż model oparty na Javie. Z pewnością możesz zintegrować się z potokiem NLTK.
Link do parsera. Repozytorium Ther zawiera wstępnie wyszkolone modele parserów dla 53 języków.