Neural network kerap digambarkan sebagai sistem yang sulit dijelaskan, padahal mesin di dalamnya dapat kita bangun sendiri dalam satu berkas Python. Sebuah neural network hanyalah kumpulan neuron sederhana yang melakukan perkalian, penjumlahan, dan pemotongan nilai — semua operasi yang sudah Anda kenal. Yang membuatnya tampak rumit adalah jumlah parameternya yang besar dan proses training yang berulang. Chapter ini membedah siklus tersebut sampai tuntas: kita akan menulis satu neuron dengan NumPy, menghitung galatnya, lalu melatihnya memprediksi harga rumah hingga galatnya turun drastis.

Anatomi Satu Neuron #

Neuron adalah unit pemrosesan terkecil dalam neural network. Neuron menerima input, mengalikan setiap input dengan bobotnya sendiri, menjumlahkan hasilnya, menambahkan bias, lalu meneruskan nilai tersebut ke fungsi aktivasi. Lima istilah ini perlu diingat karena akan muncul terus sepanjang Course:

  • Input: data yang masuk ke neuron — bisa luas rumah, satu piksel, atau keluaran neuron lain.
  • Bobot (weight): angka pengali untuk tiap input; inilah parameter yang dipelajari selama training.
  • Bias: konstanta penggeser yang memberi neuron kebebasan bergerak dari titik nol.
  • Weighted sum: hasil penjumlahan z = bobot * input + bias.
  • Fungsi aktivasi: transformasi non-linear seperti ReLU yang memotong nilai negatif menjadi nol.

Satu neuron sendiri hanya mampu memodelkan pola sederhana. Kekuatan muncul ketika ribuan neuron disusun berlapis: layer tersembunyi pertama membaca input mentah, layer berikutnya membaca keluaran layer sebelumnya, dan seterusnya — persis hierarki representasi yang kita tiru pada Chapter pertama.

Siklus Training: Empat Langkah yang Berulang #

Training adalah proses menyetel seluruh bobot dan bias agar prediksi makin dekat ke target. Seluruh framework deep learning, sekompleks apa pun tampilannya, menjalankan siklus yang sama:

Empat tahapnya masing-masing punya tanggung jawab yang jelas. Forward pass menghitung prediksi memakai parameter saat ini. Loss mengubah jarak prediksi ke target menjadi satu angka, biasanya mean squared error (MSE) untuk regresi. Backward pass memakai kalkulus untuk menghitung turunan loss terhadap setiap parameter — turunan ini disebut gradient dan menunjukkan arah parameter mana yang menaikkan atau menurunkan loss. Terakhir, tahap update menggeser setiap parameter sedikit ke arah yang menurunkan loss. Satu putaran penuh atas seluruh data latih disebut satu epoch, dan prosesnya diulang belasan hingga ratusan epoch.

Demo Forward Pass: Neuron Memprediksi Harga Rumah #

Kita mulai dari neuron yang sama sekali belum terlatih. Data latihnya lima rumah dengan luas dalam meter persegi dan harga dalam juta rupiah; menurut data ini, harga hampir selalu delapan kali luas. Neuron diberi bobot awal 2.0 dan bias -60.0, lalu menjalankan ketiga tahap awal: weighted sum, aktivasi ReLU, dan penghitungan MSE.

python 
"""Satu neuron melakukan forward pass: weighted sum + aktivasi ReLU.

Neuron menerima luas rumah, menghitung weighted sum, menerapkan
aktivasi ReLU, lalu kualitas prediksi diukur dengan MSE.
"""

import numpy as np

# Data lima rumah: luas (m2) dan harga (juta rupiah)
luas = np.array([20.0, 90.0, 120.0, 150.0, 180.0])
harga = np.array([160.0, 720.0, 950.0, 1200.0, 1430.0])

# Parameter neuron, sengaja diisi nilai awal yang belum dilatih
bobot = 2.0
bias = -60.0

# 1) Weighted sum: z = bobot * input + bias
z = bobot * luas + bias

# 2) Aktivasi ReLU: nilai negatif dipotong menjadi nol
prediksi = np.maximum(0.0, z)

# 3) Loss: mean squared error terhadap harga sebenarnya
mse = np.mean((prediksi - harga) ** 2)

print("Luas (m2)   :", luas)
print("z = w*x + b :", z)
print("Prediksi    :", prediksi)
print("Harga asli  :", harga)
print(f"MSE         : {mse:.1f}")

Output yang Dihasilkan:

text 
Luas (m2)   : [ 20.  90. 120. 150. 180.]
z = w*x + b : [-20. 120. 180. 240. 300.]
Prediksi    : [  0. 120. 180. 240. 300.]
Harga asli  : [ 160.  720.  950. 1200. 1430.]
MSE         : 635400.0

Dua hal patut dicermati dari keluaran tersebut. Pertama, untuk rumah 20 m² nilai z adalah -20 dan ReLU memotongnya menjadi prediksi 0 — inilah efek fungsi aktivasi yang menahan keluaran di wilayah non-negatif. Kedua, MSE sebesar 635.400 berarti rata-rata kuadrat galat prediksi masih sangat besar; neuron ini jelas belum siap dipakai. Mari kita telaah kodenya baris per baris:

  1. Baris 10-11: mendefinisikan data latih sebagai array NumPy — satu array untuk input (luas), satu untuk target (harga).
  2. Baris 14-15: mengisi parameter neuron dengan nilai awal apa adanya; pada model sesungguhnya nilai awal diacak terlebih dulu.
  3. Baris 18: menghitung weighted sum z untuk kelima rumah sekaligus berkat operasi vektor NumPy.
  4. Baris 21: menerapkan ReLU lewat np.maximum(0.0, z) sehingga nilai negatif menjadi nol.
  5. Baris 24: menghitung MSE — rata-rata dari kuadrat selisih prediksi terhadap harga asli.
  6. Baris 26-30: mencetak seluruh nilai antara beserta MSE agar prosesnya transparan.

Melatih Neuron dengan Gradient Descent #

Forward pass saja tidak membuat neuron belajar; kita butuh backward pass dan update. Untuk neuron linear, turunan MSE terhadap kedua parameternya memiliki bentuk sederhana (penurunan lengkapnya menyusul di bab kalkulus):

  • Turunan terhadap bobot: 2 × rata-rata(galat × input)
  • Turunan terhadap bias: 2 × rata-rata(galat)

Pembaruannya mengikuti aturan gradient descent: parameter baru = parameter lama dikurangi learning rate dikali gradient. Learning rate mengatur seberapa besar langkah tiap pembaruan. Program berikut menjalankan 25 epoch penuh dari parameter nol:

python 
"""Melatih satu neuron dengan gradient descent murni NumPy.

Siklus tiap epoch: forward pass -> hitung loss -> backward pass
(hitung gradient) -> perbarui parameter. Loss harus turun.
"""

import numpy as np

# Data yang sama dengan neuron_forward.py
luas = np.array([20.0, 90.0, 120.0, 150.0, 180.0])
harga = np.array([160.0, 720.0, 950.0, 1200.0, 1430.0])

# Parameter diawali dari nol; model akan "belajar" sendiri
bobot = 0.0
bias = 0.0
learning_rate = 1e-5

for epoch in range(1, 26):
    # Forward pass: prediksi dengan parameter saat ini
    prediksi = bobot * luas + bias
    galat = prediksi - harga
    mse = np.mean(galat ** 2)

    if epoch in (1, 5, 10, 15, 20, 25):
        print(f"epoch {epoch:2d}  bobot={bobot:7.3f}  bias={bias:7.3f}  MSE={mse:10.1f}")

    # Backward pass: turunan MSE terhadap tiap parameter
    grad_bobot = 2.0 * np.mean(galat * luas)
    grad_bias = 2.0 * np.mean(galat)

    # Pembaruan parameter: melawan arah gradient
    bobot -= learning_rate * grad_bobot
    bias -= learning_rate * grad_bias

print(f"\nParameter akhir: bobot={bobot:.3f}, bias={bias:.3f}")
print("Prediksi akhir:", np.round(bobot * luas + bias).astype(int))
print("Harga asli    :", harga.astype(int))

Output yang Dihasilkan:

text 
epoch  1  bobot=  0.000  bias=  0.000  MSE=  986280.0
epoch  5  bobot=  6.169  bias=  0.044  MSE=   49980.8
epoch 10  bobot=  7.683  bias=  0.055  MSE=    1217.7
epoch 15  bobot=  7.918  bias=  0.057  MSE=      45.7
epoch 20  bobot=  7.954  bias=  0.057  MSE=      17.5
epoch 25  bobot=  7.960  bias=  0.057  MSE=      16.8

Parameter akhir: bobot=7.960, bias=0.057
Prediksi akhir: [ 159  716  955 1194 1433]
Harga asli    : [ 160  720  950 1200 1430]

Hasilnya menunjukkan pembelajaran yang sesungguhnya. MSE turun dari 986.280 menjadi 16,8 — turun lebih dari 99 persen — dan bobot konvergen ke 7,960, nyaris persis faktor pengali harga-luas pada data (delapan). Prediksi akhir hanya meleset beberapa juta rupiah per rumah. Tidak ada yang memberi tahu neuron rumus “harga = 8 × luas”; neuron menemukannya sendiri lewat siklus forward, loss, backward, dan update. Mari kita telaah kode pelatihannya:

  1. Baris 14-16: memulai parameter dari nol dan menetapkan learning_rate = 1e-5 (0,00001) — langkah kecil yang menjaga pembaruan stabil.
  2. Baris 18-22: forward pass di dalam satu epoch: prediksi dihitung, galat terhadap harga diambil, lalu MSE dicatat.
  3. Baris 24-25: mencetak kondisi model hanya pada epoch ke-1, 5, 10, 15, 20, dan 25 agar keluaran ringkas.
  4. Baris 27-29: backward pass — dua rumus turunan tadi diterjemahkan menjadi dua baris NumPy.
  5. Baris 31-33: pembaruan parameter dengan aturan parameter -= learning_rate * gradient untuk kedua parameter.
  6. Baris 35-37: mencetak parameter akhir serta perbandingan prediksi melawan harga asli.

Pada neuron linear satu-satunya ini pembaruan masih berupa dua baris kode. Framework modern seperti PyTorch menjalankan backward pass secara otomatis melalui mekanisme autograd , tetapi siklus keempat tahapnya sama persis dengan yang baru kita jalankan tangan.

Satu neuron yang menemukan sendiri pola “delapan kali luas” adalah bukti bahwa siklus training murni aritmetika dan kalkulus yang diulang rapi, bukan proses yang mustahil dijelaskan. Persoalannya kemudian, sejauh mana siklus sederhana ini sudah membawa hasil di dunia nyata? Chapter berikutnya memetakan penerapan deep learning di visi komputer, bahasa, suara, hingga kedokteran, lengkap dengan produk yang memakainya setiap hari.