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

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)

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

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:

• Baixe e descompacte o analisador em http://nlp.stanford.edu/software/lex-parser.shtml#Download
• Baixe e descompacte o tagger da VERSÃO COMPLETA em http://nlp.stanford.edu/software/tagger.shtml#Download
• Baixe e descompacte o tagger NER em http://nlp.stanford.edu/software/CRF-NER.shtml#Download

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:

• Stanford Dependency Parser Setup e NLTK
• interface nltk para analisador stanford
• problemas para importar stanford pos tagger para nltk
• Stanford Entity Recognizer (sem caso) em Python Nltk
• Como melhorar a velocidade com Stanford NLP Tagger e NLTK
• Como posso obter o módulo stanford NLTK python?
• Stanford Parser e janelas NLTK
• Funcionalidade do Stanford Named Entity Recognizer (NER) com NLTK
• O analisador Stanford com NLTK produz uma saída vazia
• Extraia a lista de pessoas e organizações usando Stanford NER Tagger em NLTK
• Erro ao usar Stanford POS Tagger em NLTK Python

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)

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

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

Existe uma interface python para o analisador Stanford

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

A página do software Stanford Core NLP tem uma lista de wrappers python:

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

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

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!

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

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.