Lewati ke isi

Feature Engineering

Gambaran singkat

Apa ini? Membuat atau mengubah fitur agar pola lebih mudah dipelajari model.

Analogi

Dari tanggal lahir, kita hitung umur; dari harga dan luas, kita hitung harga per meter. Informasi sama, tetapi bentuk baru lebih bermakna.

Mengapa penting? Fitur yang baik sering lebih berpengaruh daripada memilih algoritma yang lebih rumit. Namun fitur baru harus diuji secara jujur.

Yang akan dipelajari, berurutan:

  1. Membuat fitur dari pengetahuan domain.
  2. Transformasi log, binning, dan fitur polinomial.
  3. Menguji apakah fitur baru benar-benar membantu.

Istilah awal:

Istilah Arti sederhana
Fitur turunan Fitur baru yang dihitung dari fitur lain
Transformasi log Menekan nilai besar agar sebaran lebih seimbang
Binning Mengelompokkan angka ke dalam rentang

Tujuan pembelajaran

  • Membuat fitur baru dari pengetahuan domain.
  • Memakai transformasi log, binning, dan fitur polinomial.
  • Menguji secara jujur apakah fitur baru benar-benar membantu.

Konsep dasar

Feature engineering adalah membuat atau mengubah fitur agar pola lebih mudah dipelajari model. Sumber ide terbaik adalah pengetahuan domain: rasio, selisih, hitungan, atau kategori yang bermakna. Namun fitur baru tidak otomatis lebih baik; ia harus dibuktikan lewat validasi.

Teknik Contoh Manfaat
Fitur turunan (rasio, total) n_orders / tenure_months Menangkap intensitas, bukan hanya jumlah
Transformasi log log1p(income) Mengurangi kemiringan ekstrem
Binning usia → kelompok usia Menangkap pola tidak linear sederhana
Fitur polinomial/interaksi \(x_1^2, x_1 x_2\) Memungkinkan model linear menangkap kelengkungan
Encoding kategorik one-hot Mengubah kategori menjadi angka

Implementasi langkah demi langkah

Memakai data pelanggan sintetis (penjelasan). Bagian akhir membandingkan ROC-AUC (5-fold CV) dengan dan tanpa fitur turunan. Program lengkap ada di akhir bagian ini.

Langkah 1: fitur turunan dari pengetahuan domain

Tujuan. Membuat fitur yang menyatakan konsep bermakna dari kolom yang sudah ada.

feature_engineering.py
import numpy as np
import pandas as pd
from sklearn.model_selection import cross_val_score
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import PolynomialFeatures, StandardScaler
from sklearn.linear_model import LogisticRegression

from customer_data import make_customer_data

df = make_customer_data().drop_duplicates().reset_index(drop=True)

# 1. Fitur turunan dari pengetahuan domain
df["spend_total"] = df["n_orders"] * df["avg_spend"]
df["orders_per_month"] = df["n_orders"] / df["tenure_months"]
df["is_new"] = (df["tenure_months"] <= 6).astype(int)
Kode Penjelasan
make_customer_data().drop_duplicates().reset_index(drop=True) Membuat data lalu langsung membuang duplikat (rangkaian pemanggilan metode, dibaca dari kiri ke kanan).
df["spend_total"] = n_orders * avg_spend Total belanja = jumlah transaksi × rata-rata belanja.
df["orders_per_month"] = n_orders / tenure_months Rasio: intensitas transaksi per bulan; pelanggan baru dan lama menjadi sebanding.
(tenure_months <= 6).astype(int) Syarat boolean menghasilkan True/False; astype(int) mengubahnya menjadi 1/0, yaitu fitur biner "pelanggan baru".

Fitur turunan di atas hanya memakai kolom pada baris yang sama sehingga aman dari kebocoran.

Langkah 2: transformasi log untuk data miring

Konsep. Pada data sangat miring ke kanan, logaritma menarik nilai besar mendekat sehingga distribusi lebih simetris. np.log1p(x) menghitung \(\ln(1+x)\): aman bila ada nilai 0.

feature_engineering.py
# 2. Transformasi log untuk data miring (income dapat bernilai hilang -> NaN tetap NaN)
df["log_income"] = np.log1p(df["income"])
print("skew income     : %.2f" % df["income"].skew())
print("skew log_income : %.2f" % df["log_income"].skew())
skew income     : 13.73
skew log_income : 1.04

Interpretasi. Skewness income turun dari 13,73 menjadi 1,04. Masih di atas 0 karena beberapa outlier ekstrem tetap ada. Nilai NaN tetap NaN setelah log (imputasi dilakukan terpisah).

Langkah 3: binning (mengelompokkan nilai numerik)

Konsep. pd.cut membagi angka menjadi kelompok menurut batas yang kita tentukan. Berguna bila hubungan dengan target tidak linear atau agar mudah dijelaskan.

feature_engineering.py
# 3. Binning usia menjadi kelompok
df["age_group"] = pd.cut(df["age"], bins=[17, 30, 45, 60, 100],
                         labels=["18-30", "31-45", "46-60", "61+"])
print(df.groupby("age_group", observed=True)["churn"].agg(["size", "mean"]).round(3))

bins=[17, 30, 45, 60, 100] mendefinisikan interval (17,30], (30,45], (45,60], (60,100]; labels memberi nama tiap kelompok. .agg(["size", "mean"]) menghitung jumlah dan rata-rata churn tiap kelompok; observed=True hanya menampilkan kelompok yang benar-benar ada.

           size   mean
age_group             
18-30       152  0.355
31-45       172  0.314
46-60       172  0.407
61+         104  0.231

Interpretasi. Tingkat churn: 35,5% (18–30), 31,4% (31–45), 40,7% (46–60), 23,1% (61+). Polanya tidak monoton, jadi pengelompokan membantu melihatnya. Perbedaan antar kelompok tidak besar dan kelompok berukuran 104–172 sampel, jadi jangan ditafsirkan berlebihan.

Langkah 4: fitur polinomial dan interaksi

Konsep. PolynomialFeatures(degree=2) menambahkan kuadrat tiap fitur dan hasil kali antar-fitur (interaksi), sehingga model linear dapat menangkap kelengkungan dan pengaruh gabungan.

feature_engineering.py
# 4. Fitur polinomial dan interaksi
X = df[["tenure_months", "n_orders"]]
poly = PolynomialFeatures(degree=2, include_bias=False)
print("fitur asli     :", list(X.columns))
print("fitur polinomial:", list(poly.fit(X).get_feature_names_out()))

include_bias=False tidak menambah kolom konstan 1. poly.fit(X) mempelajari jumlah dan nama fitur; get_feature_names_out() menamai kolom keluaran.

fitur asli     : ['tenure_months', 'n_orders']
fitur polinomial: ['tenure_months', 'n_orders', 'tenure_months^2', 'tenure_months n_orders', 'n_orders^2']

Hasil. Dua fitur asli menjadi lima kolom: dua fitur asli, kuadratnya, dan hasil kali tenure_months n_orders (interaksi). Jumlah kolom tumbuh cepat pada derajat dan fitur yang lebih banyak.

Langkah 5: apakah fitur baru benar-benar membantu?

Tujuan. Fitur baru harus dibuktikan dengan validasi, bukan diasumsikan lebih baik.

feature_engineering.py
# 5. Apakah fitur baru membantu? Bandingkan dengan validasi silang (5 lipatan)
y = df["churn"]
def cv_auc(columns):
    model = make_pipeline(StandardScaler(), LogisticRegression(max_iter=1000))
    return cross_val_score(model, df[columns], y, cv=5, scoring="roc_auc").mean()

base = ["tenure_months", "n_orders", "age", "avg_spend"]
print("ROC-AUC fitur asli        : %.3f" % cv_auc(base))
print("ROC-AUC + fitur turunan   : %.3f" % cv_auc(base + ["orders_per_month", "is_new"]))
Kode Penjelasan
def cv_auc(columns): ... Fungsi yang membangun Pipeline (scaler + regresi logistik), lalu mengembalikan rata-rata ROC-AUC 5-fold untuk kolom fitur tertentu. Pemakaian fungsi menghindari menulis ulang kode yang sama dua kali.
make_pipeline(StandardScaler(), LogisticRegression(...)) Standardisasi dilakukan di dalam validasi silang sehingga tidak bocor.
cross_val_score(..., cv=5, scoring="roc_auc") Melatih dan menguji 5 kali pada pembagian berbeda; hasilnya lima skor. .mean() merata-ratakannya.
base + ["orders_per_month", "is_new"] Menggabungkan dua list untuk membentuk daftar fitur yang diperluas.
ROC-AUC fitur asli        : 0.703
ROC-AUC + fitur turunan   : 0.702

Interpretasi. ROC-AUC 0,703 (fitur asli) vs 0,702 (ditambah orders_per_month dan is_new): tidak ada peningkatan. Pada data sintetis ini fitur asli sudah memuat informasi yang dipakai pembangkit data, sehingga fitur turunan tidak menambah apa-apa. Menambah fitur tanpa bukti hanya menambah kompleksitas.

Program lengkap (feature_engineering.py)
feature_engineering.py
import numpy as np
import pandas as pd
from sklearn.model_selection import cross_val_score
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import PolynomialFeatures, StandardScaler
from sklearn.linear_model import LogisticRegression

from customer_data import make_customer_data

df = make_customer_data().drop_duplicates().reset_index(drop=True)

# 1. Fitur turunan dari pengetahuan domain
df["spend_total"] = df["n_orders"] * df["avg_spend"]
df["orders_per_month"] = df["n_orders"] / df["tenure_months"]
df["is_new"] = (df["tenure_months"] <= 6).astype(int)

# 2. Transformasi log untuk data miring (income dapat bernilai hilang -> NaN tetap NaN)
df["log_income"] = np.log1p(df["income"])
print("skew income     : %.2f" % df["income"].skew())
print("skew log_income : %.2f" % df["log_income"].skew())

# 3. Binning usia menjadi kelompok
df["age_group"] = pd.cut(df["age"], bins=[17, 30, 45, 60, 100],
                         labels=["18-30", "31-45", "46-60", "61+"])
print(df.groupby("age_group", observed=True)["churn"].agg(["size", "mean"]).round(3))

# 4. Fitur polinomial dan interaksi
X = df[["tenure_months", "n_orders"]]
poly = PolynomialFeatures(degree=2, include_bias=False)
print("fitur asli     :", list(X.columns))
print("fitur polinomial:", list(poly.fit(X).get_feature_names_out()))

# 5. Apakah fitur baru membantu? Bandingkan dengan validasi silang (5 lipatan)
y = df["churn"]
def cv_auc(columns):
    model = make_pipeline(StandardScaler(), LogisticRegression(max_iter=1000))
    return cross_val_score(model, df[columns], y, cv=5, scoring="roc_auc").mean()

base = ["tenure_months", "n_orders", "age", "avg_spend"]
print("ROC-AUC fitur asli        : %.3f" % cv_auc(base))
print("ROC-AUC + fitur turunan   : %.3f" % cv_auc(base + ["orders_per_month", "is_new"]))

Prinsip penting

  • Fitur dibuat dari informasi yang tersedia saat prediksi. Fitur yang memakai informasi masa depan atau target menyebabkan kebocoran data.
  • Transformasi yang belajar dari data (misalnya scaling, binning berbasis kuantil) harus di-fit pada data latih, di dalam Pipeline.
  • Banyak model (Random Forest, gradient boosting) dapat menangkap non-linearitas sendiri; rekayasa fitur paling penting untuk model linear dan berbasis jarak.

Kesalahan umum

Hindari

  • Membuat fitur dari kolom target atau informasi yang baru diketahui setelah kejadian.
  • Menghitung statistik kelompok (misalnya rata-rata per kota) pada seluruh data sebelum split.
  • Menambah banyak fitur tanpa validasi sehingga risiko overfitting naik.
  • Memakai log pada nilai nol atau negatif tanpa log1p/penyesuaian.

Latihan

  1. Buat fitur spend_per_order dan uji pengaruhnya pada ROC-AUC CV.
  2. Coba PolynomialFeatures(degree=3); berapa kolom yang terbentuk dari dua fitur?
  3. Tambahkan plan (dengan one-hot) ke model. Apakah ROC-AUC naik?
  4. Berikan satu contoh fitur yang menyebabkan kebocoran pada kasus churn.

Ringkasan

Fitur baru berguna bila berlandaskan domain dan terbukti memperbaiki validasi. Buat dari informasi yang tersedia saat prediksi, dan lakukan transformasi terlatih di dalam Pipeline.

Berikutnya: Data Latih, Validasi, dan Uji.