Sistem rekomendasi telah menjadi bagian tak terpisahkan dari kehidupan digital kita. Mulai dari platform streaming film yang menyarankan tontonan berikutnya, hingga toko online yang menawarkan produk relevan, semuanya memanfaatkan kekuatan sistem rekomendasi. Artikel ini akan memandu Anda, langkah demi langkah, dalam membangun sistem rekomendasi film sederhana menggunakan metode collaborative filtering dengan bahasa pemrograman Python.
Apa itu Sistem Rekomendasi dan Collaborative Filtering?
Sistem rekomendasi adalah sistem yang memprediksi preferensi pengguna terhadap suatu item dan memberikan rekomendasi item yang paling sesuai dengan preferensi tersebut. Bayangkan Anda memiliki seorang teman yang sangat mengenal selera film Anda. Teman tersebut akan merekomendasikan film-film yang dia yakini akan Anda sukai berdasarkan film-film yang pernah Anda tonton dan sukai sebelumnya. Sistem rekomendasi bekerja dengan prinsip serupa, tetapi dalam skala yang jauh lebih besar dan menggunakan algoritma yang canggih.
Collaborative filtering merupakan salah satu algoritma yang populer dalam sistem rekomendasi. Berbeda dengan content-based filtering yang merekomendasikan item berdasarkan kemiripan fitur item, collaborative filtering memanfaatkan data preferensi pengguna lain yang memiliki kesamaan dengan Anda. Metode ini juga berbeda dengan hybrid recommendation system yang menggabungkan collaborative filtering dan content-based filtering.
Baca juga: Personalisasi Pengalaman Menonton Film dengan AI: Solusi Efisien
Collaborative filtering menjadi penting karena mampu memberikan rekomendasi yang personal dan seringkali tidak terduga, namun tetap relevan. Contoh nyata penggunaan collaborative filtering adalah rekomendasi film di Netflix atau rekomendasi produk di Amazon. Sistem ini menganalisis pola tontonan atau pembelian pengguna lain dan mencocokkannya dengan pola Anda untuk memberikan rekomendasi yang paling mungkin Anda sukai.
Baca juga: AI dalam Personalisasi Rekomendasi Produk E-commerce Tingkatkan Konversi
Kelebihan Collaborative Filtering adalah kemampuannya memberikan rekomendasi yang dipersonalisasi dan seringkali mengejutkan, namun tetap relevan. Ini didasarkan pada asumsi bahwa jika pengguna A dan B memiliki kesamaan preferensi di masa lalu, mereka cenderung memiliki kesamaan preferensi di masa depan.
Namun, Collaborative Filtering juga memiliki kekurangan. Salah satunya adalah cold start problem, yaitu kesulitan memberikan rekomendasi kepada pengguna baru yang belum memiliki riwayat preferensi, atau untuk item baru yang belum memiliki rating. Selain itu, metode ini kurang efektif jika data preferensi (seperti rating film) sangat sparse (jarang).
Persiapan Data Dataset dan Praproses
Memilih Dataset
Untuk panduan ini, kita akan menggunakan dataset MovieLens, dataset klasik dan banyak digunakan dalam pengembangan sistem rekomendasi. Dataset ini berisi rating film dari pengguna, beserta informasi tentang film dan pengguna itu sendiri. Anda bisa mengunduh dataset MovieLens di https://grouplens.org/datasets/movielens/. Pilih versi yang lebih kecil (misalnya, ml-100k atau ml-1m) untuk kemudahan dan kecepatan pemrosesan. Dataset ml-100k berisi 100.000 rating, sedangkan ml-1m berisi 1 juta rating.
Memuat Data dengan Pandas
Setelah mengunduh dan mengekstrak dataset, kita akan memuat data ke dalam Pandas DataFrame. Pandas adalah library Python yang sangat berguna untuk manipulasi dan analisis data.
import pandas as pd
# Memuat data rating
ratings = pd.read_csv('ml-100k/u.data', sep='\t', names=['user_id', 'item_id', 'rating', 'timestamp'])
# Memuat data film
movies = pd.read_csv('ml-100k/u.item', sep='|', encoding='latin-1', names=['item_id', 'title', 'release_date', 'video_release_date', 'IMDb_URL', 'unknown', 'Action', 'Adventure', 'Animation', 'Childrens', 'Comedy', 'Crime', 'Documentary', 'Drama', 'Fantasy', 'Film-Noir', 'Horror', 'Musical', 'Mystery', 'Romance', 'Sci-Fi', 'Thriller', 'War', 'Western'])
# Menampilkan 5 baris pertama data rating
print("Data Rating:")
print(ratings.head())
# Menampilkan 5 baris pertama data film
print("\nData Film:")
print(movies.head())
Kode di atas memuat dua file utama dari dataset MovieLens `u.data` (berisi rating) dan `u.item` (berisi informasi film). Kita menggunakan `pd.read_csv()` untuk membaca file CSV dan memberikan nama kolom yang sesuai. Kemudian, `ratings.head()` dan `movies.head()` menampilkan beberapa baris pertama dari masing-masing DataFrame untuk memberikan gambaran tentang struktur data.
Praproses Data
Praproses data adalah langkah penting untuk memastikan data siap digunakan oleh algoritma. Dalam kasus ini, kita akan:
- Menggabungkan Data: Menggabungkan data rating dan data film berdasarkan `item_id`.
- Membuat Matriks Utilitas: Membuat matriks utilitas (sering juga disebut user-item matrix), yaitu matriks yang merepresentasikan rating yang diberikan oleh setiap pengguna untuk setiap film.
# Menggabungkan data rating dan film
movie_ratings = pd.merge(ratings, movies, on='item_id')
# Membuat matriks utilitas
user_movie_matrix = movie_ratings.pivot_table(index='user_id', columns='title', values='rating')
# Menampilkan sebagian matriks utilitas
print("\nMatriks Utilitas (User-Movie Matrix):")
print(user_movie_matrix.iloc[:5,:5]) # Menampilkan 5 baris dan 5 kolom pertama
Kode di atas menggabungkan DataFrame `ratings` dan `movies` menjadi `movie_ratings`. Kemudian, kita menggunakan `pivot_table()` untuk membuat matriks utilitas. Baris matriks ini merepresentasikan pengguna, kolom merepresentasikan film, dan nilai selnya adalah rating yang diberikan pengguna untuk film tersebut. Jika seorang pengguna belum memberikan rating untuk sebuah film, nilai selnya akan menjadi `NaN` (Not a Number), yang merepresentasikan missing value.
Perhatikan bahwa matriks utilitas ini cenderung sparse (jarang), yang berarti sebagian besar selnya kosong. Hal ini wajar karena pengguna biasanya hanya memberikan rating untuk sebagian kecil dari seluruh film yang tersedia.
Implementasi Collaborative Filtering dengan Python
Memilih Algoritma
Sekarang kita akan mengimplementasikan dua jenis collaborative filtering: user-based dan item-based.
- User-based Collaborative Filtering: Mencari pengguna lain yang memiliki selera serupa dengan pengguna target, lalu merekomendasikan film yang disukai oleh pengguna-pengguna serupa tersebut.
- Item-based Collaborative Filtering: Mencari film yang mirip dengan film yang disukai oleh pengguna target, lalu merekomendasikan film-film serupa tersebut.
Menghitung Kesamaan (Similarity)
Untuk menghitung kesamaan, kita akan menggunakan cosine similarity. Cosine similarity mengukur sudut antara dua vektor. Dalam konteks ini, vektor merepresentasikan rating pengguna (user-based) atau rating film (item-based). Semakin kecil sudutnya (semakin dekat ke 1), semakin mirip kedua vektor tersebut.
User-Based
from sklearn.metrics.pairwise import cosine_similarity
import numpy as np
# Menghilangkan missing values (NaN) dengan menggantinya dengan 0
user_movie_matrix = user_movie_matrix.fillna(0)
# Menghitung cosine similarity antar pengguna
user_similarity = cosine_similarity(user_movie_matrix)
# Membuat DataFrame dari matriks similarity
user_similarity_df = pd.DataFrame(user_similarity, index=user_movie_matrix.index, columns=user_movie_matrix.index)
print("\nUser Similarity Matrix:")
print(user_similarity_df.iloc[:5,:5])
Kode di atas pertama-tama mengganti nilai `NaN` dalam matriks utilitas dengan 0. Ini diperlukan karena `cosine_similarity` tidak dapat menangani missing values. Kemudian, `cosine_similarity(user_movie_matrix)` menghitung cosine similarity antara semua pasangan pengguna. Hasilnya adalah matriks similarity di mana setiap sel (i, j) merepresentasikan kesamaan antara pengguna i dan pengguna j.
Item-Based
# Menghitung cosine similarity antar film (transpose matriks utilitas)
item_similarity = cosine_similarity(user_movie_matrix.T)
# Membuat DataFrame dari matriks similarity
item_similarity_df = pd.DataFrame(item_similarity, index=user_movie_matrix.columns, columns=user_movie_matrix.columns)
print("\nItem Similarity Matrix:")
print(item_similarity_df.iloc[:5,:5])
Untuk item-based, kita melakukan hal yang sama, tetapi pada versi transpose dari matriks utilitas. Dengan mentranspos matriks, baris menjadi film dan kolom menjadi pengguna, sehingga kita dapat menghitung kesamaan antar film.
Membuat Prediksi Rating
User-Based
def predict_rating_user_based(user_id, item_id, similarity_matrix, user_movie_matrix, k=20):
"""
Memprediksi rating yang akan diberikan oleh seorang pengguna ke sebuah film (user-based).
Args:
user_id (int): ID pengguna.
item_id (str): Judul film.
similarity_matrix (DataFrame): Matriks similarity antar pengguna.
user_movie_matrix (DataFrame): Matriks utilitas.
k (int): Jumlah pengguna terdekat yang dipertimbangkan.
Returns:
float: Prediksi rating.
"""
# 1. Ambil similarity semua pengguna dengan pengguna target
user_similarities = similarity_matrix.loc[user_id]
# 2. Urutkan similarity dari yang terbesar ke terkecil
user_similarities = user_similarities.sort_values(ascending=False)
# 3. Ambil k pengguna yang paling mirip (tetangga terdekat)
top_k_users = user_similarities.iloc[1:k+1].index # index 0 adalah diri sendiri
# 4. Ambil rating yang diberikan oleh k pengguna tersebut ke film target
top_k_ratings = user_movie_matrix.loc[top_k_users, item_id]
# 5. Ambil similarity dari k pengguna tersebut
top_k_similarities = user_similarities.iloc[1:k+1].values
# 6. Hitung rata-rata tertimbang dari rating, menggunakan similarity sebagai bobot
# Jika tidak ada tetangga yang memberikan rating, kembalikan rata-rata rating pengguna
if np.sum(top_k_similarities) == 0:
return user_movie_matrix.loc[user_id].mean()
else:
predicted_rating = np.dot(top_k_ratings, top_k_similarities) / np.sum(top_k_similarities)
return predicted_rating
# Contoh penggunaan
user_id = 1
item_id = 'Toy Story (1995)'
predicted_rating = predict_rating_user_based(user_id, item_id, user_similarity_df, user_movie_matrix)
print(f"\nPrediksi rating user {user_id} untuk film '{item_id}': {predicted_rating:.2f}")
Fungsi `predict_rating_user_based` memprediksi rating yang akan diberikan oleh seorang pengguna untuk sebuah film berdasarkan rating dari k pengguna yang paling mirip. Fungsi ini menghitung rata-rata tertimbang dari rating yang diberikan oleh k pengguna tersebut, dengan bobot berdasarkan nilai kesamaan (similarity).
Item-Based
def predict_rating_item_based(user_id, item_id, similarity_matrix, user_movie_matrix, k=20):
"""
Memprediksi rating yang akan diberikan oleh seorang pengguna ke sebuah film (item-based).
"""
# 1. Cek apakah item_id ada di dalam daftar kolom user_movie_matrix
if item_id not in user_movie_matrix.columns:
return user_movie_matrix.loc[user_id].mean() # Atau strategi lain untuk menangani item baru
# 2. Ambil similarity semua item dengan item target
item_similarities = similarity_matrix.loc[item_id]
# 3. Urutkan dari terbesar ke terkecil
item_similarities = item_similarities.sort_values(ascending=False)
# 4. Ambil k item yang paling mirip (tidak termasuk item itu sendiri)
top_k_items = item_similarities.iloc[1:k+1].index
# 5. Ambil rating yang diberikan oleh pengguna target ke k item tersebut
top_k_ratings = user_movie_matrix.loc[user_id, top_k_items]
# 6. Ambil similarity dari k item tersebut
top_k_similarities = item_similarities.iloc[1:k+1].values
# 7. Hitung rata-rata tertimbang dari rating
if np.sum(top_k_similarities) == 0:
return user_movie_matrix.loc[user_id].mean()
else:
predicted_rating = np.dot(top_k_ratings, top_k_similarities) / np.sum(top_k_similarities)
return predicted_rating
# Contoh penggunaan
user_id = 1
item_id = 'Toy Story (1995)'
predicted_rating = predict_rating_item_based(user_id, item_id, item_similarity_df, user_movie_matrix)
print(f"Prediksi rating user {user_id} untuk film '{item_id}': {predicted_rating:.2f}")
Logikanya sangat mirip dengan user-based, tetapi sekarang kita menghitung rata-rata tertimbang dari rating yang diberikan oleh seorang pengguna ke k film yang paling mirip dengan film target.
Membuat Rekomendasi Top-N
def get_top_n_recommendations(user_id, similarity_matrix, user_movie_matrix, n=10, prediction_function=predict_rating_user_based):
"""
Memberikan rekomendasi top-N film untuk seorang pengguna.
Args:
user_id (int): ID pengguna.
similarity_matrix (DataFrame): Matriks similarity (antar pengguna atau antar item).
user_movie_matrix (DataFrame): Matriks utilitas.
n (int): Jumlah rekomendasi yang diinginkan.
prediction_function (callable): Fungsi untuk memprediksi rating (user-based atau item-based).
Returns:
list: List judul film yang direkomendasikan.
"""
# 1. Ambil semua film yang belum diberi rating oleh pengguna
unrated_movies = user_movie_matrix.loc[user_id][user_movie_matrix.loc[user_id].isnull() | (user_movie_matrix.loc[user_id] == 0)].index
# 2. Prediksi rating untuk setiap film yang belum diberi rating
predicted_ratings = []
for movie in unrated_movies:
predicted_rating = prediction_function(user_id, movie, similarity_matrix, user_movie_matrix)
predicted_ratings.append(predicted_rating)
# 3. Buat DataFrame dari hasil prediksi
predictions_df = pd.DataFrame({'movie': unrated_movies, 'predicted_rating': predicted_ratings})
# 4. Urutkan film berdasarkan prediksi rating
predictions_df = predictions_df.sort_values(by='predicted_rating', ascending=False)
# 5. Ambil N film dengan prediksi rating tertinggi
top_n_movies = predictions_df['movie'].head(n).tolist()
return top_n_movies
# Contoh penggunaan (user-based)
user_id = 1
top_n = 10
recommendations = get_top_n_recommendations(user_id, user_similarity_df, user_movie_matrix, n=top_n, prediction_function=predict_rating_user_based)
print(f"\nTop {top_n} rekomendasi untuk user {user_id} (user-based):")
print(recommendations)
# Contoh penggunaan (item-based)
recommendations = get_top_n_recommendations(user_id, item_similarity_df, user_movie_matrix, n=top_n, prediction_function=predict_rating_item_based)
print(f"\nTop {top_n} rekomendasi untuk user {user_id} (item-based):")
print(recommendations)
Fungsi `get_top_n_recommendations` memberikan n rekomendasi film teratas untuk seorang pengguna. Fungsi ini pertama-tama mencari film yang belum diberi rating oleh pengguna, kemudian memprediksi rating untuk film-film tersebut menggunakan fungsi prediksi yang diberikan (`predict_rating_user_based` atau `predict_rating_item_based`), dan akhirnya mengurutkan film berdasarkan prediksi rating tertinggi.
Evaluasi Model
Untuk mengevaluasi performa sistem rekomendasi, kita akan menggunakan metrik RMSE (Root Mean Squared Error) dan MAE (Mean Absolute Error).
from sklearn.metrics import mean_squared_error, mean_absolute_error
from math import sqrt
def evaluate_model(similarity_matrix, user_movie_matrix, prediction_function=predict_rating_user_based):
"""
Mengevaluasi model collaborative filtering menggunakan RMSE dan MAE.
Args:
similarity_matrix (DataFrame): Matriks similarity (antar pengguna atau antar item).
user_movie_matrix (DataFrame): Matriks utilitas.
prediction_function (callable): Fungsi untuk memprediksi rating (user-based atau item-based).
Returns:
tuple: (RMSE, MAE).
"""
actual_ratings = []
predicted_ratings = []
# Iterasi melalui setiap pengguna dan film yang memiliki rating
for user_id in user_movie_matrix.index:
for item_id in user_movie_matrix.columns:
if user_movie_matrix.loc[user_id, item_id] != 0: # Hanya hitung untuk rating yang ada
actual_ratings.append(user_movie_matrix.loc[user_id, item_id])
predicted_rating = prediction_function(user_id, item_id, similarity_matrix, user_movie_matrix)
predicted_ratings.append(predicted_rating)
# Menghitung RMSE
rmse = sqrt(mean_squared_error(actual_ratings, predicted_ratings))
# Menghitung MAE
mae = mean_absolute_error(actual_ratings, predicted_ratings)
return rmse, mae
# Evaluasi model user-based
rmse_user_based, mae_user_based = evaluate_model(user_similarity_df, user_movie_matrix, predict_rating_user_based)
print(f"\nUser-based Collaborative Filtering:")
print(f"RMSE: {rmse_user_based:.2f}")
print(f"MAE: {mae_user_based:.2f}")
# Evaluasi model item-based
rmse_item_based, mae_item_based = evaluate_model(item_similarity_df, user_movie_matrix, predict_rating_item_based)
print(f"\nItem-based Collaborative Filtering:")
print(f"RMSE: {rmse_item_based:.2f}")
print(f"MAE: {mae_item_based:.2f}")
Fungsi `evaluate_model` menghitung RMSE dan MAE dengan membandingkan rating aktual dengan rating prediksi untuk semua pasangan pengguna-film yang memiliki rating. RMSE dan MAE mengukur seberapa jauh prediksi dari nilai sebenarnya. Semakin kecil nilai RMSE dan MAE, semakin baik performa model.
Kesimpulan
Kita telah berhasil membangun sistem rekomendasi film sederhana menggunakan metode collaborative filtering, baik user-based maupun item-based. Kita juga telah mengevaluasi performa model menggunakan metrik RMSE dan MAE. Hasil evaluasi menunjukkan seberapa baik model kita dapat memprediksi rating film.
Penting untuk diingat bahwa collaborative filtering memiliki keterbatasan, seperti cold start problem dan masalah sparsity. Performa model juga sangat bergantung pada kualitas dan kuantitas data. Dengan pengembangan lebih lanjut, sistem rekomendasi ini dapat ditingkatkan dengan berbagai cara, seperti menggabungkan dengan metode lain (misalnya, content-based filtering), menggunakan algoritma yang lebih canggih, atau memanfaatkan teknik pemrosesan bahasa alami (NLP) untuk menganalisis sinopsis film dan ulasan pengguna.
Dengan Kirim.ai, Anda tidak perlu repot membangun sistem rekomendasi dari awal. Platform kami menyediakan tools AI canggih dan AI Agent untuk optimasi SEO yang dapat diintegrasikan dengan mudah ke dalam sistem Anda. Pelajari lebih lanjut tentang bagaimana Kirim.ai dapat membantu Anda membangun solusi digital berbasis AI yang komprehensif, termasuk sistem rekomendasi yang lebih canggih dan personal.
Tanggapan (0 )