Lewati ke isi

Proyek: Prediksi Churn Pelanggan End-to-End

Gambaran singkat

Apa ini? Proyek penutup yang merangkai seluruh alur klasifikasi, dari data mentah sampai model siap dipakai.

Analogi

Seperti ujian praktik mengemudi setelah belajar teori: semua bagian dijalankan berurutan.

Mengapa penting? Di dunia nyata langkah-langkah itu saling memengaruhi. Proyek ini memperlihatkan keputusan di satu langkah berdampak pada langkah berikutnya.

Yang akan dipelajari, berurutan:

  1. Pembersihan data dan pembagian data uji.
  2. Praproses di dalam ColumnTransformer.
  3. Membandingkan baseline dan beberapa model.
  4. Menyetel model, memilih ambang, dan evaluasi akhir sekali pada data uji.
  5. Menyimpan model.

Istilah awal:

Istilah Arti sederhana
Churn Pelanggan yang berhenti berlangganan
ColumnTransformer Alat menerapkan praproses berbeda pada kolom berbeda
Evaluasi akhir Pengujian sekali pada data uji yang tidak pernah disentuh

Tujuan proyek

Menerapkan seluruh alur klasifikasi pada data tabular bertipe campuran: pembagian data, pipeline, baseline, perbandingan model, optimasi ringan, pemilihan ambang, evaluasi akhir, dan penyimpanan model.

Masalah dan data

Masalah: memprediksi pelanggan yang akan berhenti berlangganan (churn = 1) agar tim retensi dapat menghubungi mereka lebih dulu. Menghubungi pelanggan yang sebenarnya tidak akan berhenti punya biaya kecil; melewatkan pelanggan yang akan berhenti kehilangan pendapatan. Karena itu recall kelas churn penting, tetapi tidak boleh membuat precision runtuh.

Data: data pelanggan sintetis dari customer_data.py (lihat pandas), berisi nilai hilang, outlier, dan duplikat. Karena sintetis, hasilnya tidak menjelaskan pelanggan nyata. Skrip proyek mengimpor pembangkit data dari examples/fundamentals/.

Alur kerja

  1. Hapus duplikat dan pisahkan data uji (stratified).
  2. Praproses di dalam ColumnTransformer (imputasi, scaling, one-hot).
  3. Bandingkan baseline dan empat model dengan validasi silang berulang (ROC-AUC, PR-AUC, F1).
  4. Setel hyperparameter kandidat terbaik.
  5. Pilih ambang dari prediksi validasi silang pada data latih.
  6. Evaluasi akhir sekali pada data uji; simpan model.

Implementasi langkah demi langkah

Program examples/classification/project.py mengimpor pembangkit data dari examples/fundamentals/ (lihat pandas). Konsep di tiap langkah sudah dibahas di pelajaran sebelumnya; di sini fokusnya pada bagaimana langkah-langkah itu disatukan dan keputusan yang diambil. Program lengkap ada di akhir bagian ini.

Langkah 1: data, pembersihan duplikat, dan data uji

project.py
# Pembangkit data ada di examples/fundamentals/ (lihat lesson pandas)
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "fundamentals"))
from customer_data import make_customer_data  # noqa: E402

SEED = 42

# 1. Data, pembersihan duplikat, dan pembagian data
df = make_customer_data().drop_duplicates().reset_index(drop=True)
X, y = df.drop(columns="churn"), df["churn"]
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, stratify=y, random_state=SEED
)
print("latih:", X_train.shape, "| uji:", X_test.shape, "| churn latih: %.3f" % y_train.mean())
Kode Penjelasan
sys.path.insert(0, ...) dan from customer_data import ... Menambahkan folder fundamentals ke jalur pencarian modul Python agar customer_data.py dapat diimpor dari folder lain.
make_customer_data().drop_duplicates().reset_index(drop=True) Data sintetis lalu buang 5 baris duplikat (langkah tanpa parameter terlatih, aman sebelum split).
X, y = df.drop(columns="churn"), df["churn"] Memisahkan fitur dan target.
train_test_split(..., test_size=0.2, stratify=y, ...) Menyisihkan data uji berstrata.
latih: (480, 7) | uji: (120, 7) | churn latih: 0.338

Hasil. 480 data latih dan 120 data uji, dengan 7 kolom fitur; proporsi churn pada data latih 0,338.

Langkah 2: praproses di dalam pipeline

Konsep. Data ini campuran angka dan teks, dan ada nilai hilang, sehingga tiap model memerlukan praproses yang sama. Agar tidak mengulang kode, praproses dibungkus dalam sebuah fungsi yang mengembalikan pipeline lengkap untuk model apa pun.

project.py
# 2. Praproses (di dalam pipeline agar tidak bocor)
numeric = ["age", "tenure_months", "income", "n_orders", "avg_spend"]
categorical = ["city", "plan"]


def make_pipeline_with(clf, scale=True):
    num_steps = [("impute", SimpleImputer(strategy="median"))]
    if scale:
        num_steps.append(("scale", StandardScaler()))
    prep = ColumnTransformer([
        ("num", Pipeline(num_steps), numeric),
        ("cat", Pipeline([("impute", SimpleImputer(strategy="most_frequent")),
                          ("onehot", OneHotEncoder(handle_unknown="ignore"))]), categorical),
    ])
    return Pipeline([("prep", prep), ("clf", clf)])
Kode Penjelasan
def make_pipeline_with(clf, scale=True) Fungsi dengan dua parameter: model clf dan scale (bawaan True). Mengembalikan pipeline.
num_steps = [("impute", SimpleImputer(strategy="median"))] Daftar langkah numerik, dimulai dari imputasi median.
if scale: num_steps.append(...) Percabangan: scaler hanya ditambahkan bila scale=True. Random Forest tidak memerlukannya, sehingga dipanggil dengan scale=False.
ColumnTransformer([("num", ...), ("cat", ...)]) Praproses berbeda untuk kolom numerik dan kategorik (penjelasan).
return Pipeline([("prep", prep), ("clf", clf)]) Menggabungkan praproses dan model.

Langkah 3: membandingkan kandidat dengan baseline

project.py
# 3. Kandidat model, termasuk baseline
candidates = {
    "Baseline (mayoritas)": make_pipeline_with(DummyClassifier(strategy="most_frequent")),
    "Logistic Regression": make_pipeline_with(LogisticRegression(max_iter=1000)),
    "KNN (k=15)": make_pipeline_with(KNeighborsClassifier(n_neighbors=15)),
    "Random Forest": make_pipeline_with(
        RandomForestClassifier(n_estimators=200, min_samples_leaf=5, random_state=SEED), scale=False),
    "SVM (RBF)": make_pipeline_with(SVC()),
}
cv = RepeatedStratifiedKFold(n_splits=5, n_repeats=2, random_state=SEED)
print("\nmodel                  ROC-AUC  PR-AUC   F1(ambang 0.5)")
for name, model in candidates.items():
    s = cross_validate(model, X_train, y_train, cv=cv,
                       scoring=["roc_auc", "average_precision", "f1"])
    print(f"{name:<22} {s['test_roc_auc'].mean():.3f}    {s['test_average_precision'].mean():.3f}    "
          f"{s['test_f1'].mean():.3f}")

Lima kandidat disimpan dalam kamus: baseline mayoritas dan empat model. Perulangan menilai tiap model dengan RepeatedStratifiedKFold (5 lipatan × 2 pengulangan) pada data latih dengan tiga metrik: ROC-AUC, PR-AUC (average_precision), dan F1 pada ambang 0,5. Baris print memformat hasilnya sebagai tabel teks.

model                  ROC-AUC  PR-AUC   F1(ambang 0.5)
Baseline (mayoritas)   0.500    0.338    0.000
Logistic Regression    0.706    0.522    0.440
KNN (k=15)             0.675    0.494    0.412
Random Forest          0.720    0.561    0.419
SVM (RBF)              0.670    0.519    0.357

Interpretasi. Baseline memberi ROC-AUC 0,500 dan PR-AUC 0,338 (= proporsi churn), F1 0. Semua model mengalahkannya: Random Forest ROC-AUC 0,720 dan PR-AUC 0,561, Logistic Regression 0,706 dan 0,522, KNN 0,675 dan 0,494, SVM 0,670 dan 0,519. Sinyalnya moderat (ROC-AUC ≈ 0,7), wajar karena pembangkit data memang berderau. Selisih Random Forest dan Logistic Regression kecil; tanpa pengulangan lebih banyak, tidak ada pemenang yang pasti.

Langkah 4: optimasi ringan

project.py
# 4. Optimasi ringan untuk Logistic Regression (dipilih karena sederhana dan skornya
#    hampir setara dengan Random Forest; lihat pembahasan di lesson)
search = GridSearchCV(
    make_pipeline_with(LogisticRegression(max_iter=1000)),
    {"clf__C": [0.01, 0.1, 1, 10]}, scoring="roc_auc",
    cv=StratifiedKFold(5, shuffle=True, random_state=SEED),
).fit(X_train, y_train)
best = search.best_estimator_
print("\nC terbaik:", search.best_params_["clf__C"], "| ROC-AUC CV: %.3f" % search.best_score_)

GridSearchCV menyetel C regresi logistik (clf__C: nama langkah clf, parameter C) dengan ROC-AUC sebagai metrik; search.best_estimator_ adalah pipeline terbaik yang sudah dilatih ulang pada seluruh data latih. Regresi logistik dipilih karena sederhana dan skornya hampir setara dengan Random Forest. Ini keputusan praktis, bukan klaim bahwa ia terbaik.

C terbaik: 0.01 | ROC-AUC CV: 0.707

Interpretasi. C terbaik 0,01 (regularisasi kuat), ROC-AUC CV 0,707, hampir sama dengan regresi logistik awal 0,706: penyetelan tidak memberi perubahan berarti.

Langkah 5: memilih ambang tanpa menyentuh data uji

Konsep. Ambang 0,5 memberi F1 rendah (kisaran 0,36–0,44 pada tabel). Ambang yang lebih rendah mengutamakan recall churn. Ambang dipilih dari prediksi validasi silang pada data latih, bukan data uji.

project.py
# 5. Ambang keputusan dipilih dari prediksi validasi silang pada data LATIH (bukan data uji)
oof = cross_val_predict(best, X_train, y_train, cv=StratifiedKFold(5, shuffle=True, random_state=SEED),
                        method="predict_proba")[:, 1]
thresholds = np.arange(0.2, 0.71, 0.05)
f1s = [f1_score(y_train, oof >= t) for t in thresholds]
threshold = float(thresholds[int(np.argmax(f1s))])
print("ambang terpilih (F1 tertinggi pada prediksi CV): %.2f (F1 CV %.3f)" % (threshold, max(f1s)))
Kode Penjelasan
cross_val_predict(best, X_train, y_train, cv=..., method="predict_proba") Untuk tiap sampel latih, menghasilkan probabilitas yang diprediksi oleh model yang tidak melihat sampel itu (out-of-fold).
np.arange(0.2, 0.71, 0.05) Kandidat ambang dari 0,20 sampai 0,70 dengan langkah 0,05.
f1_score(y_train, oof >= t) F1 pada tiap ambang; oof >= t menghasilkan True/False yang dibaca sebagai prediksi 1/0.
thresholds[int(np.argmax(f1s))] Ambang dengan F1 tertinggi (argmax = indeks nilai terbesar).
ambang terpilih (F1 tertinggi pada prediksi CV): 0.30 (F1 CV 0.567)

Hasil. Ambang 0,30 terpilih (F1 CV 0,567).

Langkah 6: evaluasi akhir sekali pada data uji

project.py
# 6. Evaluasi akhir pada data uji, satu kali
proba = best.predict_proba(X_test)[:, 1]
pred = (proba >= threshold).astype(int)
print("\nROC-AUC uji: %.3f | PR-AUC uji: %.3f" % (roc_auc_score(y_test, proba), average_precision_score(y_test, proba)))
print("Confusion matrix (baris = asli, kolom = prediksi):\n", confusion_matrix(y_test, pred))
print(classification_report(y_test, pred, target_names=["bertahan", "churn"], digits=3))

best.predict_proba(X_test)[:, 1] memberi probabilitas churn; (proba >= threshold).astype(int) mengubahnya menjadi prediksi 0/1 dengan ambang terpilih.

ROC-AUC uji: 0.677 | PR-AUC uji: 0.632
Confusion matrix (baris = asli, kolom = prediksi):
 [[34 46]
 [ 9 31]]
              precision    recall  f1-score   support

    bertahan      0.791     0.425     0.553        80
       churn      0.403     0.775     0.530        40

    accuracy                          0.542       120
   macro avg      0.597     0.600     0.541       120
weighted avg      0.661     0.542     0.545       120

Interpretasi.

  • ROC-AUC uji 0,677 dan PR-AUC 0,632; ROC-AUC uji lebih rendah daripada validasi silang (0,707). Dengan 120 sampel (40 churn), selisih seperti ini masih dalam kisaran ketidakpastian.
  • Confusion matrix: dari 40 churn, 31 tertangkap (recall 0,775) dan 9 terlewat; dari 80 yang bertahan, 46 diperingatkan keliru (precision churn 0,403).
  • Akurasi 0,542 lebih rendah daripada baseline mayoritas (sekitar 0,667). Ini bukan berarti model lebih buruk: ambang 0,30 sengaja menukar akurasi dengan recall. Layak tidaknya bergantung pada biaya menghubungi pelanggan dibanding biaya kehilangan pelanggan, informasi yang tidak ada di data ini.

Langkah 7: menyimpan model beserta ambangnya

project.py
# 7. Simpan pipeline dan uji muat ulang
path = Path(tempfile.mkdtemp()) / "churn_model.joblib"
joblib.dump({"model": best, "threshold": threshold}, path)
restored = joblib.load(path)
same = np.array_equal(pred, (restored["model"].predict_proba(X_test)[:, 1] >= restored["threshold"]).astype(int))
print("model tersimpan dan prediksi identik setelah dimuat:", same)

Yang disimpan adalah kamus berisi pipeline dan ambang, karena keduanya diperlukan untuk memprediksi dengan benar. Setelah dimuat ulang, prediksi dicocokkan dengan prediksi sebelumnya.

model tersimpan dan prediksi identik setelah dimuat: True

Hasil. Prediksi identik setelah model dimuat ulang (True).

Program lengkap (project.py)
project.py
"""Proyek klasifikasi end-to-end: memprediksi churn pelanggan (data SINTETIS)."""
import sys
import tempfile
from pathlib import Path

import joblib
import numpy as np
from sklearn.compose import ColumnTransformer
from sklearn.dummy import DummyClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.impute import SimpleImputer
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import (
    average_precision_score,
    classification_report,
    confusion_matrix,
    f1_score,
    roc_auc_score,
)
from sklearn.model_selection import (
    GridSearchCV,
    RepeatedStratifiedKFold,
    StratifiedKFold,
    cross_val_predict,
    cross_validate,
    train_test_split,
)
from sklearn.neighbors import KNeighborsClassifier
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import OneHotEncoder, StandardScaler
from sklearn.svm import SVC

# Pembangkit data ada di examples/fundamentals/ (lihat lesson pandas)
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "fundamentals"))
from customer_data import make_customer_data  # noqa: E402

SEED = 42

# 1. Data, pembersihan duplikat, dan pembagian data
df = make_customer_data().drop_duplicates().reset_index(drop=True)
X, y = df.drop(columns="churn"), df["churn"]
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, stratify=y, random_state=SEED
)
print("latih:", X_train.shape, "| uji:", X_test.shape, "| churn latih: %.3f" % y_train.mean())

# 2. Praproses (di dalam pipeline agar tidak bocor)
numeric = ["age", "tenure_months", "income", "n_orders", "avg_spend"]
categorical = ["city", "plan"]


def make_pipeline_with(clf, scale=True):
    num_steps = [("impute", SimpleImputer(strategy="median"))]
    if scale:
        num_steps.append(("scale", StandardScaler()))
    prep = ColumnTransformer([
        ("num", Pipeline(num_steps), numeric),
        ("cat", Pipeline([("impute", SimpleImputer(strategy="most_frequent")),
                          ("onehot", OneHotEncoder(handle_unknown="ignore"))]), categorical),
    ])
    return Pipeline([("prep", prep), ("clf", clf)])


# 3. Kandidat model, termasuk baseline
candidates = {
    "Baseline (mayoritas)": make_pipeline_with(DummyClassifier(strategy="most_frequent")),
    "Logistic Regression": make_pipeline_with(LogisticRegression(max_iter=1000)),
    "KNN (k=15)": make_pipeline_with(KNeighborsClassifier(n_neighbors=15)),
    "Random Forest": make_pipeline_with(
        RandomForestClassifier(n_estimators=200, min_samples_leaf=5, random_state=SEED), scale=False),
    "SVM (RBF)": make_pipeline_with(SVC()),
}
cv = RepeatedStratifiedKFold(n_splits=5, n_repeats=2, random_state=SEED)
print("\nmodel                  ROC-AUC  PR-AUC   F1(ambang 0.5)")
for name, model in candidates.items():
    s = cross_validate(model, X_train, y_train, cv=cv,
                       scoring=["roc_auc", "average_precision", "f1"])
    print(f"{name:<22} {s['test_roc_auc'].mean():.3f}    {s['test_average_precision'].mean():.3f}    "
          f"{s['test_f1'].mean():.3f}")

# 4. Optimasi ringan untuk Logistic Regression (dipilih karena sederhana dan skornya
#    hampir setara dengan Random Forest; lihat pembahasan di lesson)
search = GridSearchCV(
    make_pipeline_with(LogisticRegression(max_iter=1000)),
    {"clf__C": [0.01, 0.1, 1, 10]}, scoring="roc_auc",
    cv=StratifiedKFold(5, shuffle=True, random_state=SEED),
).fit(X_train, y_train)
best = search.best_estimator_
print("\nC terbaik:", search.best_params_["clf__C"], "| ROC-AUC CV: %.3f" % search.best_score_)

# 5. Ambang keputusan dipilih dari prediksi validasi silang pada data LATIH (bukan data uji)
oof = cross_val_predict(best, X_train, y_train, cv=StratifiedKFold(5, shuffle=True, random_state=SEED),
                        method="predict_proba")[:, 1]
thresholds = np.arange(0.2, 0.71, 0.05)
f1s = [f1_score(y_train, oof >= t) for t in thresholds]
threshold = float(thresholds[int(np.argmax(f1s))])
print("ambang terpilih (F1 tertinggi pada prediksi CV): %.2f (F1 CV %.3f)" % (threshold, max(f1s)))

# 6. Evaluasi akhir pada data uji, satu kali
proba = best.predict_proba(X_test)[:, 1]
pred = (proba >= threshold).astype(int)
print("\nROC-AUC uji: %.3f | PR-AUC uji: %.3f" % (roc_auc_score(y_test, proba), average_precision_score(y_test, proba)))
print("Confusion matrix (baris = asli, kolom = prediksi):\n", confusion_matrix(y_test, pred))
print(classification_report(y_test, pred, target_names=["bertahan", "churn"], digits=3))

# 7. Simpan pipeline dan uji muat ulang
path = Path(tempfile.mkdtemp()) / "churn_model.joblib"
joblib.dump({"model": best, "threshold": threshold}, path)
restored = joblib.load(path)
same = np.array_equal(pred, (restored["model"].predict_proba(X_test)[:, 1] >= restored["threshold"]).astype(int))
print("model tersimpan dan prediksi identik setelah dimuat:", same)

Refleksi dan pengembangan

  • Sinyal data lemah: tambahkan fitur yang bermakna (sulit untuk data sintetis ini) atau kumpulkan data lebih baik daripada memperumit model.
  • Gunakan ambang yang dipilih dari biaya bisnis, bukan sekadar F1.
  • Tambahkan pemantauan pergeseran data seperti di lesson sebelumnya.

Latihan

  1. Setel RandomForestClassifier dengan RandomizedSearchCV, lalu bandingkan dengan Logistic Regression yang disetel.
  2. Ganti kriteria pemilihan ambang dari F1 ke "recall minimal 0,8 dengan precision setinggi mungkin".
  3. Tambahkan Pipeline baseline DummyClassifier(strategy="stratified") dan lihat PR-AUC-nya.
  4. Tulis laporan satu halaman untuk tim retensi: apa yang dapat dan tidak dapat disimpulkan dari model ini.

Ringkasan

Proyek ini memperlihatkan alur lengkap dan keputusan metodologisnya: praproses di dalam pipeline, baseline, perbandingan adil, ambang dari data latih, evaluasi sekali di data uji, dan penyimpanan. Hasil yang moderat pada data sintetis ini adalah pelajaran: laporkan apa adanya.

Selesai dengan bab Klasifikasi. Lanjut ke bab Estimasi (Regresi).