Lewati ke isi

Proyek: Segmentasi Pelanggan Toko Online

Gambaran singkat

Apa ini? Proyek penutup yang merangkai semua pelajaran klastering menjadi satu alur kerja nyata, dari data mentah sampai rekomendasi tindakan.

Analogi

Seperti ujian praktik setelah belajar teori mengemudi: Anda tidak lagi mempelajari satu bagian, tetapi menjalankan semuanya berurutan, mulai dari menyalakan mesin sampai tiba di tujuan.

Mengapa penting? Di dunia nyata, langkah-langkah itu tidak berdiri sendiri. Proyek ini menunjukkan bagaimana keputusan di satu langkah memengaruhi langkah berikutnya.

Yang akan dipelajari, berurutan:

  1. Memeriksa data (EDA) dan mengenali outlier.
  2. Praproses: transformasi log dan scaling.
  3. Memilih \(k\) dengan metrik internal dan kestabilan.
  4. Melatih, membandingkan, memprofilkan, dan menamai segmen.
  5. Merumuskan tindakan bisnis, menyimpan pipeline, dan menempatkan pelanggan baru.

Istilah awal:

Istilah Arti sederhana
RFM Recency (kapan terakhir beli), Frequency (seberapa sering), Monetary (berapa banyak belanja)
Segmentasi Membagi pelanggan ke kelompok bermakna

Tujuan proyek

Menerapkan alur klastering lengkap: EDA, praproses (log dan scaling), pemilihan \(k\) dengan metrik internal dan kestabilan, perbandingan dengan algoritma lain, profil dan nama segmen, tindakan bisnis, penempatan pelanggan baru, dan penyimpanan pipeline.

Masalah dan data

Masalah: mengelompokkan pelanggan toko online berdasarkan pola belanja agar tim pemasaran dapat menyusun tindakan yang berbeda untuk tiap kelompok.

Data: sintetis bergaya RFM, 900 pelanggan dengan tiga fitur: recency (hari sejak pembelian terakhir), frequency (jumlah pesanan), dan monetary (total belanja, ribu Rp). Di balik data ada tiga kelompok tersembunyi (VIP, reguler, berisiko pergi) yang hanya dipakai untuk validasi eksternal, ditambah 8 pelanggan ekstrem (misalnya reseller) dengan belanja 15 kali lipat. Hasil tidak menjelaskan pelanggan nyata.

Alur kerja

  1. EDA: skewness dan outlier.
  2. Praproses: log1p dan standardisasi di dalam pipeline.
  3. Pilih \(k\): silhouette, Davies-Bouldin, kestabilan bootstrap.
  4. Latih k-Means, bandingkan dengan Ward, profilkan, beri nama, rumuskan tindakan.
  5. Simpan pipeline dan tempatkan pelanggan baru.

Implementasi langkah demi langkah

Program examples/clustering/project.py berdiri sendiri. Konsep tiap langkah sudah dibahas di pelajaran sebelumnya; di sini fokusnya pada penyatuan langkah dan keputusan yang diambil. Program lengkap ada di akhir bagian ini.

Langkah 1: membangkitkan data RFM sintetis

project.py
# 1. Data: Recency (hari sejak pembelian terakhir), Frequency (jumlah pesanan), Monetary (total belanja, ribu Rp)
rng = np.random.default_rng(SEED)
groups = {"VIP": (0.12, 10, 30, 14.0), "reguler": (0.5, 40, 6, 5.0), "berisiko pergi": (0.38, 220, 2, 3.0)}
rows = []
for name, (share, rec, freq, mon) in groups.items():
    n = int(900 * share)
    rows.append(pd.DataFrame({
        "recency": rng.gamma(4, rec / 4, n).round(0) + 1,
        "frequency": rng.poisson(freq, n) + 1,
        "monetary": rng.lognormal(np.log(mon * 100), 0.5, n).round(0),
        "group_true": name}))
df = pd.concat(rows, ignore_index=True)
# beberapa pelanggan ekstrem (misalnya reseller)
df.loc[rng.choice(len(df), 8, replace=False), "monetary"] *= 15
features = ["recency", "frequency", "monetary"]
print("jumlah pelanggan:", len(df), "| skewness:", df[features].skew().round(2).to_dict())
Bagian Penjelasan
groups = {"VIP": (0.12, 10, 30, 14.0), ...} Tiga kelompok tersembunyi: (proporsi, recency tipikal, frekuensi tipikal, monetary tipikal).
rng.gamma(4, rec / 4, n) Recency: distribusi gamma yang miring ke kanan dengan rata-rata ≈ rec hari.
rng.poisson(freq, n) + 1 Frequency: cacahan pesanan (minimal 1).
rng.lognormal(np.log(mon * 100), 0.5, n) Monetary: distribusi lognormal (miring ke kanan, sesuai belanja nyata).
df.loc[rng.choice(len(df), 8, replace=False), "monetary"] *= 15 Delapan pelanggan ekstrem (misalnya reseller) dengan belanja 15 kali lipat.
df[features].skew() Kemiringan tiap fitur.
jumlah pelanggan: 900 | skewness: {'recency': 1.44, 'frequency': 2.15, 'monetary': 20.33}

Hasil. 900 pelanggan; monetary sangat miring (skewness 20,33) karena pelanggan ekstrem, frequency 2,15, recency 1,44.

Langkah 2: praproses (log dan standardisasi)

project.py
# 2. Praproses: log1p (data miring dan outlier) + standardisasi, semuanya di dalam pipeline
prep = Pipeline([("log", FunctionTransformer(np.log1p)), ("scale", StandardScaler())])
Z = prep.fit_transform(df[features])
print("skewness setelah log:", pd.DataFrame(np.log1p(df[features])).skew().round(2).to_dict())

Pipeline([("log", FunctionTransformer(np.log1p)), ("scale", StandardScaler())]) menerapkan log lalu standardisasi pada semua tiga kolom. prep.fit_transform(df[features]) mempelajari parameter standardisasi dan menghasilkan Z. Tanpa transformasi, pelanggan ekstrem akan menarik pusat klaster.

skewness setelah log: {'recency': -0.03, 'frequency': 0.71, 'monetary': 0.98}

Hasil. Skewness setelah log: -0,03 (recency), 0,71 (frequency), 0,98 (monetary).

Langkah 3: memilih \(k\)

Konsep. Beberapa bukti digabung: silhouette, Davies-Bouldin, dan kestabilan bootstrap (penjelasan).

project.py
# 3. Memilih k: metrik internal + kestabilan bootstrap
print("\nk   silhouette  Davies-Bouldin  stabilitas(ARI)")
boot_rng = np.random.default_rng(SEED)
for k in range(2, 7):
    km = KMeans(n_clusters=k, n_init=10, random_state=SEED).fit(Z)
    aris = []
    for _ in range(20):
        idx = np.unique(boot_rng.integers(0, len(Z), len(Z)))
        b = KMeans(n_clusters=k, n_init=10, random_state=int(boot_rng.integers(1_000_000))).fit_predict(Z[idx])
        aris.append(adjusted_rand_score(km.labels_[idx], b))
    print(f"{k:<3} {silhouette_score(Z, km.labels_):<11.3f} {davies_bouldin_score(Z, km.labels_):<15.3f} {np.mean(aris):.3f}")

Untuk tiap k dari 2 sampai 6: melatih k-Means, lalu 20 kali menghitung kestabilan (sampel bootstrap Z[idx] diklaster ulang dan dibandingkan dengan klaster penuh pada titik terambil dengan ARI).

k   silhouette  Davies-Bouldin  stabilitas(ARI)
2   0.391       0.941           0.924
3   0.446       0.815           0.990
4   0.356       1.015           0.907
5   0.315       1.130           0.871
6   0.324       1.048           0.917

Interpretasi. \(k=3\) terbaik pada ketiga ukuran: silhouette 0,446 (tertinggi), Davies-Bouldin 0,815 (terendah), dan kestabilan ARI 0,990 (tertinggi); \(k=2\) (0,924), \(k=4\) (0,907), \(k=5\) (0,871), \(k=6\) (0,917). Kesepakatan ini membuat \(k=3\) pilihan yang kuat, dan sejalan dengan kebutuhan bisnis (tiga kelompok mudah dikelola).

Dengan kata sederhana: Tiga ukuran berbeda sama-sama memilih \(k=3\), sehingga keputusan ini punya dasar kuat dan bukan sekadar satu angka.

Langkah 4: model akhir dan pembanding

project.py
# 4. Model akhir (k=3) dan pembanding algoritma lain
km = KMeans(n_clusters=3, n_init=10, random_state=SEED).fit(Z)
ward = AgglomerativeClustering(n_clusters=3, linkage="ward").fit_predict(Z)
print("\nARI k-Means vs Ward: %.3f | ARI k-Means vs kelompok sebenarnya: %.3f" % (
    adjusted_rand_score(km.labels_, ward), adjusted_rand_score(df["group_true"], km.labels_)))

k-Means dengan \(k=3\) dilatih, lalu dibandingkan dengan Agglomerative Ward (kesepakatan antar-algoritma) dan dengan kelompok sebenarnya (validasi eksternal, hanya tersedia karena data sintetis).

ARI k-Means vs Ward: 0.849 | ARI k-Means vs kelompok sebenarnya: 0.901

Hasil. ARI antara k-Means dan Ward 0,849 (mirip tetapi tidak identik); ARI k-Means terhadap kelompok sebenarnya 0,901.

Langkah 5: profil, nama, dan tindakan

project.py
# 5. Profil dan tindakan
df["cluster"] = km.labels_
prof = df.groupby("cluster")[features].median().round(0)
prof.insert(0, "n", df.groupby("cluster").size())
names = {}
names[prof["monetary"].idxmax()] = "VIP"
names[prof["recency"].idxmax()] = "berisiko pergi"
names[next(c for c in prof.index if c not in names)] = "reguler"
prof["segmen"] = prof.index.map(names)
print("\nProfil (median):\n", prof.to_string())
actions = {"VIP": "program loyalitas dan akses awal", "reguler": "dorong frekuensi dengan promo bundel",
           "berisiko pergi": "kampanye reaktivasi"}
print("\nTindakan yang diusulkan:", {names[c]: actions[names[c]] for c in sorted(names)})

df.groupby("cluster")[features].median() memakai median (bukan rata-rata) agar profil tidak terpengaruh pelanggan ekstrem. Penamaan berbasis aturan: monetary terbesar = "VIP", recency terbesar = "berisiko pergi", sisanya "reguler". Kamus actions memetakan tiap segmen ke tindakan yang diusulkan.

Profil (median):
            n  recency  frequency  monetary          segmen
cluster                                                   
0        452     38.0        7.0     502.0         reguler
1        337    205.0        3.0     279.0  berisiko pergi
2        111     10.0       32.0    1353.0             VIP

Tindakan yang diusulkan: {'reguler': 'dorong frekuensi dengan promo bundel', 'berisiko pergi': 'kampanye reaktivasi', 'VIP': 'program loyalitas dan akses awal'}

Interpretasi. "VIP": 111 pelanggan, recency 10 hari, frekuensi 32, belanja median 1.353 (ribu Rp); "reguler": 452 pelanggan (recency 38, frekuensi 7, belanja 502); "berisiko pergi": 337 pelanggan (recency 205, frekuensi 3, belanja 279). Tindakan yang diusulkan (program loyalitas; promo bundel; kampanye reaktivasi) adalah hipotesis yang harus diuji, misalnya dengan eksperimen A/B.

Dengan kata sederhana: Tiap kelompok kini punya cerita: VIP baru saja beli, sering, dan besar; reguler di tengah; berisiko pergi sudah lama tidak membeli. Dari sinilah tim pemasaran menyusun tindakan berbeda untuk tiap kelompok.

Langkah 6: menyimpan pipeline dan menempatkan pelanggan baru

project.py
# 6. Simpan pipeline (praproses + k-Means + nama segmen) dan tempatkan pelanggan baru
final = Pipeline([("prep", prep), ("km", KMeans(n_clusters=3, n_init=10, random_state=SEED))]).fit(df[features])
path = Path(tempfile.mkdtemp()) / "rfm_segments.joblib"
joblib.dump({"pipeline": final, "names": names}, path)
loaded = joblib.load(path)
new = pd.DataFrame([[5, 25, 4200], [180, 2, 250]], columns=features)
print("\npelanggan baru:", [loaded["names"][int(c)] for c in loaded["pipeline"].predict(new)])
print("hasil identik setelah dimuat:", np.array_equal(final.predict(df[features]), loaded["pipeline"].predict(df[features])))

final adalah pipeline akhir (praproses + k-Means) yang dilatih pada seluruh data; bersama kamus names disimpan dengan joblib. Dua pelanggan baru ditempatkan dengan predict, dan baris terakhir memeriksa bahwa penempatan seluruh data identik setelah model dimuat ulang.

pelanggan baru: ['VIP', 'berisiko pergi']
hasil identik setelah dimuat: True

Hasil. Pelanggan (recency 5, frekuensi 25, belanja 4.200) masuk "VIP"; pelanggan (recency 180, frekuensi 2, belanja 250) masuk "berisiko pergi". Pipeline yang dimuat ulang memberi hasil identik.

Program lengkap (project.py)
project.py
"""Proyek segmentasi pelanggan toko online (data SINTETIS bergaya RFM)."""
import tempfile
from pathlib import Path

import joblib
import numpy as np
import pandas as pd
from sklearn.cluster import AgglomerativeClustering, KMeans
from sklearn.metrics import adjusted_rand_score, davies_bouldin_score, silhouette_score
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import FunctionTransformer, StandardScaler

SEED = 42

# 1. Data: Recency (hari sejak pembelian terakhir), Frequency (jumlah pesanan), Monetary (total belanja, ribu Rp)
rng = np.random.default_rng(SEED)
groups = {"VIP": (0.12, 10, 30, 14.0), "reguler": (0.5, 40, 6, 5.0), "berisiko pergi": (0.38, 220, 2, 3.0)}
rows = []
for name, (share, rec, freq, mon) in groups.items():
    n = int(900 * share)
    rows.append(pd.DataFrame({
        "recency": rng.gamma(4, rec / 4, n).round(0) + 1,
        "frequency": rng.poisson(freq, n) + 1,
        "monetary": rng.lognormal(np.log(mon * 100), 0.5, n).round(0),
        "group_true": name}))
df = pd.concat(rows, ignore_index=True)
# beberapa pelanggan ekstrem (misalnya reseller)
df.loc[rng.choice(len(df), 8, replace=False), "monetary"] *= 15
features = ["recency", "frequency", "monetary"]
print("jumlah pelanggan:", len(df), "| skewness:", df[features].skew().round(2).to_dict())

# 2. Praproses: log1p (data miring dan outlier) + standardisasi, semuanya di dalam pipeline
prep = Pipeline([("log", FunctionTransformer(np.log1p)), ("scale", StandardScaler())])
Z = prep.fit_transform(df[features])
print("skewness setelah log:", pd.DataFrame(np.log1p(df[features])).skew().round(2).to_dict())

# 3. Memilih k: metrik internal + kestabilan bootstrap
print("\nk   silhouette  Davies-Bouldin  stabilitas(ARI)")
boot_rng = np.random.default_rng(SEED)
for k in range(2, 7):
    km = KMeans(n_clusters=k, n_init=10, random_state=SEED).fit(Z)
    aris = []
    for _ in range(20):
        idx = np.unique(boot_rng.integers(0, len(Z), len(Z)))
        b = KMeans(n_clusters=k, n_init=10, random_state=int(boot_rng.integers(1_000_000))).fit_predict(Z[idx])
        aris.append(adjusted_rand_score(km.labels_[idx], b))
    print(f"{k:<3} {silhouette_score(Z, km.labels_):<11.3f} {davies_bouldin_score(Z, km.labels_):<15.3f} {np.mean(aris):.3f}")

# 4. Model akhir (k=3) dan pembanding algoritma lain
km = KMeans(n_clusters=3, n_init=10, random_state=SEED).fit(Z)
ward = AgglomerativeClustering(n_clusters=3, linkage="ward").fit_predict(Z)
print("\nARI k-Means vs Ward: %.3f | ARI k-Means vs kelompok sebenarnya: %.3f" % (
    adjusted_rand_score(km.labels_, ward), adjusted_rand_score(df["group_true"], km.labels_)))

# 5. Profil dan tindakan
df["cluster"] = km.labels_
prof = df.groupby("cluster")[features].median().round(0)
prof.insert(0, "n", df.groupby("cluster").size())
names = {}
names[prof["monetary"].idxmax()] = "VIP"
names[prof["recency"].idxmax()] = "berisiko pergi"
names[next(c for c in prof.index if c not in names)] = "reguler"
prof["segmen"] = prof.index.map(names)
print("\nProfil (median):\n", prof.to_string())
actions = {"VIP": "program loyalitas dan akses awal", "reguler": "dorong frekuensi dengan promo bundel",
           "berisiko pergi": "kampanye reaktivasi"}
print("\nTindakan yang diusulkan:", {names[c]: actions[names[c]] for c in sorted(names)})

# 6. Simpan pipeline (praproses + k-Means + nama segmen) dan tempatkan pelanggan baru
final = Pipeline([("prep", prep), ("km", KMeans(n_clusters=3, n_init=10, random_state=SEED))]).fit(df[features])
path = Path(tempfile.mkdtemp()) / "rfm_segments.joblib"
joblib.dump({"pipeline": final, "names": names}, path)
loaded = joblib.load(path)
new = pd.DataFrame([[5, 25, 4200], [180, 2, 250]], columns=features)
print("\npelanggan baru:", [loaded["names"][int(c)] for c in loaded["pipeline"].predict(new)])
print("hasil identik setelah dimuat:", np.array_equal(final.predict(df[features]), loaded["pipeline"].predict(df[features])))

Refleksi

  • Segmentasi adalah alat bantu keputusan, bukan kebenaran; tinjau ulang secara berkala dengan pemantauan jarak dan proporsi.
  • Data sintetis memudahkan validasi eksternal; pada data nyata, andalkan kestabilan, interpretasi, dan uji tindakan.
  • Pertimbangkan fitur tambahan (kategori produk, kanal), dengan memperhatikan scaling dan pengaruh pada jarak.

Latihan

  1. Tambahkan fitur tenure_days (lama menjadi pelanggan) dan ulangi pemilihan \(k\).
  2. Hapus 8 pelanggan ekstrem dan bandingkan profilnya. Apakah segmennya berubah?
  3. Gunakan RobustScaler alih-alih StandardScaler setelah log. Bagaimana kestabilan berubah?
  4. Tulis ringkasan untuk tim pemasaran: tiga segmen, ciri, dan tindakan masing-masing, beserta keterbatasannya.

Ringkasan

Proyek ini memperlihatkan alur klastering yang benar: transformasi dan scaling di dalam pipeline, pemilihan \(k\) dengan beberapa bukti, profil pada satuan asli, nama segmen sebagai hipotesis, dan penyimpanan pipeline untuk penempatan pelanggan baru.

Selesai dengan bab Klaster. Lanjut ke bab Aturan Asosiasi.