是否可以在 NLTK 中使用斯坦福解析器？（我不是在谈论斯坦福 POS。）
问问题
104855 次
18 回答
94
请注意，此答案适用于 NLTK v 3.0，而不适用于更新的版本。
当然，在 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()
输出：
[Tree('ROOT', [Tree('S', [Tree('INTJ', [Tree('UH', ['Hello'])]), Tree(',', [',']),树（'NP'，[树（'PRP$'，['My']），树（'NN'，['name']）]），树（'VP'，[树（'VBZ'，[ 'is']), Tree('ADJP', [Tree('JJ', ['Melroy'])])]), Tree('.', ['.'])])]), Tree(' ROOT', [Tree('SBARQ', [Tree('WHNP', [Tree('WP', ['What'])]), Tree('SQ', [Tree('VBZ', ['is' ]), Tree('NP', [Tree('PRP$', ['your']), Tree('NN', ['name'])])]), Tree('.', ['? '])])])]
注意 1： 在这个例子中，解析器和模型 jar 都在同一个文件夹中。
笔记2：
- stanford解析器的文件名是：stanford-parser.jar
- stanford 模型的文件名是：stanford-parser-xxx-models.jar
注 3： englishPCFG.ser.gz 文件可以在 models.jar 文件中找到（ /edu/stanford/nlp/models/lexparser/englishPCFG.ser.gz）。请使用来存档管理器“解压缩”models.jar 文件。
注意 4： 确保您使用的是 Java JRE（运行时环境）1.8，也称为 Oracle JDK 8。否则您将得到：不支持的 major.minor 版本 52.0。
安装
从： https ://github.com/nltk/nltk下载 NLTK v3 。并安装 NLTK：
须藤 python setup.py 安装
您可以使用 NLTK 下载器获取 Stanford Parser，使用 Python：
import nltk nltk.download()试试我的例子！（不要忘记更改 jar 路径并将模型路径更改为 ser.gz 位置）
或者：
下载并安装 NLTK v3，同上。
从（当前版本文件名为 stanford-parser-full-2015-01-29.zip）下载最新版本：http: //nlp.stanford.edu/software/lex-parser.shtml#Download
提取standford-parser-full-20xx-xx-xx.zip。
创建一个新文件夹（在我的示例中为“jars”）。将提取的文件放入此 jar 文件夹：stanford-parser-3.xx-models.jar 和 stanford-parser.jar。
如上所示，您可以使用环境变量 (STANFORD_PARSER & STANFORD_MODELS) 指向此“jars”文件夹。我使用的是 Linux，所以如果你使用 Windows，请使用类似：C://folder//jars。
使用存档管理器 (7zip) 打开 stanford-parser-3.xx-models.jar。
浏览jar文件；edu/stanford/nlp/models/lexparser。再次提取名为“englishPCFG.ser.gz”的文件。记住您提取此 ser.gz 文件的位置。
创建 StanfordParser 实例时，您可以提供模型路径作为参数。这是模型的完整路径，在我们的例子中是 /location/of/englishPCFG.ser.gz。
试试我的例子！（不要忘记更改 jar 路径并将模型路径更改为 ser.gz 位置）
于 2014-03-08T13:03:36.997 回答
78
已弃用的答案
以下答案已弃用，请使用https://stackoverflow.com/a/51981566/610569上的解决方案，用于 NLTK v3.3 及更高版本。
已编辑
注意：以下答案仅适用于：
- NLTK 版本 >=3.2.4
- 斯坦福工具编译自 2015-04-20
- Python 2.7、3.4 和 3.5（尚未正式支持 Python 3.6）
由于这两种工具的变化都很快，而且 API 可能在 3-6 个月后看起来非常不同。请将以下答案视为暂时的，而不是永恒的解决方案。
有关如何使用 NLTK 连接斯坦福 NLP 工具的最新说明，请始终参考https://github.com/nltk/nltk/wiki/Installing-Third-Party-Software ！
TL;博士
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
然后：
>>> 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'])])]
在长：
首先，必须注意斯坦福 NLP 工具是用 Java 编写的，而NLTK 是用 Python 编写的。NLTK 连接工具的方式是通过命令行界面调用 Java 工具。
其次，NLTK自 3.1 版以来，斯坦福 NLP 工具的 API 发生了很大变化。因此建议将您的 NLTK 包更新到 v3.1。
第三，NLTKStanford NLP Tools 的 API 围绕着各个 NLP 工具，例如Stanford POS tagger、Stanford NER Tagger、Stanford Parser。
对于 POS 和 NER 标注器，它不包含Stanford Core NLP package。
对于Stanford Parser，这是一个特殊情况，它同时包含Stanford Parser 和Stanford Core NLP（就我个人而言，我没有在NLTK 中使用后者，我宁愿遵循@dimazest 在http://www.eecs 上的演示。 qmul.ac.uk/~dm303/stanford-dependency-parser-nltk-and-anaconda.html )
请注意，从 NLTK v3.1 开始，不推荐使用STANFORD_JARandSTANFORD_PARSER变量，不再使用
更长的：
步骤1
假设您已在操作系统上正确安装了 Java。
现在，安装/更新您的 NLTK 版本（参见http://www.nltk.org/install.html）：
- 使用点子：
sudo pip install -U nltk - Debian 发行版（使用 apt-get）：
sudo apt-get install python-nltk
对于 Windows（使用 32 位二进制安装）：
- 安装 Python 3.4： http: //www.python.org/downloads/（避免使用 64 位版本）
- 安装 Numpy（可选）： http: //sourceforge.net/projects/numpy/files/NumPy/（指定pythnon3.4的版本）
- 安装 NLTK： http: //pypi.python.org/pypi/nltk
- 测试安装：开始>Python34，然后输入import nltk
（为什么不是 64 位？见https://github.com/nltk/nltk/issues/1079）
然后出于偏执，重新检查你nltk在 python 中的版本：
from __future__ import print_function
import nltk
print(nltk.__version__)
或者在命令行上：
python3 -c "import nltk; print(nltk.__version__)"
确保您看到3.1的是输出。
如果你更偏执，请检查所有你最喜欢的斯坦福 NLP 工具 API 是否可用：
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
（注意：上面的导入只会确保您使用的是包含这些 API 的正确 NLTK 版本。在导入中没有看到错误并不意味着您已成功配置 NLTK API 以使用斯坦福工具）
第2步
现在您已经检查了是否拥有正确版本的 NLTK，其中包含必要的斯坦福 NLP 工具接口。您需要下载并提取所有必要的斯坦福 NLP 工具。
TL;DR，在 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
在 Windows/Mac 中：
- 从http://nlp.stanford.edu/software/lex-parser.shtml#Download下载并解压缩解析器
- 从http://nlp.stanford.edu/software/tagger.shtml#Download下载并统一FULL VERSION标记器
- 从http://nlp.stanford.edu/software/CRF-NER.shtml#Download下载并统一 NER 标记器
第 3 步
设置环境变量，使 NLTK 可以自动找到相关的文件路径。您必须设置以下变量：
将适当的斯坦福 NLP
.jar文件添加到CLASSPATH环境变量中。- 例如对于 NER，它将是
stanford-ner-2015-04-20/stanford-ner.jar - 例如对于 POS，它将是
stanford-postagger-full-2015-04-20/stanford-postagger.jar - 例如对于解析器，它将是
stanford-parser-full-2015-04-20/stanford-parser.jar解析器模型的 jar 文件，stanford-parser-full-2015-04-20/stanford-parser-3.5.2-models.jar
- 例如对于 NER，它将是
将适当的模型目录添加到
STANFORD_MODELS变量中（即可以找到保存预训练模型的目录）- 例如对于 NER，它将在
stanford-ner-2015-04-20/classifiers/ - 例如对于 POS，它将在
stanford-postagger-full-2015-04-20/models/ - 例如对于解析器，不会有模型目录。
- 例如对于 NER，它将在
STANFORD_MODELS在代码中，看到它在附加模型名称之前搜索目录。另请参阅，API 还会自动尝试在操作系统环境中搜索`CLASSPATH）
请注意，从 NLTK v3.1 开始，STANFORD_JAR变量已弃用且不再使用。以下 Stackoverflow 问题中的代码片段可能不起作用：
- 斯坦福依赖解析器设置和 NLTK
- 斯坦福解析器的 nltk 接口
- 将 stanford pos tagger 导入 nltk 时遇到问题
- Python Nltk 中的斯坦福实体识别器（无壳）
- 如何使用 Stanford NLP Tagger 和 NLTK 提高速度
- 如何获得 stanford NLTK python 模块？
- 斯坦福解析器和 NLTK 窗口
- 带有 NLTK 的斯坦福命名实体识别器 (NER) 功能
- 带有 NLTK 的斯坦福解析器产生空输出
- 在 NLTK 中使用斯坦福 NER 标记器提取人员和组织列表
- 在 NLTK Python 中使用斯坦福 POS 标记器时出错
TL; Ubuntu 上第 3 步的 DR
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
（对于 Windows：有关设置环境变量的说明，请参阅https://stackoverflow.com/a/17176423/610569 ）
在启动 python 之前，您必须如上所述设置变量，然后：
>>> 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'])])])])])])]
或者，您可以尝试在 python 中添加环境变量，正如前面的答案所建议的那样，但您也可以直接告诉解析器/标记器初始化为您保存.jar文件和模型的直接路径。
如果您使用以下方法，则无需设置环境变量，但是当 API 更改其参数名称时，您将需要相应更改。这就是为什么设置环境变量比修改 python 代码以适应 NLTK 版本更可取的原因。
例如（不设置任何环境变量）：
# 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)
于 2015-12-06T00:45:28.640 回答
25
从 NLTK v3.3 开始，用户应避免使用来自 的斯坦福 NER 或 POS 标记器nltk.tag，并避免使用来自nltk.tokenize.
而是使用新的nltk.parse.corenlp.CoreNLPParserAPI。
请参阅https://github.com/nltk/nltk/wiki/Stanford-CoreNLP-API-in-NLTK
（避免仅链接答案，我已从下面的 NLTK github wiki 粘贴了文档）
首先，更新您的 NLTK
pip3 install -U nltk # Make sure is >=3.3
然后下载必要的 CoreNLP 包：
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
英语
仍然在stanford-corenlp-full-2018-02-27目录中，启动服务器：
java -mx4g -cp "*" edu.stanford.nlp.pipeline.StanfordCoreNLPServer \
-preload tokenize,ssplit,pos,lemma,ner,parse,depparse \
-status_port 9000 -port 9000 -timeout 15000 &
然后在 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')]
中国人
启动服务器略有不同，仍然从 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
在 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', ['。'])])])]
阿拉伯
启动服务器：
java -Xmx4g -cp "*" edu.stanford.nlp.pipeline.StanfordCoreNLPServer \
-serverProperties StanfordCoreNLP-arabic.properties \
-preload tokenize,ssplit,pos,parse \
-status_port 9005 -port 9005 -timeout 15000
在 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')]
法语
启动服务器：
java -Xmx4g -cp "*" edu.stanford.nlp.pipeline.StanfordCoreNLPServer \
-serverProperties StanfordCoreNLP-french.properties \
-preload tokenize,ssplit,pos,parse \
-status_port 9004 -port 9004 -timeout 15000
在 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')]
德语
启动服务器：
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
在 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')]
西班牙语
启动服务器：
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
在 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')]
于 2018-08-23T08:39:16.087 回答
23
已弃用的答案
以下答案已弃用，请使用https://stackoverflow.com/a/51981566/610569上的解决方案，用于 NLTK v3.3 及更高版本。
已编辑
从当前的斯坦福解析器 (2015-04-20) 开始， 的默认输出lexparser.sh已更改，因此下面的脚本将不起作用。
但是这个答案是为了遗留的缘故而保留的，它仍然可以与http://nlp.stanford.edu/software/stanford-parser-2012-11-12.zip一起使用。
原始答案
我建议你不要乱用 Jython，JPype。让python做python的东西，让java做java的东西，通过控制台得到Stanford Parser的输出。
在你的主目录中安装了Stanford Parser~/之后，只需使用这个 python 配方来获取平括号解析：
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
于 2013-01-17T09:58:37.843 回答
7
斯坦福解析器有python接口
于 2012-12-18T18:16:21.007 回答
7
斯坦福核心 NLP 软件页面有一个 python 包装器列表：
于 2013-08-21T19:28:10.540 回答
6
请注意，此答案适用于 NLTK v 3.0，而不适用于更新的版本。
这是对danger98的代码的改编，适用于windoze上的nltk3.0.0，并且可能还有其他平台，根据您的设置调整目录名称：
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
请注意，解析命令已更改（请参阅 www.nltk.org/_modules/nltk/parse/stanford.html 上的源代码），并且您需要定义 JAVAHOME 变量。我试图让它在 jar 中原位读取语法文件，但到目前为止还没有做到这一点。
于 2014-09-11T02:54:54.243 回答
6
如果我没记错的话，斯坦福解析器是一个 Java 库，因此您的服务器/计算机上必须运行 Java 解释器。
我曾经在服务器上使用过它，并结合了一个 php 脚本。该脚本使用 php 的 exec() 函数对解析器进行命令行调用，如下所示：
<?php
exec( "java -cp /pathTo/stanford-parser.jar -mx100m edu.stanford.nlp.process.DocumentPreprocessor /pathTo/fileToParse > /pathTo/resultFile 2>/dev/null" );
?>
我不记得这个命令的所有细节，它基本上打开了fileToParse，解析它，并将输出写入resultFile。然后 PHP 将打开结果文件以供进一步使用。
命令的结尾将解析器的详细信息设置为 NULL，以防止不必要的命令行信息干扰脚本。
我对 Python 不太了解，但可能有一种方法可以进行命令行调用。
这可能不是您希望的确切路线，但希望它能给您一些启发。祝你好运。
于 2012-12-14T17:25:37.610 回答
4
您可以使用 Stanford Parsers 输出在 nltk (nltk.tree.Tree) 中创建树。
假设 stanford 解析器为您提供了一个文件，其中每个句子都有一个解析树。然后这个例子可以工作，虽然它可能看起来不是很pythonic：
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)
于 2013-08-01T16:11:06.027 回答
4
请注意，此答案适用于 NLTK v 3.0，而不适用于更新的版本。
由于没有人真正提及并且不知何故让我很困扰，这是在 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)
这样，您就不必再担心路径的事情了。
对于那些不能在 Ubuntu 上正确使用它或在 Eclipse 中运行代码的人。
于 2016-04-08T16:41:39.210 回答
3
我在 Windows 机器上，您可以像从命令一样正常运行解析器，但在不同的目录中，因此您不需要编辑 lexparser.bat 文件。只需输入完整路径即可。
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()
对我来说，棘手的部分是实现如何从不同的路径运行 java 程序。必须有更好的方法，但这有效。
于 2015-03-06T16:30:57.210 回答
3
请注意，此答案适用于 NLTK v 3.0，而不适用于更新的版本。
这是阿尔瓦斯答案的Windows版本
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)
笔记：
在
lexparser.bat您需要将所有路径更改为绝对路径以避免java错误，例如“找不到类”我强烈建议您在 windows 下应用此方法，因为我在页面上尝试了几个答案，并且所有方法将 python 与 Java 通信都失败了。
如果您在 Windows 上取得成功，希望收到您的来信，并希望您能告诉我您是如何克服所有这些问题的。
在 python 包装器中搜索 stanford coreNLP 以获取 python 版本
于 2014-12-11T03:46:27.080 回答
3
请注意，此答案适用于 NLTK v 3.0，而不适用于更新的版本。
关于在 NLTK 和 Python 中使用 Stanford Parser 的危险89 的全面答案的轻微更新（或简单的替代）
使用 stanford-parser-full-2015-04-20、JRE 1.8 和 nltk 3.0.4 (python 2.7.6)，您似乎不再需要从 stanford-parser-xxx-models 中提取 englishPCFG.ser.gz .jar 或设置任何 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()
于 2015-08-28T10:31:03.000 回答
2
请注意，此答案适用于 NLTK v 3.0，而不适用于更新的版本。
由于声誉问题，我不能将此作为评论，但由于我花了（浪费？）一些时间来解决这个问题，我宁愿分享我的问题/解决方案，让这个解析器在 NLTK 中工作。
在alvas的出色 回答中，提到：
例如对于解析器，不会有模型目录。
这导致我错误地：
- 不小心我投入的价值
STANFORD_MODELS（只关心我的CLASSPATH） - 保留
../path/tostanford-parser-full-2015-2012-09/models directory* 几乎为空*（或使用名称与 nltk 正则表达式不匹配的 jar 文件）！
如果像我一样的 OP 只是想使用解析器，那么当不下载其他任何东西（没有 POSTagger、没有 NER，...）并按照所有这些说明进行操作时，我们仍然会遇到错误，这可能会令人困惑。
最终，对于任何CLASSPATH给定的（遵循该线程答案中的示例和解释），我仍然会收到错误消息：
NLTK 无法找到 stanford-parser-(\d+)(.(\d+))+-models.jar！设置 CLASSPATH 环境变量。有关更多信息，请参阅 stanford-parser-(\d+)(.(\d+))+-models.jar，
见： http: //nlp.stanford.edu/software/lex-parser.shtml
或者：
NLTK 无法找到 stanford-parser.jar！设置 CLASSPATH 环境变量。有关 stanford-parser.jar 的更多信息，请参阅： http: //nlp.stanford.edu/software/lex-parser.shtml
不过，重要的是，如果我调用函数并完全指定所有参数和路径，我可以正确加载和使用解析器，如下所示：
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)
单独解析器的解决方案：
因此，错误来自NLTK以及它是如何使用提供的STANFORD_MODELS和CLASSPATH环境变量来查找 jar 的。为了解决这个问题*-models.jar，具有正确格式（以匹配NLTK代码中的正则表达式，因此没有 -corenlp-....jar）的 , 必须位于由STANFORD_MODELS.
即，我首先创建了：
mkdir stanford-parser-full-2015-12-09/models
然后添加.bashrc：
export STANFORD_MODELS=/path/to/stanford-parser-full-2015-12-09/models
最后，通过复制stanford-parser-3.6.0-models.jar（或相应版本）到：
path/to/stanford-parser-full-2015-12-09/models/
我可以StanfordParser使用CLASSPATH指向stanford-parser.jar. 实际上，您可以StanfordParser不带参数调用，默认值就可以了。
于 2016-10-18T00:45:28.537 回答
2
已弃用的答案
以下答案已弃用，请使用https://stackoverflow.com/a/51981566/610569上的解决方案，用于 NLTK v3.3 及更高版本。
已编辑
注意：以下答案仅适用于：
- NLTK 版本 ==3.2.5
- 斯坦福工具自 2016-10-31 编译
- Python 2.7、3.5 和 3.6
由于这两种工具的变化都很快，而且 API 可能在 3-6 个月后看起来非常不同。请将以下答案视为暂时的，而不是永恒的解决方案。
有关如何使用 NLTK 连接斯坦福 NLP 工具的最新说明，请始终参考https://github.com/nltk/nltk/wiki/Installing-Third-Party-Software ！
TL;博士
以下代码来自https://github.com/nltk/nltk/pull/1735#issuecomment-306091826
在终端：
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
在 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
有关斯坦福 API 的更多信息，请查看http://www.nltk.org/_modules/nltk/parse/corenlp.html 。看看文档字符串！
于 2018-03-18T08:21:13.900 回答
2
我花了好几个小时终于为 Windows 用户找到了一个简单的解决方案。基本上它是 alvas现有答案的总结版本，但对于那些刚接触斯坦福 NLP 并且是 Window 用户的人来说，它很容易理解（希望如此）。
1）下载你想使用的模块，比如NER，POS等。在我的例子中，我想使用NER，所以我从http://nlp.stanford.edu/software/stanford-ner-2015-下载了模块04-20.zip
2）解压文件。
3)从解压后的文件夹中设置环境变量（classpath 和 stanford_modules）。
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)设置 JAVA 的环境变量，就像安装 JAVA 的地方一样。对我来说它在下面
os.environ['JAVAHOME'] = "C:/Program Files/Java/jdk1.8.0_102/bin/java.exe"
5）导入你想要的模块
from nltk.tag import StanfordNERTagger
6）调用解压缩文件夹中分类器文件夹中存在的预训练模型。最后添加“.gz”作为文件扩展名。对我来说，我想使用的模型是english.all.3class.distsim.crf.ser
st = StanfordNERTagger('english.all.3class.distsim.crf.ser.gz')
7)现在执行解析器！！我们完成了！
st.tag('Rami Eid is studying at Stony Brook University in NY'.split())
于 2016-12-16T09:20:48.473 回答
2
我正在使用 nltk 版本 3.2.4。以下代码对我有用。
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)
输出：
[('Open', 'VB'), ('app', 'NN'), ('and', 'CC'), ('play', 'VB'), ('movie', 'NN')]
于 2017-09-14T09:39:55.697 回答
1
基于神经模型的斯坦福解析器的新开发，使用 Tensorflow 训练，最近可用作 python API。这个模型应该比基于 Java 的模型要准确得多。您当然可以与 NLTK 管道集成。
链接到解析器。Ther 存储库包含 53 种语言的预训练解析器模型。
于 2019-09-03T08:04:07.300 回答