È possibile utilizzare Stanford Parser in NLTK? (Non sto parlando di Stanford POS.)
È possibile utilizzare Stanford Parser in NLTK? (Non sto parlando di Stanford POS.)
Risposte:
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:
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.
Scarica NLTK v3 da: https://github.com/nltk/nltk . E installa NLTK:
sudo python setup.py install
Puoi utilizzare il downloader NLTK per ottenere Stanford Parser, utilizzando Python:
import nltk
nltk.download()
Prova il mio esempio! (non dimenticare di cambiare i percorsi del jar e cambiare il percorso del modello nella posizione ser.gz)
O:
Scarica e installa NLTK v3, come sopra.
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
Estrai il file standford-parser-full-20xx-xx-xx.zip.
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.
Apri stanford-parser-3.xx-models.jar utilizzando un gestore di archivi (7zip).
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.
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.
Prova il mio esempio! (non dimenticare di cambiare i percorsi del jar e cambiare il percorso del modello nella posizione ser.gz)
nltk.parse.stanford
? Ho solo nltk.tag.stanford
in NLTK 2.0.4
.
AttributeError: 'StanfordParser' object has no attribute 'raw_batch_parse'
raw_parse_sents()
for line in sentences: for sentence in line: sentence.draw()
puoi solo eseguire draw () su un oggetto Tree;)
NLTK official 3rd party tools
documentazione.
La risposta di seguito è deprecata, utilizza la soluzione su https://stackoverflow.com/a/51981566/610569 per NLTK v3.3 e versioni successive.
Nota: la seguente risposta funzionerà solo su:
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 !!
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 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' NLTK
API 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_JAR
e STANFORD_PARSER
sono deprecate e NON PIÙ utilizzate
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 ):
sudo pip install -U nltk
sudo apt-get install python-nltk
Per Windows (utilizzare l'installazione binaria a 32 bit):
( Perché non 64 bit? Vedi https://github.com/nltk/nltk/issues/1079 )
Quindi fuori dalla paranoia, ricontrolla la tua nltk
versione 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)
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:
Imposta le variabili di ambiente in modo che NLTK possa trovare automaticamente il percorso del file pertinente. Devi impostare le seguenti variabili:
Aggiungere il .jar
file PNL Stanford appropriato alla CLASSPATH
variabile d'ambiente.
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
e 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_MODELS
variabile (ovvero la directory in cui puoi trovare dove sono salvati i modelli pre-addestrati)
stanford-ner-2015-04-20/classifiers/
stanford-postagger-full-2015-04-20/models/
Nel codice, vedere che cerca la STANFORD_MODELS
directory 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_JAR
variabili 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)
La risposta di seguito è deprecata, utilizza la soluzione su https://stackoverflow.com/a/51981566/610569 per NLTK v3.3 e versioni successive.
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 .
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
len(i.strip()) > 0
altrimenti ho ricevuto un errore di indice. Immagino che l'output del mio parser avesse almeno una riga che era puramente spazio bianco.
'
, otterrai degli strani errori. Ci sono modi migliori per chiamare le cose sulla riga di comando
A partire da NLTK v3.3, gli utenti dovrebbero evitare i tagger Stanford NER o POS da nltk.tag
ed evitare il tokenizer / segmentatore Stanford da nltk.tokenize
.
Utilizza invece la nuova nltk.parse.corenlp.CoreNLPParser
API.
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
Sempre nella stanford-corenlp-full-2018-02-27
directory, 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')]
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', ['。'])])])]
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')]
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')]
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')]
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')]
list(parser.raw_parse(text))
o list(parser.parse(parser.tokenize(text))
. Corretto l'esempio;)
C'è un'interfaccia Python per il parser Stanford
La pagina del software Stanford Core NLP ha un elenco di wrapper python:
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.
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.
È 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)
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.
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.
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()
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
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())
La risposta di seguito è deprecata, utilizza la soluzione su https://stackoverflow.com/a/51981566/610569 per NLTK v3.3 e versioni successive.
Nota: la seguente risposta funzionerà solo su:
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 !!
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!
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:
STANFORD_MODELS
(e preoccuparti solo del mio CLASSPATH
)../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 CLASSPATH
dato (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)
Pertanto l'errore è venuto da NLTK
e come sta cercando i vasi utilizzando le variabili fornite STANFORD_MODELS
e di CLASSPATH
ambiente. Per risolvere questo problema, il *-models.jar
, con la formattazione corretta (per abbinare la regex nel NLTK
codice, 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 StanfordParser
caricare senza problemi in Python con il classico a CLASSPATH
cui punta stanford-parser.jar
. In realtà, in quanto tale, puoi chiamare StanfordParser
senza parametri, l'impostazione predefinita funzionerà.
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')]
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.