क्या एनएलटीके में स्टैनफोर्ड पार्सर का उपयोग करना संभव है? (मैं स्टैनफोर्ड पीओएस के बारे में बात नहीं कर रहा हूं।)
क्या एनएलटीके में स्टैनफोर्ड पार्सर का उपयोग करना संभव है? (मैं स्टैनफोर्ड पीओएस के बारे में बात नहीं कर रहा हूं।)
जवाबों:
ध्यान दें कि यह उत्तर NLTK v 3.0 पर लागू होता है, न कि हाल के संस्करणों के लिए।
ज़रूर, पायथन में निम्नलिखित प्रयास करें:
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()
आउटपुट:
[ट्री ('रूट', [ट्री ('एस'), [ट्री ('INTJ', [ट्री ('UH', ['हैलो']]), ट्री (',', [',']), ट्री ('एनपी', [ट्री ('पीआरपी $', ['माय']), ट्री ('एनएन', ['नाम']]), ट्री ('वीपी', [ट्री ('वीबीजेड),] ']']), ट्री ('ADJP', [ट्री ('JJ', ['Melroy']])])), ट्री ('।', ['']])])), Tree (' ROOT ', [ट्री (' SBARQ ', [ट्री (' WHNP ', [ट्री (' WP ', [' What '])), ट्री (' SQ ', [ट्री (' VBZ '),' '' ') ]), ट्री ('एनपी', [ट्री ('पीआरपी $', ['अपना']), ट्री ('एनएन', ['नाम'])])), ट्री ('।', [']? '])])])]
नोट 1: इस उदाहरण में पार्सर और मॉडल जार दोनों एक ही फ़ोल्डर में हैं।
नोट 2:
नोट 3: englishPCFG.ser.gz फ़ाइल को model.jar फ़ाइल (/edu/stanford/nlp/models/lexparser/englishPCFG.ser.gz) के अंदर पाया जा सकता है । कृपया मॉडल, .जर फ़ाइल को 'अनज़िप' करने के लिए संग्रह प्रबंधक का उपयोग करें।
नोट 4: सुनिश्चित करें कि आप जावा JRE (रनटाइम एनवायरनमेंट) 1.8 का उपयोग कर रहे हैं, जिसे Oracle JDK 8. के रूप में भी जाना जाता है। अन्यथा आपको यह मिलेगा: असमर्थित प्रमुख.नंबर संस्करण 52.0।
: से डाउनलोड करें NLTK v3 https://github.com/nltk/nltk । और एनएलटीके स्थापित करें:
sudo python setup.py इंस्टॉल
आप स्टैनफोर्ड पार्सर पाने के लिए NLTK डाउनलोडर का उपयोग कर सकते हैं, पायथन का उपयोग कर:
import nltk
nltk.download()
मेरे उदाहरण की कोशिश करो! (जार रास्तों को बदलना न भूलें और मॉडल पथ को ser.gz स्थान पर बदलें)
या:
एनएलटीके v3 को डाउनलोड और इंस्टॉल करें, ऊपर के समान।
नवीनतम संस्करण डाउनलोड करें ( वर्तमान संस्करण फ़ाइल नाम stanford-parser-full-2015-01-29.zip है): http://nlp.stanford.edu/software/lex-parser.shtml#Download
स्टैंडफ़ोर्ड-parser-full-20xx-xx-xx.zip निकालें।
एक नया फ़ोल्डर बनाएं (मेरे उदाहरण में 'जार')। इस जार फ़ोल्डर में निकाले गए फ़ाइलों को रखें: stanford-parser-3.xx-model.jar और stanford-parser.jar।
जैसा कि ऊपर दिखाया गया है कि आप इस 'जार्स' फोल्डर को इंगित करने के लिए पर्यावरण चर (STANFORD_PARSER और STANFORD_MODELS) का उपयोग कर सकते हैं। मैं लिनक्स का उपयोग कर रहा हूं, इसलिए यदि आप विंडोज का उपयोग करते हैं तो कृपया कुछ का उपयोग करें जैसे: सी: // फ़ोल्डर // जार।
पुरालेख प्रबंधक (7zip) का उपयोग करके स्टैनफोर्ड-पार्सर-3.xx-model.jar खोलें।
जार फ़ाइल के अंदर ब्राउज़ करें; edu / स्टैनफोर्ड / NLP / मॉडल / lexparser। फिर से, 'englishPCFG.ser.gz' नामक फाइल निकालें। उस स्थान को याद रखें जहाँ आप इस ser.gz फ़ाइल को निकालते हैं।
स्टैनफोर्डप्रैसर उदाहरण बनाते समय, आप मॉडल पथ को पैरामीटर के रूप में प्रदान कर सकते हैं। यह हमारे मामले में /location/of/englishPCFG.ser.gz मॉडल का पूर्ण पथ है।
मेरे उदाहरण की कोशिश करो! (जार रास्तों को बदलना न भूलें और मॉडल पथ को ser.gz स्थान पर बदलें)
nltk.parse.stanford
? मेरे पास केवल nltk.tag.stanford
एनएलटीके में है 2.0.4
।
AttributeError: 'StanfordParser' object has no attribute 'raw_batch_parse'
for line in sentences: for sentence in line: sentence.draw()
;) आप केवल निष्पादित () आकर्षित कर सकते हैं एक पेड़ वस्तु पर
NLTK official 3rd party tools
दस्तावेज़ीकरण से निर्देशों का पालन करने के संबंध में यहां सभी उत्तरों में अस्वीकरण जोड़ना सबसे अच्छा है ।
नीचे दिए गए उत्तर को हटा दिया गया है, कृपया एनएलटीके v3.3 और इसके बाद के संस्करण के लिए https://stackoverflow.com/a/51981566/610569 पर समाधान का उपयोग करें ।
नोट: निम्नलिखित उत्तर केवल इस पर काम करेगा:
चूंकि दोनों उपकरण जल्दी-जल्दी बदलते हैं और एपीआई 3-6 महीने बाद बहुत अलग दिख सकते हैं। कृपया निम्नलिखित उत्तर को लौकिक मानें न कि एक शाश्वत निर्धारण।
हमेशा एनटीटीके का उपयोग करके स्टैनफोर्ड एनएलपी टूल को इंटरफ़ेस करने के लिए नवीनतम निर्देश के लिए 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'])])]
सबसे पहले , एक को ध्यान में रखना चाहिए कि स्टैनफोर्ड एनएलपी उपकरण जावा में लिखे गए हैं और एनएलटीके पायथन में लिखा गया है । जिस तरह से NLTK टूल को इंटरलेस कर रहा है वह कॉल जावा टूल कमांड लाइन इंटरफेस के माध्यम से है।
दूसरे , NLTK
3.1 संस्करण के बाद से स्टैनफोर्ड एनएलपी टूल्स के लिए एपीआई काफी बदल गया है। इसलिए अपने NLTK पैकेज को v3.1 में अपडेट करना उचित है।
तीसरा , NLTK
स्टैनफोर्ड एनएलपी टूल्स के लिए एपीआई अलग-अलग एनएलपी टूल्स, जैसे स्टैनफोर्ड पीओएस टैगर , स्टैनफोर्ड एनईआर टैगर , स्टैनफोर्ड पार्सर के चारों ओर घूमता है ।
पीओएस और एनईआर टैगर के लिए, यह स्टैनफोर्ड कोर एनएलपी पैकेज के आसपास नहीं लपेटता है ।
स्टैनफोर्ड पार्सर के लिए, यह एक विशेष मामला है जहां यह स्टैनफोर्ड पार्सर और स्टैनफोर्ड कोर एनएलपी दोनों के आसपास लपेटता है (व्यक्तिगत रूप से, मैंने एनएलटीके का उपयोग करके उत्तरार्द्ध का उपयोग नहीं किया है, मैं http: //www.eecs पर @ dimazest के प्रदर्शन का पालन करूंगा)। qmul.ac.uk/~dm303/stanford-d dependency-parser-nltk-and-anandonda.html )
ध्यान दें कि NLTK v3.1 के रूप में, STANFORD_JAR
और STANFORD_PARSER
चर को पदावनत किया जाता है और NO LONGER का उपयोग नहीं किया जाता है
यह मानते हुए कि आपने जावा को अपने ओएस पर उचित रूप से स्थापित किया है।
अब, अपने NLTK संस्करण को स्थापित / अपडेट करें (देखें http://www.nltk.org/install.html ):
sudo pip install -U nltk
sudo apt-get install python-nltk
विंडोज के लिए (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
आउटपुट के रूप में देखते हैं ।
और भी व्यामोह के लिए, जांचें कि आपके सभी पसंदीदा स्टैनफोर्ड एनएलपी उपकरण एपीआई उपलब्ध हैं:
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
( नोट : उपरोक्त आयात केवल यह सुनिश्चित करेगा कि आप एक सही एनएलटीके संस्करण का उपयोग कर रहे हैं जिसमें ये एपीआई शामिल हैं। आयात में त्रुटियों को देखने का मतलब यह नहीं है कि आपने स्टैनफोर्ड टूल्स का उपयोग करने के लिए एनएलटीके एपीआई को सफलतापूर्वक कॉन्फ़िगर किया है)
अब जब आपने जाँच लिया है कि आपके पास एनएलटीके का सही संस्करण है जिसमें स्टैनफोर्ड एनएलपी टूल इंटरफ़ेस आवश्यक है। आपको सभी आवश्यक स्टैनफोर्ड एनएलपी उपकरण डाउनलोड करने और निकालने की आवश्यकता है।
यूएल में टीएल; डीआर :
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
विंडोज / मैक में:
पर्यावरण चर को ऐसे सेट करें कि NLTK प्रासंगिक फ़ाइल पथ को स्वचालित रूप से पा सके। आपको निम्नलिखित चर सेट करने होंगे:
पर्यावरण चर के .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
और पार्सर मॉडल जार फ़ाइल,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
मॉडल नाम को लागू करने से पहले निर्देशिका के लिए खोज करता है । इसके अलावा कि देखते हैं, एपीआई भी स्वतः के लिए ओएस वातावरण खोजने का प्रयास करता `CLASSPATH )
ध्यान दें कि NLTK v3.1 के रूप में, STANFORD_JAR
चर को हटा दिया जाता है और NO LONGER का उपयोग किया जाता है । निम्नलिखित Stackoverflow प्रश्नों में पाए गए कोड स्निपेट काम नहीं कर सकते हैं:
उबंटू पर 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
( विंडोज के लिए : पर्यावरण चर सेट करने के निर्देशों के लिए 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'])])])])])])]
वैकल्पिक रूप से, आप अजगर के अंदर के पर्यावरण चर को जोड़ने का प्रयास कर सकते हैं, जैसा कि पिछले उत्तरों ने सुझाया है, लेकिन आप सीधे पार्सर / टैगर को सीधे उस पथ पर आरम्भ करने के लिए भी कह सकते हैं जहाँ आपने .jar
फ़ाइल और अपने मॉडल रखे थे ।
पर्यावरण चर सेट करने की कोई आवश्यकता नहीं है यदि आप निम्न विधि का उपयोग करते हैं लेकिन जब एपीआई अपने पैरामीटर नामों को बदलता है, तो आपको तदनुसार बदलना होगा। यही कारण है कि एनएलटीके संस्करण के अनुरूप अपने अजगर कोड को संशोधित करने की तुलना में पर्यावरण चर को सेट करना अधिक उचित है।
उदाहरण के लिए ( किसी भी पर्यावरण चर को स्थापित किए बिना ):
# 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)
नीचे दिए गए उत्तर को हटा दिया गया है, कृपया एनएलटीके v3.3 और इसके बाद के संस्करण के लिए https://stackoverflow.com/a/51981566/610569 पर समाधान का उपयोग करें ।
वर्तमान स्टैनफोर्ड पार्सर (2015-04-20) के रूप में, डिफ़ॉल्ट के लिए आउटपुट lexparser.sh
बदल गया है इसलिए नीचे दी गई स्क्रिप्ट काम नहीं करेगी।
लेकिन यह जवाब विरासत की खातिर रखा गया है, यह अभी भी http://nlp.stanford.edu/software/stanford-parser-2012-11-12.zip के साथ काम करेगा ।
मेरा सुझाव है कि आप Jython, JPype के साथ गड़बड़ न करें। अजगर को अजगर सामान करते हैं और जावा को जावा सामान करते हैं, कंसोल के माध्यम से स्टैनफोर्ड पार्सर आउटपुट प्राप्त करते हैं।
अपने घर निर्देशिका में स्टैनफोर्ड पार्सर को स्थापित करने के बाद ~/
, फ्लैट ब्रैकेट पार्स पाने के लिए बस इस अजगर नुस्खा का उपयोग करें:
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
अन्यथा मुझे एक त्रुटि मिली। मुझे लगता है कि मेरे पार्सर उत्पादन में कम से कम एक लाइन थी जो विशुद्ध रूप से व्हाट्सएप थी।
'
s है, तो आपको कुछ अजीब त्रुटियाँ मिलेंगी। वहाँ बेहतर तरीके हैं कमांड लाइन पर बातें कॉल करने के लिए
NLTK v3.3 के रूप में, उन चाहिए से बचने से स्टैनफोर्ड एनईआर या पीओएस टैगकर्ताओं nltk.tag
, और से बचने के स्टैनफोर्ड tokenizer / से segmenter nltk.tokenize
।
इसके बजाय नए nltk.parse.corenlp.CoreNLPParser
एपीआई का उपयोग करें ।
कृपया https://github.com/nltk/nltk/wiki/Stanford-CoreNLP-API-in-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 &
फिर पायथन में:
>>> 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
पायथन में:
>>> 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
पायथन में:
>>> 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
पायथन में:
>>> 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
पायथन में:
>>> 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
पायथन में:
>>> 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))
। उदाहरण को सही किया;)
स्टेनफोर्ड पार्सर के लिए अजगर इंटरफ़ेस है
स्टैनफोर्ड कोर एनएलपी सॉफ्टवेयर पेज में अजगर रैपर की एक सूची है:
अगर मुझे अच्छी तरह से याद है, तो स्टैनफोर्ड पार्सर एक जावा लाइब्रेरी है, इसलिए आपके पास अपने सर्वर / कंप्यूटर पर जावा दुभाषिया होना चाहिए।
मैंने एक बार एक सर्वर का उपयोग किया, एक php स्क्रिप्ट के साथ संयुक्त। स्क्रिप्ट ने php के निष्पादन का उपयोग किया () फ़ंक्शन को पार्सर के लिए कमांड-लाइन कॉल करने के लिए इस तरह:
<?php
exec( "java -cp /pathTo/stanford-parser.jar -mx100m edu.stanford.nlp.process.DocumentPreprocessor /pathTo/fileToParse > /pathTo/resultFile 2>/dev/null" );
?>
मुझे इस कमांड के सभी विवरण याद नहीं हैं, इसने मूल रूप से fileToParse को खोला, इसे पार्स किया और परिणाम में आउटपुट लिखा। PHP फिर आगे के उपयोग के लिए परिणाम फ़ाइल को खोलेगा।
कमांड का अंत स्क्रिप्ट को परेशान करने से अनावश्यक कमांड लाइन की जानकारी को रोकने के लिए पार्सर की क्रिया को NULL को निर्देशित करता है।
मैं अजगर के बारे में ज्यादा नहीं जानता, लेकिन कमांड लाइन कॉल करने का एक तरीका हो सकता है।
यह सटीक मार्ग नहीं हो सकता है जिसकी आप उम्मीद कर रहे थे, लेकिन उम्मीद है कि यह आपको कुछ प्रेरणा देगा। शुभकामनाएँ।
ध्यान दें कि यह उत्तर NLTK v 3.0 पर लागू होता है, न कि हाल के संस्करणों के लिए।
यहां डेंजर 98 के कोड का एक अनुकूलन है जो पवनचक्की पर 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 पर स्रोत कोड देखें), और आपको जावा चर को परिभाषित करने की आवश्यकता है। मैंने इसे जार में सीटू में व्याकरण फ़ाइल पढ़ने के लिए प्राप्त करने की कोशिश की, लेकिन अभी तक ऐसा करने में विफल रहा है।
आप 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 पर लागू होता है, न कि हाल के संस्करणों के लिए।
चूंकि किसी ने वास्तव में उल्लेख नहीं किया है और यह किसी तरह से मुझे बहुत परेशान कर रहा है, यहाँ अजगर में स्टैनफोर्ड पार्सर का उपयोग करने का एक वैकल्पिक तरीका है:
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)
इस तरह से, आपको अब पथ के बारे में चिंता करने की आवश्यकता नहीं है।
उन लोगों के लिए जो इसे उबंटू पर ठीक से उपयोग नहीं कर सकते हैं या कोड को एक्लिप्स में चला सकते हैं।
मैं एक विंडोज़ मशीन पर हूँ और आप साधारण रूप से पार्सर को सामान्य रूप से चला सकते हैं जैसा कि आप कमांड से करते हैं, लेकिन एक अलग निर्देशिका में करते हैं ताकि आपको 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 और पायथन में स्टैनफोर्ड पार्सर के उपयोग पर खतरे के व्यापक उत्तर पर एक मामूली अपडेट (या बस वैकल्पिक)
Stanford-parser-2015-04-20, JRE 1.8 और nltk 3.0.4 (python 2.7.6) के साथ, यह प्रतीत होता है कि अब आपको stanford-parser-xxx-मॉडल से 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 के उत्तर का विंडोज़ संस्करण है
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
आप इस तरह के रूप बचने जावा त्रुटियों का निरपेक्ष पथ में सभी रास्तों को बदलने की जरूरत "वर्ग नहीं मिला"
मैं जोरदार तरीके से आपको इस विधि को खिड़कियों के नीचे लागू करने की सलाह देता हूं क्योंकि मैंने पृष्ठ पर कई उत्तरों की कोशिश की है और सभी विधियां जावा विफल होने के साथ अजगर का संचार करती हैं।
यदि आप खिड़कियों पर सफल होते हैं तो आप से सुनना चाहते हैं और आप मुझे बता सकते हैं कि आप इन सभी समस्याओं को कैसे दूर करते हैं।
अजगर संस्करण के लिए स्टेनफोर्ड कोरएनएलपी के लिए पायथन रैपर की खोज करें
मुझे कई घंटे लगे और अंत में विंडोज उपयोगकर्ताओं के लिए एक सरल समाधान मिला। मूल रूप से एक मौजूदा जवाब के अपने संक्षिप्त संस्करण अल्वाज़ द्वारा , लेकिन स्टैनफोर्ड एनएलपी के लिए नए और विंडो उपयोगकर्ता हैं, उन लोगों के लिए (उम्मीद) का पालन करना आसान बना दिया।
1) उस मॉड्यूल को डाउनलोड करें जिसका आप उपयोग करना चाहते हैं, जैसे NER, POS आदि। मेरे मामले में मैं NER का उपयोग करना चाहता था, इसलिए मैंने http://nlp.stanford.edu/software/stanford-ner-2015- से मॉड्यूल डाउनलोड किया 04-20.zip
2) फ़ाइल को अनज़िप करें।
3) अनजिप्ड फोल्डर से पर्यावरण चर (क्लासपैथ और स्टेनफोर्ड_मॉड्यूल्स ) सेट करें।
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) जेएवीए के लिए पर्यावरण चर निर्धारित करें, जैसे कि आपने जेएवीए स्थापित किया है। मेरे लिए यह नीचे था
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')
) अब पार्सर को निष्पादित करें !! और हम कर रहे हैं !!
st.tag('Rami Eid is studying at Stony Brook University in NY'.split())
नीचे दिए गए उत्तर को हटा दिया गया है, कृपया एनएलटीके v3.3 और इसके बाद के संस्करण के लिए https://stackoverflow.com/a/51981566/610569 पर समाधान का उपयोग करें ।
नोट: निम्नलिखित उत्तर केवल इस पर काम करेगा:
चूंकि दोनों उपकरण जल्दी-जल्दी बदलते हैं और एपीआई 3-6 महीने बाद बहुत अलग दिख सकते हैं। कृपया निम्नलिखित उत्तर को लौकिक मानें न कि एक शाश्वत निर्धारण।
हमेशा https://github.com/nltk/nltk/wiki/Installing-Third-Part-Software को देखेंएनटीटीके का उपयोग करके स्टैनफोर्ड एनएलपी टूल को इंटरफ़ेस करने के लिए नवीनतम निर्देश के !
फॉलो कोड आता है https://github.com/nltk/nltk/pull/1735#issuecomment-3060/1826
टर्मिनल में:
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
पायथन में:
>>> 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
स्टैनफोर्ड एपीआई पर अधिक जानकारी के लिए कृपया http://www.nltk.org/_modules/nltk/parse/corenlp.html पर एक नज़र डालें । डॉकस्ट्रिंग्स पर एक नज़र!
ध्यान दें कि यह उत्तर NLTK v 3.0 पर लागू होता है, न कि हाल के संस्करणों के लिए।
मैं इसे प्रतिष्ठा के कारण एक टिप्पणी के रूप में नहीं छोड़ सकता, लेकिन जब से मैंने इसे व्यर्थ किया है (व्यर्थ?) कुछ समय हल करने के बजाय मैं अपनी समस्या / समाधान को एनएलटीके में काम करने के लिए इस पार्सर को साझा करने के लिए साझा करूंगा।
में उत्कृष्ट alvas से जवाब है, यह है कि उल्लेख किया गया है:
उदाहरण के लिए, पार्सर के लिए, एक मॉडल निर्देशिका नहीं होगी।
यह मुझे गलत तरीके से ले गया:
STANFORD_MODELS
(और केवल मेरी परवाह है CLASSPATH
)../path/tostanford-parser-full-2015-2012-09/models directory
* लगभग खाली * (या एक जार फ़ाइल के साथ जिसका नाम nltk regex से मेल नहीं खाता)!यदि ओपी, मेरी तरह, बस पार्सर का उपयोग करना चाहता था, तो यह भ्रमित हो सकता है कि जब कुछ और नहीं डाउनलोड किया जाए (कोई पोसटैगर, नो एनईआर, ...) और इन सभी निर्देशों का पालन करते हुए, हमें अभी भी एक त्रुटि मिलती है।
आखिरकार, किसी के लिए भी CLASSPATH
दिए गए (इस थ्रेड से जवाब में उदाहरण और स्पष्टीकरण के बाद) मुझे अभी भी त्रुटि मिलेगी:
NLTK को स्टैनफोर्ड-पार्सर - (\ d +) (? (\ D +)) + - model.jar नहीं मिला! CLASSPATH पर्यावरण चर सेट करें। अधिक जानकारी के लिए, स्टैनफोर्ड-पार्सर पर - (\ d +) (((d + +)) + - मॉडल।
देख: http://nlp.stanford.edu/software/lex-parser.shtml
या:
NLTK को स्टैनफोर्ड-पार्सर.जर नहीं मिला! 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
पर्यावरण चर का उपयोग करके जार की तलाश कैसे की जाती है । इसे हल करने के लिए, *-models.jar
सही फ़ॉर्मेटिंग के साथ, ( NLTK
कोड में रेगेक्स से मिलान करने के लिए , इसलिए नो -कोरनल्प-इन जार) द्वारा निर्दिष्ट फ़ोल्डर में स्थित होना चाहिए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')]
एक तंत्रिका मॉडल पर आधारित स्टैनफोर्ड पार्सर का एक नया विकास, जिसे टेन्सरफ़्लो का उपयोग करके प्रशिक्षित किया गया है, हाल ही में अजगर एपीआई के रूप में उपयोग करने के लिए उपलब्ध कराया गया है। यह मॉडल जावा-आधारित moel से कहीं अधिक सटीक माना जाता है। आप निश्चित रूप से एक एनएलटीके पाइपलाइन के साथ एकीकृत कर सकते हैं।
पार्सर से लिंक करें । रिपॉजिटरी में 53 भाषाओं के लिए पूर्व-प्रशिक्षित पार्सर मॉडल हैं।