Stanford Parser e NLTK

90

É possível usar o Stanford Parser no NLTK? (Não estou falando sobre Stanford POS.)

ThanaDaray
fonte
3
Este link precisa ser mais visível. Talvez a resposta principal deva ser editada para mencionar isso?
Lalo Sánchez
1
Só uma nota lateral aqui, pessoal. Certifique-se de que seu Java está atualizado para Stanford NLP e JAVA_HOME está configurado corretamente. Às vezes, as pessoas podem receber erros "estranhos" que podem ser devido a isso.
Meng Zhao
Para NLTK v3.3, consulte stackoverflow.com/a/51981566/610569
alvas

Respostas:

89

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:

  • O nome do arquivo do analisador stanford é: stanford-parser.jar
  • O nome do arquivo dos modelos stanford é: stanford-parser-xxx-models.jar

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.

Instalação

  1. Baixe o NLTK v3 em: https://github.com/nltk/nltk . E instale o NLTK:

    sudo python setup.py install

  2. Você pode usar o downloader NLTK para obter o Stanford Parser, usando Python:

    import nltk
    nltk.download()
  3. 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:

  1. Baixe e instale o NLTK v3, o mesmo que acima.

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

  3. Extraia o standford-parser-full-20xx-xx-xx.zip.

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

  5. Abra o stanford-parser-3.xx-models.jar usando um gerenciador de arquivos (7zip).

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

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

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

perigo 89
fonte
1
Qual versão do nltk adicionada nltk.parse.stanford? Eu só tenho nltk.tag.stanfordem NLTK 2.0.4.
alexis
1
AttributeError: 'StanfordParser' object has no attribute 'raw_batch_parse'
Nick Retallack
5
@alexis: baixe o nltk 3.0 aqui @Nick Retallack: deve ser alterado pararaw_parse_sents()
Rasika Perera
1
OK, você está certo. NLTK muda a função para: raw_parse_sents (). Veja a documentação: nltk.org/_modules/nltk/parse/stanford.html Se você usar raw_parse (), irá recuperar um iter (Árvore) como valor de retorno. Significa que a amostra acima de draw () deve funcionar. Se você está usando raw_parse_sents (), você precisa de um loop duplo aparentemente; ele está retornando um iter (iter (Tree)). Portanto, exemplo de código: for line in sentences: for sentence in line: sentence.draw() Você só pode executar draw () em um objeto Árvore;)
hazard89,
1
@ hazard89, desculpe por sobrescrever sua resposta com a nota EDITADA. Recentemente, as pessoas reclamaram que o analisador de dependência de Stanford só foi adicionado recentemente desde o NLTK v3.1 e acho que eles estavam duplicando alguns trechos de código aqui e ali a partir das respostas obsoletas aqui. Portanto, para minimizar a confusão, achei melhor adicionar isenções de responsabilidade a todas as respostas aqui no que diz respeito a seguir as instruções da NLTK official 3rd party toolsdocumentação.
Alvas
77

Resposta obsoleta

A resposta abaixo está obsoleta, use a solução em https://stackoverflow.com/a/51981566/610569 para NLTK v3.3 e superior.


EDITADO

Observação: a seguinte resposta só funcionará em:

  • Versão NLTK> = 3.2.4
  • Stanford Tools compilado desde 2015-04-20
  • Python 2.7, 3.4 e 3.5 (Python 3.6 ainda não é oficialmente compatível)

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


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

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

In Long:


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 NLTKAPI 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 NLTKAPI 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_JARe STANFORD_PARSERestão obsoletas e NÃO MAIS usadas


In Longer:


PASSO 1

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

  • Usando pip :sudo pip install -U nltk
  • Distribuição Debian (usando apt-get):sudo apt-get install python-nltk

Para Windows (use a instalação binária de 32 bits):

  1. Instale o Python 3.4: http://www.python.org/downloads/ (evite as versões de 64 bits)
  2. Instale o Numpy (opcional): http://sourceforge.net/projects/numpy/files/NumPy/ (a versão que especifica pythnon3.4)
  3. Instale o NLTK: http://pypi.python.org/pypi/nltk
  4. Teste de instalação: Iniciar> Python34 e digite import nltk

( Por que não 64 bits? Consulte https://github.com/nltk/nltk/issues/1079 )


Então, por paranóia, verifique novamente sua nltkversã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.1como 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 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)


PASSO 2

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:


ETAPA 3

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 .jararquivo Stanford NLP apropriado à CLASSPATHvariável de ambiente.

    • por exemplo, para o NER, será stanford-ner-2015-04-20/stanford-ner.jar
    • por exemplo, para o PDV, será stanford-postagger-full-2015-04-20/stanford-postagger.jar
    • por exemplo, para o analisador, será stanford-parser-full-2015-04-20/stanford-parser.jare 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_MODELSvariável (ou seja, o diretório onde você pode encontrar onde os modelos pré-treinados são salvos)

    • por exemplo, para o NER, será em stanford-ner-2015-04-20/classifiers/
    • por exemplo, para o POS, será em stanford-postagger-full-2015-04-20/models/
    • por exemplo, para o Parser, não haverá um diretório de modelo.

No código, verifique se ele procura o STANFORD_MODELSdiretó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_JARvariá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 .jararquivo 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)
Alvas
fonte
22

Resposta obsoleta

A resposta abaixo está obsoleta, use a solução em https://stackoverflow.com/a/51981566/610569 para NLTK v3.3 e superior.


Editado

A partir do analisador Stanford atual (20-04-2015), a saída padrão do lexparser.shfoi 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 .


Resposta Original

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
Alvas
fonte
1
Isso funcionou para mim, exceto que eu precisava adicionar uma condição para verificar, len(i.strip()) > 0caso 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.
aelfric5578
1
como alternativa, use este wrapper python para ferramentas stanford corenlp, bitbucket.org/torotoki/corenlp-python
alvas
3
Cuidado com isso. Se sua entrada contiver algum 's, você obterá alguns erros estranhos. Existem maneiras melhores de chamar coisas na linha de comando
Nick Garvey
20

A partir do NLTK v3.3, os usuários devem evitar os identificadores NER ou POS de Stanford nltk.tage evitar o tokenizer / segmentador de Stanford nltk.tokenize.

Em vez disso, use a nova nltk.parse.corenlp.CoreNLPParserAPI.

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 

Inglês

Ainda no stanford-corenlp-full-2018-02-27diretó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')]

chinês

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

árabe

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

francês

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

alemão

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

espanhol

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')]
Alvas
fonte
Excelente resposta. Obrigado
Eben
Obrigado, isso é muito útil. A análise árabe não está correta. Está dividindo o texto em letras em vez de palavras
Labibah
Use list(parser.raw_parse(text))ou list(parser.parse(parser.tokenize(text)). Corrigido o exemplo;)
alvas de
1
Não posso acreditar que isso não é mais anunciado !!
Nimitz14,
1
Infelizmente, o NLTK não tem pessoas suficientes em encontros para dar palestras ou os recursos para hospedar a snazzy dev conference para promover a ferramenta = (Sinta-se à vontade para apresentar este recurso ou o NLTK para a comunidade ao seu redor.
alvas
6

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.

bob dope
fonte
6

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.

Avery Andrews
fonte
Sou de 1989, não de 98, mas obrigado pelo seu exemplo;)
danger89
4

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)
Sadik
fonte
1
1 por deixar java fazer coisas de java e python fazer coisas de python. Dependendo de como você chama o comando java e de quais opções, a análise do arquivo de saída do analisador Stanford pode ser diferente. Seria bom se você também adicionasse detalhes sobre como você chamou o Stanford Parse para obter seu arquivo de saída.
alvas
4

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.

Zhong Zhu
fonte
3

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.

Ted Petrou
fonte
3

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()
SYK
fonte
3

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


redreamalidade
fonte
2

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())
StatguyUser
fonte
2

Resposta obsoleta

A resposta abaixo está obsoleta, use a solução em https://stackoverflow.com/a/51981566/610569 para NLTK v3.3 e superior.


EDITADO

Observação: a seguinte resposta só funcionará em:

  • Versão NLTK == 3.2.5
  • Ferramentas de Stanford compiladas desde 31/10/2016
  • Python 2.7, 3.5 e 3.6

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

TL; DR

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!

Alvas
fonte
2

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:

  • não tenha cuidado com o valor que atribuo STANFORD_MODELS (e só me importo com o meu CLASSPATH)
  • deixe ../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 CLASSPATHdado (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)

Solução apenas para o analisador:

Portanto, o erro veio NLTKe como ele está procurando por jars usando as variáveis fornecidas STANFORD_MODELSe de CLASSPATHambiente. Para resolver isso, o *-models.jar, com a formatação correta (para corresponder ao regex no NLTKcó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 StanfordParsera carregar suavemente em python com o clássico CLASSPATHque aponta para stanford-parser.jar. Na verdade, como tal, você pode chamar StanfordParsersem parâmetros, o padrão simplesmente funcionará.

H. Rev.
fonte
2

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')]
Aditi
fonte
Acho que este é o identificador e não o analisador
Nadav B
1

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.

0x5050
fonte