Stanford Parser y NLTK


90

¿Es posible utilizar Stanford Parser en NLTK? (No estoy hablando de POS de Stanford).



3
Este enlace debe ser más visible. ¿Quizás la respuesta principal debería editarse para mencionar esto?
Lalo Sánchez

1
Solo una nota al margen aquí chicos. Asegúrese de que su Java esté actualizado para Stanford NLP y que JAVA_HOME esté configurado correctamente. A veces, la gente puede tener errores "extraños" que pueden deberse a esto.
Meng Zhao

Para NLTK v3.3, consulte stackoverflow.com/a/51981566/610569
alvas

Respuestas:


89

Tenga en cuenta que esta respuesta se aplica a NLTK v 3.0 y no a versiones más recientes.

Claro, prueba lo siguiente en 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()

Salida:

[Árbol ('RAÍZ', [Árbol ('S', [Árbol ('INTJ', [Árbol ('UH', ['Hola'])]), Árbol (',', [',']), Árbol ('NP', [Árbol ('PRP $', ['Mi']), Árbol ('NN', ['nombre'])]), Árbol ('VP', [Árbol ('VBZ', [ 'es']), Árbol ('ADJP', [Árbol ('JJ', ['Melroy'])])]), Árbol ('.', ['.'])])]), Árbol (' ROOT ', [Tree (' SBARQ ', [Tree (' WHNP ', [Tree (' WP ', [' What '])]), Tree (' SQ ', [Tree (' VBZ ', [' is ' ]), Árbol ('NP', [Árbol ('PRP $', ['su']), Árbol ('NN', ['nombre'])])]), Árbol ('.', ['? '])])])]

Nota 1: En este ejemplo, tanto el analizador como los frascos del modelo están en la misma carpeta.

Nota 2:

  • El nombre del archivo del analizador de stanford es: stanford-parser.jar
  • El nombre del archivo de los modelos stanford es: stanford-parser-xxx-models.jar

Nota 3: El archivo englishPCFG.ser.gz se puede encontrar dentro del archivo models.jar (/edu/stanford/nlp/models/lexparser/englishPCFG.ser.gz). Utilice el administrador de archivos come para 'descomprimir' el archivo models.jar.

Nota 4: asegúrese de estar utilizando Java JRE (entorno de ejecución) 1.8 también conocido como Oracle JDK 8. De lo contrario, obtendrá: No admitido major.minor versión 52.0.

Instalación

  1. Descargue NLTK v3 desde: https://github.com/nltk/nltk . E instalar NLTK:

    sudo python setup.py instalar

  2. Puede usar el descargador NLTK para obtener Stanford Parser, usando Python:

    import nltk
    nltk.download()
  3. ¡Prueba mi ejemplo! (no olvide cambiar las rutas del jar y cambie la ruta del modelo a la ubicación ser.gz)

O:

  1. Descargue e instale NLTK v3, igual que el anterior.

  2. Descargue la última versión de (el nombre de archivo de la versión actual es stanford-parser-full-2015-01-29.zip): http://nlp.stanford.edu/software/lex-parser.shtml#Download

  3. Extraiga el archivo standford-parser-full-20xx-xx-xx.zip.

  4. Cree una nueva carpeta ('frascos' en mi ejemplo). Coloque los archivos extraídos en esta carpeta jar: stanford-parser-3.xx-models.jar y stanford-parser.jar.

    Como se muestra arriba, puede usar las variables de entorno (STANFORD_PARSER & STANFORD_MODELS) para apuntar a esta carpeta 'frascos'. Estoy usando Linux, así que si usa Windows, use algo como: C: // carpeta // jars.

  5. Abra stanford-parser-3.xx-models.jar con un administrador de archivos (7zip).

  6. Navegue dentro del archivo jar; edu / stanford / nlp / models / lexparser. Nuevamente, extraiga el archivo llamado 'englishPCFG.ser.gz'. Recuerde la ubicación donde extrae este archivo ser.gz.

  7. Al crear una instancia de StanfordParser, puede proporcionar la ruta del modelo como parámetro. Esta es la ruta completa al modelo, en nuestro caso /location/of/englishPCFG.ser.gz.

  8. ¡Prueba mi ejemplo! (no olvide cambiar las rutas del jar y cambie la ruta del modelo a la ubicación ser.gz)


1
¿Qué versión de nltk agregó nltk.parse.stanford? Solo tengo nltk.tag.stanforden NLTK 2.0.4.
Alexis

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

5
@alexis: descargue nltk 3.0 desde aquí @Nick Retallack: debería cambiarse araw_parse_sents()
Rasika Perera

1
Esta bien, tienes razón. NLTK cambia la función a: raw_parse_sents (). Consulte la documentación: nltk.org/_modules/nltk/parse/stanford.html Si usa raw_parse (), obtendrá un iter (árbol) como valor de retorno. Lo que significa que la muestra anterior de draw () debería funcionar. Si usa raw_parse_sents (), aparentemente necesita un bucle doble; devuelve un iter (iter (árbol)). Ejemplo de código: for line in sentences: for sentence in line: sentence.draw() solo puede ejecutar draw () en un objeto Tree;)
danger89

1
@ danger89, perdón por sobrescribir su respuesta con la nota EDITADA. Recientemente, la gente se ha estado quejando de que el analizador de dependencias de Stanford se agregó recientemente desde NLTK v3.1 y creo que estaban duplicando algunos fragmentos de código aquí y allá de las respuestas obsoletas aquí. Entonces, para minimizar la confusión, pensé que era mejor agregar exenciones de responsabilidad a todas las respuestas aquí con respecto a seguir las instrucciones de la NLTK official 3rd party toolsdocumentación.
alvas

77

Respuesta obsoleta

La respuesta a continuación está obsoleta, utilice la solución en https://stackoverflow.com/a/51981566/610569 para NLTK v3.3 y superior.


EDITADO

Nota: La siguiente respuesta solo funcionará en:

  • Versión NLTK> = 3.2.4
  • Stanford Tools compilado desde 2015-04-20
  • Python 2.7, 3.4 y 3.5 (Python 3.6 aún no es compatible oficialmente)

Como ambas herramientas cambian con bastante rapidez y la API puede verse muy diferente de 3 a 6 meses después. Trate la siguiente respuesta como temporal y no como una solución eterna.

¡Siempre consulte https://github.com/nltk/nltk/wiki/Installing-Third-Party-Software para obtener las instrucciones más recientes sobre cómo conectar las herramientas 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

Luego:

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

En largo:


En primer lugar , hay que tener en cuenta que las herramientas de PNL de Stanford están escritas en Java y NLTK está escrito en Python . La forma en que NLTK interactúa con la herramienta es mediante la llamada a la herramienta Java a través de la interfaz de línea de comandos.

En segundo lugar , elNLTK API de las herramientas PNL de Stanford ha cambiado bastante desde la versión 3.1. Por lo tanto, es recomendable actualizar su paquete NLTK a v3.1.

En tercer lugar , la NLTKAPI para Stanford NLP Tools envuelve las herramientas individuales de PNL, por ejemplo , el etiquetador POS de Stanford , el etiquetador NER de Stanford , el analizador de Stanford .

Para el etiquetador POS y NER, NO envuelve el paquete Stanford Core NLP .

Para el Stanford Parser, es un caso especial en el que envuelve tanto al Stanford Parser como al Stanford Core NLP (personalmente, no he usado este último usando NLTK, prefiero seguir la demostración de @ dimazest en http: //www.eecs. qmul.ac.uk/~dm303/stanford-dependency-parser-nltk-and-anaconda.html )

Tenga en cuenta que a partir de NLTK v3.1, las variables STANFORD_JARy STANFORD_PARSERestán obsoletas y YA NO se utilizan


En más tiempo:


PASO 1

Suponiendo que haya instalado Java de forma adecuada en su sistema operativo.

Ahora, instale / actualice su versión NLTK (consulte http://www.nltk.org/install.html ):

  • Usando pip :sudo pip install -U nltk
  • Distribución Debian (usando apt-get):sudo apt-get install python-nltk

Para Windows (utilice la instalación binaria de 32 bits):

  1. Instale Python 3.4: http://www.python.org/downloads/ (evite las versiones de 64 bits)
  2. Instale Numpy (opcional): http://sourceforge.net/projects/numpy/files/NumPy/ (la versión que especifica pythnon3.4)
  3. Instale NLTK: http://pypi.python.org/pypi/nltk
  4. Pruebe la instalación: Inicio> Python34, luego escriba import nltk

( ¿Por qué no 64 bits? Consulte https://github.com/nltk/nltk/issues/1079 )


Luego, fuera de la paranoia, vuelva a verificar su nltkversión dentro de Python:

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

O en la línea de comando:

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

Asegúrate de ver 3.1 como resultado.

Para aún más paranoia, compruebe que todas sus API de herramientas PNL favoritas de Stanford estén disponibles:

from nltk.parse.stanford import StanfordParser
from nltk.parse.stanford import StanfordDependencyParser
from nltk.parse.stanford import StanfordNeuralDependencyParser
from nltk.tag.stanford import StanfordPOSTagger, StanfordNERTagger
from nltk.tokenize.stanford import StanfordTokenizer

( Nota : las importaciones anteriores SOLO garantizarán que esté utilizando una versión NLTK correcta que contenga estas API. No ver errores en la importación no significa que haya configurado correctamente la API NLTK para utilizar las herramientas de Stanford)


PASO 2

Ahora que ha verificado que tiene la versión correcta de NLTK que contiene la interfaz de herramientas de PNL de Stanford necesaria. Debe descargar y extraer todas las herramientas de PNL de Stanford necesarias.

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

En Windows / Mac:


PASO 3

Configure las variables de entorno de modo que NLTK pueda encontrar la ruta del archivo relevante automáticamente. Tienes que configurar las siguientes variables:

  • Agregue el .jararchivo NLP de Stanford apropiado a la CLASSPATHvariable de entorno.

    • por ejemplo, para el NER, será stanford-ner-2015-04-20/stanford-ner.jar
    • por ejemplo, para el punto de venta, será stanford-postagger-full-2015-04-20/stanford-postagger.jar
    • por ejemplo, para el analizador, será stanford-parser-full-2015-04-20/stanford-parser.jary el archivo jar del modelo del analizador,stanford-parser-full-2015-04-20/stanford-parser-3.5.2-models.jar
  • Agregue el directorio de modelo apropiado a la STANFORD_MODELSvariable (es decir, el directorio donde puede encontrar dónde se guardan los modelos previamente entrenados)

    • por ejemplo, para el NER, estará en stanford-ner-2015-04-20/classifiers/
    • por ejemplo, para el punto de venta, estará en stanford-postagger-full-2015-04-20/models/
    • por ejemplo, para el analizador, no habrá un directorio modelo.

En el código, vea que busca el STANFORD_MODELSdirectorio antes de agregar el nombre del modelo. También vea que, la API también intenta automáticamente buscar los entornos del sistema operativo para el `CLASSPATH )

Tenga en cuenta que a partir de NLTK v3.1, las STANFORD_JARvariables están obsoletas y YA NO se utilizan . Es posible que los fragmentos de código que se encuentran en las siguientes preguntas de Stackoverflow no funcionen:

TL; DR para PASO 3 en 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 obtener instrucciones sobre cómo configurar las variables de entorno)

Usted DEBE establecer las variables que el anterior antes de iniciar pitón, a continuación:

>>> 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, puede intentar agregar las variables de entorno dentro de Python, como han sugerido las respuestas anteriores, pero también puede decirle directamente al analizador / etiquetador que se inicialice en la ruta directa donde guardó el .jararchivo y sus modelos.

NO es necesario establecer las variables de entorno si usa el siguiente método, PERO cuando la API cambia los nombres de los parámetros, deberá cambiar en consecuencia. Es por eso que es MÁS recomendable establecer las variables de entorno que modificar su código de Python para adaptarse a la versión NLTK.

Por ejemplo ( sin establecer ninguna variable de entorno ):

# POS tagging:

from nltk.tag import StanfordPOSTagger

stanford_pos_dir = '/home/alvas/stanford-postagger-full-2015-04-20/'
eng_model_filename= stanford_pos_dir + 'models/english-left3words-distsim.tagger'
my_path_to_jar= stanford_pos_dir + 'stanford-postagger.jar'

st = StanfordPOSTagger(model_filename=eng_model_filename, path_to_jar=my_path_to_jar) 
st.tag('What is the airspeed of an unladen swallow ?'.split())


# NER Tagging:
from nltk.tag import StanfordNERTagger

stanford_ner_dir = '/home/alvas/stanford-ner/'
eng_model_filename= stanford_ner_dir + 'classifiers/english.all.3class.distsim.crf.ser.gz'
my_path_to_jar= stanford_ner_dir + 'stanford-ner.jar'

st = StanfordNERTagger(model_filename=eng_model_filename, path_to_jar=my_path_to_jar) 
st.tag('Rami Eid is studying at Stony Brook University in NY'.split())

# Parsing:
from nltk.parse.stanford import StanfordParser

stanford_parser_dir = '/home/alvas/stanford-parser/'
eng_model_path = stanford_parser_dir  + "edu/stanford/nlp/models/lexparser/englishRNN.ser.gz"
my_path_to_models_jar = stanford_parser_dir  + "stanford-parser-3.5.2-models.jar"
my_path_to_jar = stanford_parser_dir  + "stanford-parser.jar"

parser=StanfordParser(model_path=eng_model_path, path_to_models_jar=my_path_to_models_jar, path_to_jar=my_path_to_jar)

22

Respuesta obsoleta

La respuesta a continuación está obsoleta, utilice la solución en https://stackoverflow.com/a/51981566/610569 para NLTK v3.3 y superior.


Editado

A partir del analizador de Stanford actual (2015-04-20), la salida predeterminada para el lexparser.shha cambiado, por lo que el siguiente script no funcionará.

Pero esta respuesta se mantiene por el bien del legado, aunque seguirá funcionando con http://nlp.stanford.edu/software/stanford-parser-2012-11-12.zip .


Respuesta original

Te sugiero que no te metas con Jython, JPype. Deje que Python haga cosas de Python y deje que Java haga cosas de Java, obtenga la salida del Stanford Parser a través de la consola.

Una vez que haya instalado Stanford Parser en su directorio de inicio ~/, simplemente use esta receta de Python para obtener el análisis entre corchetes planos:

import os
sentence = "this is a foo bar i want to parse."

os.popen("echo '"+sentence+"' > ~/stanfordtemp.txt")
parser_out = os.popen("~/stanford-parser-2012-11-12/lexparser.sh ~/stanfordtemp.txt").readlines()

bracketed_parse = " ".join( [i.strip() for i in parser_out if i.strip()[0] == "("] )
print bracketed_parse

1
Esto funcionó para mí, excepto que necesitaba agregar una condición para verificar, de lo len(i.strip()) > 0contrario, obtuve un error de índice. Supongo que la salida de mi analizador tenía al menos una línea que era puramente espacios en blanco.
aelfric5578

1
alternativamente, use esta envoltura de python para las herramientas corenlp de stanford, bitbucket.org/torotoki/corenlp-python
alvas

3
Tenga cuidado con esto. Si su entrada contiene algún 's, obtendrá algunos errores extraños. Hay mejores formas de llamar a las cosas en la línea de comando
Nick Garvey

20

A partir de NLTK v3.3, los usuarios deben evitar los etiquetadores Stanford NER o POS nltk.tagy evitar el tokenizador / segmentador de Stanford nltk.tokenize.

En su lugar, utilice la nueva nltk.parse.corenlp.CoreNLPParserAPI.

Consulte https://github.com/nltk/nltk/wiki/Stanford-CoreNLP-API-in-NLTK


(Evitando la respuesta de solo enlace, he pegado los documentos de NLTK github wiki a continuación)

Primero, actualice su NLTK

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

Luego descargue los paquetes CoreNLP necesarios:

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

Aún en el stanford-corenlp-full-2018-02-27directorio, inicie el servidor:

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

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

chino

Inicie el servidor de forma un poco diferente, aún desde el directorio `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

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

Arábica

Inicie el 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

En 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 el 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

En 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án

Inicie el 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

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

Español

Inicie el 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

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

Excelente respuesta. Gracias
Eben

Gracias, esto es muy útil. Sin embargo, el análisis sintáctico árabe no es correcto. Está dividiendo el texto en letras en lugar de palabras
Labibah

Utilice list(parser.raw_parse(text))o list(parser.parse(parser.tokenize(text)). Corregido el ejemplo;)
alvas

1
¡No puedo creer que esto no se anuncie más!
Nimitz

1
Lamentablemente, NLTK no tiene suficientes personas en las reuniones para dar charlas o tener los recursos para organizar una elegante conferencia de desarrollo para promover la herramienta = (No dude en presentar esta función o NLTK a la comunidad que lo rodea.
alvas



6

Si mal no recuerdo, el analizador de Stanford es una biblioteca de Java, por lo tanto, debe tener un intérprete de Java ejecutándose en su servidor / computadora.

Lo usé una vez en un servidor, combinado con un script php. El script usó la función exec () de php para hacer una llamada de línea de comandos al analizador así:

<?php

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

?>

No recuerdo todos los detalles de este comando, básicamente abrió el fileToParse, lo analizó y escribió la salida en el resultFile. PHP luego abriría el archivo de resultados para su uso posterior.

El final del comando dirige el verbose del analizador a NULL, para evitar que la información innecesaria de la línea de comandos altere el script.

No sé mucho sobre Python, pero podría haber una forma de hacer llamadas a la línea de comandos.

Puede que no sea la ruta exacta que esperabas, pero con suerte te dará algo de inspiración. La mejor de las suertes.


6

Tenga en cuenta que esta respuesta se aplica a NLTK v 3.0 y no a versiones más recientes.

Aquí hay una adaptación del código de danger98 que funciona con nltk3.0.0 en windoze, y presumiblemente las otras plataformas también, ajuste los nombres de directorio según corresponda para su configuración:

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

Tenga en cuenta que el comando de análisis ha cambiado (consulte el código fuente en www.nltk.org/_modules/nltk/parse/stanford.html) y que necesita definir la variable JAVAHOME. Intenté que leyera el archivo de gramática in situ en el frasco, pero hasta ahora no lo he logrado.


Soy de 1989, no del 98, pero gracias por tu ejemplo;)
danger89

4

Puede utilizar la salida de Stanford Parsers para crear un árbol en nltk (nltk.tree.Tree).

Suponiendo que el analizador de Stanford le proporciona un archivo en el que hay exactamente un árbol de análisis por cada oración. Entonces este ejemplo funciona, aunque puede que no parezca muy 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)

1
+1 para permitir que Java haga cosas de Java y Python haga cosas de Python. Dependiendo de cómo llame al comando java y de las opciones, el análisis del archivo de salida del analizador stanford puede ser diferente. Sería bueno si también agregara detalles sobre cómo llamó a Stanford Parse para obtener su archivo de salida.
alvas

4

Tenga en cuenta que esta respuesta se aplica a NLTK v 3.0 y no a versiones más recientes.

Como nadie realmente lo mencionó y de alguna manera me preocupa mucho, aquí hay una forma alternativa de usar el analizador de Stanford en 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)

de esta manera, ya no tendrá que preocuparse por la ruta.

Para aquellos que no pueden usarlo correctamente en Ubuntu o ejecutar el código en Eclipse.


3

Estoy en una máquina con Windows y simplemente puede ejecutar el analizador normalmente como lo hace desde el comando, pero como en un directorio diferente, por lo que no necesita editar el archivo lexparser.bat. Solo ingrese el camino completo.

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

La parte complicada para mí fue darme cuenta de cómo ejecutar un programa Java desde una ruta diferente. Debe haber una forma mejor, pero funciona.


3

Tenga en cuenta que esta respuesta se aplica a NLTK v 3.0 y no a versiones más recientes.

Una ligera actualización (o simplemente alternativa) sobre la respuesta completa de danger89 sobre el uso de Stanford Parser en NLTK y Python

Con stanford-parser-full-2015-04-20, JRE 1.8 y nltk 3.0.4 (python 2.7.6), parece que ya no es necesario extraer el englishPCFG.ser.gz de stanford-parser-xxx-models .jar o configurando cualquier os.environ

from nltk.parse.stanford import StanfordParser

english_parser = StanfordParser('path/stanford-parser.jar', 'path/stanford-parser-3.5.2-models.jar')

s = "The real voyage of discovery consists not in seeking new landscapes, but in having new eyes."

sentences = english_parser.raw_parse_sents((s,))
print sentences #only print <listiterator object> for this version

#draw the tree
for line in sentences:
    for sentence in line:
        sentence.draw()

3

Tenga en cuenta que esta respuesta se aplica a NLTK v 3.0 y no a versiones más recientes.

Aquí está la versión de Windows de la respuesta de 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:

  • En lexparser.bat lo que necesita para cambiar todos los caminos en ruta absoluta a errores a evitar en Java, como "clase no encontrado"

  • Le recomiendo encarecidamente que aplique este método en Windows, ya que probé varias respuestas en la página y todos los métodos comunican Python con Java.

  • Deseo saber de usted si tiene éxito en Windows y desea que pueda decirme cómo ha superado todos estos problemas.

  • buscar envoltorio de python para stanford coreNLP para obtener la versión de python



2

Me tomó muchas horas y finalmente encontré una solución simple para los usuarios de Windows. Básicamente, es una versión resumida de una respuesta existente de alvas, pero es fácil de seguir (con suerte) para aquellos que son nuevos en Stanford NLP y son usuarios de Windows.

1) Descargue el módulo que desea usar, como NER, POS, etc. En mi caso, quería usar NER, así que descargué el módulo de http://nlp.stanford.edu/software/stanford-ner-2015- 04-20.zip

2) Descomprime el archivo.

3) Establezca las variables de entorno (classpath y stanford_modules) de la carpeta descomprimida.

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) establezca las variables de entorno para JAVA, como en donde tiene JAVA instalado. para mi estaba abajo

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

5) importa el módulo que quieras

from nltk.tag import StanfordNERTagger

6) llame al modelo preentrenado que está presente en la carpeta del clasificador en la carpeta descomprimida. agregue ".gz" al final para la extensión del archivo. para mí el modelo que quería usar eraenglish.all.3class.distsim.crf.ser

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

7) ¡ Ahora ejecute el analizador! y hemos terminado !!

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


2

Respuesta obsoleta

La respuesta a continuación está obsoleta, utilice la solución en https://stackoverflow.com/a/51981566/610569 para NLTK v3.3 y superior.


EDITADO

Nota: La siguiente respuesta solo funcionará en:

  • Versión NLTK == 3.2.5
  • Stanford Tools compilado desde 2016-10-31
  • Python 2.7, 3.5 y 3.6

Como ambas herramientas cambian con bastante rapidez y la API puede verse muy diferente de 3 a 6 meses después. Trate la siguiente respuesta como temporal y no como una solución eterna.

¡Siempre consulte https://github.com/nltk/nltk/wiki/Installing-Third-Party-Software para obtener las instrucciones más recientes sobre cómo conectar las herramientas de PNL de Stanford usando NLTK!

TL; DR

El siguiente código proviene de https://github.com/nltk/nltk/pull/1735#issuecomment-306091826

En 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

En 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, eche un vistazo a http://www.nltk.org/_modules/nltk/parse/corenlp.html para obtener más información sobre la API de Stanford. ¡Eche un vistazo a las cadenas de documentación!


2

Tenga en cuenta que esta respuesta se aplica a NLTK v 3.0 y no a versiones más recientes.

No puedo dejar esto como un comentario debido a mi reputación, pero como pasé (¿desperdiciado?) Algo de tiempo resolviendo esto, prefiero compartir mi problema / solución para que este analizador funcione en NLTK.

En la excelente respuesta de alvas , se menciona que:

por ejemplo, para el analizador, no habrá un directorio modelo.

Esto me llevó erróneamente a:

  • no tenga cuidado con el valor que le doy STANFORD_MODELS (y solo me preocupo por mi CLASSPATH)
  • deje ../path/tostanford-parser-full-2015-2012-09/models directory* prácticamente vacío * (o con un archivo jar cuyo nombre no coincida con nltk regex).

Si el OP, como yo, solo quería usar el analizador, puede resultar confuso que al no descargar nada más (sin POStagger, sin NER, ...) y seguir todas estas instrucciones, todavía obtengamos un error.

Eventualmente, para cualquier CLASSPATHdado (siguientes ejemplos y explicaciones en las respuestas de este hilo) todavía obtendría el error:

NLTK no pudo encontrar stanford-parser - (\ d +) (. (\ D +)) + - models.jar! Establezca la variable de entorno CLASSPATH. Para obtener más información, en stanford-parser - (\ d +) (. (\ D +)) + - models.jar,

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

O:

¡NLTK no pudo encontrar stanford-parser.jar! Establezca la variable de entorno CLASSPATH. Para obtener más información, en stanford-parser.jar, consulte: http://nlp.stanford.edu/software/lex-parser.shtml

Aunque , lo que es más importante, podría cargar y usar correctamente el analizador si llamara a la función con todos los argumentos y la ruta completamente especificados, como en:

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)

Solución solo para analizador:

Por lo tanto, el error provino de NLTKy cómo está buscando frascos utilizando las variables de entorno STANFORD_MODELSy proporcionadas CLASSPATH. Para resolver esto, el *-models.jar, con el formato correcto (para que coincida con la expresión regular en el NLTKcódigo, por lo que no -corenlp -.... jar) debe estar ubicado en la carpeta designada por STANFORD_MODELS.

Es decir, primero creé:

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

Luego agregado en .bashrc:

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

Y finalmente, copiando stanford-parser-3.6.0-models.jar(o versión correspondiente), en:

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

Pude llegar StanfordParsera cargar sin problemas en python con el clásico CLASSPATHque apunta stanford-parser.jar. En realidad, como tal, puede llamar StanfordParsersin parámetros, el valor predeterminado simplemente funcionará.


2

Estoy usando nltk versión 3.2.4. Y el siguiente código funcionó para mí.

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)

Salida:

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

Creo que este es el etiquetador y no el analizador
Nadav B

1

Un nuevo desarrollo del analizador de Stanford basado en un modelo neuronal, entrenado con Tensorflow, está disponible recientemente para su uso como una API de Python. Se supone que este modelo es mucho más preciso que el moel basado en Java. Sin duda, puede integrarse con una canalización NLTK.

Enlace al analizador. El repositorio contiene modelos de analizador previamente entrenados para 53 idiomas.

Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.