Hiburan dapat dipandang sebagai kebutuhan yang berkembang dalam masyarakat manusia. Pada masa lalu, hiburan dianggap bukan sebagai kebutuhan primer yang harus dipenuhi. Namun, seiring berjalannya waktu, persepsi ini berubah dan hiburan mulai dianggap sebagai elemen penting dalam kehidupan setiap individu. Terutama sejak memasuki abad ke-21, di mana terdapat kemajuan signifikan dalam industri hiburan, khususnya di bidang pertelevisian dan perfilman. Perubahan ini dimulai dari era televisi hitam putih menuju era televisi berwarna, bahkan kini muncul konsep televisi hologram serta layanan streaming yang disesuaikan dengan preferensi pengguna. Peningkatan penggunaan layanan streaming saat ini semakin pesat, dan tren ini semakin mendalami dampaknya selama masa pandemi yang berkepanjangan.
Mengapa Masalah Ini Harus Diselesaikan?
- Peningkatan Kualitas Rekomendasi Konten
Dengan memahami preferensi pengguna melalui data historis dan perilaku menonton, sistem dapat memberikan rekomendasi yang lebih relevan dan personal, sehingga meningkatkan kepuasan pengguna.
- Efisiensi dalam Produksi dan Distribusi
Analisis tren konsumsi hiburan membantu produsen konten dalam merancang strategi produksi dan distribusi yang tepat sasaran, sehingga dapat menghemat biaya dan waktu.
- Pengambilan Keputusan Berbasis Data dalam Industri Hiburan
Prediksi minat penonton melalui machine learning memungkinkan penyedia layanan streaming untuk membuat keputusan strategis dalam pengembangan fitur, kurasi konten, dan pengembangan pasar.
Sistem Rekomendasi adalah aplikasi yang dirancang untuk memberikan saran dalam proses pengambilan keputusan sesuai keinginan pengguna. Untuk meningkatkan user experience dalam pencarian judul film yang sesuai dengan film favorit dan pengguna, program rekomendasi sangat tepat. Jadi dengan menerapkan program rekomendasi user experience akan menjadi jauh lebih baik, karena pengguna akan meminta program untuk memberi mereka sesuatu, bukan mencarinya.
- Bagaimana cara mengolah data secara optimal sehingga dapat digunakan untuk membangun model sistem rekomendasi yang efektif?
- Bagaimana cara menciptakan model machine learning yang mampu merekomendasikan sebuah film yang kemungkinan akan diminati oleh pengguna?
- Melakukan pengolahan data secara efektif agar dapat digunakan dalam pengembangan model sistem rekomendasi yang berkualitas.
- Mengembangkan model machine learning untuk merekomendasikan film yang berpotensi disukai oleh pengguna.
Untuk menyelesaikan permasalahan ini, saya akan menerapkan dua pendekatan algoritma, yaitu Content-Based Filtering dan Collaborative Filtering. Berikut adalah penjelasan masing-masing teknik yang digunakan:
-
Content-Based Filtering merupakan metode yang memberikan rekomendasi berdasarkan kesamaan fitur atau karakteristik dari item yang disukai oleh pengguna. Pendekatan ini mempelajari profil minat pengguna berdasarkan informasi dari film-film yang sebelumnya telah ditonton atau diberi penilaian, seperti genre, sutradara, atau kata kunci tertentu.
-
Collaborative Filtering adalah metode yang menghasilkan rekomendasi berdasarkan pola dan preferensi pengguna lain dalam komunitas. Pendekatan ini tidak bergantung pada atribut atau fitur dari item, melainkan memanfaatkan data historis berupa rating atau interaksi pengguna untuk mengidentifikasi kesamaan selera di antara pengguna.
Pada proyek ini, saya menggunakan MovieLens Dataset yang diambil dari Kaggle. Dataset ini berisi data rating film yang diberikan oleh pengguna, mencakup informasi seperti userId, movieId, title, genres, dan rating. Dataset ini terdiri dari 100.836 rating yang diberikan oleh 610 pengguna terhadap 9.742 film. Data ini sangat cocok digunakan untuk membangun dan mengevaluasi sistem rekomendasi menggunakan pendekatan Content-Based Filtering dan Collaborative Filtering. Anda dapat mengunduh dataset lengkap di: MovieLens Dataset – Kaggle
| Variabel | Keterangan |
|---|---|
| Movie ID | Unique ID from Movie. |
| Title | Title of Movie. |
| Genres | Comma Separated List of Genres for this Movie. |
Info Dataset Movies :
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 9742 entries, 0 to 9741
Data columns (total 3 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 movieId 9742 non-null int64
1 title 9742 non-null object
2 genres 9742 non-null object
dtypes: int64(1), object(2)
memory usage: 228.5+ KB
| Variabel | Missing Value |
|---|---|
| Movie ID | 0 |
| Title | 0 |
| Genres | 0 |
Tidak terdapat Missing Value pada dataset Movies
Jumlah Duplikasi Data Movie : 0
| Variabel | Movie Unique |
|---|---|
| Movie ID | 9742 |
| Title | 9737 |
| Genres | 951 |
Terdapat sebanyak 9742 total Movie ID yang unik, dan 9737 judul film berbeda, dan 951 macam Genre pada dataset ini.
| Variabel | Keterangan |
|---|---|
| User ID | Identify User ID. |
| Movie ID | Unique ID from Movie. |
| Rating | Rating Out of 5 This User Has Assigned. |
| Timestamp | Datetime ratings created. |
Info Dataset Ratings :
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 100836 entries, 0 to 100835
Data columns (total 4 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 userId 100836 non-null int64
1 movieId 100836 non-null int64
2 rating 100836 non-null float64
3 timestamp 100836 non-null int64
dtypes: float64(1), int64(3)
memory usage: 3.1 MB
| Variabel | Missing Value |
|---|---|
| User ID | 0 |
| Movie ID | 0 |
| Rating | 0 |
| Timestamp | 0 |
Tidak terdapat Missing Value pada dataset Ratings
Jumlah Duplikasi Data Rating : 0
| Variabel | Movie Unique |
|---|---|
| User ID | 610 |
| Movie | 9724 |
| Rating | 10 |
| Timestamp | 85043 |
Terdapat sebanyak 610 total User ID yang unik, dan 9724 Movie ID yang berbeda yang telah di rating oleh user, dan 10 data unik pada Rating mengindikasikan rating value (0.5 - 5.0), dan 85043 data unik pada timestamp.
# Menggabungkan dataframe movie dan rating
all_df = pd.merge(ratings_df, movies_df, on='movieId', how='left')
all_df
- Teknis Merge dengan
movieId:Gunakan how='left' pada ratings_df (tabel kiri) agar semua rating tetap terjaga; kolom dari movies_df (kanan) akan terisi jika
movieIdcocok. Jika adamovieIddi rating yang tidak ada di movies (jarang terjadi pada dataset bersih), maka nilai filmnya akan NaN.
Info Dataset Setelah di Merge :
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 100836 entries, 0 to 100835
Data columns (total 5 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 userId 100836 non-null int64
1 movieId 100836 non-null int64
2 rating 100836 non-null int64
3 title 100830 non-null object
4 genres 100830 non-null object
dtypes: int64(3), object(2)
memory usage: 3.8+ MB
Manfaat merge untuk menggabungkan dua tabel yang berbeda, dengan menggunakan merge, kita dapat menggabungkan data dari dua tabel yang berbeda berdasarkan kunci yang sama, dalam hal ini adalah movieId. Dengan demikian, kita dapat memiliki informasi yang lebih lengkap tentang setiap film, seperti judul, genre, dan rating yang diberikan oleh pengguna.
-
Menghubungkan Rating dengan Informasi Film:
Dengan menggabungkan berdasarkan movieId, kita dapat mengetahui bahwa “User X memberi rating Y untuk film berjudul ‘Z’ yang bergenre A, B, …”. Tanpa merge, kita hanya punya angka rating tanpa konteks filmnya.
-
Memperkaya Data Interaksi Pengguna:
Rating (ratings_df) hanya mencerminkan interaksi (angka). Metadata film (movies_df) seperti judul dan genre menyediakan konteks mengapa pengguna menyukai atau tidak menyukai sebuah film. Gabungan ini memudahkan analisis pola preferensi (misalnya, genre apa yang paling disukai).
-
Mendukung Pembuatan Fitur untuk Model Rekomendasi:
- Content-Based Filtering: Butuh genre untuk menyarankan film serupa.
- Collaborative Filtering/Hibrid: Membuat matriks User–Film dengan rating, lalu memperkaya dengan metadata film.
-
Analisis dan Visualisasi Lebih Komprehensif: Setelah merge, kita bisa menjawab pertanyaan seperti:
- Film apa yang paling banyak di-rating pengguna?
- Genre mana yang paling populer?
- Bagaimana distribusi rating suatu film tertentu?
Distribution of Movie Ratings:
- Terlihat bahwa rating 4.0 dan 5.0 adalah yang paling sering diberikan, menunjukkan bias pengguna ke arah rating tinggi.
Top 20 Most Frequent Movie Genres:
- Genre Drama, Comedy, dan Action adalah yang paling umum, menunjukkan preferensi atau ketersediaan lebih besar pada genre ini.
Number of Rating per User:
- Mayoritas pengguna memberikan sedikit rating, sementara hanya sebagian kecil pengguna yang sangat aktif.
Average Rating by Genre:
- Genre seperti Film-Noir, Documentary, dan War cenderung mendapatkan rating rata-rata lebih tinggi.
- Genre populer seperti Action dan Comedy memiliki rating rata-rata yang sedikit lebih rendah, mungkin karena banyaknya variasi kualitas film.
Number of Ratings vs. Average Rating:
- Sebagian besar film memiliki sedikit rating, dan film dengan banyak rating cenderung memiliki rating rata-rata di sekitar 3.0–4.0.
- Ini mengindikasikan bahwa popularitas tidak selalu berarti kualitas yang sangat tinggi atau rendah.
Correlation Heatmap:
- Korelasi antar variabel numerik (terbatas pada rating, userId, movieId, timestamp) relatif lemah, menandakan bahwa tidak ada hubungan linier yang kuat di antara mereka.
Penanganan missing value yang saya lakukan yaitu dengan melakukan drop data. Tetapi karena dataset yang digunakan cukup bersih, missing value hanya terdapat ketika proses penggabungan dataset.
# Menangani Missing Value
movies_df.dropna(axis=0, inplace=True)
ratings_df.dropna(axis=0, inplace=True)
Untuk memudahkan analisis, saya melakukan sorting user ID pada data rating. Ini akan membantu saya untuk memahami perilaku pengguna secara lebih baik. Pengurutan data rating berdasarkan ID Pengguna agar mempermudah dalam melakukan penghapusan data duplikat nantinya.
# Sortir User ID
ratings_df = ratings_df.sort_values('userId').astype('int')
Untuk menghindari penghitungan rating yang tidak tepat, saya melakukan penghapusan data duplikat agar tidak terjadi bias pada data nantinya. Penghapusan data duplikat dilakukan dengan menggunakan ID pengguna dan ID film sebagai kunci. Dengan demikian, saya dapat memastikan bahwa setiap pengguna hanya memiliki satu rating per film.
# Menangani Duplikasi data
movies_df.drop_duplicates(subset=['title'], keep='first', inplace=True)
ratings_df.drop_duplicates(subset=['userId','movieId'], keep='first', inplace=True)
# Membuat Dataframe baru untuk Dataset Clean
df_clean = all_df[~pd.isnull(all_df['genres'])].copy()
df_clean.shape
Output
(100830, 5)
Dataset df_clean adalah hasil copy() dari proses merged all_df dimana dilakukan drop column Timestamp di dataset gabungan serta tanpa nilai null pada column genres.
Dan di dapat sebanyak 100830 baris data dan 5 buah kolom pada dataset df_clean.
- Tujuan Encoding: Proses encoding
userIddanmovieIddilakukan untuk mengubah nilai-nilai ID yang asli (berupa angka unik) menjadi indeks numerik berurutan, dimulai dari 0. - Manfaat Encoding:
- Efisiensi Model: Banyak algoritma machine learning (terutama neural networks) bekerja lebih baik dengan input numerik yang berurutan. Menggunakan indeks berurutan daripada ID asli dapat mengurangi ukuran matriks embedding (pada model embedding) dan mempercepat komputasi.
- Standarisasi Input: Encoding memastikan bahwa setiap pengguna dan film memiliki representasi numerik yang unik dan konsisten yang dapat dengan mudah diproses oleh model.
- Mapping: Dua kamus (dictionary) dibuat untuk setiap ID (
user_to_user_encodeddanmovie_to_movie_encoded) untuk memetakan ID asli ke indeks yang di-encode, dan dua kamus baliknya (user_encoded_to_userdanmovie_encoded_to_movie) untuk memetakan indeks kembali ke ID asli. Mapping ini penting untuk mengembalikan hasil prediksi model (dalam bentuk indeks) ke identitas pengguna atau film yang sebenarnya. - Jumlah Data Unik: Output menunjukkan bahwa ada 610
userIdunik dan 9724movieIdunik dalam datasetdf_clean. Proses encoding ini akan menciptakan indeks dari 0 hingga 609 untuk pengguna dan dari 0 hingga 9723 untuk film.
['action' 'adventure' 'animation' 'children' 'comedy' 'crime'
'documentary' 'drama' 'fantasy' 'fi' 'film' 'genres' 'horror' 'imax'
'listed' 'musical' 'mystery' 'noir' 'romance' 'sci' 'thriller' 'war'
'western']
(9737, 23)
Saya memulai proses pemodelan Content-Based Filtering dengan menerapkan TF-IDF Vectorizer untuk mengekstraksi representasi fitur penting dari setiap genre film. Saya menggunakan fungsi TfidfVectorizer() dari library scikit-learn, lalu melakukan fit dan transform terhadap kumpulan data genre. Hasilnya adalah matriks berdimensi (9737, 23), di mana 9737 menunjukkan jumlah film dalam dataset dan 23 mewakili jumlah fitur genre unik yang berhasil diidentifikasi.
# Melakukan Mapping pada ID Pengguna dan ID Film
df_clean['user'] = df_clean['userId'].map(user_to_user_encoded)
df_clean['movie'] = df_clean['movieId'].map(movie_to_movie_encoded)
# Ubah Rating value ke float untuk modeling
df_clean['rating'] = df_clean['rating'].values.astype(np.float32)
# Standarisasi MinMaxScaler
min_rating = min(df_clean['rating'])
max_rating = max(df_clean['rating'])
df = df_clean.sample(frac=1, random_state=42)
x = df[['user', 'movie']].values
y = df['rating'].apply(lambda x: (x - min_rating) / (max_rating - min_rating)).values
train_indices = int(0.8 * df.shape[0])
x_train, x_val, y_train, y_val = (
x[:train_indices],
x[train_indices:],
y[:train_indices],
y[train_indices:]
)
Saya memulai pemodelan Collaborative Filtering dengan memetakan nilai-nilai yang telah di-encode ke dalam struktur data yang akan digunakan. Saya juga memastikan nilai rating diubah menjadi tipe data float agar kompatibel dengan operasi numerik selanjutnya. Dan melakukan standarisasi dengan MinMax pada rating untuk mengurangi pengaruh skala nilai rating. Lanjut melakukan pengacakan dataset karena dataset masih dalam sortir user id. Dan saya membagi data menjadi 80% untuk training dan 20% untuk validasi.
Setelah memperoleh matriks TF-IDF, saya menghitung derajat kemiripan antar-film dengan menggunakan cosine similarity melalui fungsi cosine_similarity() dari scikit-learn. Rumus yang saya gunakan untuk menghitung cosine similarity antara dua vektor fitur 𝑢 dan 𝑣 adalah sebagai berikut:
Saya melanjutkan proses dengan memanfaatkan fungsi argpartition() untuk mengekstrak k nilai tertinggi dari matriks similarity. Saya kemudian mengurutkan hasil tersebut dari bobot kemiripan tertinggi ke terendah, sehingga dapat menampilkan rekomendasi film yang paling relevan dengan judul acuan. Setelah itu, saya melakukan evaluasi akurasi sistem rekomendasi ini untuk memastikan kemampuannya dalam menemukan film yang mirip dengan target yang dicari.
Pendekatan Content-Based Filtering diimplementasikan dalam fungsi movie_recommendation(). Sistem ini merekomendasikan film berdasarkan kemiripan konten antar item, seperti genre atau deskripsi film. Fungsi ini bekerja dengan menerima input berupa judul film dan mengakses matriks kemiripan yang telah dihitung sebelumnya menggunakan metode cosine similarity terhadap representasi TF-IDF dari data genre film. Proses dimulai dengan mengambil nilai kemiripan antara film input dengan seluruh film lain, lalu mengurutkan nilai tersebut untuk menemukan k film yang paling mirip. Film dengan kemiripan tertinggi akan diambil sebagai rekomendasi, kemudian digabungkan dengan metadata seperti judul dan genre sebelum dikembalikan.
-
Kelebihan
- Semakin banyak informasi genre dan preferensi yang saya masukkan ke dalam sistem, semakin tinggi akurasi rekomendasi yang dihasilkan.
- Rekomendasi bersifat intuitif karena didasarkan langsung pada kesamaan fitur antar-item.
-
Kekurangan
- Sistem hanya efektif untuk domain dengan fitur yang terstruktur (misalnya film, buku, musik) dan tidak dapat diaplikasikan pada data tanpa metadata yang kaya.
- Saya tidak dapat menentukan profil pengguna baru (“cold start user”) karena belum ada riwayat interaksi untuk dibandingkan.
Contoh Rekomendasi menggunakan Content-Based Filtering
movie_recomend = movie_recommendation('Kung Fu Panda: Secrets of the Masters (2011)')
movie_recomend
Output :
Setelah praproses, saya kemudian membuat embedding untuk setiap pengguna dan film, yaitu vektor berdimensi tetap yang merepresentasikan profil pengguna dan karakteristik film. Untuk memprediksi kecocokan, saya mengalikan (dot product) vektor embedding pengguna dengan vektor embedding film, kemudian menambahkan bias per pengguna dan bias per film. Hasil prediksi ini saya transformasi ke rentang 0–1 menggunakan fungsi sigmoid.
Sementara itu, pendekatan Collaborative Filtering diwujudkan dalam bentuk kelas RecommenderNet, yang merupakan model neural network berbasis embedding. Pendekatan ini tidak melihat isi film, melainkan mempelajari pola interaksi antara pengguna dan film (berdasarkan rating). Model RecommenderNet menggunakan dua buah embedding layer: satu untuk merepresentasikan pengguna dan satu lagi untuk film. Kedua vektor ini kemudian dikombinasikan melalui operasi dot product untuk menghasilkan skor prediksi seberapa besar kemungkinan seorang pengguna menyukai film tertentu. Model ini juga menambahkan bias untuk masing-masing pengguna dan film guna meningkatkan akurasi prediksi. Hasil akhir dari model ini diaktivasi menggunakan fungsi sigmoid agar skor berada dalam rentang 0 hingga 1.
Untuk menghasilkan rekomendasi, saya mengambil sampel pengguna secara acak dan menyusun variabel movies_not_watched, yaitu daftar film yang belum pernah diberi rating oleh pengguna tersebut. Kemudian saya memprediksi skor untuk setiap film dalam daftar itu dan memilih film-film dengan skor tertinggi sebagai rekomendasi.
-
Kelebihan:
- Tidak memerlukan fitur konten film.
- Masih dapat bekerja walau data item tidak lengkap.
- Skalabilitas dan kecepatan yang baik untuk dataset besar.
- Tetap memberi rekomendasi meski konten sulit dianalisis langsung.
-
Kekurangan:
- Membutuhkan data rating, sehingga film baru tanpa rating tidak akan muncul sebagai rekomendasi.
Contoh Rekomendasi menggunakan Collaborative Filtering
# Ambil sample user id
sample_user_id = df['user'].sample(1).iloc[0]
# Movie yang di tonton oleh user
movies_watched_by_user = df[df['user'] == sample_user_id]
movies_watched_by_user = movies_watched_by_user.sort_values(['rating'], ascending=False)
# Movie yang tidak di tonton oleh user
movies_not_watched = movies_df[~movies_df['movieId'].isin(movies_watched_by_user['movieId'].values)]['movieId']
movies_not_watched = list (
set(movies_not_watched).intersection(set(movie_to_movie_encoded.keys()))
)
movies_not_watched = [[movie_to_movie_encoded.get(x)] for x in movies_not_watched]
user_encoder = user_to_user_encoded.get(sample_user_id)
user_movie_array = np.hstack(
([[user_encoder]] * len(movies_not_watched), movies_not_watched)
)
Output :
Untuk mengevaluasi model Content-Based Filtering, saya menggunakan metrik yang umum digunakan dalam sistem rekomendasi, yaitu Precision@K, Recall@K.
precision, recall = precision_recall_at_k(model, x_val, y_val, k=10, threshold=0.5)
Output :
Precision@10: 0.9079
Recall@10: 0.2330
Insight dari hasil evaluasi:
- Precision@10 yang tinggi (0.9079) menunjukkan bahwa dari 10 rekomendasi teratas yang diberikan oleh model, sekitar 90.79% di antaranya adalah film yang relevan atau disukai oleh pengguna (berdasarkan threshold rating 0.5). Ini berarti ketika model merekomendasikan film, kemungkinan besar film tersebut memang sesuai dengan preferensi pengguna.
- Recall@10 yang relatif rendah (0.2330) menunjukkan bahwa model hanya mampu menangkap sekitar 23.30% dari total film relevan yang sebenarnya ada untuk pengguna dalam validation set. Ini berarti ada banyak film relevan lainnya yang tidak masuk dalam daftar 10 rekomendasi teratas model.
Kesimpulan:
Model ini sangat baik dalam memberikan rekomendasi yang akurat (tinggi Precision), artinya rekomendasi yang ditampilkan punya probabilitas tinggi disukai pengguna. Namun, model belum mampu menemukan sebagian besar film relevan yang sebenarnya disukai pengguna (rendah Recall).
Untuk mengukur akurasi model, saya menggunakan Mean Absolute Error (MAE). MAE adalah rata-rata dari nilai absolut dari perbedaan antara nilai prediksi dan nilai sebenarnya. Nilai MAE yang lebih kecil menunjukkan model yang lebih akurat.
Mean Absolute Error (MAE):
- Nilai MAE pada Data Training:
Dari grafik MAE, saya mengamati bahwa nilai MAE pada data training (garis biru) mengalami penurunan konsisten sepanjang proses pelatihan. Hal ini menunjukkan bahwa model yang saya latih semakin baik dalam memprediksi rating dengan kesalahan absolut rata-rata yang semakin kecil. Penurunan yang stabil juga mengindikasikan bahwa proses pembelajaran berlangsung secara efektif tanpa gangguan besar seperti fluktuasi atau divergensi.
- Nilai MAE pada Data Validasi:
Nilai MAE pada data validasi (garis oranye) juga menunjukkan tren penurunan di awal pelatihan, tetapi cenderung stagnan mulai dari sekitar epoch ke-2 hingga akhir. Meskipun tidak terjadi peningkatan performa yang signifikan setelah titik tersebut, kestabilan nilai validasi ini mengindikasikan bahwa model tidak mengalami overfitting secara drastis, meskipun terdapat indikasi bahwa peningkatan performa terhadap data yang tidak terlihat menjadi terbatas setelah beberapa epoch awal.
- Indikasi Konvergensi:
Perbedaan antara MAE training dan validasi yang semakin melebar secara perlahan dapat menjadi sinyal awal adanya potensi overfitting, namun grafik menunjukkan bahwa nilai validasi tetap dalam rentang yang relatif stabil. Ini menunjukkan bahwa performa model pada data validasi masih dapat diterima meskipun laju peningkatannya melambat.
Untuk mengukur akurasi model, saya menggunakan Root Mean Squared Error (RMSE) yang merupakan hasil evaluasi model Collaborative Filtering RecommenderNet menggunakan metrik Root Mean Squared Error (RMSE) pada data pelatihan (RMSE) dan data validasi (Val RMSE) selama proses training. RMSE merupakan metrik yang umum digunakan dalam sistem rekomendasi untuk mengukur selisih rata-rata kuadrat antara rating prediksi dan rating aktual; semakin kecil nilai RMSE, semakin baik kinerja model.
Pada grafik, terlihat bahwa nilai RMSE pada data pelatihan mengalami penurunan yang konsisten dari awal hingga akhir pelatihan. Ini menunjukkan bahwa model berhasil mempelajari pola dari data pelatihan dengan baik. Di sisi lain, nilai RMSE pada data validasi juga menurun secara signifikan pada beberapa epoch awal, tetapi kemudian cenderung stabil dan mengalami sedikit fluktuasi setelah sekitar epoch ke-7. Ini adalah indikasi bahwa model mencapai titik stabil dalam pembelajaran dan menghindari overfitting. Model RecommenderNet dibangun dengan ukuran embedding = 50 dan dioptimalkan menggunakan Adam Optimizer dengan learning rate 0.001. Proses pelatihan dijalankan hingga maksimum 100 epoch dengan early stopping callback yang dikonfigurasi untuk:
patience=10: pelatihan akan dihentikan jika tidak ada perbaikan RMSE validasi selama 10 epoch berturut-turut.min_delta=0.0001: perubahan minimal yang dianggap sebagai perbaikan.restore_best_weights=True: model akan mengembalikan bobot terbaik berdasarkan kinerja validasi
Berdasarkan grafik, model RecommenderNet berhasil belajar dengan baik dari data pelatihan tanpa menunjukkan gejala overfitting yang signifikan. Penggunaan callback early stopping secara efektif menghentikan pelatihan pada waktu yang tepat dan memastikan bobot terbaik digunakan yang kemungkinan besar terjadi sebelum epoch ke-10. Nilai akhir RMSE pada data validasi sekitar 0.188 menjadi indikator kinerja model dalam memberikan prediksi rating yang mendekati nilai aktual pengguna, yang menunjukkan bahwa model cukup baik dalam memahami preferensi pengguna berdasarkan data interaksi sebelumnya.
Root Mean Squared Error (RMSE):
- Nilai RMSE pada Data Training:
Berdasarkan grafik RMSE, saya melihat penurunan tajam pada nilai RMSE training (garis biru) selama epoch awal, yang kemudian diikuti oleh penurunan bertahap hingga akhir pelatihan. Ini menunjukkan bahwa model mampu menyesuaikan prediksinya terhadap data training dengan mengurangi deviasi kuadrat rata-rata secara progresif.
- Nilai RMSE pada Data Validasi:
Nilai RMSE validasi (garis oranye) menurun pada awal pelatihan hingga sekitar epoch ke-7, lalu cenderung stabil dan sedikit fluktuatif hingga akhir pelatihan. Tidak terlihat adanya penurunan signifikan setelah titik tersebut, yang mengindikasikan bahwa model telah mencapai titik optimum dalam hal generalisasi pada data validasi. Namun, fluktuasi kecil setelah epoch ke-7 menunjukkan bahwa model mulai menghadapi batas kemampuannya dalam mengurangi kesalahan pada data yang tidak dilatih.
- Konvergensi dan Early Stopping:
Pola yang tampak pada grafik RMSE validasi mendukung penggunaan strategi Early Stopping. Jika callback ini digunakan, maka kemungkinan besar pelatihan dihentikan saat tidak ada peningkatan signifikan pada performa validasi. Dengan demikian, saya dapat menghindari pelatihan berlebih dan menjaga generalisasi model tetap baik.
Berdasarkan analisis terhadap grafik MAE dan RMSE, saya menyimpulkan bahwa model Collaborative Filtering yang dibangun menunjukkan performa pelatihan yang baik dan generalisasi yang memadai. Penurunan konsisten pada data training menunjukkan bahwa model berhasil mempelajari pola dari data, sedangkan nilai validasi yang relatif stabil menunjukkan bahwa overfitting masih dalam batas yang dapat diterima. Penggunaan teknik Early Stopping sangat membantu dalam memilih parameter model terbaik. Nilai MAE dan RMSE akhir dapat dijadikan indikator akurasi model dalam memprediksi rating, masing-masing dari perspektif kesalahan absolut dan kesalahan kuadrat rata-rata.
-
Rahman, M. F., & Zulkarnain, M. (2023). Content-based filtering for improving movie recommender system. Proceedings of the International Conference on Data Analytics and Intelligence (DAI-23), 124–130.
-
Singh, A., & Gupta, R. (2018). Content-based movie recommendation system using genre correlation. Proceedings of the Second International Conference on SCI 2018, 2, 88–93.
-
Sharma, P., & Verma, S. (2024). A collaborative filtering approach in movie recommendation systems. Grenze International Journal of Engineering and Technology, 10(2), 55–62.
-
Sinha, R., & Jaiswal, A. (2017). Collaborative filtering for movie recommendation using RapidMiner. International Journal of Computer Applications, 169(6), 1–5.
-
Oliveira, D. J., & Kumar, N. (2024). A comparison of content-based and collaborative filtering methods for movie recommendation systems. Procedia Computer Science, 227, 1012–1018.
-
Chowdhury, A., & Chatterjee, D. (2024). Synergizing collaborative and content-based filtering for enhanced movie recommendations. Lecture Notes in Networks and Systems, 831, 33–42.