स्ट्रीमिंग प्लेटफ़ॉर्म्स के लिए रिकमेंडेशन सिस्टम ट्यूटोरियल

टीवी शो और फ़िल्मों को बिंज-वॉच करने की नई संस्कृति के कारण, उपयोगकर्ता Netflix, Prime Video, Hulu और Disney+ जैसी उपलब्ध सेवाओं के साथ तेज़ी से सामग्री देख रहे हैं। इन नए प्लेटफ़ॉर्म्स में से कुछ, जैसे Hulu और YouTube TV, खेल, लाइव कॉन्सर्ट/टूर और न्यूज़ चैनलों जैसे इवेंट्स की लाइव स्ट्रीमिंग भी प्रदान करते हैं। Netflix जैसे कुछ स्ट्रीमिंग प्लेटफ़ॉर्म्स ने अभी तक लाइव स्ट्रीमिंग को नहीं अपनाया है।

स्ट्रीमिंग प्लेटफ़ॉर्म्स उपयोगकर्ताओं को किसी भी समय, किसी भी डिवाइस पर अपने पसंदीदा टीवी शो और फ़िल्में देखने की अधिक सुविधा देते हैं। टीवी और फ़िल्मी सामग्री की विस्तृत विविधता के कारण ये सेवाएँ अधिक युवा और आधुनिक उपभोक्ताओं को आकर्षित कर सकती हैं। यह उन्हें अपनी सुविधा के अनुसार छूटा हुआ कोई भी प्रोग्राम देखने की अनुमति देता है। इस ट्यूटोरियल में, आप Netflix, Prime Video, Hulu और Disney+ के स्ट्रीमिंग प्लेटफ़ॉर्म्स के मूवी डेटा का विश्लेषण करेंगे और उनके दर्शकों को समझने की कोशिश करेंगे।

डेटासेट को समझना

यह डेटा केवल उन फ़िल्मों का है जो Netflix, Prime Video, Hulu और Disney+ जैसे स्ट्रीमिंग प्लेटफ़ॉर्म्स पर उपलब्ध हैं। आप इसे Kaggle से यहाँ डाउनलोड कर सकते हैं।

आइए डेटा एट्रिब्यूट्स को विस्तार से वर्णित करें:

• ID: हर रिकॉर्ड के लिए एक यूनिक ID।
• Title: फ़िल्म का नाम
• Year: फ़िल्म का रिलीज़ वर्ष।
• Age: लक्षित आयु समूह
• IMDb: फ़िल्मों की IMDB रेटिंग।
• Rotten Tomatoes: Rotten Tomatoes %
• Netflix: क्या फ़िल्म Netflix पर है
• Hulu: क्या फ़िल्म Hulu पर है
• Prime Video: क्या फ़िल्म Prime Video पर है
• Disney+: क्या फ़िल्म Disney+ पर है
• Type: मूवी या टीवी शो
• Directors: निर्देशक का नाम
• Genres: शैली का प्रकार
• Country: मूल देश
• Language: मूल भाषा
• Runtime: फ़िल्म की अवधि

आइए आवश्यक मॉड्यूल इम्पोर्ट करें और डेटासेट लोड करें:

 # Import required libraries
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.feature_extraction.text import TfidfVectorizer    
from nltk.tokenize import RegexpTokenizer
import numpy as np
from sklearn import preprocessing
from scipy.sparse import hstack
import pandas_profilingसंचालित द्वारा

# Load dataset
df = pd.read_csv("tvshow.csv")
df=df.iloc[:,1:] # removing in unnamed index columnसंचालित द्वारा

df.head()संचालित द्वारा

# Show initial information about the dataset
df.info()
संचालित द्वारा

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 16744 entries, 0 to 16743
Data columns (total 16 columns):
 #   Column           Non-Null Count  Dtype  
---  ------           --------------  -----  
 0   ID               16744 non-null  object
 1   Title            16744 non-null  object
 2   Year             16744 non-null  int64  
 3   Age              7354 non-null   object
 4   IMDb             16173 non-null  float64
 5   Rotten Tomatoes  5158 non-null   object
 6   Netflix          16744 non-null  int64  
 7   Hulu             16744 non-null  int64  
 8   Prime Video      16744 non-null  int64  
 9   Disney+          16744 non-null  int64  
 10  Type             16744 non-null  int64  
 11  Directors        16018 non-null  object
 12  Genres           16469 non-null  object
 13  Country          16309 non-null  object
 14  Language         16145 non-null  object
 15  Runtime          16152 non-null  float64
dtypes: float64(2), int64(6), object(8)
memory usage: 2.0+ MB
संचालित द्वारा

df.Type.unique()
संचालित द्वारा

array([0])
संचालित द्वारा

मिसिंग वैल्यूज़ के साथ काम करना

इस खंड में, आप isnull() फ़ंक्शन का उपयोग करके मिसिंग वैल्यूज़ के साथ काम करेंगे। नीचे एक उदाहरण देखें:

 #Finding Missing values in all columns
miss = pd.DataFrame(df.isnull().sum())
miss = miss.rename(columns={0:"miss_count"})
miss["miss_%"] = (miss.miss_count/len(df.ID))*100
missसंचालित द्वारा

आप देख सकते हैं कि Age और Rotten tomatoes वेरिएबल्स में 50% से अधिक मिसिंग वैल्यूज़ हैं, जो चिंताजनक है।

अब, हम निम्न चरणों में मिसिंग वैल्यूज़ को हैंडल करेंगे:

• उन कॉलम्स को हटाएँ जिनमें 50% से अधिक मिसिंग वैल्यूज़ हैं
• IMDb, Directors, Genres, Country, Language और Runtime कॉलम से NA हटाएँ
• इंडेक्स रीसेट करें
• Year कॉलम को ऑब्जेक्ट में बदलें

# Dropping values with missing % more than 50%
df.drop(['Rotten Tomatoes', 'Age'], axis = 1, inplace=True)
# Dropping Na's from the following columns
df.dropna(subset=['IMDb','Directors', 'Genres', 'Country', 'Language', 'Runtime'],inplace=True)
df.reset_index(inplace=True,drop=True)
# Converting into object type
df.Year = df.Year.astype("object")संचालित द्वारा

df.info()संचालित द्वारा

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 15233 entries, 0 to 15232
Data columns (total 14 columns):
 #   Column       Non-Null Count  Dtype  
---  ------       --------------  -----  
 0   ID           15233 non-null  object
 1   Title        15233 non-null  object
 2   Year         15233 non-null  object
 3   IMDb         15233 non-null  float64
  4   Netflix      15233 non-null  int64  
 5   Hulu         15233 non-null  int64  
 6   Prime Video  15233 non-null  int64  
 7   Disney+      15233 non-null  int64  
 8   Type         15233 non-null  int64  
 9   Directors    15233 non-null  object
 10  Genres       15233 non-null  object
 11  Country      15233 non-null  object
 12  Language     15233 non-null  object
 13  Runtime      15233 non-null  float64
dtypes: float64(2), int64(5), object(7)
memory usage: 1.6+ MB
संचालित द्वारा

डिस्ट्रिब्यूशन प्लॉट्स

आप seaborn के distplot() फ़ंक्शन का उपयोग करके Year कॉलम का वितरण जाँच सकते हैं। आइए Movie Year का वितरण प्लॉट करें।

#checking Distribution of years
plt.figure(figsize=(20,5))
sns.distplot(df['Year'])
plt.show()
संचालित द्वारा

चार्ट फ़िल्मों के मूल वर्ष का वितरण दिखा रहा है। आप समझ सकते हैं कि अधिकांश फ़िल्में 2000 से 2020 के बीच बनीं। आइए IMDB रेटिंग का वितरण प्लॉट करें।

# Distribution of IMDb Rating
plt.figure(figsize=(20,5))
sns.distplot(df['IMDb'])
plt.show()
संचालित द्वारा

ऊपर दिया गया वितरण प्लॉट थोड़ा स्क्यूड है। आप समझ सकते हैं कि अधिकांश फ़िल्मों का औसत IMDB लगभग 6.5 है।

आइए Movie Runtime का वितरण प्लॉट करें।

# Distribution of runtime
sns.distplot(df['Runtime'])
plt.show()
संचालित द्वारा

ऊपर दिए गए चार्ट से आप समझ सकते हैं कि फ़िल्मों का औसत रनटाइम 80 से 120 मिनट के बीच है।

प्रत्येक स्ट्रीमिंग प्लेटफ़ॉर्म पर फ़िल्मों का वितरण

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

# A function to calculate the movies in different Streaming platforms
def m_cnt(plat, count=False):
    if count==False:
        print('Platform {} Count: {}'. format(plat, df[plat].sum()))
    else:
        return df[plat].sum()
संचालित द्वारा

# Let's see count of movies/shows of each streaming platform
m_cnt('Netflix')
m_cnt('Hulu')
m_cnt('Prime Video')
m_cnt('Disney+')
संचालित द्वारा

Platform Netflix Count: 3152
Platform Hulu Count: 848
Platform Prime Video Count: 11289
Platform Disney+ Count: 542
संचालित द्वारा

# Movies on each platform
lab = 'Prime Video','Netflix', 'Hulu', 'Disney'
s = [m_cnt('Prime Video', count=True),
     m_cnt('Netflix', count=True),
     m_cnt('Hulu', count=True),
     m_cnt('Disney+', count=True)]

explode = (0.1, 0.1, 0.1, 0.1)

#plotting
fig1, ax1 = plt.subplots()
ax1.pie(s,
       labels = lab,
       autopct = '%1.1f%%',
       explode = explode,
       shadow = True,
       startangle = 100)

ax1.axis = ('equal')
plt.show()
संचालित द्वारा

ऊपर दिए गए प्लॉट से, आप कह सकते हैं कि Prime Video 71% हिस्सेदारी के साथ अधिकतम टाइटल होस्ट कर रहा है और Netflix 20% टाइटल होस्ट कर रहा है। Disney+ और Hulu क्रमशः 5.4% और 3.4% के साथ सबसे कम टाइटल होस्ट कर रहे हैं।

शैली (Genre) के अनुसार फ़िल्मों का वितरण

इस खंड में, आप शैली के अनुसार फ़िल्मों का वितरण देखेंगे। सबसे पहले, आपको अपने डेटा को तैयार करना होगा। आपको dataframe की एक ही सेल में दी गई एक से अधिक शैलियों को संभालना होगा। इसके लिए आप split(), apply() और stack() फ़ंक्शंस का उपयोग कर सकते हैं। split() फ़ंक्शन कॉमा से अलग कई मानों को बाँटकर एक सूची बनाता है। apply(pd.Series,1) प्रत्येक शैली के लिए कई कॉलम बनाने के लिए और stack() फ़ंक्शन उन्हें एक ही कॉलम में स्टैक करने के लिए।

इन तीन ऑपरेशन्स के बाद, एक नई Genres कॉलम मौजूदा dataframe के साथ जुड़ जाएगी, और आप प्लॉट करने के लिए तैयार हैं। आप value_counts() फ़ंक्शन का उपयोग कर शीर्ष 10 शैलियाँ उनके मूवी काउंट के साथ दिखा सकते हैं और pandas लाइब्रेरी के plot() फ़ंक्शन का उपयोग कर सकते हैं।

 ##split the genres by ',' & then stack it one after the other for easy analysis.
g = df['Genres'].str.split(',').apply(pd.Series, 1).stack()
g.index = g.index.droplevel(-1)
# Assign name to column
g.name = 'Genres'
# delete column
del df['Genres']
# join new column with the existing dataframe
df_genres = df.join(g)संचालित द्वारा

# Count of movies according to genre
plt.figure(figsize=(15,5))
sns.countplot(x='Genres', data=df_genres)
plt.xticks(rotation=90)
plt.show()संचालित द्वारा

ऊपर दिए गए प्लॉट से, आप कह सकते हैं कि अधिकांश फ़िल्मों की आम शैलियाँ Drama और Comedy हैं।

देश के अनुसार फ़िल्मों का वितरण

इस खंड में, आप देश के अनुसार फ़िल्मों का वितरण देखेंगे। सबसे पहले, आपको अपने डेटा को तैयार करना होगा। आपको dataframe की एक ही सेल में दिए गए एक से अधिक देशों को संभालना होगा। इसके लिए आप split(), apply(), और stack() फ़ंक्शंस का उपयोग कर सकते हैं। split() फ़ंक्शन कॉमा से अलग कई मानों को बाँटकर एक सूची बनाता है। apply(pd.Series,1) प्रत्येक देश के लिए कई कॉलम बनाने के लिए और stack() फ़ंक्शन उन्हें एक ही कॉलम में स्टैक करने के लिए।

इन तीन ऑपरेशन्स के बाद, एक नया Country कॉलम मौजूदा dataframe के साथ जुड़ जाएगा और आप प्लॉट करने के लिए तैयार हैं। आप value_counts() फ़ंक्शन का उपयोग कर शीर्ष 10 देश उनके मूवी काउंट के साथ दिखा सकते हैं और pandas लाइब्रेरी के plot() फ़ंक्शन का उपयोग कर सकते हैं।

 # Split the Country by ',' & then stack it one after the other for easy analysis.
c = df['Country'].str.split(',').apply(pd.Series, 1).stack()
c.index = c.index.droplevel(-1)
# Assign name to column
c.name = 'Country'
# delete column
del df['Country']
# join new column with the existing dataframe
df_country = df.join(c)संचालित द्वारा

# plotting top 10 country and movie count
df_country['Country'].value_counts()[:10].plot(kind='bar',figsize=(15,5))
plt.show()संचालित द्वारा

ऊपर दिया गया ग्राफ़ दिखाता है कि अधिकांश फ़िल्में संयुक्त राज्य अमेरिका में बनीं।

भाषा के अनुसार फ़िल्मों का वितरण

इस खंड में, आप भाषा के अनुसार फ़िल्मों का वितरण देखेंगे। सबसे पहले, आपको अपने डेटा को तैयार करना होगा। आपको dataframe की एक ही सेल में दी गई एक से अधिक भाषाओं को संभालना होगा। इसके लिए आप split(), apply() और stack() फ़ंक्शंस का उपयोग कर सकते हैं। split() फ़ंक्शन कॉमा से अलग कई मानों को बाँटकर एक सूची बनाता है। apply(pd.Series,1) प्रत्येक भाषा के लिए कई कॉलम बनाने के लिए और stack() फ़ंक्शन उन्हें एक ही कॉलम में स्टैक करने के लिए।

इन तीन ऑपरेशन्स के बाद, एक नई Language कॉलम मौजूदा dataframe के साथ जुड़ जाएगी, और आप प्लॉट करने के लिए तैयार हैं। आप value_counts() फ़ंक्शन का उपयोग कर शीर्ष 10 भाषाएँ उनके मूवी काउंट के साथ दिखा सकते हैं और pandas लाइब्रेरी के plot() फ़ंक्शन का उपयोग कर सकते हैं।

 # perform stacking operation on language column
l = df['Language'].str.split(',').apply(pd.Series,1).stack()
l.index = l.index.droplevel(-1)
# Assign name to column
l.name = 'Language'
# delete column
del df['Language']
# join new column with the existing dataframe
df_language = df.join(l)संचालित द्वारा

# plotting top 10 Language and movie count
df_language['Language'].value_counts()[:10].plot(kind='bar',figsize=(15,3))
plt.show()संचालित द्वारा

ऊपर दिए गए प्लॉट से, आप निष्कर्ष निकाल सकते हैं कि अधिकांश फ़िल्में अंग्रेज़ी भाषा में थीं।

प्रत्येक प्लेटफ़ॉर्म पर IMDB रेटिंग का वितरण

इस खंड में, आप प्लेटफ़ॉर्म-वार IMDB रेटिंग का वितरण प्लॉट करेंगे। ये परिणाम पाने के लिए, आपको melt() फ़ंक्शन लागू करना होगा और FacetGrid प्लॉट बनाना होगा। melt() फ़ंक्शन एक चौड़े dataframe को लंबे dataframe में बदलता है। नीचे उदाहरण देखें:

 # melting platform columns to create visualization
df2 = pd.melt(df, id_vars=["ID","Title","Year","IMDb","Type","Runtime"], var_name="platform")
df2 = df2[df2.value==1]
df2.drop(columns=["value"],axis=1,inplace=True)संचालित द्वारा

# Distribution of IMDB rating in different platform
g = sns.FacetGrid(df2, col = "platform")
g.map(plt.hist, "IMDb")
plt.show()संचालित द्वारा

ऊपर दिया गया प्लॉट प्रत्येक प्लेटफ़ॉर्म पर औसत IMDB रेटिंग वितरण दिखाता है।

एज ग्रुप के साथ प्रति प्लेटफ़ॉर्म रनटाइम

"मिसिंग वैल्यूज़ के साथ काम करना" खंड में, मैंने Age कॉलम हटा दिया था। एज ग्रुप के साथ प्रति प्लेटफ़ॉर्म रनटाइम के परिणाम प्राप्त करने के लिए, मुझे डेटा फिर से लोड करना होगा और melt() फ़ंक्शन लागू करना होगा।

# Load dataset
df = pd.read_csv("tvshow.csv")
df=df.iloc[:,1:]
df.ID = df.ID.astype("object")

# melting platform columns to create visualization
df2 = pd.melt(df, id_vars=["ID","Title","Year","Age","IMDb","Rotten Tomatoes","Type","Runtime"], var_name="platform")
df2 = df2[df2.value==1]
df2.drop(columns=["value"],axis=1,inplace=True)
संचालित द्वारा

डेटासेट को दोबारा लोड कर और मेल्टिंग करने के बाद, अब अलग-अलग आयु समूहों के लिए रनटाइम बनाम स्ट्रीमिंग प्लेटफ़ॉर्म का प्लॉट बनाने का समय है।

# Total of runtime in different platform
ax = sns.barplot(x="platform", y="Runtime",hue="Age", estimator=sum, data=df2)
संचालित द्वारा

ऊपर दिया गया प्लॉट दिखाता है कि Prime Video पर 18+ आयु समूह के उपयोगकर्ताओं द्वारा कुल रनटाइम किसी भी अन्य प्लेटफ़ॉर्म की तुलना में काफ़ी अधिक है। आप समझ सकते हैं कि Prime Video की अधिकांश सामग्री 18+ आयु समूह पर केंद्रित है।

एक रिकमेंडर सिस्टम बनाना

पिछले कुछ वर्षों में, YouTube, Walmart, Netflix और ऐसी कई वेब-आधारित सेवाओं की छलाँग के साथ, रिकमेंडर सिस्टम्स ने उद्योग में जबरदस्त प्रभाव डाला है। उत्पादों/सेवाओं का सुझाव देने से लेकर ऑनलाइन विज्ञापन-आधारित मोनेटाइज़ेशन द्वारा कंपनियों का मूल्य बढ़ाने और उपयोगकर्ता की प्रासंगिकता व पसंद से मैच करने तक—ताकि वे खरीदें—रिकमेंडर सिस्टम्स हमारी रोज़मर्रा की वेब खोज में अपरिहार्य हैं।

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

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

आइए पहले रिकमेंडर सिस्टम के लिए डेटासेट को प्रीप्रोसेस करें। पहले, आप मिसिंग वैल्यूज़ जाँचें:

# Reading Data Again
df = pd.read_csv("tvshow.csv")
df=df.iloc[:,1:]
संचालित द्वारा

#Finding Missing values in all columns
miss = pd.DataFrame(df.isnull().sum())
miss = miss.rename(columns={0:"miss_count"})
miss["miss_%"] = (miss.miss_count/len(df.ID))*100
miss
संचालित द्वारा

#Dropping values with missing % more than 50%
df.drop(['Rotten Tomatoes', 'Age'], axis = 1, inplace=True)
# Dropping Na's from the following columns
df.dropna(subset=['IMDb','Directors', 'Genres', 'Country', 'Language', 'Runtime'],inplace=True)
df.reset_index(inplace=True,drop=True)
# converting into object type
df.ID = df.ID.astype("object")
df.Year = df.Year.astype("object")
संचालित द्वारा

आप कोसाइन सिमिलैरिटी के आधार पर दो रिकमेंडर सिस्टम बनाएँगे।

1. Using only the numerical variable
2. Using both numerical and categorical variable
संचालित द्वारा

केवल संख्यात्मक कॉलम का उपयोग

चरण 1: संख्यात्मक वेरिएबल चुनें

ndf = df.select_dtypes(include=['float64',"int64"])
संचालित द्वारा

चरण 2: मॉडल की जटिलता और प्रशिक्षण समय कम करने के लिए मिन-मैक्स स्केलर से संख्यात्मक वेरिएबल को स्केल करना

#importing minmax scaler
from sklearn import preprocessing

# Create MinMaxScaler Object
scaler = preprocessing.MinMaxScaler(feature_range=(0, 1))

# Create dataframe after transformation
ndfmx = pd.DataFrame((scaler.fit_transform(ndf)))

# assign column names
ndfmx.columns=ndf.columns

# Show initial 5 records
ndfmx.head()
संचालित द्वारा

चरण 3: कोसाइन सिमिलैरिटी का उपयोग कर सिमिलैरिटी स्कोर निकालें

अब, आप कोसाइन सिमिलैरिटी का उपयोग कर सिमिलैरिटी स्कोर की गणना करेंगे।

# Import cosine similarity
from sklearn.metrics.pairwise import cosine_similarity

# Compute the cosine similarity
sig = cosine_similarity(ndfmx, ndfmx)

# Reverse mapping of indices and movie titles
indices = pd.Series(df.index, index=df['Title']).drop_duplicates()
संचालित द्वारा

indices.head()
संचालित द्वारा

चरण 4: सिमिलैरिटी स्कोर के आधार पर सिफारिशें पाने के लिए फ़ंक्शन लिखना

• यह फ़ंक्शन दो आर्गुमेंट्स लेता है: मूवी का शीर्षक और सिमिलैरिटी स्कोर्स। यह हमारे indices की सीरीज़ में original_titles इंडेक्स से मेल खाते शीर्षक का इंडेक्स ढूँढता है।
• सभी फ़िल्मों के पेयरवाइज़ सिमिलैरिटी स्कोर्स प्राप्त करें।
• सिमिलैरिटी स्कोर्स को अवरोही क्रम में सॉर्ट करें और उन्हें सूची में बदलें।
• शीर्ष 10 फ़िल्मों के स्कोर्स और इंडेक्स प्राप्त करें और हमारे डेटा फ्रेम से शीर्ष 10 फ़िल्मों के शीर्षक लौटाएँ।

def give_rec(title, sig=sig):

    # Get the index corresponding to original_title
    idx = indices[title]

    # Get the pairwise similarity scores
    sig_scores = list(enumerate(sig[idx]))

    # Sort the movies
    sig_scores = sorted(sig_scores, key=lambda x: x[1], reverse=True)

    # Scores of the 10 most similar movies
    sig_scores = sig_scores[1:11]

    # Movie indices
    movie_indices = [i[0] for i in sig_scores]

    # Top 10 most similar movies
    return df['Title'].iloc[movie_indices]
संचालित द्वारा

# Execute get_rec() function for getting recommendation
give_rec("The Matrix",sig = sig)
संचालित द्वारा

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

संख्यात्मक और पाठ्य कॉलम्स का उपयोग

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

df.head()
संचालित द्वारा

चरण 1:

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

• सभी object डेटा प्रकार चुनना और उन्हें एक सूची में सहेजना।
• ID और Title कॉलम हटाना।
• सभी टेक्स्ट/object कॉलमों को कॉमा से जोड़कर एक ही कॉलम बनाना।
• हमारे डेटा से प्रतीकों और संख्याओं जैसे अवांछित तत्वों को हटाने के लिए एक टोकनाइज़र बनाना।
• टेक्स्ट से TfidfVector बनाना। उसके बाद हम संख्यात्मक कॉलमों का पूर्व-संसाधन करेंगे।
• संख्यात्मक चरों को एक DataFrame में चुनना।
• मिन-मैक्स स्केलर (0,1) रेंज का उपयोग करके संख्यात्मक चरों को स्केल करना।
• hstack फ़ंक्शन का उपयोग करके TF-IDF वेक्टरों की स्पार्स मैट्रिक्स में संख्यात्मक चरों को जोड़ना (hstack स्पार्स मैट्रिक्स में क्षैतिज ऐरे जोड़ने के लिए उपयोग होता है)।

#the function performs all the important preprocessing steps
def preprocess(df):
    #combining all text columns
    # Selecting all object data type and storing them in list
    s = list(df.select_dtypes(include=['object']).columns)
    # Removing ID and Title column
    s.remove("Title")
    s.remove("ID")
    # Joining all text/object columns using commas into a single column
    df['all_text']= df[s].apply(lambda x: ','.join(x.dropna().astype(str)),axis=1)

    # Creating a tokenizer to remove unwanted elements from our data like symbols and numbers
    token = RegexpTokenizer(r'[a-zA-Z]+')

    # Converting TfidfVector from the text
    cv = TfidfVectorizer(lowercase=True,stop_words='english',ngram_range = (1,1),tokenizer = token.tokenize)
    text_counts= cv.fit_transform(df['all_text'])

    # Aelecting numerical variables
    ndf = df.select_dtypes(include=['float64',"int64"])

    # Scaling Numerical variables
    scaler = preprocessing.MinMaxScaler(feature_range=(0, 1))

    # Applying scaler on our data and converting i into a data frame
    ndfmx = pd.DataFrame((scaler.fit_transform(ndf)))
    ndfmx.columns=ndf.columns    

    # Adding our adding numerical variables in the TF-IDF vector
    IMDb = ndfmx.IMDb.values[:, None]
    X_train_dtm = hstack((text_counts, IMDb))
    Netflix = ndfmx.Netflix.values[:, None]
    X_train_dtm = hstack((X_train_dtm, Netflix))
    Hulu = ndfmx.Hulu.values[:, None]
    X_train_dtm = hstack((X_train_dtm, Hulu))
    Prime = ndfmx["Prime Video"].values[:, None]
    X_train_dtm = hstack((X_train_dtm, Prime))
    Disney = ndfmx["Disney+"].values[:, None]
    X_train_dtm = hstack((X_train_dtm, Disney))
    Runtime = ndfmx.Runtime.values[:, None]
    X_train_dtm = hstack((X_train_dtm, Runtime))
    return X_train_dtm
संचालित द्वारा

चरण 2: हमारे डेटा पर फ़ंक्शन लागू करना और स्पार्स मैट्रिक्स बनाना

# Preprocessing data
mat =preprocess(df)
mat.shape
संचालित द्वारा

चरण 3: समानता स्कोर निकालने के लिए दोबारा Cosine Similarity लागू करना

# using cosine similarity
from sklearn.metrics.pairwise import cosine_similarity

# Compute the sigmoid kernel
sig2 = cosine_similarity(mat, mat)

# Reverse mapping of indices and movie titles
indices = pd.Series(df.index, index=df['Title']).drop_duplicates()
संचालित द्वारा

चरण 4: हमारे उन्नत सिस्टम से अनुशंसा प्राप्त करना

give_rec("The Matrix",sig=sig2)
संचालित द्वारा

इस बार रिकमेंडर सिस्टम पहले वाले की तुलना में कहीं बेहतर काम करता है, जो दर्शाता है कि विवरण जैसे प्रासंगिक टेक्स्ट जोड़कर, कंटेंट-आधारित रिकमेंडर सिस्टम को काफी हद तक सुधारा जा सकता है।

निष्कर्ष

बधाई हो, आप इस ट्यूटोरियल के अंत तक पहुँच गए हैं!

इस ट्यूटोरियल में, आपने स्ट्रीमिंग प्लेटफ़ॉर्म मूवी डेटासेट का अन्वेषी विश्लेषण किया। आपने मिसिंग वैल्यूज़, व्यक्तिगत वितरण प्लॉट्स, और प्रत्येक स्ट्रीमिंग प्लेटफ़ॉर्म पर फिल्मों के वितरण का अध्ययन किया। आपने शैली, देश, भाषा, IMDB रेटिंग्स और मूवी रनटाइम पर अंतर्दृष्टियाँ भी खोजीं। अंत में, आपने यह भी देखा कि Python में रिकमेंडर सिस्टम कैसे बनाया जाता है।

DataCamp के Recommender Systems in Python ट्यूटोरियल पर नज़र डालें।