Tutorial Sistem Rekomendasi untuk Platform Streaming

Karena budaya baru binge-watching serial TV dan film, pengguna mengonsumsi konten dengan cepat melalui layanan yang tersedia seperti Netflix, Prime Video, Hulu, dan Disney+. Beberapa platform baru ini, seperti Hulu dan YouTube TV, juga menawarkan siaran langsung untuk acara seperti olahraga, konser/tur, dan saluran berita. Siaran langsung masih belum diadopsi oleh beberapa platform streaming, seperti Netflix.

Platform streaming memberi fleksibilitas lebih kepada pengguna untuk menonton serial TV dan film favorit mereka kapan saja, di perangkat apa pun. Layanan ini dapat menarik lebih banyak konsumen muda dan modern karena beragamnya konten TV dan film. Ini memungkinkan mereka menonton program yang terlewat sesuai waktu luang mereka. Dalam tutorial ini, Anda akan menganalisis data film dari platform streaming Netflix, Prime Video, Hulu, dan Disney+ serta mencoba memahami pemirsanya.

Memahami Dataset

Data ini hanya terdiri dari film yang tersedia di platform streaming seperti Netflix, Prime Video, Hulu, dan Disney+. Anda dapat mengunduhnya dari Kaggle di sini.

Mari jelaskan atribut data secara rinci:

• ID: ID unik untuk setiap catatan.
• Title: Nama film
• Year: Tahun rilis film.
• Age: kelompok usia sasaran
• IMDb: Peringkat IMDB film.
• Rotten Tomatoes: Persentase Rotten Tomatoes
• Netflix: apakah film tersebut ada di Netflix
• Hulu: apakah film tersebut ada di Hulu
• Prime Video: apakah film tersebut ada di Prime Video
• Disney+: apakah film tersebut ada di Disney+
• Type: Film atau acara TV
• Directors: Nama sutradara
• Genres: Jenis genre
• Country: Negara asal
• Language: Bahasa asal
• Runtime: Durasi film

Mari impor modul yang diperlukan dan muat dataset:

 # 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])

Menangani Nilai Hilang

Pada bagian ini, Anda akan bekerja dengan nilai hilang menggunakan fungsi isnull(). Mari lihat contohnya di bawah:

 #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

Anda dapat melihat bahwa variabel Age dan Rotten Tomatoes memiliki lebih dari 50% nilai hilang, yang mengkhawatirkan.

Sekarang, kita akan menangani nilai hilang dengan langkah-langkah berikut:

• Hapus kolom yang memiliki lebih dari 50% nilai hilang
• Hapus NA dari kolom IMDb, Directors, Genres, Country, Language, dan Runtime
• Reset indeks
• Ubah kolom year menjadi object

# 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

Plot Distribusi

Anda dapat memeriksa distribusi kolom Year menggunakan fungsi distplot() dari seaborn. Mari plot distribusi Year film.

#checking Distribution of years
plt.figure(figsize=(20,5))
sns.distplot(df['Year'])
plt.show()

Bagan menunjukkan distribusi tahun asal film. Anda dapat menafsirkan bahwa sebagian besar film dibuat antara tahun 2000 hingga 2020. Mari plot distribusi peringkat IMDB.

# Distribution of IMDb Rating
plt.figure(figsize=(20,5))
sns.distplot(df['IMDb'])
plt.show()

Plot distribusi di atas sedikit menyimpang. Anda dapat menafsirkan bahwa nilai tengah IMDB sebagian besar film adalah 6,5.

Mari plot distribusi Runtime film.

# Distribution of runtime
sns.distplot(df['Runtime'])
plt.show()

Dari bagan di atas, Anda dapat menafsirkan bahwa rata-rata durasi film berada antara 80 hingga 120 menit.

Distribusi Film pada Setiap Platform Streaming

Pada bagian ini, Anda akan melihat distribusi film per platform streaming. Pertama, Anda perlu membuat fungsi m_cnt() yang menghitung jumlah film untuk platform streaming tertentu. Setelah itu, Anda dapat membuat plot menggunakan diagram pai dan memahami pangsa platform streaming.

# 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()

Dari plot di atas, dapat dikatakan bahwa Prime Video menayangkan jumlah judul terbanyak dengan pangsa 71% dan Netflix menayangkan 20% judul. Disney+ dan Hulu menayangkan judul paling sedikit, masing-masing 5,4% dan 3,4%.

Distribusi Film Menurut Genre

Pada bagian ini, Anda akan melihat distribusi film per genre. Pertama, Anda perlu menyiapkan data. Anda harus menangani beberapa genre yang diberikan dalam satu sel dataframe. Untuk itu, Anda dapat menggunakan fungsi split(), apply(), dan stack(). Fungsi split() memisahkan beberapa nilai dengan koma dan membuat daftar. apply(pd.Series,1) untuk membuat beberapa kolom untuk setiap genre dan fungsi stack() menumpuknya menjadi satu kolom.

Setelah tiga operasi ini, kolom Genres baru akan digabungkan dengan dataframe yang ada, dan Anda siap untuk membuat plot. Anda dapat menampilkan 10 genre teratas beserta jumlah filmnya menggunakan fungsi value_counts() dan menggunakan fungsi plot() dari pustaka pandas.

 ##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()

Dari plot di atas, dapat dikatakan bahwa sebagian besar film memiliki genre umum Drama dan Komedi.

Distribusi Film Menurut Negara

Pada bagian ini, Anda akan melihat distribusi film per negara. Pertama, Anda perlu menyiapkan data. Anda harus menangani beberapa negara yang diberikan dalam satu sel dataframe. Untuk itu, Anda dapat menggunakan fungsi split(), apply(), dan stack(). Fungsi split() memisahkan beberapa nilai dengan koma dan membuat daftar. apply(pd.Series,1) untuk membuat beberapa kolom untuk setiap negara dan fungsi stack() menumpuknya menjadi satu kolom.

Setelah tiga operasi ini, kolom Country baru akan digabungkan dengan dataframe yang ada dan Anda siap untuk membuat plot. Anda dapat menampilkan 10 negara teratas beserta jumlah filmnya menggunakan fungsi value_counts() dan menggunakan fungsi plot() dari pustaka pandas.

 # 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()

Grafik di atas menunjukkan bahwa mayoritas film dibuat di Amerika Serikat.

Distribusi Film Menurut Bahasa

Pada bagian ini, Anda akan melihat distribusi film per bahasa. Pertama, Anda perlu menyiapkan data. Anda harus menangani beberapa bahasa yang diberikan dalam satu sel dataframe. Untuk itu, Anda dapat menggunakan fungsi split(), apply(), dan stack(). Fungsi split() memisahkan beberapa nilai dengan koma dan membuat daftar. apply(pd.Series,1) untuk membuat beberapa kolom untuk setiap bahasa dan fungsi stack() menumpuknya menjadi satu kolom.

Setelah tiga operasi ini, kolom Language baru akan digabungkan dengan dataframe yang ada, dan Anda siap untuk membuat plot. Anda dapat menampilkan 10 bahasa teratas beserta jumlah filmnya menggunakan fungsi value_counts() dan menggunakan fungsi plot() dari pustaka pandas.

 # 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()

Dari plot di atas, Anda dapat menyimpulkan bahwa mayoritas film berbahasa Inggris.

Distribusi Peringkat IMDB pada Setiap Platform

Pada bagian ini, Anda akan membuat plot distribusi peringkat IMDB per platform. Untuk mendapatkan hasil ini, Anda perlu menerapkan fungsi melt() dan membuat plot FacetGrid. Fungsi melt() mengonversi dataframe lebar menjadi dataframe panjang. Mari lihat contoh di bawah:

 # 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()

Plot di atas menunjukkan distribusi rata-rata peringkat IMDB pada setiap platform.

Runtime per Platform Bersama Kelompok Usia

Pada bagian "Menangani Nilai Hilang", saya telah menghapus kolom Age. Untuk mendapatkan hasil Runtime per Platform bersama Kelompok Usia, saya perlu memuat data kembali dan menerapkan fungsi 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)

Setelah memuat dataset kembali dan melakukan melting, saatnya membuat plot untuk runtime vs. platform streaming untuk berbagai kelompok usia.

# Total of runtime in different platform
ax = sns.barplot(x="platform", y="Runtime",hue="Age", estimator=sum, data=df2)

Plot di atas menunjukkan bahwa total runtime di Prime Video oleh pengguna kelompok usia 18+ jauh lebih tinggi dibandingkan platform lain. Anda dapat menafsirkan bahwa sebagian besar konten Prime Video berfokus pada kelompok usia 18+.

Membangun Sistem Rekomendasi

Dalam beberapa tahun terakhir, seiring pesatnya YouTube, Walmart, Netflix, dan banyak layanan berbasis web lainnya, sistem rekomendasi telah memberikan dampak besar di industri. Mulai dari menyarankan produk/layanan hingga meningkatkan nilai perusahaan melalui monetisasi iklan online dan mencocokkan relevansi serta preferensi pengguna agar mereka melakukan pembelian. Sistem rekomendasi tak tergantikan dalam penjelajahan web harian kita.

Secara umum, ini adalah kerangka berbasis matematika yang berfokus pada penyaranan produk/layanan kepada pengguna akhir yang relevan dengan kebutuhan dan keinginan mereka. Misalnya, film untuk ditonton, artikel untuk dibaca, produk untuk dibeli, musik untuk didengarkan, atau apa pun tergantung domainnya. Secara garis besar ada tiga metode untuk membangun Sistem Rekomendasi:

1. Metode Berbasis Konten: Mendefinisikan model untuk pengguna atau item yang berinteraksi dengannya berdasarkan himpunan fitur item untuk merekomendasikan item serupa kepada pengguna.
2. Metode Collaborative Filtering: Mendefinisikan model berdasarkan skor kemiripan interaksi pengguna dan item atau skor kemiripan antar pengguna untuk rekomendasi item.
3. Metode Hibrida: Menggunakan metode berbasis konten dan collaborative untuk mencapai hasil yang lebih baik.

Mari terlebih dahulu melakukan prapemrosesan dataset untuk sistem rekomendasi. Pertama, periksa nilai hilang:

# 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")

Anda akan membangun dua sistem rekomendasi berdasarkan cosine similarity.

1. Menggunakan hanya variabel numerik
2. Menggunakan variabel numerik dan kategorikal

Menggunakan Hanya Kolom Numerik

Langkah 1: Pilih variabel numerik

ndf = df.select_dtypes(include=['float64',"int64"])

Langkah 2: Skala variabel numerik menggunakan min-max scaler untuk mengurangi kompleksitas model dan waktu pelatihan

#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()

Langkah 3: Hitung skor kemiripan menggunakan cosine similarity

Sekarang, Anda akan menghitung skor kemiripan menggunakan cosine similarity.

# 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()

Langkah 4: Menulis fungsi untuk mendapatkan rekomendasi berdasarkan skor kemiripan

• Fungsi menerima dua argumen, judul film dan skor kemiripan. Fungsi mencari indeks judul yang sesuai dengan indeks original_titles dalam deret indeks kita.
• Mengambil skor kemiripan berpasangan untuk semua film.
• Mengurutkan skor kemiripan secara menurun dan mengonversinya menjadi daftar.
• Mengambil 10 skor dan indeks film teratas serta mengembalikan judul 10 film teratas dari data frame kita.

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)

Di sini, film yang direkomendasikan belum memuaskan. Alasan hasil yang kurang baik ini adalah karena Anda hanya menggunakan peringkat film, durasi film, dan variabel platform. Anda dapat meningkatkannya dengan menggunakan informasi lain seperti genre, sutradara, dan negara.

Menggunakan Kolom Numerik dan Tekstual

Karna sistem rekomendasi sebelumnya bekerja namun rekomendasinya belum memuaskan, Anda akan mencoba pendekatan baru yang lebih baik untuk meningkatkan hasil.

df.head()

Langkah 1:

Anda akan menggabungkan kolom tekstual ke dalam satu kolom lalu menggunakan tokenizer dan TF-IDF Vectorizer untuk membuat matriks jarang dari seluruh skor TF-IDF kata. Kemudian Anda akan memilih dan menskalakan variabel numerik dan menambahkannya ke matriks jarang tersebut. Anda perlu melakukan langkah-langkah berikut untuk prapemrosesan:

• Memilih semua tipe data object dan menyimpannya dalam daftar.
• Menghapus kolom ID dan Title.
• Menggabungkan semua kolom teks/object dengan koma ke dalam satu kolom.
• Membuat tokenizer untuk menghapus elemen yang tidak diinginkan dari data seperti simbol dan angka.
• Mengonversi TfidfVector dari teks Setelah itu kita akan melakukan prapemrosesan kolom numerik
• Memilih variabel numerik ke dalam DataFrame
• Menskalakan variabel numerik menggunakan minmax scaler (rentang 0,1)
• Menambahkan variabel numerik ke matriks jarang vektor TF-IDF menggunakan fungsi hstack (hstack digunakan untuk menambahkan array secara horizontal ke matriks jarang).

#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

Langkah 2: Menerapkan fungsi pada data kita dan membuat matriks jarang

# Preprocessing data
mat =preprocess(df)
mat.shape

Langkah 3: Kembali menerapkan Cosine Similarity untuk menghitung skor kemiripan

# 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()

Langkah 4: Mendapatkan rekomendasi dari sistem yang telah ditingkatkan.

give_rec("The Matrix",sig=sig2)

Kali ini sistem rekomendasi bekerja jauh lebih baik daripada sistem sebelumnya, yang menunjukkan bahwa dengan menambahkan data yang lebih relevan seperti teks deskripsi, sistem rekomendasi berbasis konten dapat ditingkatkan secara signifikan.

Kesimpulan

Selamat, Anda telah sampai di akhir tutorial ini!

Dalam tutorial ini, Anda melakukan analisis eksploratif pada dataset film platform streaming. Anda telah mengeksplorasi nilai hilang, plot distribusi per variabel, dan distribusi film pada setiap platform streaming. Anda juga menemukan wawasan tentang genre, negara, bahasa, peringkat IMDB, dan durasi film. Terakhir, Anda juga telah melihat cara membangun sistem rekomendasi di Python.

Lihat tutorial DataCamp Recommender Systems in Python.