एनएलटीके

Question

का उपयोग करके सामान्य समानार्थी और भाषण प्रसंस्करण का हिस्सा मैं एक वाक्य में शब्दों के लिए एक सामान्य समानार्थी पहचानकर्ता बनाने की कोशिश कर रहा हूं जो महत्वपूर्ण हैं (यानी "ए" या "द" नहीं), और मैं प्राकृतिक भाषा का उपयोग कर रहा हूं इसके लिए अजगर में टूलकिट (nltk)। मेरी समस्या यह है कि nltk में समानार्थी खोजक को इसके समानार्थी से जुड़ने के लिए भाषण तर्क का एक भाग की आवश्यकता होती है। इसके लिए मैंने कोशिश की थी कि एनएलटीके में मौजूद भाषण टैगर के सरलीकृत हिस्से का उपयोग किया जाए, और फिर इस तर्क को समानार्थी खोजकर्ता में पास करने के लिए पहले अक्षर को कम करें, हालांकि यह काम नहीं कर रहा है।

def synonyms(Sentence): 
    Keywords = [] 
    Equivalence = WordNetLemmatizer() 
    Stemmer = stem.SnowballStemmer('english') 
    for word in Sentence: 
     word = Equivalence.lemmatize(word) 
    words = nltk.word_tokenize(Sentence.lower()) 
    text = nltk.Text(words) 
    tags = nltk.pos_tag(text) 
    simplified_tags = [(word, simplify_wsj_tag(tag)) for word, tag in tags] 
    for tag in simplified_tags: 
     print tag 
     grammar_letter = tag[1][0].lower() 
     if grammar_letter != 'd': 
      Call = tag[0].strip() + "." + grammar_letter.strip() + ".01" 
      print Call 
      Word_Set = wordnet.synset(Call) 
      paths = Word_Set.lemma_names 
      for path in paths: 
       Keywords.append(Stemmer.stem(path)) 
    return Keywords 

इस कोड मैं वर्तमान से काम कर रहा हूँ है, और के रूप में आप मैं पहली बार इनपुट lemmatizing हूँ मैं लंबे समय में होगा मैचों की संख्या कम करने के लिए देख सकते हैं (मैं के दसियों पर इस चलाने की योजना हजारों वाक्य), और सिद्धांत रूप में मैं इस प्रभाव को आगे बढ़ाने के लिए इस शब्द को याद कर रहा हूं और मेरे द्वारा उत्पन्न अनावश्यक शब्दों की संख्या को कम करता हूं, हालांकि यह विधि लगभग हमेशा नीचे दिए गए फॉर्म के रूप में त्रुटियों को वापस लाती है:

Traceback (most recent call last): 
    File "C:\Python27\test.py", line 45, in <module> 
    synonyms('spray reddish attack force') 
    File "C:\Python27\test.py", line 39, in synonyms 
    Word_Set = wordnet.synset(Call) 
    File "C:\Python27\lib\site-packages\nltk\corpus\reader\wordnet.py", line 1016, in synset 
    raise WordNetError(message % (lemma, pos)) 
WordNetError: no lemma 'reddish' with part of speech 'n' 

मेरे पास इस डेटा पर अधिक नियंत्रण नहीं है, और यह बस मेरे कॉर्पस को साफ करना वास्तव में एक विकल्प नहीं है। इस समाधान को हल करने के बारे में कोई विचार?

मैंने कुछ और शोध किया और मेरे पास एक आशाजनक लीड है, लेकिन मुझे अभी भी यकीन नहीं है कि मैं इसे कैसे कार्यान्वित कर सकता हूं। किसी न पाए गए, या गलत तरीके से असाइन किए गए शब्द के मामले में, मैं शब्द को निकटतम सही ढंग से वर्गीकृत अन्य कीवर्ड से जोड़ने के लिए समानता मीट्रिक (लीकॉक चोडोरो, वू-पामर इत्यादि) का उपयोग करना चाहता हूं। शायद एक संपादन दूरी माप के संयोजन के साथ, लेकिन फिर से मैं इस पर किसी भी तरह के दस्तावेज नहीं मिला है।

Answer 1

स्पष्ट रूप से nltk किसी शब्द से जुड़े सभी synsets को पुनर्प्राप्त करने की अनुमति देता है। माना जाता है कि आमतौर पर उनमें से कई अलग-अलग शब्द इंद्रियों को प्रतिबिंबित करते हैं। कार्यात्मक रूप से समानार्थी शब्द खोजने के लिए (या यदि दो शब्द समानार्थी हैं) तो आपको सबसे नज़दीकी समानार्थी सेट से मिलान करने का प्रयास करना होगा, जो ऊपर वर्णित समानता मेट्रिक्स के माध्यम से संभव है। मैं नीचे के रूप में दिखाया गया है, कैसे करता है, तो दो शब्दों का अर्थ समान है खोजने के लिए, यह करने के लिए कुछ बुनियादी कोड को तैयार:

from nltk.corpus import wordnet 
from nltk.stem.wordnet import WordNetLemmatizer 
import itertools 


def Synonym_Checker(word1, word2): 
    """Checks if word1 and word2 and synonyms. Returns True if they are, otherwise False""" 
    equivalence = WordNetLemmatizer() 
    word1 = equivalence.lemmatize(word1) 
    word2 = equivalence.lemmatize(word2) 

    word1_synonyms = wordnet.synsets(word1) 
    word2_synonyms = wordnet.synsets(word2) 

    scores = [i.wup_similarity(j) for i, j in list(itertools.product(word1_synonyms, word2_synonyms))] 
    max_index = scores.index(max(scores)) 
    best_match = (max_index/len(word1_synonyms), max_index % len(word1_synonyms)-1) 

    word1_set = word1_synonyms[best_match[0]].lemma_names 
    word2_set = word2_synonyms[best_match[1]].lemma_names 
    match = False 
    match = [match or word in word2_set for word in word1_set][0] 

    return match 

print Synonym_Checker("tomato", "Lycopersicon_esculentum") 

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

Answer 2

क्या आप Word_Set = wordnet.synset(Call) को try: से लपेट सकते हैं और WordNetError अपवाद को अनदेखा कर सकते हैं? ऐसा लगता है कि आपके पास त्रुटि है कि कुछ शब्दों को सही ढंग से वर्गीकृत नहीं किया गया है, लेकिन यह अपवाद भी अपरिचित शब्दों के लिए होगा, इसलिए अपवाद को पकड़ना मेरे लिए एक अच्छा विचार है।