😲 ♾ 🕢 वास्तविक दुनिया में एलडीए लॉन्च करें। विस्तृत गाइड 👴🏼 💧 👛

प्रस्तावना

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

"अनुकरणीय" डेटासेट के उदाहरण पर प्रशिक्षण की एक विशेषता यह है कि वहां डेटा हमेशा क्रम में होता है और आसानी से एक जगह पर ढेर हो जाता है। उत्पादन मॉडल का प्रशिक्षण देते समय, वास्तविक स्रोतों से सीधे प्राप्त डेटा आमतौर पर विपरीत होता है:

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

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

विषय मॉडलिंग और एलडीए।

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

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

एक दस्तावेज़ दस्तावेज़ मैट्रिक्स एक मैट्रिक्स है जिसका आकार होता है $एन \ _ डब्लू$ जहाँ
एन मामले में दस्तावेजों की संख्या है, और डब्ल्यू मामले के शब्दकोश का आकार है, अर्थात। शब्दों की संख्या (अद्वितीय) जो हमारे कॉर्पस में पाए जाते हैं। I-th पंक्ति में, मैट्रिक्स का j-th कॉलम एक संख्या है - i-th पाठ में कितनी बार j-th शब्द मिला था।

एलडीए का निर्माण, दिए गए टर्म दस्तावेज़ मैट्रिक्स और विषयों की पूर्व निर्धारित संख्या के टी के लिए दो वितरण:

ग्रंथों में विषयों का वितरण। (व्यवहार में, आकार मैट्रिक्स द्वारा दिया गया है $एन \ _ टी$ )
विषय द्वारा शब्दों का वितरण। (आकार मैट्रिक्स) $T \ गुना W$ )

इन मैट्रिसेस की कोशिकाओं के मूल्य क्रमशः, संभावनाएं हैं कि यह विषय इस दस्तावेज़ में निहित है (या दस्तावेज़ में विषय का अनुपात, यदि हम दस्तावेज़ को विभिन्न विषयों के मिश्रण के रूप में मानते हैं) मैट्रिक्स के लिए 'ग्रंथों में विषयों का वितरण'।

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

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

यदि आप अधिक विस्तार से अध्ययन करने में रुचि रखते हैं और 'फ़ार्मुलों' में एलडीए कैसे प्रशिक्षित और काम करता है, तो यहां कुछ सामग्रियां हैं (जिनका उपयोग लेखक द्वारा किया गया था):

हमें वाइल्ड डेटा मिलता है

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

हम इसे इस तरह करेंगे:

हम कुछ वीके उपयोगकर्ता का चयन करते हैं।
हमें उनके सभी दोस्तों की एक सूची मिली है।
प्रत्येक मित्र के लिए, हम उसके सभी समुदाय को लेते हैं।
प्रत्येक मित्र के प्रत्येक समुदाय के लिए, हम पहले n (n = 100) सामुदायिक पोस्ट को पंप करते हैं और उन्हें एक समुदाय पाठ सामग्री में संयोजित करते हैं।

उपकरण और लेख

पदों को डाउनलोड करने के लिए हम VKontakte API के साथ पायथन के लिए काम करने के लिए vk मॉड्यूल का उपयोग करेंगे। VKontakte API का उपयोग करते हुए एप्लिकेशन लिखते समय सबसे जटिल क्षणों में से एक प्राधिकरण है, सौभाग्य से, यह कोड जो इस कार्य को करता है वह पहले से ही लिखित है और सार्वजनिक डोमेन में है, vk को छोड़कर, मैंने एक छोटे प्राधिकरण मॉड्यूल - vkauth का उपयोग किया।

VKontakte API का अध्ययन करने के लिए उपयोग किए जाने वाले मॉड्यूल और लेखों के लिंक:

एक कोड लिखना

और इसलिए, vkauth का उपयोग करके, लॉग इन करें:

#authorization of app using modules imported. app_id = '6203169' perms = ['photos','friends','groups'] API_ver = '5.68' Auth = VKAuth(perms, app_id, API_ver) Auth.auth() token = Auth.get_token() user_id = Auth.get_user_id() #starting session session = vk.Session(access_token=token) api = vk.API(session)

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

 def get_friends_ids(api, user_id): ''' For a given API object and user_id returns a list of all his friends ids. ''' friends = api.friends.get(user_id=user_id, v = '5.68') friends_ids = friends['items'] return friends_ids def get_user_groups(api, user_id, moder=True, only_open=True): ''' For a given API user_id returns list of all groups he subscribed to. Flag model to get only those groups where user is a moderator or an admin) Flag only_open to get only public(open) groups. ''' kwargs = {'user_id' : user_id, 'v' : '5.68' } if moder == True: kwargs['filter'] = 'moder' if only_open == True: kwargs['extended'] = 1 kwargs['fields'] = ['is_closed'] groups = api.groups.get(**kwargs) groups_refined = [] for group in groups['items']: cond_check = (only_open and group['is_closed'] == 0) or not only_open if cond_check: refined = {} refined['id'] = group['id'] * (-1) refined['name'] = group['name'] groups_refined.append(refined) return groups_refined def get_n_posts_text(api, group_id, n_posts=50): ''' For a given api and group_id returns first n_posts concatenated as one text. ''' wall_contents = api.wall.get(owner_id = group_id, count=n_posts, v = '5.68') wall_contents = wall_contents['items'] text = '' for post in wall_contents: text += post['text'] + ' ' return text

अंतिम पाइपलाइन इस प्रकार है:

 #id of user whose friends you gonna get, like: https://vk.com/id111111111 user_id = 111111111 friends_ids = vt.get_friends_ids(api, user_id) #collecting all groups groups = [] for i,friend in tqdm(enumerate(friends_ids)): if i % 3 == 0: sleep(1) friend_groups = vt.get_user_groups(api, friend, moder=False) groups += friend_groups #converting groups to dataFrame groups_df = pd.DataFrame(groups) groups_df.drop_duplicates(inplace=True) #reading content(content == first 100 posts) for i,group in tqdm(groups_df.iterrows()): name = group['name'] group_id = group['id'] #Different kinds of fails occures during scrapping #For examples there are names of groups with slashes #Like: 'The Kaaats / Indie-rock' try: content = vt.get_n_posts_text(api, group_id, n_posts=100) dst_path = join(data_path, name + '.txt') with open(dst_path, 'w+t') as f: f.write(content) except Exception as e: print('Error occured on group:', name) print(e) continue #need it because of requests limitaion in VK API. if i % 3 == 0: sleep(1)

विफल रहता है

सामान्य तौर पर, डेटा डाउनलोड करने की प्रक्रिया अपने आप में मुश्किल नहीं है; आपको केवल दो बिंदुओं पर ध्यान देना चाहिए:

कभी-कभी, कुछ समुदायों की गोपनीयता के कारण, आपको एक्सेस त्रुटियां प्राप्त होंगी, कभी-कभी अन्य त्रुटियां सही जगह को छोड़कर प्रयास स्थापित करके हल हो जाएंगी।
वीके में प्रति सेकंड अनुरोधों की संख्या की सीमा है ।

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

मूर्खतापूर्ण और स्पष्ट रूप से: स्टिक स्लीप (कुछ) हर 3 अनुरोध। यह एक पंक्ति में किया जाता है और बहुत उतार-चढ़ाव को धीमा कर देता है, ऐसी स्थितियों में जहां डेटा वॉल्यूम बड़ा नहीं है, और अधिक परिष्कृत तरीकों के लिए समय नहीं है - यह काफी स्वीकार्य है। (इस लेख में लागू किया गया है।
लांग पोल अनुरोधों के काम को समझें https://vk.com/dev/use_longpoll

इस पत्र में, एक सरल और धीमी विधि को चुना गया था, भविष्य में, मैं संभवतः प्रति सेकंड अनुरोधों की संख्या पर प्रतिबंधों को कम या कम करने के तरीकों के बारे में एक सूक्ष्म लेख लिखूंगा।

परिणाम

बीज के साथ "कुछ" उपयोगकर्ता वाले ~ 150 दोस्त, वे 4,679 ग्रंथों को प्राप्त करने में कामयाब रहे - प्रत्येक एक निश्चित वीके समुदाय की विशेषता है। ग्रंथ आकार में बहुत भिन्न होते हैं और कई भाषाओं में लिखे जाते हैं - उनमें से कुछ हमारे उद्देश्यों के लिए उपयुक्त नहीं हैं, लेकिन हम इसके बारे में थोड़ा आगे बात करेंगे।

मुख्य शरीर

चलो हमारी पाइपलाइन के सभी ब्लॉकों से गुजरते हैं - पहले, अनिवार्य (आदर्श) पर, फिर बाकी पर - वे सिर्फ सबसे बड़ी रुचि के हैं।

CountVectorizer

एलडीए को पढ़ाने से पहले, हमें अपने दस्तावेज़ों को एक टर्म दस्तावेज़ मैट्रिक्स के रूप में प्रस्तुत करने की आवश्यकता है। इसमें आमतौर पर ऑपरेशन शामिल हैं:

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

स्केलेर में ये सभी कार्य एक कार्यक्रम इकाई - sklearn.feature_extraction.text.CountVectorizer के ढांचे के भीतर आसानी से कार्यान्वित किए जाते हैं।

डॉक्यूमेंटेशन लिंक

आपको बस इतना करना है:

 count_vect = CountVectorizer(input='filename', stop_words=stopwords, vocabulary=voc) dataset = count_vect.fit_transform(train_names)

झील प्राधिकरण

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

डॉक्यूमेंटेशन लिंक

आपको एलडीए शुरू करने की आवश्यकता है:

 #training LDA lda = LDA(n_components = 60, max_iter=30, n_jobs=6, learning_method='batch', verbose=1) lda.fit(dataset)

preprocessing

यदि हम बस डाउनलोड करने के तुरंत बाद हमारे ग्रंथों को लेते हैं और उन्हें बिल-डॉक्यूमेंट मैट्रिक्स में परिवर्तित करते हैं, तो काउंटवेक्टराइज़र का उपयोग करके, बिल्ट-इन डिफ़ॉल्ट टोकन के साथ, हमें 4679x769801 आकार का एक मैट्रिक्स मिलेगा (जिस डेटा का मैं उपयोग करता हूं)।

हमारे शब्दकोश का आकार 769801 होगा। भले ही हम यह मान लें कि अधिकांश शब्द सूचनात्मक हैं, फिर भी हमें एक अच्छा एलडीए मिलने की संभावना नहीं है, हमें 'कर्स ऑफ डाइमेंशन्स' जैसा कुछ मिलेगा, जिसका उल्लेख लगभग किसी भी कंप्यूटर के लिए नहीं है, हम सिर्फ सभी RAM को रोकेंगे। वास्तव में, इनमें से अधिकांश शब्द पूरी तरह से एकरूप नहीं हैं। उनमें से अधिकांश हैं:

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

इसके अलावा, वीके में कई समूह विशेष रूप से छवियों में विशेषज्ञ हैं - वहां लगभग कोई टेक्स्ट पोस्ट नहीं हैं - उनके अनुरूप ग्रंथ पतित हैं, थर्मल दस्तावेज़ मैट्रिक्स में वे हमें लगभग पूरी तरह से शून्य लाइनें देंगे।

और इसलिए, चलो इसे सभी को हल करते हैं!
हम सभी ग्रंथों को टोकन देते हैं, उनमें से विराम चिह्न और संख्याओं को हटाते हैं, ग्रंथों के वितरण की संख्या के हिस्टोग्राम को देखते हैं:

हम सभी शब्दों को 100 शब्दों से छोटा करते हैं (उनमें 525 हैं)

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

किसी शब्दकोश के आकार को कम करने के लिए सबसे आम प्रक्रियाओं में से एक तथाकथित स्टॉपवर्ड्स (स्टॉपवर्ड्स) को हटाने के लिए है - ऐसे शब्द जो शब्दार्थ भार नहीं ले जाते हैं और / या कोई विषयगत रंग नहीं है (हमारे मामले में, टॉपिक मॉडलिंग)। हमारे मामले में ऐसे शब्द हैं, उदाहरण के लिए:

सर्वनाम और प्रस्ताव।
लेख - ए, ए।
सामान्य शब्द: 'होना', 'अच्छा', 'शायद', आदि।

Nltk मॉड्यूल ने रूसी और अंग्रेजी में स्टॉपवर्ड्स की सूची बनाई है, लेकिन वे बल्कि कमजोर हैं। इंटरनेट पर, आप किसी भी भाषा के लिए स्टॉपवार्ड की सूची भी पा सकते हैं और उन्हें nltk में जोड़ सकते हैं। तो हम करेंगे। यहां से अतिरिक्त स्टॉप पासवर्ड लें:

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

अपने आप से, स्टॉपवार्ड हटाने की प्रक्रिया काउंटवेक्टराइज़र में बनाई गई है - हमें बस उनकी एक सूची चाहिए।

क्या हमने काफी कुछ किया है?

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

i d f (t, D) = l o g f r a c | D | | d_{D} : t_{d} | $ म े

$idf (t, D) = \ log \ frac {| D |} {| \\ {d \ _ D: t \ _ d \\} |} $ मे$

जहाँ
t शब्दकोश से एक शब्द है।
डी - केस (कई ग्रंथ)
d शरीर के ग्रंथों में से एक है।
हम अपने सभी शब्दों के आईडीएफ की गणना करते हैं, और सबसे बड़े आईडीएफ (बहुत दुर्लभ) और सबसे छोटे (व्यापक शब्दों) के साथ शब्दों को काट देते हैं।

 #'training' (tf-)idf vectorizer. tf_idf = TfidfVectorizer(input='filename', stop_words=stopwords, smooth_idf=False ) tf_idf.fit(train_names) #getting idfs idfs = tf_idf.idf_ #sorting out too rare and too common words lower_thresh = 3. upper_thresh = 6. not_often = idfs > lower_thresh not_rare = idfs < upper_thresh mask = not_often * not_rare good_words = np.array(tf_idf.get_feature_names())[mask] #deleting punctuation as well. cleaned = [] for word in good_words: word = re.sub("^(\d+\w*$|_+)", "", word) if len(word) == 0: continue cleaned.append(word)

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

 #Stemming m = Mystem() stemmed = set() voc_len = len(cleaned) for i in tqdm(range(voc_len)): word = cleaned.pop() stemmed_word = m.lemmatize(word)[0] stemmed.add(stemmed_word) stemmed = list(stemmed) print('After stemming: %d'%(len(stemmed)))

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

परीक्षण, आवेदन और ट्यूनिंग एलडीए

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

एक आवेदन के रूप में, शुरुआत के लिए, किसी दिए गए पाठ के लिए कीवर्ड बनाने के कार्य पर विचार करें। आप इसे इस तरह से काफी सरल तरीके से कर सकते हैं:

हम एलडीए से इस पाठ के लिए विषयों का वितरण प्राप्त करते हैं।
सबसे स्पष्ट विषयों के n (उदाहरण के लिए, n = 2) चुनें।
प्रत्येक विषय के लिए, m (उदाहरण के लिए m = 3) सबसे विशेषता शब्द चुनें।
हमारे पास एक दिए गए पाठ को दर्शाते हुए n * m शब्दों का एक सेट है।

हम एक सरल इंटरफ़ेस क्लास लिखेंगे जो कीवर्ड बनाने की इस पद्धति को लागू करेगा:

 #Let\`s do simple interface class class TopicModeler(object): ''' Inteface object for CountVectorizer + LDA simple usage. ''' def __init__(self, count_vect, lda): ''' Args: count_vect - CountVectorizer object from sklearn. lda - LDA object from sklearn. ''' self.lda = lda self.count_vect = count_vect self.count_vect.input = 'content' def __call__(self, text): ''' Gives topics distribution for a given text Args: text - raw text via python string. returns: numpy array - topics distribution for a given text. ''' vectorized = self.count_vect.transform([text]) lda_topics = self.lda.transform(vectorized) return lda_topics def get_keywords(self, text, n_topics=3, n_keywords=5): ''' For a given text gives n top keywords for each of m top texts topics. Args: text - raw text via python string. n_topics - int how many top topics to use. n_keywords - how many top words of each topic to return. returns: list - of m*n keywords for a given text. ''' lda_topics = self(text) lda_topics = np.squeeze(lda_topics, axis=0) n_topics_indices = lda_topics.argsort()[-n_topics:][::-1] top_topics_words_dists = [] for i in n_topics_indices: top_topics_words_dists.append(self.lda.components_[i]) shape=(n_keywords*n_topics, self.lda.components_.shape[1]) keywords = np.zeros(shape=shape) for i,topic in enumerate(top_topics_words_dists): n_keywords_indices = topic.argsort()[-n_keywords:][::-1] for k,j in enumerate(n_keywords_indices): keywords[i * n_keywords + k, j] = 1 keywords = self.count_vect.inverse_transform(keywords) keywords = [keyword[0] for keyword in keywords] return keywords

हम कई तरीकों से अपनी पद्धति लागू करते हैं और देखते हैं कि क्या होता है:
समुदाय : ट्रैवल एजेंसी "कलर्स ऑफ़ द वर्ल्ड"
कीवर्ड: ['फोटो', 'सामाजिक', 'यात्रा', 'समुदाय', 'यात्रा', 'यूरो', 'आवास', 'कीमत', 'पोलैंड', 'प्रस्थान']
समुदाय: खाद्य Gifs
कीवर्ड: ['मक्खन', 'सेंट', 'नमक', 'पीसी', 'आटा', 'कुकिंग', 'प्याज', 'काली मिर्च', 'चीनी', 'जीआर']

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

वेब पते के समग्र घटक: www, http, ru, com ...
आम शब्द।
इकाइयों: सेमी, मीटर, किमी ...

मॉडल की ट्यूनिंग (ट्यूनिंग) को निम्नानुसार किया गया था:

प्रत्येक विषय के लिए, n (n = 5) सबसे अधिक विशिष्ट शब्दों का चयन करें।
हम प्रशिक्षण मामले के अनुसार, उन्हें निष्क्रिय मानते हैं।
हम सबसे व्यापक रूप से 5-10% कीवर्ड लाते हैं।

इस तरह के "सफाई" को सावधानीपूर्वक किया जाना चाहिए, उन 10% शब्दों को पूर्व-देखना। बल्कि, विलोपन के उम्मीदवारों को इस तरह से चुना जाना चाहिए, और फिर हटाए जाने वाले शब्दों को मैन्युअल रूप से उनसे चुना जाना चाहिए।

कहीं न कहीं 2-3 पीढ़ी के मॉडल में, स्टॉपवर्ड्स के चयन के समान तरीके के साथ, व्यापक शीर्ष-शब्द वितरण के शीर्ष 5% के लिए, हमें मिलता है:
[[कोई ’, 'पूरी तरह’,' सही ’,, आसान’,, अगला ’, 'इंटरनेट’,' छोटा ’, difficult रास्ता’, way मुश्किल ’, 'मूड’, much इतना ’,' सेट’, ’ विकल्प ',' नाम ',' भाषण ',' कार्यक्रम ',' प्रतियोगिता ',' संगीत ',' लक्ष्य ',' फिल्म ',' कीमत ',' खेल ',' प्रणाली ',' खेल ',' कंपनी ' , 'अच्छा']

अधिक अनुप्रयोग

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

ऐसा करते हैं:

 term_doc_matrix = count_vect.transform(names) embeddings = lda.transform(term_doc_matrix) kmeans = KMeans(n_clusters=30) clust_labels = kmeans.fit_predict(embeddings) clust_centers = kmeans.cluster_centers_ embeddings_to_tsne = np.concatenate((embeddings,clust_centers), axis=0) tSNE = TSNE(n_components=2, perplexity=15) tsne_embeddings = tSNE.fit_transform(embeddings_to_tsne) tsne_embeddings, centroids_embeddings = np.split(tsne_embeddings, [len(clust_labels)], axis=0)

आउटपुट पर, हमें निम्न छवि मिलती है:

क्रॉस गुच्छों के गुरुत्वाकर्षण (सेन्रॉइड्स) के केंद्र हैं।

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

बाकी सब, आपके ऊपर।

सभी कोड के लिए लिंक: https://gitlab.com/Mozes/VK_LDA

वास्तविक दुनिया में एलडीए लॉन्च करें। विस्तृत गाइड