Tugas praktik: Regresi linear, polynomial, & regularisasi
Data Science — materi DS-09
Petunjuk umum
Kerjakan tugas ini di Jupyter Notebook (lokal) atau Google Colab. Laporan akhir berupa berkas PDF yang diekspor dari notebook, lalu unggah ke SCALSA sesuai tenggat dosen.
Rujukan materi: Regresi — linear, polynomial, & regularisasi — slide.
Yang dinilai: perumusan masalah regresi yang jelas; pemisahan train/test yang benar; baseline dan model (linear, polynomial, regularisasi) dengan metrik yang konsisten; validasi silang untuk memilih hiperparameter (bukan mengutak-atik set uji); analisis outlier atau robust minimal satu skenario; kode NumPy / Pandas / scikit-learn yang jalan; narasi singkat per bagian; serta kepatuhan format pengumpulan.
Di bawah ini tersedia lampiran contoh kode — Anda wajib menyesuaikan narasi Markdown, parameter, dan interpretasi; jangan mengumpulkan skrip mentah tanpa penjelasan.
Identitas (isi di notebook Anda)
Di cell Markdown paling atas notebook, tulis:
- Nama lengkap dan NIM
- Kelas / rombel
- Tanggal pengerjaan
- Lingkungan: Jupyter lokal / Google Colab
- Dataset yang dipakai (nama dan sumber)
Persiapan lingkungan
Jupyter lokal
python -m venv .venv
# Windows: .venv\Scripts\activate
# macOS/Linux: source .venv/bin/activate
pip install jupyter pandas numpy scikit-learn matplotlib seaborn ipykernelConda / Mamba / Micromamba: Anda boleh membuat environment terpisah; pastikan kernel Jupyter mengarah ke environment tempat paket tugas terpasang.
Google Colab
numpy, pandas, matplotlib, dan scikit-learn biasanya sudah tersedia. Pasang tambahan hanya jika cell mengeluh modul hilang.
Dataset
Pilih satu dataset dengan target numerik kontinu (regresi). Jangan ganti dataset di tengah pengerjaan.
| Pilihan | Cara memuat (contoh) | Catatan |
|---|---|---|
| A | sklearn.datasets.load_diabetes(as_frame=True) |
Target: progres penyakit diabetes (skor); 10 fitur numerik |
| B | sklearn.datasets.fetch_california_housing(as_frame=True) |
Target: MedHouseVal; fitur geospasial — boleh sample baris jika notebook berat, mis. df.sample(5000, random_state=42) |
| C | Dataset tabular publik lain (Kaggle / OpenML) dengan kolom target kontinu — cantumkan URL di identitas |
Bagian 0 — Rumusan masalah
- Tulis satu paragraf (3–5 kalimat): pertanyaan analitik Anda, variabel target \(y\) yang diprediksi, dan minimal dua fitur \(X\) yang dipakai (boleh lebih).
- Sebutkan metrik utama untuk evaluasi (mis. RMSE dan MAE) dan mengapa dipilih untuk konteks Anda.
Bagian 1 — EDA singkat
- Muat data ke
DataFrame(atauBunch.framedari sklearn).
- Laporkan
shape, cek missing (jumlah per kolom).
- Buat minimal dua visual yang relevan: mis. histogram target, scatter satu fitur vs target, atau heatmap korelasi subset fitur.
- Satu kalimat: apakah hubungan fitur–target terlihat linear atau melengkung secara kasar?
Bagian 2 — Baseline & regresi linear
- Bagi data:
train_test_split(..., test_size=0.2–0.3, random_state=<bilangan tetap>). Untuk California Housing, pertimbangkanshuffle=True(default).
- Baseline: prediktor yang selalu memprediksi rata-rata
y_trainuntuk semua baris uji (boleh manual NumPy atauDummyRegressor(strategy="mean")).
- OLS:
LinearRegression()dilatih padaX_train, y_train.
- Laporkan RMSE dan MAE (dan boleh \(R^2\)) pada set uji untuk baseline dan OLS.
- Jika Anda memakai lebih dari satu fitur: jelaskan arah koefisien OLS untuk dua fitur (positif/negatif) dalam bahasa bisnis/domain, dengan peringatan bahwa ini asosiasi, bukan bukti kausal.
Bagian 3 — Polynomial regression + validasi silang
- Bangun
Pipeline:PolynomialFeatures→LinearRegression. Gunakaninclude_bias=Truesecara konsisten.
- Pilih kandidat derajat polinomial, mis.
degreedalam{1, 2, 3, 4, 5}(sesuaikan jika \(p\) besar — hindari ledakan kolom).
- Gunakan
cross_val_scoreatauGridSearchCVdengan K-fold (mis.KFoldatauShuffleSplit) hanya pada data latih untuk memilih derajat terbaik menurut neg_mean_squared_error atauneg_root_mean_squared_error(sklearn:scoring="neg_root_mean_squared_error"jika versi Anda mendukung; jika tidak, gunakanneg_mean_squared_errordan jelaskan).
- Latih pipeline dengan derajat terpilih pada seluruh train, evaluasi pada test.
- Satu grafik: prediksi vs aktual pada test untuk model polinomial terpilih (scatter + garis identitas
y=x).
- Jelaskan dalam 2–4 kalimat: risiko overfitting jika derajat terlalu tinggi, dan bagaimana CV membantu.
Bagian 4 — Ridge dan/atau Lasso
- Wajib penskalaan fitur sebelum penalti:
StandardScalerdi dalamPipelinesebelumRidgeatauLasso.
- Gunakan
RidgeCVdan/atauLassoCV(atauGridSearchCVdengan rentangalphalog-spaced) dengan CV pada train untuk memilihalpha.
- Bandingkan RMSE test (minimal): OLS pada fitur yang sama vs Ridge vs Lasso (jika hanya salah satu, jelaskan mengapa).
- Satu visual: batang koefisien (OLS vs Ridge vs Lasso pada skala yang sama setelah scaler) untuk subset fitur yang sama, atau tabel koefisien; untuk Lasso, sebutkan berapa koefisien yang tepat nol (jika ada).
Bagian 5 — Outlier & sensitivitas OLS
Pilih salah satu skenario berikut (A atau B):
A — Outlier sintetis
- Salin
X_train, y_trainke variabel baru; tambahkan 1–3 titik outlier (jelaskan di Markdown: outlier vertikal pada \(y\), atau leverage pada \(x\)).
- Latih
LinearRegressionpada data asli vs data ber-outlier; plot scatter + kedua garis regresi (atau dua subplot).
- Laporkan perubahan RMSE/MAE pada test set yang asli (tidak diubah) jika Anda hanya mengubah train — atau jelaskan protokol Anda dengan konsisten.
- Latih
HuberRegressor(dengan atau tanpaPolynomialFeaturesderajat rendah) pada data ber-outlier; bandingkan garis atau metrik dengan OLS.
B — Winsorize / cap
- Definisikan aturan cap pada train saja (mis. batas persentil 1 dan 99 pada target atau satu fitur).
- Terapkan transformasi yang sama ke test (gunakan nilai ambang dari train).
- Bandingkan RMSE test OLS sebelum vs sesudah cap; refleksi singkat: kapan cap etis untuk dilaporkan ke stakeholder?
Bagian 6 — Ringkasan
Lima sampai tujuh poin bullet: metrik utama; model terbaik pada test; derajat polinomial terpilih; nilai alpha Ridge/Lasso; pelajaran tentang outlier atau penskalaan; satu risiko data leakage yang Anda hindari (mis. mem-fit scaler pada train+test sekaligus).
Lampiran — contoh kode referensi
Contoh di bawah memakai load_diabetes (pilihan A). Jika Anda memilih California Housing, ganti blok muat data: fetch_california_housing(as_frame=True), lalu X = data.drop(columns="MedHouseVal"), y = data["MedHouseVal"], dan sesuaikan nama kolom untuk plot.
Urutan blok mengikuti alur pengerjaan: dari impor → data → EDA → model sederhana → polinomial + validasi silang → regularisasi → outlier / winsorize. Baca narasi di bawah setiap blok sebelum menjalankan atau menyalin ke notebook.
Impor & helper metrik
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.datasets import load_diabetes
from sklearn.dummy import DummyRegressor
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score
from sklearn.model_selection import train_test_split
RNG = 42 # ganti jika perlu, tetap konsisten di seluruh notebook
def rmse(y_true, y_pred):
return float(np.sqrt(mean_squared_error(y_true, y_pred)))Narasi: Di sini semua pustaka yang dipakai di contoh berikut diimpor sekaligus agar satu cell “siap jalan”. RNG dipakai di mana pun ada random_state agar hasil reproduksibel (split, K-fold, Lasso). Fungsi rmse membungkus mean_squared_error lalu akar pangkat dua, karena di beberapa versi scikit-learn tidak ada argumen squared=False — satu definisi RMSE dipakai konsisten di seluruh notebook.
Muat data & pemisahan train/test
bunch = load_diabetes(as_frame=True)
X = bunch.data
y = bunch.target
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.25, random_state=RNG
)
print(X_train.shape, X_test.shape)Narasi: as_frame=True mengembalikan fitur sebagai DataFrame Pandas sehingga nama kolom mudah dipakai di plot dan koefisien. X adalah semua prediktor, y adalah target regresi. train_test_split memisahkan 75% / 25% (sesuai test_size); set uji tidak ikut dilatih — nanti dipakai hanya sekali untuk metrik akhir yang adil. Cetak shape untuk memastikan proporsi baris sesuai ekspektasi.
Bagian 1 — EDA (contoh)
print(X_train.isna().sum())
print(y_train.describe())
fig, axes = plt.subplots(1, 2, figsize=(10, 4))
axes[0].hist(y_train, bins=30, edgecolor="white")
axes[0].set_title("Distribusi target (train)")
col = X_train.columns[2] # ganti indeks / nama fitur sesuai analisis Anda
axes[1].scatter(X_train[col], y_train, alpha=0.35, s=12)
axes[1].set_xlabel(col)
axes[1].set_ylabel("target")
axes[1].set_title(f"{col} vs target")
plt.tight_layout()Narasi: Langkah pertama EDA memeriksa missing hanya pada train (prinsip yang sama dengan transform: statistik dasar dari test tidak “bocor” ke keputusan eksplorasi awal, meskipun untuk missing count saja risikanya kecil). describe() pada target memberi gambar pusat dan sebaran. Histogram melihat bentuk distribusi \(y\); scatter satu fitur vs target membantu melihat linear vs melengkung — ganti col atau indeks 2 ke fitur yang relevan dengan rumusan masalah Anda.
Bagian 2 — Baseline & OLS
baseline = DummyRegressor(strategy="mean")
baseline.fit(X_train, y_train)
pred_base = baseline.predict(X_test)
ols = LinearRegression()
ols.fit(X_train, y_train)
pred_ols = ols.predict(X_test)
for name, pred in [("Baseline mean", pred_base), ("OLS", pred_ols)]:
print(
name,
"| RMSE:", round(rmse(y_test, pred), 3),
"| MAE:", round(mean_absolute_error(y_test, pred), 3),
"| R2:", round(r2_score(y_test, pred), 3),
)
# Koefisien (nama fitur = bunch.feature_names)
pd.Series(ols.coef_, index=X_train.columns)Narasi: Baseline mean adalah “model nol”: tanpa memakai \(X\), selalu menebak rata-rata \(y\) di train. Jika OLS tidak jauh lebih baik dari baseline, berarti sinyal fitur lemah atau preprocessing kurang. OLS meminimumkan MSE latih secara analitik pada bentuk linear. Metrik dihitung pada y_test — ini estimasi generalisasi, bukan kinerja menghafal latih. RMSE dan MAE bersama-sama memberi gambar error besar (RMSE lebih “hukum” ekstrem) vs error rata-rata absolut. Series koefisien menghubungkan angka dengan nama fitur untuk interpretasi di laporan.
Bagian 3 — Polynomial + CV pada train
from sklearn.model_selection import GridSearchCV, KFold
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import PolynomialFeatures
poly_pipe = Pipeline(
[
("poly", PolynomialFeatures(include_bias=True)),
("lin", LinearRegression()),
]
)
cv = KFold(n_splits=5, shuffle=True, random_state=RNG)
grid = GridSearchCV(
poly_pipe,
param_grid={"poly__degree": [1, 2, 3, 4, 5]},
cv=cv,
scoring="neg_mean_squared_error",
n_jobs=-1,
)
grid.fit(X_train, y_train)
print("Derajat terbaik (min MSE CV):", grid.best_params_)
best_poly = grid.best_estimator_
pred_poly = best_poly.predict(X_test)
print("RMSE test (poly):", round(rmse(y_test, pred_poly), 3))
fig, ax = plt.subplots(figsize=(5, 5))
ax.scatter(y_test, pred_poly, alpha=0.5, s=20)
lims = [min(y_test.min(), pred_poly.min()), max(y_test.max(), pred_poly.max())]
ax.plot(lims, lims, "k--", label="y = ŷ")
ax.set_xlabel("y aktual (test)")
ax.set_ylabel("y prediksi (test)")
ax.legend()
ax.set_title("Polynomial (derajat terpilih) — test")
plt.tight_layout()Narasi: Pipeline memastikan urutan tetap: dari nilai mentah fitur dulu dibuat monomial derajat \(\leq d\), baru regresi linear pada vektor yang memanjang itu — setara “linear dalam parameter, nonlinear dalam \(x\)”. GridSearchCV mencoba setiap degree di grid; skor CV (neg_mean_squared_error) dihitung hanya dari lipatan train, jadi set uji tidak memilih derajat (menghindari optimisme berlebihan). best_estimator_ adalah pipeline terbaik; setelah itu baru predict pada test. Scatter prediksi vs aktual dengan garis identitas: titik mengumpul di garis \(y=\hat{y}\) berarti kalibrasi baik; awan yang melebar di ujung sering berarti ekstrapolasi atau heteroskedastisitas.
Catatan: jika jumlah fitur \(p\) besar, derajat polinomial tinggi membuat kolom meledak — kurangi derajat maksimum atau gunakan subset fitur.
Bagian 4 — Ridge & Lasso dengan StandardScaler
from sklearn.linear_model import LassoCV, RidgeCV
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
alphas = np.logspace(-4, 3, 60)
ridge = Pipeline(
[
("scale", StandardScaler()),
("model", RidgeCV(alphas=alphas, cv=5)),
]
)
ridge.fit(X_train, y_train)
print("alpha Ridge:", ridge.named_steps["model"].alpha_)
print("RMSE test Ridge:", round(rmse(y_test, ridge.predict(X_test)), 3))
lasso = Pipeline(
[
("scale", StandardScaler()),
(
"model",
LassoCV(alphas=alphas, cv=5, random_state=RNG, max_iter=20000),
),
]
)
lasso.fit(X_train, y_train)
print("alpha Lasso:", lasso.named_steps["model"].alpha_)
print("RMSE test Lasso:", round(rmse(y_test, lasso.predict(X_test)), 3))
coef_lasso = lasso.named_steps["model"].coef_
print("Jumlah koefisien Lasso == 0:", int(np.sum(coef_lasso == 0)))
# Perbandingan batang (OLS tanpa scale vs Ridge/Lasso pada X ter-scale)
# OLS pada matriks sama untuk apple-to-apple: bandingkan Ridge/Lasso dengan OLS pada StandardScaler
ols_scaled = Pipeline(
[("scale", StandardScaler()), ("model", LinearRegression())]
)
ols_scaled.fit(X_train, y_train)
df_coef = pd.DataFrame(
{
"OLS_scaled": ols_scaled.named_steps["model"].coef_,
"Ridge": ridge.named_steps["model"].coef_,
"Lasso": lasso.named_steps["model"].coef_,
},
index=X_train.columns,
)
df_coef.plot.bar(figsize=(10, 4), rot=45)
plt.ylabel("koefisien")
plt.title("Perbandingan koefisien (setelah StandardScaler)")
plt.tight_layout()Narasi: Penalti Ridge/Lasso membandingkan magnitudo koefisien antar fitur; tanpa standarisasi, fitur ber-skala besar mendominasi penalti dan interpretasi. StandardScaler di Pipeline memastikan fit hanya pada train saat ridge.fit / lasso.fit. RidgeCV dan LassoCV mencari alpha yang meminimumkan error validasi silang di dalam train. Mencetak alpha terpilih dokumentasikan hiperparameter final. Hitungan koefisien nol Lasso menunjukkan sparse (fitur yang “dibuang” model). OLS kedua dengan scaler membandingkan apel dengan apel terhadap Ridge/Lasso: semua tiga melihat \(X\) dalam satuan z-score yang sama; grafik batang membantu menjelaskan arah dan penyusutan koefisien di laporan.
Bagian 5A — Outlier sintetis + Huber (satu fitur, ilustrasi)
from sklearn.linear_model import HuberRegressor, LinearRegression
j = 0 # indeks satu fitur untuk ilustrasi 1D
x_tr = X_train.iloc[:, [j]].values
x_te = X_test.iloc[:, [j]].values
ols_1d = LinearRegression().fit(x_tr, y_train)
# Tambah outlier vertikal di train
x_bad = np.vstack([x_tr, np.array([[x_tr.mean()]])])
y_bad = np.concatenate([y_train.values, [y_train.max() + 3 * y_train.std()]])
ols_bad = LinearRegression().fit(x_bad, y_bad)
hub = HuberRegressor(epsilon=1.35, max_iter=200).fit(x_bad, y_bad)
xx = np.linspace(x_tr.min(), x_tr.max(), 200).reshape(-1, 1)
plt.figure(figsize=(7, 4))
plt.scatter(x_tr, y_train, alpha=0.4, label="train asli")
plt.scatter(x_bad[-1], y_bad[-1], color="red", s=80, label="outlier sintetis")
plt.plot(xx, ols_1d.predict(xx), label="OLS (train bersih)", color="C0")
plt.plot(xx, ols_bad.predict(xx), label="OLS + outlier", color="orange")
plt.plot(xx, hub.predict(xx), label="Huber + outlier", color="green")
plt.legend()
plt.xlabel(X_train.columns[j])
plt.ylabel("target")
plt.title("Sensitivitas OLS vs Huber (contoh 1 fitur)")
plt.tight_layout()
# Metrik pada test (model dilatih pada data ber-outlier — hanya untuk latihan; bandingkan dengan OLS bersih)
print("RMSE test OLS (1 fitur, train bersih):", round(rmse(y_test, ols_1d.predict(x_te)), 3))
print("RMSE test OLS (train+outlier):", round(rmse(y_test, ols_bad.predict(x_te)), 3))
print("RMSE test Huber:", round(rmse(y_test, hub.predict(x_te)), 3))Narasi: Contoh ini menyederhanakan ke satu fitur agar garis regresi mudah divisualkan; di tugas Anda boleh memperluas ide yang sama atau hanya melaporkan efek outlier pada model multi-fitur. Outlier sintetis di sini adalah vertikal (\(y\) ekstrem pada \(x\) di sekitar rata-rata): OLS dipaksa mendekati titik itu sehingga kemiringan berubah. HuberRegressor memakai loss yang kurang “hukum” kuadrat pada residual besar, sehingga garis hijau cenderung lebih stabil. Metrik di test tetap memakai test set asli dan prediktor satu kolom yang sama — membandingkan apakah model yang dilatih dengan train “kotor” masih berguna pada distribusi test. Ingat: di penelitian sungguhan, outlier sebaiknya diinvestigasi (bukan hanya ditambah sintetis tanpa konteks).
Bagian 5B — Winsorize target berdasarkan persentil train
low, high = np.percentile(y_train, [1, 99])
def winsorize_series(s, lo, hi):
return s.clip(lower=lo, upper=hi)
y_train_w = winsorize_series(y_train, low, high)
ols_w = LinearRegression()
ols_w.fit(X_train, y_train_w)
pred_w = ols_w.predict(X_test)
ols_plain = LinearRegression()
ols_plain.fit(X_train, y_train)
pred_plain = ols_plain.predict(X_test)
# Bandingkan keduanya terhadap target test asli (satu definisi error)
print("RMSE test (OLS, target train asli):", round(rmse(y_test, pred_plain), 3))
print("RMSE test (OLS, target train winsor 1–99%):", round(rmse(y_test, pred_w), 3))Narasi: Persentil 1 dan 99 dihitung hanya dari y_train — batas clip tidak boleh memakai y_test agar tidak bocor informasi. Target yang di-winsorize di train berarti model belajar memprediksi versi target yang dipotong; prediksi pada test tetap dibandingkan dengan y_test asli agar metrik satu “target bisnis” yang sama. Jika RMSE membaik, itu menunjukkan ekstrem train sebelumnya menarik OLS; jika memburuk, cap terlalu agresif atau hubungan berubah. Dokumentasikan ke pembaca laporan bahwa definisi target latih telah diubah.
Peringatan: winsorize target mengubah definisi variabel yang dipelajari — dokumentasikan ke stakeholder.
Alternatif: California Housing (ganti blok muat data)
from sklearn.datasets import fetch_california_housing
cal = fetch_california_housing(as_frame=True)
df = cal.frame
# Opsional percepat: df = df.sample(5000, random_state=RNG)
X = df.drop(columns="MedHouseVal")
y = df["MedHouseVal"]
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.25, random_state=RNG
)
# Lanjutkan dengan baseline / OLS / poly / Ridge seperti di atasNarasi: Dataset ini memiliki banyak baris dan fitur geospasial; sampling opsional mempercepat iterasi di laptop. Kolom target bernama MedHouseVal; sisanya menjadi \(X\). Setelah train_test_split, semua blok berikutnya (Dummy, OLS, Pipeline polinomial, Ridge/Lasso, dll.) dapat disalin apa adanya — perhatikan bahwa polinomial derajat tinggi pada banyak fitur bisa sangat lambat; turunkan degree maksimum atau subset kolom jika notebook macet.
Pengumpulan: PDF dan SCALSA
- Selesaikan seluruh bagian (0–6) dalam satu notebook dengan heading Markdown per bagian.
- Pastikan semua cell sudah di-Run dan output tampil.
- Ekspor ke PDF sesuai panduan kampus.
- Unggah PDF ke SCALSA sebelum tenggat.