Belajar Machine Learning - Feature Engineering & Selection

#Pendahuluan

Setelah di episode 8 kita mengeksplorasi unsupervised learning, pada episode ini kita kembali ke seni yang paling membedakan data scientist kompetisi dari yang sekadar menjalankan model.fit(): feature engineering dan feature selection.

Mengapa ini penting? Karena model hanya sebaik fiturnya. Dua engineer dengan model yang sama persis bisa mendapat hasil sangat berbeda — yang satu memahami data dan membangun fitur yang menangkap sinyal, yang lain melempar data mentah begitu saja. Di kompetisi tabular seperti Kaggle, feature engineering sering menjadi pembeda antara peringkat 10 dan peringkat 500.

#Feature Engineering

#Fitur Turunan (Derived Features)

Kadang kombinasi fitur lebih bermakna daripada fitur aslinya. Untuk prediksi harga rumah: alih-alih luas_tanah dan luas_bangunan terpisah, rasio = luas_bangunan / luas_tanah bisa menangkap efisiensi pemanfaatan lahan.

df["rasio_bangunan"] = df["luas_bangunan"] / df["luas_tanah"]
df["umur_rumah"] = df["tahun_sekarang"] - df["tahun_dibangun"]
df["harga_per_m2"] = df["harga"] / df["luas_bangunan"]

Sumber fitur turunan terbaik adalah domain knowledge: seorang sales tahu bahwa pendapatan - pengeluaran (sisa uang) lebih menentukan kemampuan membeli daripada keduanya terpisah.

#Binning

Binning mengubah fitur kontinu menjadi kategori. Berguna untuk menangkap hubungan non-linear dan untuk model yang butuh kategori:

df["grup_umur"] = pd.cut(
    df["umur"],
    bins=[0, 18, 30, 45, 60, 100],
    labels=["anak", "muda", "dewasa", "paruh_baya", "lansia"],
)

Binning juga berguna untuk menangani outlier: nilai pendapatan 10 miliar dan 1 miliar sama-sama masuk bin "sangat tinggi", sehingga outlier tidak lagi mengganggu.

#Feature Interaction

Interaksi menggabungkan dua fitur untuk menangkap efek gabungan. Misalnya umur × pendapatan: pola spending anak muda berpendapatan tinggi berbeda dari orang tua berpendapatan tinggi.

from sklearn.preprocessing import PolynomialFeatures
 
poly = PolynomialFeatures(degree=2, interaction_only=True)
X_inter = poly.fit_transform(X[["umur", "pendapatan"]])

interaction_only=True membuat hasilnya hanya pasangan kali-kalian (x1·x2), tanpa kuadrat — fokus pada interaksi saja.

#Penanganan Tanggal

Kolom tanggal berisi informasi tersembunyi: tahun, bulan, hari dalam seminggu, atau apakah hari libur. Pecah menjadi fitur numerik yang bisa dipahami model:

df["tanggal"] = pd.to_datetime(df["tanggal_transaksi"])
 
df["tahun"] = df["tanggal"].dt.year
df["bulan"] = df["tanggal"].dt.month
df["hari_dalam_minggu"] = df["tanggal"].dt.dayofweek
df["minggu_dalam_tahun"] = df["tanggal"].dt.isocalendar().week

Untuk model linear, bulan sebagai angka 1-12 mengasumsikan Desember lebih "jauh" dari Januari — kadang benar (musiman), kadang tidak. Pertimbangkan sin/cos transformasi untuk fitur siklik:

import numpy as np
 
df["bulan_sin"] = np.sin(2 * np.pi * df["bulan"] / 12)
df["bulan_cos"] = np.cos(2 * np.pi * df["bulan"] / 12)

#Feature Selection

Setelah fitur dibuat, masalah berikutnya: terlalu banyak fitur → lambat, overfit, dan noise. Feature selection memilih subset fitur yang paling berguna.

#Filter Methods

Metode filter menilai tiap fitur secara terpisah, cepat dan murah. Yang paling umum: korelasi terhadap target.

correlations = df.corr()["harga"].abs().sort_values(ascending=False)
print(correlations.head(10))

Fitur dengan korelasi sangat rendah ke target (|r| di bawah 0.05, misalnya) seringkali aman dibuang. Kelemahan filter: tidak melihat interaksi antar fitur — dua fitur yang masing-masing lemah bisa kuat jika digabung.

#Wrapper Methods

Wrapper melatih model berulang kali untuk menilai subset fitur. Contoh: RFE (Recursive Feature Elimination) — mulai dari semua fitur, buang yang paling tidak penting, ulangi.

from sklearn.feature_selection import RFE
from sklearn.ensemble import RandomForestRegressor
 
selector = RFE(RandomForestRegressor(random_state=42), n_features_to_select=10)
selector.fit(X_train, y_train)
 
print(selector.support_)
print(X.columns[selector.support_])

Wrapper mempertimbangkan interaksi antar fitur, tetapi mahal secara komputasi — melatih model puluhan kali.

#Embedded Methods

Embedded memilih fitur saat training berlangsung. Yang paling populer: feature_importances_ dari tree-based dan koefisien Lasso (ingat episode 5).

importances = pd.Series(
    rf.feature_importances_,
    index=X.columns,
).sort_values(ascending=False)
 
print(importances.head(10))

Keunggulan embedded: murah seperti filter (satu kali training), tetapi tetap mempertimbangkan interaksi seperti wrapper.

#Multicollinearity

Multicollinearity terjadi saat dua fitur sangat berkorelasi satu sama lain (misalnya luas_m2 dan luas_kaki2 — mengukur hal yang sama). Dampaknya:

• Model linear: koefisien tidak stabil dan sulit diinterpretasi.
• Tree-based: tidak terlalu bermasalah, tapi fitur menjadi redundan.

Deteksi dengan matriks korelasi antar fitur:

import numpy as np
 
corr = X.corr().abs()
upper = corr.where(np.triu(np.ones(corr.shape), k=1).astype(bool))
tinggi = [(col, row, upper.loc[row, col])
          for col in upper.columns for row in upper.index
          if upper.loc[row, col] > 0.95]
 
print(tinggi)

Alternatif formal: VIF (Variance Inflation Factor) di atas 10 menandakan multicollinearity parah. Solusinya: buang salah satu fitur yang berpasangan, atau gunakan PCA.

#Praktik: Satu Alur Feature Engineering

import pandas as pd
 
df = pd.read_csv("rumah.csv")
 
# Derived + date features
df["umur_rumah"] = 2026 - df["tahun_dibangun"]
df["rasio_luas"] = df["luas_bangunan"] / df["luas_tanah"]
 
# Binning
df["tipe_umur"] = pd.cut(df["umur_rumah"],
                         bins=[0, 5, 15, 30, 100],
                         labels=["baru", "menengah", "tua", "sangat_tua"])
 
# Seleksi berbasis korelasi
target_corr = df.corr()["harga"].abs().sort_values(ascending=False)
fitur_tersisa = target_corr[target_corr > 0.05].index.tolist()
print(fitur_tersisa)

#Common Pitfalls

• Feature engineering setelah split — fitur seperti tahun_sekarang boleh, tapi statistik data (misal mean per grup) hanya boleh dari train set.
• Terlalu banyak fitur — setiap fitur menambah dimensi; overfit mengintai (kurse of dimensionality).
• Lupa mengecek multicollinearity pada model linear.
• Membuang fitur berdasarkan importance sekali jalan — selalu validasi dengan evaluasi di episode 10.
• Encoding siklik memakai angka mentah — gunakan sin/cos untuk data periodik.

#Penutup

Pada episode 9 ini, kalian telah menguasai seni membangun dan memilih fitur.

Inti yang harus dibawa pulang:

• Feature engineering: fitur turunan, binning, interaksi, dan parsing tanggal/kategori.
• Sumber terbaik fitur turunan adalah domain knowledge.
• Seleksi: filter (korelasi) cepat, wrapper (RFE) akurat tapi mahal, embedded (importance) kompromi terbaik.
• Awasi multicollinearity pada model linear.
• Selalu buat fitur dengan data train saja.

Di episode 10 selanjutnya kita akan membahas model evaluation & hyperparameter tuning — cross-validation k-fold/stratified, validation curves, bias-variance trade-off, lalu GridSearchCV, RandomizedSearchCV, Optuna, dan early stopping. Sampai jumpa di episode 10!