Algoritma Machine Learning untuk Wawancara Teknis: Panduan Lengkap 2026

Algoritma machine learning telah menjadi salah satu topik paling sering dibahas dalam wawancara teknis di bidang data science dan rekayasa perangkat lunak. Pemahaman yang mendalam tentang cara kerja algoritma-algoritma ini, kapan menggunakannya, dan bagaimana mengevaluasi performanya merupakan keahlian yang sangat dicari oleh perusahaan teknologi pada tahun 2026. Artikel ini menyajikan panduan komprehensif yang mencakup konsep-konsep inti dari supervised learning hingga teknik evaluasi model, lengkap dengan contoh kode Python yang siap digunakan dalam sesi coding interview.

Supervised Learning: Regresi dan Klasifikasi

Supervised learning adalah paradigma machine learning di mana model dilatih menggunakan data berlabel — setiap sampel pelatihan memiliki input (fitur) dan output yang diketahui (target). Dua tugas utama dalam supervised learning adalah regresi (memprediksi nilai kontinu) dan klasifikasi (memprediksi kategori diskrit).

Regresi Linear

Regresi linear adalah fondasi dari hampir semua teknik supervised learning. Model ini mengasumsikan hubungan linear antara variabel input dan output, mengoptimalkan koefisien dengan meminimalkan jumlah kuadrat error (Ordinary Least Squares). Meskipun sederhana, regresi linear sangat efektif sebagai baseline dan sering menghasilkan performa yang kompetitif pada data dengan hubungan yang memang linear.

Dalam konteks wawancara, kandidat sering diminta untuk menjelaskan asumsi-asumsi regresi linear: linearitas antara fitur dan target, independensi residual, homoskedastisitas (varians error yang konstan), dan normalitas residual. Memahami kapan asumsi-asumsi ini dilanggar dan dampaknya terhadap prediksi adalah penanda kandidat yang kuat.

# linear_regression_demo.py
import numpy as np
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error, r2_score

# Generate synthetic housing data: square footage -> price
np.random.seed(42)
sqft = np.random.uniform(500, 3000, size=200).reshape(-1, 1)
price = 150 * sqft.flatten() + np.random.normal(0, 20000, size=200)

X_train, X_test, y_train, y_test = train_test_split(sqft, price, test_size=0.2)

model = LinearRegression()
model.fit(X_train, y_train)                    # Fit on training data
predictions = model.predict(X_test)            # Predict on unseen data

print(f"Coefficient: {model.coef_[0]:.2f}")    # Weight per sqft
print(f"R2 Score: {r2_score(y_test, predictions):.4f}")
print(f"RMSE: {np.sqrt(mean_squared_error(y_test, predictions)):.2f}")

Regresi Logistik untuk Klasifikasi

Meskipun namanya mengandung kata "regresi", regresi logistik adalah algoritma klasifikasi yang menggunakan fungsi sigmoid untuk memetakan output ke probabilitas antara 0 dan 1. Algoritma ini menjadi baseline yang sangat populer untuk tugas klasifikasi biner karena mudah diinterpretasikan — koefisien modelnya dapat dibaca sebagai log-odds dari kelas positif.

Hal yang perlu dipahami dalam wawancara adalah perbedaan antara output probabilitas dan keputusan kelas, serta bagaimana parameter regularisasi C mempengaruhi batas keputusan. Nilai C yang kecil berarti regularisasi yang lebih kuat (model lebih sederhana), sedangkan C yang besar memungkinkan model mengikuti data pelatihan lebih ketat.

# logistic_classification.py
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report

data = load_breast_cancer()                    # Binary classification dataset
X_train, X_test, y_train, y_test = train_test_split(
    data.data, data.target, test_size=0.2, random_state=42
)

clf = LogisticRegression(max_iter=5000, C=1.0) # C controls regularization strength
clf.fit(X_train, y_train)
y_pred = clf.predict(X_test)

print(classification_report(y_test, y_pred, target_names=data.target_names))

Output classification report mencakup precision, recall, dan F1-score untuk setiap kelas. Kemampuan menginterpretasikan metrik-metrik ini adalah keterampilan esensial yang sering diuji dalam wawancara, terutama dalam skenario data tidak seimbang di mana accuracy tidak cukup sebagai ukuran performa.

Decision Tree dan Metode Ensemble

Decision tree membangun model prediksi berbentuk struktur pohon dengan mempartisi ruang fitur secara rekursif berdasarkan aturan if-else. Setiap node internal mewakili keputusan berdasarkan satu fitur, setiap cabang mewakili hasil keputusan, dan setiap daun mewakili prediksi akhir. Meskipun decision tree tunggal rentan terhadap overfitting dan sensitif terhadap variasi kecil dalam data, metode ensemble yang menggabungkan banyak pohon menghasilkan model yang jauh lebih robust dan akurat.

Random Forest vs Gradient Boosting

Dua metode ensemble yang paling dominan adalah Random Forest dan Gradient Boosting. Keduanya menggabungkan decision tree, tetapi dengan cara yang sangat berbeda:

Random Forest membangun pohon-pohon secara paralel dan independen menggunakan subset acak dari data (bagging) dan subset acak dari fitur di setiap split. Keberagaman pohon-pohon ini mengurangi varians melalui agregasi, menghasilkan model yang lebih stabil dan tahan terhadap noise.

Gradient Boosting membangun pohon secara sekuensial, di mana setiap pohon baru dilatih untuk memprediksi residual (error) dari model sebelumnya. Pendekatan ini secara bertahap mengurangi bias melalui gradient descent dalam ruang fungsi, menghasilkan model yang sangat akurat pada data tabular yang bersih.

# ensemble_comparison.py
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.model_selection import cross_val_score
from sklearn.datasets import load_wine

X, y = load_wine(return_X_y=True)

# Random Forest: parallel trees, reduces variance
rf = RandomForestClassifier(n_estimators=100, max_depth=5, random_state=42)
rf_scores = cross_val_score(rf, X, y, cv=5, scoring='accuracy')

# Gradient Boosting: sequential trees, reduces bias
gb = GradientBoostingClassifier(n_estimators=100, learning_rate=0.1, max_depth=3)
gb_scores = cross_val_score(gb, X, y, cv=5, scoring='accuracy')

print(f"Random Forest:     {rf_scores.mean():.4f} +/- {rf_scores.std():.4f}")
print(f"Gradient Boosting: {gb_scores.mean():.4f} +/- {gb_scores.std():.4f}")

Tabel Perbandingan: Random Forest vs Gradient Boosting

| Kriteria | Random Forest | Gradient Boosting | |----------|---------------|-------------------| | Kecepatan pelatihan | Cepat (paralel) | Lebih lambat (sekuensial) | | Risiko overfitting | Rendah | Lebih tinggi tanpa tuning | | Sensitivitas hyperparameter | Rendah | Tinggi | | Feature importance | Bawaan (berbasis impuritas) | Bawaan (berbasis gain) | | Terbaik untuk | Model baseline, data noisy | Kompetisi, data tabular |

Unsupervised Learning: Clustering dan PCA

Unsupervised learning bekerja pada data tanpa label, mencari pola dan struktur tersembunyi secara mandiri. Tidak ada "jawaban benar" yang dapat digunakan untuk mengukur performa secara langsung — evaluasi bergantung pada metrik internal atau validasi domain. Dua teknik yang paling fundamental adalah clustering (mengelompokkan data yang serupa) dan dimensionality reduction (mereduksi dimensi fitur sambil mempertahankan informasi penting).

K-Means Clustering

K-Means adalah algoritma clustering yang paling banyak digunakan. Algoritma ini mempartisi data menjadi k kelompok dengan meminimalkan jumlah kuadrat jarak antara setiap titik data dengan centroid kelompoknya melalui iterasi. Proses ini bergantian antara langkah assignment (setiap titik ditugaskan ke centroid terdekat) dan langkah update (centroid diperbarui sebagai rata-rata anggota kelompok).

Tantangan utama K-Means adalah menentukan nilai k yang optimal. Dua metode yang umum digunakan adalah elbow method (mencari titik "siku" pada plot inertia vs k) dan silhouette score (mengukur seberapa mirip titik data dengan kelompoknya sendiri dibandingkan kelompok terdekat lainnya, dengan rentang -1 hingga 1).

# kmeans_clustering.py
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import silhouette_score
from sklearn.datasets import load_iris

data = load_iris()
X = StandardScaler().fit_transform(data.data)  # Scale features first

# Test multiple values of k to find optimal cluster count
for k in [2, 3, 4, 5]:
    kmeans = KMeans(n_clusters=k, n_init=10, random_state=42)
    labels = kmeans.fit_predict(X)
    sil = silhouette_score(X, labels)          # Higher = better-defined clusters
    inertia = kmeans.inertia_                  # Within-cluster sum of squares
    print(f"k={k}: silhouette={sil:.3f}, inertia={inertia:.1f}")

Perhatikan penggunaan StandardScaler sebelum clustering — ini sangat penting karena K-Means sensitif terhadap skala fitur. Fitur dengan rentang nilai besar akan mendominasi perhitungan jarak jika tidak dinormalisasi. Ini adalah salah satu kesalahan umum yang diperhatikan interviewer dalam coding exercise.

Keterbatasan K-Means yang perlu diketahui: algoritma ini mengasumsikan kelompok berbentuk bulat (spherical) dengan ukuran serupa, sensitif terhadap inisialisasi centroid (diatasi dengan n_init), dan tidak efektif untuk kelompok yang non-convex atau memiliki kepadatan yang sangat berbeda.

Principal Component Analysis (PCA)

PCA adalah teknik dimensionality reduction yang mengubah fitur-fitur berkorelasi menjadi komponen-komponen yang saling tidak berkorelasi (principal components), diurutkan berdasarkan varians yang dijelaskan. Komponen pertama menjelaskan varians terbesar, komponen kedua menjelaskan varians terbesar yang tersisa tegak lurus dengan komponen pertama, dan seterusnya.

PCA sering digunakan sebagai preprocessing sebelum training untuk mengurangi dimensi dan mencegah curse of dimensionality, visualisasi data berdimensi tinggi dalam 2D atau 3D, atau untuk mengurangi noise dengan membuang komponen yang menjelaskan varians sangat kecil.

Dalam wawancara, pertanyaan umum mencakup: apa yang dimaksud dengan explained variance ratio dan bagaimana memilih jumlah komponen (biasanya 95% atau 99% explained variance), apa perbedaan antara PCA dan t-SNE (PCA bersifat linear dan cocok untuk preprocessing, t-SNE non-linear dan hanya untuk visualisasi), serta mengapa standardisasi fitur penting sebelum PCA.

Metrik Evaluasi Model

Memilih metrik evaluasi yang tepat adalah salah satu keputusan terpenting dalam machine learning, terutama pada data yang tidak seimbang (imbalanced dataset). Accuracy yang tinggi bisa menyesatkan jika distribusi kelas sangat tidak merata — model yang selalu memprediksi kelas mayoritas dapat mencapai accuracy 95% pada dataset dengan 5% kelas positif, tetapi sama sekali tidak berguna.

# evaluation_metrics.py
from sklearn.metrics import (
    precision_score, recall_score, f1_score,
    roc_auc_score, confusion_matrix
)
import numpy as np

# Simulated predictions on imbalanced data (5% positive class)
np.random.seed(42)
y_true = np.array([1]*50 + [0]*950)
y_pred = np.array([1]*40 + [0]*10 + [1]*30 + [0]*920)  # Some errors

print(f"Precision: {precision_score(y_true, y_pred):.3f}")  # 40/(40+30) = 0.571
print(f"Recall:    {recall_score(y_true, y_pred):.3f}")     # 40/(40+10) = 0.800
print(f"F1-Score:  {f1_score(y_true, y_pred):.3f}")         # Harmonic mean

cm = confusion_matrix(y_true, y_pred)
print(f"\nConfusion Matrix:\n{cm}")
# [[920, 30],   -> TN=920, FP=30
#  [10,  40]]   -> FN=10,  TP=40

Panduan Memilih Metrik

Pemilihan metrik harus didasarkan pada konsekuensi bisnis dari kesalahan prediksi:

• Precision tinggi diutamakan ketika false positive memiliki biaya tinggi. Contoh: sistem rekomendasi konten — lebih baik melewatkan konten relevan daripada merekomendasikan konten tidak relevan kepada pengguna.
• Recall tinggi diutamakan ketika false negative memiliki biaya tinggi. Contoh: deteksi penyakit atau deteksi fraud — lebih baik melakukan pemeriksaan lanjutan yang tidak perlu daripada melewatkan kasus positif yang kritis.
• F1-Score adalah pilihan seimbang ketika kedua jenis kesalahan sama pentingnya, merupakan rata-rata harmonik dari precision dan recall.
• ROC-AUC mengukur kemampuan model membedakan kelas secara keseluruhan pada berbagai threshold, berguna untuk membandingkan model secara threshold-agnostic.

Bias-Variance Tradeoff dan Regularisasi

Bias-variance tradeoff adalah konsep fundamental yang menjelaskan dua sumber utama error dalam model machine learning. Bias yang tinggi mengindikasikan model terlalu sederhana untuk menangkap pola dalam data (underfitting) — model dengan bias tinggi memiliki performa buruk bahkan pada data pelatihan. Varians yang tinggi mengindikasikan model terlalu kompleks dan terlalu bergantung pada data pelatihan tertentu (overfitting) — model dengan varians tinggi memiliki performa sangat baik pada data pelatihan tetapi buruk pada data baru.

Regularisasi adalah teknik untuk mengurangi varians dengan menambahkan penalti pada kompleksitas model ke dalam fungsi loss. Tiga bentuk regularisasi yang paling umum digunakan pada model linear adalah Ridge (L2), Lasso (L1), dan ElasticNet (kombinasi keduanya).

# regularization_comparison.py
from sklearn.linear_model import Ridge, Lasso, ElasticNet
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import make_pipeline
from sklearn.model_selection import cross_val_score
from sklearn.datasets import load_diabetes

X, y = load_diabetes(return_X_y=True)

models = {
    "Ridge (L2)":      make_pipeline(StandardScaler(), Ridge(alpha=1.0)),
    "Lasso (L1)":      make_pipeline(StandardScaler(), Lasso(alpha=0.1)),
    "ElasticNet (L1+L2)": make_pipeline(StandardScaler(), ElasticNet(alpha=0.1, l1_ratio=0.5)),
}

for name, model in models.items():
    scores = cross_val_score(model, X, y, cv=5, scoring='r2')
    print(f"{name:25s}  R2: {scores.mean():.4f} +/- {scores.std():.4f}")

Perbedaan L1 dan L2 Regularisasi

Perbedaan kunci antara Ridge dan Lasso terletak pada perilaku terhadap koefisien fitur yang tidak relevan:

• Ridge (L2) menambahkan penalti sebesar kuadrat koefisien. Ini mengecilkan semua koefisien mendekati nol tetapi tidak pernah tepat nol. Berguna ketika sebagian besar fitur memiliki kontribusi kecil namun nyata terhadap prediksi.
• Lasso (L1) menambahkan penalti sebesar nilai absolut koefisien. Ini dapat mengatur koefisien menjadi tepat nol, sehingga melakukan feature selection secara otomatis. Sangat berguna ketika banyak fitur tidak relevan.
• ElasticNet menggabungkan keduanya dengan parameter l1_ratio yang mengontrol proporsi L1 vs L2. Memberikan feature selection seperti Lasso sekaligus stabilitas numerik seperti Ridge, terutama berguna ketika fitur-fitur berkorelasi tinggi.

Tips Persiapan Wawancara Machine Learning 2026

Industri teknologi pada tahun 2026 semakin mengintegrasikan machine learning ke dalam berbagai domain produk — dari rekomendasi konten dan deteksi fraud hingga computer vision dan pemrosesan bahasa alami. Wawancara teknis data scientist dan ML engineer kini mencakup kombinasi pertanyaan konseptual, studi kasus, dan sesi coding langsung menggunakan Python dengan library standar seperti scikit-learn, XGBoost, dan PyTorch.

Topik yang Sering Muncul

Beberapa area yang konsisten muncul dalam wawancara machine learning tingkat menengah hingga senior:

Fundamental Statistik dan Probabilitas: Distribusi probabilitas (normal, binomial, Poisson), central limit theorem dan implikasinya, hypothesis testing (t-test, chi-square), p-value, dan confidence interval. Interviewer ingin memastikan kandidat memahami landasan matematis di balik algoritma, bukan hanya cara menggunakan library.

Feature Engineering: Teknik encoding variabel kategorikal (one-hot encoding, target encoding, ordinal encoding), penanganan missing values (imputation vs removal), deteksi dan penanganan outlier, serta pembuatan fitur baru dari domain knowledge. Feature engineering yang baik sering kali lebih berpengaruh terhadap performa model daripada pilihan algoritma.

Cross-Validation dan Model Selection: Perbedaan antara k-fold, stratified k-fold (untuk data imbalanced), dan time series cross-validation (untuk data temporal di mana urutan penting). Bagaimana menghindari data leakage dalam pipeline preprocessing — kesalahan klasik yang sering muncul dalam diskusi wawancara.

Interpretabilitas Model: SHAP values (SHapley Additive exPlanations), LIME (Local Interpretable Model-agnostic Explanations), dan permutation importance. Kemampuan menjelaskan keputusan model kepada stakeholder non-teknis semakin menjadi keharusan, terutama dalam industri yang diregulasi seperti keuangan dan kesehatan.

Deployment dan MLOps: Pemahaman tentang model serving (REST API vs batch inference), monitoring model drift (konsep data drift vs concept drift), dan pipeline retraining. Pertanyaan tentang bagaimana memastikan model tetap performatif setelah deployment ke produksi semakin umum di wawancara senior.

Strategi Menjawab Pertanyaan Desain Sistem ML

Ketika diminta merancang sistem machine learning dari awal, struktur jawaban yang efektif dan disukai interviewer meliputi: (1) klarifikasi problem dan mendefinisikan metrik sukses bisnis dan teknis, (2) eksplorasi data dan identifikasi fitur yang relevan, (3) pemilihan model dengan justifikasinya berdasarkan sifat data dan constraint waktu/resource, (4) strategi evaluasi offline yang robust untuk menghindari data leakage, (5) pertimbangan deployment, monitoring, dan kapan model perlu diretrain.

Hindari langsung melompat ke model yang kompleks seperti neural network atau XGBoost. Interviewer menghargai kandidat yang memulai dengan baseline sederhana (regresi logistik, decision tree) dan secara sistematis menjelaskan kapan dan mengapa model yang lebih kompleks diperlukan berdasarkan karakteristik data dan kebutuhan bisnis.

Latihan Praktis yang Direkomendasikan

Untuk mempersiapkan diri secara efektif, beberapa praktik terbaik meliputi: mengerjakan dataset publik di Kaggle dengan fokus pada interpretasi hasil dan dokumentasi keputusan pemodelan bukan sekadar optimasi akurasi, membaca paper-paper klasik seperti XGBoost (Chen & Guestrin 2016), Random Forests (Breiman 2001), dan Attention Is All You Need (Vaswani 2017), serta berlatih menjelaskan konsep teknis yang kompleks dengan bahasa sederhana yang dapat dipahami oleh non-specialist.

Kesimpulan

Penguasaan algoritma machine learning untuk wawancara teknis memerlukan pemahaman berlapis — dari intuisi matematis hingga implementasi praktis dan interpretasi hasil yang bermakna secara bisnis:

• Supervised learning mencakup regresi (Linear Regression, Ridge, Lasso) dan klasifikasi (Logistic Regression, SVM, Decision Tree), dengan pemilihan berdasarkan sifat target variable dan distribusi data.
• Ensemble methods seperti Random Forest (mengurangi varians melalui bagging paralel) dan Gradient Boosting (mengurangi bias secara sekuensial) adalah workhorses data science modern yang mendominasi kompetisi dan produksi.
• Unsupervised learning melalui K-Means clustering dan PCA memungkinkan eksplorasi pola dalam data tanpa label, dengan standardisasi fitur sebagai prasyarat wajib sebelum keduanya.
• Metrik evaluasi harus dipilih berdasarkan konsekuensi bisnis: precision untuk meminimalkan false positive, recall untuk meminimalkan false negative, F1 sebagai kompromi, dan ROC-AUC untuk perbandingan threshold-agnostic.
• Regularisasi (L1/Lasso untuk feature selection, L2/Ridge untuk koefisien kecil, ElasticNet untuk keduanya) adalah senjata utama melawan overfitting, selalu digunakan bersama normalisasi fitur.
• Bias-variance tradeoff adalah kerangka konseptual yang menjelaskan hampir semua keputusan pemodelan, dari pemilihan kompleksitas model hingga strategi ensemble dan regularisasi.
• Wawancara ML modern menguji kemampuan end-to-end: dari problem framing, feature engineering, pemilihan dan evaluasi model, hingga pertimbangan deployment dan monitoring di lingkungan produksi.