Lewati ke isi

Proyek: Memperkirakan Harga Rumah End-to-End

Gambaran singkat

Apa ini? Proyek penutup yang merangkai alur regresi: dari data mentah sampai model taksiran harga rumah siap pakai.

Analogi

Seperti ujian praktik setelah belajar teori: semua langkah dijalankan berurutan.

Mengapa penting? Di dunia nyata keputusan di satu langkah (misalnya mengubah target ke log) berdampak pada langkah lain. Proyek ini memperlihatkan alur itu secara utuh.

Yang akan dipelajari, berurutan:

  1. EDA singkat dan pembagian data uji.
  2. Praproses dalam ColumnTransformer.
  3. Membandingkan baseline, Ridge, dan Random Forest, dengan dan tanpa target log.
  4. Menyetel, evaluasi akhir, analisis galat per kecamatan.
  5. Menyimpan model.

Istilah awal:

Istilah Arti sederhana
Target log Memodelkan logaritma harga agar sebaran lebih seimbang
TransformedTargetRegressor Alat yang melatih pada target yang diubah lalu mengembalikannya ke satuan asli
Galat per kelompok Mengecek apakah kesalahan merata di tiap kecamatan

Tujuan proyek

Menerapkan seluruh alur regresi pada data tabular bertipe campuran: EDA singkat, pipeline praproses, baseline, perbandingan model, keputusan transformasi target, optimasi ringan, evaluasi akhir, analisis galat per kelompok, dan penyimpanan.

Masalah dan data

Masalah: memperkirakan harga rumah (juta Rupiah) dari luas, jumlah kamar, usia, jarak ke pusat kota, kecamatan, dan kondisi.

Data: sintetis, dibangkitkan oleh fungsi make_housing_data dengan seed tetap (800 baris). Harga dibuat dari hubungan multiplikatif (harga ∝ luas^0,9 dikali faktor usia, jarak, kecamatan, dan kondisi) ditambah derau acak 20% pada skala log, serta sebagian nilai hilang (5% age_years, 4% condition). Karena kita yang membuat datanya, kita tahu bahwa derau acak ini tidak dapat diprediksi oleh model mana pun; pada data nyata batas seperti ini tidak diketahui. Hasil tidak menggambarkan pasar properti nyata.

Alur kerja

  1. EDA singkat dan pemisahan data uji (acak, 80/20).
  2. Praproses dalam ColumnTransformer (imputasi, scaling, one-hot).
  3. Bandingkan baseline, Ridge, dan Random Forest, masing-masing dengan target asli dan target log (TransformedTargetRegressor).
  4. Setel alpha Ridge pada target log.
  5. Evaluasi sekali pada data uji dan periksa galat per kecamatan.
  6. Simpan dan uji muat ulang.

Implementasi langkah demi langkah

Program examples/estimation/project.py. Konsep tiap langkah sudah dibahas di pelajaran sebelumnya; di sini fokusnya pada penyatuan langkah dan keputusan yang diambil. Program lengkap ada di akhir bagian ini.

Langkah 1: membangkitkan data sintetis

Tujuan. Membuat data harga rumah yang strukturnya kita ketahui, agar hasil model dapat dibandingkan dengan batas yang diketahui.

project.py
def make_housing_data(n=800, seed=42):
    """Harga rumah (juta Rupiah) SINTETIS dengan hubungan multiplikatif + derau."""
    rng = np.random.default_rng(seed)
    area = rng.uniform(30, 300, n)                                   # m2
    bedrooms = np.clip(np.round(area / 50 + rng.normal(0, 0.7, n)), 1, 6)
    age = rng.integers(0, 40, n).astype(float)                       # tahun
    distance = rng.gamma(2.0, 4.0, n)                                # km ke pusat kota
    district = rng.choice(["Pusat", "Barat", "Timur", "Selatan"], n, p=[0.2, 0.3, 0.3, 0.2])
    condition = rng.choice(["baik", "sedang", "kurang"], n, p=[0.4, 0.4, 0.2])
    d_eff = pd.Series(district).map({"Pusat": 0.35, "Barat": 0.1, "Timur": 0.0, "Selatan": 0.15}).to_numpy()
    c_eff = pd.Series(condition).map({"baik": 0.1, "sedang": 0.0, "kurang": -0.15}).to_numpy()
    log_price = (2.0 + 0.9 * np.log(area) - 0.012 * age - 0.03 * distance + d_eff + c_eff
                 + rng.normal(0, 0.2, n))
    df = pd.DataFrame({"area_m2": area.round(1), "bedrooms": bedrooms, "age_years": age,
                       "distance_km": distance.round(1), "district": district,
                       "condition": condition, "price": np.exp(log_price).round(1)})
    df.loc[rng.choice(n, int(0.05 * n), replace=False), "age_years"] = np.nan
    df.loc[rng.choice(n, int(0.04 * n), replace=False), "condition"] = np.nan
    return df
Bagian Penjelasan
rng = np.random.default_rng(seed) Generator acak dengan seed tetap (data identik tiap dijalankan).
area = rng.uniform(30, 300, n); distance = rng.gamma(2.0, 4.0, n) Fitur numerik dengan distribusi masing-masing (merata dan miring ke kanan).
rng.choice([...], n, p=[...]) Fitur kategorik dengan peluang tiap kategori.
log_price = 2.0 + 0.9*np.log(area) - ... + rng.normal(0, 0.2, n) Harga ditentukan pada skala log oleh luas, usia, jarak, kecamatan, dan kondisi, ditambah derau normal (simpangan baku 0,2).
np.exp(log_price) Kembali ke skala asli: hubungan menjadi multiplikatif (setiap faktor mengalikan harga).
df.loc[rng.choice(n, ...), "age_years"] = np.nan Sebagian nilai dikosongkan agar ada data hilang yang harus ditangani.

Langkah 2: EDA singkat dan data uji

project.py
# 1. Data dan EDA singkat
df = make_housing_data()
print("Ukuran:", df.shape, "| hilang:", df.isna().sum()[lambda s: s > 0].to_dict())
print("Harga (juta Rp): median %.0f | rata-rata %.0f | maks %.0f | skew %.2f"
      % (df["price"].median(), df["price"].mean(), df["price"].max(), df["price"].skew()))
print("skew log(harga): %.2f" % np.log(df["price"]).skew())

X, y = df.drop(columns="price"), df["price"]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=SEED)

df.isna().sum()[lambda s: s > 0].to_dict() menghitung data hilang per kolom lalu menyaring kolom yang punya data hilang (fungsi lambda sebagai syarat). np.log(df["price"]).skew() menghitung kemiringan harga setelah logaritma. train_test_split membagi tanpa stratify (target kontinu).

Ukuran: (800, 7) | hilang: {'age_years': 40, 'condition': 32}
Harga (juta Rp): median 505 | rata-rata 557 | maks 2068 | skew 0.86
skew log(harga): -0.50

Interpretasi. 800 baris; data hilang: 40 pada age_years dan 32 pada condition. Harga median 505, rata-rata 557, maksimum 2068 juta; skewness harga 0,86 (miring ke kanan), dan setelah log -0,50 (agak miring ke kiri): log mengoreksi kemiringan tetapi sedikit berlebihan.

Langkah 3: praproses dan pembungkus target log

Konsep. Praproses (imputasi, scaling, one-hot) dibangun sekali sebagai prep. Karena harga multiplikatif, kita mencoba juga memprediksi log harga lalu mengembalikannya ke skala asli. TransformedTargetRegressor melakukannya otomatis: ia melatih model pada func(y) dan menerapkan inverse_func pada prediksi.

project.py
# 2. Praproses di dalam pipeline
numeric = ["area_m2", "bedrooms", "age_years", "distance_km"]
categorical = ["district", "condition"]
prep = ColumnTransformer([
    ("num", Pipeline([("impute", SimpleImputer(strategy="median")), ("scale", StandardScaler())]), numeric),
    ("cat", Pipeline([("impute", SimpleImputer(strategy="most_frequent")),
                      ("onehot", OneHotEncoder(handle_unknown="ignore"))]), categorical),
])


def with_log_target(est):
    return TransformedTargetRegressor(Pipeline([("prep", prep), ("model", est)]),
                                      func=np.log, inverse_func=np.exp)


candidates = {
    "Baseline (rata-rata)": Pipeline([("prep", prep), ("model", DummyRegressor())]),
    "Ridge, target asli": Pipeline([("prep", prep), ("model", Ridge(alpha=1))]),
    "Ridge, target log": with_log_target(Ridge(alpha=1)),
    "Random Forest, target asli": Pipeline([("prep", prep), ("model", RandomForestRegressor(
        n_estimators=200, min_samples_leaf=3, random_state=SEED))]),
    "Random Forest, target log": with_log_target(RandomForestRegressor(
        n_estimators=200, min_samples_leaf=3, random_state=SEED)),
}
Kode Penjelasan
ColumnTransformer([...]) Imputasi median + scaling untuk numerik; imputasi modus + one-hot untuk kategorik (penjelasan).
def with_log_target(est): return TransformedTargetRegressor(...) Fungsi yang membungkus pipeline (praproses + model) agar targetnya di-np.log saat pelatihan dan di-np.exp saat prediksi.
candidates = {...} Baseline rata-rata serta Ridge dan Random Forest masing-masing dengan target asli dan target log.

Langkah 4: perbandingan dengan validasi silang

project.py
# 3. Perbandingan dengan validasi silang pada data latih
cv = KFold(5, shuffle=True, random_state=SEED)
print("\nmodel                       MAE     RMSE    R2")
for name, model in candidates.items():
    s = cross_validate(model, X_train, y_train, cv=cv,
                       scoring=["neg_mean_absolute_error", "neg_root_mean_squared_error", "r2"])
    print(f"{name:<27} {-s['test_neg_mean_absolute_error'].mean():<7.1f} "
          f"{-s['test_neg_root_mean_squared_error'].mean():<7.1f} {s['test_r2'].mean():.3f}")

Perulangan menilai tiap kandidat pada data latih dengan tiga metrik; tanda minus mengembalikan galat negatif menjadi positif, dan R² ditampilkan apa adanya.

model                       MAE     RMSE    R2
Baseline (rata-rata)        259.1   324.4   -0.001
Ridge, target asli          110.9   147.4   0.792
Ridge, target log           106.6   149.9   0.783
Random Forest, target asli  107.2   150.6   0.781
Random Forest, target log   105.7   149.9   0.783

Interpretasi. Baseline RMSE 324,4 dan R² ≈ 0. Ridge target asli 147,4 (MAE 110,9; R² 0,792); Ridge target log 149,9 (MAE 106,6; R² 0,783); Random Forest target asli 150,6 (MAE 107,2); Random Forest target log 149,9 (MAE 105,7). Keempatnya sangat dekat. Target log memperbaiki MAE sedikit tetapi tidak memperbaiki RMSE; keduanya menimbang galat besar dan kecil secara berbeda. Pilih berdasarkan metrik yang sesuai tujuan bisnis.

Langkah 5: optimasi ringan

project.py
# 4. Optimasi ringan Ridge pada target log
search = GridSearchCV(with_log_target(Ridge()), {"regressor__model__alpha": [0.01, 0.1, 1, 10, 100]},
                      scoring="neg_root_mean_squared_error", cv=cv).fit(X_train, y_train)
best = search.best_estimator_
print("\nalpha terbaik:", search.best_params_["regressor__model__alpha"], "| RMSE CV: %.1f" % -search.best_score_)

Nama parameter regressor__model__alpha menelusuri lapisan bersarang: TransformedTargetRegressor menyimpan pipeline di atribut regressor, yang memiliki langkah model, yang memiliki parameter alpha. search.best_estimator_ adalah model terbaik yang sudah dilatih ulang.

alpha terbaik: 10 | RMSE CV: 147.5

Interpretasi. alpha terbaik 10 (RMSE CV 147,5): perubahan kecil dibanding alpha=1, jadi Ridge tidak sensitif pada rentang ini.

Langkah 6: evaluasi akhir dan galat per kecamatan

project.py
# 5. Evaluasi akhir pada data uji (satu kali) dan galat per kelompok
pred = best.predict(X_test)
print("\nUji -> MAE %.1f | RMSE %.1f | R2 %.3f (satuan: juta Rp)" % (
    mean_absolute_error(y_test, pred), mean_squared_error(y_test, pred) ** 0.5, r2_score(y_test, pred)))
err = pd.DataFrame({"district": X_test["district"], "abs_err": (y_test - pred).abs(),
                    "rel_err_pct": (y_test - pred).abs() / y_test * 100})
print(err.groupby("district").agg(MAE=("abs_err", "mean"), rel_err_pct=("rel_err_pct", "mean")).round(1))

err adalah tabel berisi kecamatan, galat mutlak, dan galat relatif (galat dibagi harga sebenarnya, dalam persen). groupby("district").agg(...) menghitung rata-rata keduanya per kecamatan.

Uji -> MAE 102.8 | RMSE 149.5 | R2 0.788 (satuan: juta Rp)
            MAE  rel_err_pct
district                    
Barat     104.3         20.2
Pusat     123.7         21.5
Selatan    84.2         21.0
Timur      98.5         20.7

Interpretasi. Data uji (sekali): MAE 102,8; RMSE 149,5; R² 0,788 (juta Rp), konsisten dengan validasi silang (R² ≈ 0,78). Galat relatif rata-rata sekitar 20–21% di semua kecamatan (20,2% Barat, 21,5% Pusat, 21,0% Selatan, 20,7% Timur), meski galat absolut berbeda (MAE 84–124 juta) karena harga di Pusat lebih tinggi. Derau 20% pada skala log yang kita masukkan berarti galat relatif rata-rata sekitar 16% (kira-kira 0,8 × 0,2) bahkan bagi model yang sempurna mengenali hubungan sebenarnya. Galat 20–21% di sini cukup dekat dengan batas itu, sehingga ruang perbaikan model terbatas dan Ridge maupun Random Forest tidak perlu diperumit lebih jauh.

Langkah 7: menyimpan dan memuat ulang

project.py
# 6. Simpan dan uji muat ulang
path = Path(tempfile.mkdtemp()) / "house_price_model.joblib"
joblib.dump(best, path)
print("prediksi identik setelah dimuat:", np.allclose(pred, joblib.load(path).predict(X_test)))
prediksi identik setelah dimuat: True

Hasil. Model disimpan dan prediksinya identik setelah dimuat (np.allclose).

Program lengkap (project.py)
project.py
"""Proyek regresi end-to-end: memperkirakan harga rumah (data SINTETIS)."""
import tempfile
from pathlib import Path

import joblib
import numpy as np
import pandas as pd
from sklearn.compose import ColumnTransformer, TransformedTargetRegressor
from sklearn.dummy import DummyRegressor
from sklearn.ensemble import RandomForestRegressor
from sklearn.impute import SimpleImputer
from sklearn.linear_model import Ridge
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score
from sklearn.model_selection import GridSearchCV, KFold, cross_validate, train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import OneHotEncoder, StandardScaler

SEED = 42


def make_housing_data(n=800, seed=42):
    """Harga rumah (juta Rupiah) SINTETIS dengan hubungan multiplikatif + derau."""
    rng = np.random.default_rng(seed)
    area = rng.uniform(30, 300, n)                                   # m2
    bedrooms = np.clip(np.round(area / 50 + rng.normal(0, 0.7, n)), 1, 6)
    age = rng.integers(0, 40, n).astype(float)                       # tahun
    distance = rng.gamma(2.0, 4.0, n)                                # km ke pusat kota
    district = rng.choice(["Pusat", "Barat", "Timur", "Selatan"], n, p=[0.2, 0.3, 0.3, 0.2])
    condition = rng.choice(["baik", "sedang", "kurang"], n, p=[0.4, 0.4, 0.2])
    d_eff = pd.Series(district).map({"Pusat": 0.35, "Barat": 0.1, "Timur": 0.0, "Selatan": 0.15}).to_numpy()
    c_eff = pd.Series(condition).map({"baik": 0.1, "sedang": 0.0, "kurang": -0.15}).to_numpy()
    log_price = (2.0 + 0.9 * np.log(area) - 0.012 * age - 0.03 * distance + d_eff + c_eff
                 + rng.normal(0, 0.2, n))
    df = pd.DataFrame({"area_m2": area.round(1), "bedrooms": bedrooms, "age_years": age,
                       "distance_km": distance.round(1), "district": district,
                       "condition": condition, "price": np.exp(log_price).round(1)})
    df.loc[rng.choice(n, int(0.05 * n), replace=False), "age_years"] = np.nan
    df.loc[rng.choice(n, int(0.04 * n), replace=False), "condition"] = np.nan
    return df


# 1. Data dan EDA singkat
df = make_housing_data()
print("Ukuran:", df.shape, "| hilang:", df.isna().sum()[lambda s: s > 0].to_dict())
print("Harga (juta Rp): median %.0f | rata-rata %.0f | maks %.0f | skew %.2f"
      % (df["price"].median(), df["price"].mean(), df["price"].max(), df["price"].skew()))
print("skew log(harga): %.2f" % np.log(df["price"]).skew())

X, y = df.drop(columns="price"), df["price"]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=SEED)

# 2. Praproses di dalam pipeline
numeric = ["area_m2", "bedrooms", "age_years", "distance_km"]
categorical = ["district", "condition"]
prep = ColumnTransformer([
    ("num", Pipeline([("impute", SimpleImputer(strategy="median")), ("scale", StandardScaler())]), numeric),
    ("cat", Pipeline([("impute", SimpleImputer(strategy="most_frequent")),
                      ("onehot", OneHotEncoder(handle_unknown="ignore"))]), categorical),
])


def with_log_target(est):
    return TransformedTargetRegressor(Pipeline([("prep", prep), ("model", est)]),
                                      func=np.log, inverse_func=np.exp)


candidates = {
    "Baseline (rata-rata)": Pipeline([("prep", prep), ("model", DummyRegressor())]),
    "Ridge, target asli": Pipeline([("prep", prep), ("model", Ridge(alpha=1))]),
    "Ridge, target log": with_log_target(Ridge(alpha=1)),
    "Random Forest, target asli": Pipeline([("prep", prep), ("model", RandomForestRegressor(
        n_estimators=200, min_samples_leaf=3, random_state=SEED))]),
    "Random Forest, target log": with_log_target(RandomForestRegressor(
        n_estimators=200, min_samples_leaf=3, random_state=SEED)),
}

# 3. Perbandingan dengan validasi silang pada data latih
cv = KFold(5, shuffle=True, random_state=SEED)
print("\nmodel                       MAE     RMSE    R2")
for name, model in candidates.items():
    s = cross_validate(model, X_train, y_train, cv=cv,
                       scoring=["neg_mean_absolute_error", "neg_root_mean_squared_error", "r2"])
    print(f"{name:<27} {-s['test_neg_mean_absolute_error'].mean():<7.1f} "
          f"{-s['test_neg_root_mean_squared_error'].mean():<7.1f} {s['test_r2'].mean():.3f}")

# 4. Optimasi ringan Ridge pada target log
search = GridSearchCV(with_log_target(Ridge()), {"regressor__model__alpha": [0.01, 0.1, 1, 10, 100]},
                      scoring="neg_root_mean_squared_error", cv=cv).fit(X_train, y_train)
best = search.best_estimator_
print("\nalpha terbaik:", search.best_params_["regressor__model__alpha"], "| RMSE CV: %.1f" % -search.best_score_)

# 5. Evaluasi akhir pada data uji (satu kali) dan galat per kelompok
pred = best.predict(X_test)
print("\nUji -> MAE %.1f | RMSE %.1f | R2 %.3f (satuan: juta Rp)" % (
    mean_absolute_error(y_test, pred), mean_squared_error(y_test, pred) ** 0.5, r2_score(y_test, pred)))
err = pd.DataFrame({"district": X_test["district"], "abs_err": (y_test - pred).abs(),
                    "rel_err_pct": (y_test - pred).abs() / y_test * 100})
print(err.groupby("district").agg(MAE=("abs_err", "mean"), rel_err_pct=("rel_err_pct", "mean")).round(1))

# 6. Simpan dan uji muat ulang
path = Path(tempfile.mkdtemp()) / "house_price_model.joblib"
joblib.dump(best, path)
print("prediksi identik setelah dimuat:", np.allclose(pred, joblib.load(path).predict(X_test)))

Refleksi

  • Bandingkan galat dengan batas yang bisa dicapai: pada data sintetis ini kita tahu batasnya, pada data nyata gunakan model sederhana sebagai pembanding.
  • Metrik relatif (galat persen) lebih bermakna untuk harga yang bervariasi besar.
  • Pemantauan setelah deployment: lihat lesson monitoring.

Latihan

  1. Tambahkan GradientBoostingRegressor dan bandingkan dengan Ridge dan Random Forest.
  2. Hitung galat relatif median (bukan rata-rata) per kecamatan.
  3. Ubah derau dalam make_housing_data dari 0,2 menjadi 0,05. Bagaimana R² dan kesimpulan tentang model berubah?
  4. Tulis ringkasan untuk pembaca non-teknis: seberapa akurat estimasi ini?

Ringkasan

Proyek ini menunjukkan alur regresi lengkap: praproses di dalam pipeline, baseline, keputusan transformasi target dengan bukti, penyetelan ringan, evaluasi sekali di data uji, dan analisis galat per kelompok. Karena derau data dikendalikan, kita dapat melihat bahwa galat model sudah dekat dengan batas yang tak dapat dihindari.

Selesai dengan bab Estimasi. Lanjut ke bab Forecasting.