Skip to main content

Tugas praktik: Regresi linear, polynomial, & regularisasi

Data Science — materi DS-09

Penulis

Anggit Wirasto, S.Si., M.Eng.

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 ipykernel

Conda / 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

  1. Tulis satu paragraf (3–5 kalimat): pertanyaan analitik Anda, variabel target \(y\) yang diprediksi, dan minimal dua fitur \(X\) yang dipakai (boleh lebih).
  2. Sebutkan metrik utama untuk evaluasi (mis. RMSE dan MAE) dan mengapa dipilih untuk konteks Anda.

Bagian 1 — EDA singkat

  1. Muat data ke DataFrame (atau Bunch.frame dari sklearn).
  2. Laporkan shape, cek missing (jumlah per kolom).
  3. Buat minimal dua visual yang relevan: mis. histogram target, scatter satu fitur vs target, atau heatmap korelasi subset fitur.
  4. Satu kalimat: apakah hubungan fitur–target terlihat linear atau melengkung secara kasar?

Bagian 2 — Baseline & regresi linear

  1. Bagi data: train_test_split(..., test_size=0.2–0.3, random_state=<bilangan tetap>). Untuk California Housing, pertimbangkan shuffle=True (default).
  2. Baseline: prediktor yang selalu memprediksi rata-rata y_train untuk semua baris uji (boleh manual NumPy atau DummyRegressor(strategy="mean")).
  3. OLS: LinearRegression() dilatih pada X_train, y_train.
  4. Laporkan RMSE dan MAE (dan boleh \(R^2\)) pada set uji untuk baseline dan OLS.
  5. 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

  1. Bangun Pipeline: PolynomialFeatures → LinearRegression. Gunakan include_bias=True secara konsisten.
  2. Pilih kandidat derajat polinomial, mis. degree dalam {1, 2, 3, 4, 5} (sesuaikan jika \(p\) besar — hindari ledakan kolom).
  3. Gunakan cross_val_score atau GridSearchCV dengan K-fold (mis. KFold atau ShuffleSplit) hanya pada data latih untuk memilih derajat terbaik menurut neg_mean_squared_error atau neg_root_mean_squared_error (sklearn: scoring="neg_root_mean_squared_error" jika versi Anda mendukung; jika tidak, gunakan neg_mean_squared_error dan jelaskan).
  4. Latih pipeline dengan derajat terpilih pada seluruh train, evaluasi pada test.
  5. Satu grafik: prediksi vs aktual pada test untuk model polinomial terpilih (scatter + garis identitas y=x).
  6. Jelaskan dalam 2–4 kalimat: risiko overfitting jika derajat terlalu tinggi, dan bagaimana CV membantu.

Bagian 4 — Ridge dan/atau Lasso

  1. Wajib penskalaan fitur sebelum penalti: StandardScaler di dalam Pipeline sebelum Ridge atau Lasso.
  2. Gunakan RidgeCV dan/atau LassoCV (atau GridSearchCV dengan rentang alpha log-spaced) dengan CV pada train untuk memilih alpha.
  3. Bandingkan RMSE test (minimal): OLS pada fitur yang sama vs Ridge vs Lasso (jika hanya salah satu, jelaskan mengapa).
  4. 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

  1. Salin X_train, y_train ke variabel baru; tambahkan 1–3 titik outlier (jelaskan di Markdown: outlier vertikal pada \(y\), atau leverage pada \(x\)).
  2. Latih LinearRegression pada data asli vs data ber-outlier; plot scatter + kedua garis regresi (atau dua subplot).
  3. Laporkan perubahan RMSE/MAE pada test set yang asli (tidak diubah) jika Anda hanya mengubah train — atau jelaskan protokol Anda dengan konsisten.
  4. Latih HuberRegressor (dengan atau tanpa PolynomialFeatures derajat rendah) pada data ber-outlier; bandingkan garis atau metrik dengan OLS.

B — Winsorize / cap

  1. Definisikan aturan cap pada train saja (mis. batas persentil 1 dan 99 pada target atau satu fitur).
  2. Terapkan transformasi yang sama ke test (gunakan nilai ambang dari train).
  3. 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 atas

Narasi: 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

  1. Selesaikan seluruh bagian (0–6) dalam satu notebook dengan heading Markdown per bagian.
  2. Pastikan semua cell sudah di-Run dan output tampil.
  3. Ekspor ke PDF sesuai panduan kampus.
  4. Unggah PDF ke SCALSA sebelum tenggat.

Checklist sebelum kumpul