मुख्य सामग्री पर जाएँ

Machine Learning का उपयोग करके सत्य और भ्रामक होटल समीक्षाएँ पहचानना

इस ट्यूटोरियल में, आप Python में एक मशीन लर्निंग एल्गोरिदम का उपयोग करके वास्तविक जीवन की समस्या लागू करेंगे। आप सीखेंगे कि Python में कई टेक्स्ट फाइलें कैसे पढ़ें, लेबल कैसे निकालें, डेटाफ़्रेम का उपयोग करें और बहुत कुछ!
· 11 मि॰ पढ़ें

AI के साथ खोजें

इस ट्यूटोरियल के लिए, आप एक टेक्स्ट डेटासेट Deceptive Opinion Spam Corpus के साथ उदाहरण के रूप में काम करेंगे।

संक्षेप में, आप आज के ट्यूटोरियल में निम्नलिखित विषयों को कवर करेंगे:

  • शुरुआत में, आपको Hotel Review Dataset के बारे में जानकारी दी जाएगी और फिर सभी आवश्यक मॉड्यूल आयात करेंगे,
  • इसके बाद आप डेटा की संरचना समझना शुरू करेंगे: डेटा पाथ से सभी टेक्स्ट फाइलें लाएँ, उनसे लेबल निकालें, लेबल और रिव्यू का एक डेटाफ़्रेम बनाएं, और अंत में दोनों डेटाफ़्रेम को मर्ज करें,
  • फिर आप डेटा का प्रीप्रोसेसिंग करेंगे: प्राकृतिक भाषा टूलकिट लाइब्रेरी का उपयोग करके होटल रिव्यू से स्टॉपवर्ड्स हटाएँ और अपने डेटासेट में प्रत्येक शब्द के लिए पार्ट्स ऑफ़ स्पीच निकालें।
  • एक बार जब आपने डेटा का प्रीप्रोसेसिंग कर लिया, तो आप डेटा ट्रेनिंग के लिए तैयार हैं: डेटा को ट्रेनिंग और टेस्टिंग में बाँटें, Tfidf के बारे में जानें, ट्रेनिंग और टेस्टिंग डेटा को वेक्टराइज़ करें, सपोर्ट वेक्टर मशीन मॉडल लागू करें, अपने डेटा के लिए Tfidf वेक्टराइज़र और मॉडल—दोनों को सेव करें, फिर उन्हें वापस लोड करें।
  • अंत में, आप टेस्ट डेटा पर प्रिडिक्ट करेंगे: मॉडल की प्रभावशीलता जाँचने के लिए कन्फ्यूजन मैट्रिक्स, एक्यूरसी स्कोर और कन्फ्यूजन मैट्रिक्स प्लॉट करें, अलग-अलग रैंडम स्टेट्स के साथ ट्रेनिंग और टेस्टिंग डेटा बाँटकर मॉडल का परीक्षण करें, और अंत में दो ऑनलाइन Yelp रिव्यू का उपयोग करके अपने मॉडल का परीक्षण करें।

Deceptive Opinion Spam Dataset को समझना

डेटा लोड करने से पहले, यह देखना अच्छा है कि आप वास्तव में किसके साथ काम करेंगे! Deceptive opinion spam डेटासेट 20 शिकागो होटलों की सत्य और भ्रामक समीक्षाओं का एक कॉर्पस है। डेटा को समीक्षा के सेंटिमेंट के अनुसार दो शोधपत्रों में वर्णित किया गया है। विशेष रूप से, लेख 1 में सकारात्मक सेंटिमेंट समीक्षाओं और 2 में नकारात्मक सेंटिमेंट समीक्षाओं पर चर्चा करता है। अधिक विस्तृत जानकारी के लिए आप इन शोधपत्रों को देख सकते हैं।

कॉर्पस में शामिल है:

  • TripAdvisor से 400 सत्य, सकारात्मक समीक्षाएँ
  • Mechanical Turk से 400 भ्रामक, सकारात्मक समीक्षाएँ
  • Expedia, Hotels.com, Orbitz, Priceline, TripAdvisor, और Yelp से 400 सत्य, नकारात्मक समीक्षाएँ
  • Mechanical Turk से 400 भ्रामक, नकारात्मक समीक्षाएँ

कुल मिलाकर आपके पास 1600 समीक्षाएँ हैं, आपका कार्य एक मशीन लर्निंग एल्गोरिदम का उपयोग करके सत्य और भ्रामक होटल समीक्षाओं का वर्गीकरण करना होगा।

तो चलिए शुरू करते हैं!

सभी आवश्यक मॉड्यूल आयात करें

आप os, pandas, nltk, regex और सबसे महत्वपूर्ण Sklearn जैसे सभी आवश्यक मॉड्यूल आयात करने से शुरू करेंगे क्योंकि आज के ट्यूटोरियल में आप Sklearn लाइब्रेरी द्वारा प्रदान किए गए मशीन लर्निंग एल्गोरिदम Support Vector Machine का उपयोग करेंगे!

टेक्स्ट फाइलें जिन फोल्डरों और सबफोल्डरों में हैं, उन पर इटरेट करने के लिए आपको os की आवश्यकता होगी, केवल टेक्स्ट फाइलों को फ़िल्टर करने और फोल्डरों में मौजूद बाकी सबको अनदेखा करने के लिए fnmatch काम आएगा, pandas आपके डेटा को पंक्तियों और स्तंभों के रूप में रखने में मदद करेगा और आप pandas का उपयोग करके विभिन्न डेटा हेरफेर कर सकते हैं। Regex आपके द्वारा निर्दिष्ट पैटर्न के आधार पर डेटा निकालने में मदद करता है, इसलिए इसकी भी ज़रूरत होगी! Nltk एक नेचुरल लैंग्वेज टूलकिट है जो आपको वे स्टॉपवर्ड्स हटाने में मदद करेगा जिन्हें आप नहीं चाहते कि आपका मॉडल सीखे। फिर सबसे महत्वपूर्ण रूप से आप Sklearn आयात करेंगे जो डेटा में हेरफेर करने, डेटा को वेक्टराइज़ करने, मशीन लर्निंग एल्गोरिदम का उपयोग करके डेटा पॉइंट्स के बीच की सीमा सीखने और अंततः एक्यूरसी प्लॉट करने के लिए कई लाइब्रेरी प्रदान करेगा।

import os
import fnmatch
from textblob import TextBlob
import pandas as pd
from sklearn.feature_extraction.text import TfidfVectorizer
from nltk.corpus import stopwords
from nltk import pos_tag,pos_tag_sents
import regex as re
import operator
from sklearn.svm import SVC, LinearSVC
from sklearn.metrics import classification_report, accuracy_score, confusion_matrix
from sklearn.cross_validation import train_test_split  
from sklearn import metrics
from sklearn import svm
from sklearn.grid_search import GridSearchCV
import pickle
from nltk.corpus import stopwords

पाथ से सभी टेक्स्ट फाइलें लाएँ, उनसे लेबल निकालें, और लेबल्स का एक डेटाफ़्रेम बनाएँ

structure of the data
चित्र: डेटा की संरचना


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

आप पहले सभी टेक्स्ट फाइलों पर इटरेट करेंगे और सभी टेक्स्ट फाइलों के एब्सोल्यूट पाथ प्राप्त करेंगे, जिनसे आप संबंधित लेबल निकालेंगे।

path = 'op_spam_train/'

label = []

configfiles = [os.path.join(subdir,f)
for subdir, dirs, files in os.walk(path)
    for f in fnmatch.filter(files, '*.txt')]

1600 पाथ होने चाहिए, जिनमें से प्रत्येक एक नई टेक्स्ट फाइल का प्रतिनिधित्व करता है। आइए इसे जल्दी से सत्यापित करें!

len(configfiles)
1600

आइए टेक्स्ट फाइल पाथ में से एक को भी प्रिंट करते हैं।

configfiles[1]
'op_spam_train/negative_polarity/deceptive_from_MTurk/fold4/d_swissotel_14.txt'

तो, ऊपर के आउटपुट से आप देख सकते हैं कि लेबल निकालने के लिए हमें किसी तरह के फ़िल्टर की ज़रूरत है। इसके लिए आप Regex यानी रेगुलर एक्सप्रेशन का उपयोग करेंगे।

for f in configfiles:
    c = re.search('(trut|deceptiv)\w',f)
    label.append(c.group())

एक बार जब लेबल label नामक list में निकाल लिए जाएँ, तो इस सूची का एक डेटाफ़्रेम बनाते हैं।

labels = pd.DataFrame(label, columns = ['Labels'])

आइए labels डेटाफ़्रेम की पहली पाँच पंक्तियाँ प्रिंट करें।

labels.head(5)
 Labels
0deceptive
1deceptive
2deceptive
3deceptive
4deceptive

सभी रिव्यू लाएँ और एक सूची में जोड़ें

जब आपने सभी लेबल निकाल लिए हैं, तो अब टेक्स्ट फाइलों से रिव्यू निकालने का समय है!

review = []
directory =os.path.join("op_spam_train")
for subdir,dirs ,files in os.walk(directory):
   # print (subdir)
    for file in files:
        if fnmatch.filter(files, '*.txt'):
            f=open(os.path.join(subdir, file),'r')
            a = f.read()
            review.append(a)

पहले की तरह, अब आप review सूची का एक डेटाफ़्रेम बनाएँगे।

reviews = pd.DataFrame(review, columns = ['HotelReviews'])

आइए reviews डेटाफ़्रेम की पहली पाँच पंक्तियाँ प्रिंट करें।

reviews.head(5)
 HotelReviews
0Grant it, this hotel seems very nice, but I wa...
1I recently stayed at the Swissotel Chicago wit...
2I was sorely disappointed with the Sheraton Ch...
3My family and I stayed at the Sheraton Chicago...
4I recently stayed at the Homewood Suites by Hi...

बहुत बढ़िया! अभी तक सब काफ़ी सहज था, है ना?

अब labels और reviews दोनों डेटाफ़्रेम को मर्ज करते हैं!

रिव्यू डेटाफ़्रेम और लेबल डेटाफ़्रेम को मर्ज करें

result = pd.merge(reviews, labels,right_index=True,left_index = True)


result['HotelReviews'] = result['HotelReviews'].map(lambda x: x.lower())

मर्ज होने के बाद, आपके पास result नाम से एक नया डेटाफ़्रेम है। आइए इस नए डेटाफ़्रेम की कुछ पंक्तियाँ भी प्रिंट करें।

result.head()
 HotelReviewsLabels
0grant it, this hotel seems very nice, but i wa...deceptive
1i recently stayed at the swissotel chicago wit...deceptive
2i was sorely disappointed with the sheraton ch...deceptive
3my family and i stayed at the sheraton chicago...deceptive
4i recently stayed at the homewood suites by hi...deceptive

Hotel Reviews कॉलम से स्टॉपवर्ड्स हटाएँ

टेक्स्ट डेटा के साथ काम करते समय, स्टॉपवर्ड्स हटाना ज़रूरी है। स्टॉपवर्ड्स अर्थपूर्ण नहीं होते, और वे ऐसी कोई जानकारी नहीं देते जो मॉडल को डेटा में पैटर्न सीखने में मदद कर सके।

आप डेटाफ़्रेम में review_without_stopwords नाम से एक नया कॉलम बनाएँगे। lambda फ़ंक्शन HotelReviews कॉलम की सभी पंक्तियों पर प्रोसेस करेगा। आप लिस्ट कॉम्प्रिहेंशन का उपयोग करेंगे और नए कॉलम में केवल वे शब्द स्टोर करेंगे जो stop वेरिएबल में मौजूद नहीं हैं।

import ntlk
nltk.download('stopwords')

नोट: नीचे वाले सेल को चलाने के लिए, आपको अपने टर्मिनल में ऊपर दी गई कोड लाइनों को चलाने की आवश्यकता हो सकती है।

stop = stopwords.words('english')

result['review_without_stopwords'] = result['HotelReviews'].apply(lambda x: ' '.join([word for word in x.split() if word not in (stop)]))

आइए बिना स्टॉपवर्ड्स वाला डेटाफ़्रेम जल्दी से प्रिंट करें!

result.head()
 HotelReviewsLabelsreview_without_stopwords
0grant it, this hotel seems very nice, but i wa...deceptivegrant it, hotel seems nice, pleased stay here....
1i recently stayed at the swissotel chicago wit...deceptiverecently stayed swissotel chicago husband two ...
2i was sorely disappointed with the sheraton ch...deceptivesorely disappointed sheraton chicago. outside ...
3my family and i stayed at the sheraton chicago...deceptivefamily stayed sheraton chicago hotel towers be...
4i recently stayed at the homewood suites by hi...deceptiverecently stayed homewood suites hilton chicago...

Hotel Reviews से पार्ट्स ऑफ़ स्पीच निकालें जिन्हें मॉडल के लिए फीचर इनपुट के रूप में दिया जाएगा

1 के अनुसार, सत्य और भ्रामक राय क्रमशः सूचनात्मक और कल्पनात्मक विधाओं में वर्गीकृत की जा सकती हैं। सूचनात्मक और कल्पनात्मक लेखन के बीच एक मजबूत वितरणात्मक अंतर है—पहले में आमतौर पर अधिक संज्ञाएँ, विशेषण, पूर्वसर्ग, निर्धारक, और समन्वयक संयोजन होते हैं, जबकि बाद वाले में अधिक क्रियाएँ, क्रिया विशेषण, सर्वनाम और प्री-डिटरमाइनर शामिल होते हैं। हालाँकि, यह अप्रत्याशित नहीं है कि भ्रामक राय में अधिक सुपरलेटिव्स होते हैं क्योंकि भ्रामक लेखन (लेकिन सामान्य रूप से आवश्यक नहीं कि कल्पनात्मक लेखन) में अक्सर अतिरंजित भाषा होती है।

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

pos टैगिंग के लिए, आप TextBlob का उपयोग करेंगे, जो टेक्स्टुअल डेटा प्रोसेस करने के लिए एक Python लाइब्रेरी है। यह पार्ट-ऑफ-स्पीच टैगिंग, नाउन फ़्रेज़ एक्सट्रैक्शन, सेंटिमेंट एनालिसिस, क्लासिफिकेशन, ट्रांसलेशन और अन्य सामान्य NLP कार्यों के लिए एक सरल API प्रदान करती है।

नोट: pos फ़ंक्शन वाले सेल को चलाने के लिए, आपको अपने टर्मिनल विंडो में निम्नलिखित कोड लाइनों को चलाने की आवश्यकता हो सकती है।

import nltk
nltk.download('punkt')
nltk.download('averaged_perceptron_tagger')
def pos(review_without_stopwords):
    return TextBlob(review_without_stopwords).tags
os = result.review_without_stopwords.apply(pos)
os1 = pd.DataFrame(os)

os1 डेटाफ़्रेम की प्रत्येक पंक्ति शब्दों और उनके संबंधित पार्ट ऑफ़ स्पीच की एक सूची से बनी होगी। आप इस सूची को सीधे मॉडल में फीड करने के लिए वेक्टराइज़ नहीं कर पाएँगे। इसलिए, आपको इन सूचियों वाली पंक्तियों को स्ट्रिंग में बदलना होगा।

os1.head()
 review_without_stopwords
0[(grant, NN), (it, PRP), (hotel, NN), (seems, ...
1[(recently, RB), (stayed, VBN), (swissotel, NN...
2[(sorely, RB), (disappointed, JJ), (sheraton, ...
3[(family, NN), (stayed, VBD), (sheraton, JJ), ...
4[(recently, RB), (stayed, VBN), (homewood, NN)...

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

os1['pos'] = os1['review_without_stopwords'].map(lambda x:" ".join(["".join(x) for x in x ]) )

अंत में, pos कॉलम को मुख्य result डेटाफ़्रेम के साथ मर्ज करें और इसकी शुरुआती कुछ पंक्तियाँ प्रिंट करें!

result = result = pd.merge(result, os1,right_index=True,left_index = True)
result.head()
first few rows of pos column and the main result df

ट्रेनिंग चरण

डेटा को दो भागों में बाँटें: 80% ट्रेन और 20% टेस्ट डेटा

एक बार जब आपने फीचर्स निकाल लिए, अब डेटा को ट्रेनिंग और टेस्टिंग में बाँटने का समय है। इस ट्यूटोरियल में, आप 80% डेटा को ट्रेनिंग और शेष 20% को टेस्टिंग में बाँटेंगे।

review_train, review_test, label_train, label_test = train_test_split(result['pos'],result['Labels'], test_size=0.2,random_state=13)

TfidfVectorizer का उपयोग करके ट्रेनिंग और टेस्टिंग डेटा को वेक्टराइज़ करें

आइए TfidfVectorizer को विस्तार से समझते हैं

Tfidf के दो भाग होते हैं:

    • टर्म फ़्रीक्वेंसी (Tf): एक एकल डॉक्युमेंट में कोई विशेष शब्द कितनी बार आता है। इसे बेहतर समझने के लिए एक शब्द लें: “the”। यह शब्द काफी आम है और आपके सभी डॉक्युमेंट्स में उच्च आवृत्ति के साथ आएगा। लेकिन अगर आप सोचें, तो “the” आपके डॉक्युमेंट के बारे में कोई अतिरिक्त जानकारी नहीं देता। लेकिन अगर हम “messi” शब्द की बात करें, तो यह हमें संदर्भ देता है। हम कुछ हद तक कह सकते हैं कि डॉक्युमेंट फुटबॉल के बारे में हो सकता है। इसलिए हमें “the” का वेट किसी तरह कम करना होगा। अब आप कह सकते हैं कि उनके-अपने फ़्रीक्वेंसी का व्युत्क्रम ले लिया जाए ताकि “messi” को अधिक वेट मिल सके। ठीक, लेकिन एक पेंच है। हमारे डॉक्युमेंट में बहुत दुर्लभ शब्द भी हो सकते हैं। उदाहरण: “floccinaucinihilipilification”। यह एक वास्तविक शब्द है जिसका अर्थ है: “किसी चीज़ को निकृष्ट समझने की क्रिया या आदत।” अब यदि आप इस शब्द के लिए व्युत्क्रम का उपयोग करें, तो यह निश्चित रूप से 1 के क़रीब होगा पर फिर भी संदर्भ नहीं बताता। तो, (उदाहरण के लिए संख्या लेते हुए) tf(“the”) = 100, tf(“messi”) = 5, tf(“floccinaucinihilipilification”) = 1
  • इनवर्स डॉक्युमेंट फ़्रीक्वेंसी (idf): बार-बार और दुर्लभ शब्दों की ऊपर बताई समस्या इस टर्म से हल होती है। यह क्या है? इसे {आपके कॉर्पस में डॉक्युमेंट्स की संख्या / जिन डॉक्युमेंट्स में यह टर्म आता है उनकी संख्या} का लॉग लेकर निकाला जाता है। तो “the” के लिए यह अनुपात 1 के क़रीब होगा। इसलिए, लॉग इसे 0 पर ले जाएगा। idf(“the”) = 0, idf(“messi”) = log(10/3) = 0.52 (क्योंकि कॉर्पस फुटबॉल के बारे में है), idf(“floccinaucinihilipilification”) = log(10/1) = 1
  • अंतिम चरण: अब हम चाहते हैं कि “messi” को दिया गया वेट बाकी दो शब्दों से ज्यादा हो। इसके लिए हम दोनों टर्म्स को गुणा करते हैं: tfidf = tf x idf — "the" = 100 x 0 = 0, "floccinaucinihilipilification" = 1 x 1 = 1, "messi" = 5 x 0.52 = 2.6

यह वेटिंग तकनीक क्लासिफिकेशन के दौरान मशीन लर्निंग (ML) मॉडल की मदद करती है क्योंकि हम स्पष्ट रूप से बताते हैं कि कौन-सा शब्द अधिक/कम वज़नी है।

अब जब आप इसके बारे में जानते हैं, तो इसे ट्रेनिंग और टेस्टिंग डेटा पर लागू करते हैं।

tf_vect = TfidfVectorizer(lowercase = True, use_idf=True, smooth_idf=True, sublinear_tf=False)

X_train_tf = tf_vect.fit_transform(review_train)
X_test_tf = tf_vect.transform(review_test)

मॉडल को लागू करना

अब आप Support Vector Machines (SVM) नामक मशीन लर्निंग मॉडल को लागू करेंगे। इसे समझने के लिए आप यह लिंक देख सकते हैं।

अपने ML एल्गोरिदम के लिए सर्वश्रेष्ठ हाइपरपैरामीटर्स चुनने के लिए आप GridSearchCV का उपयोग करेंगे, जो आपके ट्रेनिंग डेटा और लेबल के आधार पर, आपकी दी गई सूची में से सर्वश्रेष्ठ हाइपरपैरामीटर मान सुझाता है। आप Cs और gammas के पाँच अलग-अलग मान चुनेंगे और अपने डेटा के आधार पर आपको सर्वश्रेष्ठ हाइपरपैरामीटर मिलेंगे।

def svc_param_selection(X, y, nfolds):
    Cs = [0.001, 0.01, 0.1, 1, 10]
    gammas = [0.001, 0.01, 0.1, 1]
    param_grid = {'C': Cs, 'gamma' : gammas}
    grid_search = GridSearchCV(svm.SVC(kernel='linear'), param_grid, cv=nfolds)
    grid_search.fit(X, y)
    return grid_search.best_params_
svc_param_selection(X_train_tf,label_train,5)
{'C': 10, 'gamma': 0.001}
clf = svm.SVC(C=10,gamma=0.001,kernel='linear')
clf.fit(X_train_tf,label_train)
pred = clf.predict(X_test_tf)

Tfidf वेक्टराइज़र और ML मॉडल को सेव करें

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

with open('vectorizer.pickle', 'wb') as fin:
    pickle.dump(tf_vect, fin)
with open('mlmodel.pickle','wb') as f:
    pickle.dump(clf,f)

Tfidf वेक्टराइज़र और ML मॉडल लोड करें

pkl = open('mlmodel.pickle', 'rb')
clf = pickle.load(pkl)   
vec = open('vectorizer.pickle', 'rb')
tf_vect = pickle.load(vec)
/home/naveksha/.local/lib/python3.5/site-packages/sklearn/base.py:311: UserWarning: Trying to unpickle estimator SVC from version pre-0.18 when using version 0.19.1. This might lead to breaking code or invalid results. Use at your own risk.
  UserWarning)
/home/naveksha/.local/lib/python3.5/site-packages/sklearn/base.py:311: UserWarning: Trying to unpickle estimator TfidfTransformer from version pre-0.18 when using version 0.19.1. This might lead to breaking code or invalid results. Use at your own risk.
  UserWarning)
/home/naveksha/.local/lib/python3.5/site-packages/sklearn/base.py:311: UserWarning: Trying to unpickle estimator TfidfVectorizer from version pre-0.18 when using version 0.19.1. This might lead to breaking code or invalid results. Use at your own risk.
  UserWarning)

टेस्ट डेटा पर प्रिडिक्ट करें

X_test_tf = tf_vect.transform(review_test)
pred = clf.predict(X_test_tf)

मॉडल के प्रदर्शन का विश्लेषण करने के लिए कन्फ्यूजन मैट्रिक्स, एक्यूरसी स्कोर और क्लासिफिकेशन रिपोर्ट प्लॉट करें

print(metrics.accuracy_score(label_test, pred))
0.96875
print (confusion_matrix(label_test, pred))
[[149   6]
 [  4 161]]

उपरोक्त कन्फ्यूजन मैट्रिक्स 2 x 2 मैट्रिक्स है, जिसमें पहली पंक्ति का पहला तत्व True Positive (TP), पहली पंक्ति का दूसरा तत्व False Negative (FN), दूसरी पंक्ति का पहला तत्व False Positive (FP) और दूसरी पंक्ति का दूसरा तत्व True Negative (TN) है।

ऊपर दिए गए कन्फ्यूजन मैट्रिक्स से, आप निष्कर्ष निकाल सकते हैं कि 320 में से केवल 10 टेस्ट नमूनों का गलत वर्गीकरण हुआ।

print (classification_report(label_test, pred))
             precision    recall  f1-score   support

  deceptive       0.97      0.96      0.97       155
      truth       0.96      0.98      0.97       165

avg / total       0.97      0.97      0.97       320

विभिन्न रैंडम स्टेट्स का उपयोग करके मॉडल का परीक्षण करें

  • Random State 1
review_train, review_test, label_train, label_test = train_test_split(result['pos'],result['Labels'], test_size=0.2,random_state=1)
X_test_tf = tf_vect.transform(review_test)
pred = clf.predict(X_test_tf)
print(metrics.accuracy_score(label_test, pred))
0.978125
print (confusion_matrix(label_test, pred))
[[146   5]
 [  2 167]]
print (classification_report(label_test, pred))
             precision    recall  f1-score   support

  deceptive       0.99      0.97      0.98       151
      truth       0.97      0.99      0.98       169

avg / total       0.98      0.98      0.98       320
  • Random State 10
review_train, review_test, label_train, label_test = train_test_split(result['pos'],result['Labels'], test_size=0.2,random_state=10)
X_test_tf = tf_vect.transform(review_test)
pred = clf.predict(X_test_tf)
print(metrics.accuracy_score(label_test, pred))
0.98125
print (confusion_matrix(label_test, pred))
[[155   5]
 [  1 159]]
print (classification_report(label_test, pred))
             precision    recall  f1-score   support

  deceptive       0.99      0.97      0.98       160
      truth       0.97      0.99      0.98       160

avg / total       0.98      0.98      0.98       320
  • Random State 42
review_train, review_test, label_train, label_test = train_test_split(result['pos'],result['Labels'], test_size=0.2,random_state=42)
X_test_tf = tf_vect.transform(review_test)
pred = clf.predict(X_test_tf)
print(metrics.accuracy_score(label_test, pred))
0.984375
print (confusion_matrix(label_test, pred))
[[165   3]
 [  2 150]]
print (classification_report(label_test, pred))
             precision    recall  f1-score   support

  deceptive       0.99      0.98      0.99       168
      truth       0.98      0.99      0.98       152

avg / total       0.98      0.98      0.98       320

उपरोक्त प्रिडिक्शन्स से आप देख सकते हैं कि मॉडल ने शानदार काम किया और ओवरफिटिंग नहीं कर रहा है क्योंकि आपने डेटा को हर बार अलग तरह से बाँटकर कई बार मॉडल का परीक्षण किया।

Yelp के दो रिव्यू के साथ मॉडल का परीक्षण करें

def test_string(s):
    X_test_tf = tf_vect.transform([s])
    y_predict = clf.predict(X_test_tf)
    return y_predict
test_string("The hotel was good.The room had a 27-inch Samsung led tv, a microwave.The room had a double bed")
array(['truth'], dtype=object)
test_string("My family and I are huge fans of this place. The staff is super nice, and the food is great. The chicken is very good, and the garlic sauce is perfect. Ice cream topped with fruit is delicious too. Highly recommended!")
array(['deceptive'], dtype=object)

अच्छा, मॉडल ने ऊपर दिए गए दोनों रिव्यू सही तरीके से प्रिडिक्ट किए। पहला रिव्यू एक सत्य रिव्यू है जबकि दूसरा रिव्यू भ्रामक है!

नोट

जब मॉडल को अलग-अलग स्पेसिफिकेशन वाले अलग प्रोसेसिंग सिस्टम पर लागू किया गया, तो इसके प्रदर्शन में बदलाव देखा गया—यह एक असामान्य व्यवहार है। यदि समुदाय इस समस्या को समझने में मदद कर सके, तो इससे इस पोस्ट के लेखक सहित कई लोगों को मदद मिलेगी। यहाँ समुदाय से आशय है वे पाठक जो इस ट्यूटोरियल से गुजरेंगे!

सीखते रहिए!

आशा है यह ट्यूटोरियल वास्तव में सहायक रहा और आपके कौशल में कुछ मूल्य जोड़ा।

यदि आप Machine Learning के बारे में और सीखना चाहते हैं, तो DataCamp का Building Chatbots in Python कोर्स देखें।

विषय