स्टैनफोर्ड पार्सर और एनएलटीके


90

क्या एनएलटीके में स्टैनफोर्ड पार्सर का उपयोग करना संभव है? (मैं स्टैनफोर्ड पीओएस के बारे में बात नहीं कर रहा हूं।)


6
इसे भी देखें: gist.github.com/alvations/e1df0ba227e542955a8a
alvas

3
इस लिंक को और अधिक दिखाई देने की आवश्यकता है। शायद इसका उल्लेख करने के लिए शीर्ष उत्तर को संपादित किया जाना चाहिए?
लालो सान्चेज़

1
बस एक साइड नोट यहाँ दोस्तों। सुनिश्चित करें कि आपका Java स्टैनफोर्ड NLP और JAVA_HOME के ​​लिए अद्यतित है, ठीक से सेट किया गया है। कभी-कभी लोगों को "अजीब" त्रुटियां हो सकती हैं जो इसके कारण हो सकती हैं।
मेंग झाओ

NLTK v3.3 के लिए, stackoverflow.com/a/51981566/610569
alvas

जवाबों:


89

ध्यान दें कि यह उत्तर 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।

स्थापना

  1. : से डाउनलोड करें NLTK v3 https://github.com/nltk/nltk । और एनएलटीके स्थापित करें:

    sudo python setup.py इंस्टॉल

  2. आप स्टैनफोर्ड पार्सर पाने के लिए NLTK डाउनलोडर का उपयोग कर सकते हैं, पायथन का उपयोग कर:

    import nltk
    nltk.download()
  3. मेरे उदाहरण की कोशिश करो! (जार रास्तों को बदलना न भूलें और मॉडल पथ को ser.gz स्थान पर बदलें)

या:

  1. एनएलटीके v3 को डाउनलोड और इंस्टॉल करें, ऊपर के समान।

  2. नवीनतम संस्करण डाउनलोड करें ( वर्तमान संस्करण फ़ाइल नाम stanford-parser-full-2015-01-29.zip है): http://nlp.stanford.edu/software/lex-parser.shtml#Download

  3. स्टैंडफ़ोर्ड-parser-full-20xx-xx-xx.zip निकालें।

  4. एक नया फ़ोल्डर बनाएं (मेरे उदाहरण में 'जार')। इस जार फ़ोल्डर में निकाले गए फ़ाइलों को रखें: stanford-parser-3.xx-model.jar और stanford-parser.jar।

    जैसा कि ऊपर दिखाया गया है कि आप इस 'जार्स' फोल्डर को इंगित करने के लिए पर्यावरण चर (STANFORD_PARSER और STANFORD_MODELS) का उपयोग कर सकते हैं। मैं लिनक्स का उपयोग कर रहा हूं, इसलिए यदि आप विंडोज का उपयोग करते हैं तो कृपया कुछ का उपयोग करें जैसे: सी: // फ़ोल्डर // जार।

  5. पुरालेख प्रबंधक (7zip) का उपयोग करके स्टैनफोर्ड-पार्सर-3.xx-model.jar खोलें।

  6. जार फ़ाइल के अंदर ब्राउज़ करें; edu / स्टैनफोर्ड / NLP / मॉडल / lexparser। फिर से, 'englishPCFG.ser.gz' नामक फाइल निकालें। उस स्थान को याद रखें जहाँ आप इस ser.gz फ़ाइल को निकालते हैं।

  7. स्टैनफोर्डप्रैसर उदाहरण बनाते समय, आप मॉडल पथ को पैरामीटर के रूप में प्रदान कर सकते हैं। यह हमारे मामले में /location/of/englishPCFG.ser.gz मॉडल का पूर्ण पथ है।

  8. मेरे उदाहरण की कोशिश करो! (जार रास्तों को बदलना न भूलें और मॉडल पथ को ser.gz स्थान पर बदलें)


1
Nltk के किस संस्करण को जोड़ा गया nltk.parse.stanford? मेरे पास केवल nltk.tag.stanfordएनएलटीके में है 2.0.4
एलेक्सिस

1
AttributeError: 'StanfordParser' object has no attribute 'raw_batch_parse'
निक रिटलैक

5
@alexis: nltk 3.0 को यहाँ से डाउनलोड करें @ रिकॉल: इसे बदला जाना चाहिएraw_parse_sents()
रसिका परेरा

1
ठीक है, आप सही हैं। NLTK फ़ंक्शन को इसमें बदलता है: raw_parse_sents ()। दस्तावेज़ीकरण देखें: nltk.org/_modules/nltk/parse/stanford.html यदि आप कच्चे_परसे () का उपयोग कर रहे हैं, तो आप रिटर्न मान के रूप में एक पुनरावृति (ट्री) प्राप्त करेंगे। मतलब ड्रा का उपरोक्त नमूना () काम करना चाहिए। यदि आप raw_parse_sents () का उपयोग कर रहे हैं, तो आपको स्पष्ट रूप से एक डबल लूप की आवश्यकता है; यह एक iter (iter (ट्री)) लौटा रहा है। कोड उदाहरण तो: for line in sentences: for sentence in line: sentence.draw() ;) आप केवल निष्पादित () आकर्षित कर सकते हैं एक पेड़ वस्तु पर
danger89

1
@ danger89, EDITED नोट के साथ आपके उत्तर को लिखने के लिए क्षमा करें। हाल ही में लोग स्टैनफोर्ड डिपेंडेंसी पार्सर के बारे में शिकायत करते रहे हैं कि हाल ही में NLTK v3.1 के बाद से जोड़ा गया है और मुझे लगता है कि वे यहां और वहां से निकले उत्तरों से कोड के कुछ स्निपेट की नकल कर रहे थे। इसलिए भ्रम को कम करने के लिए, मैंने सोचा कि NLTK official 3rd party toolsदस्तावेज़ीकरण से निर्देशों का पालन करने के संबंध में यहां सभी उत्तरों में अस्वीकरण जोड़ना सबसे अच्छा है ।
3

77

पदावनत उत्तर

नीचे दिए गए उत्तर को हटा दिया गया है, कृपया एनएलटीके v3.3 और इसके बाद के संस्करण के लिए https://stackoverflow.com/a/51981566/610569 पर समाधान का उपयोग करें ।


संपादित

नोट: निम्नलिखित उत्तर केवल इस पर काम करेगा:

  • एनएलटीके संस्करण> = 3.2.4
  • स्टैनफोर्ड टूल्स 2015-04-20 से संकलित किया गया
  • पायथन 2.7, 3.4 और 3.5 (पायथन 3.6 अभी तक आधिकारिक रूप से समर्थित नहीं है)

चूंकि दोनों उपकरण जल्दी-जल्दी बदलते हैं और एपीआई 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 टूल को इंटरलेस कर रहा है वह कॉल जावा टूल कमांड लाइन इंटरफेस के माध्यम से है।

दूसरे , NLTK3.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 का उपयोग नहीं किया जाता है


अब में:


चरण 1

यह मानते हुए कि आपने जावा को अपने ओएस पर उचित रूप से स्थापित किया है।

अब, अपने NLTK संस्करण को स्थापित / अपडेट करें (देखें http://www.nltk.org/install.html ):

  • पाइप का उपयोग करना :sudo pip install -U nltk
  • डेबियन डिस्ट्रो (उपयुक्त-का उपयोग करके):sudo apt-get install python-nltk

विंडोज के लिए (32-बिट बाइनरी इंस्टॉलेशन का उपयोग करें):

  1. पायथन 3.4 स्थापित करें: http://www.python.org/downloads/ (64-बिट संस्करणों से बचें)
  2. Numpy (वैकल्पिक) स्थापित करें: http://sourceforge.net/projects/numpy/files/NumPy/ (संस्करण जो pythnon3.4 को निर्दिष्ट करता है)
  3. एनएलटीके स्थापित करें: http://pypi.python.org/pypi/nltk
  4. परीक्षण स्थापना: प्रारंभ> Python34, फिर आयात टाइप करें nltk

( 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

( नोट : उपरोक्त आयात केवल यह सुनिश्चित करेगा कि आप एक सही एनएलटीके संस्करण का उपयोग कर रहे हैं जिसमें ये एपीआई शामिल हैं। आयात में त्रुटियों को देखने का मतलब यह नहीं है कि आपने स्टैनफोर्ड टूल्स का उपयोग करने के लिए एनएलटीके एपीआई को सफलतापूर्वक कॉन्फ़िगर किया है)


चरण 2

अब जब आपने जाँच लिया है कि आपके पास एनएलटीके का सही संस्करण है जिसमें स्टैनफोर्ड एनएलपी टूल इंटरफ़ेस आवश्यक है। आपको सभी आवश्यक स्टैनफोर्ड एनएलपी उपकरण डाउनलोड करने और निकालने की आवश्यकता है।

यूएल में टीएल; डीआर :

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

विंडोज / मैक में:


चरण 3

पर्यावरण चर को ऐसे सेट करें कि 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)

22

पदावनत उत्तर

नीचे दिए गए उत्तर को हटा दिया गया है, कृपया एनएलटीके 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

1
यह मेरे लिए काम करता है सिवाय इसके कि मुझे जाँच करने के लिए एक शर्त जोड़ने की आवश्यकता है len(i.strip()) > 0अन्यथा मुझे एक त्रुटि मिली। मुझे लगता है कि मेरे पार्सर उत्पादन में कम से कम एक लाइन थी जो विशुद्ध रूप से व्हाट्सएप थी।
aelfric5578

1
वैकल्पिक रूप से, स्टेनफोर्ड कॉर्नलप टूल्स, bitbucket.org/torotoki/corenlp-python के
alvas

3
इससे सावधान रहें। यदि आपके इनपुट में कोई भी 's है, तो आपको कुछ अजीब त्रुटियाँ मिलेंगी। वहाँ बेहतर तरीके हैं कमांड लाइन पर बातें कॉल करने के लिए
निक गर्वे

20

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))। उदाहरण को सही किया;)
अल्व्स १ed

1
विश्वास नहीं कर सकता यह अधिक विज्ञापित नहीं है !!
निमित्ज 14

1
दुःख की बात है NLTK पर्याप्त लोग भाषण देते या मेजबान अत्यधिक आकर्षित देव सम्मेलन के लिए संसाधनों के लिए बैठकों के आसपास जा रहा उपकरण को बढ़ावा देने की जरूरत नहीं है = (आप के आसपास इस सुविधा या समुदाय के लिए NLTK लागू करने के लिए स्वतंत्र महसूस।
alvas



6

अगर मुझे अच्छी तरह से याद है, तो स्टैनफोर्ड पार्सर एक जावा लाइब्रेरी है, इसलिए आपके पास अपने सर्वर / कंप्यूटर पर जावा दुभाषिया होना चाहिए।

मैंने एक बार एक सर्वर का उपयोग किया, एक 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 को निर्देशित करता है।

मैं अजगर के बारे में ज्यादा नहीं जानता, लेकिन कमांड लाइन कॉल करने का एक तरीका हो सकता है।

यह सटीक मार्ग नहीं हो सकता है जिसकी आप उम्मीद कर रहे थे, लेकिन उम्मीद है कि यह आपको कुछ प्रेरणा देगा। शुभकामनाएँ।


6

ध्यान दें कि यह उत्तर 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 पर स्रोत कोड देखें), और आपको जावा चर को परिभाषित करने की आवश्यकता है। मैंने इसे जार में सीटू में व्याकरण फ़ाइल पढ़ने के लिए प्राप्त करने की कोशिश की, लेकिन अभी तक ऐसा करने में विफल रहा है।


मैं १ ९, ९ से नहीं, बल्कि आपके उदाहरण के लिए धन्यवाद;)
खतरे

4

आप 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)

1
+1 करने के लिए जावा जावा सामान और अजगर अजगर सामग्री दे। आप जावा कमांड को कैसे कहते हैं और किन विकल्पों के आधार पर, स्टैनफोर्ड पार्सर से आउटपुट फाइल को पार्स करना अलग हो सकता है। यह अच्छा होगा यदि आप स्टैनफोर्ड पार्स को अपनी आउटपुट फ़ाइल प्राप्त करने के लिए कैसे कहते हैं, इस पर भी विवरण जोड़ते हैं।
अलवास

4

ध्यान दें कि यह उत्तर 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)

इस तरह से, आपको अब पथ के बारे में चिंता करने की आवश्यकता नहीं है।

उन लोगों के लिए जो इसे उबंटू पर ठीक से उपयोग नहीं कर सकते हैं या कोड को एक्लिप्स में चला सकते हैं।


3

मैं एक विंडोज़ मशीन पर हूँ और आप साधारण रूप से पार्सर को सामान्य रूप से चला सकते हैं जैसा कि आप कमांड से करते हैं, लेकिन एक अलग निर्देशिका में करते हैं ताकि आपको 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()

मेरे लिए मुश्किल हिस्सा एक अलग रास्ते से जावा प्रोग्राम चलाने का एहसास था। एक बेहतर तरीका होना चाहिए लेकिन यह काम करता है।


3

ध्यान दें कि यह उत्तर 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()

3

ध्यान दें कि यह उत्तर 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 आप इस तरह के रूप बचने जावा त्रुटियों का निरपेक्ष पथ में सभी रास्तों को बदलने की जरूरत "वर्ग नहीं मिला"

  • मैं जोरदार तरीके से आपको इस विधि को खिड़कियों के नीचे लागू करने की सलाह देता हूं क्योंकि मैंने पृष्ठ पर कई उत्तरों की कोशिश की है और सभी विधियां जावा विफल होने के साथ अजगर का संचार करती हैं।

  • यदि आप खिड़कियों पर सफल होते हैं तो आप से सुनना चाहते हैं और आप मुझे बता सकते हैं कि आप इन सभी समस्याओं को कैसे दूर करते हैं।

  • अजगर संस्करण के लिए स्टेनफोर्ड कोरएनएलपी के लिए पायथन रैपर की खोज करें



2

मुझे कई घंटे लगे और अंत में विंडोज उपयोगकर्ताओं के लिए एक सरल समाधान मिला। मूल रूप से एक मौजूदा जवाब के अपने संक्षिप्त संस्करण अल्वाज़ द्वारा , लेकिन स्टैनफोर्ड एनएलपी के लिए नए और विंडो उपयोगकर्ता हैं, उन लोगों के लिए (उम्मीद) का पालन करना आसान बना दिया।

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())


2

पदावनत उत्तर

नीचे दिए गए उत्तर को हटा दिया गया है, कृपया एनएलटीके v3.3 और इसके बाद के संस्करण के लिए https://stackoverflow.com/a/51981566/610569 पर समाधान का उपयोग करें ।


संपादित

नोट: निम्नलिखित उत्तर केवल इस पर काम करेगा:

  • एनएलटीके संस्करण == 3.2.5
  • स्टैनफोर्ड टूल्स 2016-10-31 से संकलित किया गया
  • पायथन 2.7, 3.5 और 3.6

चूंकि दोनों उपकरण जल्दी-जल्दी बदलते हैं और एपीआई 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 पर एक नज़र डालें । डॉकस्ट्रिंग्स पर एक नज़र!


2

ध्यान दें कि यह उत्तर 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बिना किसी पैरामीटर के कॉल कर सकते हैं , डिफ़ॉल्ट बस काम करेगा।


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')]

मुझे लगता है कि यह टैगर है न कि पार्सर
नादव बी

1

एक तंत्रिका मॉडल पर आधारित स्टैनफोर्ड पार्सर का एक नया विकास, जिसे टेन्सरफ़्लो का उपयोग करके प्रशिक्षित किया गया है, हाल ही में अजगर एपीआई के रूप में उपयोग करने के लिए उपलब्ध कराया गया है। यह मॉडल जावा-आधारित moel से कहीं अधिक सटीक माना जाता है। आप निश्चित रूप से एक एनएलटीके पाइपलाइन के साथ एकीकृत कर सकते हैं।

पार्सर से लिंक करें । रिपॉजिटरी में 53 भाषाओं के लिए पूर्व-प्रशिक्षित पार्सर मॉडल हैं।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.