是否可以在NLTK中使用Stanford Parser？ （我不是在谈论斯坦福POS。）
答案 0 :(得分：83)
请注意，此答案适用于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']）]）， 树（'，'，['，']），树（'NP'，[树（'PRP $'，['我''）），树（'NN'， ['name']）]），树（'VP'，[树（'VBZ'，['是']），树（'ADJP'，[树（'JJ'， ['Melroy']）]）]），树（'。'，['。']）]）]），树（'ROOT'，[树（'SBARQ'， [树（'WHNP'，[树（'WP'，['什么']）]），树（'SQ'，[树（'VBZ'， ['是']），树（'NP'，[树（'PRP $'，['你']），树（'NN'，['name']）]）]）， 树（'。'，['？']）]）]）]
注1： 在这个例子中，解析器和解析器都是model jars在同一个文件夹中。
注2：
注3： englishPCFG.ser.gz文件可以在 里面 models.jar文件中找到（/edu/stanford/nlp/models/lexparser/englishPCFG.ser.gz）。请使用come archive manager来“解压缩”models.jar文件。
注4： 确保您使用的是Java JRE（运行时环境） 1.8 ，也称为Oracle JDK 8.否则您将获得：不支持的major.minor版本52.0。
从https://github.com/nltk/nltk下载NLTK v3。并安装NLTK：
sudo python setup.py install
您可以使用NLTK下载程序使用Python获取Stanford Parser：
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.x.x-models.jar和stanford-parser.jar。
如上所示，您可以使用环境变量（STANFORD_PARSER＆amp; STANFORD_MODELS）指向此'jars'文件夹。我正在使用Linux，所以如果你使用Windows，请使用类似：C：// folder // jars。
使用档案管理器（7zip）打开stanford-parser-3.x.x-models.jar。
浏览jar文件;埃杜/斯坦福/ NLP /模型/ lexparser。再次，提取名为'englishPCFG.ser.gz'的文件。记住您提取此ser.gz文件的位置。
创建StanfordParser实例时，可以提供模型路径作为参数。这是模型的完整路径，在我们的案例中为/location/of/englishPCFG.ser.gz。
试试我的榜样！ （不要忘记更改jar路径并将模型路径更改为ser.gz位置）
答案 1 :(得分：76)
以下答案已弃用，请使用https://stackoverflow.com/a/51981566/610569上的解决方案获取NLTK v3.3及更高版本。
注意：以下答案仅适用于：
由于这两种工具变化相当快，并且API可能在3-6个月后看起来非常不同。请将以下答案视为时间而非永恒的解决方法。
有关如何使用NLTK连接Stanford NLP工具的最新说明，请务必参考https://github.com/nltk/nltk/wiki/Installing-Third-Party-Software
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'])])]
首先，必须注意 Stanford NLP工具是用Java编写的 而 NLTK是用Python编写的 即可。 NLTK连接工具的方式是通过命令行界面调用Java工具。
其次，自版本3.1以来，斯坦福NLP工具的NLTK API发生了很大变化。因此，建议您将NLTK软件包更新到v3.1。
第三，斯坦福NLP工具的NLTK API包含各个NLP工具，例如： Stanford POS tagger，Stanford NER Tagger，Stanford Parser。
对于POS和NER标记器，不会环绕Stanford Core NLP package。
对于斯坦福分析师来说，这是一个特殊的情况，包括斯坦福分析师和斯坦福核心NLP（个人而言，我没有使用后者使用NLTK，我宁愿关注@dimazest＆＃39; s http://www.eecs.qmul.ac.uk/~dm303/stanford-dependency-parser-nltk-and-anaconda.html）上的示范
请注意，自NLTK v3.1起，STANFORD_JAR和STANFORD_PARSER变量已弃用且不再使用
假设您已在操作系统上正确安装了Java。
现在，安装/更新您的NLTK版本（请参阅http://www.nltk.org/install.html）：
sudo pip install -U nltk sudo apt-get install python-nltk 对于Windows （使用32位二进制安装）：
（为什么不是64位？请参阅https://github.com/nltk/nltk/issues/1079）
然后出于偏执，重新检查python中的nltk版本：
from __future__ import print_function
import nltk
print(nltk.__version__)
或者在命令行上：
python3 -c "import nltk; print(nltk.__version__)"
确保您将3.1视为输出。
对于更多的偏执狂，请检查所有您最喜爱的Stanford 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以使用Stanford Tools）
现在您已经检查过您是否拥有包含必要的Stanford NLP工具界面的正确版本的NLTK。您需要下载并提取所有必要的Stanford 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中：
设置环境变量，以便NLTK可以自动找到相关的文件路径。您必须设置以下变量：
将适当的Stanford NLP .jar文件添加到CLASSPATH环境变量中。
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和解析器模型jar文件stanford-parser-full-2015-04-20/stanford-parser-3.5.2-models.jar 将相应的模型目录添加到STANFORD_MODELS变量（即可以找到保存预训练模型的目录）
stanford-ner-2015-04-20/classifiers/ stanford-postagger-full-2015-04-20/models/ 在代码中，看到它在附加模型名称之前搜索STANFORD_MODELS目录。另请注意，API还会自动尝试在OS环境中搜索`CLASSPATH）
请注意，自NLTK v3.1起，STANFORD_JAR变量已弃用且不再使用。以下Stackoverflow问题中找到的代码段可能不起作用：
TL; Ubuntu上的STEP 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
（ For 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更改其参数名称时使用以下方法 BUT ，则无需设置环境变量，您需要进行相应更改。 这就是为什么设置环境变量比修改你的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)
答案 2 :(得分：22)
以下答案已弃用，请使用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
答案 3 :(得分：14)
从NLTK v3.3开始，用户应避免来自nltk.tag的Stanford NER或POS标记，以及避免 {{1 }}。
请使用新的nltk.tokenize API。
请参阅https://github.com/nltk/nltk/wiki/Stanford-CoreNLP-API-in-NLTK
（避免仅回答链接，我粘贴了以下NLTK github wiki中的文档）
首先，更新您的NLTK
nltk.parse.corenlp.CoreNLPParser然后下载必要的CoreNLP软件包：
pip3 install -U nltk # Make sure is >=3.3
仍然在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然后用Python：
java -mx4g -cp "*" edu.stanford.nlp.pipeline.StanfordCoreNLPServer \
-preload tokenize,ssplit,pos,lemma,ner,parse,depparse \
-status_port 9000 -port 9000 -timeout 15000 &
从stanford-corenlp-full-2018-02-27目录中启动服务器有所不同：
>>> 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')]
在Python中：
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
启动服务器：
>>> 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', ['。'])])])]
在Python中：
java -Xmx4g -cp "*" edu.stanford.nlp.pipeline.StanfordCoreNLPServer \
-serverProperties StanfordCoreNLP-arabic.properties \
-preload tokenize,ssplit,pos,parse \
-status_port 9005 -port 9005 -timeout 15000
启动服务器：
>>> 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')]
在Python中：
java -Xmx4g -cp "*" edu.stanford.nlp.pipeline.StanfordCoreNLPServer \
-serverProperties StanfordCoreNLP-french.properties \
-preload tokenize,ssplit,pos,parse \
-status_port 9004 -port 9004 -timeout 15000
启动服务器：
>>> 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')]
在Python中：
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
启动服务器：
>>> 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')]
在Python中：
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
答案 4 :(得分：7)
stanford解析器有python接口
答案 5 :(得分：7)
Stanford Core NLP软件页面有一个python包装器列表：
答案 6 :(得分：6)
请注意，此答案适用于NLTK v 3.0，而不适用于更新版本。
以下是对windoze中nltk3.0.0一起使用的danger98代码的改编，也可能是其他平台，根据您的设置调整目录名称：
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中原位读取语法文件，但到目前为止还没有做到。
答案 7 :(得分：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知之甚少，但可能有办法进行命令行调用。
这可能不是你希望的确切路线，但希望它会给你一些灵感。祝你好运。
答案 8 :(得分：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)
答案 9 :(得分：3)
请注意，此答案适用于NLTK v 3.0，而不适用于更新版本。
对危险89关于在NLTK和Python中使用Stanford Parser的全面答案的略微更新（或简单替代）
使用stanford-parser-full-2015-04-20，JRE 1.8和nltk 3.0.4（python 2.7.6），你似乎不再需要从stanford-parser中提取englishPCFG.ser.gz- xxx-models.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()
答案 10 :(得分：3)
请注意，此答案适用于NLTK v 3.0，而不适用于更新版本。
由于没有人真正提到它并且它在某种程度上困扰了我很多，这里是在python中使用Stanford解析器的另一种方法：
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中运行代码的人。
答案 11 :(得分：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程序。必须有一个更好的方法，但这是有效的。
答案 12 :(得分：3)
请注意，此答案适用于NLTK v 3.0，而不适用于更新版本。
以下是alvas回答的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下应用此方法，因为我在页面上尝试了几个答案，所有方法都与Java通信python失败。
希望听到您在Windows上取得成功并希望您能告诉我您是如何克服所有这些问题的。
搜索stanford coreNLP的python包装器以获取python版本
答案 13 :(得分：2)
请注意，此答案适用于NLTK v 3.0，而不适用于更新版本。
由于声誉，我不能把它留作评论，但是因为我花了一些时间来解决这个问题，所以我宁愿分享我的问题/解决方案来让这个解析器在NLTK中工作。
在优秀 answer from alvas中，提到：
e.g。对于Parser来说，它不会成为模型目录。
这导致我错误地：
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环境变量。有关更多信息，请参阅 斯坦福分析器 - （\ d +）+（（\ d +）。） - models.jar，
请参阅： http://nlp.stanford.edu/software/lex-parser.shtml
OR：
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）必须位于{{1}指定的文件夹中}}
即，我首先创建：
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在python中顺利加载CLASSPATH。实际上，你可以在没有参数的情况下调用stanford-parser.jar，默认情况下就可以了。
答案 14 :(得分：2)
我花了很多时间，最后为Windows用户找到了一个简单的解决方案。基本上它是alvas的existing answer的汇总版本，但对于那些刚接触stanford 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())
答案 15 :(得分：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')]
答案 16 :(得分：2)
以下答案已弃用，请使用https://stackoverflow.com/a/51981566/610569上的解决方案获取NLTK v3.3及更高版本。
注意：以下答案仅适用于：
由于这两种工具变化相当快，并且API可能在3-6个月后看起来非常不同。请将以下答案视为时间而非永恒的解决方法。
总是参考https://github.com/nltk/nltk/wiki/Installing-Third-Party-Software获取有关如何使用NLTK连接Stanford NLP工具的最新说明!!
以下代码来自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
有关Stanford API的更多信息，请查看http://www.nltk.org/_modules/nltk/parse/corenlp.html。看一下docstrings！
答案 17 :(得分：0)
基于神经模型的斯坦福解析器的新开发成果，使用Tensorflow进行了训练，最近可以用作python API。该模型应该比基于Java的moel更加准确。您当然可以与NLTK管道集成。
Link到解析器。该存储库包含针对53种语言的预训练解析器模型。