Feature Engineering untuk Machine Learning: Teknik dan Pertanyaan Wawancara 2026

Feature engineering menentukan seberapa baik sebuah model machine learning dapat bekerja. Data mentah jarang tersedia dalam format yang bisa langsung dimanfaatkan oleh algoritma — mengubahnya menjadi fitur-fitur yang bermakna menjembatani kesenjangan antara pengumpulan data dan akurasi model.

Strategi Encoding Kategorikal untuk Model ML

Sebagian besar algoritma machine learning membutuhkan input numerik. Variabel kategorikal — label teks seperti "tinggi", "sedang", "rendah" atau nama negara — perlu dikonversi menjadi angka yang dapat diproses oleh model. Strategi encoding yang dipilih secara langsung memengaruhi performa dan interpretabilitas model.

Tiga teknik encoding mencakup mayoritas skenario dunia nyata: label encoding untuk data ordinal, one-hot encoding untuk kategori nominal, dan target encoding untuk fitur dengan kardinalitas tinggi.

# encoding_strategies.py
import pandas as pd
from sklearn.preprocessing import LabelEncoder, OneHotEncoder
from sklearn.compose import ColumnTransformer

df = pd.DataFrame({
    "size": ["small", "medium", "large", "medium", "small"],
    "color": ["red", "blue", "green", "red", "blue"],
    "price": [10, 25, 40, 22, 12]
})

# Label encoding for ordinal feature (size has natural order)
le = LabelEncoder()
df["size_encoded"] = le.fit_transform(df["size"])  # large=0, medium=1, small=2

# One-hot encoding for nominal feature (color has no order)
ct = ColumnTransformer(
    transformers=[
        ("onehot", OneHotEncoder(drop="first", sparse_output=False), ["color"])
    ],
    remainder="passthrough"  # Keep other columns unchanged
)
result = ct.fit_transform(df[["color", "price"]])
# Produces: color_green, color_red columns (blue dropped as reference)

Label encoding cocok untuk fitur ordinal di mana urutan numerik sesuai dengan urutan kategori. One-hot encoding mencegah model menafsirkan hubungan ordinal yang salah di antara kategori nominal. Parameter drop="first" menghindari dummy variable trap dengan menghapus satu kolom yang redundan.

Feature Scaling: StandardScaler vs MinMaxScaler vs RobustScaler

Algoritma berbasis jarak (KNN, SVM, K-Means) dan optimizer gradient descent memperlakukan semua fitur secara setara secara default. Kolom gaji dengan rentang 30.000 hingga 200.000 akan mendominasi kolom pengalaman kerja dengan rentang 0 hingga 40 tanpa adanya scaling.

Pemilihan scaler bergantung pada distribusi data dan sensitivitas terhadap outlier.

# feature_scaling.py
import numpy as np
from sklearn.preprocessing import StandardScaler, MinMaxScaler, RobustScaler

# Simulated dataset: salary with outliers
data = np.array([[35000], [42000], [55000], [67000], [450000]])  # 450k is an outlier

# StandardScaler: mean=0, std=1 (sensitive to outliers)
standard = StandardScaler().fit_transform(data)
# Result: [-0.72, -0.68, -0.60, -0.53, 2.53] — outlier distorts the scale

# MinMaxScaler: maps to [0, 1] (very sensitive to outliers)
minmax = MinMaxScaler().fit_transform(data)
# Result: [0.0, 0.017, 0.048, 0.077, 1.0] — most values crushed near zero

# RobustScaler: uses median and IQR (robust to outliers)
robust = RobustScaler().fit_transform(data)
# Result: [-0.77, -0.5, 0.0, 0.46, 15.38] — outlier isolated, core data preserved

StandardScaler cocok untuk sebagian besar kasus penggunaan — model linear, neural network, dan PCA semuanya mengharapkan fitur yang terstandarisasi. MinMaxScaler sesuai untuk aktivasi terbatas (sigmoid, tanh) dan normalisasi piksel gambar. RobustScaler sebaiknya menjadi pilihan default ketika terdapat outlier dalam dataset, sebagaimana didokumentasikan dalam panduan preprocessing scikit-learn.

Transformasi Matematis untuk Distribusi yang Miring

Fitur yang miring melanggar asumsi normalitas model linear dan memperbesar pengaruh nilai-nilai ekstrem. Transformasi log, akar kuadrat, dan Box-Cox mengompresi ekor distribusi yang miring, mendekatkannya ke distribusi normal.

# skew_transformations.py
import numpy as np
from sklearn.preprocessing import PowerTransformer

# Right-skewed income data (common in real datasets)
income = np.array([[25000], [32000], [41000], [55000], [72000],
                   [150000], [320000], [890000]])

# Log transform: simple, effective for right-skewed data
log_income = np.log1p(income)  # log1p handles zero values safely

# Box-Cox: finds optimal power parameter automatically
pt = PowerTransformer(method="box-cox")  # Requires strictly positive values
income_boxcox = pt.fit_transform(income)
print(f"Optimal lambda: {pt.lambdas_[0]:.3f}")  # Shows learned parameter

# Yeo-Johnson: works with zero and negative values too
pt_yj = PowerTransformer(method="yeo-johnson")
income_yj = pt_yj.fit_transform(income)

PowerTransformer dengan Box-Cox atau Yeo-Johnson secara otomatis mempelajari parameter transformasi yang optimal. Yeo-Johnson dapat menangani nilai nol dan negatif, menjadikannya pilihan default yang lebih aman. Selalu periksa distribusi yang dihasilkan dengan Q-Q plot atau uji Shapiro-Wilk untuk memastikan transformasi memperbaiki normalitas.

Seleksi Fitur: Menghilangkan Noise Sebelum Pelatihan

Lebih banyak fitur tidak selalu berarti prediksi yang lebih baik. Fitur yang tidak relevan atau redundan memperkenalkan noise, meningkatkan waktu pelatihan, dan menyebabkan overfitting — terutama dalam dataset berdimensi tinggi di mana jumlah fitur mendekati atau melebihi jumlah sampel.

Tiga kategori metode seleksi fitur: metode filter (uji statistik), metode wrapper (evaluasi berbasis model), dan metode embedded (terintegrasi dalam proses pelatihan).

# feature_selection.py
from sklearn.datasets import make_classification
from sklearn.feature_selection import (
    SelectKBest, f_classif,  # Filter method
    SequentialFeatureSelector,  # Wrapper method
    SelectFromModel  # Embedded method
)
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LassoCV

# Dataset: 20 features, only 5 are informative
X, y = make_classification(
    n_samples=1000, n_features=20,
    n_informative=5, n_redundant=3, random_state=42
)

# Filter: ANOVA F-test selects top k features by statistical significance
selector_filter = SelectKBest(f_classif, k=8)
X_filtered = selector_filter.fit_transform(X, y)
print(f"Selected features: {selector_filter.get_support(indices=True)}")

# Embedded: L1 regularization (Lasso) zeros out irrelevant feature weights
lasso = LassoCV(cv=5, random_state=42).fit(X, y)
selector_embedded = SelectFromModel(lasso, prefit=True)
X_lasso = selector_embedded.transform(X)
print(f"Lasso kept {X_lasso.shape[1]} features out of {X.shape[1]}")

Metode filter (ANOVA, chi-squared, mutual information) berjalan cepat tetapi mengevaluasi fitur secara independen — mereka tidak menangkap interaksi antar fitur. Metode embedded seperti regularisasi Lasso melakukan seleksi selama pelatihan, menghasilkan model yang lebih sparse dan mampu melakukan generalisasi dengan lebih baik. Untuk pemahaman lebih dalam tentang algoritma di balik model-model ini, panduan algoritma machine learning membahas dasar-dasar matematisnya.

Membangun Pipeline Siap Produksi dengan ColumnTransformer

Menyebarkan langkah-langkah preprocessing di seluruh sel notebook menciptakan alur kerja yang rapuh dan tidak dapat direproduksi. Pipeline dan ColumnTransformer dari scikit-learn mengenkapsulasi seluruh proses feature engineering ke dalam satu objek yang dapat diserialisasi dan mencegah kebocoran data selama cross-validation.

# production_pipeline.py
import pandas as pd
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.model_selection import cross_val_score

# Define column groups by type
numeric_features = ["age", "income", "credit_score"]
categorical_features = ["education", "employment_type", "region"]

# Numeric pipeline: impute missing values, then scale
numeric_pipeline = Pipeline([
    ("imputer", SimpleImputer(strategy="median")),  # Median resists outliers
    ("scaler", StandardScaler())
])

# Categorical pipeline: impute missing, then one-hot encode
categorical_pipeline = Pipeline([
    ("imputer", SimpleImputer(strategy="most_frequent")),
    ("encoder", OneHotEncoder(handle_unknown="ignore", sparse_output=False))
])

# Combine into a single preprocessor
preprocessor = ColumnTransformer([
    ("num", numeric_pipeline, numeric_features),
    ("cat", categorical_pipeline, categorical_features)
])

# Full pipeline: preprocessing + model in one object
full_pipeline = Pipeline([
    ("preprocessor", preprocessor),
    ("classifier", GradientBoostingClassifier(n_estimators=200, random_state=42))
])

# Cross-validation applies preprocessing correctly within each fold
scores = cross_val_score(full_pipeline, X, y, cv=5, scoring="roc_auc")
print(f"AUC: {scores.mean():.3f} +/- {scores.std():.3f}")

Pipeline menjamin bahwa statistik imputasi, parameter scaling, dan pemetaan encoding hanya dihitung dari data pelatihan dalam setiap fold cross-validation. Memanggil full_pipeline.fit(X_train, y_train) diikuti dengan full_pipeline.predict(X_test) menerapkan transformasi yang identik tanpa kebocoran informasi. Seluruh pipeline dapat diserialisasi menggunakan joblib.dump() untuk keperluan deployment.

Feature Engineering Otomatis dengan Featuretools

Feature engineering manual berfungsi baik untuk dataset terstruktur dengan beberapa lusin kolom. Dataset relasional yang mencakup beberapa tabel — transaksi yang terhubung ke pelanggan yang terhubung ke merchant — membutuhkan pendekatan otomatis untuk mengeksplorasi kombinasi fitur secara sistematis.

Featuretools mengimplementasikan Deep Feature Synthesis (DFS), yang menelusuri hubungan antar entitas dan menerapkan primitif transformasi dan agregasi untuk menghasilkan ratusan fitur kandidat secara otomatis.

# automated_feature_engineering.py
import featuretools as ft
import pandas as pd

# Define entities from relational tables
customers = pd.DataFrame({
    "customer_id": [1, 2, 3],
    "signup_date": pd.to_datetime(["2024-01-15", "2024-03-22", "2024-06-01"]),
    "region": ["US", "EU", "APAC"]
})

transactions = pd.DataFrame({
    "txn_id": range(1, 8),
    "customer_id": [1, 1, 1, 2, 2, 3, 3],
    "amount": [50, 120, 30, 200, 85, 340, 15],
    "category": ["food", "tech", "food", "tech", "travel", "food", "tech"]
})

# Create an EntitySet with relationships
es = ft.EntitySet(id="retail")
es = es.add_dataframe(dataframe=customers, dataframe_name="customers",
                      index="customer_id", time_index="signup_date")
es = es.add_dataframe(dataframe=transactions, dataframe_name="transactions",
                      index="txn_id")
es = es.add_relationship("customers", "customer_id",
                         "transactions", "customer_id")

# DFS generates features: COUNT, MEAN, MAX, STD of transactions per customer
feature_matrix, feature_defs = ft.dfs(
    entityset=es, target_dataframe_name="customers",
    max_depth=2,  # Controls complexity of generated features
    trans_primitives=["month", "weekday"],  # Transformation primitives
    agg_primitives=["count", "mean", "std", "max"]  # Aggregation primitives
)
print(f"Generated {len(feature_defs)} features from 2 tables")

DFS menghasilkan fitur seperti MEAN(transactions.amount), STD(transactions.amount), dan COUNT(transactions) — agregasi yang biasanya dibuat secara manual oleh data scientist tetapi dalam waktu yang jauh lebih singkat. Parameter max_depth mengontrol kompleksitas fitur: kedalaman 2 menghasilkan agregasi bersarang seperti STD(transactions.MONTH(signup_date)).

Pertanyaan Wawancara Feature Engineering yang Sering Muncul

Wawancara data science pada tahun 2026 menguji pemahaman teoretis dan implementasi praktis dari feature engineering. Pertanyaan-pertanyaan berikut sering muncul dalam wawancara di perusahaan teknologi besar maupun startup.

T: Bagaimana cara menangani fitur kategorikal dengan 10.000+ nilai unik?

Kategorikal dengan kardinalitas tinggi tidak bisa menggunakan one-hot encoding — karena akan menghasilkan 10.000 kolom sparse. Strategi efektif meliputi: target encoding (dengan cross-validation yang tepat untuk menghindari kebocoran), frequency encoding (mengganti kategori dengan jumlah kemunculannya), hashing (menggunakan HashingVectorizer untuk memetakan kategori ke ruang berukuran tetap), dan embedding layer dalam neural network.

T: Kapan sebaiknya TIDAK melakukan scaling pada fitur?

Model berbasis tree (Random Forest, XGBoost, LightGBM) bersifat invarian terhadap transformasi monoton pada fitur. Scaling hanya menambah komputasi yang tidak perlu tanpa memengaruhi split. Model berbasis jarak dan neural network selalu membutuhkan scaling.

T: Jelaskan perbedaan antara feature selection dan dimensionality reduction.

Feature selection mempertahankan subset dari fitur asli — fitur yang terpilih tetap dapat diinterpretasi. Dimensionality reduction (PCA, t-SNE, UMAP) membuat fitur sintetis baru sebagai kombinasi linear atau nonlinear dari fitur asli. Komponen PCA memaksimalkan explained variance tetapi kehilangan interpretabilitas langsung. Pilihan yang tepat bergantung pada apakah explainability model menjadi persyaratan proyek.

T: Bagaimana cara mendeteksi dan menangani multikolinearitas?

Variance Inflation Factor (VIF) di atas 5-10 menandakan multikolinearitas yang bermasalah. Matriks korelasi menangkap hubungan berpasangan tetapi tidak mendeteksi dependensi multi-variabel. Solusi yang dapat diterapkan meliputi menghapus salah satu fitur yang berkorelasi, menggabungkannya (PCA pada subset yang berkorelasi), atau menggunakan regularisasi (Ridge/Lasso) yang menangani kolinearitas secara internal.

Untuk praktik langsung dengan library manipulasi data Python yang penting dalam feature engineering, panduan Python untuk Data Science membahas alur kerja NumPy, Pandas, dan scikit-learn secara mendalam.

Kesimpulan

• Lakukan encoding kategorikal dengan sengaja: label encoding untuk data ordinal, one-hot untuk nominal, target encoding (di dalam fold CV) untuk fitur kardinalitas tinggi
• Skalakan fitur berdasarkan kebutuhan model: StandardScaler untuk model linear dan neural network, lewati scaling untuk model berbasis tree
• Terapkan transformasi power (PowerTransformer) untuk mengurangi skewness sebelum memasukkan data ke algoritma yang mengasumsikan normalitas
• Seleksi fitur secara sistematis menggunakan metode filter untuk kecepatan, metode embedded (Lasso) untuk akurasi, dan selalu validasi dengan cross-validation
• Bungkus semua preprocessing ke dalam Pipeline + ColumnTransformer scikit-learn untuk mencegah kebocoran data dan memastikan reprodusibilitas
• Otomatisasi pembuatan fitur dengan Featuretools DFS untuk dataset relasional yang mencakup beberapa tabel
• Berlatihlah menjelaskan keputusan feature engineering dalam istilah bisnis — pewawancara mengevaluasi keterampilan teknis sekaligus kejelasan komunikasi