Tutorial Sistem Rekomendasi Python Content-Based Filtering

Sistem rekomendasi telah menjadi bagian tak terpisahkan dari banyak platform digital yang kita gunakan sehari-hari, mulai dari layanan streaming film seperti Netflix, platform musik seperti Spotify, hingga toko online. Kemampuannya untuk menyajikan konten atau produk yang relevan dengan minat pengguna secara signifikan meningkatkan pengalaman pengguna dan engagement. Artikel ini akan menjadi tutorial sistem rekomendasi content-based yang memandu Anda langkah demi langkah dalam membuat sistem rekomendasi Python yang sederhana dari awal. Kita akan fokus pada salah satu metode paling fundamental dan intuitif: Content-Based Filtering. Tutorial ini ditujukan bagi para pengembang Python, mahasiswa ilmu komputer atau data science, serta siapa saja yang tertarik mempelajari dasar-dasar sistem rekomendasi untuk pemula.

Memahami Konsep Dasar: Apa Itu Content-Based Filtering?

Sebelum kita melangkah ke implementasi kode, mari kita pahami terlebih dahulu konsep dasar di balik metode ini.

Definisi Content-Based Filtering

Content-Based Filtering adalah salah satu pendekatan utama dalam sistem rekomendasi yang bekerja dengan cara merekomendasikan item (misalnya, film, artikel, produk) yang memiliki kemiripan konten atau fitur dengan item yang pernah disukai atau berinteraksi positif oleh pengguna di masa lalu. Intinya, jika Anda menyukai item X, sistem akan mencari item Y yang memiliki karakteristik serupa dengan X dan merekomendasikannya kepada Anda. Pertanyaan mendasar yang dijawab oleh metode ini adalah “Item apa lagi yang mirip dengan yang Anda sukai sebelumnya?”. Jadi, apa itu content-based filtering? Ini adalah teknik rekomendasi berdasarkan atribut item itu sendiri.

Bagaimana Cara Kerja Content-Based Filtering?

Secara konseptual, cara kerja content-based filtering dapat diuraikan dalam beberapa langkah utama:

1. Analisis Fitur Item: Sistem pertama-tama menganalisis konten atau fitur dari setiap item dalam koleksi. Fitur ini bisa berupa genre film, kata kunci dalam deskripsi artikel, bahan dalam resep masakan, penulis buku, dan sebagainya.
2. Pembangunan Profil Pengguna: Berdasarkan riwayat interaksi pengguna (misalnya, item yang diberi rating tinggi, diklik, atau dibeli), sistem membangun profil preferensi pengguna. Profil ini mencerminkan jenis konten atau fitur item yang disukai oleh pengguna tersebut.
3. Pencocokan Profil: Sistem kemudian membandingkan profil fitur dari item-item baru (yang belum pernah berinteraksi dengan pengguna) dengan profil preferensi pengguna.
4. Pemberian Rekomendasi: Item-item yang memiliki profil fitur paling cocok atau paling mirip dengan profil preferensi pengguna akan direkomendasikan.

Perbandingan Singkat: Content-Based vs. Collaborative Filtering

Untuk memberikan konteks, penting untuk mengetahui perbedaan utama antara Content-Based Filtering dan metode populer lainnya, yaitu Collaborative Filtering. Perbedaan content-based dan collaborative terletak pada sumber informasinya:

• Content-Based Filtering: Fokus pada atribut item dan riwayat satu pengguna. Kelebihannya adalah tidak memerlukan data dari pengguna lain (mengatasi masalah “cold start” untuk item baru) dan dapat merekomendasikan item yang spesifik sesuai selera pengguna. Kekurangannya, rekomendasi cenderung terbatas pada jenis item yang mirip (kurang ada kejutan/serendipity) dan sangat bergantung pada kualitas ekstraksi fitur.
• Collaborative Filtering: Fokus pada pola perilaku pengguna secara kolektif. Metode ini merekomendasikan item berdasarkan apa yang disukai oleh pengguna lain yang memiliki selera serupa. Kelebihannya bisa menemukan item baru yang beragam (serendipity). Kekurangannya adalah kesulitan menangani pengguna baru atau item baru (masalah “cold start”) dan membutuhkan banyak data interaksi pengguna.

Tutorial ini akan berfokus pada implementasi Content-Based Filtering.

Persiapan Data dan Library Python yang Dibutuhkan

Sebelum memulai pengkodean untuk membuat sistem rekomendasi Python, kita perlu mempersiapkan lingkungan dan data.

Library Python utama yang akan kita gunakan adalah:

• Pandas: Untuk memanipulasi dan mengelola data tabular dengan mudah.
• Scikit-learn: Pustaka machine learning yang sangat populer, akan kita gunakan untuk vektorisasi teks (TF-IDF) dan perhitungan kemiripan (Cosine Similarity).

Anda dapat menginstal kedua library ini menggunakan pip:

pip install pandas scikit-learn

Untuk dataset, metode content-based memerlukan data yang memiliki deskripsi atau atribut untuk setiap item. Contoh ideal bisa berupa:

• Dataset film dengan kolom seperti ‘judul’, ‘genre’, ‘sinopsis’, ‘aktor’. (Sebagai studi kasus sistem rekomendasi film sederhana)
• Dataset artikel berita dengan ‘judul’, ‘kategori’, ‘isi artikel’.
• Dataset produk e-commerce dengan ‘nama_produk’, ‘deskripsi’, ‘kategori’.

Dalam tutorial ini, kita akan menggunakan contoh dataset sederhana yang bisa Anda buat sendiri dalam format CSV (Comma Separated Values). Misalnya, buat file bernama konten_data.csv dengan isi seperti berikut:

id,judul,deskripsi
1,"Pengantar Machine Learning","Artikel ini menjelaskan konsep dasar machine learning dan aplikasinya."
2,"Tutorial Python untuk Pemula","Belajar dasar-dasar pemrograman Python dari awal dengan contoh kode."
3,"Konsep Deep Learning","Pembahasan mendalam tentang arsitektur jaringan syaraf tiruan dan deep learning."
4,"Panduan Analisis Data dengan Pandas","Cara menggunakan library Pandas untuk manipulasi dan analisis data di Python."
5,"Aplikasi Machine Learning di Industri","Contoh penerapan nyata machine learning di berbagai sektor industri."

Pastikan file CSV ini berada di direktori yang sama dengan skrip Python Anda.

Langkah-Langkah Membuat Sistem Rekomendasi Content-Based dengan Python

Berikut adalah langkah membuat sistem rekomendasi content-based secara detail menggunakan Python.

Langkah 1: Memuat dan Membersihkan Data

Langkah pertama adalah memuat dataset kita ke dalam struktur data yang mudah dikelola menggunakan Pandas, yaitu DataFrame. Kita juga akan melakukan inspeksi singkat.

import pandas as pd

# Memuat dataset dari file CSV
df = pd.read_csv('konten_data.csv')

# Menampilkan 5 baris pertama data
print("Data Awal:")
print(df.head())

# (Opsional) Memeriksa nilai null jika perlu
# print("\nInfo Nilai Null:")
# print(df.isnull().sum())

# Dalam contoh ini, kita akan menggunakan kolom 'deskripsi' sebagai fitur konten
# Jika ada nilai null di kolom fitur, Anda perlu menanganinya (misal: mengisi dengan string kosong)
# df['deskripsi'] = df['deskripsi'].fillna('')

Langkah 2: Representasi Konten – Vektorisasi Teks Menggunakan TF-IDF

Komputer tidak dapat memahami teks secara langsung. Oleh karena itu, kita perlu mengubah deskripsi teks menjadi representasi numerik. Teknik ini disebut vektorisasi teks Python. Salah satu metode yang paling umum dan efektif adalah TF-IDF (Term Frequency-Inverse Document Frequency).

Secara sederhana, TF-IDF bekerja dengan cara:

• Term Frequency (TF): Mengukur seberapa sering sebuah kata muncul dalam satu dokumen (deskripsi item). Kata yang sering muncul dianggap lebih penting untuk dokumen tersebut.
• Inverse Document Frequency (IDF): Mengukur seberapa unik sebuah kata di seluruh koleksi dokumen (korpus). Kata yang muncul di banyak dokumen (seperti “dan”, “atau”, “di”) dianggap kurang informatif dan diberi bobot lebih rendah.

TF-IDF menggabungkan kedua ukuran ini untuk memberikan bobot pada setiap kata dalam setiap dokumen, yang menunjukkan tingkat kepentingan kata tersebut. Kita akan menggunakan TfidfVectorizer dari Scikit-learn. Ini adalah bagian penting dari tutorial TF-IDF Python.

from sklearn.feature_extraction.text import TfidfVectorizer

# Inisialisasi TfidfVectorizer
# stop_words='english' bisa ditambahkan jika teks berbahasa Inggris untuk menghapus kata umum
# atau gunakan daftar stop words Bahasa Indonesia jika perlu
tfidf = TfidfVectorizer(stop_words=None) # Gunakan None jika tidak ingin stop words atau data Indonesia

# Melakukan fit dan transform pada kolom 'deskripsi'
# Ini akan membuat matriks TF-IDF dimana baris adalah dokumen dan kolom adalah kata unik
tfidf_matrix = tfidf.fit_transform(df['deskripsi'])

# Menampilkan ukuran matriks TF-IDF (jumlah dokumen x jumlah kata unik)
print("\nUkuran Matriks TF-IDF:")
print(tfidf_matrix.shape)

# (Opsional) Menampilkan beberapa fitur (kata) yang diekstrak
# print("\nContoh Fitur (Kata):")
# feature_names = tfidf.get_feature_names_out()
# print(feature_names[:10])

Sekarang, setiap deskripsi artikel direpresentasikan sebagai vektor numerik dalam tfidf_matrix.

Langkah 3: Menghitung Kemiripan Antar Konten dengan Cosine Similarity

Setelah memiliki representasi vektor untuk setiap item, langkah selanjutnya adalah menghitung seberapa mirip vektor-vektor tersebut satu sama lain. Metrik yang umum digunakan untuk ini adalah Cosine Similarity.

Cosine Similarity mengukur kosinus sudut antara dua vektor non-nol. Nilainya berkisar antara -1 hingga 1 (atau 0 hingga 1 untuk vektor non-negatif seperti TF-IDF). Nilai 1 berarti vektor identik (sangat mirip), nilai 0 berarti vektor ortogonal (tidak mirip), dan nilai -1 berarti vektor berlawanan arah.

Kita akan menggunakan fungsi cosine_similarity dari Scikit-learn untuk menghitung matriks kemiripan antara semua pasangan item berdasarkan vektor TF-IDF mereka. Ini adalah inti dari penggunaan cosine similarity Python sistem rekomendasi.

from sklearn.metrics.pairwise import cosine_similarity

# Menghitung matriks cosine similarity
cosine_sim = cosine_similarity(tfidf_matrix, tfidf_matrix)

# Menampilkan ukuran matriks similarity (jumlah dokumen x jumlah dokumen)
print("\nUkuran Matriks Cosine Similarity:")
print(cosine_sim.shape)

# Menampilkan sebagian matriks similarity (misal, untuk 5 item pertama)
# print("\nMatriks Cosine Similarity (sebagian):")
# print(cosine_sim[:5, :5])

Matriks cosine_sim sekarang berisi skor kemiripan antara setiap pasang artikel. Nilai cosine_sim[i][j] adalah skor kemiripan antara artikel ke-i dan artikel ke-j.

Langkah 4: Membuat Fungsi untuk Mendapatkan Rekomendasi

Langkah terakhir adalah membuat fungsi yang dapat mengambil judul artikel sebagai input dan mengembalikan daftar artikel lain yang paling mirip berdasarkan skor Cosine Similarity. Ini akan menjadi fungsi inti dari sistem rekomendasi Python kita dan menyediakan kode Python sistem rekomendasi sederhana yang fungsional.

Logika fungsi ini adalah sebagai berikut:

1. Temukan indeks artikel yang judulnya cocok dengan input.
2. Ambil baris skor kemiripan untuk artikel tersebut dari matriks cosine_sim.
3. Urutkan skor kemiripan ini dalam urutan menurun, sambil tetap melacak indeks asli artikel.
4. Ambil N indeks teratas (misalnya 10) yang memiliki skor tertinggi (tidak termasuk artikel input itu sendiri).
5. Kembalikan judul artikel yang sesuai dengan indeks teratas tersebut.

# Membuat Series Pandas untuk memetakan judul ke indeks
indices = pd.Series(df.index, index=df['judul']).drop_duplicates()

def get_recommendations(judul, cosine_sim=cosine_sim, data=df, indices=indices):
    """
    Fungsi untuk mendapatkan rekomendasi berdasarkan content-based filtering.

    Args:
        judul (str): Judul artikel yang ingin dicari rekomendasinya.
        cosine_sim (numpy.ndarray): Matriks cosine similarity.
        data (pd.DataFrame): DataFrame asli yang berisi data artikel.
        indices (pd.Series): Series yang memetakan judul ke indeks.

    Returns:
        pd.Series atau str: Series berisi judul artikel yang direkomendasikan,
                            atau pesan jika judul tidak ditemukan atau tidak ada rekomendasi.
    """
    # Mendapatkan indeks dari artikel yang cocok dengan judul
    try:
        idx = indices[judul]
    except KeyError:
        return f"Artikel dengan judul '{judul}' tidak ditemukan."

    # Mendapatkan skor kemiripan cosine untuk semua artikel dengan artikel input
    # Mengubahnya menjadi list pasangan (indeks, skor)
    sim_scores = list(enumerate(cosine_sim[idx]))

    # Mengurutkan artikel berdasarkan skor kemiripan (secara menurun)
    sim_scores = sorted(sim_scores, key=lambda x: x[1], reverse=True)

    # Mengambil skor dari N artikel paling mirip (misal 10), mengabaikan artikel input itu sendiri (indeks 0 setelah sorting)
    # Jika jumlah artikel kurang dari N+1, ambil semuanya kecuali input
    top_n = 10 
    sim_scores = sim_scores[1:top_n+1]

    # Jika tidak ada skor yang cukup tinggi (selain item itu sendiri)
    if not sim_scores:
         return "Tidak ada rekomendasi yang cukup mirip ditemukan."

    # Mendapatkan indeks artikel yang direkomendasikan
    article_indices = [i[0] for i in sim_scores]

    # Mengembalikan judul dari artikel yang paling mirip
    return data['judul'].iloc[article_indices]

Contoh Implementasi Lengkap Content-Based Filtering

Sekarang mari kita gabungkan semua langkah dan lihat contoh implementasi content-based filtering secara utuh. Blok kode berikut mencakup semua langkah dari memuat data hingga mendapatkan rekomendasi. Ini adalah kode Python sistem rekomendasi sederhana yang siap dijalankan.

import pandas as pd
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity

# --- Langkah 1: Memuat Data ---
try:
    df = pd.read_csv('konten_data.csv')
    print("Data berhasil dimuat.")
    # Mengatasi potensi NaN di deskripsi untuk mencegah error
    df['deskripsi'] = df['deskripsi'].fillna('')
except FileNotFoundError:
    print("Error: File 'konten_data.csv' tidak ditemukan. Pastikan file ada di direktori yang sama.")
    exit() # Keluar jika file tidak ada
except Exception as e:
    print(f"Terjadi error saat memuat data: {e}")
    exit()

# --- Langkah 2: Vektorisasi TF-IDF ---
tfidf = TfidfVectorizer(stop_words=None)
tfidf_matrix = tfidf.fit_transform(df['deskripsi'])
print(f"Matriks TF-IDF dibuat dengan ukuran: {tfidf_matrix.shape}")

# --- Langkah 3: Menghitung Cosine Similarity ---
cosine_sim = cosine_similarity(tfidf_matrix, tfidf_matrix)
print(f"Matriks Cosine Similarity dibuat dengan ukuran: {cosine_sim.shape}")

# --- Langkah 4: Membuat Fungsi Rekomendasi ---
indices = pd.Series(df.index, index=df['judul']).drop_duplicates()

def get_recommendations(judul, cosine_sim=cosine_sim, data=df, indices=indices):
    try:
        idx = indices[judul]
    except KeyError:
        return f"Artikel dengan judul '{judul}' tidak ditemukan."

    sim_scores = list(enumerate(cosine_sim[idx]))
    sim_scores = sorted(sim_scores, key=lambda x: x[1], reverse=True)

    # Ambil N teratas, misal N=3 untuk contoh ini agar lebih ringkas
    top_n = 3
    sim_scores = sim_scores[1:top_n+1]
    
    if not sim_scores:
         return "Tidak ada rekomendasi yang cukup mirip ditemukan."

    article_indices = [i[0] for i in sim_scores]
    return data['judul'].iloc[article_indices]

# --- Contoh Pengujian Fungsi Rekomendasi ---
print("\n--- Pengujian Rekomendasi ---")

# Contoh 1: Rekomendasi untuk 'Pengantar Machine Learning'
judul_input1 = "Pengantar Machine Learning"
rekomendasi1 = get_recommendations(judul_input1)
print(f"\nJika Anda menyukai '{judul_input1}', Anda mungkin juga menyukai:")
if isinstance(rekomendasi1, str): # Jika fungsi mengembalikan pesan error/not found
    print(rekomendasi1)
elif not rekomendasi1.empty:
    print(rekomendasi1.to_string(index=False))
else:
    print("Tidak ada rekomendasi lain yang ditemukan.")


# Contoh 2: Rekomendasi untuk 'Tutorial Python untuk Pemula'
judul_input2 = "Tutorial Python untuk Pemula"
rekomendasi2 = get_recommendations(judul_input2)
print(f"\nJika Anda menyukai '{judul_input2}', Anda mungkin juga menyukai:")
if isinstance(rekomendasi2, str):
    print(rekomendasi2)
elif not rekomendasi2.empty:
    print(rekomendasi2.to_string(index=False))
else:
     print("Tidak ada rekomendasi lain yang ditemukan.")

# Contoh 3: Judul tidak ditemukan
judul_input3 = "Judul yang Tidak Ada"
rekomendasi3 = get_recommendations(judul_input3)
print(f"\nMencoba mencari rekomendasi untuk '{judul_input3}':")
print(rekomendasi3)

Jalankan kode ini. Anda akan melihat output yang menunjukkan matriks TF-IDF dan Cosine Similarity dibuat, diikuti dengan rekomendasi untuk artikel yang Anda pilih berdasarkan kemiripan deskripsinya. Ini menunjukkan bagaimana sistem rekomendasi sederhana dapat dibangun menggunakan Python.

Kesimpulan dan Pengembangan Lebih Lanjut

Dalam tutorial sistem rekomendasi content-based ini, kita telah mempelajari langkah-langkah fundamental untuk membangun sistem rekomendasi sederhana menggunakan Python. Kita telah membahas konsep dasar, cara kerja content-based filtering, melakukan pra-pemrosesan data, mengubah teks menjadi vektor numerik menggunakan TF-IDF, menghitung kemiripan antar item dengan Cosine Similarity, dan akhirnya membuat fungsi untuk menghasilkan rekomendasi.

Meskipun metode ini efektif untuk memulai, ada beberapa area untuk pengembangan lebih lanjut:

• Fitur Konten yang Lebih Kaya: Menggunakan fitur tambahan selain deskripsi, seperti kategori, tag, atau bahkan metadata lainnya untuk representasi item yang lebih baik.
• Pra-pemrosesan Teks Lanjutan: Menerapkan teknik seperti stemming (mengubah kata ke bentuk dasar) atau lemmatization, serta penanganan stop words yang lebih canggih untuk meningkatkan kualitas vektorisasi.
• Evaluasi Kualitas Rekomendasi: Menggunakan metrik evaluasi (misalnya, precision, recall, F1-score) untuk mengukur seberapa baik sistem rekomendasi bekerja secara objektif.
• Hybrid Filtering: Menggabungkan content-based filtering dengan collaborative filtering untuk memanfaatkan kelebihan kedua metode dan mengatasi kekurangannya, sering kali menghasilkan rekomendasi yang lebih akurat dan beragam.
• Skalabilitas: Untuk dataset yang sangat besar, pertimbangkan penggunaan teknik atau library yang lebih dioptimalkan untuk performa dan memori (misalnya, Approximate Nearest Neighbors, atau kerangka kerja pemrosesan data terdistribusi seperti Spark).

Membangun sistem rekomendasi, bahkan yang sederhana sekalipun, dapat memberikan nilai tambah signifikan bagi platform digital Anda. Teknik yang dipelajari di sini menjadi fondasi penting untuk eksplorasi lebih lanjut di dunia AI dan personalisasi.

Baca juga: Image Captioning Dijelaskan Cara Kerja & Manfaat AI (2025)

Ingin mengimplementasikan sistem rekomendasi yang lebih canggih atau solusi AI lainnya yang disesuaikan untuk kebutuhan spesifik bisnis Anda? Memanfaatkan kekuatan AI dapat mengotomatiskan tugas, meningkatkan pengalaman pengguna, dan mendorong pertumbuhan. Kirim.ai, sebagai pemimpin dalam solusi digital berbasis AI, menawarkan platform SaaS canggih dan layanan pengembangan platform lengkap (web, aplikasi mobile, solusi AI kustom) untuk membantu Anda mencapai tujuan tersebut. Kami menyediakan alat AI untuk pembuatan konten, AI Agent untuk optimasi SEO otomatis, serta keahlian dalam pengembangan solusi AI yang terintegrasi. Jika Anda membutuhkan partner strategis untuk inovasi digital Anda, pelajari lebih lanjut bagaimana Kirim.ai dapat memberdayakan bisnis Anda dengan solusi AI terdepan.