¿Es posible utilizar Stanford Parser en NLTK? (No estoy hablando de POS de Stanford).
¿Es posible utilizar Stanford Parser en NLTK? (No estoy hablando de POS de Stanford).
Respuestas:
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:
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.
Descargue NLTK v3 desde: https://github.com/nltk/nltk . E instalar NLTK:
sudo python setup.py instalar
Puede usar el descargador NLTK para obtener Stanford Parser, usando Python:
import nltk
nltk.download()
¡Prueba mi ejemplo! (no olvide cambiar las rutas del jar y cambie la ruta del modelo a la ubicación ser.gz)
O:
Descargue e instale NLTK v3, igual que el anterior.
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
Extraiga el archivo standford-parser-full-20xx-xx-xx.zip.
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.
Abra stanford-parser-3.xx-models.jar con un administrador de archivos (7zip).
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.
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.
¡Prueba mi ejemplo! (no olvide cambiar las rutas del jar y cambie la ruta del modelo a la ubicación ser.gz)
nltk.parse.stanford
? Solo tengo nltk.tag.stanford
en NLTK 2.0.4
.
AttributeError: 'StanfordParser' object has no attribute 'raw_batch_parse'
raw_parse_sents()
for line in sentences: for sentence in line: sentence.draw()
solo puede ejecutar draw () en un objeto Tree;)
NLTK official 3rd party tools
documentación.
La respuesta a continuación está obsoleta, utilice la solución en https://stackoverflow.com/a/51981566/610569 para NLTK v3.3 y superior.
Nota: La siguiente respuesta solo funcionará en:
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!
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 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 NLTK
API 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_JAR
y STANFORD_PARSER
están obsoletas y YA NO se utilizan
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 ):
sudo pip install -U nltk
sudo apt-get install python-nltk
Para Windows (utilice la instalación binaria de 32 bits):
( ¿Por qué no 64 bits? Consulte https://github.com/nltk/nltk/issues/1079 )
Luego, fuera de la paranoia, vuelva a verificar su nltk
versió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)
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:
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 .jar
archivo NLP de Stanford apropiado a la CLASSPATH
variable de entorno.
stanford-ner-2015-04-20/stanford-ner.jar
stanford-postagger-full-2015-04-20/stanford-postagger.jar
stanford-parser-full-2015-04-20/stanford-parser.jar
y 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_MODELS
variable (es decir, el directorio donde puede encontrar dónde se guardan los modelos previamente entrenados)
stanford-ner-2015-04-20/classifiers/
stanford-postagger-full-2015-04-20/models/
En el código, vea que busca el STANFORD_MODELS
directorio 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_JAR
variables 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 .jar
archivo 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)
La respuesta a continuación está obsoleta, utilice la solución en https://stackoverflow.com/a/51981566/610569 para NLTK v3.3 y superior.
A partir del analizador de Stanford actual (2015-04-20), la salida predeterminada para el lexparser.sh
ha 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 .
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
len(i.strip()) > 0
contrario, 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.
'
s, obtendrá algunos errores extraños. Hay mejores formas de llamar a las cosas en la línea de comando
A partir de NLTK v3.3, los usuarios deben evitar los etiquetadores Stanford NER o POS nltk.tag
y evitar el tokenizador / segmentador de Stanford nltk.tokenize
.
En su lugar, utilice la nueva nltk.parse.corenlp.CoreNLPParser
API.
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
Aún en el stanford-corenlp-full-2018-02-27
directorio, 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')]
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', ['。'])])])]
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')]
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')]
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')]
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')]
list(parser.raw_parse(text))
o list(parser.parse(parser.tokenize(text))
. Corregido el ejemplo;)
Hay una interfaz de Python para el analizador de Stanford
La página del software Stanford Core NLP tiene una lista de envoltorios de Python:
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.
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.
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)
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.
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.
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()
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
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())
La respuesta a continuación está obsoleta, utilice la solución en https://stackoverflow.com/a/51981566/610569 para NLTK v3.3 y superior.
Nota: La siguiente respuesta solo funcionará en:
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!
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!
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:
STANFORD_MODELS
(y solo me preocupo por mi CLASSPATH
)../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 CLASSPATH
dado (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)
Por lo tanto, el error provino de NLTK
y cómo está buscando frascos utilizando las variables de entorno STANFORD_MODELS
y proporcionadas CLASSPATH
. Para resolver esto, el *-models.jar
, con el formato correcto (para que coincida con la expresión regular en el NLTK
có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 StanfordParser
a cargar sin problemas en python con el clásico CLASSPATH
que apunta stanford-parser.jar
. En realidad, como tal, puede llamar StanfordParser
sin parámetros, el valor predeterminado simplemente funcionará.
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')]
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.