मैं शब्द Stemming या Lemmatization कैसे करूँ?

Question

मैंने पोर्टरस्ट्रीमर और स्नोबॉल की कोशिश की है, लेकिन दोनों सभी शब्दों पर काम नहीं करते हैं, कुछ बहुत ही सामान्य याद आ रही है।

मेरे परीक्षण के शब्द हैं: " रनिंग कैक्टस कैक्टस कैक्टि समुदाय समुदाय भागते हैं ", और दोनों आधे से कम सही हैं।

यह सभी देखें:

• वास्तविक शब्दों का निर्माण करने वाला एल्गोरिथ्म
• स्टेमिंग - कोड उदाहरण या ओपन सोर्स प्रोजेक्ट?

Comments

क्या यह कैक्टि नहीं होना चाहिए?

— MSalters

बस Reddit पर पोस्ट किए गए मूल प्रश्न का एक गोलाकार संदर्भ बनाने के लिए: मैं प्रोग्रामेटिक रूप से स्टेमिंग कैसे करूं? (उदाहरण के लिए "खाने" से "खाने के लिए", "कैक्टस" से "कैक्टस") इसे यहाँ पोस्ट करना क्योंकि टिप्पणियों में उपयोगी जानकारी शामिल है।

— रेनॉड बोमफ़ोस

देखें stackoverflow.com/questions/17317418/stemmers-vs-lemmatizers

— alvas

Answer 1

यदि आप पायथन को जानते हैं, तो द नेचुरल लैंग्वेज टूलकिट (एनएलटीके) में एक बहुत शक्तिशाली लेम्मेटाइज़र है जो वर्डनेट का उपयोग करता है ।

ध्यान दें कि यदि आप पहली बार इस लेमेटाइज़र का उपयोग कर रहे हैं, तो आपको इसका उपयोग करने से पहले कॉर्पस को डाउनलोड करना होगा। इसके द्वारा किया जा सकता है:

>>> import nltk
>>> nltk.download('wordnet')

आपको केवल एक बार ऐसा करना है। यह मानते हुए कि आपने अब कॉर्पस डाउनलोड कर लिया है, यह इस तरह काम करता है:

>>> from nltk.stem.wordnet import WordNetLemmatizer
>>> lmtzr = WordNetLemmatizer()
>>> lmtzr.lemmatize('cars')
'car'
>>> lmtzr.lemmatize('feet')
'foot'
>>> lmtzr.lemmatize('people')
'people'
>>> lmtzr.lemmatize('fantasized','v')
'fantasize'

Nltk.stem मॉड्यूल में अन्य लेमेटाइज़र हैं , लेकिन मैंने उन्हें स्वयं आज़माया नहीं है।

Comments

ओह दुखद ... इससे पहले कि मैं एसओ को खोजता, मैं अपना खुद का लागू करता!

— क्रिस Pfohl

पहली बार nltk का उपयोग करने से पहले कॉर्पस को स्थापित करने के लिए मत भूलना ! velvetcache.org/2010/03/01/…

— मैथ्यू रोडिक

ठीक है, यह एक पोर्टर स्टीमर जैसे कुछ गैर-नियतात्मक एल्गोरिथ्म का उपयोग करता है, यदि आप इसके साथ प्रयास करते हैं dies, तो यह आपको dyइसके बजाय देता है die। क्या किसी प्रकार का हार्डकोडेड स्टीमर शब्दकोश नहीं है?

— सेक्सीबस्ट

किसी भी विचार जो WordNetLemmatizerगलत तरीके से lemmatize शब्द हैं ?

— आल्व्स

nltk WordNetLemmatizer को तर्क के रूप में पॉज़ टैग की आवश्यकता होती है। डिफ़ॉल्ट रूप से यह 'एन' (संज्ञा के लिए खड़ा है) है। तो यह क्रियाओं के लिए सही ढंग से काम नहीं करेगा। यदि पीओएस टैग उपलब्ध नहीं हैं, तो एक सरल (लेकिन तदर्थ) दृष्टिकोण दो बार लेमेटाइजेशन करना है, एक 'एन' के लिए, और दूसरा 'वी' के लिए (क्रिया के लिए खड़ा है), और वह परिणाम चुनें जो अलग से हो मूल शब्द (आमतौर पर लंबाई में छोटा होता है, लेकिन 'भागा' और 'रन' की लंबाई समान होती है)। ऐसा लगता है कि हमें 'adj', 'adv', 'prep' आदि के बारे में चिंता करने की आवश्यकता नहीं है, क्योंकि वे पहले से ही किसी न किसी अर्थ में मूल रूप में हैं।

— फशांदे

Answer 2

मैं लेन्मेटाइजेशन करने के लिए स्टैनफोर्ड एलईपीपी का उपयोग करता हूं । मैं पिछले कुछ दिनों में इसी तरह की समस्या से जूझ रहा हूं। समस्या को हल करने में मेरी सहायता करने के लिए स्टैकवॉटरफ़्लो के लिए सभी धन्यवाद।

import java.util.*; 
import edu.stanford.nlp.pipeline.*;
import edu.stanford.nlp.ling.*; 
import edu.stanford.nlp.ling.CoreAnnotations.*;  

public class example
{
    public static void main(String[] args)
    {
        Properties props = new Properties(); 
        props.put("annotators", "tokenize, ssplit, pos, lemma"); 
        pipeline = new StanfordCoreNLP(props, false);
        String text = /* the string you want */; 
        Annotation document = pipeline.process(text);  

        for(CoreMap sentence: document.get(SentencesAnnotation.class))
        {    
            for(CoreLabel token: sentence.get(TokensAnnotation.class))
            {       
                String word = token.get(TextAnnotation.class);      
                String lemma = token.get(LemmaAnnotation.class); 
                System.out.println("lemmatized version :" + lemma);
            }
        }
    }
}

यह भी एक अच्छा विचार हो सकता है कि स्टॉपवार्ड का उपयोग आउटपुट लेम्स को कम करने के लिए करें यदि यह बाद में क्लासिलेटर में उपयोग किया जाता है। कृपया जॉन कॉनवेल द्वारा लिखे गए CoreNlp एक्सटेंशन पर एक नज़र डालें ।

Comments

देर से जवाब के लिए खेद है .. मैं इस मुद्दे को केवल अब हल हो गया! :)

— सीटीसिद्धार्थ

लाइन 'पाइपलाइन = नई ...' मेरे लिए संकलित नहीं है। अगर मैं इसे 'StanfordCoreNLP pipelne = new ...' में बदलता हूं तो यह संकलन करता है। यह सही है?

— आदम_जी

हां, आपको पहले पाइपलाइन संस्करण की घोषणा करनी चाहिए। स्टैनफोर्ड एनएलपी का उपयोग कमांड लाइन से किया जा सकता है और साथ ही आपको कोई प्रोग्रामिंग करने की आवश्यकता नहीं है, आप बस गुण फ़ाइल बनाते हैं और इसके साथ निष्पादन योग्य फ़ीड करते हैं। डॉक्स पढ़ें: nlp.stanford.edu/software/corenlp.shtml

— Jindra Helcl

Answer 3

मैंने इस स्नोबॉल डेमो साइट पर आपकी शर्तों की सूची की कोशिश की और परिणाम ठीक दिखे ...।

• बिल्लियाँ -> बिल्ली
• दौड़ना -> चलाना
• भागा -> भागा
• कैक्टस -> कैक्टस
• कैक्टस -> कैक्टस
• समुदाय -> कम्युनिटी
• समुदाय -> कम्युनिटी

एक स्टेमर को शब्दों के विभक्त रूपों को कुछ सामान्य मूल में बदलना चाहिए। यह वास्तव में एक स्टेमर का काम नहीं है कि उस मूल शब्द को 'उचित' शब्द बनाया जाए। उसके लिए आपको रूपात्मक / ऑर्थोग्राफ़िक विश्लेषणकर्ताओं को देखने की आवश्यकता है ।

मुझे लगता है कि यह सवाल कमोबेश उसी चीज के बारे में है, और करेल का उस सवाल का जवाब है कि मैंने दूसरी कड़ी कहां से ली है।

Comments

मुद्दा यह है कि स्टेम ("अपडेट") == स्टेम ("अपडेट"), जो यह करता है (अपडेट ->

— अपडैट

सॉफ्टवेयर स्टेम (x) == स्टेम (y) कर सकता है लेकिन इस सवाल का पूरी तरह से जवाब नहीं दे रहा है

— उपयोगकर्ता

लिंगो के साथ सावधान, एक स्टेम एक शब्द का आधार रूप नहीं है। यदि आप आधार फॉर्म चाहते हैं, तो आपको लेमेटाइज़र की आवश्यकता है। स्टेम एक शब्द का सबसे बड़ा हिस्सा है जिसमें उपसर्ग या प्रत्यय नहीं होते हैं। एक शब्द अद्यतन का स्टेम वास्तव में "अपडेटैट" है। शब्द उपजी और प्रत्यय जोड़कर उपजा है, जैसे updat-e, या updat-ing। ( en.wikipedia.org/wiki/Word_stem )

— जिंद्रा हेलक्ल

Answer 4

स्टेमर बनाम लेम्मेटाइज़र बहस चलती है। यह दक्षता पर सटीक पसंद करने की बात है। आपको भाषाई रूप से सार्थक इकाइयों को प्राप्त करने और कम से कम कंप्यूटिंग जूस का उपयोग करने के लिए स्टेम करना चाहिए और एक ही कुंजी के तहत एक शब्द और इसके बदलावों को अनुक्रमित करना चाहिए।

देखें स्टेमर्स बनाम लेम्मेटाइज़र

यहाँ अजगर एनएलटीके के साथ एक उदाहरण दिया गया है:

>>> sent = "cats running ran cactus cactuses cacti community communities"
>>> from nltk.stem import PorterStemmer, WordNetLemmatizer
>>>
>>> port = PorterStemmer()
>>> " ".join([port.stem(i) for i in sent.split()])
'cat run ran cactu cactus cacti commun commun'
>>>
>>> wnl = WordNetLemmatizer()
>>> " ".join([wnl.lemmatize(i) for i in sent.split()])
'cat running ran cactus cactus cactus community community'

Comments

जैसा कि पहले उल्लेख किया है, WordNetLemmatizerके lemmatize()एक पीओएस टैग ले सकते हैं। तो अपने उदाहरण से: " ".join([wnl.lemmatize(i, pos=VERB) for i in sent.split()])देता है 'cat run run cactus cactuses cacti community communities'।

— निक रुइज

@NickRuiz, मुझे लगता है कि आपका मतलब है pos=NOUN? Btw: लंबे समय नहीं देखते हैं, उम्मीद है कि हम जल्द ही सम्मेलन में एक दूसरे से मिलने जाएगा =)

— alvas

वास्तव में, नहीं (उम्मीद है कि 'हां' सम्मेलनों के लिए, हालांकि)। क्योंकि यदि आप सेट pos=VERBकरते हैं तो आप केवल क्रियाओं पर ही लेटमैटाइजेशन करते हैं। संज्ञाएं समान रहती हैं। मुझे बस अपने कुछ कोड लिखने के लिए वास्तविक पेन ट्रीबैंक पीओएस टैग के चारों ओर पिवट करना था ताकि प्रत्येक टोकन के लिए सही लेमेट्रेटेशन लागू किया जा सके। इसके अलावा, WordNetLemmatizernltk के डिफॉल्ट टोकन को lemmatizing में बदबू आ रही है। तो जैसे उदाहरण के does n'tलिए lemmatize नहीं है do not।

— निक रुइज़

लेकिन, लेकिन port.stem("this")उत्पादन करता है thiऔर port.stem("was") waतब भी, जब प्रत्येक के लिए सही स्थिति प्रदान की जाती है।

— लर्नर झांग

एक स्टेम भाषाई रूप से ध्वनि आउटपुट वापस नहीं करता है। यह केवल पाठ को और अधिक "घना" बनाने के लिए है (अर्थात इसमें कम शब्दकोष हैं)। देखें stackoverflow.com/questions/17317418/stemmers-vs-lemmatizers और stackoverflow.com/questions/51943811/...

— alvas

Answer 5

मार्टिन पोर्टर के आधिकारिक पृष्ठ में PHP के साथ-साथ अन्य भाषाओं में एक पोर्टर स्टेमर शामिल है ।

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

Comments

एक आदर्श समाधान इन उम्मीदों को स्वचालित रूप से सीख लेगा। क्या आपके पास ऐसी प्रणाली के साथ कोई अनुभव है?

— मैल्कम

नहीं। हमारे मामले में अनुक्रमित किए जा रहे दस्तावेज कानून के एक विशिष्ट क्षेत्र के लिए कोड और नियम थे और दर्जनों (मानव) संपादक थे जो किसी भी खराब उपजी के लिए सूचकांक का विश्लेषण कर रहे थे।

— वान गेल

Answer 6

http://wordnet.princeton.edu/man/morph.3WN

अपनी बहुत सी परियोजनाओं के लिए, मैं अधिक आक्रामक कुली उपहास पर लेक्सिकॉन-आधारित वर्डनेट लेमेटाइज़र को प्राथमिकता देता हूं।

http://wordnet.princeton.edu/links#PHP में डब्ल्यूएन एपीआई के लिए एक पीएचपी इंटरफ़ेस का लिंक है।

Answer 7

स्टैक ओवरफ्लो और ब्लॉग्स पर आए विभिन्न उत्तरों के आधार पर, यह वह तरीका है जिसका मैं उपयोग कर रहा हूं, और यह वास्तविक शब्दों को काफी अच्छी तरह से वापस करता है। विचार आने वाले पाठ को शब्दों के एक सरणी में विभाजित करना है (जो भी विधि आप चाहें) का उपयोग करें, और फिर उन शब्दों के लिए भाषण (पीओएस) के कुछ हिस्सों को ढूंढें और उन शब्दों का उपयोग करें और शब्दों को स्टेम करने में मदद करें।

आप ऊपर का नमूना बहुत अच्छी तरह से काम नहीं करते हैं, क्योंकि पीओएस निर्धारित नहीं किया जा सकता है। हालांकि, अगर हम एक वास्तविक वाक्य का उपयोग करते हैं, तो चीजें बहुत बेहतर काम करती हैं।

import nltk
from nltk.corpus import wordnet

lmtzr = nltk.WordNetLemmatizer().lemmatize


def get_wordnet_pos(treebank_tag):
    if treebank_tag.startswith('J'):
        return wordnet.ADJ
    elif treebank_tag.startswith('V'):
        return wordnet.VERB
    elif treebank_tag.startswith('N'):
        return wordnet.NOUN
    elif treebank_tag.startswith('R'):
        return wordnet.ADV
    else:
        return wordnet.NOUN


def normalize_text(text):
    word_pos = nltk.pos_tag(nltk.word_tokenize(text))
    lemm_words = [lmtzr(sw[0], get_wordnet_pos(sw[1])) for sw in word_pos]

    return [x.lower() for x in lemm_words]

print(normalize_text('cats running ran cactus cactuses cacti community communities'))
# ['cat', 'run', 'ran', 'cactus', 'cactuses', 'cacti', 'community', 'community']

print(normalize_text('The cactus ran to the community to see the cats running around cacti between communities.'))
# ['the', 'cactus', 'run', 'to', 'the', 'community', 'to', 'see', 'the', 'cat', 'run', 'around', 'cactus', 'between', 'community', '.']

Answer 8

वर्डनेट में देखें, अंग्रेजी भाषा के लिए एक बड़ा शाब्दिक डेटाबेस:

http://wordnet.princeton.edu/

कई भाषाओं में इसे एक्सेस करने के लिए एपीआई हैं।

Answer 9

यह दिलचस्प लग रहा है: एमआईटी जावा वर्डनेटस्टेमर: http://projects.csail.mit.edu/jwi/api/edu/mit/jwi/morph/WordnetStemmer.html

Comments

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

— जोगोजपन

Answer 10

पर एक नजर डालें LemmaGen सी # 3.0 में लिखा खुला स्रोत पुस्तकालय -।

आपके परीक्षण शब्दों के लिए परिणाम ( http://lemmatise.ijs.si/Services )

• बिल्लियाँ -> बिल्ली
• चल रहा है
• भागा -> चला
• कैक्टस
• कैक्टस -> कैक्टस
• कैक्टि -> कैक्टस
• समुदाय
• समुदाय -> समुदाय

Answer 11

शीर्ष अजगर पैकेज (कोई विशेष क्रम में) lemmatization के लिए कर रहे हैं: spacy, nltk, gensim, pattern, CoreNLPऔर TextBlob। मैं SpaCy और गेंसिम के कार्यान्वयन (पैटर्न के आधार पर) को पसंद करता हूं क्योंकि वे शब्द के पीओएस टैग की पहचान करते हैं और स्वचालित रूप से उपयुक्त लेम्मा प्रदान करते हैं। अर्थ को अक्षुण्ण बनाये रखते हुए अधिक प्रासंगिक नींबू देता है।

यदि आप nltk या TextBlob का उपयोग करने की योजना बना रहे हैं, तो आपको मैन्युअल रूप से सही POS टैग खोजने और सही लेम्मा खोजने की आवश्यकता है।

Lemmatization उदाहरण SpaCy के साथ:

# Run below statements in terminal once. 
pip install spacy
spacy download en

import spacy

# Initialize spacy 'en' model
nlp = spacy.load('en', disable=['parser', 'ner'])

sentence = "The striped bats are hanging on their feet for best"

# Parse
doc = nlp(sentence)

# Extract the lemma
" ".join([token.lemma_ for token in doc])
#> 'the strip bat be hang on -PRON- foot for good'

Lemmatization उदाहरण के साथ Gensim:

from gensim.utils import lemmatize
sentence = "The striped bats were hanging on their feet and ate best fishes"
lemmatized_out = [wd.decode('utf-8').split('/')[0] for wd in lemmatize(sentence)]
#> ['striped', 'bat', 'be', 'hang', 'foot', 'eat', 'best', 'fish']

उपरोक्त उदाहरण इस लेमेटेटेशन पेज से उधार लिए गए थे ।

Answer 12

एक खोज करें फुकर ल्यूसिनेन, यह सुनिश्चित न करें कि यदि कोई पीएचपी पोर्ट है लेकिन मुझे पता है कि ल्यूसीन कई प्लेटफार्मों के लिए उपलब्ध है। ल्यूसीन एक ओएसएस (अपाचे से) अनुक्रमण और खोज पुस्तकालय है। स्वाभाविक रूप से यह और समुदाय एक्स्ट्रा कलाकार को देखने के लिए कुछ दिलचस्प हो सकता है। बहुत कम से कम आप सीख सकते हैं कि इसका एक भाषा में कैसे किया जाता है ताकि आप "विचार" को PHP में अनुवाद कर सकें

Answer 13

यदि मैं अपने प्रश्न का उत्तर StompChicken उल्लेख कर सकता हूं:

यहां मुख्य मुद्दा यह है कि स्टेमिंग एल्गोरिदम एक ध्वन्यात्मक आधार पर काम करते हैं, जिस भाषा के साथ वे काम कर रहे हैं उसकी कोई वास्तविक समझ नहीं है।

चूंकि उन्हें भाषा की कोई समझ नहीं है और वे शब्दों के शब्दकोश से नहीं चलते हैं, इसलिए उनके पास अनियमित मामलों, जैसे "रन" / "भागा" को उचित रूप से पहचानने और प्रतिक्रिया देने का कोई तरीका नहीं है।

यदि आपको अनियमित मामलों को संभालने की आवश्यकता है, तो आपको या तो एक अलग दृष्टिकोण चुनने की आवश्यकता होगी या अपने स्वयं के कस्टम शब्दकोश के साथ अपने स्टेमिंग को बढ़ाना होगा जब स्टेमर ने अपनी बात की है।

Answer 14

एनएलटीके में स्टेमर का सबसे वर्तमान संस्करण स्नोबॉल है।

आप इसका उपयोग कैसे करें, इस पर उदाहरण पा सकते हैं:

http://nltk.googlecode.com/svn/trunk/doc/api/nltk.stem.snowball2-pysrc.html#demo

Answer 15

आप मोरफा स्टेमर का उपयोग कर सकते हैं। यदि आपने जावा एप्लिकेशन से इसका उपयोग करने की योजना बनाई है, तो यूडब्ल्यू ने मोर्फा स्टेमर को मावेन सेंट्रल पर अपलोड किया है । एक आवरण है जो इसे उपयोग करने के लिए बहुत आसान बनाता है। आपको बस इसे एक निर्भरता के रूप में जोड़ने और edu.washington.cs.knowitall.morpha.MorphaStemmerवर्ग का उपयोग करने की आवश्यकता है। उदाहरण थ्रेडसेफ़ हैं (मूल JFlex में स्थानीय चर के लिए अनावश्यक रूप से वर्ग फ़ील्ड थे)। एक वर्ग को तुरंत चलाएं morphaऔर जिस शब्द को आप स्टेम करना चाहते हैं।

new MorphaStemmer().morpha("climbed") // goes to "climb"

Answer 16

.Net ल्यूसिने में एक इनबिल्ट पोर्टर स्टेमर है। आप कोशिश कर सकते हैं कि लेकिन ध्यान दें कि पोर्टर स्टेमिंग लेम्मा को व्युत्पन्न करते समय शब्द के संदर्भ में विचार नहीं करता है। (एल्गोरिथ्म और इसके कार्यान्वयन के माध्यम से जाओ और आप देखेंगे कि यह कैसे काम करता है)

Answer 17

मार्टिन पोर्टर ने स्नोबॉल (एल्गोरिथम एल्गोरिथम के लिए एक भाषा) लिखा और स्नोबॉल में "इंग्लिश स्टीमर" को फिर से लिखा। सी और जावा के लिए एक अंग्रेजी स्टेमर हैं।

वह स्पष्ट रूप से कहता है कि पोर्टर स्टीमर को केवल ऐतिहासिक कारणों के लिए फिर से लागू किया गया है, इसलिए पोर्टर स्टेमर के खिलाफ सहीता का परीक्षण करने से आपको ऐसे परिणाम मिलेंगे जो आपको (पहले से ही) पता हैं।

से http://tartarus.org/~martin/PorterStemmer/index.html (जोर मेरा)

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

डॉ। पोर्टर पोर्टर स्टेमर के बजाय अंग्रेजी या पोर्टर 2 स्टेमर्स का उपयोग करने का सुझाव देते हैं। अंग्रेजी स्टेमर का उपयोग वास्तव में डेमो साइट में किया जाता है जैसा कि @StompChicken ने पहले उत्तर दिया है।

Answer 18

जावा में, मैं शब्दों का उपयोग करने के लिए टैटारगस-स्नोबॉल का उपयोग करता हूं

Maven:

<dependency>
        <groupId>org.apache.lucene</groupId>
        <artifactId>lucene-snowball</artifactId>
        <version>3.0.3</version>
        <scope>test</scope>
</dependency>

नमूना कोड:

SnowballProgram stemmer = new EnglishStemmer();
String[] words = new String[]{
    "testing",
    "skincare",
    "eyecare",
    "eye",
    "worked",
    "read"
};
for (String word : words) {
    stemmer.setCurrent(word);
    stemmer.stem();
    //debug
    logger.info("Origin: " + word + " > " + stemmer.getCurrent());// result: test, skincar, eyecar, eye, work, read
}

Answer 19

इसे यहां देखें: http://www.twinword.com/lemmatizer.php

मैंने डेमो में आपकी क्वेरी दर्ज की "cats running ran cactus cactuses cacti community communities"और ["cat", "running", "run", "cactus", "cactus", "cactus", "community", "community"]वैकल्पिक ध्वज के साथ मिला ALL_TOKENS।

नमूना कोड

यह एक एपीआई है जिससे आप इसे किसी भी वातावरण से जोड़ सकते हैं। यहाँ PHP REST कॉल जैसा दिख सकता है।

// These code snippets use an open-source library. http://unirest.io/php
$response = Unirest\Request::post([ENDPOINT],
  array(
    "X-Mashape-Key" => [API KEY],
    "Content-Type" => "application/x-www-form-urlencoded",
    "Accept" => "application/json"
  ),
  array(
    "text" => "cats running ran cactus cactuses cacti community communities"
  )
);

Answer 20

मैं स्पैसी (बेस टेक्स्ट पार्सिंग और टैगिंग) और टेक्स्टेसी (स्पाइस के शीर्ष पर निर्मित उच्च स्तरीय टेक्स्ट प्रोसेसिंग ) का उपयोग करने की अत्यधिक सलाह देता हूं ।

Lemmatized शब्द डिफ़ॉल्ट रूप से एक .lemma_विशेषता के रूप में Spacy में उपलब्ध होते हैं और पाठ को पाठ के साथ कई अन्य प्रीप्रोसेसिंग करते हुए lemmatized किया जा सकता है। उदाहरण के लिए , कुछ प्रसंस्करण करने से पहले आमतौर पर शब्दों या शब्दों का एक बैग बनाते समय या इसके लिए आवश्यकता होती है।

मैं आपको किसी भी कोड को लिखने से पहले दोनों की जांच करने के लिए प्रोत्साहित करता हूं, क्योंकि इससे आपका बहुत समय बच सकता है!

Answer 21

df_plots = pd.read_excel("Plot Summary.xlsx", index_col = 0)
df_plots
# Printing first sentence of first row and last sentence of last row
nltk.sent_tokenize(df_plots.loc[1].Plot)[0] + nltk.sent_tokenize(df_plots.loc[len(df)].Plot)[-1]

# Calculating length of all plots by words
df_plots["Length"] = df_plots.Plot.apply(lambda x : 
len(nltk.word_tokenize(x)))

print("Longest plot is for season"),
print(df_plots.Length.idxmax())

print("Shortest plot is for season"),
print(df_plots.Length.idxmin())



#What is this show about? (What are the top 3 words used , excluding the #stop words, in all the #seasons combined)

word_sample = list(["struggled", "died"])
word_list = nltk.pos_tag(word_sample)
[wnl.lemmatize(str(word_list[index][0]), pos = word_list[index][1][0].lower()) for index in range(len(word_list))]

# Figure out the stop words
stop = (stopwords.words('english'))

# Tokenize all the plots
df_plots["Tokenized"] = df_plots.Plot.apply(lambda x : nltk.word_tokenize(x.lower()))

# Remove the stop words
df_plots["Filtered"] = df_plots.Tokenized.apply(lambda x : (word for word in x if word not in stop))

# Lemmatize each word
wnl = WordNetLemmatizer()
df_plots["POS"] = df_plots.Filtered.apply(lambda x : nltk.pos_tag(list(x)))
# df_plots["POS"] = df_plots.POS.apply(lambda x : ((word[1] = word[1][0] for word in word_list) for word_list in x))
df_plots["Lemmatized"] = df_plots.POS.apply(lambda x : (wnl.lemmatize(x[index][0], pos = str(x[index][1][0]).lower()) for index in range(len(list(x)))))



#Which Season had the highest screenplay of "Jesse" compared to "Walt" 
#Screenplay of Jesse =(Occurences of "Jesse")/(Occurences of "Jesse"+ #Occurences of "Walt")

df_plots.groupby("Season").Tokenized.sum()

df_plots["Share"] = df_plots.groupby("Season").Tokenized.sum().apply(lambda x : float(x.count("jesse") * 100)/float(x.count("jesse") + x.count("walter") + x.count("walt")))

print("The highest times Jesse was mentioned compared to Walter/Walt was in season"),
print(df_plots["Share"].idxmax())
#float(df_plots.Tokenized.sum().count('jesse')) * 100 / #float((df_plots.Tokenized.sum().count('jesse') + #df_plots.Tokenized.sum().count('walt') + #df_plots.Tokenized.sum().count('walter')))