Lewati ke isi

Menyimpan Pipeline Klastering dan Memantau Segmen

Gambaran singkat

Apa ini? Cara menyimpan model klastering supaya dapat dipakai lagi, lalu menempatkan pelanggan baru ke segmen yang sudah ada tanpa melatih ulang.

Analogi

Setelah menyusun rak buku per kategori, Anda mencatat aturan penyusunannya. Saat buku baru datang, Anda cukup melihat catatan itu untuk menaruhnya, tanpa menyusun ulang seluruh rak. Namun jika jenis buku yang datang mulai berbeda, Anda perlu menyadarinya dan memperbarui aturan.

Mengapa penting? Model yang hanya berjalan di notebook tidak berguna bagi bisnis. Selain itu, perilaku pelanggan berubah seiring waktu, sehingga segmen perlu dipantau.

Yang akan dipelajari, berurutan:

  1. Menyimpan pipeline (praproses + k-Means) beserta nama segmen.
  2. Menempatkan pelanggan baru ke segmen.
  3. Mendeteksi pelanggan yang tidak cocok dengan segmen mana pun (jauh dari semua pusat).
  4. Memantau proporsi segmen untuk melihat pergeseran.

Istilah awal:

Istilah Arti sederhana
Pipeline Rangkaian langkah (praproses lalu model) yang dijalankan sebagai satu kesatuan
joblib Pustaka untuk menyimpan objek Python ke berkas
Pergeseran (drift) Pola data baru mulai berbeda dari data saat pelatihan

Tujuan pembelajaran

  • Menyimpan pipeline klastering (praproses + k-Means) beserta nama segmen.
  • Menempatkan pelanggan baru ke segmen tanpa melatih ulang.
  • Mendeteksi pelanggan yang tidak cocok dengan segmen mana pun dan memantau pergeseran segmen.

Prasyarat

Dasar joblib dan keamanan berkas model dibahas di Klasifikasi: Simpan, Deploy, Monitor.

Yang khas untuk klastering

  • Tidak ada "prediksi benar", tetapi ada penempatan (predict): titik baru masuk ke pusat terdekat memakai praproses dan pusat dari data latih.
  • Nomor klaster tidak stabil antar-pelatihan. Bila model dilatih ulang, klaster "0" bisa menjadi segmen berbeda. Simpan nama segmen bersama pipeline dan petakan ulang dari profil.
  • Pelanggan di luar pola. Titik jauh dari semua pusat tetap ditempatkan ke pusat terdekat; periksa jaraknya.
  • Pemantauan menggunakan proporsi segmen dan jarak ke pusat, bukan akurasi.

Implementasi langkah demi langkah

Memakai data pelanggan sintetis (penjelasan). Batch "bergeser" adalah simulasi sintetis: nilai recency_days dikalikan 3 dan visits_per_month dikalikan 0,5, sebagai tiruan pelanggan yang makin jarang kembali. Program examples/clustering/clustering_saving.py; program lengkap ada di akhir bagian ini.

Langkah 1: melatih pipeline

clustering_saving.py
SEED = 42
features = ["annual_spend", "visits_per_month", "avg_basket", "recency_days", "age"]
skewed = ["annual_spend", "recency_days"]

train = make_customer_segments(n=600, seed=42)
pipe = Pipeline([
    ("prep", ColumnTransformer([("log", FunctionTransformer(np.log1p), skewed)], remainder="passthrough")),
    ("scale", StandardScaler()),
    ("km", KMeans(n_clusters=4, n_init=10, random_state=SEED)),
]).fit(train[features])

Pipeline sama dengan pelajaran profil: transformasi log pada fitur miring, standardisasi, lalu k-Means (4 klaster), dilatih pada 600 pelanggan.

Langkah 2: menamai segmen dan menyimpan bundel

Konsep. Nomor klaster tidak stabil antar-pelatihan (klaster "0" hari ini bisa menjadi segmen lain setelah dilatih ulang). Karena itu nama segmen disimpan bersama pipeline sebagai satu bundel.

clustering_saving.py
# 1. Nama segmen berdasarkan pusat klaster (disimpan bersama pipeline agar tidak berubah)
centers = pd.DataFrame(pipe[:-1].named_steps["scale"].inverse_transform(pipe["km"].cluster_centers_),
                       columns=skewed + [c for c in features if c not in skewed])
names = {}
left = set(range(4))
for rule, label in [(lambda i: centers.loc[i, "recency_days"], "tidak aktif"),
                    (lambda i: centers.loc[i, "annual_spend"], "loyal"),
                    (lambda i: centers.loc[i, "visits_per_month"], "pemburu diskon")]:
    pick = max(left, key=rule)
    names[pick] = label
    left.discard(pick)
names[left.pop()] = "musiman"

path = Path(tempfile.mkdtemp()) / "segment_model.joblib"
joblib.dump({"pipeline": pipe, "names": names, "features": features}, path)
bundle = joblib.load(path)
print("nama segmen tersimpan:", {int(k): v for k, v in sorted(bundle["names"].items())})
Kode Penjelasan
pipe["km"].cluster_centers_ Pusat klaster (pada skala terstandardisasi); pipe["km"] mengambil langkah km menurut namanya.
pipe[:-1].named_steps["scale"].inverse_transform(...) Mengembalikan pusat ke skala sebelum standardisasi (tetapi masih dalam log untuk dua kolom miring). Kolom diberi nama dengan urutan yang sama seperti keluaran ColumnTransformer (kolom log dulu).
max(left, key=rule) Memilih nomor klaster dengan nilai terbesar menurut aturan rule (fungsi lambda), dari klaster yang tersisa.
joblib.dump({"pipeline": pipe, "names": names, "features": features}, path) Menyimpan kamus: pipeline, nama segmen, dan daftar fitur.
joblib.load(path) Memuat bundel; bundle["names"] kembali berisi nama segmen.
nama segmen tersimpan: {0: 'musiman', 1: 'loyal', 2: 'tidak aktif', 3: 'pemburu diskon'}

Hasil. Nama segmen tersimpan: 0 musiman, 1 loyal, 2 tidak aktif, 3 pemburu diskon.

Langkah 3: menempatkan pelanggan baru

clustering_saving.py
# 2. Menempatkan pelanggan BARU: tidak ada fit ulang; praproses memakai parameter data latih
new = pd.DataFrame([[35.0, 8.0, 250.0, 7.0, 36], [3.0, 0.5, 100.0, 300.0, 50], [14.0, 1.0, 450.0, 60.0, 47]],
                   columns=features)
assigned = bundle["pipeline"].predict(new[features])
print("pelanggan baru ->", [bundle["names"][int(c)] for c in assigned])

new adalah tabel tiga pelanggan baru dengan kolom yang sama seperti data latih. bundle["pipeline"].predict(new[features]) menerapkan log dan standardisasi dengan parameter dari data latih, lalu menempatkan tiap pelanggan ke pusat klaster terdekat; tidak ada pelatihan ulang. bundle["names"][int(c)] mengubah nomor klaster menjadi nama.

pelanggan baru -> ['loyal', 'tidak aktif', 'musiman']

Hasil. Tiga pelanggan ditempatkan ke "loyal", "tidak aktif", dan "musiman".

Langkah 4: mendeteksi pelanggan yang tidak cocok dengan segmen mana pun

Konsep. Pelanggan yang sangat berbeda tetap ditempatkan ke pusat terdekat. Jarak ke pusat terdekat menunjukkan seberapa "asing" ia bagi semua segmen.

clustering_saving.py
# 3. Deteksi pelanggan yang tidak cocok dengan segmen mana pun: jarak ke pusat terdekat
train_dist = bundle["pipeline"].transform(train[features]).min(axis=1)
limit = np.percentile(train_dist, 99)
odd = pd.DataFrame([[400.0, 20.0, 5000.0, 1.0, 30]], columns=features)  # nilai ekstrem buatan
d_new = bundle["pipeline"].transform(pd.concat([new, odd]).reset_index(drop=True)[features]).min(axis=1)
print("\nbatas jarak (persentil 99 data latih): %.2f" % limit)
print("jarak pelanggan baru ke pusat terdekat:", d_new.round(2).tolist(), "| melebihi batas:", (d_new > limit).tolist())
Kode Penjelasan
bundle["pipeline"].transform(...) Untuk pipeline yang berakhir pada k-Means, transform mengembalikan jarak ke tiap pusat klaster (satu kolom per klaster).
.min(axis=1) Jarak ke pusat terdekat untuk tiap pelanggan (per baris).
np.percentile(train_dist, 99) Batas: persentil ke-99 jarak pada data latih. Pelanggan dengan jarak lebih besar dianggap tidak lazim.
odd = pd.DataFrame([[400.0, 20.0, ...]]) Satu pelanggan ekstrem buatan untuk menguji deteksi.
batas jarak (persentil 99 data latih): 2.37
jarak pelanggan baru ke pusat terdekat: [0.27, 0.8, 0.22, 29.99] | melebihi batas: [False, False, False, True]

Interpretasi. Batas jarak 2,37. Pelanggan baru normal berjarak 0,27; 0,80; dan 0,22 dari pusat terdekat, sedangkan pelanggan ekstrem buatan berjarak 29,99 dan ditandai melebihi batas: tetap masuk ke segmen terdekat tetapi perlu ditinjau.

Dengan kata sederhana: Pelanggan baru selalu dimasukkan ke segmen terdekat, tetapi yang jaraknya sangat jauh dari semua pusat (di atas batas) ditandai agar diperiksa manusia. Model tidak boleh dipercaya begitu saja untuk data yang tidak mirip data latihnya.

Langkah 5: memantau proporsi segmen dan jarak

clustering_saving.py
# 4. Pemantauan: porsi segmen pada batch baru vs data latih
print("\nporsi segmen (%)  latih | batch sama distribusi | batch SINTETIS bergeser")
same = make_customer_segments(n=600, seed=7)
shifted = make_customer_segments(n=600, seed=8)
shifted["recency_days"] = shifted["recency_days"] * 3   # simulasi: pelanggan makin jarang kembali
shifted["visits_per_month"] = shifted["visits_per_month"] * 0.5


def share(df):
    return pd.Series(bundle["pipeline"].predict(df[features])).map(bundle["names"]).value_counts(normalize=True) * 100


table = pd.DataFrame({"latih": share(train), "batch_sama": share(same), "batch_bergeser": share(shifted)}).fillna(0).round(0)
print(table.to_string())
for col in ["batch_sama", "batch_bergeser"]:
    print(f"selisih porsi terbesar {col:<15}: {(table[col] - table['latih']).abs().max():.0f} poin persen")

# 5. Sinyal lain: rata-rata jarak ke pusat terdekat (makin besar = data makin "jauh" dari segmen yang dikenal)
for name, batch in [("latih", train), ("batch_sama", same), ("batch_bergeser", shifted)]:
    print(f"rata-rata jarak ke pusat terdekat {name:<15}: {bundle['pipeline'].transform(batch[features]).min(axis=1).mean():.2f}")
Kode Penjelasan
make_customer_segments(n=600, seed=7) Batch baru dengan distribusi yang sama (seed berbeda).
shifted[...] * 3, * 0.5 Batch dengan perilaku bergeser (simulasi).
def share(df): ... Menempatkan batch ke segmen, memberi nama, lalu menghitung proporsi tiap segmen (value_counts(normalize=True) * 100).
pd.DataFrame({...}).fillna(0) Menggabungkan proporsi tiga kelompok data; segmen yang tidak muncul diisi 0.
porsi segmen (%)  latih | batch sama distribusi | batch SINTETIS bergeser
                latih  batch_sama  batch_bergeser
loyal            20.0        20.0            21.0
musiman          24.0        24.0            28.0
pemburu diskon   31.0        28.0            24.0
tidak aktif      25.0        28.0            28.0
selisih porsi terbesar batch_sama     : 3 poin persen
selisih porsi terbesar batch_bergeser : 7 poin persen
rata-rata jarak ke pusat terdekat latih          : 1.13
rata-rata jarak ke pusat terdekat batch_sama     : 1.12
rata-rata jarak ke pusat terdekat batch_bergeser : 1.48

Interpretasi.

  • Proporsi segmen: batch dengan distribusi sama memiliki selisih proporsi terbesar 3 poin persen terhadap data latih; batch bergeser 7 poin persen. Sinyal ini lemah: pergeseran besar pada fitur hanya sedikit mengubah proporsi karena titik tetap jatuh ke segmen terdekat.
  • Jarak ke pusat terdekat lebih sensitif: rata-rata 1,13 (latih), 1,12 (batch sama), dan 1,48 (batch bergeser). Kenaikan itu menandakan data makin tidak cocok dengan segmen yang dikenal, sinyal untuk meninjau dan melatih ulang model.
Program lengkap (clustering_saving.py)
clustering_saving.py
import tempfile
from pathlib import Path

import joblib
import numpy as np
import pandas as pd
from sklearn.cluster import KMeans
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import FunctionTransformer, StandardScaler

from segment_data import make_customer_segments

SEED = 42
features = ["annual_spend", "visits_per_month", "avg_basket", "recency_days", "age"]
skewed = ["annual_spend", "recency_days"]

train = make_customer_segments(n=600, seed=42)
pipe = Pipeline([
    ("prep", ColumnTransformer([("log", FunctionTransformer(np.log1p), skewed)], remainder="passthrough")),
    ("scale", StandardScaler()),
    ("km", KMeans(n_clusters=4, n_init=10, random_state=SEED)),
]).fit(train[features])

# 1. Nama segmen berdasarkan pusat klaster (disimpan bersama pipeline agar tidak berubah)
centers = pd.DataFrame(pipe[:-1].named_steps["scale"].inverse_transform(pipe["km"].cluster_centers_),
                       columns=skewed + [c for c in features if c not in skewed])
names = {}
left = set(range(4))
for rule, label in [(lambda i: centers.loc[i, "recency_days"], "tidak aktif"),
                    (lambda i: centers.loc[i, "annual_spend"], "loyal"),
                    (lambda i: centers.loc[i, "visits_per_month"], "pemburu diskon")]:
    pick = max(left, key=rule)
    names[pick] = label
    left.discard(pick)
names[left.pop()] = "musiman"

path = Path(tempfile.mkdtemp()) / "segment_model.joblib"
joblib.dump({"pipeline": pipe, "names": names, "features": features}, path)
bundle = joblib.load(path)
print("nama segmen tersimpan:", {int(k): v for k, v in sorted(bundle["names"].items())})

# 2. Menempatkan pelanggan BARU: tidak ada fit ulang; praproses memakai parameter data latih
new = pd.DataFrame([[35.0, 8.0, 250.0, 7.0, 36], [3.0, 0.5, 100.0, 300.0, 50], [14.0, 1.0, 450.0, 60.0, 47]],
                   columns=features)
assigned = bundle["pipeline"].predict(new[features])
print("pelanggan baru ->", [bundle["names"][int(c)] for c in assigned])

# 3. Deteksi pelanggan yang tidak cocok dengan segmen mana pun: jarak ke pusat terdekat
train_dist = bundle["pipeline"].transform(train[features]).min(axis=1)
limit = np.percentile(train_dist, 99)
odd = pd.DataFrame([[400.0, 20.0, 5000.0, 1.0, 30]], columns=features)  # nilai ekstrem buatan
d_new = bundle["pipeline"].transform(pd.concat([new, odd]).reset_index(drop=True)[features]).min(axis=1)
print("\nbatas jarak (persentil 99 data latih): %.2f" % limit)
print("jarak pelanggan baru ke pusat terdekat:", d_new.round(2).tolist(), "| melebihi batas:", (d_new > limit).tolist())

# 4. Pemantauan: porsi segmen pada batch baru vs data latih
print("\nporsi segmen (%)  latih | batch sama distribusi | batch SINTETIS bergeser")
same = make_customer_segments(n=600, seed=7)
shifted = make_customer_segments(n=600, seed=8)
shifted["recency_days"] = shifted["recency_days"] * 3   # simulasi: pelanggan makin jarang kembali
shifted["visits_per_month"] = shifted["visits_per_month"] * 0.5


def share(df):
    return pd.Series(bundle["pipeline"].predict(df[features])).map(bundle["names"]).value_counts(normalize=True) * 100


table = pd.DataFrame({"latih": share(train), "batch_sama": share(same), "batch_bergeser": share(shifted)}).fillna(0).round(0)
print(table.to_string())
for col in ["batch_sama", "batch_bergeser"]:
    print(f"selisih porsi terbesar {col:<15}: {(table[col] - table['latih']).abs().max():.0f} poin persen")

# 5. Sinyal lain: rata-rata jarak ke pusat terdekat (makin besar = data makin "jauh" dari segmen yang dikenal)
for name, batch in [("latih", train), ("batch_sama", same), ("batch_bergeser", shifted)]:
    print(f"rata-rata jarak ke pusat terdekat {name:<15}: {bundle['pipeline'].transform(batch[features]).min(axis=1).mean():.2f}")

Kapan melatih ulang?

  • Jarak rata-rata ke pusat naik jelas dibanding periode latih.
  • Proporsi segmen berubah besar atau muncul kelompok baru.
  • Kebutuhan bisnis berubah (fitur baru, definisi segmen baru).
  • Setelah melatih ulang, petakan ulang nama segmen dan bandingkan dengan segmentasi lama (ARI) sebelum menggantinya.

Kesalahan umum

Hindari

  • Mengandalkan nomor klaster antar-versi model.
  • Melatih ulang praproses pada data baru saat hanya ingin menempatkan.
  • Mengabaikan pelanggan yang jauh dari semua pusat.
  • Memantau hanya proporsi segmen.
  • Memuat berkas model dari sumber tidak tepercaya.

Latihan

  1. Hitung ARI antara penempatan model lama dan model yang dilatih ulang pada batch bergeser.
  2. Tentukan ambang jarak rata-rata yang memicu pelatihan ulang dan alasannya.
  3. Tambahkan label segmen dan jarak ke keluaran penempatan pelanggan baru.

Ringkasan

Simpan pipeline lengkap dengan nama segmen, tempatkan pelanggan baru tanpa fit ulang, tandai pelanggan yang jauh dari segmen, dan pantau jarak ke pusat selain proporsi segmen.

Berikutnya: Proyek Segmentasi Pelanggan.