Lewati ke isi

Konsep Klastering dan Persiapan Data

Gambaran singkat

Apa ini? Pelajaran pertama: memahami apa itu klastering dan menyiapkan data sebelum dikelompokkan.

Analogi

Seorang guru baru menerima 600 siswa yang belum dikenal. Ia mengelompokkan siswa menurut kebiasaan mereka tanpa daftar kelompok yang sudah jadi. Setelah itu ia bertanya: apakah kelompok ini masuk akal dan berguna? Pertanyaan itu sama dengan pertanyaan pada klastering.

Mengapa penting? Klastering tidak punya kunci jawaban, jadi kita tidak bisa menghitung "berapa persen benar". Kita perlu cara lain untuk menilai hasilnya, dan data harus diperiksa lebih dulu agar hasilnya tidak menyesatkan.

Yang akan dipelajari, berurutan:

  1. Arti klastering dan bedanya dengan klasifikasi.
  2. Cara menilai hasil tanpa label (pengganti data uji).
  3. Memeriksa data (EDA) untuk melihat ukuran, skala, dan kemiringan tiap fitur.

Istilah awal:

Istilah Arti sederhana
Klaster (cluster) Satu kelompok data yang mirip
Fitur (feature) Satu kolom informasi, misalnya umur atau total belanja
Tanpa label (unsupervised) Data tidak disertai jawaban benar
EDA Memeriksa data lebih dulu sebelum dianalisis

Tujuan pembelajaran

  • Menjelaskan unsupervised learning dan tujuan klastering.
  • Menjelaskan mengapa prosedur train/test terawasi tidak berlaku langsung pada klastering, dan apa gantinya.
  • Melakukan EDA dan menentukan praproses untuk data klastering.

Konsep

Klastering mengelompokkan data berdasarkan kemiripan tanpa label. Tidak ada jawaban benar yang tersedia sebagai acuan; "kelompok" adalah struktur yang kita temukan, bukan kebenaran yang diprediksi.

Klasifikasi Klastering
Label Ada Tidak ada
Tujuan Memprediksi kelas Menemukan struktur dan menjelaskannya
Evaluasi Skor pada data uji berlabel Indeks internal, kestabilan, interpretasi (validasi eksternal bila ada acuan)
Hasil Satu jawaban benar per sampel Bergantung pada algoritma, parameter, dan skala

Penggunaan umum: segmentasi pelanggan, pengelompokan dokumen, deteksi pola, kompresi data, dan eksplorasi awal.

Mengapa tidak ada "data uji berlabel"?

Pada klasifikasi, data uji punya jawaban benar sehingga kita bisa menghitung berapa tebakan yang salah. Pada klastering tidak ada jawaban benar, jadi tidak ada yang langsung bisa disebut "benar" atau "salah". Sebagai gantinya, kita menilai hasil dari empat sisi:

  1. Kestabilan: apakah struktur yang sama ditemukan pada data lain atau sampel berbeda? Praproses tetap dipelajari dari data latih, lalu data baru ditempatkan ke klaster yang ada.
  2. Kualitas internal: seberapa padat dan terpisah klasternya (silhouette, Davies-Bouldin).
  3. Kegunaan: apakah klaster dapat ditafsirkan dan dimanfaatkan?
  4. Validasi eksternal (hanya jika ada label acuan): kecocokan dengan label yang diketahui (ARI, NMI).

Dataset: pelanggan sintetis

Data sintetis (dibangkitkan program dengan seed tetap): 600 pelanggan dengan lima fitur numerik annual_spend (juta Rp/tahun), visits_per_month, avg_basket (ribu Rp), recency_days, dan age. Di balik data ada empat kelompok tersembunyi (segment_true: pemburu diskon, loyal, musiman, tidak aktif) yang hanya dipakai untuk validasi eksternal dalam materi ini; pada masalah nyata kelompok seperti itu tidak diketahui. Karena sintetis, hasil tidak menjelaskan pelanggan nyata.

Kode pembangkit data (segment_data.py)
segment_data.py
"""Data pelanggan SINTETIS untuk latihan segmentasi (dibangkitkan dengan seed tetap).

Ada empat kelompok tersembunyi (`segment_true`). Kolom ini HANYA untuk validasi eksternal
dalam materi; pada masalah nyata kelompok semacam itu tidak diketahui.
"""
import numpy as np
import pandas as pd

SEGMENTS = {
    # nama: (spend juta Rp/tahun, kunjungan/bulan, keranjang ribu Rp, recency hari, usia)
    "pemburu_diskon": (6, 9, 90, 15, 24),
    "loyal": (30, 8, 250, 10, 38),
    "musiman": (14, 1.5, 420, 70, 45),
    "tidak_aktif": (3, 0.8, 110, 220, 40),
}


def make_customer_segments(n=600, seed=42):
    rng = np.random.default_rng(seed)
    names = list(SEGMENTS)
    labels = rng.choice(names, n, p=[0.3, 0.2, 0.25, 0.25])
    rows = []
    for name in labels:
        spend, visits, basket, recency, age = SEGMENTS[name]
        rows.append([
            rng.lognormal(np.log(spend), 0.45),
            max(rng.normal(visits, visits * 0.4), 0.1),
            max(rng.normal(basket, basket * 0.35), 10),
            max(rng.normal(recency, recency * 0.45), 1),
            np.clip(rng.normal(age, 9), 18, 75),
        ])
    df = pd.DataFrame(rows, columns=["annual_spend", "visits_per_month", "avg_basket", "recency_days", "age"])
    df["segment_true"] = labels
    return df.round(1)

Implementasi langkah demi langkah

Program examples/clustering/concepts_data.py; program lengkap ada di akhir bagian ini.

Langkah 1: EDA data pelanggan

Tujuan. Mengenal ukuran, kualitas, dan skala fitur sebelum mengklaster.

concepts_data.py
import numpy as np
from sklearn.cluster import KMeans
from sklearn.metrics import adjusted_rand_score
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

from segment_data import make_customer_segments

SEED = 42
df = make_customer_segments()
features = ["annual_spend", "visits_per_month", "avg_basket", "recency_days", "age"]
X = df[features]

# 1. EDA: ukuran, data hilang, rentang nilai (skala sangat berbeda!)
print("Ukuran:", X.shape, "| hilang:", int(X.isna().sum().sum()), "| duplikat:", int(X.duplicated().sum()))
print(X.describe().T[["mean", "std", "min", "max"]].round(1).to_string())
print("skewness annual_spend: %.2f" % X["annual_spend"].skew())
Kode Penjelasan
from segment_data import make_customer_segments Mengimpor pembangkit data sintetis dari berkas segment_data.py di folder yang sama.
X = df[features] Hanya lima kolom fitur untuk klastering. Kolom segment_true sengaja tidak dimasukkan ke X.
X.describe().T[["mean", "std", "min", "max"]] Ringkasan statistik per fitur; .T memutar tabel agar satu fitur per baris.
X["annual_spend"].skew() Kemiringan distribusi belanja.
Ukuran: (600, 5) | hilang: 0 | duplikat: 0
                   mean    std   min    max
annual_spend       13.3   13.3   0.9  101.3
visits_per_month    4.9    4.5   0.1   18.8
avg_basket        206.8  156.2  10.0  833.7
recency_days       78.8   99.3   1.0  430.0
age                36.7   11.8  18.0   73.6
skewness annual_spend: 2.08

Interpretasi. 600 baris, tanpa data hilang atau duplikat. Skala sangat berbeda: avg_basket rata-rata 207 (maksimum 834) sedangkan visits_per_month rata-rata 4,9; recency_days bersimpangan baku 99, age 11,8. Algoritma berbasis jarak akan didominasi fitur berskala besar, sehingga scaling wajib (lihat lesson berikutnya). annual_spend miring ke kanan (skewness 2,08, maksimum 101 vs rata-rata 13); transformasi log membantu (dipakai pada profil klaster).

Dengan kata sederhana: Data bersih dan cukup, tetapi satuan tiap kolom sangat berbeda (ratusan vs satuan). Itu sebabnya scaling perlu, dan fitur belanja yang miring perlu ditransformasi log.

Langkah 2: kelompok sebenarnya (hanya untuk validasi eksternal)

concepts_data.py
# 2. Kelompok tersembunyi hanya untuk validasi eksternal pada materi ini
print("\nUkuran kelompok sebenarnya:", df["segment_true"].value_counts().sort_index().to_dict())
Ukuran kelompok sebenarnya: {'loyal': 119, 'musiman': 150, 'pemburu_diskon': 181, 'tidak_aktif': 150}

Kolom segment_true menyimpan kelompok yang dipakai pembangkit data: pemburu diskon (181), loyal (119), musiman (150), dan tidak aktif (150). Ini tidak tersedia pada masalah nyata; di sini dipakai hanya untuk memeriksa hasil klastering.

Langkah 3: apa pengganti "data uji" pada klastering?

Konsep. Tanpa label tidak ada galat yang bisa dihitung pada data uji. Yang dapat diuji adalah kestabilan: apakah struktur yang sama muncul pada data lain? Caranya: pelajari praproses dan klaster dari data latih (70%), lalu bandingkan dua cara mengelompokkan 30% data sisanya.

concepts_data.py
# 3. Mengapa tidak ada "data uji berlabel": kita tidak punya jawaban benar.
#    Yang dapat diuji adalah KESTABILAN: apakah struktur yang sama ditemukan pada data lain?
train_idx, test_idx = train_test_split(np.arange(len(df)), test_size=0.3, random_state=SEED)
scaler = StandardScaler().fit(X.iloc[train_idx])            # praproses dipelajari dari data latih
km = KMeans(n_clusters=4, n_init=10, random_state=SEED).fit(scaler.transform(X.iloc[train_idx]))

assigned = km.predict(scaler.transform(X.iloc[test_idx]))   # data uji ditempatkan ke klaster latih
own = KMeans(n_clusters=4, n_init=10, random_state=SEED).fit_predict(
    StandardScaler().fit_transform(X.iloc[test_idx]))       # data uji diklaster sendiri
print("\nKestabilan (ARI antara dua cara mengelompokkan data uji): %.3f" % adjusted_rand_score(assigned, own))
Kode Penjelasan
train_test_split(np.arange(len(df)), test_size=0.3, ...) Membagi nomor baris (bukan data) menjadi indeks latih dan uji; indeks dipakai untuk memilih baris dengan iloc.
StandardScaler().fit(X.iloc[train_idx]) Scaler belajar hanya dari data latih (rata-rata dan simpangan baku).
KMeans(n_clusters=4, n_init=10, random_state=SEED).fit(...) k-Means dengan 4 klaster dilatih pada data latih terskala; n_init=10 mengulang inisialisasi 10 kali dan memilih yang terbaik.
km.predict(scaler.transform(X.iloc[test_idx])) Penempatan: data uji diubah dengan scaler latih lalu ditempatkan ke pusat klaster terdekat (tanpa melatih ulang).
fit_predict(StandardScaler().fit_transform(X.iloc[test_idx])) Cara kedua: data uji diklaster sendiri dengan scaler dan k-Means barunya.
adjusted_rand_score(a, b) ARI: seberapa mirip dua pengelompokan (1 = identik, ≈ 0 = acak); nomor klasternya tidak perlu sama.
Kestabilan (ARI antara dua cara mengelompokkan data uji): 0.957

Interpretasi. ARI kestabilan 0,957: model dari data latih dan klastering mandiri pada data uji hampir sama, sehingga struktur yang ditemukan bukan kebetulan satu sampel.

Dengan kata sederhana: Nilai mendekati 1 berarti dua cara mengelompokkan menghasilkan pembagian hampir sama, jadi kelompok yang ditemukan bukan kebetulan.

Langkah 4: validasi eksternal

concepts_data.py
# 4. Validasi eksternal (hanya mungkin karena data sintetis ini punya kelompok sebenarnya)
print("ARI terhadap kelompok sebenarnya (data uji, penempatan dari model latih): %.3f"
      % adjusted_rand_score(df["segment_true"].iloc[test_idx], assigned))
ARI terhadap kelompok sebenarnya (data uji, penempatan dari model latih): 0.849

Interpretasi. ARI penempatan data uji terhadap kelompok sebenarnya 0,849 (hanya mungkin karena data sintetis). Struktur cukup jelas tetapi tidak sempurna; tiap kelompok sengaja dibuat saling tumpang tindih.

Dengan kata sederhana: Kelompok baru cocok dengan kelompok sebenarnya di sekitar 85%. Cukup baik, tetapi tidak sempurna karena kelompoknya memang sengaja dibuat saling tumpang tindih.

Program lengkap (concepts_data.py)
concepts_data.py
import numpy as np
from sklearn.cluster import KMeans
from sklearn.metrics import adjusted_rand_score
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

from segment_data import make_customer_segments

SEED = 42
df = make_customer_segments()
features = ["annual_spend", "visits_per_month", "avg_basket", "recency_days", "age"]
X = df[features]

# 1. EDA: ukuran, data hilang, rentang nilai (skala sangat berbeda!)
print("Ukuran:", X.shape, "| hilang:", int(X.isna().sum().sum()), "| duplikat:", int(X.duplicated().sum()))
print(X.describe().T[["mean", "std", "min", "max"]].round(1).to_string())
print("skewness annual_spend: %.2f" % X["annual_spend"].skew())

# 2. Kelompok tersembunyi hanya untuk validasi eksternal pada materi ini
print("\nUkuran kelompok sebenarnya:", df["segment_true"].value_counts().sort_index().to_dict())

# 3. Mengapa tidak ada "data uji berlabel": kita tidak punya jawaban benar.
#    Yang dapat diuji adalah KESTABILAN: apakah struktur yang sama ditemukan pada data lain?
train_idx, test_idx = train_test_split(np.arange(len(df)), test_size=0.3, random_state=SEED)
scaler = StandardScaler().fit(X.iloc[train_idx])            # praproses dipelajari dari data latih
km = KMeans(n_clusters=4, n_init=10, random_state=SEED).fit(scaler.transform(X.iloc[train_idx]))

assigned = km.predict(scaler.transform(X.iloc[test_idx]))   # data uji ditempatkan ke klaster latih
own = KMeans(n_clusters=4, n_init=10, random_state=SEED).fit_predict(
    StandardScaler().fit_transform(X.iloc[test_idx]))       # data uji diklaster sendiri
print("\nKestabilan (ARI antara dua cara mengelompokkan data uji): %.3f" % adjusted_rand_score(assigned, own))

# 4. Validasi eksternal (hanya mungkin karena data sintetis ini punya kelompok sebenarnya)
print("ARI terhadap kelompok sebenarnya (data uji, penempatan dari model latih): %.3f"
      % adjusted_rand_score(df["segment_true"].iloc[test_idx], assigned))

Kesalahan umum

Hindari

  • Mengklaster tanpa scaling pada fitur berskala berbeda.
  • Menganggap klaster sebagai "kebenaran" dan bukan sebagai gambaran data.
  • Memilih jumlah klaster hanya dari satu metrik.
  • Meng-fit praproses pada seluruh data sebelum memeriksa kestabilan.
  • Mengklaster data berisi banyak fitur tidak relevan.

Latihan

  1. Ubah n_clusters menjadi 3 dan 5 pada bagian kestabilan. Bagaimana ARI kestabilannya?
  2. Hapus fitur age dan ulangi. Apakah ARI terhadap kelompok sebenarnya berubah?
  3. Mengapa pada klastering kita tetap boleh membagi data? Jelaskan apa tujuannya dibanding pada klasifikasi.

Ringkasan

Klastering tanpa label tidak memiliki data uji berlabel; kualitasnya dinilai dengan indeks internal, kestabilan, interpretasi, dan (bila ada) validasi eksternal. Siapkan data dengan EDA dan scaling, dan simpan praproses di dalam pipeline.

Berikutnya: Scaling dan Ukuran Jarak.