शब्दों के थैले का परिचय और एनएलपी के लिए इसे पायथन में कैसे कोडित किया जाए

पिक्साबे द्वारा काली सतह पर सफेद और काले स्क्रैबल टाइल

बैग ऑफ़ वर्ड्स (BOW) पाठ दस्तावेज़ों से सुविधाओं को निकालने की एक विधि है। इन सुविधाओं का उपयोग प्रशिक्षण मशीन लर्निंग एल्गोरिदम के लिए किया जा सकता है। यह प्रशिक्षण सेट में सभी दस्तावेजों में होने वाले सभी अनूठे शब्दों की शब्दावली बनाता है।

सरल शब्दों में, यह शब्द गणना के साथ एक वाक्य का प्रतिनिधित्व करने के लिए शब्दों का एक संग्रह है और ज्यादातर उस क्रम को नापसंद करते हैं जिसमें वे दिखाई देते हैं।

BOW एक दृष्टिकोण है जिसका व्यापक रूप से उपयोग किया जाता है:

  1. प्राकृतिक भाषा प्रसंस्करण
  2. दस्तावेजों से सूचना पुनर्प्राप्ति
  3. दस्तावेज़ वर्गीकरण

उच्च स्तर पर, इसमें निम्नलिखित चरण शामिल हैं।

जेनरेट किए गए वैक्टर आपके मशीन लर्निंग एल्गोरिदम में इनपुट हो सकते हैं।

आइए कुछ वाक्यों को समझकर और उन लोगों के लिए वैक्टर उत्पन्न करके एक उदाहरण के साथ शुरुआत करें।

नीचे दिए गए दो वाक्यों पर विचार करें।

1. "जॉन को फिल्में देखना पसंद है। मैरी को फिल्में भी पसंद हैं।"
2. "जॉन को फुटबॉल खेल देखना भी पसंद है।"

इन दो वाक्यों को शब्दों के संग्रह के साथ भी दर्शाया जा सकता है।

1. ['जॉन', 'पसंद', 'से', 'घड़ी', 'फिल्में।', 'मैरी', 'पसंद', 'फिल्में', 'भी।']
2. ['जॉन', 'भी', 'लाइक', 'टू', 'वॉच', 'फुटबॉल', 'गेम्स']

इसके अलावा, प्रत्येक वाक्य के लिए, शब्द की कई घटनाओं को हटा दें और इस का प्रतिनिधित्व करने के लिए शब्द गणना का उपयोग करें।

7. "" जॉन ": 1," पसंद ": 2," से ": 1," घड़ी ": 1," फिल्में ": 2," मैरी ": 1," भी ": 1}
11. "" जॉन ": 1," भी ": 1," पसंद ": 1," से ": 1," घड़ी ": 1," फुटबॉल ": 1," खेल ": 1}

इन वाक्यों को मानकर एक दस्तावेज़ का हिस्सा है, नीचे हमारे पूरे दस्तावेज़ के लिए संयुक्त शब्द आवृत्ति है। दोनों वाक्यों को ध्यान में रखा गया है।

 {"जॉन": 2, "पसंद": 3, "से": 2, "घड़ी": 2, "फिल्में": 2, "मैरी": 1, "भी": 1, "भी": 1, " फुटबॉल ": 1," खेल ": 1}

एक दस्तावेज़ में सभी शब्दों से उपरोक्त शब्दावली, उनके संबंधित शब्द गणना के साथ, प्रत्येक वाक्य के लिए वैक्टर बनाने के लिए उपयोग किया जाएगा।

वेक्टर की लंबाई हमेशा शब्दावली आकार के बराबर होगी। इस मामले में वेक्टर की लंबाई 11 है।

वेक्टर में हमारे मूल वाक्यों का प्रतिनिधित्व करने के लिए, प्रत्येक वेक्टर को सभी शून्य के साथ आरम्भ किया जाता है - [0, 0, 0, 0, 0, 0, 0, 0, 0]

इसके बाद हमारी शब्दावली में प्रत्येक शब्द के साथ पुनरावृत्ति और तुलना होती है, और यदि वाक्य में यह शब्द है, तो वेक्टर मान को बढ़ाता है।

जॉन को फिल्में देखना पसंद है। मैरी को फिल्में भी पसंद हैं।
[१, २, १, १, २, १, १, ०, ०, ०]
जॉन को फुटबॉल खेल देखना भी पसंद है।
[१, १, १, १, ०, ०, ०, १, १, १]

उदाहरण के लिए, वाक्य 1 में शब्द पसंद दूसरी स्थिति में और दो बार दिखाई देता है। तो वाक्य 1 के लिए हमारे वेक्टर का दूसरा तत्व 2 होगा: [1, 2, 1, 1, 2, 1, 1, 0, 0, 0]।

वेक्टर हमेशा हमारी शब्दावली के आकार के समानुपाती होता है।

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

हमारे BOW एल्गोरिथ्म को कोड करना

हमारे कोड का इनपुट कई वाक्य होंगे और आउटपुट वैक्टर होंगे।

इनपुट सरणी यह ​​है:

["जो ट्रेन का इंतजार करता है", "ट्रेन लेट हो गई", "मैरी और सामंथा ने बस ली",
"मैंने बस स्टेशन पर मेरी और सामंथा की तलाश की",
"मैरी और सामंथा बस स्टेशन पर जल्दी पहुंची लेकिन बस के लिए दोपहर तक इंतजार करती रही"]

चरण 1: एक वाक्य को टोकन दें

हम वाक्यों से स्टॉपवार्ड हटाकर शुरू करेंगे।

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

टोकनेशन शब्द, कीवर्ड, वाक्यांश, प्रतीक और टोकन नामक अन्य तत्वों जैसे टुकड़ों में तार के अनुक्रम को तोड़ने का कार्य है। टोकन व्यक्तिगत शब्द, वाक्यांश या यहां तक ​​कि पूरे वाक्य हो सकते हैं। टोकेनाइजेशन की प्रक्रिया में, कुछ अक्षर जैसे विराम चिह्न को छोड़ दिया जाता है।

def word_extraction (वाक्य):
    नजरअंदाज करना = [= ए ’’, ’’ ’’, ’’ ’’]
    शब्द = re.sub ("[^ \ w]", "", वाक्य) .split ()
    शब्दों में w के लिए cleaned_text = [w.lower () यदि अनदेखा नहीं किया गया है]
    cleaned_text पर वापस लौटें

स्टॉपवर्ड्स के अधिक मजबूत कार्यान्वयन के लिए, आप अजगर nltk लाइब्रेरी का उपयोग कर सकते हैं। इसमें प्रति भाषा पूर्वनिर्धारित शब्दों का एक सेट है। यहाँ एक उदाहरण है:

आयात nltk
nltk.corpus आयात स्टॉप से ​​पासवर्ड
 (Stopwords.words ( 'अंग्रेज़ी')) सेट

चरण 2: सभी वाक्यों के लिए टोकन लागू करें

tokenize (वाक्य):
    शब्द = []
    वाक्यों में सजा के लिए:
        w = word_extraction (वाक्य)
        words.extend (डब्ल्यू)
        
    शब्द = क्रमबद्ध (सूची (सेट (शब्द)))
    वापसी शब्द

विधि सभी वाक्यों को पुनरावृत्त करती है और निकाले गए शब्द को एक सरणी में जोड़ती है।

इस विधि का आउटपुट होगा:

['और', 'पहुंचे', 'एट', 'बस', 'लेकिन', 'अर्ली', 'फॉर', 'आई', 'जो', 'लेट', 'लुक', 'मेरी', ' दोपहर ',' सामंथा ',' स्टेशन ',' द ',' लिया ',' ट्रेन ',' जब तक ',' इंतजार ',' '] था।

चरण 3: शब्दावली बनाएं और वैक्टर उत्पन्न करें

दस्तावेज़ शब्दावली बनाने और वाक्यों से शब्द निकालने के लिए चरण 1 और 2 में परिभाषित विधियों का उपयोग करें।

डिफ जनरेट_बो (ऑलसेन्टेंस):
    वोकब = टोकन
    प्रिंट ("डॉक्यूमेंट लिस्ट फॉर डॉक्यूमेंट \ n {0} \ n" .फॉर्मैट (वोकैब));
सभी स्थितियों में सजा के लिए:
        शब्द = शब्द_ वाक्य (वाक्य)
        bag_vector = numpy.zeros (लेन (शब्द))
        w में शब्दों के लिए:
            मेरे लिए, एन्युमरेट (शब्द) में शब्द:
                यदि शब्द == w:
                    bag_vector [i] + = 1
                    
        प्रिंट ( "{0} \ N {1} \ n" .format (वाक्य, numpy.array (bag_vector)))

यहाँ हमारे कोड का परिभाषित इनपुट और निष्पादन है:

allsentences = ["जो ट्रेन ट्रेन का इंतजार करता है", "ट्रेन लेट हो गई", "मैरी और सामंथा ने बस ली",
"मैंने बस स्टेशन पर मेरी और सामंथा की तलाश की",
"मैरी और सामंथा बस स्टेशन पर जल्दी पहुंची लेकिन बस के लिए दोपहर तक इंतजार करती रही"]
generate_bow (allsentences)

प्रत्येक वाक्य के लिए आउटपुट वैक्टर हैं:

आउटपुट:
जो ट्रेन ट्रेन का इंतजार कर रहा था
[0। 0. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 2. 0. 1. 0.]
ट्रेन लेट थी
[0। 0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0. 0. 1. 1. 0. 0. 0. 1.]
मेरी और सामंथा ने बस ली
[1। 0. 0. 1. 0. 0. 0. 0. 0. 0. 1. 0. 1. 0. 0. 1. 0. 0. 0.]
मैंने बस स्टेशन पर मेरी और सामंथा की तलाश की
[1। 0. 1. 1. 0. 0. 1. 1. 0. 1. 1. 1. 1. 1. 1. 0. 0. 0. 0. 0.]
मैरी और सामंथा बस स्टेशन पर जल्दी पहुंची लेकिन बस के लिए दोपहर तक इंतजार करती रही
[1। 1. 1. 2. 1. 1. 1. 0. 0. 0. 1. 1. 1. 1. 1. 0. 0. 0. 1. 1. 0.]

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

हमने अपना कोड और जेनरेट किए गए वैक्टर लिखे हैं, लेकिन अब शब्दों के बैग को थोड़ा और समझ लें।

शब्दों के बैग में अंतर्दृष्टि

BOW मॉडल केवल यह मानता है कि कोई ज्ञात शब्द किसी दस्तावेज़ में है या नहीं। यह अर्थ, संदर्भ और आदेश के बारे में परवाह नहीं करता है जिसमें वे दिखाई देते हैं।

इससे यह जानकारी मिलती है कि समान दस्तावेजों में एक दूसरे के समान शब्द मायने रखता है। दूसरे शब्दों में, दो दस्तावेज़ों में जितने अधिक शब्द हैं, उतने ही समान दस्तावेज़ हो सकते हैं।

BOW की सीमाएँ

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

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

जब भी आपको आवश्यकता हो आपको BOW कोड नहीं करना है। यह पहले से ही कई उपलब्ध रूपरेखाओं का हिस्सा है जैसे कि Sci-kit सीखें।

हमारे पिछले कोड को इससे बदला जा सकता है:

Sklearn.feature_extraction.text आयात से CountVectorizer

वैक्टराइज़र = काउंटवाइज़र ()
एक्स = वेक्टराइज़र.फिट_ट्रांसफॉर्म (ऑलसेन्टेंस)

प्रिंट (X.toarray ())

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

लेख पढ़ने के लिए धन्यवाद। दिखाया गया कोड मेरे GitHub पर उपलब्ध है।

आप मुझे मीडियम, ट्विटर और लिंक्डइन पर फॉलो कर सकते हैं। किसी भी प्रश्न के लिए, आप मुझे ईमेल पर बता सकते हैं (praveend806 [at] gmail [dot] com)।

शब्दों के बैग पर अधिक पढ़ने के लिए संसाधन

  1. विकिपीडिया-धनुष
  2. बैग-ऑफ-वर्ड्स मॉडल को समझना: एक सांख्यिकीय ढांचा
  3. शब्दार्थ-संरक्षण-बैग-शब्द मॉडल और अनुप्रयोग

यह सभी देखें

अपने सभी लड़ाकू विमानों को हवा में लाने के लिए एक विमान वाहक को कितना समय लगता है? एक डोमेन की तलाश करने और एक वर्डप्रेस साइट को एक साल तक रखने में कितना खर्च होता है? डेनिअर की गणना कैसे करेंप्रोग्रेसिव वेब ऐप विकसित करना कितना अच्छा है? टेबलेट मोड विंडो 8 को कैसे बंद करेंविपणन एजेंसियां ​​खुद को बेचने और अधिक ग्राहक प्राप्त करने में अच्छी लगती हैं। लेकिन मेरा व्यवसाय (टेनिकेल) ऐसी एजेंसी को कैसे प्राप्त कर सकता है जो सुसंगत हो, शुरू करने के लिए सस्ती हो, और पैमाने पर हो?मैं अपना डिजिटल मेनू बोर्ड कैसे बना सकता हूं? मैं एक वेब डेवलपर हूं। मैं ग्राहकों के लिए काम किए बिना पैसा कैसे कमा सकता हूं?