NLTK에서 Stanford Parser를 사용할 수 있습니까? (나는 스탠포드 POS에 대해 말하는 것이 아닙니다.)
NLTK에서 Stanford Parser를 사용할 수 있습니까? (나는 스탠포드 POS에 대해 말하는 것이 아닙니다.)
답변:
이 답변은 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 ( ',', [ ',']), Tree ( 'NP', [Tree ( 'PRP $', [ 'My']), Tree ( 'NN', [ 'name'])]), Tree ( 'VP', [Tree ( '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:
주 3 : englishPCFG.ser.gz 파일을 찾을 수 있습니다 내부 models.jar 파일 (/edu/stanford/nlp/models/lexparser/englishPCFG.ser.gz). 아카이브 관리자를 사용하여 models.jar 파일을 '압축 해제'하십시오.
참고 4 : Oracle JDK 8이라고도 하는 Java JRE (런타임 환경) 1.8을 사용하고 있는지 확인하십시오 . 그렇지 않으면 다음이 표시됩니다. Unsupported major.minor version 52.0.
https://github.com/nltk/nltk 에서 NLTK v3를 다운로드합니다 . 그리고 NLTK를 설치합니다.
sudo python setup.py 설치
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.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 위치로 변경하는 것을 잊지 마십시오)
nltk.parse.stanford
되었습니까? 나는 nltk.tag.stanford
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()
Tree 객체에서만 draw ()를 실행할 수 있습니다.)
NLTK official 3rd party tools
문서 의 지침을 따르는 것과 관련하여 여기의 모든 답변에 면책 조항을 추가하는 것이 가장 좋다고 생각했습니다 .
아래 답변은 더 이상 사용되지 않습니다 . NLTK v3.3 이상의 경우 https://stackoverflow.com/a/51981566/610569 의 솔루션을 사용하십시오 .
참고 : 다음 답변은 다음에서만 작동합니다.
두 도구 모두 빠르게 변경되고 3 ~ 6 개월 후에 API가 매우 다르게 보일 수 있습니다. 다음 답변을 영원한 수정이 아닌 일시적인 것으로 취급하십시오.
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 도구를 호출하는 것입니다.
둘째 , NLTK
Stanford NLP 도구에 대한 API는 버전 3.1 이후로 많이 변경되었습니다. 따라서 NLTK 패키지를 v3.1로 업데이트하는 것이 좋습니다.
셋째 , NLTK
Stanford NLP Tools에 대한 API는 Stanford POS tagger , Stanford NER Tagger , Stanford Parser 와 같은 개별 NLP 도구를 래핑합니다 .
POS 및 NER 태거의 경우 Stanford Core NLP 패키지를 감싸지 않습니다 .
Stanford Parser의 경우 Stanford Parser와 Stanford Core NLP를 모두 감싸는 특수한 경우입니다 (개인적으로 NLTK를 사용하여 후자를 사용하지 않았으므로 http : //www.eecs 에서 @dimazest의 데모를 따르 겠습니다. qmul.ac.uk/~dm303/stanford-dependency-parser-nltk-and-anaconda.html )
NLTK v3.1부터 STANFORD_JAR
및 STANFORD_PARSER
변수는 더 이상 사용되지 않으며 더 이상 사용되지 않습니다.
OS에 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를 )
그런 다음 편집증에서 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 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는 자동으로 `CLASSPATH )에 대한 OS 환경 검색을 시도합니다.
NLTK v3.1부터는 STANFORD_JAR
변수가 더 이상 사용되지 않으며 더 이상 사용되지 않습니다 . 다음 Stackoverflow 질문에있는 코드 조각이 작동하지 않을 수 있습니다.
Ubuntu의 STEP 3에 대한 TL; 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 참조 )
당신은 해야 다음, 파이썬을 시작하기 전에 위와 같이 변수를 설정 :
>>> 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가 매개 변수 이름을 변경할 때 그에 따라 변경해야합니다. 그렇기 때문에 NLTK 버전에 맞게 Python 코드를 수정하는 것보다 환경 변수를 설정하는 것이 더 좋습니다.
예를 들어 ( 환경 변수를 설정하지 않고 ) :
# 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)
아래 답변은 더 이상 사용되지 않습니다 . NLTK v3.3 이상의 경우 https://stackoverflow.com/a/51981566/610569 의 솔루션을 사용하십시오 .
현재 Stanford 파서 (2015-04-20)부터의 기본 출력 lexparser.sh
이 변경되어 아래 스크립트가 작동하지 않습니다.
그러나이 답변은 레거시를 위해 유지 되지만 http://nlp.stanford.edu/software/stanford-parser-2012-11-12.zip 에서는 여전히 작동 합니다.
나는 당신이 Jython, JPype를 엉망으로 만들지 말 것을 제안합니다. 파이썬은 파이썬 작업을하고 자바는 자바 작업을하게하고 콘솔을 통해 스탠포드 파서 출력을 얻습니다.
홈 디렉토리에 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
len(i.strip()) > 0
색인 오류가 발생했는지 확인하기 위해 조건을 추가해야한다는 점을 제외하고는 나를 위해 일했습니다 . 내 파서 출력에 순전히 공백이었던 줄이 하나 이상 있다고 생각합니다.
NLTK의 V3.3로, 사용자는해야 하지 않도록 에서 스탠포드 NER 또는 POS 태거를 nltk.tag
하고, 피 에서 스탠포드 토크 나이 / 분할기를 nltk.tokenize
.
대신 새 nltk.parse.corenlp.CoreNLPParser
API를 사용하십시오 .
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')]
list(parser.raw_parse(text))
또는 list(parser.parse(parser.tokenize(text))
. 예 수정;)
스탠포드 파서 용 파이썬 인터페이스가 있습니다.
Stanford Core NLP 소프트웨어 페이지에는 Python 래퍼 목록이 있습니다.
내가 잘 기억한다면 Stanford 파서는 자바 라이브러리이므로 서버 / 컴퓨터에서 자바 인터프리터를 실행해야합니다.
한 번 서버로 사용하고 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에 대해 잘 모르지만 명령 줄 호출을 수행하는 방법이있을 수 있습니다.
당신이 원했던 정확한 경로가 아닐 수도 있지만, 그것이 당신에게 영감을 줄 수 있기를 바랍니다. 행운을 빕니다.
이 답변은 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 변수를 정의해야합니다. 항아리에있는 문법 파일을 in situ로 읽으려고했지만 지금까지 그렇게하지 못했습니다.
Stanford Parsers 출력을 사용하여 nltk (nltk.tree.Tree)에 트리를 생성 할 수 있습니다.
스탠포드 구문 분석기가 모든 문장에 대해 정확히 하나의 구문 분석 트리가있는 파일을 제공한다고 가정합니다. 그런 다음이 예제는 작동하지만 매우 비단뱀처럼 보일 수 있습니다.
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)
이 답변은 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에서 코드를 실행할 수없는 사람들을 위해.
저는 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()
저에게 까다로운 부분은 다른 경로에서 자바 프로그램을 실행하는 방법을 깨닫는 것이 었습니다. 더 나은 방법이 있어야하지만 이것은 작동합니다.
이 답변은 NLTK v 3.0에 적용되며 최신 버전에는 적용되지 않습니다.
NLTK 및 Python에서 Stanford Parser 사용에 대한 danger89의 포괄적 인 답변에 대한 약간의 업데이트 (또는 단순히 대안)
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()
이 답변은 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 에서이 방법을 적용하는 것이 좋습니다.
창문에서 성공하면 여러분의 의견을 듣고이 모든 문제를 어떻게 극복했는지 말 해주길 바랍니다.
파이썬 버전을 얻으려면 stanford coreNLP에 대한 파이썬 래퍼를 검색하십시오.
몇 시간이 걸렸고 마침내 Windows 사용자를위한 간단한 솔루션을 찾았습니다. 기본적으로 alvas 의 기존 답변 에 대한 요약 버전 이지만 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())
아래 답변은 더 이상 사용되지 않습니다 . NLTK v3.3 이상의 경우 https://stackoverflow.com/a/51981566/610569 의 솔루션을 사용하십시오 .
참고 : 다음 답변은 다음에서만 작동합니다.
두 도구 모두 빠르게 변경되고 3 ~ 6 개월 후에 API가 매우 다르게 보일 수 있습니다. 다음 답변을 영원한 수정이 아닌 일시적인 것으로 취급하십시오.
NLTK를 사용하여 Stanford NLP 도구를 인터페이스하는 방법에 대한 최신 지침은 항상 https://github.com/nltk/nltk/wiki/Installing-Third-Party-Software 를 참조하십시오 !!
다음 코드는 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 을 참조하십시오. 독 스트링을보세요!
이 답변은 NLTK v 3.0에 적용되며 최신 버전에는 적용되지 않습니다.
나는 평판 때문에 이것을 코멘트로 남길 수는 없지만, 이것을 해결하는데 어느 정도 시간을 보냈기 때문에 나는이 파서를 NLTK에서 작동하도록 내 문제 / 솔루션을 공유하고 싶습니다.
alvas 의 훌륭한 답변에서 다음 과 같이 언급됩니다.
예를 들어 파서의 경우 모델 디렉토리가 없습니다.
이것은 나를 잘못 이끌었습니다.
STANFORD_MODELS
(내 걱정 만 CLASSPATH
)../path/tostanford-parser-full-2015-2012-09/models directory
* 사실상 비워 두십시오 * (또는 이름이 nltk regex와 일치하지 않는 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
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')]