🐀 😧 🕟 पायथन और TextBlob के साथ प्रोटोटाइप सेंटीमेंट विश्लेषण 🐀 🗿 👇

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

यह लेख प्रोटोटाइप पर केंद्रित होगा। जिसे प्रोडक्ट मैनेजर के साथ बात करने के कुछ समय बाद बनाया गया था: हम मशीन लर्निंग को "टच" क्यों नहीं करते? विशेष रूप से, एनएलपी और सेंटीमेंट विश्लेषण?

"क्यों नहीं?" मैंने जवाब दिया। फिर भी, मैं 15 से अधिक वर्षों से बैकएंड विकास में लगा हुआ हूं, मुझे डेटा के साथ काम करना और प्रदर्शन समस्याओं को हल करना पसंद है। लेकिन मुझे अभी भी यह पता लगाना था कि "खरगोश छेद कितना गहरा है"।

घटकों का चयन करें

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

पायथन में भावना विश्लेषण का एक उदाहरण

import collections import nltk import os from sklearn import ( datasets, model_selection, feature_extraction, linear_model ) def extract_features(corpus): '''Extract TF-IDF features from corpus''' # vectorize means we turn non-numerical data into an array of numbers count_vectorizer = feature_extraction.text.CountVectorizer( lowercase=True, # for demonstration, True by default tokenizer=nltk.word_tokenize, # use the NLTK tokenizer stop_words='english', # remove stop words min_df=1 # minimum document frequency, ie the word must appear more than once. ) processed_corpus = count_vectorizer.fit_transform(corpus) processed_corpus = feature_extraction.text.TfidfTransformer().fit_transform( processed_corpus) return processed_corpus data_directory = 'movie_reviews' movie_sentiment_data = datasets.load_files(data_directory, shuffle=True) print('{} files loaded.'.format(len(movie_sentiment_data.data))) print('They contain the following classes: {}.'.format( movie_sentiment_data.target_names)) movie_tfidf = extract_features(movie_sentiment_data.data) X_train, X_test, y_train, y_test = model_selection.train_test_split( movie_tfidf, movie_sentiment_data.target, test_size=0.30, random_state=42) # similar to nltk.NaiveBayesClassifier.train() model = linear_model.LogisticRegression() model.fit(X_train, y_train) print('Model performance: {}'.format(model.score(X_test, y_test))) y_pred = model.predict(X_test) for i in range(5): print('Review:\n{review}\n-\nCorrect label: {correct}; Predicted: {predict}'.format( review=X_test[i], correct=y_test[i], predict=y_pred[i] ))

ऐसे उदाहरणों को पार्स करना डेवलपर के लिए एक अलग चुनौती है।
कोड की केवल 45 लाइनें, और 4 (चार, कार्ल!) एक बार में तार्किक ब्लॉक:

मॉडल प्रशिक्षण के लिए डेटा डाउनलोड करना (लाइनें 25-26)
अपलोड किया गया डेटा तैयार करना - सुविधा निष्कर्षण (लाइनें 31-34)
एक मॉडल बनाना और प्रशिक्षण (लाइनें 36-39)
एक प्रशिक्षित मॉडल और आउटपुट परिणाम का परीक्षण करना (लाइनें 41-45)

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

अलग-अलग, यह डेटा तैयारी और मॉडल प्रशिक्षण के घटकों को उजागर करने के लायक है।
मॉडल को अधिक सटीक बनाने के प्रत्येक तरीके में, वैज्ञानिक और इंजीनियरिंग कार्यों के सैकड़ों घंटे का निवेश किया जाता है।

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

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

डेटा तैयार करना

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

अगर हम प्रोटोटाइप के बारे में बात करते हैं, तो CSV / TSV फ़ाइल से डेटा लोड करना प्राथमिक है। आप बस पंडों के पुस्तकालय से read_csv फ़ंक्शन को कॉल करते हैं:

 import pandas as pd data = pd.read_csv(data_path, delimiter)

लेकिन यह मॉडल में उपयोग के लिए तैयार डेटा नहीं होगा।

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

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

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

इसलिए, तीन कार्य हैं जो हमें डेटा लोडिंग चरण में करने की आवश्यकता है:

डेटा स्रोत से कनेक्शन CSV के लिए है, हमारे मामले में इसे read_csv फ़ंक्शन के अंदर लागू किया गया है;
प्रारूप सुविधाओं के लिए समर्थन;
प्रारंभिक डेटा तैयारी।

इस तरह से यह कोड में दिखता है।

 import numpy as np # linear algebra import pandas as pd # data processing, CSV file I/O (eg pd.read_csv) import logging log = logging.getLogger() class CsvSentimentDataLoader(): def __init__(self, file_path, delim, text_attr, rate_attr, pos_rates): self.data_path = file_path self.delimiter = delim self.text_attr = text_attr self.rate_attr = rate_attr self.pos_rates = pos_rates def load_data(self): #     csv  tsv  data = pd.read_csv(self.data_path, self.delimiter) data.head() #   , #      data = data[[self.text_attr, self.rate_attr]] #    #     'pos'  'neg' data[self.rate_attr] = np.where( data[self.rate_attr].isin(self.pos_rates), 'pos', 'neg') return data

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

लोडिंग स्वयं लोड_डेटा विधि में होती है।

हम डेटा को परीक्षण और प्रशिक्षण सेटों में विभाजित करते हैं

ठीक है, हमने डेटा अपलोड कर दिया है, लेकिन हमें अभी भी इसे प्रशिक्षण और परीक्षण सेट में विभाजित करने की आवश्यकता है।

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

 from sklearn.model_selection import train_test_split # to split the training and testing data import logging log = logging.getLogger() class SimpleDataSplitter(): def __init__(self, text_attr, rate_attr, test_part_size=.3): self.text_attr = text_attr self.rate_attr = rate_attr self.test_part_size = test_part_size def split_data(self, data): x = data[self.text_attr] y = data[self.rate_attr] x_train, x_test, y_train, y_test = train_test_split( x, y, test_size = self.test_part_size) return x_train, x_test, y_train, y_test

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

डेटासेट

मॉडल को प्रशिक्षित करने के लिए, मैंने सीएसवी प्रारूप में स्वतंत्र रूप से उपलब्ध डेटासेट का उपयोग किया:

अमेज़न एलेक्सा समीक्षा डेटा सेट, कागल में उपलब्ध है
कैलिफोर्निया विश्वविद्यालय के सेंटेंस लेबल वाले सेंटेंस डेटा सेट

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

 import os import collections import logging from web.data.loaders import CsvSentimentDataLoader from web.data.splitters import SimpleDataSplitter, TdIdfDataSplitter log = logging.getLogger() class AmazonAlexaDataset(): def __init__(self): self.file_path = os.path.normpath(os.path.join(os.path.dirname(__file__), 'amazon_alexa/train.tsv')) self.delim = '\t' self.text_attr = 'verified_reviews' self.rate_attr = 'feedback' self.pos_rates = [1] self.data = None self.train = None self.test = None def load_data(self): loader = CsvSentimentDataLoader(self.file_path, self.delim, self.text_attr, self.rate_attr, self.pos_rates) splitter = SimpleDataSplitter(self.text_attr, self.rate_attr, test_part_size=.3) self.data = loader.load_data() x_train, x_test, y_train, y_test = splitter.split_data(self.data) self.train = [x for x in zip(x_train, y_train)] self.test = [x for x in zip(x_test, y_test)]

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

प्लस, यूनिट परीक्षण के लिए व्यक्तिगत घटक बहुत अधिक सुविधाजनक हैं।

हम मॉडल को प्रशिक्षित करते हैं

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

 class TextBlobWrapper(): def __init__(self): self.log = logging.getLogger() self.is_model_trained = False self.classifier = None def init_app(self): self.log.info('>>>>> TextBlob initialization started') self.ensure_model_is_trained() self.log.info('>>>>> TextBlob initialization completed') def ensure_model_is_trained(self): if not self.is_model_trained: ds = SentimentLabelledDataset() ds.load_data() # train the classifier and test the accuracy self.classifier = NaiveBayesClassifier(ds.train) acr = self.classifier.accuracy(ds.test) self.log.info(str.format('>>>>> NaiveBayesClassifier trained with accuracy {}', acr)) self.is_model_trained = True return self.classifier

पहले हम प्रशिक्षण प्राप्त करते हैं और डेटा का परीक्षण करते हैं, फिर हम फीचर निष्कर्षण करते हैं, और अंत में हम क्लासिफायर ट्रेन करते हैं और परीक्षण सेट पर सटीकता की जांच करते हैं।

परीक्षण

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

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

इसका कारण प्रशिक्षण सेट डेटा में है। सेट में सकारात्मक समीक्षाओं की संख्या 90% से अधिक है। तदनुसार, लगभग 88% की मॉडल सटीकता के साथ, नकारात्मक समीक्षा केवल 12% गलत वर्गीकरणों में आती है।

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

वास्तव में यह सुनिश्चित करने के लिए, मैंने एक इकाई परीक्षण किया जो कि एक और डेटा सेट से 100 सकारात्मक और 100 नकारात्मक वाक्यांशों के लिए अलग से वर्गीकरण चलाता है - परीक्षण के लिए मैंने कैलिफोर्निया विश्वविद्यालय से सेंटीमेंट लेबल वाले सेंटेंस डेटा सेट लिया।

  @loggingtestcase.capturelogs(None, level='INFO') def test_classifier_on_separate_set(self, logs): tb = TextBlobWrapper() # Going to be trained on Amazon Alexa dataset ds = SentimentLabelledDataset() # Test dataset ds.load_data() # Check poisitives true_pos = 0 data = ds.data.to_numpy() seach_mask = np.isin(data[:, 1], ['pos']) data = data[seach_mask][:100] for e in data[:]: # Model train will be performed on first classification call r = tb.do_sentiment_classification(e[0]) if r == e[1]: true_pos += 1 self.assertLessEqual(true_pos, 100) print(str.format('\n\nTrue Positive answers - {} of 100', true_pos))

सकारात्मक मूल्यों के वर्गीकरण के परीक्षण के लिए एल्गोरिथ्म इस प्रकार है:

परीक्षण डेटा डाउनलोड करें;
'पॉस' टैग की गई 100 पोस्ट लें
हम उनमें से प्रत्येक को मॉडल के माध्यम से चलाते हैं और सही परिणामों की संख्या की गणना करते हैं
कंसोल में अंतिम परिणाम प्रदर्शित करें।

इसी तरह, एक टिप्पणी नकारात्मक टिप्पणियों के लिए बनाई गई है।

परिणाम

जैसा कि अपेक्षित था, सभी नकारात्मक टिप्पणियों को सकारात्मक के रूप में मान्यता दी गई थी।

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

कोड बदलें और परीक्षण करें, चलाएं

कुछ पहले से ही। तीसरे पक्ष के सेट से 200 प्रविष्टियों की वास्तविक सटीकता 76% है, जबकि नकारात्मक टिप्पणियों के वर्गीकरण की सटीकता 79% है।

बेशक, 76% एक प्रोटोटाइप के लिए करेंगे, लेकिन उत्पादन के लिए पर्याप्त नहीं है। इसका मतलब है कि एल्गोरिथ्म की सटीकता में सुधार के लिए अतिरिक्त उपायों की आवश्यकता होगी। लेकिन यह एक अन्य रिपोर्ट के लिए एक विषय है।

परिणाम

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

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

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

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

मेरे लिए, वास्तुकला को डिजाइन करने और विकास प्रक्रियाओं के निर्माण के दौरान यह सब ध्यान में रखा जाना चाहिए।

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

पायथन और TextBlob के साथ प्रोटोटाइप सेंटीमेंट विश्लेषण