Netflix and Content-Based Filtering: A Perfect Match for Movie Recommendations | by Andi Engku Putribuana | Feb, 2025

Gambaran Struktur Information

Information yang digunakan adalah dataset yang berasal dari Kaggle — Netflix Popoular Movies Dataset yang terdiri dari 9 kolom, diantaranya:

• title = Judul dari movie
• yr= Tahun rilis movie
• certificates = Sertifikat ranking usia, seperti “PG-13”, “R”, dll..
• period = Durasi movie dalam format waktu, misalnya “2h 30m”
• style = Style movie, misalnya “Motion”, “Comedy”, dll..
• ranking = Score movie berdasarkan skor pengguna
• description = Deskripsi singkat tentang cerita movie
• stars = Nama-nama yang membintangi movie
• votes = Jumlah suara (votes) yang diberikan oleh pengguna untuk movie tersebut

Import Library

Import library sesuai dengan kebutuhan. Library yang aku pake disini adalah sebagai berikut: os buat kerja dengan file dan sistem operasi, re buat pencarian pola di teks, numpy buat komputasi ilmiah, pandas buat manipulasi dan analisis knowledge, seaborn dan matplotlib.pyplot buat visualisasi knowledge, tensorflow buat machine studying, TfidfVectorizer buat konversi teks ke matriks TF-IDF, dan cosine_similarity buat hitung kesamaan antara vektor.

import os
import re
import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
import tensorflow as tf
from sklearn.feature_extraction.textual content import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity

Load Dataset

Selanjutnya, kita akan load knowledge yang diambil dari lewat kaggle.com.

#!/bin/bash
!kaggle datasets obtain narayan63/netflix-popular-movies-dataset
import zipfile
zip_path = '/content material/netflix-popular-movies-dataset.zip'
zip_ref = zipfile.ZipFile(zip_path, 'r')
zip_ref.extractall('netflix/')
zip_ref.shut()
netflix = '/content material/netflix/n_movies.csv'

Verify Dataset

df.isnull().sum()

Karena terdapat banyak lacking worth pada knowledge yaitu pada kolom yr sebanyak 527, kolom certificates sebanyak 3453, kolom period sebanyak 2036, kolom style = 73, kolom ranking 1173 dan kolom votes= 1173, maka dari itu kita akan membersihkannya.

df.dropna(inplace=True)

Sekarang, knowledge yang kita miliki berjumlah 5754 baris.

Cek Nilai Unik Setiap Kolom

1. Kolom ‘title’

df.title.distinctive()

2. Kolom ‘yr’

df.yr.distinctive()

Pada kolom yr, terlihat knowledge tanggal yang bervariasi dengan beberapa pola diantarany :

• (YYYY): Hanya tahun.
• (YYYY– ): Tahun mulai hingga sekarang.
• (YYYY–YYYY): Tahun mulai hingga tahun berakhir.
• (II) (YYYY): Tahun dengan penanda tambahan (II).
• (YYYY–2022): Tahun mulai hingga 2022

maka dari itu, kita akan melakukan perbaikan.

def clean_year(year_str):
"""Membersihkan dan mengekstrak tahun dari string."""
# Menghapus tanda kurung dan spasi ekstra
year_str = year_str.strip('()').strip()
# Pola untuk mencocokkan tahun
match = re.search(r'(d{4})', year_str)
if match:
return match.group(1)  # Mengembalikan tahun jika ditemukan
else:
return None  # Mengembalikan None jika tidak ditemukan
# Terapkan fungsi clean_year ke kolom 'yr'
df['year'] = df['year'].apply(clean_year)
# Ubah kolom 'yr' menjadi tipe knowledge datetime
df['year'] = pd.to_datetime(df['year'], format='%Y', errors='coerce')

Berikut hasilnya:

3. kolom ‘certificates’

df.certificates.distinctive()

4. kolom ‘period’

df.period.distinctive()

Pada kolom durasi, terlihat pola yang tidak rapi dan tipe datanya masih string, maka dari itu kita akan lakukan perbaikan.

def clean_duration(duration_str):
"""Membersihkan dan mengekstrak durasi dalam menit dari string."""
match = re.search(r'(d+)s*min', duration_str)
if match:
return int(match.group(1))
else:
return None  # Mengembalikan None jika tidak ditemukan
# Terapkan fungsi clean_duration ke kolom 'period'
df['duration'] = df['duration'].apply(clean_duration)

berikut outputnya:

5. kolom ‘style’

df.style.value_counts()

6. kolom ‘ranking’

df.ranking.distinctive()

7. kolom ‘description’

df.description.distinctive()

8. Kolom ‘stars’

df.stars.distinctive()

9. Kolom ‘votes’

df.votes.distinctive()

Eksplor Information Kategorikal Fitur

objects = ['title','certificate', 'genre', 'description', 'stars']
category_df = df[objects]
category_df.describe()

Eksplor Information Numerikal Fitur

#For Numerical Column
numerical = [col for col in df.columns if df[col].dtype in ['int', 'float64']]
for col in numerical:
print(f'nDescriptive statistics for {col}:')
print(f'Imply: {df[col].imply()}')
print(f'Median: {df[col].median()}')
print(f'Mode: {df[col].mode().iloc[0]}')
print(f'Commonplace Deviation: {df[col].std()}')
print(f'Min: {df[col].min()}')
print(f'Max: {df[col].max()}')
print(f'twenty fifth Percentile: {df[col].quantile(0.25)}')
print(f'fiftieth Percentile: {df[col].quantile(0.50)}')
print(f'seventy fifth Percentile: {df[col].quantile(0.75)}')

Information Preparation

Karena kita akan membuat sistem rekomendasi berdasarkan style dan ranking movie, kita akan melihat kembali nilau unik pada kolom goal.

1. Melihat nilai unik pada kolom ‘style’

df['genre'] = df['genre'].apply(lambda x: ', '.be a part of(x) if isinstance(x, listing) else x)
unique_genres = df['genre'].distinctive()
print(unique_genres)

2. Konversi Information dengan tolist()

Selanjutnya, kita kan mengonversi knowledge yang akan menjadi fitur utama, yaitu kolom style, title, dan kolom ranking.

# Convert a Pandas Sequence to an inventory:
title_list = df['title'].tolist()
# Convert a selected column with a number of values (like 'style') to an inventory of lists:
genre_lists = df['genre'].apply(lambda x: x.cut up(', ') if isinstance(x, str) else x).tolist()
stars_list = df['rating'].tolist()
array = np.array([1, 2, 3])
list_from_array = array.tolist()
print(len(title_list))
print(len(genre_lists))
print(len(stars_list))

3. Membuat Dictionary Pada Information

movie_dict = {}
for i in vary(len(title_list)):
movie_id = i
movie_dict[movie_id] = {
'title': title_list[i],
'style': genre_lists[i],
'ranking': stars_list[i]
}
movie_dict

Tahap berikutnya, kita akan membuat dataframe baru berdasarkan dictionary knowledge:

movie_df = pd.DataFrame.from_dict(movie_dict, orient='index')
movie_df.head()

Melakukan TF-IDF

TF-IDF (Time period Frequency-Inverse Doc Frequency) adalah tehnik untuk mengukut seberapa sering sebuah kata muncul pada knowledge.

• TF-IDF Vectorization: untuk mengubah teks pada kolom ‘style’ menjadi representatik numerik berbasis bobot. Pada tahap ini, aku menggabungkan teks pada kolom ‘style’ menjadi string untuk setiap movie dan menginisialisasi TfidfVectorizer dari sklearnkemudian melakukan transformasi teks style menjadi matriks TF-IDF.

from sklearn.feature_extraction.textual content import TfidfVectorizer
# Inisialisasi TfidfVectorizer
tf = TfidfVectorizer()
# Ubah listing style menjadi string
knowledge['genre_str'] = knowledge['genre'].apply(lambda x: ' '.be a part of(x))
# Melakukan perhitungan idf pada knowledge style yang sudah diubah menjadi string
tf.match(knowledge['genre_str'])
# Mapping array dari fitur index integer ke fitur nama
tf.get_feature_names_out()

pd.DataFrame(
tfidf_matrix.todense(),
columns=tf.get_feature_names_out(),
index=knowledge.title
).pattern(5, axis=1).pattern(10, axis=0)

Cosine Similarity

Cosine similarity adalah tahapan untuk mengidentifikasi dokumen yang memiliki pola serupa dalam analisis teks menggunakan library sklearn.

Untuk itu, kita akan menghitung cosine similarity pada matriks TF-IDF untuk sistem content-based filtering ini dengan tujuan: untuk menemukan merchandise yang mirip berdasarkan konten.

from sklearn.metrics.pairwise import cosine_similarity
# Menghitung cosine similarity pada matrix tf-idf
cosine_sim = cosine_similarity(tfidf_matrix)
cosine_sim

Konfersi ke dataframe baru untuk proses pencarian

Tahap berikutnya, mengatur dan memvisualisasikan knowledge similarity untuk analisis lebih lanjut dalam sistem content-based filtering.

cosine_sim_df = pd.DataFrame(cosine_sim, index=knowledge['title'], columns=knowledge['title'])
print('Form:', cosine_sim_df.form)
# Melihat similarity matrix pada setiap judul
cosine_sim_df.pattern(10, axis=1).pattern(3, axis=0)

Mannequin Growth dengan Content material-Based mostly Filtering

Tahapan yang dilakukan:

• Cosine Similarity: Menghitung skor kesamaan antar movie menggunakan Cosine Similarity pada matriks TF-IDF dan melihat nilai kesamaan yang berkisar dari 0 (tidak mirip) hingga 1 (identik).
• Rekomendasi Prime-N: Berdasarkan skor kesamaan, sistem menghasilkan daftar movie yang paling mirip dengan movie pilihan pengguna.

def movie_recommendations(movie_title, similarity_data=cosine_sim_df, objects=knowledge[['title', 'genre', 'rating']], okay=10):
# Mengambil knowledge dengan menggunakan argpartition untuk melakukan partisi secara tidak lengkap
index = similarity_data.loc[:,movie_title].to_numpy().argpartition(
vary(-1, -k, -1))
# Mengambil knowledge dengan similarity terbesar dari index yang sudah dipartisi
closest = similarity_data.columns[index[-1:-(k+2):-1]]
# Drop movie_title agar judul yang dicari tidak direkomendasikan
closest = closest.drop(movie_title, errors='ignore')
return pd.DataFrame(closest).merge(objects).head(okay)

Take a look at Prediksi

Disini saya akan mencoba melakukan prediksi hasil rekomendasi yang telah dibuat, dengan memilih judul “Legally Excessive”.

movie_recommendations("Legally Excessive", okay=10)

Dari hasil output diatas, mannequin menampilkan 10 rekomendasi movie yang paling mirip berdasarkan cosine similiarity yang telah dibuat.

Dapat dilihat juga, bahwa mannequin memberikan beberapa movie ber-genre “Dokumentary” dengan ranking yang bervariasi.

Perception

Sistem yang dibuat dengan mannequin cosine similarity terbukti sukses merekomendasikan movie yang bergenre sama, dan menunjukkan relevansi tinggi untuk pencarian berbasis ‘style’.

Mannequin ini nggak cuma mudah diterapkan, tapi juga komputasinya efisien, jadi cocok untuk platform dengan skala besar kayak Netflix.