Czy można używać Stanford Parser w NLTK? (Nie mówię o Stanford POS.)

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:

• Nazwa pliku parsera stanford to: stanford-parser.jar
• Nazwa pliku modeli stanford to: stanford-parser-xxx-models.jar

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.

Instalacja

1. Pobierz NLTK v3 z: https://github.com/nltk/nltk . I zainstaluj NLTK:

   sudo python setup.py install

2. Możesz użyć narzędzia do pobierania NLTK, aby pobrać Stanford Parser, używając Pythona:

   import nltk
   nltk.download()
   

3. Wypróbuj mój przykład! (nie zapomnij o zmianie ścieżek jar i zmień ścieżkę modelu do lokalizacji ser.gz)

LUB:

1. Pobierz i zainstaluj NLTK v3, tak samo jak powyżej.

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

3. Wypakuj standford-parser-full-20xx-xx-xx.zip.

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

5. Otwórz plik stanford-parser-3.xx-models.jar za pomocą programu Archive Manager (7zip).

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

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

8. Wypróbuj mój przykład! (nie zapomnij o zmianie ścieżek jar i zmień ścieżkę modelu do lokalizacji ser.gz)

Przestarzała odpowiedź

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.

EDYTOWANO

Uwaga: następująca odpowiedź będzie działać tylko na:

• Wersja NLTK> = 3.2.4
• Stanford Tools opracowywany od 20.04.2015
• Python 2.7, 3.4 i 3.5 (Python 3.6 nie jest jeszcze oficjalnie obsługiwany)

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 !!

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

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

W długim:

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 , NLTKAPI 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_JARSTANFORD_PARSER zmienne i są przestarzałe i NIE JUŻ JESZCZE używane

Dłużej:

KROK 1

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

• Korzystanie z pip :sudo pip install -U nltk
• Dystrybucja Debiana (przy użyciu apt-get):sudo apt-get install python-nltk

Dla Windowsa (użyj 32-bitowej instalacji binarnej):

1. Zainstaluj Python 3.4: http://www.python.org/downloads/ (unikaj wersji 64-bitowych)
2. Zainstaluj Numpy (opcjonalnie): http://sourceforge.net/projects/numpy/files/NumPy/ (wersja, która określa pythnon3.4)
3. Zainstaluj NLTK: http://pypi.python.org/pypi/nltk
4. Instalacja testowa: Start> Python34, a następnie wpisz import nltk

( Dlaczego nie 64-bitowy? Zobacz https://github.com/nltk/nltk/issues/1079 )

Następnie wyjdź z paranoi i sprawdź ponownie swoją nltkwersję 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)

KROK 2

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:

• Pobierz i rozpakuj parser z http://nlp.stanford.edu/software/lex-parser.shtml#Download
• Pobierz i unizp FULL VERSION tagger z http://nlp.stanford.edu/software/tagger.shtml#Download
• Pobierz i unizp tagger NER z http://nlp.stanford.edu/software/CRF-NER.shtml#Download

KROK 3

Skonfiguruj zmienne środowiskowe tak, aby NLTK mógł automatycznie znaleźć odpowiednią ścieżkę do pliku. Musisz ustawić następujące zmienne:

• Dodaj odpowiedni .jarplik NLP Stanforda do CLASSPATHzmiennej środowiskowej.

  • np. dla NER będzie stanford-ner-2015-04-20/stanford-ner.jar
  • np. w przypadku punktu sprzedaży będzie stanford-postagger-full-2015-04-20/stanford-postagger.jar
  • np. dla parsera będzie to stanford-parser-full-2015-04-20/stanford-parser.jarplik jar modelu parsera,stanford-parser-full-2015-04-20/stanford-parser-3.5.2-models.jar

• Dodaj odpowiedni katalog modelu do STANFORD_MODELSzmiennej (tj. Katalog, w którym można znaleźć miejsce, w którym zapisano wstępnie wytrenowane modele)

  • np. dla NER będzie w stanford-ner-2015-04-20/classifiers/
  • np. dla POS, będzie w stanford-postagger-full-2015-04-20/models/
  • np. dla Parsera nie będzie katalogu modeli.

W kodzie zobacz, że wyszukuje STANFORD_MODELSkatalog 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_JARzmienne są przestarzałe i NIE są już używane . Fragmenty kodu znalezione w następujących pytaniach Stackoverflow mogą nie działać:

• Konfiguracja parsera zależności Stanforda i NLTK
• Interfejs nltk do parsera Stanford
• problem z importowaniem taggera pozycji Stanford do nltk
• Stanford Entity Recognizer (bez obudowy) w Python Nltk
• Jak zwiększyć szybkość dzięki Stanford NLP Tagger i NLTK
• Jak mogę uzyskać moduł Python Stanford NLTK?
• Okna Stanford Parser i NLTK
• Funkcjonalność Stanford Named Entity Recognizer (NER) z NLTK
• Parser Stanforda z NLTK generuje puste wyjście
• Wyodrębnij listę osób i organizacji używających Stanford NER Tagger w NLTK
• Błąd podczas korzystania ze Stanford POS Tagger w NLTK Python

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ś .jarplik 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)

Przestarzała odpowiedź

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.

Edytowano

Od obecnego parsera Stanforda (20.04.2015) domyślne dane wyjściowe dla programu lexparser.shuległ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 .

Oryginalna odpowiedź

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

Począwszy od NLTK v3.3, użytkownicy powinni unikać tych taggers Stanford NER lub z POS nltk.tagi uniknąć Stanford tokenizer / z segmentacji nltk.tokenize.

Zamiast tego użyj nowego nltk.parse.corenlp.CoreNLPParserinterfejsu 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 

język angielski

Pozostając w stanford-corenlp-full-2018-02-27katalogu, 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')]

chiński

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

arabski

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

Francuski

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

Niemiecki

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

hiszpański

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

Istnieje interfejs Pythona dla parsera Stanforda

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

Na stronie oprogramowania Stanford Core NLP znajduje się lista opakowań Pythona:

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

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

Przestarzała odpowiedź

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.

EDYTOWANO

Uwaga: następująca odpowiedź będzie działać tylko na:

• Wersja NLTK == 3.2.5
• Stanford Tools opracowywany od 31.10.2016
• Python 2.7, 3.5 i 3.6

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 !!

TL; DR

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:

• nie zwracaj uwagi na wartość, którą przypisuję STANFORD_MODELS (i dbam tylko o moje CLASSPATH)
• pozostaw ../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 CLASSPATHpodanego (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)

Rozwiązanie dla samego Parsera:

Dlatego błąd pochodzi NLTKi jak szuka plików jar przy użyciu podanych STANFORD_MODELSi CLASSPATHzmiennych środowiskowych. Aby rozwiązać ten problem *-models.jar, z odpowiednim formatowaniem (aby dopasować wyrażenie regularne w NLTKkodzie, 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 StanfordParserpłynnie ładować w Pythonie z klasycznym, na CLASSPATHktóry wskazuje stanford-parser.jar. Właściwie jako taki możesz wywołać StanfordParserbez 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.