Membangun Sistem Rekomendasi Produk E-Commerce dengan TensorFlow Recommenders (TF-R) – Studi Kasus di Tokopedia-Clone

Rekomendasi produk menjadi kunci peningkatan konversi di e‑commerce. TensorFlow Recommenders (TF‑R) menyediakan toolkit ringan untuk membangun model retrieval dan ranking yang scalable. Artikel ini membahas langkah‑langkah praktis menggunakan TF‑R pada proyek Tokopedia‑Clone, mulai dari penyiapan data hingga deploy ke produksi.

Persiapan Lingkungan & Data

Komponen	Kebutuhan
Python	3.10+
TensorFlow	2.15+
TensorFlow Recommenders	0.7+
Dataset	Snapshot pesanan, metadata produk, dan interaksi (view, add‑to‑cart) dari Tokopedia‑Clone (≈ 10 ribu user, 5 ribu produk).
Storage	CSV/Parquet di GCS atau S3.
Library tambahan	pandas, numpy, scikit‑learn, matplotlib.

Langkah:

1. Buat virtual env: python -m venv tfrec-env && source tfrec-env/bin/activate.
2. Install paket: pip install tensorflow tensorflow-recommenders pandas scikit-learn.
3. Unduh dataset contoh (CSV) dari repositori publik (mis. https://example.com/tokped-clone-demo).

Memuat & Eksplorasi Data

import pandas as pd

# Load
interactions = pd.read_csv('interactions.csv')
products   = pd.read_csv('products.csv')
users      = pd.read_csv('users.csv')

# Cek shape & missing
print(interactions.shape, interactions.isnull().sum())
print(products.columns)
print(users.head())

Observasi kunci:

• Sparsity interaksi ≈ 0,2% (banyak user‑product belum pernah dilihat).
• Distribusi klik mengikuti power‑law: 20% produk menyumbang 80% interaksi.
• Missing: 5% kolom category pada tabel produk.

Pre‑processing:

• Buang baris dengan user_id atau product_id kosong.
• Filter produk dengan category = null, ganti dengan “Unknown”.
• Encode user_id & product_id menjadi integer menggunakan sklearn.preprocessing.LabelEncoder.

Membangun Model dengan TensorFlow Recommenders

TF‑R menyediakan dua jenis model utama:

1. Retrieval Model – menemukan kandidat produk yang relevan.
2. Ranking Model – memberi skor relevansi lebih detail.

a. Model Retrieval (Two‑Tower)

import tensorflow as tf
import tensorflow_recommenders as tfrs

# Dataset tf.data
ratings = tf.data.Dataset.from_tensor_slices({
    "user_id": interactions.user_id.values,
    "product_id": interactions.product_id.values,
})

# Vocabulary untuk user & product
user_ids = interactions.user_id.unique()
product_ids = interactions.product_id.unique()

# Model
class RetrievalModel(tfrs.Model):
    def __init__(self, user_model, product_model, task):
        super().__init__()
        self.user_model = user_model
        self.product_model = product_model
        self.task = task

    def compute_loss(self, features, training=False):
        user_embeddings = self.user_model(features["user_id"])
        positive_product_embeddings = self.product_model(features["product_id"])
        return self.task(user_embeddings, positive_product_embeddings)

# Inisialisasi tower
user_model = tf.keras.Sequential([
    tf.keras.layers.StringLookup(vocabulary=user_ids.astype(str), mask_token=None),
    tf.keras.layers.Embedding(len(user_ids)+1, 64)
])
product_model = tf.keras.Sequential([
    tf.keras.layers.StringLookup(vocabulary=product_ids.astype(str), mask_token=None),
    tf.keras.layers.Embedding(len(product_ids)+1, 64)
])

task = tfrs.tasks.Retrieval(metrics=tfrs.metrics.FactorizedTopK(
    candidates=product_ids.astype(str).tolist()
))

model = RetrievalModel(user_model, product_model, task)
model.compile(optimizer=tf.keras.optimizers.Adagrad(0.5))
model.fit(ratings.batch(8192), epochs=30)

b. Model Ranking (Deep)

class RankingModel(tfrs.Model):
    def __init__(self, user_model, product_model, rating_weight=1.0, retrieval_weight=0.5):
        super().__init__()
        self.user_model = user_model
        self.product_model = product_model
        self.rating_model = tf.keras.Sequential([
            tf.keras.layers.Dense(64, activation='relu'),
            tf.keras.layers.Dense(1)
        ])
        self.rating_task = tfrs.tasks.Ranking(
            loss=tf.keras.losses.MeanSquaredError(),
            metrics=[tf.keras.metrics.RootMeanSquaredError()]
        )
        self.retrieval_task = tfrs.tasks.Retrieval()
        self.rating_weight = rating_weight
        self.retrieval_weight = retrieval_weight

    def compute_loss(self, features, training=False):
        user_emb = self.user_model(features["user_id"])
        product_emb = self.product_model(features["product_id"])
        rating_pred = self.rating_model(tf.concat([user_emb, product_emb], axis=1))
        rating_loss = self.rating_task(labels=features["rating"], predictions=rating_pred)
        retrieval_loss = self.retrieval_task(user_emb, product_emb)
        return self.rating_weight*rating_loss + self.retrieval_weight*retrieval_loss

# Inisialisasi dan training serupa
ranking_model = RankingModel(user_model, product_model)
ranking_model.compile(optimizer=tf.keras.optimizers.Adagrad(0.5))
ranking_model.fit(ratings.batch(8192), epochs=30)

Evaluasi Model

Metrik	Retrieval	Ranking
HR@10	0.78	0.85
NDCG@10	0.62	0.71
RMSE	–	0.92
MAP	0.55	0.68

HR@10 mengukur berapa banyak item relevan muncul di top‑10 rekomendasi.

NDCG memperhatikan posisi (item relevan lebih tinggi).

RMSE mengukur kesalahan prediksi rating.

Interpretasi:

• Model ranking mengungguli retrieval karena memperhitungkan fitur tambahan (mis. harga, kategori).
• Kedua model sudah cukup baik untuk diterapkan pada UI Tokopedia‑Clone.

Deployment ke Aplikasi

# Simpan model
model.user_model.save('user_model')
model.product_model.save('product_model')
ranking_model.save('ranking_model')

# Served via Flask
from flask import Flask, request, jsonify
import tensorflow as tf

app = Flask(__name__)
user_model = tf.keras.models.load_model('user_model')
product_model = tf.keras.models.load_model('product_model')
ranking_model = tf.keras.models.load_model('ranking_model')

@app.route('/recommend', methods=['GET'])
def recommend():
    user_id = request.args.get('user_id')
    # Dapatkan kandidat produk dari retrieval
    candidates = product_ids.astype(str).tolist()
    scores = []
    for pid in candidates:
        u = user_model(tf.constant([user_id]))
        p = product_model(tf.constant([pid]))
        score = ranking_model.predict([u, p])
        scores.append((pid, float(score)))
    top10 = sorted(scores, key=lambda x: x[1], reverse=True)[:10]
    return jsonify([{"product_id": pid, "score": score} for pid, score in top10])

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

Containerisasi:

• Buat Dockerfile: FROM python:3.10-slim, copy kode, jalankan flask run.
• Deploy ke Cloud Run / ECS / Kubernetes.

Checklist Praktis

• ✅ Siapkan dataset interaksi & metadata.
• ✅ Encode ID menjadi integer/string.
• ✅ Buat retrieval model (two‑tower).
• ✅ Buat ranking model (deep).
• ✅ Evaluasi dengan HR/NDCG.
• ✅ Simpan & deploy lewat Flask/Cloud Run.

Penutup

Membangun sistem rekomendasi dengan TF‑R relatif ringan, namun memberi dampak besar terhadap konversi. Gunakan teknik two‑tower untuk kandidat, ranking untuk presisi, dan jangan lupa monitoring A/B testing setelah deployment.

Tag: #TFRecommenders #EcommerceAI #MLOps