Lewati ke isi

Workflow scikit-learn dan Pipeline

Gambaran singkat

Apa ini? Mengenal cara kerja scikit-learn dan Pipeline yang merangkai praproses dan model dalam satu alur.

Analogi

Seperti ban berjalan di pabrik: bahan mentah lewat beberapa stasiun yang selalu berurutan sama, sehingga hasil konsisten dan tidak ada langkah terlewat.

Mengapa penting? Pipeline mencegah kebocoran data pada validasi silang dan membuat model mudah disimpan serta dipakai ulang.

Yang akan dipelajari, berurutan:

  1. API scikit-learn: fit, transform, predict, score.
  2. Pipeline dan ColumnTransformer untuk data campuran.
  3. Bagaimana Pipeline mencegah kebocoran.

Istilah awal:

Istilah Arti sederhana
fit Belajar dari data
transform Menerapkan yang sudah dipelajari
Pipeline Rangkaian langkah sebagai satu kesatuan
ColumnTransformer Praproses berbeda untuk kolom berbeda

Tujuan pembelajaran

  • Memahami API scikit-learn: fit, transform, predict, score.
  • Membangun Pipeline dan ColumnTransformer untuk data campuran numerik dan kategorik.
  • Menjelaskan bagaimana Pipeline mencegah kebocoran data pada validasi silang.

Konsep dasar

Objek scikit-learn berbagi antarmuka yang konsisten:

Jenis Metode utama Contoh
Transformer fit(X), transform(X) StandardScaler, SimpleImputer, OneHotEncoder
Estimator/model fit(X, y), predict(X), score(X, y) LogisticRegression, RandomForestClassifier
  • fit mempelajari parameter dari data (mis. rata-rata untuk scaler, koefisien untuk model).
  • transform/predict menerapkan hasil belajar itu.

Pipeline merangkai langkah berurutan menjadi satu objek. ColumnTransformer menerapkan praproses berbeda pada kelompok kolom berbeda. Keuntungannya:

  1. Mencegah kebocoran data: pada validasi silang, seluruh pipeline di-fit ulang hanya pada data latih tiap lipatan.
  2. Reproduksibel dan rapi: satu objek untuk praproses dan model, dapat disimpan dan dipakai ulang.
  3. Memudahkan penyetelan hyperparameter praproses dan model sekaligus.
flowchart LR
    A[Data mentah] --> B[ColumnTransformer<br/>numerik: impute + scale<br/>kategorik: impute + one-hot]
    B --> C[Model]
    C --> D[Prediksi]

Implementasi langkah demi langkah

Memakai data pelanggan sintetis (penjelasan) untuk memprediksi churn. Simpan customer_data.py pada folder yang sama. Program lengkap ada di akhir bagian ini.

Langkah 1: memisahkan X, y, dan data uji

Tujuan. Menyiapkan fitur dan target, lalu menyisihkan data uji sebelum apa pun dipelajari dari data.

sklearn_pipeline.py
from sklearn.compose import ColumnTransformer
from sklearn.impute import SimpleImputer
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import cross_val_score, train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import OneHotEncoder, StandardScaler

from customer_data import make_customer_data

SEED = 42
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)

numeric = ["age", "tenure_months", "income", "n_orders", "avg_spend"]
categorical = ["city", "plan"]
Kode Penjelasan
X, y = df.drop(columns="churn"), df["churn"] X = semua kolom kecuali target (tabel fitur); y = kolom target (Series).
train_test_split(X, y, test_size=0.2, stratify=y, random_state=SEED) Mengembalikan empat bagian dalam urutan X_train, X_test, y_train, y_test. 20% menjadi data uji; stratify=y menjaga proporsi churn; random_state membuat hasilnya dapat diulang.
numeric, categorical Dua daftar nama kolom yang akan diperlakukan berbeda.

Langkah 2: praproses berbeda untuk kolom berbeda (ColumnTransformer)

Konsep. Kolom angka perlu imputasi dan scaling; kolom teks perlu imputasi dan one-hot. ColumnTransformer menerapkan rangkaian langkah berbeda pada kelompok kolom berbeda, lalu menyatukan hasilnya.

sklearn_pipeline.py
# Praproses berbeda untuk kolom numerik dan kategorik
preprocess = ColumnTransformer([
    ("num", Pipeline([("impute", SimpleImputer(strategy="median")),
                      ("scale", StandardScaler())]), numeric),
    ("cat", Pipeline([("impute", SimpleImputer(strategy="most_frequent")),
                      ("onehot", OneHotEncoder(handle_unknown="ignore"))]), categorical),
])

Setiap entri ColumnTransformer berbentuk (nama, transformer, kolom):

  • ("num", Pipeline([imputasi median, standardisasi]), numeric): untuk kolom numerik, jalankan imputasi median, lalu StandardScaler.
  • ("cat", Pipeline([imputasi modus, one-hot]), categorical): untuk kolom kategorik, jalankan imputasi modus, lalu OneHotEncoder(handle_unknown="ignore") (kategori baru saat prediksi tidak menimbulkan galat).

Istilah. Transformer adalah objek dengan fit dan transform; estimator adalah objek yang dapat fit (belajar). Pipeline sendiri adalah estimator yang merangkai beberapa langkah berurutan.

Langkah 3: merangkai praproses dan model menjadi satu Pipeline

sklearn_pipeline.py
model = Pipeline([("preprocess", preprocess),
                  ("clf", LogisticRegression(max_iter=1000))])

Pipeline([("preprocess", preprocess), ("clf", LogisticRegression(max_iter=1000))]) merangkai praproses dan model. Tiap langkah berupa pasangan (nama, objek); langkah terakhir adalah model. Pada titik ini belum ada yang dilatih: kita baru menginisialisasi objek. max_iter=1000 memberi optimisasi regresi logistik batas 1000 iterasi agar sempat konvergen.

Mengapa pipeline? Dengan satu objek, fit mempelajari imputer, scaler, encoder, dan model hanya dari data yang diberikan (data latih), dan predict menerapkan semuanya secara konsisten pada data baru. Inilah cara mencegah kebocoran data.

Langkah 4: validasi silang pada seluruh pipeline

sklearn_pipeline.py
# Validasi silang: setiap lipatan melatih ulang SELURUH pipeline pada data latih lipatan itu
scores = cross_val_score(model, X_train, y_train, cv=5, scoring="roc_auc")
print("ROC-AUC CV: %.3f (+/- %.3f)" % (scores.mean(), scores.std()))

cross_val_score(model, X_train, y_train, cv=5, scoring="roc_auc") membagi data latih menjadi 5 lipatan. Untuk tiap lipatan ia melatih ulang seluruh pipeline (imputer, scaler, encoder, model) pada 4 lipatan lalu menilai pada lipatan sisanya. Hasilnya 5 skor ROC-AUC; scores.mean() dan scores.std() merangkumnya. Karena praproses ikut dilatih ulang tiap lipatan, tidak ada informasi lipatan validasi yang bocor.

ROC-AUC CV: 0.709 (+/- 0.040)

Interpretasi. ROC-AUC rata-rata 0,709 dengan simpangan baku 0,040: kemampuan memisahkan churn dan non-churn lumayan tetapi tidak tinggi, dan skor bervariasi antar lipatan.

Langkah 5: melatih dan menguji

sklearn_pipeline.py
model.fit(X_train, y_train)
print("Akurasi uji : %.3f" % model.score(X_test, y_test))

model.fit(X_train, y_train) melatih seluruh pipeline pada data latih. model.score(X_test, y_test) memprediksi X_test dan membandingkannya dengan y_test; untuk klasifikasi, score bawaan adalah akurasi.

Akurasi uji : 0.742

Interpretasi. Akurasi uji 0,742. Menebak "bertahan" untuk semua orang memberi sekitar 0,66 (proporsi kelas 0 = 0,661), sehingga model lebih baik dari tebakan sederhana, tetapi tidak jauh.

Langkah 6: melihat isi pipeline

sklearn_pipeline.py
names = model.named_steps["preprocess"].get_feature_names_out()
print("jumlah fitur setelah praproses:", len(names))
print(list(names))
print("langkah pipeline:", list(model.named_steps))

model.named_steps["preprocess"] mengambil satu langkah berdasarkan namanya; get_feature_names_out() menamai kolom hasil praproses (awalan num__ dan cat__ menunjukkan cabang asalnya). list(model.named_steps) menampilkan nama langkah.

jumlah fitur setelah praproses: 11
['num__age', 'num__tenure_months', 'num__income', 'num__n_orders', 'num__avg_spend', 'cat__city_Bandung', 'cat__city_Jakarta', 'cat__city_Medan', 'cat__city_Surabaya', 'cat__plan_basic', 'cat__plan_premium']
langkah pipeline: ['preprocess', 'clf']

Hasil. Praproses menghasilkan 11 fitur: 5 numerik + 4 kota + 2 paket. Satu kolom city menjadi empat kolom one-hot, dan plan menjadi dua.

Program lengkap (sklearn_pipeline.py)
sklearn_pipeline.py
from sklearn.compose import ColumnTransformer
from sklearn.impute import SimpleImputer
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import cross_val_score, train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import OneHotEncoder, StandardScaler

from customer_data import make_customer_data

SEED = 42
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)

numeric = ["age", "tenure_months", "income", "n_orders", "avg_spend"]
categorical = ["city", "plan"]

# Praproses berbeda untuk kolom numerik dan kategorik
preprocess = ColumnTransformer([
    ("num", Pipeline([("impute", SimpleImputer(strategy="median")),
                      ("scale", StandardScaler())]), numeric),
    ("cat", Pipeline([("impute", SimpleImputer(strategy="most_frequent")),
                      ("onehot", OneHotEncoder(handle_unknown="ignore"))]), categorical),
])

model = Pipeline([("preprocess", preprocess),
                  ("clf", LogisticRegression(max_iter=1000))])

# Validasi silang: setiap lipatan melatih ulang SELURUH pipeline pada data latih lipatan itu
scores = cross_val_score(model, X_train, y_train, cv=5, scoring="roc_auc")
print("ROC-AUC CV: %.3f (+/- %.3f)" % (scores.mean(), scores.std()))

model.fit(X_train, y_train)
print("Akurasi uji : %.3f" % model.score(X_test, y_test))

names = model.named_steps["preprocess"].get_feature_names_out()
print("jumlah fitur setelah praproses:", len(names))
print(list(names))
print("langkah pipeline:", list(model.named_steps))

Kesalahan umum

Hindari

  • Memanggil fit_transform pada seluruh data sebelum cross_val_score (kebocoran).
  • Memanggil fit pada data uji.
  • Lupa bahwa urutan kolom saat prediksi harus sama dengan saat pelatihan (pipeline dengan DataFrame dan nama kolom menjaga ini).
  • Menggunakan score default (accuracy) tanpa memikirkan metrik yang sesuai.

Latihan

  1. Ganti LogisticRegression dengan RandomForestClassifier dan hapus StandardScaler. Apakah ROC-AUC CV berubah?
  2. Tambahkan DummyClassifier(strategy="most_frequent") sebagai baseline dengan pipeline yang sama.
  3. Cetak model.named_steps["clf"].coef_. Fitur mana yang koefisiennya terbesar (dalam nilai mutlak)?
  4. Mengapa SimpleImputer ada di dalam pipeline dan bukan dijalankan sebelum split?

Ringkasan

Pipeline + ColumnTransformer menyatukan praproses dan model dalam satu objek yang di-fit hanya pada data latih, sehingga mencegah kebocoran dan membuat alur kerja rapi, dapat diulang, dan mudah disimpan.

Berikutnya: Overfitting, Underfitting, dan Kebocoran Data.