जेनसिम - त्वरित गाइड

यह अध्याय आपको इसके उपयोग और फायदे के साथ-साथ जेनसिम के इतिहास और विशेषताओं को समझने में मदद करेगा।

जेनसिम क्या है?

Gensim = “Generate Similar”एक लोकप्रिय ओपन सोर्स नेचुरल लैंग्वेज प्रोसेसिंग (एनएलपी) लाइब्रेरी है, जिसका उपयोग अनछुए विषय मॉडलिंग के लिए किया जाता है। यह शीर्ष शैक्षणिक मॉडल और आधुनिक सांख्यिकीय मशीन सीखने का उपयोग करता है जैसे कि विभिन्न जटिल कार्यों को करने के लिए -

भवन दस्तावेज़ या शब्द वैक्टर
Corpora
विषय की पहचान करना
दस्तावेज़ तुलना करना (शब्दार्थ समान दस्तावेज़ों को प्राप्त करना)
सिमेंटिक संरचना के लिए सादा-पाठ दस्तावेजों का विश्लेषण

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

इतिहास

2008 में, जेनसिम ने चेक डिजिटल गणित के लिए विभिन्न पायथन लिपियों के संग्रह के रूप में शुरुआत की। वहाँ, यह एक विशेष दिए गए लेख के लिए सबसे समान लेख की एक छोटी सूची उत्पन्न करने के लिए कार्य किया। लेकिन 2009 में, RARE Technologies Ltd. ने अपनी प्रारंभिक रिलीज़ जारी की। फिर, बाद में जुलाई 2019 में, हमें इसकी स्थिर रिलीज़ (3.8.0) मिली।

विभिन्न विशेषताएं

गेंसिम द्वारा पेश की गई कुछ विशेषताएं और क्षमताएं निम्नलिखित हैं -

अनुमापकता

Gensim अपने वृद्धिशील ऑनलाइन प्रशिक्षण एल्गोरिदम का उपयोग करके आसानी से बड़े और वेब-स्केल कॉर्पोरा को संसाधित कर सकता है। यह प्रकृति में स्केलेबल है, क्योंकि किसी भी समय रैंडम एक्सेस मेमोरी (रैम) में पूरी तरह से निवास करने के लिए पूरे इनपुट कॉर्पस की आवश्यकता नहीं है। दूसरे शब्दों में, इसके सभी एल्गोरिदम कॉर्पस आकार के संबंध में मेमोरी-स्वतंत्र हैं।

मजबूत

Gensim प्रकृति में मजबूत है और विभिन्न लोगों द्वारा विभिन्न प्रणालियों के साथ-साथ संगठनों में 4 वर्षों से उपयोग में है। हम आसानी से अपने स्वयं के इनपुट कॉर्पस या डेटा स्ट्रीम में प्लग कर सकते हैं। अन्य वेक्टर स्पेस एल्गोरिदम के साथ विस्तार करना भी बहुत आसान है।

मंच अज्ञेय

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

कुशल मल्टीकोर कार्यान्वयन

मशीन समूहों पर प्रसंस्करण और पुनः प्राप्ति में तेजी लाने के लिए, Gensim विभिन्न लोकप्रिय एल्गोरिदम जैसे कुशल मल्टीकोर कार्यान्वयन प्रदान करता है Latent Semantic Analysis (LSA), Latent Dirichlet Allocation (LDA), Random Projections (RP), Hierarchical Dirichlet Process (HDP)।

मुक्त स्रोत और सामुदायिक सहायता की प्रचुरता

Gensim को OSI-स्वीकृत GNU LGPL लाइसेंस के तहत लाइसेंस प्राप्त है जो इसे व्यक्तिगत और साथ ही साथ वाणिज्यिक उपयोग दोनों के लिए मुफ्त में उपयोग करने की अनुमति देता है। गेंसिम में किए गए कोई भी संशोधन खुले तौर पर किए गए हैं और इसमें सामुदायिक समर्थन भी प्रचुर मात्रा में है।

Gensim का उपयोग

Gensim का उपयोग किया गया है और हजार से अधिक वाणिज्यिक और शैक्षणिक अनुप्रयोगों में उद्धृत किया गया है। यह विभिन्न शोध पत्रों और छात्र शोधों द्वारा भी उद्धृत किया गया है। इसमें निम्नलिखित के सुव्यवस्थित समानांतर कार्यान्वयन शामिल हैं -

fastText

FastText, शब्द एम्बेडिंग के लिए एक तंत्रिका नेटवर्क का उपयोग करता है, शब्द एम्बेडिंग और पाठ वर्गीकरण के सीखने के लिए एक पुस्तकालय है। इसे फेसबुक की AI रिसर्च (FAIR) लैब ने बनाया है। यह मॉडल, मूल रूप से, हमें शब्दों के लिए वेक्टर अभ्यावेदन प्राप्त करने के लिए एक पर्यवेक्षित या अनुपयोगी एल्गोरिथ्म बनाने की अनुमति देता है।

Word2vec

Word2vec, शब्द एम्बेडिंग का उत्पादन करने के लिए उपयोग किया जाता है, उथले और दो-परत तंत्रिका नेटवर्क मॉडल का एक समूह है। मॉडल को मूल रूप से शब्दों के भाषाई संदर्भों को फिर से बनाने के लिए प्रशिक्षित किया जाता है।

LSA (अव्यक्त अर्थ विश्लेषण)

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

LDA (अव्यक्त डिरिचलेट आवंटन)

यह एनएलपी में एक तकनीक है जो अप्रमाणित समूहों द्वारा व्याख्या के सेट की अनुमति देता है। ये अनयूज्ड समूह बताते हैं कि डेटा के कुछ हिस्से समान क्यों हैं। यही कारण है कि, यह एक पीढ़ीगत सांख्यिकीय मॉडल है।

tf-idf (शब्द आवृत्ति-व्युत्क्रम दस्तावेज़ आवृत्ति)

tf-idf, सूचना पुनर्प्राप्ति में एक संख्यात्मक आँकड़ा, यह दर्शाता है कि एक कोष में एक दस्तावेज के लिए एक शब्द कितना महत्वपूर्ण है। इसका उपयोग अक्सर खोज इंजन द्वारा उपयोगकर्ता क्वेरी के लिए दस्तावेज़ की प्रासंगिकता को स्कोर करने और रैंक करने के लिए किया जाता है। इसका उपयोग पाठ संक्षेप और वर्गीकरण में स्टॉप-वर्ड फ़िल्टरिंग के लिए भी किया जा सकता है।

उन सभी को अगले खंडों में विस्तार से बताया जाएगा।

लाभ

Gensim एक NLP पैकेज है जो विषय मॉडलिंग करता है। Gensim के महत्वपूर्ण लाभ इस प्रकार हैं -

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

अध्याय Gensim, इसकी मुख्य निर्भरता और इसके वर्तमान संस्करण के बारे में जानकारी स्थापित करने के लिए आवश्यक शर्तें के बारे में बताता है।

आवश्यक शर्तें

Gensim को स्थापित करने के लिए, हमें अपने कंप्यूटर पर Python स्थापित करना होगा। आप लिंक www.python.org/downloads/ पर जा सकते हैं और अपने ओएस यानी विंडोज और लिनक्स / यूनिक्स के लिए नवीनतम संस्करण का चयन कर सकते हैं । आप पायथन पर बुनियादी ट्यूटोरियल के लिए लिंक www.tutorialspoint.com/python3/index.htm का उल्लेख कर सकते हैं । Gensim लिनक्स, विंडोज और मैक ओएस एक्स के लिए समर्थित है।

कोड निर्भरता

गेंसिम को किसी भी प्लेटफ़ॉर्म पर चलना चाहिए जो समर्थन करता है Python 2.7 or 3.5+ तथा NumPy। यह वास्तव में निम्नलिखित सॉफ्टवेयर पर निर्भर करता है -

अजगर

गेन्सिम का परीक्षण पायथन संस्करणों 2.7, 3.5, 3.6 और 3.7 के साथ किया गया है।

Numpy

जैसा कि हम जानते हैं कि, NumPy पायथन के साथ वैज्ञानिक कंप्यूटिंग के लिए एक पैकेज है। यह जेनेरिक डेटा के कुशल बहुआयामी कंटेनर के रूप में भी इस्तेमाल किया जा सकता है। Gensim नंबर क्रंचिंग के लिए NumPy पैकेज पर निर्भर करता है। पायथन पर बुनियादी ट्यूटोरियल के लिए, आप लिंक www.tutorialspoint.com/numpy/index.htm का उल्लेख कर सकते हैं ।

smart_open

smart_open, Python 2 और Python 3 लाइब्रेरी, का उपयोग बहुत बड़ी फ़ाइलों की कुशल स्ट्रीमिंग के लिए किया जाता है। यह S3, HDFS, WebHDFS, HTTP, HTTPS, SFTP, या स्थानीय फाइल सिस्टम जैसे स्टोरेज / से स्ट्रीमिंग का समर्थन करता है। गेंसिम पर निर्भर करता हैsmart_open दूरस्थ भंडारण के साथ-साथ संपीड़ित फ़ाइलों को पारदर्शी रूप से खोलने के लिए पायथन लाइब्रेरी।

वर्तमान संस्करण

Gensim का वर्तमान संस्करण है 3.8.0 जो जुलाई 2019 में रिलीज़ हुई थी।

टर्मिनल का उपयोग कर स्थापित करना

Gensim को स्थापित करने के सबसे सरल तरीकों में से एक, अपने टर्मिनल में निम्न कमांड को चलाना है -

pip install --upgrade gensim

Conda पर्यावरण का उपयोग कर स्थापित करना

Gensim डाउनलोड करने का एक वैकल्पिक तरीका है, उपयोग करना condaवातावरण। अपने में निम्न कमांड चलाएँconda टर्मिनल -

conda install –c conda-forge gensim

स्रोत पैकेज का उपयोग कर स्थापित करना

मान लीजिए, यदि आपने स्रोत पैकेज को डाउनलोड और अनज़िप कर लिया है, तो आपको निम्न कमांड चलाने की आवश्यकता है -

python setup.py test
python setup.py install

यहाँ, हम Gensim की मुख्य अवधारणाओं के बारे में जानेंगे, जो दस्तावेजों और कॉर्पस पर मुख्य ध्यान केंद्रित करेंगे।

कोर कॉन्सेप्ट ऑफ गेन्सिम

Gensim को समझने और उपयोग करने के लिए आवश्यक मुख्य अवधारणाएँ और शर्तें निम्नलिखित हैं -

Document - ZIt कुछ पाठ को संदर्भित करता है।
Corpus - यह दस्तावेजों के संग्रह को संदर्भित करता है।
Vector - एक दस्तावेज के गणितीय प्रतिनिधित्व को वेक्टर कहा जाता है।
Model - यह वैक्टर को एक प्रतिनिधित्व से दूसरे में बदलने के लिए उपयोग किए जाने वाले एल्गोरिदम को संदर्भित करता है।

दस्तावेज़ क्या है?

जैसा कि चर्चा की गई है, यह कुछ पाठ को संदर्भित करता है। यदि हम कुछ विस्तार से जाते हैं, तो यह पाठ अनुक्रम प्रकार का एक ऑब्जेक्ट है जिसे के रूप में जाना जाता है‘str’ अजगर में 3. उदाहरण के लिए, जेनसिम में, एक दस्तावेज कुछ भी हो सकता है जैसे कि -

140 अक्षरों का लघु ट्वीट
एकल अनुच्छेद, यानी लेख या शोध पत्र सार
समाचार लेख
Book
Novel
Theses

पाठ अनुक्रम

एक पाठ अनुक्रम प्रकार आमतौर पर के रूप में जाना जाता है ‘str’ पाइथन में 3. जैसा कि हम जानते हैं कि पाइथन में, शाब्दिक डेटा को स्ट्रिंग्स या अधिक विशेष रूप से संभाला जाता है ‘str’वस्तुओं। स्ट्रिंग्स मूल रूप से यूनिकोड कोड बिंदुओं के अपरिवर्तनीय अनुक्रम हैं और इन्हें निम्नलिखित तरीकों से लिखा जा सकता है -

Single quotes - उदाहरण के लिए, ‘Hi! How are you?’। यह हमें दोहरे उद्धरण चिह्नों को भी एम्बेड करने की अनुमति देता है। उदाहरण के लिए,‘Hi! “How” are you?’
Double quotes - उदाहरण के लिए, "Hi! How are you?"। यह हमें सिंगल कोट्स को भी एम्बेड करने की अनुमति देता है। उदाहरण के लिए,"Hi! 'How' are you?"
Triple quotes - यह या तो तीन एकल उद्धरण की तरह हो सकता है, '''Hi! How are you?'''। या तीन दोहरे उद्धरण जैसे,"""Hi! 'How' are you?"""

सभी व्हाट्सएप को स्ट्रिंग शाब्दिक में शामिल किया जाएगा।

उदाहरण

Gensim में दस्तावेज़ का एक उदाहरण निम्नलिखित है -

Document = “Tutorialspoint.com is the biggest online tutorials library and it’s all free also”

कॉर्पस क्या है?

एक कॉर्पस को प्राकृतिक संचार सेटिंग में उत्पादित मशीन-पठनीय ग्रंथों के बड़े और संरचित सेट के रूप में परिभाषित किया जा सकता है। जेनसिम में, दस्तावेज़ ऑब्जेक्ट के संग्रह को कॉर्पस कहा जाता है। कॉर्पस का बहुवचन हैcorpora।

गेंसिम में कॉर्पस की भूमिका

Gensim में एक कॉर्पस निम्नलिखित दो भूमिकाओं में कार्य करता है -

प्रशिक्षण के लिए एक मॉडल के रूप में कार्य करता है

गेंसिम में एक कॉरपस की भूमिका निभाने वाली पहली और महत्वपूर्ण भूमिका, एक मॉडल को प्रशिक्षित करने के लिए एक इनपुट के रूप में है। प्रशिक्षण के दौरान मॉडल के आंतरिक मापदंडों को शुरू करने के लिए, मॉडल प्रशिक्षण कॉरपस से कुछ सामान्य विषयों और विषयों की तलाश करता है। जैसा कि ऊपर चर्चा की गई है, जेनसिम अनसुनी मॉडल पर केंद्रित है, इसलिए इसे किसी भी प्रकार के मानवीय हस्तक्षेप की आवश्यकता नहीं है।

विषय चिमटा के रूप में कार्य करता है

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

उदाहरण

कॉर्पस में किसी व्यक्ति विशेष के सभी ट्वीट, किसी अखबार के सभी लेखों की सूची या किसी विशेष वेबसाइट पर सभी शोध पत्र आदि शामिल हो सकते हैं।

कॉर्पस एकत्रित करना

निम्नलिखित छोटे कॉर्पस का एक उदाहरण है जिसमें 5 दस्तावेज़ शामिल हैं। यहां, प्रत्येक दस्तावेज़ एक वाक्य से युक्त एक स्ट्रिंग है।

t_corpus = [
   "A survey of user opinion of computer system response time",
   "Relation of user perceived response time to error measurement",
   "The generation of random binary unordered trees",
   "The intersection graph of paths in trees",
   "Graph minors IV Widths of trees and well quasi ordering",
]

प्रीप्रोसेसिंग कलेक्टिंग कॉर्पस

एक बार जब हम कॉर्पस को इकट्ठा करते हैं, तो कॉरपस को सरल रखने के लिए कुछ प्रीप्रोसेसिंग कदम उठाए जाने चाहिए। हम 'अंग्रेजी' जैसे कुछ सामान्य रूप से उपयोग किए जाने वाले अंग्रेजी शब्दों को हटा सकते हैं। हम उन शब्दों को भी हटा सकते हैं जो केवल एक बार कॉर्पस में होते हैं।

उदाहरण के लिए, निम्नलिखित पायथन लिपि का उपयोग प्रत्येक दस्तावेज़ को कम करने के लिए किया जाता है, इसे सफेद स्थान से विभाजित करें और स्टॉप वर्ड को फ़िल्टर करें -

उदाहरण

import pprint
t_corpus = [
   "A survey of user opinion of computer system response time", 
   "Relation of user perceived response time to error measurement", 
   "The generation of random binary unordered trees", 
   "The intersection graph of paths in trees", 
   "Graph minors IV Widths of trees and well quasi ordering",
]
stoplist = set('for a of the and to in'.split(' '))
processed_corpus = [[word for word in document.lower().split() if word not in stoplist]
   for document in t_corpus]
	
pprint.pprint(processed_corpus)
]

उत्पादन

[['survey', 'user', 'opinion', 'computer', 'system', 'response', 'time'],
['relation', 'user', 'perceived', 'response', 'time', 'error', 'measurement'],
['generation', 'random', 'binary', 'unordered', 'trees'],
['intersection', 'graph', 'paths', 'trees'],
['graph', 'minors', 'iv', 'widths', 'trees', 'well', 'quasi', 'ordering']]

प्रभावी प्रीप्रोसेसिंग

गेंसिम भी कॉर्पस के अधिक प्रभावी प्रीप्रोसेसिंग के लिए कार्य प्रदान करता है। इस तरह के प्रीप्रोसेसिंग में, हम एक दस्तावेज को लोअरकेस टोकन की सूची में बदल सकते हैं। हम उन टोकन को भी अनदेखा कर सकते हैं जो बहुत कम या बहुत लंबे हैं। ऐसा समारोह हैgensim.utils.simple_preprocess(doc, deacc=False, min_len=2, max_len=15)।

gensim.utils.simple_preprocess() fucntion

गेन्सिम इस फ़ंक्शन को एक दस्तावेज़ को लोअरकेस टोकन की एक सूची में बदलने के लिए प्रदान करता है और टोकन की अनदेखी के लिए बहुत छोटा या बहुत लंबा है। इसके निम्न पैरामीटर हैं -

डॉक (एसटीआर)

यह इनपुट दस्तावेज को संदर्भित करता है जिस पर प्रीप्रोसेसिंग लागू किया जाना चाहिए।

बधिया (बूल, वैकल्पिक)

इस पैरामीटर का उपयोग टोकन से उच्चारण चिह्न को हटाने के लिए किया जाता है। यह उपयोगकर्ता हैdeaccent() यह करने के लिए।

min_len (int, वैकल्पिक)

इस पैरामीटर की मदद से, हम एक टोकन की न्यूनतम लंबाई निर्धारित कर सकते हैं। निर्धारित लंबाई से कम टोकन को छोड़ दिया जाएगा।

अधिकतम_लेन (int, वैकल्पिक)

इस पैरामीटर की मदद से हम एक टोकन की अधिकतम लंबाई निर्धारित कर सकते हैं। निर्धारित लंबाई से अधिक टोकन को छोड़ दिया जाएगा।

इस फ़ंक्शन का आउटपुट इनपुट दस्तावेज़ से निकाले गए टोकन होंगे।

यहाँ, हम Gensim की मुख्य अवधारणाओं के बारे में जानेंगे, जिसमें वेक्टर और मॉडल पर मुख्य ध्यान दिया जाएगा।

वेक्टर क्या है?

क्या होगा यदि हम अपने कॉर्पस में अव्यक्त संरचना का अनुमान लगाना चाहते हैं? इसके लिए, हमें दस्तावेजों का इस तरह से प्रतिनिधित्व करने की आवश्यकता है कि हम उसी गणितीय रूप से हेरफेर कर सकें। एक लोकप्रिय प्रकार का प्रतिनिधित्व सुविधाओं के वेक्टर के रूप में कॉर्पस के प्रत्येक दस्तावेज़ का प्रतिनिधित्व करना है। इसलिए हम कह सकते हैं कि वेक्टर एक दस्तावेज़ का गणितीय सुविधाजनक प्रतिनिधित्व है।

आपको एक उदाहरण देने के लिए, आइए एक उपर्युक्त कॉर्पस के रूप में, क्यूए जोड़ी के रूप में, एक ही विशेषता का प्रतिनिधित्व करते हैं -

Q - शब्द कितनी बार करता है Hello दस्तावेज़ में दिखाई देते हैं?

A - शून्य (को ०)।

Q - दस्तावेज़ में कितने पैराग्राफ हैं?

A - दो (2)

प्रश्न आम तौर पर इसकी पूर्णांक आईडी द्वारा दर्शाया जाता है, इसलिए इस दस्तावेज़ का प्रतिनिधित्व जोड़े की एक श्रृंखला है (1, 0.0), (2, 2.0)। इस तरह के वेक्टर प्रतिनिधित्व को एक के रूप में जाना जाता हैdenseवेक्टर। क्योंdense, क्योंकि इसमें ऊपर लिखे गए सभी प्रश्नों का स्पष्ट उत्तर शामिल है।

प्रतिनिधित्व एक सरल (0, 2) की तरह हो सकता है, अगर हम सभी प्रश्नों को पहले से जानते हैं। उत्तर का ऐसा क्रम (यदि प्रश्न पहले से ज्ञात हो)vector हमारे दस्तावेज़ के लिए।

एक और लोकप्रिय प्रकार का प्रतिनिधित्व है bag-of-word (BoW)नमूना। इस दृष्टिकोण में, प्रत्येक दस्तावेज़ मूल रूप से एक वेक्टर द्वारा दर्शाया जाता है जिसमें शब्दकोश में हर शब्द की आवृत्ति गणना होती है।

आपको एक उदाहरण देने के लिए, मान लीजिए कि हमारे पास एक शब्दकोष है जिसमें '' हैलो ',' कैसे ',' हैं ',' आप '] शब्द हैं। स्ट्रिंग से युक्त एक दस्तावेज़ "आप कैसे हैं" तब वेक्टर [0, 2, 1, 1] द्वारा दर्शाया जाएगा। यहां, वेक्टर की प्रविष्टियां "हैलो", "हाउ", "हैं" और "आप" की घटनाओं के क्रम में हैं।

वेक्टर बनाम दस्तावेज़

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

उदाहरण के लिए, मान लीजिए कि हमारे पास कुछ मनमाना दस्तावेज़ है, तो कहने के बजाय, "वेक्टर जो दस्तावेज़ A के अनुरूप है", वे कहते थे, "वेक्टर A" या "दस्तावेज़ A"। इससे बड़ी अस्पष्टता होती है। यहां एक और महत्वपूर्ण बात ध्यान देने वाली है कि, दो अलग-अलग दस्तावेजों में एक ही वेक्टर प्रतिनिधित्व हो सकता है।

वैक्टर की सूची में कॉर्पस परिवर्तित करना

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

उदाहरण

from gensim import corpora
dictionary = corpora.Dictionary(processed_corpus)
print(dictionary)

उत्पादन

Dictionary(25 unique tokens: ['computer', 'opinion', 'response', 'survey', 'system']...)

यह दर्शाता है कि हमारे कॉर्पस में 25 अलग-अलग टोकन हैं gensim.corpora.Dictionary।

कार्यान्वयन उदाहरण

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

pprint.pprint(dictionary.token2id)

उत्पादन

{
   'binary': 11,
   'computer': 0,
   'error': 7,
   'generation': 12,
   'graph': 16,
   'intersection': 17,
   'iv': 19,
   'measurement': 8,
   'minors': 20,
   'opinion': 1,
   'ordering': 21,
   'paths': 18,
   'perceived': 9,
   'quasi': 22,
   'random': 13,
   'relation': 10,
   'response': 2,
   'survey': 3,
   'system': 4,
   'time': 5,
   'trees': 14,
   'unordered': 15,
   'user': 6,
   'well': 23,
   'widths': 24
}

और इसी तरह, हम एक दस्तावेज़ के लिए बैग-ऑफ-वर्ड प्रतिनिधित्व बना सकते हैं -

BoW_corpus = [dictionary.doc2bow(text) for text in processed_corpus]
pprint.pprint(BoW_corpus)

उत्पादन

[
   [(0, 1), (1, 1), (2, 1), (3, 1), (4, 1), (5, 1), (6, 1)],
   [(2, 1), (5, 1), (6, 1), (7, 1), (8, 1), (9, 1), (10, 1)],
   [(11, 1), (12, 1), (13, 1), (14, 1), (15, 1)],
   [(14, 1), (16, 1), (17, 1), (18, 1)],
   [(14, 1), (16, 1), (19, 1), (20, 1), (21, 1), (22, 1), (23, 1), (24, 1)]
]

मॉडल क्या है?

एक बार जब हमने कॉर्पस को सदिश कर दिया है, तो आगे क्या? अब, हम इसे मॉडल का उपयोग करके बदल सकते हैं। मॉडल को एक दस्तावेज़ प्रतिनिधित्व को दूसरे में बदलने के लिए उपयोग किए जाने वाले एल्गोरिदम के लिए भेजा जा सकता है।

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

एक मॉडल की शुरुआत

आइए आरंभ करते हैं tf-idfनमूना। यह मॉडल BoW (शब्दों के थैले) से वैक्टर को एक अन्य वेक्टर स्थान में बदल देता है, जहां आवृत्ति गणना को कॉर्पस में प्रत्येक शब्द की सापेक्ष दुर्लभता के अनुसार भारित किया जाता है।

कार्यान्वयन उदाहरण

निम्नलिखित उदाहरण में, हम इनिशियलाइज़ करने जा रहे हैं tf-idfनमूना। हम इसे अपने कॉर्पस पर प्रशिक्षित करेंगे और फिर स्ट्रिंग "ट्री ग्राफ" को रूपांतरित करेंगे।

उदाहरण

from gensim import models
tfidf = models.TfidfModel(BoW_corpus)
words = "trees graph".lower().split()
print(tfidf[dictionary.doc2bow(words)])

उत्पादन

[(3, 0.4869354917707381), (4, 0.8734379353188121)]

अब, एक बार जब हमने मॉडल बना लिया, तो हम पूरे कॉर्पस को tfidf के माध्यम से बदल सकते हैं और इसे अनुक्रमित कर सकते हैं, और हमारे क्वेरी दस्तावेज़ की समानता (हम क्वेरी दस्तावेज़ 'ट्री सिस्टम' दे रहे हैं) को कॉर्पस में प्रत्येक दस्तावेज़ के विरुद्ध बदल सकते हैं -

उदाहरण

from gensim import similarities
index = similarities.SparseMatrixSimilarity(tfidf[BoW_corpus],num_features=5)
query_document = 'trees system'.split()
query_bow = dictionary.doc2bow(query_document)
simils = index[tfidf[query_bow]]
print(list(enumerate(simils)))

उत्पादन

[(0, 0.0), (1, 0.0), (2, 1.0), (3, 0.4869355), (4, 0.4869355)]

उपरोक्त आउटपुट से, दस्तावेज़ 4 और दस्तावेज़ 5 में लगभग 49% की समानता स्कोर है।

इसके अलावा, हम इस आउटपुट को अधिक पठनीयता के लिए भी सॉर्ट कर सकते हैं -

उदाहरण

for doc_number, score in sorted(enumerate(sims), key=lambda x: x[1], reverse=True):
   print(doc_number, score)

उत्पादन

2 1.0
3 0.4869355
4 0.4869355
0 0.0
1 0.0

पिछले अध्याय में जहां हमने वेक्टर और मॉडल के बारे में चर्चा की, आपको शब्दकोश के बारे में एक विचार मिला। यहां, हम चर्चा करने जा रहे हैंDictionary वस्तु थोड़ा और विस्तार से।

डिक्शनरी क्या है?

शब्दकोश की अवधारणा में गहरी डुबकी लगाने से पहले, आइए कुछ सरल एनएलपी अवधारणाओं को समझते हैं -

Token - टोकन का मतलब एक 'शब्द' होता है।
Document - एक दस्तावेज एक वाक्य या पैराग्राफ को संदर्भित करता है।
Corpus - यह शब्दों के एक बैग (BoW) के रूप में दस्तावेजों के संग्रह को संदर्भित करता है।

सभी दस्तावेजों के लिए, एक कॉर्पस में हमेशा दस्तावेज़ में इसकी आवृत्ति गणना के साथ प्रत्येक शब्द की टोकन आईडी होती है।

चलो गेंसिम में शब्दकोश की अवधारणा पर चलते हैं। टेक्स्ट डॉक्यूमेंट्स पर काम करने के लिए, गेंसिम को भी शब्दों की आवश्यकता होती है, अर्थात टोकन को अपने यूनिक आईडी में बदलना होगा। इसे प्राप्त करने के लिए, यह हमें सुविधा प्रदान करता हैDictionary object, जो प्रत्येक शब्द को अपनी विशिष्ट पूर्णांक आईडी में मैप करता है। यह इनपुट टेक्स्ट को शब्दों की सूची में परिवर्तित करके और फिर इसे पास करने के लिए करता हैcorpora.Dictionary() वस्तु।

शब्दकोश की जरूरत है

अब प्रश्न यह उठता है कि वास्तव में डिक्शनरी ऑब्जेक्ट की आवश्यकता क्या है और इसका उपयोग कहाँ किया जा सकता है? Gensim में, डिक्शनरी ऑब्जेक्ट का उपयोग शब्दों के एक बैग (BoW) कॉर्पस को बनाने के लिए किया जाता है जो आगे मॉडलिंग और अन्य मॉडलों के विषय के लिए इनपुट के रूप में उपयोग किया जाता है।

पाठ इनपुट के रूप

इनपुट पाठ के तीन अलग-अलग रूप हैं, हम गेंसिम को प्रदान कर सकते हैं -

जैसा कि पायथन की मूल सूची ऑब्जेक्ट में संग्रहीत वाक्य (के रूप में जाना जाता है str पायथन 3 में)
एक एकल पाठ फ़ाइल के रूप में (छोटी या बड़ी हो सकती है)
एकाधिक पाठ फ़ाइलें

Gensim का उपयोग करके एक शब्दकोश बनाना

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

वाक्य की सूची से

निम्नलिखित उदाहरण में हम वाक्यों की सूची से शब्दकोश बनाने वाले हैं। जब हमारे पास वाक्यों की सूची होती है या आप कई वाक्य कह सकते हैं, तो हमें हर वाक्य को शब्दों की सूची में बदलना चाहिए और यह समझने के लिए बहुत ही सामान्य तरीकों में से एक है।

कार्यान्वयन उदाहरण

सबसे पहले, आवश्यक और आवश्यक पैकेजों को निम्नानुसार आयात करें -

import gensim
from gensim import corpora
from pprint import pprint

इसके बाद, शब्दकोश बनाने के लिए वाक्यों / दस्तावेज़ों की सूची से समझ की सूची बनाएं -

doc = [
   "CNTK formerly known as Computational Network Toolkit",
   "is a free easy-to-use open-source commercial-grade toolkit",
   "that enable us to train deep learning algorithms to learn like the human brain."
]

अगला, हमें वाक्यों को शब्दों में विभाजित करने की आवश्यकता है। इसे टोकनेशन कहा जाता है।

text_tokens = [[text for text in doc.split()] for doc in doc]

अब, निम्नलिखित स्क्रिप्ट की मदद से, हम शब्दकोश बना सकते हैं -

dict_LoS = corpora.Dictionary(text_tokens)

अब कुछ और जानकारी प्राप्त करते हैं जैसे कि शब्दकोश में टोकन की संख्या -

print(dict_LoS)

उत्पादन

Dictionary(27 unique tokens: ['CNTK', 'Computational', 'Network', 'Toolkit', 'as']...)

हम निम्न पूर्णांक मानचित्रण के लिए शब्द भी देख सकते हैं -

print(dict_LoS.token2id)

उत्पादन

{
   'CNTK': 0, 'Computational': 1, 'Network': 2, 'Toolkit': 3, 'as': 4, 
   'formerly': 5, 'known': 6, 'a': 7, 'commercial-grade': 8, 'easy-to-use': 9,
   'free': 10, 'is': 11, 'open-source': 12, 'toolkit': 13, 'algorithms': 14,
   'brain.': 15, 'deep': 16, 'enable': 17, 'human': 18, 'learn': 19, 'learning': 20,
   'like': 21, 'that': 22, 'the': 23, 'to': 24, 'train': 25, 'us': 26
}

पूर्ण कार्यान्वयन उदाहरण

import gensim
from gensim import corpora
from pprint import pprint
doc = [
   "CNTK formerly known as Computational Network Toolkit",
   "is a free easy-to-use open-source commercial-grade toolkit",
   "that enable us to train deep learning algorithms to learn like the human brain."
]
text_tokens = [[text for text in doc.split()] for doc in doc]
dict_LoS = corpora.Dictionary(text_tokens)
print(dict_LoS.token2id)

सिंगल टेक्स्ट फाइल से

निम्नलिखित उदाहरण में हम एक एकल पाठ फ़ाइल से शब्दकोश बना रहे हैं। इसी तरह से, हम एक से अधिक पाठ फ़ाइलों (यानी फ़ाइलों की निर्देशिका) से भी शब्दकोश बना सकते हैं।

इसके लिए, हमने पिछले उदाहरण में उपयोग किए गए दस्तावेज़ को सहेजा है, जिसका नाम टेक्स्ट फ़ाइल में है doc.txt। Gensim फ़ाइल लाइन को लाइन से पढ़ेगा और एक बार में एक लाइन का उपयोग करके प्रोसेस करेगाsimple_preprocess। इस तरह, इसे एक बार में पूरी फ़ाइल को मेमोरी में लोड करने की आवश्यकता नहीं है।

कार्यान्वयन उदाहरण

सबसे पहले, आवश्यक और आवश्यक पैकेजों को निम्नानुसार आयात करें -

import gensim
from gensim import corpora
from pprint import pprint
from gensim.utils import simple_preprocess
from smart_open import smart_open
import os

कोड की अगली पंक्ति doc.txt नाम की एकल पाठ फ़ाइल का उपयोग करके gensim शब्दकोश बनाएगी -

dict_STF = corpora.Dictionary(
   simple_preprocess(line, deacc =True) for line in open(‘doc.txt’, encoding=’utf-8’)
)

अब कुछ और जानकारी प्राप्त करते हैं जैसे कि शब्दकोश में टोकन की संख्या -

print(dict_STF)

उत्पादन

Dictionary(27 unique tokens: ['CNTK', 'Computational', 'Network', 'Toolkit', 'as']...)

हम निम्न पूर्णांक मानचित्रण के लिए शब्द भी देख सकते हैं -

print(dict_STF.token2id)

उत्पादन

{
   'CNTK': 0, 'Computational': 1, 'Network': 2, 'Toolkit': 3, 'as': 4, 
   'formerly': 5, 'known': 6, 'a': 7, 'commercial-grade': 8, 'easy-to-use': 9, 
   'free': 10, 'is': 11, 'open-source': 12, 'toolkit': 13, 'algorithms': 14, 
   'brain.': 15, 'deep': 16, 'enable': 17, 'human': 18, 'learn': 19, 
   'learning': 20, 'like': 21, 'that': 22, 'the': 23, 'to': 24, 'train': 25, 'us': 26
}

पूर्ण कार्यान्वयन उदाहरण

import gensim
from gensim import corpora
from pprint import pprint
from gensim.utils import simple_preprocess
from smart_open import smart_open
import os
dict_STF = corpora.Dictionary(
   simple_preprocess(line, deacc =True) for line in open(‘doc.txt’, encoding=’utf-8’)
)
dict_STF = corpora.Dictionary(text_tokens)
print(dict_STF.token2id)

एकाधिक पाठ फ़ाइलों से

अब कई फ़ाइलों से शब्दकोश बनाते हैं, यानी एक ही निर्देशिका में एक से अधिक पाठ फ़ाइल सहेजी गई हैं। इस उदाहरण के लिए, हमने तीन अलग-अलग पाठ फ़ाइलें बनाई हैंfirst.txt, second.txt तथा third.txtपाठ फ़ाइल (doc.txt) से तीन पंक्तियों वाले, हमने पिछले उदाहरण के लिए उपयोग किया था। इन तीनों टेक्स्ट फ़ाइलों को एक डायरेक्टरी नाम से सेव किया गया हैABC।

कार्यान्वयन उदाहरण

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

नाम की कक्षा को परिभाषित करते हैं Read_files __ नामक एक विधि हैiteration__ () निम्नानुसार है -

class Read_files(object):
   def __init__(self, directoryname):
      elf.directoryname = directoryname
   def __iter__(self):
      for fname in os.listdir(self.directoryname):
         for line in open(os.path.join(self.directoryname, fname), encoding='latin'):
   yield simple_preprocess(line)

अगला, हमें निर्देशिका का मार्ग निम्नानुसार प्रदान करना होगा -

path = "ABC"

#provide the path as per your computer system where you saved the directory।

अगले चरण भी वैसे ही हैं जैसे हमने पिछले उदाहरणों में दिए थे। कोड की अगली पंक्ति तीन पाठ फ़ाइलों वाली निर्देशिका का उपयोग करके जेनसिम निर्देशिका बनाएगी -

dict_MUL = corpora.Dictionary(Read_files(path))

उत्पादन

Dictionary(27 unique tokens: ['CNTK', 'Computational', 'Network', 'Toolkit', 'as']...)

अब हम इस शब्द को अद्वितीय पूर्णांक मानचित्रण के रूप में भी देख सकते हैं -

print(dict_MUL.token2id)

उत्पादन

{
   'CNTK': 0, 'Computational': 1, 'Network': 2, 'Toolkit': 3, 'as': 4, 
   'formerly': 5, 'known': 6, 'a': 7, 'commercial-grade': 8, 'easy-to-use': 9, 
   'free': 10, 'is': 11, 'open-source': 12, 'toolkit': 13, 'algorithms': 14, 
   'brain.': 15, 'deep': 16, 'enable': 17, 'human': 18, 'learn': 19, 
   'learning': 20, 'like': 21, 'that': 22, 'the': 23, 'to': 24, 'train': 25, 'us': 26
}

बचत और एक Gensim शब्दकोश लोड हो रहा है

जेनसिम अपने मूल निवासी का समर्थन करते हैं save() डिस्क में शब्दकोश को बचाने के लिए विधि और load() डिस्क से वापस शब्दकोश लोड करने की विधि।

उदाहरण के लिए, हम निम्नलिखित स्क्रिप्ट की मदद से शब्दकोश को बचा सकते हैं -

Gensim.corpora.dictionary.save(filename)

#provide the path where you want to save the dictionary।

इसी तरह, हम लोड () पद्धति का उपयोग करके सहेजे गए शब्दकोश को लोड कर सकते हैं। निम्नलिखित स्क्रिप्ट ऐसा कर सकती है -

Gensim.corpora.dictionary.load(filename)

#provide the path where you have saved the dictionary.

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

एक BoW कॉर्पस बनाना

जैसा कि चर्चा की गई है, गेंसिम में, कॉर्पस में प्रत्येक दस्तावेज में आईडी शब्द और इसकी आवृत्ति शामिल है। हम दस्तावेजों की एक सरल सूची और पाठ फ़ाइलों से एक BoW कॉर्पस बना सकते हैं। हमें क्या करने की आवश्यकता है, नाम की वस्तु को शब्दों की टोकन सूची पास करने के लिएDictionary.doc2bow()। तो पहले, चलो दस्तावेजों की एक सरल सूची का उपयोग करके BoW कॉर्पस बनाकर शुरू करते हैं।

वाक्य की एक सरल सूची से

निम्नलिखित उदाहरण में, हम एक साधारण सूची से BoW कॉर्पस बनाएंगे जिसमें तीन वाक्य होंगे।

सबसे पहले, हमें सभी आवश्यक पैकेजों को निम्नानुसार आयात करना होगा -

import gensim
import pprint
from gensim import corpora
from gensim.utils import simple_preprocess

अब सूची युक्त वाक्य प्रदान करें। हमारी सूची में तीन वाक्य हैं -

doc_list = [
   "Hello, how are you?", "How do you do?", 
   "Hey what are you doing? yes you What are you doing?"
]

इसके बाद, वाक्यों का टोकन निम्नानुसार करें -

doc_tokenized = [simple_preprocess(doc) for doc in doc_list]

का एक ऑब्जेक्ट बनाएँ corpora.Dictionary() निम्नानुसार है -

dictionary = corpora.Dictionary()

अब इन टोकन वाक्यों को पास करें dictionary.doc2bow() objectनिम्नानुसार है -

BoW_corpus = [dictionary.doc2bow(doc, allow_update=True) for doc in doc_tokenized]

आखिरकार हम शब्द कोष के बैग को प्रिंट कर सकते हैं -

print(BoW_corpus)

उत्पादन

[
   [(0, 1), (1, 1), (2, 1), (3, 1)], 
   [(2, 1), (3, 1), (4, 2)], [(0, 2), (3, 3), (5, 2), (6, 1), (7, 2), (8, 1)]
]

उपरोक्त आउटपुट से पता चलता है कि आईडी = 0 वाला शब्द पहले दस्तावेज़ में एक बार दिखाई देता है (क्योंकि हमें आउटपुट में 0,1 मिला है) और इसी तरह।

उपरोक्त आउटपुट किसी तरह मनुष्य के लिए पढ़ना संभव नहीं है। हम इन id को शब्दों में भी बदल सकते हैं लेकिन इसके लिए हमें अपने शब्दकोश को रूपांतरित करने की आवश्यकता है -

id_words = [[(dictionary[id], count) for id, count in line] for line in BoW_corpus]
print(id_words)

उत्पादन

[
   [('are', 1), ('hello', 1), ('how', 1), ('you', 1)], 
   [('how', 1), ('you', 1), ('do', 2)], 
   [('are', 2), ('you', 3), ('doing', 2), ('hey', 1), ('what', 2), ('yes', 1)]
]

अब उपरोक्त आउटपुट किसी तरह मानव पठनीय है।

पूर्ण कार्यान्वयन उदाहरण

import gensim
import pprint
from gensim import corpora
from gensim.utils import simple_preprocess
doc_list = [
   "Hello, how are you?", "How do you do?", 
   "Hey what are you doing? yes you What are you doing?"
]
doc_tokenized = [simple_preprocess(doc) for doc in doc_list]
dictionary = corpora.Dictionary()
BoW_corpus = [dictionary.doc2bow(doc, allow_update=True) for doc in doc_tokenized]
print(BoW_corpus)
id_words = [[(dictionary[id], count) for id, count in line] for line in BoW_corpus]
print(id_words)

एक पाठ फ़ाइल से

निम्नलिखित उदाहरण में, हम एक टेक्स्ट फ़ाइल से BoW कॉर्पस बना रहे हैं। इसके लिए, हमने पिछले उदाहरण में प्रयुक्त दस्तावेज़ को सहेजा है, जिसका नाम टेक्स्ट फ़ाइल में हैdoc.txt.।

Gensim फ़ाइल लाइन को लाइन से पढ़ेगा और एक बार में एक लाइन का उपयोग करके प्रोसेस करेगा simple_preprocess। इस तरह, इसे एक बार में पूरी फ़ाइल को मेमोरी में लोड करने की आवश्यकता नहीं है।

कार्यान्वयन उदाहरण

सबसे पहले, आवश्यक और आवश्यक पैकेजों को निम्नानुसार आयात करें -

import gensim
from gensim import corpora
from pprint import pprint
from gensim.utils import simple_preprocess
from smart_open import smart_open
import os

अगला, कोड की निम्नलिखित पंक्ति doc.txt से दस्तावेजों को पढ़ेगी और इसे टोकन देगी -

doc_tokenized = [
   simple_preprocess(line, deacc =True) for line in open(‘doc.txt’, encoding=’utf-8’)
]
dictionary = corpora.Dictionary()

अब हमें इन टोकन शब्दों को पारित करने की आवश्यकता है dictionary.doc2bow() ऑब्जेक्ट (जैसा कि पिछले उदाहरण में किया गया था)

BoW_corpus = [
   dictionary.doc2bow(doc, allow_update=True) for doc in doc_tokenized
]
print(BoW_corpus)

उत्पादन

[
   [(9, 1), (10, 1), (11, 1), (12, 1), (13, 1), (14, 1), (15, 1)], 
   [
      (15, 1), (16, 1), (17, 1), (18, 1), (19, 1), (20, 1), (21, 1), 
      (22, 1), (23, 1), (24, 1)
   ], 
   [
      (23, 2), (25, 1), (26, 1), (27, 1), (28, 1), (29, 1), 
      (30, 1), (31, 1), (32, 1), (33, 1), (34, 1), (35, 1), (36, 1)
   ], 
   [(3, 1), (18, 1), (37, 1), (38, 1), (39, 1), (40, 1), (41, 1), (42, 1), (43, 1)], 
   [
      (18, 1), (27, 1), (31, 2), (32, 1), (38, 1), (41, 1), (43, 1), 
      (44, 1), (45, 1), (46, 1), (47, 1), (48, 1), (49, 1), (50, 1), (51, 1), (52, 1)
   ]
]

doc.txt फ़ाइल में निम्न सामग्री है -

CNTK जिसे पहले कम्प्यूटेशनल नेटवर्क टूलकिट के रूप में जाना जाता है, एक मुक्त उपयोग में आसान ओपन-सोर्स कमर्शियल-ग्रेड टूलकिट है जो हमें मानव मस्तिष्क की तरह सीखने के लिए गहन शिक्षण एल्गोरिदम को प्रशिक्षित करने में सक्षम बनाता है।

आप इसके मुक्त ट्यूटोरियल को tutorialspoint.com पर पा सकते हैं, जो कि एआई डीप लर्निंग मशीन लर्निंग जैसी तकनीकों पर सर्वश्रेष्ठ तकनीकी ट्यूटोरियल प्रदान करते हैं।

पूर्ण कार्यान्वयन उदाहरण

import gensim
from gensim import corpora
from pprint import pprint
from gensim.utils import simple_preprocess
from smart_open import smart_open
import os
doc_tokenized = [
   simple_preprocess(line, deacc =True) for line in open(‘doc.txt’, encoding=’utf-8’)
]
dictionary = corpora.Dictionary()
BoW_corpus = [dictionary.doc2bow(doc, allow_update=True) for doc in doc_tokenized]
print(BoW_corpus)

बचत और एक Gensim Corpus लोड हो रहा है

हम निम्नलिखित स्क्रिप्ट की मदद से कॉर्पस को बचा सकते हैं -

corpora.MmCorpus.serialize(‘/Users/Desktop/BoW_corpus.mm’, bow_corpus)

#provide the path and the name of the corpus. The name of corpus is BoW_corpus and we saved it in Matrix Market format.

इसी प्रकार, हम निम्न लिपि का उपयोग करके सहेजे हुए कॉर्पस को लोड कर सकते हैं -

corpus_load = corpora.MmCorpus(‘/Users/Desktop/BoW_corpus.mm’)
for line in corpus_load:
print(line)

यह अध्याय आपको गेंसिम में विभिन्न परिवर्तनों के बारे में जानने में मदद करेगा। हमें परिवर्तन दस्तावेजों को समझने के द्वारा शुरू करते हैं।

रूपांतरण दस्तावेज़

दस्तावेज़ों को बदलने का अर्थ है दस्तावेज़ का इस तरह से प्रतिनिधित्व करना कि दस्तावेज़ को गणितीय रूप से हेरफेर किया जा सके। कॉर्पस की अव्यक्त संरचना को तैयार करने के अलावा, दस्तावेजों को बदलना भी निम्नलिखित लक्ष्यों को पूरा करेगा -

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

आइए दस्तावेजों को एक वेक्टर अंतरिक्ष प्रतिनिधित्व से दूसरे में बदलने के कार्यान्वयन चरणों को देखें।

कार्यान्वयन कदम

दस्तावेजों को बदलने के लिए, हमें निम्नलिखित चरणों का पालन करना चाहिए -

चरण 1: कॉर्पस बनाना

दस्तावेजों से कॉर्पस बनाने के लिए पहला और बुनियादी कदम है। हमने पहले के उदाहरणों में कॉर्पस बनाया है। आइए कुछ संवर्द्धन के साथ एक और बनाएं (सामान्य शब्दों और केवल एक बार आने वाले शब्दों को हटा दें) -

import gensim
import pprint
from collections import defaultdict
from gensim import corpora

अब कॉर्पस बनाने के लिए दस्तावेज प्रदान करें -

t_corpus = ["CNTK जिसे पहले कम्प्यूटेशनल नेटवर्क टूलकिट के रूप में जाना जाता है", "एक मुक्त उपयोग में आसान ओपन-सोर्स कमर्शियल-ग्रेड टूलकिट" है, "जो हमें मानव मस्तिष्क की तरह सीखने के लिए गहन शिक्षण एल्गोरिदम को प्रशिक्षित करने में सक्षम बनाता है।" आप "Tutorialspoint.com" पर अपना मुफ्त ट्यूटोरियल पा सकते हैं "," Tutorialspoint.com तकनीक पर सर्वश्रेष्ठ तकनीकी ट्यूटोरियल भी प्रदान करता है, जैसे कि एआई डीप लर्निंग मशीन मुफ्त में सीखना "।

अगला, हमें टोकन करने की आवश्यकता है और इसके साथ हम सामान्य शब्दों को भी हटा देंगे -

stoplist = set('for a of the and to in'.split(' '))
processed_corpus = [
   [
      word for word in document.lower().split() if word not in stoplist
   ]
	for document in t_corpus
]

निम्नलिखित स्क्रिप्ट उन शब्दों को हटा देगा जो केवल दिखाई देते हैं -

frequency = defaultdict(int)
for text in processed_corpus:
   for token in text:
      frequency[token] += 1
   processed_corpus = [
      [token for token in text if frequency[token] > 1] 
      for text in processed_corpus
   ]
pprint.pprint(processed_corpus)

उत्पादन

[
   ['toolkit'],
   ['free', 'toolkit'],
   ['deep', 'learning', 'like'],
   ['free', 'on', 'tutorialspoint.com'],
   ['tutorialspoint.com', 'on', 'like', 'deep', 'learning', 'learning', 'free']
]

अब इसे पास करें corpora.dictionary() हमारे कोष में अद्वितीय वस्तुओं को प्राप्त करने के लिए वस्तु -

dictionary = corpora.Dictionary(processed_corpus)
print(dictionary)

उत्पादन

Dictionary(7 unique tokens: ['toolkit', 'free', 'deep', 'learning', 'like']...)

अगला, कोड की निम्नलिखित पंक्ति हमारे कॉर्पस के लिए वर्ड मॉडल का बैग बनाएगी -

BoW_corpus = [dictionary.doc2bow(text) for text in processed_corpus]
pprint.pprint(BoW_corpus)

उत्पादन

[
   [(0, 1)],
   [(0, 1), (1, 1)],
   [(2, 1), (3, 1), (4, 1)],
   [(1, 1), (5, 1), (6, 1)],
   [(1, 1), (2, 1), (3, 2), (4, 1), (5, 1), (6, 1)]
]

चरण 2: एक परिवर्तन बनाना

परिवर्तन कुछ मानक पायथन ऑब्जेक्ट हैं। हम एक प्रशिक्षित कॉर्पस का उपयोग करके इन परिवर्तनों यानी पायथन ऑब्जेक्ट्स को इनिशियलाइज़ कर सकते हैं। यहां हम उपयोग करने जा रहे हैंtf-idf मॉडल हमारे प्रशिक्षित कॉर्पस का एक परिवर्तन बनाने के लिए BoW_corpus।

सबसे पहले, हमें gensim से मॉडल पैकेज आयात करने की आवश्यकता है।

from gensim import models

अब, हमें इस प्रकार मॉडल को इनिशियलाइज़ करने की आवश्यकता है -

tfidf = models.TfidfModel(BoW_corpus)

चरण 3: ट्रांसफॉर्मिंग वैक्टर

अब, इस अंतिम चरण में, वैक्टर को पुराने प्रतिनिधित्व से नए प्रतिनिधित्व में बदल दिया जाएगा। जैसा कि हमने ऊपर चरण में tfidf मॉडल को इनिशियलाइज़ किया है, tfidf को अब रीड ओनली ऑब्जेक्ट माना जाएगा। यहां, इस tfidf ऑब्जेक्ट का उपयोग करके हम अपने वेक्टर को शब्द प्रतिनिधित्व (पुराने प्रतिनिधित्व) के बैग से Tfidf वास्तविक-मूल्यवान भार (नए प्रतिनिधित्व) में बदल देंगे।

doc_BoW = [(1,1),(3,1)]
print(tfidf[doc_BoW]

उत्पादन

[(1, 0.4869354917707381), (3, 0.8734379353188121)]

हमने कॉर्पस के दो मूल्यों पर परिवर्तन लागू किया है, लेकिन हम इसे पूरे कॉर्पस पर भी लागू कर सकते हैं -

corpus_tfidf = tfidf[BoW_corpus]
for doc in corpus_tfidf:
   print(doc)

उत्पादन

[(0, 1.0)]
[(0, 0.8734379353188121), (1, 0.4869354917707381)]
[(2, 0.5773502691896257), (3, 0.5773502691896257), (4, 0.5773502691896257)]
[(1, 0.3667400603126873), (5, 0.657838022678017), (6, 0.657838022678017)]
[
   (1, 0.19338287240886842), (2, 0.34687949360312714), (3, 0.6937589872062543), 
   (4, 0.34687949360312714), (5, 0.34687949360312714), (6, 0.34687949360312714)
]

पूर्ण कार्यान्वयन उदाहरण

import gensim
import pprint
from collections import defaultdict
from gensim import corpora
t_corpus = [
   "CNTK formerly known as Computational Network Toolkit", 
   "is a free easy-to-use open-source commercial-grade toolkit", 
   "that enable us to train deep learning algorithms to learn like the human brain.", 
   "You can find its free tutorial on tutorialspoint.com", 
   "Tutorialspoint.com also provide best technical tutorials on 
   technologies like AI deep learning machine learning for free"
]
stoplist = set('for a of the and to in'.split(' '))
processed_corpus = [
   [word for word in document.lower().split() if word not in stoplist]
   for document in t_corpus
]
frequency = defaultdict(int)
for text in processed_corpus:
   for token in text:
      frequency[token] += 1
   processed_corpus = [
      [token for token in text if frequency[token] > 1] 
      for text in processed_corpus
   ]
pprint.pprint(processed_corpus)
dictionary = corpora.Dictionary(processed_corpus)
print(dictionary)
BoW_corpus = [dictionary.doc2bow(text) for text in processed_corpus]
pprint.pprint(BoW_corpus)
   from gensim import models
   tfidf = models.TfidfModel(BoW_corpus)
   doc_BoW = [(1,1),(3,1)]
   print(tfidf[doc_BoW])
   corpus_tfidf = tfidf[BoW_corpus]
   for doc in corpus_tfidf:
print(doc)

गेंसिम में विभिन्न रूपांतरण

Gensim का उपयोग करके, हम विभिन्न लोकप्रिय परिवर्तनों को लागू कर सकते हैं, अर्थात वेक्टर स्पेस मॉडल एल्गोरिदम। उनमें से कुछ इस प्रकार हैं -

Tf-Idf (शब्द आवृत्ति-व्युत्क्रम दस्तावेज़ आवृत्ति)

आरंभीकरण के दौरान, यह tf-idf मॉडल एल्गोरिथ्म एक प्रशिक्षण कॉर्पस को पूर्णांक मान (जैसे बैग-ऑफ-वर्ड्स मॉडल) की उम्मीद करता है। फिर उसके बाद, परिवर्तन के समय, यह एक वेक्टर प्रतिनिधित्व लेता है और एक और वेक्टर प्रतिनिधित्व लौटाता है।

आउटपुट वेक्टर में समान आयाम होगा लेकिन दुर्लभ सुविधाओं (प्रशिक्षण के समय) के मूल्य में वृद्धि होगी। यह मूल रूप से पूर्णांक-मूल्यवान वैक्टर को वास्तविक-मूल्यवान वैक्टर में रूपांतरित करता है। निम्नलिखित Tf-idf परिवर्तन का सिंटैक्स है -

Model=models.TfidfModel(corpus, normalize=True)

LSI (अव्यक्त अर्थ इंडेक्सिंग)

LSI मॉडल एल्गोरिथ्म या तो पूर्णांक मूल्यवान वेक्टर मॉडल (जैसे बैग-ऑफ-वर्ड्स मॉडल) या Tf-Idf भारित स्थान को अव्यक्त स्थान से दस्तावेज़ को रूपांतरित कर सकता है। आउटपुट वेक्टर निम्न आयामीता का होगा। निम्नलिखित LSI परिवर्तन का वाक्य विन्यास है -

Model=models.LsiModel(tfidf_corpus, id2word=dictionary, num_topics=300)

LDA (अव्यक्त डिरिचलेट आवंटन)

एलडीए मॉडल एल्गोरिथ्म एक और एल्गोरिथ्म है जो बैग-ऑफ-वर्ड्स मॉडल स्पेस से दस्तावेज़ को एक विषय स्थान में बदल देता है। आउटपुट वेक्टर निम्न आयामीता का होगा। निम्नलिखित LSI परिवर्तन का वाक्य विन्यास है -

Model=models.LdaModel(corpus, id2word=dictionary, num_topics=100)

यादृच्छिक अनुमान (आरपी)

आरपी, एक बहुत ही कुशल दृष्टिकोण, जिसका उद्देश्य वेक्टर अंतरिक्ष की गतिशीलता को कम करना है। यह दृष्टिकोण मूल रूप से दस्तावेजों के बीच Tf-Idf दूरियों का अनुमान है। यह थोड़ा यादृच्छिकता में फेंकने से ऐसा होता है।

Model=models.RpModel(tfidf_corpus, num_topics=500)

पदानुक्रमित डिरिलेट प्रक्रिया (HDP)

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

Model=models.HdpModel(corpus, id2word=dictionary

यहां, हम गेन्सिम की मदद से टर्म फ़्रीक्वेंसी-इनवर्स डॉक्यूमेंट फ़्रीक्वेंसी (TF-IDF) मैट्रिक्स बनाने के बारे में जानेंगे।

TF-IDF क्या है?

यह टर्म फ़्रीक्वेंसी-इनवर्स डॉक्यूमेंट फ़्रीक्वेंसी मॉडल है जो एक बैग-ऑफ-वर्ड मॉडल भी है। यह नियमित कॉर्पस से अलग है क्योंकि यह टोकन को तौलता है यानी दस्तावेज़ों में अक्सर दिखाई देने वाले शब्द। आरंभीकरण के दौरान, यह tf-idf मॉडल एल्गोरिथ्म एक प्रशिक्षण कॉर्पस को पूर्णांक मान (जैसे बैग-ऑफ-वर्ड्स मॉडल) की उम्मीद करता है।

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

इसकी गणना कैसे की जाती है?

TF-IDF मॉडल निम्नलिखित दो सरल चरणों की मदद से tfidf की गणना करता है -

चरण 1: स्थानीय और वैश्विक घटक को गुणा करना

इस पहले चरण में, मॉडल TFF (टर्म फ़्रीक्वेंसी) जैसे स्थानीय घटक को IDF (व्युत्क्रम दस्तावेज़ आवृत्ति) जैसे वैश्विक घटक से गुणा करेगा।

चरण 2: परिणाम को सामान्य करें

एक बार गुणा करने के बाद, अगले चरण में TFIDF मॉडल इकाई लंबाई के परिणाम को सामान्य करेगा।

इन चरणों के परिणामस्वरूप दो चरणों में अक्सर दस्तावेज़ों के पार होने वाले शब्द नीचे-भारित हो जाएंगे।

TF-IDF वेट कैसे प्राप्त करें?

यहां, हम एक उदाहरण को लागू करने जा रहे हैं कि हम टीएफ-आईडीएफ भार कैसे प्राप्त कर सकते हैं। मूल रूप से, TF-IDF वेट प्राप्त करने के लिए, पहले हमें कॉर्पस को प्रशिक्षित करने की आवश्यकता है और फिर उस कॉर्पस को tfidf मॉडल में लागू करना होगा।

कॉर्पस को प्रशिक्षित करें

जैसा कि ऊपर कहा गया है कि TF-IDF प्राप्त करने के लिए हमें सबसे पहले अपने कॉर्पस को प्रशिक्षित करना होगा। सबसे पहले, हमें सभी आवश्यक पैकेजों को निम्नानुसार आयात करना होगा -

import gensim
import pprint
from gensim import corpora
from gensim.utils import simple_preprocess

अब सूची युक्त वाक्य प्रदान करें। हमारी सूची में तीन वाक्य हैं -

doc_list = [
   "Hello, how are you?", "How do you do?", 
   "Hey what are you doing? yes you What are you doing?"
]

इसके बाद, वाक्यों का टोकन निम्नानुसार करें -

doc_tokenized = [simple_preprocess(doc) for doc in doc_list]

का एक ऑब्जेक्ट बनाएँ corpora.Dictionary() निम्नानुसार है -

dictionary = corpora.Dictionary()

अब इन टोकन वाक्यों को पास करें dictionary.doc2bow() वस्तु इस प्रकार है -

BoW_corpus = [dictionary.doc2bow(doc, allow_update=True) for doc in doc_tokenized]

इसके बाद, हम अपने दस्तावेज़ों में शब्द आईडी और उनकी आवृत्तियों को प्राप्त करेंगे।

for doc in BoW_corpus:
   print([[dictionary[id], freq] for id, freq in doc])

उत्पादन

[['are', 1], ['hello', 1], ['how', 1], ['you', 1]]
[['how', 1], ['you', 1], ['do', 2]]
[['are', 2], ['you', 3], ['doing', 2], ['hey', 1], ['what', 2], ['yes', 1]]

इस तरह हमने अपने कॉर्पस (बैग-ऑफ-वर्ड कॉर्पस) को प्रशिक्षित किया है।

अगला, हमें इस प्रशिक्षित कॉर्पस को tfidf मॉडल के भीतर लागू करने की आवश्यकता है models.TfidfModel()।

पहले numpay पैकेज आयात करें -

import numpy as np

अब के वर्ग कोष्ठक के भीतर हमारे प्रशिक्षित कॉर्पस (BoW_corpus) को लागू करना models.TfidfModel()

tfidf = models.TfidfModel(BoW_corpus, smartirs='ntc')

इसके बाद, हम अपने tfidf मॉडल किए गए कॉर्पस में शब्द आईडी और उनकी आवृत्तियों को प्राप्त करेंगे -

for doc in tfidf[BoW_corpus]:
   print([[dictionary[id], np.around(freq,decomal=2)] for id, freq in doc])

उत्पादन

[['are', 0.33], ['hello', 0.89], ['how', 0.33]]
[['how', 0.18], ['do', 0.98]]
[['are', 0.23], ['doing', 0.62], ['hey', 0.31], ['what', 0.62], ['yes', 0.31]]

[['are', 1], ['hello', 1], ['how', 1], ['you', 1]]
[['how', 1], ['you', 1], ['do', 2]]
[['are', 2], ['you', 3], ['doing', 2], ['hey', 1], ['what', 2], ['yes', 1]]

[['are', 0.33], ['hello', 0.89], ['how', 0.33]]
[['how', 0.18], ['do', 0.98]]
[['are', 0.23], ['doing', 0.62], ['hey', 0.31], ['what', 0.62], ['yes', 0.31]]

उपरोक्त आउटपुट से, हम अपने दस्तावेजों में शब्दों की आवृत्तियों में अंतर देखते हैं।

पूर्ण कार्यान्वयन उदाहरण

import gensim
import pprint
from gensim import corpora
from gensim.utils import simple_preprocess
doc_list = [
   "Hello, how are you?", "How do you do?", 
   "Hey what are you doing? yes you What are you doing?"
]
doc_tokenized = [simple_preprocess(doc) for doc in doc_list]
dictionary = corpora.Dictionary()
BoW_corpus = [dictionary.doc2bow(doc, allow_update=True) for doc in doc_tokenized]
for doc in BoW_corpus:
   print([[dictionary[id], freq] for id, freq in doc])
import numpy as np
tfidf = models.TfidfModel(BoW_corpus, smartirs='ntc')
for doc in tfidf[BoW_corpus]:
   print([[dictionary[id], np.around(freq,decomal=2)] for id, freq in doc])

शब्दों के वजन में अंतर

जैसा कि ऊपर चर्चा की गई है, दस्तावेज़ में अधिक बार होने वाले शब्दों को छोटे वजन मिलेंगे। आइए उपरोक्त दो आउटपुट से शब्दों के भार में अंतर को समझते हैं। शब्द‘are’दो दस्तावेज़ों में होता है और इसका भार कम किया जाता है। इसी तरह, शब्द‘you’ सभी दस्तावेजों में दिखाई दे रहा है और पूरी तरह से हटा दिया गया है।

यह अध्याय Gensim के संबंध में विषय मॉडलिंग से संबंधित है।

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

क्या हम जान सकते हैं कि हमारे कोष में दूसरों की तुलना में किस तरह के शब्द अधिक बार दिखाई देते हैं?
क्या हम अपना डेटा ग्रुप कर सकते हैं?
क्या हम अपने डेटा में अंतर्निहित विषय हो सकते हैं?

हम विषय मॉडलिंग की मदद से इन सभी को प्राप्त करने में सक्षम होंगे। तो आइए विषय के मॉडल की अवधारणा में गहरी डुबकी लगाएं।

विषय मॉडल क्या हैं?

एक विषय मॉडल को हमारे पाठ में विषयों के बारे में जानकारी रखने वाले संभावित मॉडल के रूप में परिभाषित किया जा सकता है। लेकिन यहां दो महत्वपूर्ण सवाल उठते हैं जो इस प्रकार हैं -

प्रथम, what exactly a topic is?

विषय, जैसा कि नाम से तात्पर्य है, अंतर्निहित विचार या हमारे पाठ में दर्शाए गए विषय हैं। आपको एक उदाहरण देने के लिए, युक्त कोषnewspaper articles से संबंधित विषय होंगे finance, weather, politics, sports, various states news और इसी तरह।

दूसरा, what is the importance of topic models in text processing?

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

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

टॉपिक मॉडल के लक्ष्य

जैसा कि ऊपर चर्चा की गई है, विषय मॉडलिंग का ध्यान अंतर्निहित विचारों और विषयों के बारे में है। इसके मुख्य लक्ष्य इस प्रकार हैं -

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

गेन्सिम में विषय मॉडलिंग एल्गोरिदम

निस्संदेह, Gensim सबसे लोकप्रिय विषय मॉडलिंग टूलकिट है। इसकी मुफ्त उपलब्धता और पायथन में होने के कारण यह अधिक लोकप्रिय है। इस खंड में, हम कुछ सबसे लोकप्रिय विषय मॉडलिंग एल्गोरिदम पर चर्चा करेंगे। यहाँ, हम 'कैसे' के बजाय 'क्या' पर ध्यान केन्द्रित करेंगे क्योंकि गेंसिम हमारे लिए बहुत अच्छा है।

अव्यक्त डिरिचलेट आवंटन (LDA)

लेटेंट डिरिचलेट आवंटन (LDA) सबसे आम और लोकप्रिय तकनीक है जो वर्तमान में विषय मॉडलिंग के लिए उपयोग में है। यह वह है जिसे फेसबुक शोधकर्ताओं ने 2013 में प्रकाशित अपने शोध पत्र में इस्तेमाल किया था। यह पहली बार डेविड बेली, एंड्रयू एनजी, और माइकल जॉर्डन ने 2003 में प्रस्तावित किया था। उन्होंने एलडीए को अपने पेपर में प्रस्तावित किया था जो कि केवल हकदार था।Latent Dirichlet allocation।

एलडीए के लक्षण

आइए जानते हैं इस अद्भुत तकनीक के बारे में इसकी विशेषताओं के बारे में -

Probabilistic topic modeling technique

एलडीए एक संभावित विषय मॉडलिंग तकनीक है। जैसा कि हमने ऊपर चर्चा की है, विषय मॉडलिंग में हम मानते हैं कि किसी भी तरह के परस्पर संबंधित दस्तावेजों का संग्रह (अकादमिक पत्र, समाचार पत्र लेख, फेसबुक पोस्ट, ट्वीट्स, ई-मेल और इतने पर हो सकता है), प्रत्येक दस्तावेज़ में शामिल विषयों के कुछ संयोजन हैं। ।

संभाव्य विषय मॉडलिंग का मुख्य लक्ष्य परस्पर संबंधित दस्तावेजों के संग्रह के लिए छिपे हुए विषय संरचना की खोज करना है। निम्नलिखित तीन चीजें आम तौर पर एक विषय संरचना में शामिल होती हैं -

Topics
दस्तावेजों के बीच विषयों का सांख्यिकीय वितरण
एक दस्तावेज़ में विषय शामिल शब्द

Work in an unsupervised way

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

Very easy to create it in Gensim

Gensim में, LDA मॉडल बनाना बहुत आसान है। हमें बस कॉर्पस, डिक्शनरी मैपिंग और उन विषयों की संख्या को निर्दिष्ट करने की आवश्यकता है जिन्हें हम अपने मॉडल में उपयोग करना चाहते हैं।

Model=models.LdaModel(corpus, id2word=dictionary, num_topics=100)

May face computationally intractable problem

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

अव्यक्त शब्दार्थ अनुक्रमण (LSI)

विषय मॉडलिंग एल्गोरिदम जो पहली बार के साथ जेनसिम में लागू किया गया था Latent Dirichlet Allocation (LDA) है Latent Semantic Indexing (LSI)। इसे कहते भी हैंLatent Semantic Analysis (LSA)।

इसे 1988 में स्कॉट डियरवेस्टर, सुसान डुमिस, जॉर्ज फर्नास, रिचर्ड हर्शमैन, थॉमस लैंडौर, करेन लोचबूम और लिन स्ट्रीटर ने पेटेंट कराया। इस खंड में हम अपना LSI मॉडल स्थापित करने जा रहे हैं। यह एलडीए मॉडल स्थापित करने के उसी तरीके से किया जा सकता है। हमें LSI मॉडल से आयात करने की आवश्यकता हैgensim.models।

LSI की भूमिका

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

एक बार निर्माण के बाद, पंक्तियों की संख्या को कम करने के लिए, एलएसआई मॉडल एक गणितीय तकनीक का उपयोग करता है जिसे विलक्षण मूल्य अपघटन (एसवीडी) कहा जाता है। पंक्तियों की संख्या को कम करने के साथ, यह स्तंभों के बीच समानता संरचना को भी संरक्षित करता है। मैट्रिक्स में, पंक्तियाँ अद्वितीय शब्दों का प्रतिनिधित्व करती हैं और कॉलम प्रत्येक दस्तावेज़ का प्रतिनिधित्व करते हैं। यह वितरण संबंधी परिकल्पना के आधार पर काम करता है यानी यह मानता है कि जो शब्द अर्थ में करीब हैं वे एक ही तरह के पाठ में होंगे।

Model=models.LsiModel(corpus, id2word=dictionary, num_topics=100)

पदानुक्रमित डिरिलेट प्रक्रिया (HDP)

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

Model=models.HdpModel(corpus, id2word=dictionary

यह अध्याय आपको यह जानने में मदद करेगा कि गेंसिम में लैटर डेंटिलेट आवंटन (एलडीए) विषय मॉडल कैसे बनाया जाए।

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

इस डिजिटल युग में, यह जानने के लिए कि लोग / ग्राहक किस बारे में बात कर रहे हैं, उनकी राय और उनकी समस्याओं को समझने के लिए, व्यवसायों, राजनीतिक अभियानों और प्रशासकों के लिए अत्यधिक मूल्यवान हो सकता है। लेकिन, क्या पाठ के इतने बड़े संस्करणों को मैन्युअल रूप से पढ़ना और फिर विषयों से जानकारी निकालना संभव है?

नहीं यह नहीं। इसके लिए एक स्वचालित एल्गोरिथ्म की आवश्यकता होती है जो इन बड़ी मात्रा में पाठ दस्तावेज़ों के माध्यम से पढ़ सकता है और स्वचालित रूप से आवश्यक जानकारी / विषयों को इसमें से निकाल सकता है।

एलडीए की भूमिका

विषय मॉडलिंग के लिए LDA का दृष्टिकोण एक विशेष विषय के लिए एक दस्तावेज़ में पाठ को वर्गीकृत करना है। डिरिक्लेट डिस्ट्रीब्यूशन के रूप में मॉडल, LDA बनाता है -

दस्तावेज़ मॉडल के अनुसार एक विषय और
विषय प्रति शब्द मॉडल

एलडीए विषय मॉडल एल्गोरिथ्म प्रदान करने के बाद, विषय-कीवर्ड वितरण की एक अच्छी रचना प्राप्त करने के लिए, यह फिर से व्यवस्थित करता है -

दस्तावेज़ के भीतर विषय वितरण और
विषयों के भीतर खोजशब्द वितरण

प्रसंस्करण करते समय, एलडीए द्वारा बनाई गई कुछ धारणाएं हैं -

प्रत्येक दस्तावेज़ को विषयों के बहु-नाममात्र वितरण के रूप में तैयार किया जाता है।
हर विषय को शब्दों के बहु-नाममात्र वितरण के रूप में तैयार किया जाता है।
हमें डेटा के सही कॉर्पस का चयन करना चाहिए क्योंकि एलडीए मानता है कि पाठ के प्रत्येक भाग में संबंधित शब्द हैं।
एलडीए भी मानता है कि दस्तावेजों का निर्माण विषयों के मिश्रण से किया जाता है।

गेंसिम के साथ कार्यान्वयन

यहां, हम डेटासेट से स्वाभाविक रूप से चर्चित विषयों को निकालने के लिए LDA (अव्यक्त डिरिचलेट आवंटन) का उपयोग करने जा रहे हैं।

लोड हो रहा है डेटा सेट

जिस डेटासेट का हम उपयोग करने जा रहे हैं, वह डेटासेट है ’20 Newsgroups’एक समाचार रिपोर्ट के विभिन्न अनुभागों से हजारों समाचार लेख। के तहत उपलब्ध हैSklearnडेटा सेट। हम पायथन लिपि की मदद से आसानी से डाउनलोड कर सकते हैं -

from sklearn.datasets import fetch_20newsgroups
newsgroups_train = fetch_20newsgroups(subset='train')

आइए निम्नलिखित स्क्रिप्ट की मदद से कुछ नमूना समाचार देखें -

newsgroups_train.data[:4]

["From: [email protected] (where's my thing)\nSubject: 
WHAT car is this!?\nNntp-Posting-Host: rac3.wam.umd.edu\nOrganization: 
University of Maryland, College Park\nLines: 
15\n\n I was wondering if anyone out there could enlighten me on this car 
I saw\nthe other day. It was a 2-door sports car, looked to be from the 
late 60s/\nearly 70s. It was called a Bricklin. The doors were really small. 
In addition,\nthe front bumper was separate from the rest of the body. 
This is \nall I know. If anyone can tellme a model name, 
engine specs, years\nof production, where this car is made, history, or 
whatever info you\nhave on this funky looking car, please e-mail.\n\nThanks,
\n- IL\n ---- brought to you by your neighborhood Lerxst ----\n\n\n\n\n",

"From: [email protected] (Guy Kuo)\nSubject: SI Clock Poll - Final 
Call\nSummary: Final call for SI clock reports\nKeywords: 
SI,acceleration,clock,upgrade\nArticle-I.D.: shelley.1qvfo9INNc3s\nOrganization: 
University of Washington\nLines: 11\nNNTP-Posting-Host: carson.u.washington.edu\n\nA 
fair number of brave souls who upgraded their SI clock oscillator have\nshared their 
experiences for this poll. Please send a brief message detailing\nyour experiences with 
the procedure. Top speed attained, CPU rated speed,\nadd on cards and adapters, heat 
sinks, hour of usage per day, floppy disk\nfunctionality with 800 and 1.4 m floppies 
are especially requested.\n\nI will be summarizing in the next two days, so please add 
to the network\nknowledge base if you have done the clock upgrade and haven't answered 
this\npoll. Thanks.\n\nGuy Kuo <;[email protected]>\n",

'From: [email protected] (Thomas E Willis)\nSubject: 
PB questions...\nOrganization: Purdue University Engineering 
Computer Network\nDistribution: usa\nLines: 36\n\nwell folks, 
my mac plus finally gave up the ghost this weekend after\nstarting 
life as a 512k way back in 1985. sooo, i\'m in the market for 
a\nnew machine a bit sooner than i intended to be...\n\ni\'m looking 
into picking up a powerbook 160 or maybe 180 and have a bunch\nof 
questions that (hopefully) somebody can answer:\n\n* does anybody 
know any dirt on when the next round of powerbook\nintroductions 
are expected? i\'d heard the 185c was supposed to make an\nappearence 
"this summer" but haven\'t heard anymore on it - and since i\ndon\'t 
have access to macleak, i was wondering if anybody out there had\nmore 
info...\n\n* has anybody heard rumors about price drops to the powerbook 
line like the\nones the duo\'s just went through recently?\n\n* what\'s 
the impression of the display on the 180? i could probably swing\na 180 
if i got the 80Mb disk rather than the 120, but i don\'t really have\na 
feel for how much "better" the display is (yea, it looks great in the\nstore, 
but is that all "wow" or is it really that good?). could i solicit\nsome 
opinions of people who use the 160 and 180 day-to-day on if its
worth\ntaking the disk size and money hit to get the active display? 
(i realize\nthis is a real subjective question, but i\'ve only played around 
with the\nmachines in a computer store breifly and figured the opinions 
of somebody\nwho actually uses the machine daily might prove helpful).\n\n* 
how well does hellcats perform? ;)\n\nthanks a bunch in advance for any info - 
if you could email, i\'ll post a\nsummary (news reading time is at a premium 
with finals just around the\ncorner... :
( )\n--\nTom Willis \\ [email protected] \\ Purdue Electrical 
Engineering\n---------------------------------------------------------------------------\
n"Convictions are more dangerous enemies of truth than lies." - F. W.\nNietzsche\n',

'From: jgreen@amber (Joe Green)\nSubject: Re: Weitek P9000 ?\nOrganization: 
Harris Computer Systems Division\nLines: 14\nDistribution: world\nNNTP-Posting-Host: 
amber.ssd.csd.harris.com\nX-Newsreader: TIN [version 1.1 PL9]\n\nRobert 
J.C. Kyanko ([email protected]) wrote:\n >[email protected] writes in article 
<[email protected] >:\n> > Anyone know about the 
Weitek P9000 graphics chip?\n > As far as the low-level stuff goes, it looks 
pretty nice. It\'s got this\n> quadrilateral fill command that requires just 
the four points.\n\nDo you have Weitek\'s address/phone number? I\'d like to get 
some information\nabout this chip.\n\n--\nJoe Green\t\t\t\tHarris 
Corporation\[email protected]\t\t\tComputer Systems Division\n"The only 
thing that really scares me is a person with no sense of humor.
"\n\t\t\t\t\t\t-- Jonathan Winters\n']

शर्त

हमें स्कल्प से एनएलटीके और अंग्रेजी मॉडल से स्टॉपवार्ड चाहिए। दोनों को निम्नानुसार डाउनलोड किया जा सकता है -

import nltk;
nltk.download('stopwords')
nlp = spacy.load('en_core_web_md', disable=['parser', 'ner'])

आवश्यक पैकेज आयात करना

एलडीए मॉडल बनाने के लिए हमें आवश्यक पैकेज के बाद आयात करने की आवश्यकता है -

import re
import numpy as np
import pandas as pd
from pprint import pprint
import gensim
import gensim.corpora as corpora
from gensim.utils import simple_preprocess
from gensim.models import CoherenceModel
import spacy
import pyLDAvis
import pyLDAvis.gensim
import matplotlib.pyplot as plt

स्टॉपवर्ड्स तैयार करना

अब, हमें Stopwords को आयात करने और उनका उपयोग करने की आवश्यकता है -

from nltk.corpus import stopwords
stop_words = stopwords.words('english')
stop_words.extend(['from', 'subject', 're', 'edu', 'use'])

पाठ को साफ करें

अब, Gensim की मदद से simple_preprocess()हमें शब्दों की सूची में प्रत्येक वाक्य को टोकन की आवश्यकता है। हमें विराम चिह्नों और अनावश्यक पात्रों को भी हटा देना चाहिए। ऐसा करने के लिए, हम एक फ़ंक्शन बनाएंगे जिसका नाम हैsent_to_words() -

def sent_to_words(sentences):
   for sentence in sentences:
      yield(gensim.utils.simple_preprocess(str(sentence), deacc=True))
data_words = list(sent_to_words(data))

बिल्डिंग बिग्राम और ट्रिग्राम मॉडल

जैसा कि हम जानते हैं कि, बिग्रेड दो शब्द हैं जो अक्सर दस्तावेज़ में एक साथ होते हैं और ट्रिग्राम तीन शब्द होते हैं जो अक्सर दस्तावेज़ में एक साथ होते हैं। गेन्सिम की मदद सेPhrases मॉडल, हम यह कर सकते हैं -

bigram = gensim.models.Phrases(data_words, min_count=5, threshold=100)
trigram = gensim.models.Phrases(bigram[data_words], threshold=100)
bigram_mod = gensim.models.phrases.Phraser(bigram)
trigram_mod = gensim.models.phrases.Phraser(trigram)

Stopwords को फ़िल्टर करें

इसके बाद, हमें Stopwords को फ़िल्टर करना होगा। इसके साथ ही, हम बिग्रेड, ट्रिगर्स और लेमेटमाइजेशन बनाने के लिए फंक्शन भी बनाएंगे -

def remove_stopwords(texts):
   return [[word for word in simple_preprocess(str(doc))
if word not in stop_words] for doc in texts]
def make_bigrams(texts):
   return [bigram_mod[doc] for doc in texts]
def make_trigrams(texts):
   return [trigram_mod[bigram_mod[doc]] for doc in texts]
def lemmatization(texts, allowed_postags=['NOUN', 'ADJ', 'VERB', 'ADV']):
   texts_out = []
   for sent in texts:
     doc = nlp(" ".join(sent))
     texts_out.append([token.lemma_ for token in doc if token.pos_ in allowed_postags])
   return texts_out

टॉपिक मॉडल के लिए बिल्डिंग डिक्शनरी और कॉर्पस

अब हमें शब्दकोश और कोष बनाने की आवश्यकता है। हमने इसे पिछले उदाहरणों में भी किया था -

id2word = corpora.Dictionary(data_lemmatized)
texts = data_lemmatized
corpus = [id2word.doc2bow(text) for text in texts]

बिल्डिंग एलडीए टॉपिक मॉडल

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

lda_model = gensim.models.ldamodel.LdaModel(
   corpus=corpus, id2word=id2word, num_topics=20, random_state=100, 
   update_every=1, chunksize=100, passes=10, alpha='auto', per_word_topics=True
)

कार्यान्वयन उदाहरण

आइए देखें एलडीए विषय मॉडल बनाने के लिए पूरा कार्यान्वयन उदाहरण -

import re
import numpy as np
import pandas as pd
from pprint import pprint
import gensim
import gensim.corpora as corpora
from gensim.utils import simple_preprocess
from gensim.models import CoherenceModel
import spacy
import pyLDAvis
import pyLDAvis.gensim
import matplotlib.pyplot as plt
from nltk.corpus import stopwords
stop_words = stopwords.words('english')
stop_words.extend(['from', 'subject', 're', 'edu', 'use'])
from sklearn.datasets import fetch_20newsgroups
newsgroups_train = fetch_20newsgroups(subset='train')
data = newsgroups_train.data
data = [re.sub('\S*@\S*\s?', '', sent) for sent in data]
data = [re.sub('\s+', ' ', sent) for sent in data]
data = [re.sub("\'", "", sent) for sent in data]
print(data_words[:4]) #it will print the data after prepared for stopwords
bigram = gensim.models.Phrases(data_words, min_count=5, threshold=100)
trigram = gensim.models.Phrases(bigram[data_words], threshold=100)
bigram_mod = gensim.models.phrases.Phraser(bigram)
trigram_mod = gensim.models.phrases.Phraser(trigram)
def remove_stopwords(texts):
   return [[word for word in simple_preprocess(str(doc)) 
   if word not in stop_words] for doc in texts]
def make_bigrams(texts):
   return [bigram_mod[doc] for doc in texts]
def make_trigrams(texts):
   [trigram_mod[bigram_mod[doc]] for doc in texts]
def lemmatization(texts, allowed_postags=['NOUN', 'ADJ', 'VERB', 'ADV']):
   texts_out = []
   for sent in texts:
      doc = nlp(" ".join(sent))
      texts_out.append([token.lemma_ for token in doc if token.pos_ in allowed_postags])
   return texts_out
data_words_nostops = remove_stopwords(data_words)
data_words_bigrams = make_bigrams(data_words_nostops)
nlp = spacy.load('en_core_web_md', disable=['parser', 'ner'])
data_lemmatized = lemmatization(data_words_bigrams, allowed_postags=[
   'NOUN', 'ADJ', 'VERB', 'ADV'
])
print(data_lemmatized[:4]) #it will print the lemmatized data.
id2word = corpora.Dictionary(data_lemmatized)
texts = data_lemmatized
corpus = [id2word.doc2bow(text) for text in texts]
print(corpus[:4]) #it will print the corpus we created above.
[[(id2word[id], freq) for id, freq in cp] for cp in corpus[:4]] 
#it will print the words with their frequencies.
lda_model = gensim.models.ldamodel.LdaModel(
   corpus=corpus, id2word=id2word, num_topics=20, random_state=100, 
   update_every=1, chunksize=100, passes=10, alpha='auto', per_word_topics=True
)

अब हम टॉपिक्स के लिए एलडीए मॉडल का उपयोग कर सकते हैं, ताकि मॉडल पर्फ्लेक्सिटी की गणना की जा सके।

इस अध्याय में, हम समझेंगे कि कैसे लेटेंट डिरिचलेट आवंटन (एलडीए) विषय मॉडल का उपयोग किया जाए।

एलडीए मॉडल में विषय देखना

एलडीए मॉडल (lda_model) जो हमने ऊपर बनाया है, इसका उपयोग दस्तावेजों से विषयों को देखने के लिए किया जा सकता है। यह निम्नलिखित स्क्रिप्ट की मदद से किया जा सकता है -

pprint(lda_model.print_topics())
doc_lda = lda_model[corpus]

उत्पादन

[
   (0, 
   '0.036*"go" + 0.027*"get" + 0.021*"time" + 0.017*"back" + 0.015*"good" + '
   '0.014*"much" + 0.014*"be" + 0.013*"car" + 0.013*"well" + 0.013*"year"'),
   (1,
   '0.078*"screen" + 0.067*"video" + 0.052*"character" + 0.046*"normal" + '
   '0.045*"mouse" + 0.034*"manager" + 0.034*"disease" + 0.031*"processor" + '
   '0.028*"excuse" + 0.028*"choice"'),
   (2,
   '0.776*"ax" + 0.079*"_" + 0.011*"boy" + 0.008*"ticket" + 0.006*"red" + '
   '0.004*"conservative" + 0.004*"cult" + 0.004*"amazing" + 0.003*"runner" + '
   '0.003*"roughly"'),
   (3,
   '0.086*"season" + 0.078*"fan" + 0.072*"reality" + 0.065*"trade" + '
   '0.045*"concept" + 0.040*"pen" + 0.028*"blow" + 0.025*"improve" + '
   '0.025*"cap" + 0.021*"penguin"'),
   (4,
   '0.027*"group" + 0.023*"issue" + 0.016*"case" + 0.016*"cause" + '
   '0.014*"state" + 0.012*"whole" + 0.012*"support" + 0.011*"government" + '
   '0.010*"year" + 0.010*"rate"'),
   (5,
   '0.133*"evidence" + 0.047*"believe" + 0.044*"religion" + 0.042*"belief" + '
   '0.041*"sense" + 0.041*"discussion" + 0.034*"atheist" + 0.030*"conclusion" +
   '
   '0.029*"explain" + 0.029*"claim"'),
   (6,
   '0.083*"space" + 0.059*"science" + 0.031*"launch" + 0.030*"earth" + '
   '0.026*"route" + 0.024*"orbit" + 0.024*"scientific" + 0.021*"mission" + '
   '0.018*"plane" + 0.017*"satellite"'),
   (7,
   '0.065*"file" + 0.064*"program" + 0.048*"card" + 0.041*"window" + '
   '0.038*"driver" + 0.037*"software" + 0.034*"run" + 0.029*"machine" + '
   '0.029*"entry" + 0.028*"version"'),
   (8,
   '0.078*"publish" + 0.059*"mount" + 0.050*"turkish" + 0.043*"armenian" + '
   '0.027*"western" + 0.026*"russian" + 0.025*"locate" + 0.024*"proceed" + '
   '0.024*"electrical" + 0.022*"terrorism"'),
   (9,
   '0.023*"people" + 0.023*"child" + 0.021*"kill" + 0.020*"man" + 0.019*"death" '
   '+ 0.015*"die" + 0.015*"live" + 0.014*"attack" + 0.013*"age" + '
   '0.011*"church"'),
   (10,
   '0.092*"cpu" + 0.085*"black" + 0.071*"controller" + 0.039*"white" + '
   '0.028*"water" + 0.027*"cold" + 0.025*"solid" + 0.024*"cool" + 0.024*"heat" '
   '+ 0.023*"nuclear"'),
   (11,
   '0.071*"monitor" + 0.044*"box" + 0.042*"option" + 0.041*"generate" + '
   '0.038*"vote" + 0.032*"battery" + 0.029*"wave" + 0.026*"tradition" + '
   '0.026*"fairly" + 0.025*"task"'),
   (12,
   '0.048*"send" + 0.045*"mail" + 0.036*"list" + 0.033*"include" + '
   '0.032*"price" + 0.031*"address" + 0.027*"email" + 0.026*"receive" + '
   '0.024*"book" + 0.024*"sell"'),
   (13,
   '0.515*"drive" + 0.052*"laboratory" + 0.042*"blind" + 0.020*"investment" + '
   '0.011*"creature" + 0.010*"loop" + 0.005*"dialog" + 0.000*"slave" + '
   '0.000*"jumper" + 0.000*"sector"'),
   (14,
   '0.153*"patient" + 0.066*"treatment" + 0.062*"printer" + 0.059*"doctor" + '

   '0.036*"medical" + 0.031*"energy" + 0.029*"study" + 0.029*"probe" + '
   '0.024*"mph" + 0.020*"physician"'),
   (15,
   '0.068*"law" + 0.055*"gun" + 0.039*"government" + 0.036*"right" + '
   '0.029*"state" + 0.026*"drug" + 0.022*"crime" + 0.019*"person" + '
   '0.019*"citizen" + 0.019*"weapon"'),
   (16,
   '0.107*"team" + 0.102*"game" + 0.078*"play" + 0.055*"win" + 0.052*"player" + '
   '0.051*"year" + 0.030*"score" + 0.025*"goal" + 0.023*"wing" + 0.023*"run"'),
   (17,
   '0.031*"say" + 0.026*"think" + 0.022*"people" + 0.020*"make" + 0.017*"see" + '
   '0.016*"know" + 0.013*"come" + 0.013*"even" + 0.013*"thing" + 0.013*"give"'),
   (18,
   '0.039*"system" + 0.034*"use" + 0.023*"key" + 0.016*"bit" + 0.016*"also" + '
   '0.015*"information" + 0.014*"source" + 0.013*"chip" + 0.013*"available" + '
   '0.010*"provide"'),
   (19,
   '0.085*"line" + 0.073*"write" + 0.053*"article" + 0.046*"organization" + '
   '0.034*"host" + 0.023*"be" + 0.023*"know" + 0.017*"thank" + 0.016*"want" + '
   '0.014*"help"')
]

कम्प्यूटिंग मॉडल Perplexity

एलडीए मॉडल (lda_model) जो हमने ऊपर बनाया है, का उपयोग मॉडल की गड़बड़ी की गणना करने के लिए किया जा सकता है, अर्थात मॉडल कितना अच्छा है। जितना कम स्कोर होगा उतना बेहतर मॉडल होगा। यह निम्नलिखित स्क्रिप्ट की मदद से किया जा सकता है -

print('\nPerplexity: ', lda_model.log_perplexity(corpus))

उत्पादन

Perplexity: -12.338664984332151

कम्प्यूटिंग सुसंगतता स्कोर

एलडीए मॉडल (lda_model)हमने ऊपर बनाया है, इसका उपयोग मॉडल के सुसंगतता स्कोर के लिए किया जा सकता है, अर्थात विषय में शब्दों के जोड़ीदार शब्द-समानता स्कोर का औसत / औसत। यह निम्नलिखित स्क्रिप्ट की मदद से किया जा सकता है -

coherence_model_lda = CoherenceModel(
   model=lda_model, texts=data_lemmatized, dictionary=id2word, coherence='c_v'
)
coherence_lda = coherence_model_lda.get_coherence()
print('\nCoherence Score: ', coherence_lda)

उत्पादन

Coherence Score: 0.510264381411751

विषय-खोजशब्दों की कल्पना करना

एलडीए मॉडल (lda_model)हमने ऊपर बनाया है इसका उपयोग उत्पादित विषयों और संबंधित कीवर्ड की जांच के लिए किया जा सकता है। इसका उपयोग करके कल्पना की जा सकती हैpyLDAvisपैकेज निम्नानुसार है -

pyLDAvis.enable_notebook()
vis = pyLDAvis.gensim.prepare(lda_model, corpus, id2word)
vis

उत्पादन

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

यह अध्याय बताएगा कि लेटेंट डिरिचलेट आवंटन (एलडीए) मैलेट मॉडल क्या है और गेंसिम में इसे कैसे बनाया जाए।

पिछले भाग में हमने LDA मॉडल लागू किया है और 20Newsgroup डेटासेट के दस्तावेजों से विषय प्राप्त करते हैं। यह Gensim एलडीए एल्गोरिथ्म का इनबिल्ट वर्जन था। Gensim का एक Mallet संस्करण भी है, जो विषयों की बेहतर गुणवत्ता प्रदान करता है। यहां, हम पहले से लागू किए गए उदाहरण पर मैलेट के एलडीए को लागू करने जा रहे हैं।

LDA Mallet Model क्या है?

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

Mallet2.0 MALLET से वर्तमान रिलीज़ है, जावा विषय मॉडलिंग टूलकिट है। इससे पहले कि हम एलडीए के लिए गेंसिम के साथ इसका उपयोग शुरू करें, हमें अपने सिस्टम पर mallet-2.0.8.zip पैकेज डाउनलोड करना होगा और इसे अनइंस्टॉल करना होगा। एक बार स्थापित और अनजिप हो जाने पर, पर्यावरण चर% MALLET_HOME% को MALLET निर्देशिका को इंगित करने के लिए मैन्युअल रूप से या हमारे द्वारा प्रदान किए जा रहे कोड द्वारा, जबकि बगल में Mallet के साथ LDA लागू करते हैं।

जेनसिम आवरण

अजगर लेटेंट डिरिचलेट आवंटन (एलडीए) के लिए जेनसिम आवरण प्रदान करता है। उस आवरण का वाक्य विन्यास हैgensim.models.wrappers.LdaMallet। यह मॉड्यूल, MALLET से गिब्ब्स के नमूने को तोड़ दिया गया है, एक प्रशिक्षण कॉर्पस से एलडीए मॉडल का अनुमान लगाने और नए, अनदेखी दस्तावेजों के साथ-साथ विषय वितरण के संबंध में भी अनुमति देता है।

कार्यान्वयन उदाहरण

हम पहले से बने एलडीए मॉडल पर एलडीए मैलेट का उपयोग करेंगे और कोहेरेंस स्कोर की गणना करके प्रदर्शन में अंतर की जांच करेंगे।

मैलेट फ़ाइल को पथ प्रदान करना

पिछले उदाहरण में निर्मित हमारे कॉर्पस पर मैलेट एलडीए मॉडल को लागू करने से पहले, हमें पर्यावरण चर को अपडेट करना होगा और साथ ही मैलेट फ़ाइल को पथ प्रदान करना होगा। यह निम्नलिखित कोड की मदद से किया जा सकता है -

import os
from gensim.models.wrappers import LdaMallet
os.environ.update({'MALLET_HOME':r'C:/mallet-2.0.8/'}) 
#You should update this path as per the path of Mallet directory on your system.
mallet_path = r'C:/mallet-2.0.8/bin/mallet' 
#You should update this path as per the path of Mallet directory on your system.

एक बार जब हमने मैलेट फ़ाइल को पथ प्रदान किया, तो अब हम इसे कॉर्पस पर उपयोग कर सकते हैं। की सहायता से किया जा सकता हैldamallet.show_topics() कार्य निम्नानुसार है -

ldamallet = gensim.models.wrappers.LdaMallet(
   mallet_path, corpus=corpus, num_topics=20, id2word=id2word
)
pprint(ldamallet.show_topics(formatted=False))

उत्पादन

[
   (4,
   [('gun', 0.024546225966016102),
   ('law', 0.02181426826996709),
   ('state', 0.017633545129043606),
   ('people', 0.017612848479831116),
   ('case', 0.011341763768445888),
   ('crime', 0.010596684396796159),
   ('weapon', 0.00985160502514643),
   ('person', 0.008671896020034356),
   ('firearm', 0.00838214293105946),
   ('police', 0.008257963035784506)]),
   (9,
   [('make', 0.02147966482730431),
   ('people', 0.021377478029838543),
   ('work', 0.018557122419783363),
   ('money', 0.016676885346413244),
   ('year', 0.015982015123646026),
   ('job', 0.012221540976905783),
   ('pay', 0.010239117106069897),
   ('time', 0.008910688739014919),
   ('school', 0.0079092581238504),
   ('support', 0.007357449417535254)]),
   (14,
   [('power', 0.018428398507941996),
   ('line', 0.013784244460364121),
   ('high', 0.01183271164249895),
   ('work', 0.011560979224821522),
   ('ground', 0.010770484918850819),
   ('current', 0.010745781971789235),
   ('wire', 0.008399002000938712),
   ('low', 0.008053160742076529),
   ('water', 0.006966231071366814),
   ('run', 0.006892122230182061)]),
   (0,
   [('people', 0.025218349201353372),
   ('kill', 0.01500904870564167),
   ('child', 0.013612400660948935),
   ('armenian', 0.010307655991816822),
   ('woman', 0.010287984892595798),
   ('start', 0.01003226060272248),
   ('day', 0.00967818081674404),
   ('happen', 0.009383114328428673),
   ('leave', 0.009383114328428673),
   ('fire', 0.009009363443229208)]),
   (1,
   [('file', 0.030686386604212003),
   ('program', 0.02227713642901929),
   ('window', 0.01945561169918489),
   ('set', 0.015914874783314277),
   ('line', 0.013831003577619592),
   ('display', 0.013794120901412606),
   ('application', 0.012576992586582082),
   ('entry', 0.009275993066056873),
   ('change', 0.00872275292295209),
   ('color', 0.008612104894331132)]),
   (12,
   [('line', 0.07153810971508515),
   ('buy', 0.02975597944523662),
   ('organization', 0.026877236406682988),
   ('host', 0.025451316957679788),
   ('price', 0.025182275552207485),
   ('sell', 0.02461728860071565),
   ('mail', 0.02192687454599263),
   ('good', 0.018967419085797303),
   ('sale', 0.017998870026097017),
   ('send', 0.013694207538540181)]),
   (11,
   [('thing', 0.04901329901329901),
   ('good', 0.0376018876018876),
   ('make', 0.03393393393393394),
   ('time', 0.03326898326898327),
   ('bad', 0.02664092664092664),
   ('happen', 0.017696267696267698),
   ('hear', 0.015615615615615615),
   ('problem', 0.015465465465465466),
   ('back', 0.015143715143715144),
   ('lot', 0.01495066495066495)]),
   (18,
   [('space', 0.020626317374284855),
   ('launch', 0.00965716006366413),
   ('system', 0.008560244332602057),
   ('project', 0.008173097603991913),
   ('time', 0.008108573149223556),
   ('cost', 0.007764442723792318),
   ('year', 0.0076784101174345075),
   ('earth', 0.007484836753129436),
   ('base', 0.0067535595990880545),
   ('large', 0.006689035144319697)]),
   (5,
   [('government', 0.01918437232469453),
   ('people', 0.01461203206475212),
   ('state', 0.011207097828624796),
   ('country', 0.010214802708381975),
   ('israeli', 0.010039691804809714),
   ('war', 0.009436532025838587),
   ('force', 0.00858043427504086),
   ('attack', 0.008424780138532182),
   ('land', 0.0076659662230523775),
   ('world', 0.0075103120865437)]),
   (2,
   [('car', 0.041091194044470564),
   ('bike', 0.015598981291017729),
   ('ride', 0.011019688510138114),
   ('drive', 0.010627877363110981),
   ('engine', 0.009403467528651191),
   ('speed', 0.008081104907434616),
   ('turn', 0.007738270153785875),
   ('back', 0.007738270153785875),
   ('front', 0.007468899990204721),
   ('big', 0.007370947203447938)])
]

प्रदर्शन का मूल्यांकन

अब हम इसके प्रदर्शन का मूल्यांकन इस प्रकार कर सकते हैं कि सुसंगतता की गणना निम्न प्रकार से की गई है -

ldamallet = gensim.models.wrappers.LdaMallet(
   mallet_path, corpus=corpus, num_topics=20, id2word=id2word
)
pprint(ldamallet.show_topics(formatted=False))

उत्पादन

Coherence Score: 0.5842762900901401

इस अध्याय में गेंसिम में दस्तावेजों और एलडीए मॉडल पर चर्चा की गई है।

एलडीए के लिए विषयों की इष्टतम संख्या ढूँढना

हम विभिन्न मूल्यों वाले विभिन्न एलडीए मॉडल बनाकर एलडीए के लिए विषयों की इष्टतम संख्या पा सकते हैं। उन एलडीए में से हम सबसे अधिक सुसंगत मूल्य रख सकते हैं।

नाम के समारोह के बाद coherence_values_computation()कई एलडीए मॉडल को प्रशिक्षित करेंगे। यह मॉडल और साथ ही उनके सुसंगत स्कोर को भी प्रदान करेगा -

def coherence_values_computation(dictionary, corpus, texts, limit, start=2, step=3):
   coherence_values = []
   model_list = []
   for num_topics in range(start, limit, step):
      model = gensim.models.wrappers.LdaMallet(
         mallet_path, corpus=corpus, num_topics=num_topics, id2word=id2word
      )
      model_list.append(model)
   coherencemodel = CoherenceModel(
      model=model, texts=texts, dictionary=dictionary, coherence='c_v'
   )
   coherence_values.append(coherencemodel.get_coherence())
return model_list, coherence_values

अब निम्नलिखित कोड की सहायता से, हम उन विषयों की इष्टतम संख्या प्राप्त कर सकते हैं, जिन्हें हम ग्राफ़ की सहायता से भी दिखा सकते हैं -

model_list, coherence_values = coherence_values_computation (
   dictionary=id2word, corpus=corpus, texts=data_lemmatized, 
   start=1, limit=50, step=8
)
limit=50; start=1; step=8;
x = range(start, limit, step)
plt.plot(x, coherence_values)
plt.xlabel("Num Topics")
plt.ylabel("Coherence score")
plt.legend(("coherence_values"), loc='best')
plt.show()

उत्पादन

इसके बाद, हम विभिन्न विषयों के लिए सुसंगत मूल्यों को भी निम्नानुसार मुद्रित कर सकते हैं -

for m, cv in zip(x, coherence_values):
   print("Num Topics =", m, " is having Coherence Value of", round(cv, 4))

उत्पादन

Num Topics = 1 is having Coherence Value of 0.4866
Num Topics = 9 is having Coherence Value of 0.5083
Num Topics = 17 is having Coherence Value of 0.5584
Num Topics = 25 is having Coherence Value of 0.5793
Num Topics = 33 is having Coherence Value of 0.587
Num Topics = 41 is having Coherence Value of 0.5842
Num Topics = 49 is having Coherence Value of 0.5735

अब, सवाल उठता है कि अब हमें कौन सा मॉडल चुनना चाहिए? अच्छी प्रथाओं में से एक मॉडल को चुनना है, जो कि चापलूसी करने से पहले उच्चतम सुसंगतता दे रही है। इसलिए, हम उन 25 विषयों के साथ मॉडल का चयन करेंगे जो उपरोक्त सूची में 4 वें स्थान पर हैं।

optimal_model = model_list[3]
model_topics = optimal_model.show_topics(formatted=False)
pprint(optimal_model.print_topics(num_words=10))

[
   (0,
   '0.018*"power" + 0.011*"high" + 0.010*"ground" + 0.009*"current" + '
   '0.008*"low" + 0.008*"wire" + 0.007*"water" + 0.007*"work" + 0.007*"design" '
   '+ 0.007*"light"'),
   (1,
   '0.036*"game" + 0.029*"team" + 0.029*"year" + 0.028*"play" + 0.020*"player" '
   '+ 0.019*"win" + 0.018*"good" + 0.013*"season" + 0.012*"run" + 0.011*"hit"'),
   (2,
   '0.020*"image" + 0.019*"information" + 0.017*"include" + 0.017*"mail" + '
   '0.016*"send" + 0.015*"list" + 0.013*"post" + 0.012*"address" + '
   '0.012*"internet" + 0.012*"system"'),
   (3,
   '0.986*"ax" + 0.002*"_" + 0.001*"tm" + 0.000*"part" + 0.000*"biz" + '
   '0.000*"mb" + 0.000*"mbs" + 0.000*"pne" + 0.000*"end" + 0.000*"di"'),
   (4,
   '0.020*"make" + 0.014*"work" + 0.013*"money" + 0.013*"year" + 0.012*"people" '
   '+ 0.011*"job" + 0.010*"group" + 0.009*"government" + 0.008*"support" + '
   '0.008*"question"'),
   (5,
   '0.011*"study" + 0.011*"drug" + 0.009*"science" + 0.008*"food" + '
   '0.008*"problem" + 0.008*"result" + 0.008*"effect" + 0.007*"doctor" + '
   '0.007*"research" + 0.007*"patient"'),
   (6,
   '0.024*"gun" + 0.024*"law" + 0.019*"state" + 0.015*"case" + 0.013*"people" + '
   '0.010*"crime" + 0.010*"weapon" + 0.010*"person" + 0.008*"firearm" + '
   '0.008*"police"'),
   (7,
   '0.012*"word" + 0.011*"question" + 0.011*"exist" + 0.011*"true" + '
   '0.010*"religion" + 0.010*"claim" + 0.008*"argument" + 0.008*"truth" + '
   '0.008*"life" + 0.008*"faith"'),
   (8,
   '0.077*"time" + 0.029*"day" + 0.029*"call" + 0.025*"back" + 0.021*"work" + '
   '0.019*"long" + 0.015*"end" + 0.015*"give" + 0.014*"year" + 0.014*"week"'),
   (9,
   '0.048*"thing" + 0.041*"make" + 0.038*"good" + 0.037*"people" + '
   '0.028*"write" + 0.019*"bad" + 0.019*"point" + 0.018*"read" + 0.018*"post" + '
   '0.016*"idea"'),
   (10,
   '0.022*"book" + 0.020*"_" + 0.013*"man" + 0.012*"people" + 0.011*"write" + '
   '0.011*"find" + 0.010*"history" + 0.010*"armenian" + 0.009*"turkish" + '
   '0.009*"number"'),
   (11,
   '0.064*"line" + 0.030*"buy" + 0.028*"organization" + 0.025*"price" + '
   '0.025*"sell" + 0.023*"good" + 0.021*"host" + 0.018*"sale" + 0.017*"mail" + '
   '0.016*"cost"'),
   (12,
   '0.041*"car" + 0.015*"bike" + 0.011*"ride" + 0.010*"engine" + 0.009*"drive" '
   '+ 0.008*"side" + 0.008*"article" + 0.007*"turn" + 0.007*"front" + '
   '0.007*"speed"'),
   (13,
   '0.018*"people" + 0.011*"attack" + 0.011*"state" + 0.011*"israeli" + '
   '0.010*"war" + 0.010*"country" + 0.010*"government" + 0.009*"live" + '
   '0.009*"give" + 0.009*"land"'),
   (14,
   '0.037*"file" + 0.026*"line" + 0.021*"read" + 0.019*"follow" + '
   '0.018*"number" + 0.015*"program" + 0.014*"write" + 0.012*"entry" + '
   '0.012*"give" + 0.011*"check"'),
   (15,
   '0.196*"write" + 0.172*"line" + 0.165*"article" + 0.117*"organization" + '
   '0.086*"host" + 0.030*"reply" + 0.010*"university" + 0.008*"hear" + '
   '0.007*"post" + 0.007*"news"'),
   (16,
   '0.021*"people" + 0.014*"happen" + 0.014*"child" + 0.012*"kill" + '
   '0.011*"start" + 0.011*"live" + 0.010*"fire" + 0.010*"leave" + 0.009*"hear" '
   '+ 0.009*"home"'),
   (17,
   '0.038*"key" + 0.018*"system" + 0.015*"space" + 0.015*"technology" + '
   '0.014*"encryption" + 0.010*"chip" + 0.010*"bit" + 0.009*"launch" + '
   '0.009*"public" + 0.009*"government"'),
   (18,
   '0.035*"drive" + 0.031*"system" + 0.027*"problem" + 0.027*"card" + '
   '0.020*"driver" + 0.017*"bit" + 0.017*"work" + 0.016*"disk" + '
   '0.014*"monitor" + 0.014*"machine"'),
   (19,
   '0.031*"window" + 0.020*"run" + 0.018*"color" + 0.018*"program" + '
   '0.017*"application" + 0.016*"display" + 0.015*"set" + 0.015*"version" + '
   '0.012*"screen" + 0.012*"problem"')
]

वाक्यों में प्रमुख विषयों का पता लगाना

वाक्यों में प्रमुख विषयों को खोजना विषय मॉडलिंग के सबसे उपयोगी व्यावहारिक अनुप्रयोगों में से एक है। यह निर्धारित करता है कि दिए गए दस्तावेज़ किस विषय के बारे में हैं। यहां, हम उस विषय संख्या को प्राप्त करेंगे जिसका उस विशेष दस्तावेज़ में सबसे अधिक प्रतिशत योगदान है। किसी तालिका में जानकारी एकत्र करने के लिए, हम एक फ़ंक्शन का नाम देंगेdominant_topics() -

def dominant_topics(ldamodel=lda_model, corpus=corpus, texts=data):
   sent_topics_df = pd.DataFrame()

अगला, हम हर दस्तावेज में मुख्य विषय प्राप्त करेंगे -

for i, row in enumerate(ldamodel[corpus]):
   row = sorted(row, key=lambda x: (x[1]), reverse=True)

इसके बाद, हम हर दस्तावेज के लिए डोमिनेंट विषय, Perc योगदान और कीवर्ड प्राप्त करेंगे -

for j, (topic_num, prop_topic) in enumerate(row):
   if j == 0: # => dominant topic
      wp = ldamodel.show_topic(topic_num)
      topic_keywords = ", ".join([word for word, prop in wp])
sent_topics_df = sent_topics_df.append(
   pd.Series([int(topic_num), round(prop_topic,4), topic_keywords]), ignore_index=True
)
   else:
      break
sent_topics_df.columns = ['Dominant_Topic', 'Perc_Contribution', 'Topic_Keywords']

निम्नलिखित कोड की मदद से, हम मूल पाठ को आउटपुट के अंत में जोड़ देंगे -

contents = pd.Series(texts)
   sent_topics_df = pd.concat([sent_topics_df, contents], axis=1)
   return(sent_topics_df)
df_topic_sents_keywords = dominant_topics(
   ldamodel=optimal_model, corpus=corpus, texts=data
)

अब, वाक्यों में विषयों का प्रारूपण निम्न प्रकार से करें -

df_dominant_topic = df_topic_sents_keywords.reset_index()
df_dominant_topic.columns = [
   'Document_No', 'Dominant_Topic', 'Topic_Perc_Contrib', 'Keywords', 'Text'
]

अंत में, हम प्रमुख विषयों को निम्नानुसार दिखा सकते हैं -

df_dominant_topic.head(15)

सबसे अधिक प्रतिनिधि दस्तावेज़ ढूँढना

विषय के बारे में अधिक समझने के लिए, हम दस्तावेजों को भी पा सकते हैं, किसी दिए गए विषय ने सबसे अधिक योगदान दिया है। हम उस विशेष दस्तावेज़ (दों) को पढ़कर उस विषय का अनुमान लगा सकते हैं।

sent_topics_sorteddf_mallet = pd.DataFrame()
sent_topics_outdf_grpd = df_topic_sents_keywords.groupby('Dominant_Topic')
for i, grp in sent_topics_outdf_grpd:
   sent_topics_sorteddf_mallet = pd.concat([sent_topics_sorteddf_mallet,
grp.sort_values(['Perc_Contribution'], ascending=[0]).head(1)], axis=0)
sent_topics_sorteddf_mallet.reset_index(drop=True, inplace=True)
sent_topics_sorteddf_mallet.columns = [
   'Topic_Number', "Contribution_Perc", "Keywords", "Text"
]
sent_topics_sorteddf_mallet.head()

उत्पादन

मात्रा और विषयों का वितरण

कभी-कभी हम यह भी जज करना चाहते हैं कि दस्तावेजों में विषय पर व्यापक रूप से चर्चा कैसे की जाती है। इसके लिए हमें दस्तावेज़ों में विषयों के आयतन और वितरण को समझना होगा।

सबसे पहले प्रत्येक विषय के लिए दस्तावेजों की संख्या की गणना करें -

topic_counts = df_topic_sents_keywords['Dominant_Topic'].value_counts()

अगला, प्रत्येक विषय के लिए दस्तावेजों के प्रतिशत की गणना निम्नानुसार है -;

topic_contribution = round(topic_counts/topic_counts.sum(), 4)

अब विषय संख्या और खोजशब्द इस प्रकार है -

topic_num_keywords = df_topic_sents_keywords[['Dominant_Topic', 'Topic_Keywords']]

अब, बाद में संक्षिप्त रूप में संक्षिप्त करें -

df_dominant_topics = pd.concat(
   [topic_num_keywords, topic_counts, topic_contribution], axis=1
)

अगला, हम कॉलम के नाम इस प्रकार बदलेंगे -

df_dominant_topics.columns = [
   'Dominant-Topic', 'Topic-Keywords', 'Num_Documents', 'Perc_Documents'
]
df_dominant_topics

उत्पादन

यह अध्याय Gensim के संबंध में अव्यक्त अर्थ इंडेक्सिंग (LSI) और श्रेणीबद्ध डिरिक्लेट प्रक्रिया (HDP) विषय मॉडल बनाने से संबंधित है।

मॉडलिंग एल्गोरिदम का विषय है जिसे सबसे पहले लेन्सेंट डिरिचलेट आवंटन (एलडीए) के साथ जेनसिम में लागू किया गया था Latent Semantic Indexing (LSI)। इसे कहते भी हैंLatent Semantic Analysis (LSA)। इसे 1988 में स्कॉट डियरवेस्टर, सुसान डुमिस, जॉर्ज फर्नास, रिचर्ड हर्शमैन, थॉमस लैंडौर, करेन लोचबूम और लिन स्ट्रीटर ने पेटेंट कराया।

इस खंड में हम अपना LSI मॉडल स्थापित करने जा रहे हैं। यह एलडीए मॉडल स्थापित करने के उसी तरीके से किया जा सकता है। हमें LSI मॉडल से आयात करने की आवश्यकता हैgensim.models।

LSI की भूमिका

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

मैट्रिक्स में, पंक्तियाँ अद्वितीय शब्दों का प्रतिनिधित्व करती हैं और कॉलम प्रत्येक दस्तावेज़ का प्रतिनिधित्व करते हैं। यह वितरण संबंधी परिकल्पना के आधार पर काम करता है, अर्थात यह मानता है कि जो शब्द अर्थ में करीब हैं वे एक ही तरह के पाठ में होंगे।

गेंसिम के साथ कार्यान्वयन

यहां, हम डेटासेट से स्वाभाविक रूप से चर्चित विषयों को निकालने के लिए LSI (अव्यक्त अर्थ इंडेक्सिंग) का उपयोग करने जा रहे हैं।

लोड हो रहा है डेटा सेट

from sklearn.datasets import fetch_20newsgroups
newsgroups_train = fetch_20newsgroups(subset='train')

आइए निम्नलिखित स्क्रिप्ट की मदद से कुछ नमूना समाचार देखें -

newsgroups_train.data[:4]
["From: [email protected] (where's my thing)\nSubject: 
WHAT car is this!?\nNntp-Posting-Host: rac3.wam.umd.edu\nOrganization: 
University of Maryland, College Park\nLines: 15\n\n 
I was wondering if anyone out there could enlighten me on this car 
I saw\nthe other day. It was a 2-door sports car,
looked to be from the late 60s/\nearly 70s. It was called a Bricklin. 
The doors were really small. In addition,\nthe front bumper was separate from 
the rest of the body. This is \nall I know. If anyone can tellme a model name, 
engine specs, years\nof production, where this car is made, history, or 
whatever info you\nhave on this funky looking car, 
please e-mail.\n\nThanks,\n- IL\n ---- brought to you by your neighborhood 
Lerxst ----\n\n\n\n\n",

"From: [email protected] (Guy Kuo)\nSubject: 
SI Clock Poll - Final Call\nSummary: Final call for SI clock reports\nKeywords: 
SI,acceleration,clock,upgrade\nArticle-I.D.: shelley.1qvfo9INNc3s\nOrganization: 
University of Washington\nLines: 11\nNNTP-Posting-Host: carson.u.washington.edu\n\nA 
fair number of brave souls who upgraded their SI clock oscillator have\nshared their 
experiences for this poll. Please send a brief message detailing\nyour experiences with 
the procedure. Top speed attained, CPU rated speed,\nadd on cards and adapters, heat 
sinks, hour of usage per day, floppy disk\nfunctionality with 800 and 1.4 m floppies 
are especially requested.\n\nI will be summarizing in the next two days, so please add 
to the network\nknowledge base if you have done the clock upgrade and haven't answered 
this\npoll. Thanks.\n\nGuy Kuo <[email protected]>\n",

'From: [email protected] (Thomas E Willis)\nSubject: 
PB questions...\nOrganization: Purdue University Engineering Computer 
Network\nDistribution: usa\nLines: 36\n\nwell folks, my mac plus finally gave up the 
ghost this weekend after\nstarting life as a 512k way back in 1985. sooo, i\'m in the 
market for a\nnew machine a bit sooner than i intended to be...\n\ni\'m looking into 
picking up a powerbook 160 or maybe 180 and have a bunch\nof questions that (hopefully) 
somebody can answer:\n\n* does anybody know any dirt on when the next round of 
powerbook\nintroductions are expected? i\'d heard the 185c was supposed to make 
an\nappearence "this summer" but haven\'t heard anymore on it - and since i\ndon\'t 
have access to macleak, i was wondering if anybody out there had\nmore info...\n\n* has 
anybody heard rumors about price drops to the powerbook line like the\nones the duo\'s 
just went through recently?\n\n* what\'s the impression of the display on the 180? i 
could probably swing\na 180 if i got the 80Mb disk rather than the 120, but i don\'t 
really have\na feel for how much "better" the display is (yea, it looks great in 
the\nstore, but is that all "wow" or is it really that good?). could i solicit\nsome 
opinions of people who use the 160 and 180 day-to-day on if its worth\ntaking the disk 
size and money hit to get the active display? (i realize\nthis is a real subjective 
question, but i\'ve only played around with the\nmachines in a computer store breifly 
and figured the opinions of somebody\nwho actually uses the machine daily might prove 
helpful).\n\n* how well does hellcats perform? ;)\n\nthanks a bunch in advance for any 
info - if you could email, i\'ll post a\nsummary (news reading time is at a premium 
with finals just around the\ncorner... :( )\n--\nTom Willis \\ [email protected] 
\\ Purdue Electrical 
Engineering\n---------------------------------------------------------------------------\
n"Convictions are more dangerous enemies of truth than lies." - F. W.\nNietzsche\n',

'From: jgreen@amber (Joe Green)\nSubject: Re: Weitek P9000 ?\nOrganization: Harris 
Computer Systems Division\nLines: 14\nDistribution: world\nNNTP-Posting-Host: 
amber.ssd.csd.harris.com\nX-Newsreader: TIN [version 1.1 PL9]\n\nRobert J.C. Kyanko 
([email protected]) wrote:\n > [email protected] writes in article <
[email protected]>:\n> > Anyone know about the Weitek P9000 
graphics chip?\n > As far as the low-level stuff goes, it looks pretty nice. It\'s 
got this\n > quadrilateral fill command that requires just the four
points.\n\nDo you have Weitek\'s address/phone number? I\'d like to get some 
information\nabout this chip.\n\n--\nJoe Green\t\t\t\tHarris 
Corporation\[email protected]\t\t\tComputer Systems Division\n"The only thing that 
really scares me is a person with no sense of humor."\n\t\t\t\t\t\t-- Jonathan 
Winters\n']

शर्त

import nltk;
nltk.download('stopwords')
nlp = spacy.load('en_core_web_md', disable=['parser', 'ner'])

आवश्यक पैकेज आयात करना

LSI मॉडल बनाने के लिए हमें आवश्यक पैकेज का पालन करना होगा -

import re
import numpy as np
import pandas as pd
from pprint import pprint
import gensim
import gensim.corpora as corpora
from gensim.utils import simple_preprocess
from gensim.models import CoherenceModel
import spacy
import matplotlib.pyplot as plt

स्टॉपवर्ड्स तैयार करना

अब हमें Stopwords को आयात करने और उनका उपयोग करने की आवश्यकता है -

from nltk.corpus import stopwords
stop_words = stopwords.words('english')
stop_words.extend(['from', 'subject', 're', 'edu', 'use'])

पाठ को साफ करें

def sent_to_words(sentences):
   for sentence in sentences:
      yield(gensim.utils.simple_preprocess(str(sentence), deacc=True))
data_words = list(sent_to_words(data))

बिल्डिंग बिग्राम और ट्रिग्राम मॉडल

जैसा कि हम जानते हैं कि बिग्रेड दो शब्द हैं जो अक्सर दस्तावेज़ में एक साथ होते हैं और ट्रिग्राम तीन शब्द होते हैं जो अक्सर दस्तावेज़ में एक साथ होते हैं। Gensim के वाक्यांश मॉडल की मदद से, हम यह कर सकते हैं -

bigram = gensim.models.Phrases(data_words, min_count=5, threshold=100)
trigram = gensim.models.Phrases(bigram[data_words], threshold=100)
bigram_mod = gensim.models.phrases.Phraser(bigram)
trigram_mod = gensim.models.phrases.Phraser(trigram)

Stopwords को फ़िल्टर करें

def remove_stopwords(texts):
   return [[word for word in simple_preprocess(str(doc)) 
   if word not in stop_words] for doc in texts]
def make_bigrams(texts):
   return [bigram_mod[doc] for doc in texts]
def make_trigrams(texts):
   return [trigram_mod[bigram_mod[doc]] for doc in texts]
def lemmatization(texts, allowed_postags=['NOUN', 'ADJ', 'VERB', 'ADV']):
   texts_out = []
   for sent in texts:
      doc = nlp(" ".join(sent))
      texts_out.append([token.lemma_ for token in doc if token.pos_ in allowed_postags])
   return texts_out

टॉपिक मॉडल के लिए बिल्डिंग डिक्शनरी और कॉर्पस

id2word = corpora.Dictionary(data_lemmatized)
texts = data_lemmatized
corpus = [id2word.doc2bow(text) for text in texts]

LSI विषय मॉडल का निर्माण

हमने पहले से ही एलएसआई मॉडल को प्रशिक्षित करने के लिए आवश्यक सभी चीजों को लागू किया है। अब, यह LSI विषय मॉडल बनाने का समय है। हमारे कार्यान्वयन उदाहरण के लिए, यह कोड की निम्नलिखित पंक्ति की सहायता से किया जा सकता है -

lsi_model = gensim.models.lsimodel.LsiModel(
   corpus=corpus, id2word=id2word, num_topics=20,chunksize=100
)

कार्यान्वयन उदाहरण

आइए देखें एलडीए विषय मॉडल बनाने के लिए पूरा कार्यान्वयन उदाहरण -

import re
import numpy as np
import pandas as pd
from pprint import pprint
import gensim
import gensim.corpora as corpora
from gensim.utils import simple_preprocess
from gensim.models import CoherenceModel
import spacy
import matplotlib.pyplot as plt
from nltk.corpus import stopwords
stop_words = stopwords.words('english')
stop_words.extend(['from', 'subject', 're', 'edu', 'use'])
from sklearn.datasets import fetch_20newsgroups
newsgroups_train = fetch_20newsgroups(subset='train')
data = newsgroups_train.data
data = [re.sub('\S*@\S*\s?', '', sent) for sent in data]
data = [re.sub('\s+', ' ', sent) for sent in data]
data = [re.sub("\'", "", sent) for sent in data]
print(data_words[:4]) #it will print the data after prepared for stopwords
bigram = gensim.models.Phrases(data_words, min_count=5, threshold=100)
trigram = gensim.models.Phrases(bigram[data_words], threshold=100)
bigram_mod = gensim.models.phrases.Phraser(bigram)
trigram_mod = gensim.models.phrases.Phraser(trigram)
def remove_stopwords(texts):
   return [[word for word in simple_preprocess(str(doc)) 
   if word not in stop_words] for doc in texts]
def make_bigrams(texts):
   return [bigram_mod[doc] for doc in texts]
def make_trigrams(texts):
   return [trigram_mod[bigram_mod[doc]] for doc in texts]
def lemmatization(texts, allowed_postags=['NOUN', 'ADJ', 'VERB', 'ADV']):
   texts_out = []
   for sent in texts:
      doc = nlp(" ".join(sent))
      texts_out.append([token.lemma_ for token in doc if token.pos_ in allowed_postags])
return texts_out
data_words_nostops = remove_stopwords(data_words)
data_words_bigrams = make_bigrams(data_words_nostops)
nlp = spacy.load('en_core_web_md', disable=['parser', 'ner'])
data_lemmatized = lemmatization(
   data_words_bigrams, allowed_postags=['NOUN', 'ADJ', 'VERB', 'ADV']
)
print(data_lemmatized[:4]) #it will print the lemmatized data.
id2word = corpora.Dictionary(data_lemmatized)
texts = data_lemmatized
corpus = [id2word.doc2bow(text) for text in texts]
print(corpus[:4]) #it will print the corpus we created above.
[[(id2word[id], freq) for id, freq in cp] for cp in corpus[:4]] 
#it will print the words with their frequencies.
lsi_model = gensim.models.lsimodel.LsiModel(
   corpus=corpus, id2word=id2word, num_topics=20,chunksize=100
)

अब हम विषयों को प्राप्त करने के लिए उपरोक्त बनाए गए LSI मॉडल का उपयोग कर सकते हैं।

एलएसआई मॉडल में विषय देखना

LSI मॉडल (lsi_model)हमने ऊपर बनाया है इसका उपयोग दस्तावेजों से विषयों को देखने के लिए किया जा सकता है। यह निम्नलिखित स्क्रिप्ट की मदद से किया जा सकता है -

pprint(lsi_model.print_topics())
doc_lsi = lsi_model[corpus]

उत्पादन

[
   (0,
   '1.000*"ax" + 0.001*"_" + 0.000*"tm" + 0.000*"part" +    0.000*"pne" + '
   '0.000*"biz" + 0.000*"mbs" + 0.000*"end" + 0.000*"fax" + 0.000*"mb"'),
   (1,
   '0.239*"say" + 0.222*"file" + 0.189*"go" + 0.171*"know" + 0.169*"people" + '
   '0.147*"make" + 0.140*"use" + 0.135*"also" + 0.133*"see" + 0.123*"think"')
]

पदानुक्रमित डिरिलेट प्रक्रिया (एचपीडी)

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

गेंसिम के साथ कार्यान्वयन

Gensim में HDP को लागू करने के लिए, हमें corpus और Dictionary (जैसा कि LDA और LSI विषय मॉडल को लागू करते समय उपरोक्त उदाहरणों में दिया गया है) को प्रशिक्षित करने की आवश्यकता है, HDP विषय मॉडल जिसे हम gensim.models.HdpModel से आयात कर सकते हैं। यहां हम 20Newsgroup डेटा पर HDP विषय मॉडल भी लागू करेंगे और चरण भी समान हैं।

हमारे कॉर्पस और डिक्शनरी के लिए (LSI और LDA मॉडल के लिए उपरोक्त उदाहरणों में), हम HdpModel को निम्न प्रकार से आयात कर सकते हैं:

Hdp_model = gensim.models.hdpmodel.HdpModel(corpus=corpus, id2word=id2word)

एलएसआई मॉडल में विषय देखना

HDP मॉडल (Hdp_model)दस्तावेजों से विषयों को देखने के लिए इस्तेमाल किया जा सकता है। यह निम्नलिखित स्क्रिप्ट की मदद से किया जा सकता है -

pprint(Hdp_model.print_topics())

उत्पादन

[
   (0,
   '0.009*line + 0.009*write + 0.006*say + 0.006*article + 0.006*know + '
   '0.006*people + 0.005*make + 0.005*go + 0.005*think + 0.005*be'),
   (1,
   '0.016*line + 0.011*write + 0.008*article + 0.008*organization + 0.006*know '
   '+ 0.006*host + 0.006*be + 0.005*get + 0.005*use + 0.005*say'),
   (2,
   '0.810*ax + 0.001*_ + 0.000*tm + 0.000*part + 0.000*mb + 0.000*pne + '
   '0.000*biz + 0.000*end + 0.000*wwiz + 0.000*fax'),
   (3,
   '0.015*line + 0.008*write + 0.007*organization + 0.006*host + 0.006*know + '
   '0.006*article + 0.005*use + 0.005*thank + 0.004*get + 0.004*problem'),
   (4,
   '0.004*line + 0.003*write + 0.002*believe + 0.002*think + 0.002*article + '
   '0.002*belief + 0.002*say + 0.002*see + 0.002*look + 0.002*organization'),
   (5,
   '0.005*line + 0.003*write + 0.003*organization + 0.002*article + 0.002*time '
   '+ 0.002*host + 0.002*get + 0.002*look + 0.002*say + 0.001*number'),
   (6,
   '0.003*line + 0.002*say + 0.002*write + 0.002*go + 0.002*gun + 0.002*get + '
   '0.002*organization + 0.002*bill + 0.002*article + 0.002*state'),
   (7,
   '0.003*line + 0.002*write + 0.002*article + 0.002*organization + 0.001*none '
   '+ 0.001*know + 0.001*say + 0.001*people + 0.001*host + 0.001*new'),
   (8,
   '0.004*line + 0.002*write + 0.002*get + 0.002*team + 0.002*organization + '
   '0.002*go + 0.002*think + 0.002*know + 0.002*article + 0.001*well'),
   (9,
   '0.004*line + 0.002*organization + 0.002*write + 0.001*be + 0.001*host + '
   '0.001*article + 0.001*thank + 0.001*use + 0.001*work + 0.001*run'),
   (10,
   '0.002*line + 0.001*game + 0.001*write + 0.001*get + 0.001*know + '
   '0.001*thing + 0.001*think + 0.001*article + 0.001*help + 0.001*turn'),
   (11,
   '0.002*line + 0.001*write + 0.001*game + 0.001*organization + 0.001*say + '
   '0.001*host + 0.001*give + 0.001*run + 0.001*article + 0.001*get'),
   (12,
   '0.002*line + 0.001*write + 0.001*know + 0.001*time + 0.001*article + '
   '0.001*get + 0.001*think + 0.001*organization + 0.001*scope + 0.001*make'),
   (13,
   '0.002*line + 0.002*write + 0.001*article + 0.001*organization + 0.001*make '
   '+ 0.001*know + 0.001*see + 0.001*get + 0.001*host + 0.001*really'),
   (14,
   '0.002*write + 0.002*line + 0.002*know + 0.001*think + 0.001*say + '
   '0.001*article + 0.001*argument + 0.001*even + 0.001*card + 0.001*be'),
   (15,
   '0.001*article + 0.001*line + 0.001*make + 0.001*write + 0.001*know + '
   '0.001*say + 0.001*exist + 0.001*get + 0.001*purpose + 0.001*organization'),
   (16,
   '0.002*line + 0.001*write + 0.001*article + 0.001*insurance + 0.001*go + '
   '0.001*be + 0.001*host + 0.001*say + 0.001*organization + 0.001*part'),
   (17,
   '0.001*line + 0.001*get + 0.001*hit + 0.001*go + 0.001*write + 0.001*say + '
   '0.001*know + 0.001*drug + 0.001*see + 0.001*need'),
   (18,
   '0.002*option + 0.001*line + 0.001*flight + 0.001*power + 0.001*software + '
   '0.001*write + 0.001*add + 0.001*people + 0.001*organization + 0.001*module'),
   (19,
   '0.001*shuttle + 0.001*line + 0.001*roll + 0.001*attitude + 0.001*maneuver + '
   '0.001*mission + 0.001*also + 0.001*orbit + 0.001*produce + 0.001*frequency')
]

अध्याय हमें Gensim में शब्द एम्बेडिंग को समझने में मदद करेगा।

वर्ड एम्बेडिंग, शब्दों और दस्तावेज़ का प्रतिनिधित्व करने के लिए दृष्टिकोण, पाठ के लिए एक सघन वेक्टर प्रतिनिधित्व है जहाँ समान अर्थ वाले शब्दों का समान प्रतिनिधित्व होता है। शब्द एम्बेड करने की कुछ विशेषताएँ निम्नलिखित हैं -

यह तकनीक का एक वर्ग है जो पूर्व-परिभाषित वेक्टर अंतरिक्ष में वास्तविक-मूल्यवान वैक्टर के रूप में व्यक्तिगत शब्दों का प्रतिनिधित्व करता है।
इस तकनीक को अक्सर DL (डीप लर्निंग) के क्षेत्र में ढकेल दिया जाता है क्योंकि हर शब्द को एक वेक्टर में मैप किया जाता है और वेक्टर मानों को उसी तरह से सीखा जाता है जिस तरह से एक NN (न्यूरल नेटवर्क्स) करता है।
शब्द एम्बेडिंग तकनीक का मुख्य दृष्टिकोण हर शब्द के लिए एक सघन वितरित प्रतिनिधित्व है।

विभिन्न वर्ड एंबेडिंग मेथड्स / एल्गोरिदम

जैसा कि ऊपर चर्चा की गई है, शब्द एम्बेड करने के तरीके / एल्गोरिदम पाठ के एक कोष से वास्तविक-मूल्यवान वेक्टर प्रतिनिधित्व सीखते हैं। यह सीखने की प्रक्रिया या तो NN मॉडल के साथ डॉक्यूमेंट के वर्गीकरण जैसे कार्य का उपयोग कर सकती है या एक असुरक्षित प्रक्रिया है जैसे डॉक्यूमेंट के आँकड़े। यहां हम दो तरीकों / एल्गोरिथ्म पर चर्चा करने जा रहे हैं जिनका उपयोग पाठ से शब्द को सीखने के लिए किया जा सकता है -

Google द्वारा Word2Vec

टॉमस मिकोलोव, एट द्वारा विकसित वर्ड 2 वीईसी। अल। 2013 में Google पर, पाठ कोष से एम्बेड किए गए किसी शब्द को कुशलतापूर्वक सीखने के लिए एक सांख्यिकीय पद्धति है। यह वास्तव में एनएन आधारित शब्द प्रशिक्षण को और अधिक कुशल बनाने के लिए एक प्रतिक्रिया के रूप में विकसित किया गया है। यह शब्द एम्बेडिंग के लिए वास्तविक मानक बन गया है।

Word2Vec द्वारा शब्द एम्बेडिंग में सीखे हुए वैक्टरों के विश्लेषण के साथ-साथ शब्दों के प्रतिनिधित्व पर वेक्टर गणित की खोज शामिल है। निम्नलिखित दो अलग-अलग शिक्षण विधियाँ हैं जिनका उपयोग Word2Vec विधि के भाग के रूप में किया जा सकता है -

CBoW (शब्दों का निरंतर थैला) मॉडल
सतत स्किप-ग्राम मॉडल

स्टैंडफोर्ड द्वारा ग्लोव

GloVe (वर्ड प्रतिनिधि के लिए ग्लोबल वैक्टर), Word2Vec विधि का विस्तार है। यह पेनिंगटन एट अल द्वारा विकसित किया गया था। स्टैनफोर्ड में। GloVe एल्गोरिथ्म दोनों का मिश्रण है -

एलएसए (अव्यक्त अर्थ विश्लेषण) जैसे मैट्रिक्स फैक्टराइजेशन तकनीकों के वैश्विक आंकड़े
Word2Vec में स्थानीय संदर्भ-आधारित शिक्षा।

अगर हम इसके काम के बारे में बात करते हैं तो स्थानीय संदर्भ को परिभाषित करने के लिए एक विंडो का उपयोग करने के बजाय, GloVe पूरे पाठ कॉर्पस के आंकड़ों का उपयोग करके एक स्पष्ट शब्द सह-घटना मैट्रिक्स का निर्माण करता है।

Word2Vec एंबेडिंग का विकास करना

यहां, हम Gensim का उपयोग करके Word2Vec एम्बेडिंग विकसित करेंगे। Word2Vec मॉडल के साथ काम करने के लिए, Gensim हमें प्रदान करता हैWord2Vec वर्ग जो आयात किया जा सकता है models.word2vec। इसके कार्यान्वयन के लिए, word2vec को बहुत सारे पाठ की आवश्यकता होती है जैसे संपूर्ण अमेज़ॅन समीक्षा कॉर्पस। लेकिन यहां, हम इस सिद्धांत को स्मॉल-इन मेमोरी टेक्स्ट पर लागू करेंगे।

कार्यान्वयन उदाहरण

सबसे पहले हमें gensim.models से Word2Vec वर्ग को निम्नानुसार आयात करना होगा -

from gensim.models import Word2Vec

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

sentences = [
   ['this', 'is', 'gensim', 'tutorial', 'for', 'free'],
   ['this', 'is', 'the', 'tutorials' 'point', 'website'],
   ['you', 'can', 'read', 'technical','tutorials', 'for','free'],
   ['we', 'are', 'implementing','word2vec'],
   ['learn', 'full', 'gensim', 'tutorial']
]

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

model = Word2Vec(sentences, min_count=1)

हम मॉडल को संक्षेप में निम्नानुसार कर सकते हैं -;

print(model)

हम निम्नानुसार शब्दावली को संक्षेप में प्रस्तुत कर सकते हैं -

words = list(model.wv.vocab)
print(words)

अगला, आइए एक शब्द के लिए वेक्टर तक पहुंचें। हम इसे 'ट्यूटोरियल' शब्द के लिए कर रहे हैं।

print(model['tutorial'])

अगला, हमें मॉडल को बचाने की आवश्यकता है -

model.save('model.bin')

अगला, हमें मॉडल लोड करने की आवश्यकता है -

new_model = Word2Vec.load('model.bin')

अंत में, सहेजे गए मॉडल को निम्नानुसार प्रिंट करें -

print(new_model)

पूर्ण कार्यान्वयन उदाहरण

from gensim.models import Word2Vec
sentences = [
   ['this', 'is', 'gensim', 'tutorial', 'for', 'free'],
   ['this', 'is', 'the', 'tutorials' 'point', 'website'],
   ['you', 'can', 'read', 'technical','tutorials', 'for','free'],
   ['we', 'are', 'implementing','word2vec'],
   ['learn', 'full', 'gensim', 'tutorial']
]
model = Word2Vec(sentences, min_count=1)
print(model)
words = list(model.wv.vocab)
print(words)
print(model['tutorial'])
model.save('model.bin')
new_model = Word2Vec.load('model.bin')
print(new_model)

उत्पादन

Word2Vec(vocab=20, size=100, alpha=0.025)
[
   'this', 'is', 'gensim', 'tutorial', 'for', 'free', 'the', 'tutorialspoint', 
   'website', 'you', 'can', 'read', 'technical', 'tutorials', 'we', 'are', 
   'implementing', 'word2vec', 'learn', 'full'
]
[
   -2.5256255e-03 -4.5352755e-03 3.9024993e-03 -4.9509313e-03
   -1.4255195e-03 -4.0217536e-03 4.9407515e-03 -3.5925603e-03
   -1.1933431e-03 -4.6682903e-03 1.5440651e-03 -1.4101702e-03
   3.5070938e-03 1.0914479e-03 2.3334436e-03 2.4452661e-03
   -2.5336299e-04 -3.9676363e-03 -8.5054158e-04 1.6443320e-03
   -4.9968651e-03 1.0974540e-03 -1.1123562e-03 1.5393364e-03
   9.8941079e-04 -1.2656028e-03 -4.4471184e-03 1.8309267e-03
   4.9302122e-03 -1.0032534e-03 4.6892050e-03 2.9563988e-03
   1.8730218e-03 1.5343715e-03 -1.2685956e-03 8.3664013e-04
   4.1721235e-03 1.9445885e-03 2.4097660e-03 3.7517555e-03
   4.9687522e-03 -1.3598346e-03 7.1032363e-04 -3.6595813e-03
   6.0000515e-04 3.0872561e-03 -3.2115565e-03 3.2270295e-03
   -2.6354722e-03 -3.4988276e-04 1.8574356e-04 -3.5757164e-03
   7.5391348e-04 -3.5205986e-03 -1.9795434e-03 -2.8321696e-03
   4.7155009e-03 -4.3349937e-04 -1.5320212e-03 2.7013756e-03
   -3.7055744e-03 -4.1658725e-03 4.8034848e-03 4.8594419e-03
   3.7129463e-03 4.2385766e-03 2.4612297e-03 5.4920948e-04
   -3.8912550e-03 -4.8226118e-03 -2.2763973e-04 4.5571579e-03
   -3.4609400e-03 2.7903817e-03 -3.2709218e-03 -1.1036445e-03
   2.1492650e-03 -3.0384419e-04 1.7709908e-03 1.8429896e-03
   -3.4038599e-03 -2.4872608e-03 2.7693063e-03 -1.6352943e-03
   1.9182395e-03 3.7772327e-03 2.2769428e-03 -4.4629495e-03
   3.3151123e-03 4.6509290e-03 -4.8521687e-03 6.7615538e-04
   3.1034781e-03 2.6369948e-05 4.1454583e-03 -3.6932561e-03
   -1.8769916e-03 -2.1958587e-04 6.3395966e-04 -2.4969708e-03
]
Word2Vec(vocab=20, size=100, alpha=0.025)

विज़ुअलाइज़िंग वर्ड एंबेडिंग

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

पीसीए का उपयोग करते हुए वर्ड वैक्टर को प्लॉट करना

सबसे पहले, हमें एक प्रशिक्षित मॉडल से सभी वैक्टरों को पुनः प्राप्त करने की आवश्यकता है -

Z = model[model.wv.vocab]

अगला, हमें पीसीए वर्ग का उपयोग करके शब्द वैक्टरों का 2-डी पीसीए मॉडल बनाना होगा -

pca = PCA(n_components=2)
result = pca.fit_transform(Z)

अब, हम matplotlib का उपयोग करके परिणामी प्रक्षेपण की साजिश कर सकते हैं -

Pyplot.scatter(result[:,0],result[:,1])

हम शब्दों के साथ ग्राफ पर बिंदुओं को भी एनोटेट कर सकते हैं। निम्न के रूप में matplotlib का उपयोग करके परिणामी प्रक्षेपण प्लॉट करें -

words = list(model.wv.vocab)
for i, word in enumerate(words):
   pyplot.annotate(word, xy=(result[i, 0], result[i, 1]))

पूर्ण कार्यान्वयन उदाहरण

from gensim.models import Word2Vec
from sklearn.decomposition import PCA
from matplotlib import pyplot
sentences = [
   ['this', 'is', 'gensim', 'tutorial', 'for', 'free'],
	['this', 'is', 'the', 'tutorials' 'point', 'website'],
	['you', 'can', 'read', 'technical','tutorials', 'for','free'],
	['we', 'are', 'implementing','word2vec'],
	['learn', 'full', 'gensim', 'tutorial']
]
model = Word2Vec(sentences, min_count=1)
X = model[model.wv.vocab]
pca = PCA(n_components=2)
result = pca.fit_transform(X)
pyplot.scatter(result[:, 0], result[:, 1])
words = list(model.wv.vocab)
for i, word in enumerate(words):
   pyplot.annotate(word, xy=(result[i, 0], result[i, 1]))
pyplot.show()

उत्पादन

D22Vec मॉडल, Word2Vec मॉडल के विपरीत, एक इकाई के रूप में सामूहिक रूप से लिए गए शब्दों के समूह का एक वेक्टर प्रतिनिधित्व बनाने के लिए उपयोग किया जाता है। यह केवल वाक्य में शब्दों का सरल औसत नहीं देता है।

Doc2Vec का उपयोग करके दस्तावेज़ क्षेत्र बनाना

Doc2Vec का उपयोग करके दस्तावेज़ वैक्टर बनाने के लिए, हम text8 डेटासेट का उपयोग करेंगे, जिसे डाउनलोड किया जा सकता है gensim.downloader।

डाटसेट डाउनलोड करना

हम निम्नलिखित आदेशों का उपयोग करके text8 डेटासेट डाउनलोड कर सकते हैं -

import gensim
import gensim.downloader as api
dataset = api.load("text8")
data = [d for d in dataset]

टेक्स्ट 8 डेटासेट डाउनलोड करने में कुछ समय लगेगा।

Doc2Vec को प्रशिक्षित करें

मॉडल को प्रशिक्षित करने के लिए, हमें टैग किए गए दस्तावेज़ की आवश्यकता है जिसे उपयोग करके बनाया जा सकता है models.doc2vec.TaggedDcument() निम्नानुसार है -

def tagged_document(list_of_list_of_words):
   for i, list_of_words in enumerate(list_of_list_of_words):
      yield gensim.models.doc2vec.TaggedDocument(list_of_words, [i])
data_for_training = list(tagged_document(data))

हम प्रशिक्षित डेटासेट निम्नानुसार प्रिंट कर सकते हैं -

print(data_for_training [:1])

उत्पादन

[TaggedDocument(words=['anarchism', 'originated', 'as', 'a', 'term', 'of',
'abuse', 'first', 'used', 'against', 'early', 'working', 'class', 'radicals',
'including', 'the', 'diggers', 'of', 'the', 'english', 'revolution', 
'and', 'the', 'sans', 'culottes', 'of', 'the', 'french', 'revolution',
'whilst', 'the', 'term', 'is', 'still', 'used', 'in', 'a', 'pejorative',
'way', 'to', 'describe', 'any', 'act', 'that', 'used', 'violent', 
'means', 'to', 'destroy',
'the', 'organization', 'of', 'society', 'it', 'has', 'also', 'been'
, 'taken', 'up', 'as', 'a', 'positive', 'label', 'by', 'self', 'defined',
'anarchists', 'the', 'word', 'anarchism', 'is', 'derived', 'from', 'the',
'greek', 'without', 'archons', 'ruler', 'chief', 'king', 'anarchism', 
'as', 'a', 'political', 'philosophy', 'is', 'the', 'belief', 'that', 
'rulers', 'are', 'unnecessary', 'and', 'should', 'be', 'abolished',
'although', 'there', 'are', 'differing', 'interpretations', 'of', 
'what', 'this', 'means', 'anarchism', 'also', 'refers', 'to', 
'related', 'social', 'movements', 'that', 'advocate', 'the', 
'elimination', 'of', 'authoritarian', 'institutions', 'particularly',
'the', 'state', 'the', 'word', 'anarchy', 'as', 'most', 'anarchists', 
'use', 'it', 'does', 'not', 'imply', 'chaos', 'nihilism', 'or', 'anomie',
'but', 'rather', 'a', 'harmonious', 'anti', 'authoritarian', 'society', 
'in', 'place', 'of', 'what', 'are', 'regarded', 'as', 'authoritarian',
'political', 'structures', 'and', 'coercive', 'economic', 'institutions', 
'anarchists', 'advocate', 'social', 'relations', 'based', 'upon', 'voluntary',
'association', 'of', 'autonomous', 'individuals', 'mutual', 'aid', 'and', 
'self', 'governance', 'while', 'anarchism', 'is', 'most', 'easily', 'defined',
'by', 'what', 'it', 'is', 'against', 'anarchists', 'also', 'offer', 
'positive', 'visions', 'of', 'what', 'they', 'believe', 'to', 'be', 'a',
'truly', 'free', 'society', 'however', 'ideas', 'about', 'how', 'an', 'anarchist',
'society', 'might', 'work', 'vary', 'considerably', 'especially', 'with',
'respect', 'to', 'economics', 'there', 'is', 'also', 'disagreement', 'about', 
'how', 'a', 'free', 'society', 'might', 'be', 'brought', 'about', 'origins', 
'and', 'predecessors', 'kropotkin', 'and', 'others', 'argue', 'that', 'before',
'recorded', 'history', 'human', 'society', 'was', 'organized', 'on', 'anarchist', 
'principles', 'most', 'anthropologists', 'follow', 'kropotkin', 'and', 'engels', 
'in', 'believing', 'that', 'hunter', 'gatherer', 'bands', 'were', 'egalitarian',
'and', 'lacked', 'division', 'of', 'labour', 'accumulated', 'wealth', 'or', 'decreed',
'law', 'and', 'had', 'equal', 'access', 'to', 'resources', 'william', 'godwin', 
'anarchists', 'including', 'the', 'the', 'anarchy', 'organisation', 'and', 'rothbard',
'find', 'anarchist', 'attitudes', 'in', 'taoism', 'from', 'ancient', 'china', 
'kropotkin', 'found', 'similar', 'ideas', 'in', 'stoic', 'zeno', 'of', 'citium', 
'according', 'to', 'kropotkin', 'zeno', 'repudiated', 'the', 'omnipotence', 'of',
'the', 'state', 'its', 'intervention', 'and', 'regimentation', 'and', 'proclaimed',
'the', 'sovereignty', 'of', 'the', 'moral', 'law', 'of', 'the', 'individual', 'the',
'anabaptists', 'of', 'one', 'six', 'th', 'century', 'europe', 'are', 'sometimes',
'considered', 'to', 'be', 'religious', 'forerunners', 'of', 'modern', 'anarchism',
'bertrand', 'russell', 'in', 'his', 'history', 'of', 'western', 'philosophy', 
'writes', 'that', 'the', 'anabaptists', 'repudiated', 'all', 'law', 'since', 
'they', 'held', 'that', 'the', 'good', 'man', 'will', 'be', 'guided', 'at', 
'every', 'moment', 'by', 'the', 'holy', 'spirit', 'from', 'this', 'premise',
'they', 'arrive', 'at', 'communism', 'the', 'diggers', 'or', 'true', 'levellers', 
'were', 'an', 'early', 'communistic', 'movement',
(truncated…)

मॉडल को इनिशियलाइज़ करें

एक बार प्रशिक्षित होने के बाद हमें अब मॉडल को इनिशियलाइज़ करना होगा। इसे निम्नानुसार किया जा सकता है -

model = gensim.models.doc2vec.Doc2Vec(vector_size=40, min_count=2, epochs=30)

अब, निम्नानुसार शब्दावली का निर्माण करें -

model.build_vocab(data_for_training)

अब, Doc2Vec मॉडल को निम्नानुसार प्रशिक्षित करें -

model.train(data_for_training, total_examples=model.corpus_count, epochs=model.epochs)

आउटपुट का विश्लेषण

अंत में, हम model.infer_vector () का उपयोग करके आउटपुट का विश्लेषण कर सकते हैं -

print(model.infer_vector(['violent', 'means', 'to', 'destroy', 'the','organization']))

पूर्ण कार्यान्वयन उदाहरण

import gensim
import gensim.downloader as api
dataset = api.load("text8")
data = [d for d in dataset]
def tagged_document(list_of_list_of_words):
   for i, list_of_words in enumerate(list_of_list_of_words):
      yield gensim.models.doc2vec.TaggedDocument(list_of_words, [i])
data_for_training = list(tagged_document(data))
print(data_for_training[:1])
model = gensim.models.doc2vec.Doc2Vec(vector_size=40, min_count=2, epochs=30)
model.build_vocab(data_training)
model.train(data_training, total_examples=model.corpus_count, epochs=model.epochs)
print(model.infer_vector(['violent', 'means', 'to', 'destroy', 'the','organization']))

उत्पादन

[
   -0.2556166 0.4829361 0.17081228 0.10879577 0.12525807 0.10077011
   -0.21383236 0.19294572 0.11864349 -0.03227958 -0.02207291 -0.7108424
   0.07165232 0.24221905 -0.2924459 -0.03543589 0.21840079 -0.1274817
   0.05455418 -0.28968817 -0.29146606 0.32885507 0.14689675 -0.06913587
   -0.35173815 0.09340707 -0.3803535 -0.04030455 -0.10004586 0.22192696
   0.2384828 -0.29779273 0.19236489 -0.25727913 0.09140676 0.01265439
   0.08077634 -0.06902497 -0.07175519 -0.22583418 -0.21653089 0.00347822
   -0.34096122 -0.06176808 0.22885063 -0.37295452 -0.08222228 -0.03148199
   -0.06487323 0.11387568
]