Bikin Sistem Rekomendasi Film Sederhana dengan Python & Pandas

Halo gaes! Pernah gak sih ngerasa stuck pas mau nonton film? Scrolling Netflix sejam tapi ujung-ujungnya balik lagi nonton film lama yang itu-itu aja? Atau malah bingung mau pilih yang mana saking banyaknya pilihan? Nah, di sinilah magic dari sistem rekomendasi bekerja!

Kali ini, kita bakal spill gimana sih cara bikin sistem rekomendasi film sederhana pakai Python dan Pandas. Gampang banget kok, dan dijamin bakal bikin kamu makin pede ngoding sekaligus paham konsep dasarnya. Siap? Yuk, kita bedah!

Ngapain Sih Pake Sistem Rekomendasi?

Oke, sebelum nyemplung ke kode, kita samain dulu vibes-nya ya. Apa sih sebenernya sistem rekomendasi itu? Simpelnya, itu adalah sistem cerdas yang coba nebak kira-kira film (atau produk, musik, artikel, dll) apa yang bakal kamu suka, berdasarkan preferensi kamu sebelumnya atau preferensi orang lain yang punya selera mirip kamu.

Bayangin deh, hidup jadi lebih gampang kan kalau ada yang bantuin milih? Gak perlu lagi overthinking atau buang-buang waktu cuma buat cari film. Nah, ini alasan kenapa sistem rekomendasi itu penting banget di era digital sekarang.

Kenapa Python dan Pandas Jadi Bestie Kita?

• Python: Bahasa pemrograman sejuta umat yang super fleksibel dan ramah buat data science. Punya banyak library keren yang siap pakai.
• Pandas: Ini dia library andalan Python buat manipulasi data tabel (mirip Excel tapi jauh lebih powerful). Nanti kita bakal pake buat ngolah dataset film kita.
• Kombinasi Maut: Python sebagai otaknya, Pandas sebagai tangannya. Klop banget buat proyek kita ini!

Konsep Inti: Collaborative Filtering (Item-Based)

Ada banyak jenis sistem rekomendasi, tapi buat proyek sederhana ini, kita bakal fokus ke salah satu pendekatan paling populer: Collaborative Filtering. Lebih spesifik lagi, kita bakal pake yang Item-Based.

Gampangnya gini: Kalau kamu suka film A, dan banyak orang lain yang juga suka film A ternyata juga suka film B, maka sistem akan merekomendasikan film B ke kamu. Ini berdasarkan asumsi bahwa film-film yang sering disukai bersama oleh banyak orang punya "kemiripan" tertentu. Kita bakal pakai rating dari para user untuk menghitung kemiripan antar film ini.

Studi Kasus: Rekomendasi Film Pakai MovieLens

Kita bakal pakai dataset MovieLens. Ini dataset standar yang sering dipake buat belajar sistem rekomendasi. Untuk proyek sederhana kita, download yang versi ml-latest-small aja ya biar enggak terlalu berat. Nanti di dalamnya ada dua file utama yang bakal kita pake:

• movies.csv: Isinya ID film, judul, dan genre.
• ratings.csv: Isinya ID user, ID film, rating yang diberikan (skala 1-5), dan timestamp.

Skuy, kita mulai ngoding!

Langkah 1: Siapin Lingkungan & Data (Install, Import, Load!)

Pertama, pastikan kamu udah install Pandas ya. Kalau belum: pip install pandas.

# Import library yang dibutuhkan
import pandas as pd

# Path ke folder dataset MovieLens kamu
# Pastikan kamu sudah mendownload dan mengekstrak ml-latest-small.zip
# Contoh: data/ml-latest-small/
path_data = 'ml-latest-small/' 

# Load dataset movies.csv dan ratings.csv
try:
    movies_df = pd.read_csv(f'{path_data}movies.csv')
    ratings_df = pd.read_csv(f'{path_data}ratings.csv')
    print("Dataset berhasil dimuat, gaes!")
except FileNotFoundError:
    print(f"Ups, file dataset tidak ditemukan di '{path_data}'.")
    print("Pastikan kamu sudah download 'ml-latest-small.zip' dan ekstrak ke folder yang benar ya!")
    exit() # Keluar dari program jika file tidak ditemukan

Langkah 2: Intip Dulu Data Kita Biar Paham (Eksplorasi Data)

Sebelum nyemplung lebih jauh, kita intip dulu data kita pakai .head(), .info(), dan .shape() biar tau isinya apa, ada yang bolong (missing value) atau enggak, gitu.

print("\n--- Data Movies (5 baris pertama) ---")
print(movies_df.head())

print("\n--- Info Data Movies ---")
movies_df.info()

print("\n--- Data Ratings (5 baris pertama) ---")
print(ratings_df.head())

print("\n--- Info Data Ratings ---")
ratings_df.info()

Dari info di atas, keliatan kan kalau datanya lumayan bersih. Sekarang kita gabungin dua dataset ini biar gampang diolah.

Langkah 3: Gabungin Data, Bikin Matriks Ajaib!

Kita bakal gabungin ratings_df sama movies_df berdasarkan movieId biar ratingnya ada judul filmnya. Abis itu, kita bikin pivot table yang akan jadi "matriks ajaib" kita. Di matriks ini, index-nya adalah userId, kolomnya adalah title film, dan isinya adalah rating yang diberikan oleh user tersebut ke film itu.

# Gabungkan dataset ratings dan movies
# Kita cuma butuh movieId, title, userId, dan rating
merged_df = pd.merge(ratings_df, movies_df, on='movieId')

print("\n--- Data Gabungan (5 baris pertama) ---")
print(merged_df.head())

# Bikin pivot table: user_id jadi index, title jadi kolom, rating jadi value
user_movie_ratings = merged_df.pivot_table(index='userId', columns='title', values='rating')

print("\n--- Matriks User-Movie-Ratings (5 baris pertama) ---")
print(user_movie_ratings.head())

# Perhatiin nilai NaN (Not a Number) itu artinya user belum ngasih rating ke film tersebut

Matriks user_movie_ratings ini punya banyak nilai NaN karena gak semua user ngasih rating ke semua film. Itu normal kok!

Langkah 4: Nyari Kemiripan Film (Pake Korelasi Pearson!)

Ini nih inti dari Collaborative Filtering kita! Kita bakal hitung kemiripan antar film pakai Korelasi Pearson. Logikanya: kalau dua film punya pola rating yang mirip dari user-user yang sama, berarti dua film itu punya kemiripan.

Pandas punya fungsi keren namanya corrwith() yang bisa bantu kita ngitung korelasi satu seri dengan semua kolom di DataFrame.

# Pilih satu film sebagai acuan. Misal, 'Toy Story (1995)'.
# Penting: Pastikan judul filmnya persis sama dengan di dataset ya!
film_pilihan = 'Toy Story (1995)' 

# Cek dulu apakah film_pilihan ada di kolom matriks kita
if film_pilihan not in user_movie_ratings.columns:
    print(f"\nOops! Film '{film_pilihan}' tidak ditemukan di dataset.")
    print("Coba pilih film lain dari daftar user_movie_ratings.columns")
else:
    # Ambil rating user untuk film pilihan kita
    ratings_film_pilihan = user_movie_ratings[film_pilihan]

    # Hitung korelasi film pilihan dengan semua film lainnya
    # min_periods=10: Hanya hitung korelasi jika ada minimal 10 user yang rating kedua film.
    # Ini buat menghindari korelasi yang tidak stabil karena sedikit data.
    similar_to_film_pilihan = user_movie_ratings.corrwith(ratings_film_pilihan, min_periods=10)

    # Ubah hasil korelasi jadi DataFrame biar gampang diolah
    similar_to_film_pilihan_df = pd.DataFrame(similar_to_film_pilihan, columns=['correlation'])

    # Drop nilai NaN (film yang gak ada korelasinya)
    similar_to_film_pilihan_df.dropna(inplace=True)

    print(f"\n--- Korelasi Film dengan '{film_pilihan}' (contoh 5 teratas) ---")
    print(similar_to_film_pilihan_df.sort_values('correlation', ascending=False).head())

Langkah 5: Fungsi Rekomendasi Film: The Grand Finale!

Sekarang kita bikin fungsi deh, biar bisa dipanggil kapan aja. Fungsi ini akan menerima judul film sebagai input, lalu ngasih output daftar film yang paling direkomendasiin.

def recommend_movies(movie_title, user_movie_matrix, num_recommendations=10):
    """
    Memberikan rekomendasi film berdasarkan Collaborative Filtering (Item-Based).

    Args:
        movie_title (str): Judul film acuan.
        user_movie_matrix (pd.DataFrame): Matriks user-movie-ratings.
        num_recommendations (int): Jumlah film yang ingin direkomendasikan.

    Returns:
        pd.DataFrame: DataFrame berisi film-film yang direkomendasikan
                      beserta nilai korelasinya, diurutkan dari yang paling mirip.
    """
    if movie_title not in user_movie_matrix.columns:
        print(f"Maaf, film '{movie_title}' tidak ditemukan di daftar.")
        return pd.DataFrame() # Return DataFrame kosong jika film tidak ditemukan

    # Ambil rating user untuk film acuan
    movie_ratings = user_movie_matrix[movie_title]

    # Hitung korelasi film acuan dengan semua film lainnya
    # min_periods bisa diatur, disarankan > 1 untuk hasil yang lebih stabil
    similar_movies = user_movie_matrix.corrwith(movie_ratings, min_periods=50) # Naikkan min_periods untuk korelasi yang lebih kuat

    # Ubah hasil korelasi jadi DataFrame dan bersihkan NaN
    similar_movies_df = pd.DataFrame(similar_movies, columns=['correlation'])
    similar_movies_df.dropna(inplace=True)

    # Urutkan dari korelasi tertinggi
    similar_movies_df = similar_movies_df.sort_values('correlation', ascending=False)

    # Hapus film acuan dari daftar rekomendasi
    similar_movies_df = similar_movies_df.drop(movie_title, errors='ignore')

    # Ambil sejumlah rekomendasi teratas
    return similar_movies_df.head(num_recommendations)

# Coba panggil fungsi kita!
# Contoh film: 'Forrest Gump (1994)' atau 'Matrix, The (1999)'
film_yang_disuka = 'Forrest Gump (1994)' 
rekomendasi_ku = recommend_movies(film_yang_disuka, user_movie_ratings, num_recommendations=7)

if not rekomendasi_ku.empty:
    print(f"\n--- Rekomendasi Film Mirip '{film_yang_disuka}' ---")
    print(rekomendasi_ku)

Output Contoh:

--- Rekomendasi Film Mirip 'Forrest Gump (1994)' ---
                            correlation
title                                  
Shawshank Redemption, The (1994)   0.584160
Pulp Fiction (1994)                0.579435
Silence of the Lambs, The (1991)   0.518609
Braveheart (1995)                  0.490794
Jurassic Park (1993)               0.485188
Star Wars: Episode IV - A New Hope (1977) 0.465551
Apollo 13 (1995)                   0.463288

Nah, keren kan? Film-film yang direkomendasiin vibes-nya emang mirip-mirip sama Forrest Gump (1994)!

Tips Praktis Biar Makin GG (Good Game)!

1. Filter min_periods: Penting banget untuk menghindari korelasi yang tidak stabil. Kalau cuma ada 2 user yang rating dua film yang sama, korelasinya bisa 1.0 atau -1.0, padahal datanya sedikit banget. Dengan min_periods, kita bisa pastikan korelasi dihitung dari jumlah user yang cukup banyak.
2. Performa Data Gede: Kalau datasetnya super gede (jutaan user dan film), pendekatan ini mungkin kurang efisien. Kita perlu algoritma yang lebih canggih kayak SVD (Singular Value Decomposition) atau Matrix Factorization lainnya dari library seperti scikit-learn atau Surprise.
3. Cold Start Problem: Gimana kalau ada film baru yang belum ada rating-nya sama sekali? Atau user baru yang belum ngasih rating apa-apa? Sistem rekomendasi berbasis Collaborative Filtering kayak gini bakal bingung. Ini namanya "Cold Start Problem". Solusinya bisa pakai pendekatan Content-Based (rekomendasi berdasarkan genre, deskripsi, aktor) atau gabungan keduanya (Hybrid System).
4. Skalabilitas: Untuk aplikasi production, kamu perlu database yang kuat dan sistem deployment yang baik.
5. Explore Lebih Lanjut: Coba eksplorasi genre dari dataset movies_df. Kamu bisa pakai pendekatan Content-Based Filtering juga, misalnya mencari kemiripan film berdasarkan genre-nya.

Kesimpulan

Gimana, seru kan bikin sistem rekomendasi sendiri? Dari sini, kamu udah punya basic yang kuat buat eksplorasi lebih dalam. Kamu udah belajar gimana ngolah data dengan Pandas, bikin pivot table, sampai nyari kemiripan antar item pakai korelasi.

Dunia data science itu luas banget, gaes! Jadi, jangan takut buat eksperimen, coba algoritma lain, atau gabungin beberapa teknik rekomendasi. Coding itu proses belajar terus-menerus. Skuy, terus ngoding dan bikin project keren lainnya!