É possível usar o Stanford Parser no NLTK? (Não estou falando sobre Stanford POS.)
É possível usar o Stanford Parser no NLTK? (Não estou falando sobre Stanford POS.)
Respostas:
Observe que esta resposta se aplica ao NLTK v 3.0, e não às versões mais recentes.
Claro, tente o seguinte em 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()
Resultado:
[Árvore ('ROOT', [Árvore ('S', [Árvore ('INTJ', [Árvore ('UH', ['Olá'])]), Árvore (',', [',']), Árvore ('NP', [Árvore ('PRP $', ['Meu']), Árvore ('NN', ['nome'])]), Árvore ('VP', [Árvore ('VBZ', [ 'é']), Árvore ('ADJP', [Árvore ('JJ', ['Melroy'])])]), Árvore ('.', ['.'])])]), Árvore (' ROOT ', [Tree (' SBARQ ', [Tree (' WHNP ', [Tree (' WP ', [' What '])]), Tree (' SQ ', [Tree (' VBZ ', [' is ' ]), Árvore ('NP', [Árvore ('PRP $', ['seu']), Árvore ('NN', ['nome'])])]), Árvore ('.', ['? '])])])]
Nota 1: neste exemplo, os jars do analisador e do modelo estão na mesma pasta.
Nota 2:
Nota 3: O arquivo englishPCFG.ser.gz pode ser encontrado dentro do arquivo models.jar (/edu/stanford/nlp/models/lexparser/englishPCFG.ser.gz). Use o gerenciador de arquivos come para 'descompactar' o arquivo models.jar.
Nota 4: Certifique-se de estar usando Java JRE (Runtime Environment) 1.8 também conhecido como Oracle JDK 8. Caso contrário, você obterá: Major.minor version 52.0 sem suporte.
Baixe o NLTK v3 em: https://github.com/nltk/nltk . E instale o NLTK:
sudo python setup.py install
Você pode usar o downloader NLTK para obter o Stanford Parser, usando Python:
import nltk
nltk.download()
Experimente meu exemplo! (não se esqueça de alterar os caminhos do jar e alterar o caminho do modelo para o local ser.gz)
OU:
Baixe e instale o NLTK v3, o mesmo que acima.
Baixe a versão mais recente de ( o nome do arquivo da versão atual é stanford-parser-full-2015-01-29.zip): http://nlp.stanford.edu/software/lex-parser.shtml#Download
Extraia o standford-parser-full-20xx-xx-xx.zip.
Crie uma nova pasta ('jars' no meu exemplo). Coloque os arquivos extraídos nesta pasta jar: stanford-parser-3.xx-models.jar e stanford-parser.jar.
Conforme mostrado acima, você pode usar as variáveis de ambiente (STANFORD_PARSER & STANFORD_MODELS) para apontar para esta pasta 'jars'. Estou usando Linux, portanto, se você usa Windows, use algo como: C: // pasta // jars.
Abra o stanford-parser-3.xx-models.jar usando um gerenciador de arquivos (7zip).
Navegue dentro do arquivo jar; edu / stanford / nlp / models / lexparser. Novamente, extraia o arquivo chamado 'englishPCFG.ser.gz'. Lembre-se do local onde você extraiu este arquivo ser.gz.
Ao criar uma instância StanfordParser, você pode fornecer o caminho do modelo como parâmetro. Este é o caminho completo para o modelo, em nosso caso /location/of/englishPCFG.ser.gz.
Experimente meu exemplo! (não se esqueça de alterar os caminhos do jar e alterar o caminho do modelo para o local ser.gz)
nltk.parse.stanford
? Eu só tenho nltk.tag.stanford
em 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()
Você só pode executar draw () em um objeto Árvore;)
NLTK official 3rd party tools
documentação.
A resposta abaixo está obsoleta, use a solução em https://stackoverflow.com/a/51981566/610569 para NLTK v3.3 e superior.
Observação: a seguinte resposta só funcionará em:
Como ambas as ferramentas mudam rapidamente e a API pode parecer muito diferente 3-6 meses depois. Por favor, trate a seguinte resposta como temporal e não uma solução eterna.
Sempre consulte https://github.com/nltk/nltk/wiki/Installing-Third-Party-Software para obter as instruções mais recentes sobre como fazer a interface das ferramentas de PNL de Stanford usando 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
Então:
>>> 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'])])]
Em primeiro lugar , deve-se observar que as ferramentas Stanford NLP são escritas em Java e NLTK em Python . A forma como o NLTK faz a interface com a ferramenta é por meio da chamada da ferramenta Java por meio da interface da linha de comando.
Em segundo lugar , a NLTK
API para as ferramentas de PNL de Stanford mudou bastante desde a versão 3.1. Portanto, é aconselhável atualizar seu pacote NLTK para a v3.1.
Em terceiro lugar , a NLTK
API para Ferramentas de PNL de Stanford envolve as ferramentas de PNL individuais, por exemplo, Stanford POS tagger , Stanford NER Tagger , Stanford Parser .
Para o tagger POS e NER, NÃO envolve o pacote Stanford Core PNL .
Para o Stanford Parser, é um caso especial em que envolve o Stanford Parser e o Stanford Core NLP (pessoalmente, não usei o último usando NLTK, prefiro seguir a demonstração de @dimazest em http: //www.eecs. qmul.ac.uk/~dm303/stanford-dependency-parser-nltk-and-anaconda.html )
Observe que, a partir do NLTK v3.1, as variáveis STANFORD_JAR
e STANFORD_PARSER
estão obsoletas e NÃO MAIS usadas
Supondo que você tenha instalado o Java apropriadamente em seu sistema operacional.
Agora, instale / atualize sua versão NLTK (consulte http://www.nltk.org/install.html ):
sudo pip install -U nltk
sudo apt-get install python-nltk
Para Windows (use a instalação binária de 32 bits):
( Por que não 64 bits? Consulte https://github.com/nltk/nltk/issues/1079 )
Então, por paranóia, verifique novamente sua nltk
versão dentro do python:
from __future__ import print_function
import nltk
print(nltk.__version__)
Ou na linha de comando:
python3 -c "import nltk; print(nltk.__version__)"
Certifique-se de ver 3.1
como a saída.
Para ainda mais paranóia, verifique se todas as suas ferramentas de API de PNL de Stanford favoritas estão disponíveis:
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
( Observação : as importações acima SÓ garantirão que você esteja usando uma versão NLTK correta que contenha essas APIs. Não ver erros na importação não significa que você configurou com êxito a API NLTK para usar as Ferramentas de Stanford)
Agora que você verificou que possui a versão correta do NLTK que contém a interface das ferramentas de PNL de Stanford necessária. Você precisa baixar e extrair todas as ferramentas de PNL de Stanford necessárias.
TL; DR , no 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
No Windows / Mac:
Configure as variáveis de ambiente de forma que o NLTK possa localizar o caminho do arquivo relevante automaticamente. Você deve definir as seguintes variáveis:
Adicione o .jar
arquivo Stanford NLP apropriado à CLASSPATH
variável de 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 o arquivo jar do modelo do analisador,stanford-parser-full-2015-04-20/stanford-parser-3.5.2-models.jar
Adicione o diretório de modelo apropriado à STANFORD_MODELS
variável (ou seja, o diretório onde você pode encontrar onde os modelos pré-treinados são salvos)
stanford-ner-2015-04-20/classifiers/
stanford-postagger-full-2015-04-20/models/
No código, verifique se ele procura o STANFORD_MODELS
diretório antes de anexar o nome do modelo. Veja também que, a API também tenta pesquisar automaticamente os ambientes do sistema operacional para `CLASSPATH )
Observe que, a partir do NLTK v3.1, as STANFORD_JAR
variáveis foram descontinuadas e NÃO MAIS usadas . Os snippets de código encontrados nas seguintes perguntas do Stackoverflow podem não funcionar:
TL; DR para a ETAPA 3 no 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
( Para Windows : consulte https://stackoverflow.com/a/17176423/610569 para obter instruções para definir variáveis de ambiente)
Você DEVE definir as variáveis conforme acima antes de iniciar o Python, então:
>>> 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'])])])])])])]
Alternativamente, você pode tentar adicionar as variáveis de ambiente dentro do python, como as respostas anteriores sugeriram, mas você também pode dizer diretamente ao analisador / identificador para inicializar no caminho direto onde você manteve o .jar
arquivo e seus modelos.
NÃO há necessidade de definir as variáveis de ambiente se você usar o método a seguir, MAS quando a API alterar seus nomes de parâmetro, você precisará alterar de acordo. É por isso que é MAIS aconselhável definir as variáveis de ambiente do que modificar seu código Python para se adequar à versão NLTK.
Por exemplo ( sem definir nenhuma variável de 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)
A resposta abaixo está obsoleta, use a solução em https://stackoverflow.com/a/51981566/610569 para NLTK v3.3 e superior.
A partir do analisador Stanford atual (20-04-2015), a saída padrão do lexparser.sh
foi alterada, portanto o script abaixo não funcionará.
Mas essa resposta é mantida para fins de legado, mas ainda funcionará com http://nlp.stanford.edu/software/stanford-parser-2012-11-12.zip .
Eu sugiro que você não mexa com Jython, JPype. Deixe python fazer coisas de python e deixe java fazer coisas de java, obtenha a saída do Stanford Parser através do console.
Depois de instalar o Stanford Parser em seu diretório inicial ~/
, basta usar esta receita Python para obter a análise entre colchetes:
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
caso contrário, obtive um erro de índice. Acho que a saída do meu analisador teve pelo menos uma linha que era puramente espaço em branco.
'
s, você obterá alguns erros estranhos. Existem maneiras melhores de chamar coisas na linha de comando
A partir do NLTK v3.3, os usuários devem evitar os identificadores NER ou POS de Stanford nltk.tag
e evitar o tokenizer / segmentador de Stanford nltk.tokenize
.
Em vez disso, use a nova nltk.parse.corenlp.CoreNLPParser
API.
Consulte https://github.com/nltk/nltk/wiki/Stanford-CoreNLP-API-in-NLTK
(Evitando responder apenas com link, colei os documentos do wiki do github NLTK abaixo)
Primeiro, atualize seu NLTK
pip3 install -U nltk # Make sure is >=3.3
Em seguida, baixe os pacotes CoreNLP necessários:
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
Ainda no stanford-corenlp-full-2018-02-27
diretório, inicie o servidor:
java -mx4g -cp "*" edu.stanford.nlp.pipeline.StanfordCoreNLPServer \
-preload tokenize,ssplit,pos,lemma,ner,parse,depparse \
-status_port 9000 -port 9000 -timeout 15000 &
Depois, em 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')]
Inicie o servidor de maneira um pouco diferente, ainda a partir do diretório `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
Em 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', ['。'])])])]
Inicie o servidor:
java -Xmx4g -cp "*" edu.stanford.nlp.pipeline.StanfordCoreNLPServer \
-serverProperties StanfordCoreNLP-arabic.properties \
-preload tokenize,ssplit,pos,parse \
-status_port 9005 -port 9005 -timeout 15000
Em 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')]
Inicie o servidor:
java -Xmx4g -cp "*" edu.stanford.nlp.pipeline.StanfordCoreNLPServer \
-serverProperties StanfordCoreNLP-french.properties \
-preload tokenize,ssplit,pos,parse \
-status_port 9004 -port 9004 -timeout 15000
Em 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')]
Inicie o servidor:
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
Em 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')]
Inicie o servidor:
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
Em 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))
ou list(parser.parse(parser.tokenize(text))
. Corrigido o exemplo;)
Existe uma interface python para o analisador Stanford
A página do software Stanford Core NLP tem uma lista de wrappers python:
Se bem me lembro, o analisador Stanford é uma biblioteca java, portanto, você deve ter um interpretador Java em execução no seu servidor / computador.
Eu usei uma vez um servidor, combinado com um script php. O script usou a função exec () do php para fazer uma chamada de linha de comando para o analisador assim:
<?php
exec( "java -cp /pathTo/stanford-parser.jar -mx100m edu.stanford.nlp.process.DocumentPreprocessor /pathTo/fileToParse > /pathTo/resultFile 2>/dev/null" );
?>
Não me lembro de todos os detalhes desse comando, ele basicamente abriu o fileToParse, o analisou e escreveu a saída no resultFile. O PHP então abriria o arquivo de resultado para uso posterior.
O final do comando direciona o verbose do analisador para NULL, para evitar que informações desnecessárias da linha de comando perturbem o script.
Não sei muito sobre Python, mas pode haver uma maneira de fazer chamadas de linha de comando.
Pode não ser a rota exata que você esperava, mas espero que lhe dê alguma inspiração. Boa sorte.
Observe que esta resposta se aplica ao NLTK v 3.0, e não às versões mais recentes.
Aqui está uma adaptação do código do hazard98 que funciona com nltk3.0.0 no Windows e, presumivelmente, também nas outras plataformas, ajuste os nomes dos diretórios conforme apropriado para sua configuração:
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
Observe que o comando de análise mudou (veja o código-fonte em www.nltk.org/_modules/nltk/parse/stanford.html) e que você precisa definir a variável JAVAHOME. Tentei fazer com que ele lesse o arquivo de gramática in situ no jar, mas até agora não consegui fazer isso.
Você pode usar a saída do Stanford Parsers para criar uma Árvore em nltk (nltk.tree.Tree).
Supondo que o analisador Stanford forneça um arquivo no qual existe exatamente uma árvore de análise para cada frase. Então, este exemplo funciona, embora possa não parecer muito pitônico:
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)
Observe que esta resposta se aplica ao NLTK v 3.0, e não às versões mais recentes.
Uma vez que ninguém realmente mencionou e de alguma forma isso me incomodou muito, aqui está uma maneira alternativa de usar o analisador Stanford em 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)
dessa forma, você não precisa mais se preocupar com o caminho.
Para aqueles que não podem usá-lo corretamente no Ubuntu ou executar o código no Eclipse.
Estou em uma máquina Windows e você pode simplesmente executar o analisador normalmente como faria no comando like, mas como em um diretório diferente, então você não precisa editar o arquivo lexparser.bat. Basta inserir o caminho 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()
A parte complicada para mim foi perceber como executar um programa java a partir de um caminho diferente. Deve haver uma maneira melhor, mas isso funciona.
Observe que esta resposta se aplica ao NLTK v 3.0, e não às versões mais recentes.
Uma ligeira atualização (ou simplesmente alternativa) na resposta abrangente de danger89 sobre o uso de Stanford Parser em NLTK e Python
Com stanford-parser-full-2015-04-20, JRE 1.8 e nltk 3.0.4 (python 2.7.6), parece que você não precisa mais extrair o englishPCFG.ser.gz de stanford-parser-xxx-models .jar ou configurar qualquer 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()
Observe que esta resposta se aplica ao NLTK v 3.0, e não às versões mais recentes.
Aqui está a versão do Windows da resposta do 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)
NOTAS:
Em lexparser.bat
você precisa mudar todos os caminhos em caminho absoluto para evitar erros de java como "classe não encontrada"
Eu recomendo fortemente que você aplique este método no Windows, uma vez que tentei várias respostas na página e todos os métodos comunicam python com Java falham.
gostaria de ouvir de você se você teve sucesso no Windows e gostaria que você pudesse me dizer como você superou todos esses problemas.
procure o wrapper python por stanford coreNLP para obter a versão python
Levei muitas horas e finalmente encontrei uma solução simples para usuários do Windows. Basicamente, é uma versão resumida de uma resposta existente da alvas, mas fácil de seguir (espero) para aqueles que são novos no stanford de PNL e são usuários do Windows.
1) Baixe o módulo que deseja usar, como NER, POS etc. No meu caso, eu queria usar o NER, então baixei o módulo de http://nlp.stanford.edu/software/stanford-ner-2015- 04-20.zip
2) Descompacte o arquivo.
3) Defina as variáveis de ambiente (classpath e stanford_modules) da pasta descompactada.
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) defina as variáveis de ambiente para JAVA, como em onde você instalou JAVA. para mim foi embaixo
os.environ['JAVAHOME'] = "C:/Program Files/Java/jdk1.8.0_102/bin/java.exe"
5) importe o módulo que você deseja
from nltk.tag import StanfordNERTagger
6) chame o modelo pré-treinado que está presente na pasta do classificador na pasta descompactada. adicione ".gz" no final para a extensão do arquivo. para mim, o modelo que eu queria usar eraenglish.all.3class.distsim.crf.ser
st = StanfordNERTagger('english.all.3class.distsim.crf.ser.gz')
7) Agora execute o analisador !! e terminamos !!
st.tag('Rami Eid is studying at Stony Brook University in NY'.split())
A resposta abaixo está obsoleta, use a solução em https://stackoverflow.com/a/51981566/610569 para NLTK v3.3 e superior.
Observação: a seguinte resposta só funcionará em:
Como ambas as ferramentas mudam rapidamente e a API pode parecer muito diferente 3-6 meses depois. Por favor, trate a seguinte resposta como temporal e não uma solução eterna.
Sempre consulte https://github.com/nltk/nltk/wiki/Installing-Third-Party-Software para obter as instruções mais recentes sobre como fazer a interface das ferramentas de PNL de Stanford usando NLTK !!
O código a seguir vem de https://github.com/nltk/nltk/pull/1735#issuecomment-306091826
No 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
Em 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
Por favor, dê uma olhada em http://www.nltk.org/_modules/nltk/parse/corenlp.html para mais informações sobre a API de Stanford. Dê uma olhada nos docstrings!
Observe que esta resposta se aplica ao NLTK v 3.0, e não às versões mais recentes.
Não posso deixar isso como um comentário por causa da reputação, mas como passei (perdi?) Algum tempo resolvendo isso, prefiro compartilhar meu problema / solução para fazer esse analisador funcionar em NLTK.
Na excelente resposta da alvas , é mencionado que:
por exemplo, para o Parser, não haverá um diretório de modelo.
Isso me levou erroneamente a:
STANFORD_MODELS
(e só me importo com o meu CLASSPATH
)../path/tostanford-parser-full-2015-2012-09/models directory
* virtualmente vazio * (ou com um arquivo jar cujo nome não corresponda a nltk regex)!Se o OP, como eu, só queria usar o analisador, pode ser confuso que ao não baixar mais nada (sem POStagger, sem NER, ...) e seguindo todas essas instruções, ainda obteremos um erro.
Eventualmente, para qualquer CLASSPATH
dado (seguindo exemplos e explicações nas respostas deste tópico), ainda receberia o erro:
O NLTK não conseguiu localizar o analisador de stanford - (\ d +) (. (\ D +)) + - models.jar! Defina a variável de ambiente CLASSPATH. Para obter mais informações, em stanford-parser - (\ d +) (. (\ D +)) + - models.jar,
consulte: http://nlp.stanford.edu/software/lex-parser.shtml
OU:
O NLTK não conseguiu localizar stanford-parser.jar! Defina a variável de ambiente CLASSPATH. Para obter mais informações, em stanford-parser.jar, consulte: http://nlp.stanford.edu/software/lex-parser.shtml
Embora , o mais importante, eu pudesse carregar e usar o analisador corretamente se chamasse a função com todos os argumentos e o caminho totalmente especificado, como em:
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)
Portanto, o erro veio NLTK
e como ele está procurando por jars usando as variáveis fornecidas STANFORD_MODELS
e de CLASSPATH
ambiente. Para resolver isso, o *-models.jar
, com a formatação correta (para corresponder ao regex no NLTK
código, portanto, não -corenlp -.... jar) deve estar localizado na pasta designada por STANFORD_MODELS
.
Ou seja, eu primeiro criei:
mkdir stanford-parser-full-2015-12-09/models
Em seguida, adicionado em .bashrc
:
export STANFORD_MODELS=/path/to/stanford-parser-full-2015-12-09/models
E, finalmente, ao copiar stanford-parser-3.6.0-models.jar
(ou versão correspondente), em:
path/to/stanford-parser-full-2015-12-09/models/
Eu poderia começar StanfordParser
a carregar suavemente em python com o clássico CLASSPATH
que aponta para stanford-parser.jar
. Na verdade, como tal, você pode chamar StanfordParser
sem parâmetros, o padrão simplesmente funcionará.
Estou usando o nltk versão 3.2.4. E o código a seguir funcionou para mim.
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)
Resultado:
[('Open', 'VB'), ('app', 'NN'), ('and', 'CC'), ('play', 'VB'), ('movie', 'NN')]
Um novo desenvolvimento do analisador Stanford baseado em um modelo neural, treinado com o Tensorflow, foi disponibilizado recentemente para ser usado como uma API Python. Este modelo é considerado muito mais preciso do que o moel baseado em Java. Você certamente pode se integrar a um pipeline de NLTK.
Link para o analisador. O repositório contém modelos de analisador pré-treinados para 53 idiomas.