Tutorial 15 mnt baca

Panduan Lengkap Feature Engineering dengan Scikit-Learn Pipeline dan ColumnTransformer

Pelajari feature engineering secara menyeluruh menggunakan scikit-learn Pipeline dan ColumnTransformer. Tutorial langkah demi langkah dengan contoh kode Python yang siap dijalankan — dari teknik dasar hingga custom transformer dan hyperparameter tuning.

Editorial Team
Feature Engineering Scikit-Learn 2026 Guide

Kenapa Feature Engineering Itu Penting Banget?

Kalau kamu pernah bikin model machine learning dan hasilnya... ya, biasa aja — akurasi mentok, prediksi meleset — kemungkinan besar masalahnya bukan di algoritma yang kamu pakai. Masalahnya ada di fitur. Data mentah yang kamu lempar langsung ke model itu ibarat bahan masakan yang belum dicuci, belum dipotong, apalagi dibumbui.

Hasilnya? Nggak enak. Titik.

Feature engineering adalah proses mengubah data mentah menjadi fitur-fitur yang lebih informatif dan bermakna bagi model machine learning. Ini mencakup banyak hal — membuat fitur baru dari data yang sudah ada, mengubah format fitur, menangani missing values, encoding variabel kategorikal, scaling fitur numerik, dan masih banyak lagi. Jujur, ini bagian yang sering di-skip padahal dampaknya luar biasa besar.

Menurut berbagai survei, data scientist menghabiskan sekitar 60-80% waktu mereka untuk data preprocessing dan feature engineering. Angka yang gila, kan? Tapi masuk akal. Model yang sama — misalnya Random Forest atau Logistic Regression — bisa memberikan akurasi yang jauh berbeda tergantung kualitas fitur yang kamu masukkan.

Di panduan ini, kita akan bahas feature engineering secara menyeluruh menggunakan scikit-learn 1.8 dan pandas 3.0. Bukan cuma teori — semua disertai kode yang bisa langsung kamu jalankan. Kita akan bangun pipeline preprocessing dari nol sampai siap produksi. So, let's dive in.

Persiapan Lingkungan Kerja

Instalasi Library

Pastikan kamu sudah menginstal library yang dibutuhkan. Jalankan perintah berikut di terminal:

pip install scikit-learn==1.8.0 pandas==3.0.1 numpy matplotlib seaborn

Kemudian import semua yang kita butuhkan:

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split, GridSearchCV, cross_val_score
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer, make_column_selector
from sklearn.preprocessing import (
    StandardScaler, MinMaxScaler, OneHotEncoder,
    OrdinalEncoder, LabelEncoder, FunctionTransformer
)
from sklearn.impute import SimpleImputer
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report, accuracy_score
import matplotlib.pyplot as plt
import seaborn as sns
import warnings
warnings.filterwarnings("ignore")

print(f"scikit-learn version: {__import__('sklearn').__version__}")
print(f"pandas version: {pd.__version__}")

Dataset: Prediksi Kelangsungan Penumpang Titanic

Untuk tutorial ini, kita pakai dataset Titanic yang tersedia langsung dari URL publik. Kenapa Titanic? Karena dataset ini punya campuran fitur numerik, kategorikal, dan banyak missing values — persis situasi yang bakal kamu temui di dunia nyata. Dataset yang "kotor" justru perfect buat latihan feature engineering.

url = "https://raw.githubusercontent.com/datasciencedojo/datasets/master/titanic.csv"
df = pd.read_csv(url)
print(f"Shape: {df.shape}")
print(f"\nInfo:")
print(df.info())
print(f"\nMissing values:\n{df.isnull().sum()}")
print(f"\nSample data:")
df.head()

Output-nya akan menunjukkan bahwa dataset punya 891 baris dan 12 kolom, dengan missing values di kolom Age, Cabin, dan Embarked.

Teknik Feature Engineering Dasar

1. Membuat Fitur Baru dari Data yang Ada

Ini salah satu teknik paling powerful dalam feature engineering — dan honestly, yang paling seru juga. Kamu pada dasarnya "menggali" informasi tersembunyi yang sudah ada di data. Berikut beberapa contoh:

# Ukuran keluarga = saudara + pasangan + diri sendiri
df["FamilySize"] = df["SibSp"] + df["Parch"] + 1

# Apakah penumpang sendirian?
df["IsAlone"] = (df["FamilySize"] == 1).astype(int)

# Ekstrak gelar dari nama
df["Title"] = df["Name"].str.extract(r" ([A-Za-z]+)\.", expand=False)

# Kelompokkan gelar langka
rare_titles = df["Title"].value_counts()
rare_titles = rare_titles[rare_titles < 10].index
df["Title"] = df["Title"].replace(rare_titles, "Rare")

print(df[["Name", "Title", "FamilySize", "IsAlone"]].head(10))

Dengan menambahkan FamilySize dan IsAlone, kita memberikan model informasi yang lebih terstruktur dibandingkan kolom SibSp dan Parch secara terpisah. Gelar (Title) yang diekstrak dari nama juga mengandung informasi tentang status sosial dan gender — dua faktor yang ternyata cukup berpengaruh terhadap prediksi survival di Titanic.

2. Binning — Mengubah Data Kontinu Jadi Kategori

Binning berguna ketika hubungan antara fitur dan target tidak linear. Kadang model lebih mudah "memahami" data kalau kamu kelompokkan dulu. Misalnya, usia bisa dikelompokkan menjadi kategori:

# Binning usia menjadi kelompok
df["AgeGroup"] = pd.cut(
    df["Age"],
    bins=[0, 12, 18, 35, 60, 100],
    labels=["Anak", "Remaja", "Dewasa_Muda", "Dewasa", "Lansia"]
)

# Binning tarif menjadi kuartil
df["FareGroup"] = pd.qcut(
    df["Fare"],
    q=4,
    labels=["Murah", "Ekonomi", "Bisnis", "Premium"]
)

print(df[["Age", "AgeGroup", "Fare", "FareGroup"]].head(10))

3. Encoding Variabel Kategorikal

Model machine learning umumnya cuma bisa memproses data numerik. Jadi, fitur kategorikal harus diubah ke bentuk angka dulu. Ada beberapa pendekatan yang bisa kamu pakai.

One-Hot Encoding

Cocok untuk fitur kategorikal nominal (tanpa urutan) dengan jumlah kategori yang nggak terlalu banyak:

from sklearn.preprocessing import OneHotEncoder

encoder = OneHotEncoder(sparse_output=False, handle_unknown="ignore", drop="first")
encoded = encoder.fit_transform(df[["Embarked"]].fillna("S"))
encoded_df = pd.DataFrame(
    encoded,
    columns=encoder.get_feature_names_out(["Embarked"])
)
print(encoded_df.head())

Ordinal Encoding

Cocok untuk fitur kategorikal ordinal — yaitu yang punya urutan alami:

from sklearn.preprocessing import OrdinalEncoder

ordinal_enc = OrdinalEncoder(
    categories=[["Murah", "Ekonomi", "Bisnis", "Premium"]]
)
df["FareGroupEncoded"] = ordinal_enc.fit_transform(df[["FareGroup"]])
print(df[["FareGroup", "FareGroupEncoded"]].head())

4. Scaling Fitur Numerik

Beberapa algoritma — seperti Logistic Regression, SVM, dan KNN — sensitif banget terhadap skala fitur. Kalau satu fitur nilainya ratusan ribu dan yang lain cuma 0-1, model bakal "bingung". Dua teknik scaling yang paling umum dipakai:

# StandardScaler: mean=0, std=1
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
df["Age_scaled"] = scaler.fit_transform(df[["Age"]].fillna(df["Age"].median()))

# MinMaxScaler: range [0, 1]
from sklearn.preprocessing import MinMaxScaler
minmax = MinMaxScaler()
df["Fare_scaled"] = minmax.fit_transform(df[["Fare"]])

print(df[["Age", "Age_scaled", "Fare", "Fare_scaled"]].describe())

Tips: Untuk model berbasis pohon (Random Forest, Gradient Boosting, XGBoost), scaling tidak diperlukan karena model ini membuat keputusan berdasarkan threshold, bukan jarak antar fitur. Jadi jangan buang waktu scaling kalau kamu pakai tree-based model.

Membangun Pipeline Preprocessing dengan Scikit-Learn

Apa Itu Pipeline dan Kenapa Kamu Perlu Menggunakannya?

Pipeline di scikit-learn adalah cara untuk mengemas urutan langkah transformasi dan pemodelan menjadi satu objek tunggal. Bayangkan seperti assembly line di pabrik — data mentah masuk dari satu ujung, dan prediksi keluar dari ujung lainnya. Simpel, rapi, dan (yang paling penting) aman dari data leakage.

Keuntungan utama Pipeline:

  • Mencegah data leakage: Transformasi hanya di-fit pada data training
  • Kode lebih bersih: Tidak perlu menulis transformasi manual berulang kali
  • Mudah di-deploy: Satu objek yang bisa disimpan dengan joblib dan digunakan di produksi
  • Kompatibel dengan cross-validation: Semua langkah preprocessing diulang dengan benar di setiap fold

Pipeline Sederhana

Mari mulai dari pipeline paling sederhana — hanya menangani fitur numerik dulu:

from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler

numeric_pipeline = Pipeline(steps=[
    ("imputer", SimpleImputer(strategy="median")),
    ("scaler", StandardScaler())
])

# Contoh penggunaan
import numpy as np
sample_data = pd.DataFrame({
    "Age": [22, np.nan, 35, 28, np.nan, 45],
    "Fare": [7.25, 71.28, 8.05, np.nan, 13.0, 53.1]
})

transformed = numeric_pipeline.fit_transform(sample_data)
print("Data setelah transformasi:")
print(pd.DataFrame(transformed, columns=["Age", "Fare"]))

Pipeline di atas melakukan dua langkah: mengisi missing values dengan median, kemudian standarisasi. Dua langkah, satu baris fit_transform(). Nggak perlu ribet.

ColumnTransformer: Jantung Preprocessing Modern

Mengapa ColumnTransformer Itu Game-Changer?

Di dunia nyata, dataset hampir selalu punya campuran kolom numerik dan kategorikal. Dan ini yang bikin repot — kedua tipe ini butuh transformasi yang berbeda. Kamu nggak bisa menerapkan StandardScaler ke kolom Gender, dan kamu juga nggak bisa menerapkan OneHotEncoder ke kolom Age. Hasilnya bakal error atau nonsense.

Di sinilah ColumnTransformer berperan. Ia memungkinkan kamu menerapkan pipeline berbeda ke subset kolom yang berbeda, lalu menggabungkan hasilnya menjadi satu matriks fitur. Menurut saya pribadi, ini salah satu fitur terbaik yang pernah ditambahkan ke scikit-learn.

Implementasi Langkah demi Langkah

Langkah 1: Siapkan data dan identifikasi tipe kolom.

# Persiapan dataset
df = pd.read_csv(url)
df["FamilySize"] = df["SibSp"] + df["Parch"] + 1
df["IsAlone"] = (df["FamilySize"] == 1).astype(int)
df["Title"] = df["Name"].str.extract(r" ([A-Za-z]+)\.", expand=False)
rare_titles = df["Title"].value_counts()
rare_titles = rare_titles[rare_titles < 10].index
df["Title"] = df["Title"].replace(rare_titles, "Rare")

# Definisikan fitur dan target
feature_cols = ["Pclass", "Sex", "Age", "Fare", "Embarked",
                "FamilySize", "IsAlone", "Title"]
X = df[feature_cols]
y = df["Survived"]

# Identifikasi kolom berdasarkan tipe
numerical_features = ["Age", "Fare", "FamilySize"]
categorical_features = ["Pclass", "Sex", "Embarked", "Title"]
binary_features = ["IsAlone"]

print(f"Fitur numerik: {numerical_features}")
print(f"Fitur kategorikal: {categorical_features}")
print(f"Fitur biner: {binary_features}")

Langkah 2: Buat sub-pipeline untuk setiap tipe fitur.

# Pipeline untuk fitur numerik
numerical_pipeline = Pipeline(steps=[
    ("imputer", SimpleImputer(strategy="median")),
    ("scaler", StandardScaler())
])

# Pipeline untuk fitur kategorikal
categorical_pipeline = Pipeline(steps=[
    ("imputer", SimpleImputer(strategy="most_frequent")),
    ("encoder", OneHotEncoder(
        drop="first",
        sparse_output=False,
        handle_unknown="ignore"
    ))
])

Langkah 3: Gabungkan semuanya dengan ColumnTransformer.

from sklearn.compose import ColumnTransformer

preprocessor = ColumnTransformer(
    transformers=[
        ("num", numerical_pipeline, numerical_features),
        ("cat", categorical_pipeline, categorical_features),
        ("bin", "passthrough", binary_features)
    ],
    remainder="drop"  # Buang kolom yang tidak disebutkan
)

print("Preprocessor siap!")
print(preprocessor)

Perhatikan parameter remainder="drop". Ini berarti kolom yang tidak termasuk dalam ketiga grup akan dibuang. Kamu bisa menggantinya dengan "passthrough" kalau ingin menyimpan semua kolom lainnya tanpa transformasi.

Langkah 4: Buat pipeline end-to-end dengan model.

# Pipeline lengkap: preprocessing + model
full_pipeline = Pipeline(steps=[
    ("preprocessor", preprocessor),
    ("classifier", RandomForestClassifier(
        n_estimators=200,
        random_state=42,
        n_jobs=-1
    ))
])

# Split data
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# Training
full_pipeline.fit(X_train, y_train)

# Evaluasi
y_pred = full_pipeline.predict(X_test)
print(f"Akurasi: {accuracy_score(y_test, y_pred):.4f}")
print(f"\nClassification Report:")
print(classification_report(y_test, y_pred, target_names=["Tidak Selamat", "Selamat"]))

Menggunakan make_column_selector untuk Seleksi Otomatis

Nggak mau repot menulis daftar kolom secara manual? Pakai make_column_selector untuk memilih kolom otomatis berdasarkan tipe data:

from sklearn.compose import make_column_selector as selector

auto_preprocessor = ColumnTransformer(
    transformers=[
        ("num", numerical_pipeline, selector(dtype_include="number")),
        ("cat", categorical_pipeline, selector(dtype_include="object"))
    ]
)

# Ini sangat berguna ketika kolom bisa berubah
# atau ketika kamu bekerja dengan banyak dataset berbeda
print("Kolom numerik yang terdeteksi:", selector(dtype_include="number")(X))
print("Kolom kategorikal yang terdeteksi:", selector(dtype_include="object")(X))

Catatan: make_column_selector menentukan kolom saat fit() dipanggil, jadi ia lebih robust terhadap perubahan dataset dibandingkan hardcode nama kolom. Fitur kecil tapi sangat berguna.

Hyperparameter Tuning dalam Pipeline

Grid Search yang Mengoptimasi Semuanya Sekaligus

Nah, ini bagian yang menurut saya paling keren dari Pipeline. Kamu bisa mengoptimasi hyperparameter dari preprocessing dan model secara bersamaan menggunakan GridSearchCV. Jadi bukan cuma tuning model — kamu juga bisa eksperimen dengan strategi imputation yang berbeda, misalnya.

Nama parameter menggunakan format nama_langkah__nama_sub_langkah__parameter (pakai double underscore):

param_grid = {
    # Hyperparameter preprocessing
    "preprocessor__num__imputer__strategy": ["mean", "median"],

    # Hyperparameter model
    "classifier__n_estimators": [100, 200, 300],
    "classifier__max_depth": [5, 10, 15, None],
    "classifier__min_samples_split": [2, 5, 10]
}

grid_search = GridSearchCV(
    full_pipeline,
    param_grid,
    cv=5,
    scoring="accuracy",
    n_jobs=-1,
    verbose=1
)

grid_search.fit(X_train, y_train)

print(f"Parameter terbaik: {grid_search.best_params_}")
print(f"Skor CV terbaik: {grid_search.best_score_:.4f}")
print(f"Skor test: {grid_search.score(X_test, y_test):.4f}")

Membandingkan Beberapa Model dalam Pipeline

Kamu juga bisa membandingkan beberapa model menggunakan pipeline preprocessing yang sama. Ini cara yang fair karena semua model mendapat input yang identik:

models = {
    "Logistic Regression": LogisticRegression(max_iter=1000, random_state=42),
    "Random Forest": RandomForestClassifier(n_estimators=200, random_state=42),
    "Gradient Boosting": GradientBoostingClassifier(n_estimators=200, random_state=42)
}

results = {}
for name, model in models.items():
    pipeline = Pipeline(steps=[
        ("preprocessor", preprocessor),
        ("classifier", model)
    ])

    scores = cross_val_score(pipeline, X_train, y_train, cv=5, scoring="accuracy")
    results[name] = {
        "mean": scores.mean(),
        "std": scores.std()
    }
    print(f"{name}: {scores.mean():.4f} (+/- {scores.std():.4f})")

# Visualisasi perbandingan
fig, ax = plt.subplots(figsize=(10, 5))
model_names = list(results.keys())
means = [results[m]["mean"] for m in model_names]
stds = [results[m]["std"] for m in model_names]
ax.barh(model_names, means, xerr=stds, color=["#2196F3", "#4CAF50", "#FF9800"])
ax.set_xlabel("Akurasi (CV 5-Fold)")
ax.set_title("Perbandingan Model dengan Pipeline yang Sama")
ax.set_xlim(0.7, 0.9)
plt.tight_layout()
plt.show()

Custom Transformer: Buat Transformasi Sendiri

Menggunakan FunctionTransformer

Untuk transformasi sederhana, kamu bisa pakai FunctionTransformer untuk membungkus fungsi Python biasa menjadi transformer yang kompatibel dengan Pipeline. Praktis banget:

from sklearn.preprocessing import FunctionTransformer

# Transformer untuk log transformation
log_transformer = FunctionTransformer(
    func=np.log1p,
    inverse_func=np.expm1,
    validate=True
)

# Contoh penggunaan dalam pipeline
log_pipeline = Pipeline(steps=[
    ("imputer", SimpleImputer(strategy="median")),
    ("log", log_transformer),
    ("scaler", StandardScaler())
])

Membuat Custom Transformer dengan BaseEstimator

Untuk transformasi yang lebih kompleks — misalnya membuat fitur baru secara otomatis — kamu bisa membuat class sendiri. Ini memang butuh sedikit lebih banyak kode, tapi hasilnya sangat fleksibel:

from sklearn.base import BaseEstimator, TransformerMixin

class FeatureCreator(BaseEstimator, TransformerMixin):
    """Transformer kustom untuk membuat fitur baru."""

    def __init__(self, create_family_size=True, create_is_alone=True):
        self.create_family_size = create_family_size
        self.create_is_alone = create_is_alone

    def fit(self, X, y=None):
        return self  # Tidak ada yang perlu di-fit

    def transform(self, X):
        X = X.copy()
        if self.create_family_size:
            X["FamilySize"] = X["SibSp"] + X["Parch"] + 1
        if self.create_is_alone:
            if "FamilySize" in X.columns:
                X["IsAlone"] = (X["FamilySize"] == 1).astype(int)
            else:
                X["IsAlone"] = ((X["SibSp"] + X["Parch"]) == 0).astype(int)
        return X

# Integrasi ke pipeline
enhanced_pipeline = Pipeline(steps=[
    ("feature_creator", FeatureCreator()),
    ("preprocessor", preprocessor),
    ("classifier", RandomForestClassifier(n_estimators=200, random_state=42))
])

Dengan custom transformer, kamu bisa memasukkan seluruh logika feature engineering ke dalam pipeline. Artinya semua transformasi — termasuk pembuatan fitur baru — dieksekusi secara otomatis dan konsisten, baik saat training maupun inference. Nggak ada lagi cerita "lupa jalankan step X sebelum prediksi".

Menyimpan dan Memuat Pipeline untuk Produksi

Oke, pipeline sudah dioptimasi. Sekarang gimana cara deploy-nya? Simpan sebagai satu file menggunakan joblib:

import joblib

# Simpan pipeline lengkap
joblib.dump(full_pipeline, "titanic_pipeline.joblib")
print("Pipeline disimpan!")

# Muat kembali
loaded_pipeline = joblib.load("titanic_pipeline.joblib")

# Langsung bisa digunakan untuk prediksi
new_data = pd.DataFrame({
    "Pclass": [1],
    "Sex": ["female"],
    "Age": [29.0],
    "Fare": [100.0],
    "Embarked": ["C"],
    "FamilySize": [1],
    "IsAlone": [1],
    "Title": ["Mrs"]
})

prediction = loaded_pipeline.predict(new_data)
probability = loaded_pipeline.predict_proba(new_data)
print(f"Prediksi: {'Selamat' if prediction[0] == 1 else 'Tidak Selamat'}")
print(f"Probabilitas selamat: {probability[0][1]:.2%}")

Satu file .joblib, satu objek pipeline, dan kamu sudah siap deploy. Semudah itu.

Best Practice Feature Engineering di 2026

Berdasarkan pengalaman (dan beberapa kali kena data leakage yang bikin frustrasi), berikut praktik terbaik yang perlu kamu ikuti:

  1. Selalu gunakan Pipeline: Jangan pernah melakukan transformasi manual di luar pipeline untuk data yang akan masuk ke model. Ini mencegah data leakage dan memastikan konsistensi antara training dan inference.
  2. Gunakan OneHotEncoder daripada pd.get_dummies(): get_dummies() tidak menyimpan state dan bisa menghasilkan jumlah kolom berbeda antara training dan test data. OneHotEncoder di dalam pipeline jauh lebih aman.
  3. Set handle_unknown="ignore": Pada OneHotEncoder, parameter ini mencegah error ketika data baru mengandung kategori yang tidak ada di data training. Trust me, ini menyelamatkan banyak pipeline di produksi.
  4. Split data sebelum feature engineering: Fit transformer hanya pada data training. Gunakan transform() — bukan fit_transform() — pada data test.
  5. Pertimbangkan tipe model: Model berbasis pohon tidak butuh scaling, tapi model linear dan distance-based sangat membutuhkannya. Sesuaikan pipeline-mu.
  6. Manfaatkan fitur baru scikit-learn 1.8: Versi terbaru mendukung Array API untuk komputasi GPU dengan PyTorch dan CuPy, serta peningkatan performa untuk model L1-penalized.
  7. Dokumentasikan pipeline-mu: Gunakan nama yang deskriptif untuk setiap langkah di pipeline sehingga orang lain (dan kamu di masa depan) bisa memahaminya dengan cepat.

Visualisasi Pipeline

Scikit-learn 1.8 menyediakan representasi HTML interaktif dari pipeline. Ini fitur yang kecil tapi super helpful untuk debugging:

from sklearn import set_config
set_config(display="diagram")

# Tampilkan diagram pipeline di Jupyter Notebook
full_pipeline

Kalau kamu bekerja di Jupyter Notebook, pipeline akan ditampilkan sebagai diagram interaktif yang bisa diklik untuk melihat detail setiap langkah. Sangat membantu ketika pipeline-mu sudah kompleks dengan banyak sub-pipeline di dalamnya.

Kesalahan Umum yang Harus Dihindari

Berikut beberapa jebakan yang sering banget ditemui (dan saya sendiri pernah kena beberapa di antaranya):

  • Data leakage: Melakukan fit_transform() pada seluruh dataset (termasuk test) sebelum split. Ini menyebabkan model "melihat" informasi dari data test saat training. Akurasi terlihat bagus, tapi di produksi? Beda cerita.
  • Mengabaikan fitur kategorikal: Langsung membuang kolom kategorikal karena model tidak bisa memprosesnya. Padahal, fitur ini sering mengandung informasi yang sangat valuable.
  • Over-engineering fitur: Membuat terlalu banyak fitur yang tidak relevan bisa menyebabkan overfitting. Lebih banyak fitur bukan berarti lebih baik. Gunakan feature selection setelah feature engineering.
  • Menggunakan mean imputation tanpa berpikir: Untuk data yang highly skewed, median biasanya lebih baik daripada mean. Untuk fitur kategorikal, gunakan mode atau nilai khusus seperti "Unknown".
  • Lupa handle unknown categories: Saat deploy, data baru bisa mengandung kategori yang belum pernah dilihat model. Tanpa handle_unknown="ignore", pipeline-mu akan crash di produksi. Percaya deh.

FAQ — Pertanyaan yang Sering Diajukan

Apa perbedaan antara Pipeline dan ColumnTransformer di scikit-learn?

Pipeline mengeksekusi serangkaian transformasi secara berurutan pada data yang sama — misalnya imputation lalu scaling. Sedangkan ColumnTransformer menerapkan transformasi yang berbeda pada subset kolom yang berbeda secara paralel, lalu menggabungkan hasilnya. Dalam praktiknya, keduanya sering digunakan bersama: ColumnTransformer berisi beberapa sub-Pipeline, dan keseluruhannya dibungkus lagi dalam Pipeline utama bersama model.

Apakah feature scaling diperlukan untuk semua model machine learning?

Tidak. Model berbasis pohon seperti Random Forest, Gradient Boosting, dan XGBoost tidak memerlukan scaling karena mereka membuat keputusan berdasarkan threshold, bukan jarak. Namun, model linear (Logistic Regression, Linear SVM) dan model berbasis jarak (KNN, SVM dengan kernel RBF) sangat memerlukan scaling agar fitur dengan skala besar tidak mendominasi.

Bagaimana cara menghindari data leakage saat feature engineering?

Kuncinya sederhana: selalu split data sebelum transformasi apapun. Gunakan Pipeline scikit-learn untuk memastikan semua transformasi hanya di-fit pada data training. Saat cross-validation, Pipeline otomatis mengulangi proses fit-transform di setiap fold, jadi data leakage dicegah tanpa effort tambahan dari kamu.

Kapan sebaiknya menggunakan pd.get_dummies() vs OneHotEncoder?

Gunakan pd.get_dummies() hanya untuk eksplorasi data awal dan analisis cepat. Untuk pipeline ML yang akan digunakan di produksi, selalu gunakan OneHotEncoder dari scikit-learn. Alasannya: OneHotEncoder menyimpan state (kategori yang dipelajari saat fit), bisa menangani kategori baru, dan terintegrasi sempurna dengan Pipeline dan GridSearchCV.

Apa yang baru di scikit-learn 1.8 untuk feature engineering?

Scikit-learn 1.8 (dirilis Desember 2025) membawa beberapa update menarik: dukungan Array API untuk komputasi GPU menggunakan PyTorch dan CuPy pada beberapa transformer seperti StandardScaler; peningkatan performa signifikan untuk model L1-penalized berkat gap safe screening rules; dukungan free-threaded CPython; serta fitur baru Classical MDS di modul manifold. Kalau kamu kerja dengan dataset besar, update ini cukup terasa dampaknya.

Tentang Penulis Editorial Team

Our team of expert writers and editors.

Artikel Terkait