Stanford Parser e NLTK


90

È possibile utilizzare Stanford Parser in NLTK? (Non sto parlando di Stanford POS.)



3
Questo collegamento deve essere più visibile. Forse la risposta principale dovrebbe essere modificata per menzionarlo?
Lalo Sánchez

1
Solo una nota a margine qui ragazzi. Assicurati che il tuo Java sia aggiornato per Stanford NLP e che JAVA_HOME sia impostato correttamente. A volte le persone potrebbero ricevere errori "strani" che potrebbero essere dovuti a questo.
Meng Zhao

Risposte:


89

Nota che questa risposta si applica a NLTK v 3.0 e non alle versioni più recenti.

Certo, prova quanto segue 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()

Produzione:

[Tree ('ROOT', [Tree ('S', [Tree ('INTJ', [Tree ('UH', ['Hello'])]), Tree (',', [',']), Albero ('NP', [Tree ('PRP $', ['My']), Tree ('NN', ['name'])]), Tree ('VP', [Tree ('VBZ', [ 'è']), Albero ('ADJP', [Albero ('JJ', ['Melroy'])])]), Albero ('.', ['.'])])]), Albero (' ROOT ', [Tree (' SBARQ ', [Tree (' WHNP ', [Tree (' WP ', [' What '])]), Tree (' SQ ', [Tree (' VBZ ', [' is ' ]), Albero ('NP', [Albero ('PRP $', ['tuo']), Albero ('NN', ['nome'])])]), Albero ('.', ['? '])])])]

Nota 1: in questo esempio, sia il parser che i contenitori del modello si trovano nella stessa cartella.

Nota 2:

  • Il nome del file del parser di stanford è: stanford-parser.jar
  • Il nome del file dei modelli stanford è: stanford-parser-xxx-models.jar

Nota 3: il file englishPCFG.ser.gz si trova all'interno del file models.jar (/edu/stanford/nlp/models/lexparser/englishPCFG.ser.gz). Utilizzare come Archive Manager per "decomprimere" il file models.jar.

Nota 4: assicurati di utilizzare Java JRE (Runtime Environment) 1.8 noto anche come Oracle JDK 8. Altrimenti si otterrà: major.minor versione 52.0 non supportata.

Installazione

  1. Scarica NLTK v3 da: https://github.com/nltk/nltk . E installa NLTK:

    sudo python setup.py install

  2. Puoi utilizzare il downloader NLTK per ottenere Stanford Parser, utilizzando Python:

    import nltk
    nltk.download()
  3. Prova il mio esempio! (non dimenticare di cambiare i percorsi del jar e cambiare il percorso del modello nella posizione ser.gz)

O:

  1. Scarica e installa NLTK v3, come sopra.

  2. Scarica l'ultima versione da (il nome del file della versione corrente è stanford-parser-full-2015-01-29.zip): http://nlp.stanford.edu/software/lex-parser.shtml#Download

  3. Estrai il file standford-parser-full-20xx-xx-xx.zip.

  4. Crea una nuova cartella ("jars" nel mio esempio). Posiziona i file estratti in questa cartella jar: stanford-parser-3.xx-models.jar e stanford-parser.jar.

    Come mostrato sopra, puoi usare le variabili d'ambiente (STANFORD_PARSER & STANFORD_MODELS) per puntare a questa cartella "jars". Sto usando Linux, quindi se usi Windows per favore usa qualcosa come: C: // cartella // jars.

  5. Apri stanford-parser-3.xx-models.jar utilizzando un gestore di archivi (7zip).

  6. Sfoglia all'interno del file jar; edu / stanford / nlp / models / lexparser. Di nuovo, estrai il file chiamato "englishPCFG.ser.gz". Ricorda la posizione in cui estrai questo file ser.gz.

  7. Quando si crea un'istanza StanfordParser, è possibile fornire il percorso del modello come parametro. Questo è il percorso completo del modello, nel nostro caso /location/of/englishPCFG.ser.gz.

  8. Prova il mio esempio! (non dimenticare di cambiare i percorsi del jar e cambiare il percorso del modello nella posizione ser.gz)


1
Quale versione di nltk è stata aggiunta nltk.parse.stanford? Ho solo nltk.tag.stanfordin NLTK 2.0.4.
alexis

1
AttributeError: 'StanfordParser' object has no attribute 'raw_batch_parse'
Nick Retallack

5
@alexis: scarica nltk 3.0 da qui @Nick Retallack: dovrebbe essere cambiato inraw_parse_sents()
Rasika Perera

1
Ok, hai ragione. NLTK cambia la funzione in: raw_parse_sents (). Vedi Documentazione: nltk.org/_modules/nltk/parse/stanford.html Se usi raw_parse () recupererai un iter (Albero) come valore di ritorno. Significa che l'esempio sopra di draw () dovrebbe funzionare. Se stai usando raw_parse_sents (), apparentemente hai bisogno di un doppio loop; restituisce un iter (iter (Tree)). Quindi esempio di codice: for line in sentences: for sentence in line: sentence.draw() puoi solo eseguire draw () su un oggetto Tree;)
danger89

1
@ danger89, scusa per aver sovrascritto la tua risposta con la nota MODIFICATA. Recentemente le persone si sono lamentate del parser Stanford Dependency è stato aggiunto solo di recente da NLTK v3.1 e penso che stessero duplicando alcuni frammenti di codice qua e là dalle risposte deprecate qui. Quindi, per ridurre al minimo la confusione, ho pensato che fosse meglio aggiungere dichiarazioni di non responsabilità a tutte le risposte qui riguardo al seguire le istruzioni dalla NLTK official 3rd party toolsdocumentazione.
alvas

77

Risposta obsoleta

La risposta di seguito è deprecata, utilizza la soluzione su https://stackoverflow.com/a/51981566/610569 per NLTK v3.3 e versioni successive.


MODIFICATO

Nota: la seguente risposta funzionerà solo su:

  • Versione NLTK> = 3.2.4
  • Stanford Tools compilato dal 2015-04-20
  • Python 2.7, 3.4 e 3.5 (Python 3.6 non è ancora ufficialmente supportato)

Poiché entrambi gli strumenti cambiano piuttosto rapidamente e l'API potrebbe apparire molto diversa 3-6 mesi dopo. Si prega di considerare la seguente risposta come una soluzione temporale e non eterna.

Fare sempre riferimento a https://github.com/nltk/nltk/wiki/Installing-Third-Party-Software per le ultime istruzioni su come interfacciare gli strumenti PNL di Stanford utilizzando 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

Poi:

>>> from nltk.tag.stanford import StanfordPOSTagger
>>> st = StanfordPOSTagger('english-bidirectional-distsim.tagger')
>>> st.tag('What is the airspeed of an unladen swallow ?'.split())
[(u'What', u'WP'), (u'is', u'VBZ'), (u'the', u'DT'), (u'airspeed', u'NN'), (u'of', u'IN'), (u'an', u'DT'), (u'unladen', u'JJ'), (u'swallow', u'VB'), (u'?', u'.')]

>>> from nltk.tag import StanfordNERTagger
>>> st = StanfordNERTagger('english.all.3class.distsim.crf.ser.gz') 
>>> st.tag('Rami Eid is studying at Stony Brook University in NY'.split())
[(u'Rami', u'PERSON'), (u'Eid', u'PERSON'), (u'is', u'O'), (u'studying', u'O'), (u'at', u'O'), (u'Stony', u'ORGANIZATION'), (u'Brook', u'ORGANIZATION'), (u'University', u'ORGANIZATION'), (u'in', u'O'), (u'NY', u'O')]


>>> from nltk.parse.stanford import StanfordParser
>>> parser=StanfordParser(model_path="edu/stanford/nlp/models/lexparser/englishPCFG.ser.gz")
>>> list(parser.raw_parse("the quick brown fox jumps over the lazy dog"))
[Tree('ROOT', [Tree('NP', [Tree('NP', [Tree('DT', ['the']), Tree('JJ', ['quick']), Tree('JJ', ['brown']), Tree('NN', ['fox'])]), Tree('NP', [Tree('NP', [Tree('NNS', ['jumps'])]), Tree('PP', [Tree('IN', ['over']), Tree('NP', [Tree('DT', ['the']), Tree('JJ', ['lazy']), Tree('NN', ['dog'])])])])])])]

>>> from nltk.parse.stanford import StanfordDependencyParser
>>> dep_parser=StanfordDependencyParser(model_path="edu/stanford/nlp/models/lexparser/englishPCFG.ser.gz")
>>> print [parse.tree() for parse in dep_parser.raw_parse("The quick brown fox jumps over the lazy dog.")]
[Tree('jumps', [Tree('fox', ['The', 'quick', 'brown']), Tree('dog', ['over', 'the', 'lazy'])])]

In lungo:


In primo luogo , si deve notare che gli strumenti NLP di Stanford sono scritti in Java e NLTK è scritto in Python . Il modo in cui NLTK interfaccia lo strumento è tramite la chiamata allo strumento Java tramite l'interfaccia della riga di comando.

In secondo luogo , ilNLTK API per gli strumenti PNL di Stanford è cambiata parecchio dalla versione 3.1. Quindi è consigliabile aggiornare il pacchetto NLTK alla v3.1.

In terzo luogo , l' NLTKAPI di Stanford NLP Tools avvolge i singoli strumenti di PNL, ad esempio Stanford POS tagger , Stanford NER Tagger , Stanford Parser .

Per il tagger POS e NER, NON avvolge il pacchetto Stanford Core NLP .

Per lo Stanford Parser, è un caso speciale in cui avvolge sia lo Stanford Parser che lo Stanford Core NLP (personalmente, non ho usato quest'ultimo utilizzando NLTK, preferirei seguire la dimostrazione di @ dimazest su http: //www.eecs. qmul.ac.uk/~dm303/stanford-dependency-parser-nltk-and-anaconda.html )

Si noti che a partire da NLTK v3.1, le variabili STANFORD_JARe STANFORD_PARSERsono deprecate e NON PIÙ utilizzate


In più:


PASSO 1

Supponendo che tu abbia installato Java in modo appropriato sul tuo sistema operativo.

Ora installa / aggiorna la tua versione NLTK (vedi http://www.nltk.org/install.html ):

  • Utilizzando pip :sudo pip install -U nltk
  • Distribuzione Debian (usando apt-get):sudo apt-get install python-nltk

Per Windows (utilizzare l'installazione binaria a 32 bit):

  1. Installa Python 3.4: http://www.python.org/downloads/ (evita le versioni a 64 bit)
  2. Installa Numpy (opzionale): http://sourceforge.net/projects/numpy/files/NumPy/ (la versione che specifica pythnon3.4)
  3. Installa NLTK: http://pypi.python.org/pypi/nltk
  4. Installazione di prova: Start> Python34, quindi digita import nltk

( Perché non 64 bit? Vedi https://github.com/nltk/nltk/issues/1079 )


Quindi fuori dalla paranoia, ricontrolla la tua nltkversione all'interno di Python:

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

O sulla riga di comando:

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

Assicurati di vedere 3.1 come output.

Per ancora più paranoia, controlla che tutte le tue API degli strumenti PNL di Stanford preferite siano disponibili:

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

( Nota : le importazioni di cui sopra garantiranno SOLO che stai utilizzando una versione NLTK corretta che contiene queste API. Non vedere errori nell'importazione non significa che hai configurato correttamente l'API NLTK per utilizzare gli strumenti di Stanford)


PASSO 2

Ora che hai verificato di avere la versione corretta di NLTK che contiene la necessaria interfaccia degli strumenti PNL di Stanford. Devi scaricare ed estrarre tutti gli strumenti necessari per la PNL di Stanford.

TL; DR , in 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:


FASE 3

Imposta le variabili di ambiente in modo che NLTK possa trovare automaticamente il percorso del file pertinente. Devi impostare le seguenti variabili:

  • Aggiungere il .jarfile PNL Stanford appropriato alla CLASSPATHvariabile d'ambiente.

    • ad esempio per il NER, lo sarà stanford-ner-2015-04-20/stanford-ner.jar
    • ad esempio per il POS, lo sarà stanford-postagger-full-2015-04-20/stanford-postagger.jar
    • ad esempio per il parser, sarà stanford-parser-full-2015-04-20/stanford-parser.jare il file jar del modello del parser,stanford-parser-full-2015-04-20/stanford-parser-3.5.2-models.jar
  • Aggiungi la directory del modello appropriata alla STANFORD_MODELSvariabile (ovvero la directory in cui puoi trovare dove sono salvati i modelli pre-addestrati)

    • ad esempio per il NER, sarà in stanford-ner-2015-04-20/classifiers/
    • ad esempio per il POS, sarà in stanford-postagger-full-2015-04-20/models/
    • ad esempio, per il parser, non ci sarà una directory del modello.

Nel codice, vedere che cerca la STANFORD_MODELSdirectory prima di aggiungere il nome del modello. Inoltre, l'API tenta automaticamente di cercare negli ambienti del sistema operativo il `CLASSPATH )

Si noti che a partire da NLTK v3.1, le STANFORD_JARvariabili sono deprecate e NON PIÙ utilizzate . I frammenti di codice trovati nelle seguenti domande di Stackoverflow potrebbero non funzionare:

TL; DR per STEP 3 su 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

( Per Windows : vedere https://stackoverflow.com/a/17176423/610569 per istruzioni sull'impostazione delle variabili di ambiente)

È NECESSARIO impostare le variabili come sopra prima di avviare Python, quindi:

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

In alternativa, potresti provare ad aggiungere le variabili di ambiente all'interno di python, come suggerito dalle risposte precedenti, ma puoi anche dire direttamente al parser / tagger di inizializzare il percorso diretto in cui hai mantenuto il .jar file ei tuoi modelli.

NON è necessario impostare le variabili di ambiente se si utilizza il seguente metodo MA quando l'API cambia i nomi dei parametri, sarà necessario modificarli di conseguenza. Questo è il motivo per cui è PIÙ consigliabile impostare le variabili d'ambiente che modificare il codice Python per adattarlo alla versione NLTK.

Ad esempio ( senza impostare alcuna variabile di ambiente ):

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

22

Risposta obsoleta

La risposta di seguito è deprecata, utilizza la soluzione su https://stackoverflow.com/a/51981566/610569 per NLTK v3.3 e versioni successive.


Modificato

A partire dall'attuale parser Stanford (2015-04-20), l'output predefinito per lexparser.sh è cambiato, quindi lo script seguente non funzionerà.

Ma questa risposta è conservata per il bene precedente, funzionerà comunque con http://nlp.stanford.edu/software/stanford-parser-2012-11-12.zip .


Risposta originale

Ti suggerisco di non scherzare con Jython, JPype. Lascia che python esegua le cose di Python e lasci che Java faccia le cose di Java, ottieni l'output di Stanford Parser attraverso la console.

Dopo aver installato Stanford Parser nella tua home directory ~/, usa questa ricetta Python per ottenere il parse piatto tra parentesi:

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

1
Questo ha funzionato per me tranne che dovevo aggiungere una condizione da controllare, len(i.strip()) > 0altrimenti ho ricevuto un errore di indice. Immagino che l'output del mio parser avesse almeno una riga che era puramente spazio bianco.
aelfric5578

1
in alternativa, usa questo wrapper python per gli strumenti stanford corenlp, bitbucket.org/torotoki/corenlp-python
alvas

3
Stai attento con questo. Se il tuo input contiene dei messaggi ', otterrai degli strani errori. Ci sono modi migliori per chiamare le cose sulla riga di comando
Nick Garvey

20

A partire da NLTK v3.3, gli utenti dovrebbero evitare i tagger Stanford NER o POS da nltk.taged evitare il tokenizer / segmentatore Stanford da nltk.tokenize.

Utilizza invece la nuova nltk.parse.corenlp.CoreNLPParserAPI.

Si prega di consultare https://github.com/nltk/nltk/wiki/Stanford-CoreNLP-API-in-NLTK


(Evitando solo la risposta al collegamento, ho incollato i documenti dal wiki di NLTK github di seguito)

Innanzitutto, aggiorna il tuo NLTK

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

Quindi scarica i pacchetti CoreNLP necessari:

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 

Inglese

Sempre nella stanford-corenlp-full-2018-02-27directory, avvia il server:

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

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

Cinese

Avvia il server in modo leggermente diverso, sempre dalla directory `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', ['。'])])])]

Arabo

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

francese

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

Tedesco

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

spagnolo

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

Ottima risposta. Grazie
Eben

Grazie, è molto utile. Tuttavia, l'analisi araba non è corretta.
Divide

Usa list(parser.raw_parse(text))o list(parser.parse(parser.tokenize(text)). Corretto l'esempio;)
alvas

1
Non posso credere che questo non sia più pubblicizzato !!
Nimitz14

1
Purtroppo, NLTK non ha abbastanza persone che vanno in giro per i meetup per tenere discorsi o hanno le risorse per ospitare un'accattivante conferenza di sviluppo per promuovere lo strumento = (Sentiti libero di presentare questa funzione o NLTK alla comunità intorno a te.
alvas



6

Se ricordo bene, il parser Stanford è una libreria java, quindi devi avere un interprete Java in esecuzione sul tuo server / computer.

L'ho usato una volta come server, combinato con uno script php. Lo script utilizzava la funzione exec () di php per effettuare una chiamata da riga di comando al parser in questo modo:

<?php

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

?>

Non ricordo tutti i dettagli di questo comando, fondamentalmente ha aperto il fileToParse, lo ha analizzato e ha scritto l'output nel resultFile. PHP aprirà quindi il file dei risultati per un ulteriore utilizzo.

La fine del comando indirizza il verbose del parser a NULL, per evitare che informazioni sulla riga di comando non necessarie disturbino lo script.

Non so molto di Python, ma potrebbe esserci un modo per effettuare chiamate dalla riga di comando.

Potrebbe non essere il percorso esatto che speravi, ma si spera che ti darà qualche ispirazione. Buona fortuna.


6

Nota che questa risposta si applica a NLTK v 3.0 e non alle versioni più recenti.

Ecco un adattamento del codice di danger98 che funziona con nltk3.0.0 su windoze, e presumibilmente anche le altre piattaforme, regola i nomi delle directory come appropriato per la tua configurazione:

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

Notare che il comando di analisi è cambiato (vedere il codice sorgente su www.nltk.org/_modules/nltk/parse/stanford.html) e che è necessario definire la variabile JAVAHOME. Ho provato a convincerlo a leggere il file grammaticale in situ nel jar, ma finora non sono riuscito a farlo.


Sono del 1989 non del 98, ma grazie per il tuo esempio;)
danger89

4

È possibile utilizzare l'output di Stanford Parsers per creare un albero in nltk (nltk.tree.Tree).

Supponendo che il parser stanford ti dia un file in cui c'è esattamente un albero di analisi per ogni frase. Quindi questo esempio funziona, anche se potrebbe non sembrare molto pitonico:

f = open(sys.argv[1]+".output"+".30"+".stp", "r")
parse_trees_text=[]
tree = ""
for line in f:
  if line.isspace():
    parse_trees_text.append(tree)
tree = ""
  elif "(. ...))" in line:
#print "YES"
tree = tree+')'
parse_trees_text.append(tree)
tree = ""
  else:
tree = tree + line

parse_trees=[]
for t in parse_trees_text:
  tree = nltk.Tree(t)
  tree.__delitem__(len(tree)-1) #delete "(. .))" from tree (you don't need that)
  s = traverse(tree)
  parse_trees.append(tree)

1
+1 per lasciare che Java faccia roba Java e Python faccia roba Python. A seconda di come si chiama il comando java e di quali opzioni, l'analisi del file di output dal parser stanford potrebbe essere diversa. Sarebbe bello se aggiungessi anche dettagli su come hai chiamato Stanford Parse per ottenere il tuo file di output.
alvas

4

Nota che questa risposta si applica a NLTK v 3.0 e non alle versioni più recenti.

Dal momento che nessuno ha davvero menzionato e in qualche modo mi ha turbato molto, ecco un modo alternativo per usare il parser Stanford in Python:

stanford_parser_jar = '../lib/stanford-parser-full-2015-04-20/stanford-parser.jar'
stanford_model_jar = '../lib/stanford-parser-full-2015-04-20/stanford-parser-3.5.2-models.jar'    
parser = StanfordParser(path_to_jar=stanford_parser_jar, 
                        path_to_models_jar=stanford_model_jar)

in questo modo, non devi più preoccuparti della cosa del percorso.

Per coloro che non possono usarlo correttamente su Ubuntu o eseguire il codice in Eclipse.


3

Sono su una macchina Windows e puoi semplicemente eseguire il parser normalmente come fai dal comando, ma come in una directory diversa, quindi non è necessario modificare il file lexparser.bat. Basta inserire il percorso completo.

cmd = r'java -cp \Documents\stanford_nlp\stanford-parser-full-2015-01-30 edu.stanford.nlp.parser.lexparser.LexicalizedParser -outputFormat "typedDependencies" \Documents\stanford_nlp\stanford-parser-full-2015-01-30\stanford-parser-3.5.1-models\edu\stanford\nlp\models\lexparser\englishFactored.ser.gz stanfordtemp.txt'
parse_out = os.popen(cmd).readlines()

La parte difficile per me è stata capire come eseguire un programma java da un percorso diverso. Ci deve essere un modo migliore, ma funziona.


3

Nota che questa risposta si applica a NLTK v 3.0 e non alle versioni più recenti.

Un leggero aggiornamento (o semplicemente un'alternativa) alla risposta completa di danger89 sull'uso di Stanford Parser in NLTK e Python

Con stanford-parser-full-2015-04-20, JRE 1.8 e nltk 3.0.4 (python 2.7.6), sembra che non sia più necessario estrarre englishPCFG.ser.gz da stanford-parser-xxx-models .jar o configurare qualsiasi 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()

3

Nota che questa risposta si applica a NLTK v 3.0 e non alle versioni più recenti.

Ecco la versione per Windows della risposta di alvas

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)

APPUNTI:

  • In lexparser.bat è necessario modificare tutti i percorsi in percorso assoluto per evitare errori java come "classe non trovata"

  • Ti consiglio vivamente di applicare questo metodo sotto Windows poiché ho provato diverse risposte sulla pagina e tutti i metodi comunicano python con Java non riescono.

  • desidero sentirti se riesci con Windows e vorrei che tu mi dicessi come hai superato tutti questi problemi.

  • cerca il wrapper python per stanford coreNLP per ottenere la versione python



2

Ho impiegato molte ore e finalmente ho trovato una soluzione semplice per gli utenti Windows. Fondamentalmente la sua versione riassunta di una risposta esistente di alvas, ma resa facile da seguire (si spera) per coloro che sono nuovi a Stanford NLP e sono utenti di Windows.

1) Scarica il modulo che desideri utilizzare, come NER, POS ecc. Nel mio caso volevo usare NER, quindi ho scaricato il modulo da http://nlp.stanford.edu/software/stanford-ner-2015- 04-20.zip

2) Decomprimere il file.

3) Impostare le variabili d'ambiente (classpath e stanford_modules) dalla cartella decompressa.

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) imposta le variabili d'ambiente per JAVA, come dove hai installato JAVA. per me era sotto

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

5) importa il modulo che desideri

from nltk.tag import StanfordNERTagger

6) chiama il modello pre-addestrato che è presente nella cartella del classificatore nella cartella decompressa. aggiungere ".gz" alla fine per l'estensione del file. per me il modello che volevo usare eraenglish.all.3class.distsim.crf.ser

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

7) Ora esegui il parser !! e abbiamo finito !!

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


2

Risposta obsoleta

La risposta di seguito è deprecata, utilizza la soluzione su https://stackoverflow.com/a/51981566/610569 per NLTK v3.3 e versioni successive.


MODIFICATO

Nota: la seguente risposta funzionerà solo su:

  • Versione NLTK == 3.2.5
  • Stanford Tools compilato dal 2016-10-31
  • Python 2.7, 3.5 e 3.6

Poiché entrambi gli strumenti cambiano piuttosto rapidamente e l'API potrebbe apparire molto diversa 3-6 mesi dopo. Si prega di considerare la seguente risposta come una soluzione temporale e non eterna.

Fare sempre riferimento a https://github.com/nltk/nltk/wiki/Installing-Third-Party-Software per le ultime istruzioni su come interfacciare gli strumenti PNL di Stanford utilizzando NLTK !!

TL; DR

Il codice seguente proviene da https://github.com/nltk/nltk/pull/1735#issuecomment-306091826

Nel 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

Si prega di dare un'occhiata a http://www.nltk.org/_modules/nltk/parse/corenlp.html per ulteriori informazioni sull'API di Stanford. Dai un'occhiata alle docstrings!


2

Nota che questa risposta si applica a NLTK v 3.0 e non alle versioni più recenti.

Non posso lasciarlo come un commento a causa della reputazione, ma poiché ho speso (sprecato?) Un po 'di tempo per risolverlo, preferirei condividere il mio problema / soluzione per far funzionare questo parser in NLTK.

In ottima risposta da alvas , si è detto che:

ad esempio, per il parser, non ci sarà una directory del modello.

Questo mi ha portato erroneamente a:

  • non stare attento al valore che metto STANFORD_MODELS (e preoccuparti solo del mio CLASSPATH)
  • lascia ../path/tostanford-parser-full-2015-2012-09/models directory* virtualmente vuoto * (o con un file jar il cui nome non corrisponde all'espressione regolare nltk)!

Se l'OP, come me, volesse solo usare il parser, potrebbe essere fonte di confusione quando non si scarica nient'altro (nessun POStagger, nessun NER, ...) e seguendo tutte queste istruzioni, otteniamo comunque un errore.

Alla fine, per qualsiasi CLASSPATHdato (seguenti esempi e spiegazioni nelle risposte da questo thread) avrei comunque ricevuto l'errore:

NLTK non è riuscito a trovare stanford-parser - (\ d +) (. (\ D +)) + - models.jar! Imposta la variabile d'ambiente CLASSPATH. Per ulteriori informazioni, su stanford-parser - (\ d +) (. (\ D +)) + - models.jar,

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

O:

NLTK non è riuscito a trovare stanford-parser.jar! Imposta la variabile d'ambiente CLASSPATH. Per ulteriori informazioni, su stanford-parser.jar, vedere: http://nlp.stanford.edu/software/lex-parser.shtml

Tuttavia , cosa importante, potrei caricare e utilizzare correttamente il parser se chiamassi la funzione con tutti gli argomenti e il percorso completamente specificato, come in:

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)

Soluzione solo per Parser:

Pertanto l'errore è venuto da NLTKe come sta cercando i vasi utilizzando le variabili fornite STANFORD_MODELSe di CLASSPATHambiente. Per risolvere questo problema, il *-models.jar, con la formattazione corretta (per abbinare la regex nel NLTKcodice, quindi no -corenlp -.... jar) deve essere posizionato nella cartella designata da STANFORD_MODELS.

Vale a dire, per prima cosa ho creato:

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

Quindi aggiunto in .bashrc:

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

E infine, copiando stanford-parser-3.6.0-models.jar(o la versione corrispondente), in:

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

Potrei StanfordParsercaricare senza problemi in Python con il classico a CLASSPATHcui punta stanford-parser.jar. In realtà, in quanto tale, puoi chiamare StanfordParsersenza parametri, l'impostazione predefinita funzionerà.


2

Sto usando nltk versione 3.2.4. E il codice seguente ha funzionato per me.

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)

Produzione:

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

Penso che questo sia il tagger e non il parser
Nadav B

1

Recentemente è stato reso disponibile un nuovo sviluppo del parser Stanford basato su un modello neurale, addestrato utilizzando Tensorflow, per essere utilizzato come API Python. Questo modello dovrebbe essere molto più accurato del moel basato su Java. Puoi sicuramente integrarti con una pipeline NLTK.

Collegamento al parser. Il repository contiene modelli parser pre-addestrati per 53 lingue.

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.