Dokumentasi Algoritma Sistem Market Mural

Penjabaran matematis Multi Layer Perceptron (MLP) & Random Forest Regressor — dari rumus hingga hasil estimasi harga. Seluruh rumus dan langkah pada dokumen ini sesuai dengan implementasi kode pada folder includes/ml/.

Daftar Isi

Alur Umum Sistem
Tahap 1 — Pra-pemrosesan Data (Encoding & Normalisasi)
Tahap 2A — Multi Layer Perceptron (MLP)
Tahap 2B — Random Forest Regressor
Tahap 3 — Evaluasi Model (MAE, RMSE, R²)
Tahap 4 — Pemilihan Model Terbaik
Pemetaan Rumus ↔ Kode Program

1. Alur Umum Sistem

Sistem menerima 5 spesifikasi mural, memprosesnya, lalu memprediksi harga dengan dua algoritma secara paralel. Alurnya:

Input (ukuran, kerumitan, bahan, lokasi, waktu) → Encoding → Normalisasi Min-Max → [ MLP & Random Forest ] → Denormalisasi → Harga (Rp) → pilih model dengan error terkecil

Karena kedua algoritma bekerja pada angka, tahap pra-pemrosesan wajib dilakukan lebih dulu.

2. Tahap 1 — Pra-pemrosesan Data

2.1 Encoding fitur

Data kategorikal (teks) diubah menjadi angka dengan aturan tetap (deterministik):

Fitur	Tipe	Aturan encoding
Ukuran bidang	numerik	dipakai langsung (m²)
Estimasi waktu	numerik	dipakai langsung (hari)
Tingkat kerumitan	ordinal	Sederhana=1, Sedang=2, Rumit=3
Jenis bahan/cat	indeks	indeks biaya bahan 1,0 – 2,6
Lokasi	indeks	faktor biaya kota 1,0 – 1,35

Hasilnya sebuah vektor fitur x = (x₁, x₂, x₃, x₄, x₅).

2.2 Normalisasi Min-Max

Skala tiap fitur berbeda jauh (mis. ukuran 3–75 vs kerumitan 1–3). Agar setara, semua diskalakan ke rentang [0, 1] memakai normalisasi Min-Max Han, Kamber & Pei, 2011:

x′ = x − x_minx_max − x_min (2.1)

Nilai x_min dan x_max diambil dari data latih, lalu disimpan bersama model agar input baru diproses dengan skala yang sama. Target harga y juga dinormalisasi dengan rumus yang sama menjadi y′ ∈ [0,1].

Contoh

Ukuran 12 m², bila pada data latih ukuran min = 2,5 dan max = 75:

x′ = 12 − 2,575 − 2,5 = 9,572,5 = 0,131

3. Tahap 2A — Multi Layer Perceptron (MLP)

MLP adalah jaringan saraf tiruan berlapis (feed-forward) yang memetakan input ke output melalui neuron-neuron berbobot. Sistem ini memakai arsitektur:

5 input

→

16 (ReLU)

→

8 (ReLU)

→

1 output

Arsitektur: 5 → 16 → 8 → 1

3.1 Inisialisasi bobot (He Initialization)

Bobot awal W diacak dari distribusi normal dengan varians yang disesuaikan jumlah input tiap neuron (n_in), sesuai metode He He et al., 2015 yang cocok untuk aktivasi ReLU:

W_ij ~ 𝒩(0, σ²), σ = √2n_in (3.1)

Bias awal b = 0.

3.2 Forward Propagation (perambatan maju)

Untuk setiap layer l, keluaran tiap neuron dihitung 2 langkah: (a) penjumlahan berbobot, (b) fungsi aktivasi.

(a) Penjumlahan berbobot (weighted sum)

z_j^(l) = ∑_i W_ij^(l) a_i^(l−1) + b_j^(l) (3.2)

dengan a^(l−1) = keluaran layer sebelumnya (untuk layer pertama, a⁽⁰⁾ = x′ input ternormalisasi).

(b) Fungsi aktivasi ReLU (untuk layer tersembunyi)

ReLU (Rectified Linear Unit) Nair & Hinton, 2010:

a_j^(l) = ReLU(z_j^(l)) = max(0, z_j^(l)) (3.3)

(c) Layer output (linear)

Karena ini regresi (memprediksi angka), neuron output memakai fungsi linear (tanpa ReLU):

ŷ = z^(L) = ∑_i W_i^(L) a_i^(L−1) + b^(L) (3.4)

Nilai ŷ masih dalam skala ternormalisasi [0,1].

3.3 Fungsi Loss (Mean Squared Error)

Seberapa jauh prediksi dari nilai sebenarnya diukur dengan MSE. Untuk satu sampel dipakai bentuk ½ agar turunannya bersih:

L = 12(ŷ − y′)² (3.5)

3.4 Backpropagation (perambatan mundur)

Algoritma backpropagation Rumelhart, Hinton & Williams, 1986 menghitung gradien loss terhadap tiap bobot memakai aturan rantai (chain rule), dari output mundur ke input.

(a) Error pada layer output (δ)

Karena output linear dan loss ½(ŷ−y′)²:

δ^(L) = ŷ − y′ (3.6)

(b) Error layer tersembunyi

Error dirambatkan mundur, dikalikan turunan ReLU:

δ_i^(l) = (∑_j W_ij^(l+1) δ_j^(l+1)) · ReLU′(z_i^(l)) (3.7)

dengan turunan ReLU:

ReLU′(z) = { 1, jika z > 0
0, jika z ≤ 0 } (3.8)

(c) Gradien bobot & bias

∂L∂W_ij^(l) = a_i^(l−1) δ_j^(l) + λW_ij^(l) , ∂L∂b_j^(l) = δ_j^(l) (3.9)

Suku λW adalah regularisasi L2 (λ = 0,0001) untuk mencegah overfitting. Gradien dirata-rata pada satu mini-batch berukuran 16.

3.5 Optimasi bobot dengan Adam

Bobot diperbarui memakai optimizer Adam Kingma & Ba, 2015, yang menggabungkan momentum dan laju belajar adaptif. Misal g_t gradien saat iterasi t:

m_t = β₁m_t−1 + (1−β₁)g_t (3.10) — estimasi momen ke-1

v_t = β₂v_t−1 + (1−β₂)g_t² (3.11) — estimasi momen ke-2

m̂_t = m_t1 − β₁^t , v̂_t = v_t1 − β₂^t (3.12) — koreksi bias

θ_t = θ_t−1 − η · m̂_t√v̂_t + ε (3.13) — pembaruan bobot

dengan konstanta pada sistem: laju belajar η = 0,01; β₁ = 0,9; β₂ = 0,999; ε = 10⁻⁸. θ mewakili tiap bobot/bias. Langkah 3.2–3.5 diulang selama 500 epoch.

3.6 Contoh perhitungan (jaringan mini 2→2→1)

Forward pass

Misal input x′ = (0,5 ; 0,8), bobot & bias:

W1 = [[0,3 ; −0,2],[0,4 ; 0,1]], b1 = [0,1 ; −0,1]; W2 = [0,6 ; −0,5], b2 = 0,2.

Layer tersembunyi (pers. 3.2 & 3.3):

z₁ = 0,5·0,3 + 0,8·0,4 + 0,1 = 0,57 → a₁ = ReLU(0,57) = 0,57

z₂ = 0,5·(−0,2) + 0,8·0,1 + (−0,1) = −0,12 → a₂ = ReLU(−0,12) = 0

Layer output (pers. 3.4):

ŷ = 0,57·0,6 + 0·(−0,5) + 0,2 = 0,542

Backward pass

Bila target y′ = 0,5 → δ^(L) = 0,542 − 0,5 = 0,042 (pers. 3.6)

Gradien: ∂L/∂W2₁ = a₁·δ = 0,57·0,042 = 0,0239

δ neuron tersembunyi 1: z₁ > 0 → ReLU′=1, maka δ = 0,042·0,6·1 = 0,0252 (pers. 3.7)

Neuron 2: z₂ ≤ 0 → ReLU′=0 → δ = 0 (neuron "mati" untuk sampel ini). Nilai-nilai gradien ini kemudian dimasukkan ke Adam (pers. 3.10–3.13) untuk memperbarui bobot.

3.7 Denormalisasi → Harga Rupiah

Output ŷ masih [0,1], dikembalikan ke rupiah dengan kebalikan pers. (2.1):

Harga = ŷ · (y_max − y_min) + y_min (3.14)

Contoh

Bila ŷ = 0,092 dan pada data latih harga min = Rp1.070.000, max = Rp35.050.000:

Harga = 0,092 · (35.050.000 − 1.070.000) + 1.070.000 = 0,092 · 33.980.000 + 1.070.000 = Rp4.196.160

4. Tahap 2B — Random Forest Regressor

Random Forest Breiman, 2001 adalah gabungan (ensemble) banyak pohon regresi. Tiap pohon dilatih pada sampel data acak, lalu prediksi akhir = rata-rata semua pohon. Sistem ini memakai T = 120 pohon.

4.1 Pohon Regresi (CART)

Tiap pohon dibangun dengan algoritma CART Breiman et al., 1984. Pohon membagi data secara rekursif dengan aturan fitur ≤ ambang. Ambang dipilih agar keragaman (varians) nilai harga di anak-cabang sekecil mungkin.

(a) Varians simpul

Untuk himpunan data S pada satu simpul:

Var(S) = 1|S| ∑_i∈S (y_i − ȳ_S)² , ȳ_S = 1|S|∑_i∈S y_i (4.1)

(b) Kriteria pemisahan (variance reduction)

Sebuah split (fitur j, ambang t) memecah S menjadi S_L = {x_j ≤ t} dan S_R = {x_j > t}. Varians berbobot anak:

Var_anak = |S_L||S| Var(S_L) + |S_R||S| Var(S_R) (4.2)

Dipilih split yang memaksimalkan penurunan varians (variance reduction):

ΔVar = Var(S) − Var_anak → pilih (j, t) dengan ΔVar terbesar (4.3)

(c) Nilai daun (leaf)

Pembagian berhenti bila kedalaman maksimum tercapai (20) atau jumlah sampel < 2. Nilai prediksi sebuah daun = rata-rata harga sampel di daun tersebut:

c_daun = ȳ_daun (4.4)

Contoh perhitungan variance reduction

Enam mural dengan harga (juta): S = {1,2 ; 1,5 ; 2,0 ; 5,0 ; 5,5 ; 6,0}

ȳ_S = 21,2 / 6 = 3,533 → Var(S) = 24,03/6 = 4,006 (pers. 4.1)

Split pada ukuran (misal ambang tertentu) → S_L={1,2 ; 1,5 ; 2,0}, S_R={5,0 ; 5,5 ; 6,0}:

ȳ_L=1,567; Var(S_L)=0,109 · ȳ_R=5,5; Var(S_R)=0,167

Var_anak = (3/6)·0,109 + (3/6)·0,167 = 0,138 (pers. 4.2)

ΔVar = 4,006 − 0,138 = 3,868 → penurunan besar, split ini sangat baik (pers. 4.3).

Prediksi: daun kiri = 1,567 jt, daun kanan = 5,5 jt (pers. 4.4).

4.2 Bagging (Bootstrap Aggregating)

Agar 120 pohon berbeda, tiap pohon dilatih pada sampel bootstrap Breiman, 1996: n data diambil acak dengan pengembalian dari data latih (sehingga sebagian data terduplikasi, sebagian tak terpakai).

4.3 Random Feature Subset

Pada setiap split, hanya m_try = 4 fitur (dari 5) yang dipilih acak sebagai kandidat. Ini membuat pohon-pohon tidak seragam dan mengurangi korelasi antar-pohon — inti keunggulan Random Forest.

4.4 Agregasi — prediksi akhir

Prediksi hutan = rata-rata prediksi seluruh pohon h_t:

ŷ = 1T ∑_t=1^T h_t(x) , T = 120 (4.5)

Nilai ŷ ini (skala ternormalisasi) lalu didenormalisasi memakai pers. (3.14) untuk menjadi harga rupiah — sama seperti MLP.

📌 Kenapa hasil RF "bertangga"? Karena tiap pohon hanya bisa mengeluarkan nilai rata-rata daun (pers. 4.4), dan tidak bisa memprediksi di luar rentang harga data latih (tidak bisa extrapolate). Ini kelebihan pada data ber-pola tangga/kategori, namun kekurangan pada permukaan harga yang mulus.

5. Tahap 3 — Evaluasi Model

Setelah dilatih, kedua model diuji pada 20% data uji (yang tidak dipakai saat latih). Tiga metrik dihitung Hastie et al., 2009:

Mean Absolute Error (MAE)

MAE = 1n ∑_i=1ⁿ |y_i − ŷ_i| (5.1)

Rata-rata selisih absolut. Makin kecil makin baik.

Root Mean Squared Error (RMSE)

RMSE = √ 1n ∑_i=1ⁿ (y_i − ŷ_i)² (5.2)

Akar rata-rata kuadrat error; memberi penalti lebih besar pada error besar. Dipakai sebagai kriteria pemilihan model.

Koefisien Determinasi (R²)

R² = 1 − ∑_i(y_i − ŷ_i)² ∑_i(y_i − ȳ)² (5.3)

Proporsi variasi harga yang berhasil dijelaskan model. Nilai mendekati 1 = makin baik.

6. Tahap 4 — Pemilihan Model Terbaik

Sistem membandingkan RMSE kedua model dan memilih yang RMSE-nya terkecil sebagai model rekomendasi (ditandai is_recommended di database), lalu harga dari model itu dipakai sebagai harga final:

Model terpilih = arg min_{m ∈ {MLP, RF}} RMSE_m (6.1)

Karena pembagian data latih/uji dilakukan acak tiap pelatihan, model pemenang dapat berubah antar sesi training. Inilah alasan sistem selalu melatih & membandingkan kedua algoritma, bukan mengandalkan satu saja.

7. Pemetaan Rumus ↔ Kode Program

Rumus	Berkas kode
(2.1) Normalisasi Min-Max	`includes/ml/Preprocessor.php` → `scaleFeatures()`, `scaleTarget()`
(3.1) He init	`MLPRegressor.php` → `initParams()`, `gauss()`
(3.2)–(3.4) Forward propagation	`MLPRegressor.php` → `forward()`
(3.5)–(3.9) Loss & backpropagation	`MLPRegressor.php` → `fit()`
(3.10)–(3.13) Adam optimizer	`MLPRegressor.php` → `fit()` (blok update)
(3.14) Denormalisasi	`Preprocessor.php` → `inverseTarget()`
(4.1)–(4.4) Pohon CART	`DecisionTreeRegressor.php` → `build()`, `variance()`
(4.5) Bagging & agregasi	`RandomForestRegressor.php` → `fit()`, `predictOne()`
(5.1)–(5.3) MAE, RMSE, R²	`ModelManager.php` → `evaluate()`
(6.1) Pemilihan model	`ModelManager.php` → `trainAll()`

Dokumen ini bagian dari Sistem Market Mural — Penentuan Harga Otomatis dengan MLP & Random Forest Regressor.