Backpropagation dengan tangan

Backpropagation adalah algoritma yang menghitung gradien loss terhadap setiap parameter jaringan berlapis dengan menerapkan aturan rantai dari keluaran ke belakang. Topik ini menurunkannya secara manual pada jaringan terkecil yang tetap mewakili, tepat satu kali sepanjang jalur, lalu memverifikasi setiap angkanya dengan autograd. Setelah selesai, seluruh pemakaian .backward() pada topik berikutnya berdiri di atas pemahaman yang dapat dihitung ulang dengan tangan.

Jaringan contoh dan angkanya#

Jaringan contoh memiliki satu masukan, satu neuron tersembunyi dengan aktivasi ReLU, dan satu keluaran linier. Parameternya adalah $w_1$ pada masukan, $w_2$ pada keluaran, dan lossnya MSE tanpa rata-rata karena hanya ada satu contoh:

Angka yang dipilih sengaja sederhana: $x = 2$, $w_1 = 0{,}3$, $w_2 = 1{,}0$, dan target $t = 1$. Kecilnya jaringan tidak mengurangi sifat wakilnya, karena struktur gradiennya sudah memuat tiga hal inti, yaitu perkalian rantai, turunan aktivasi, dan pembagian kontribusi antara dua parameter.

Forward pass dan aturan rantai#

Forward passnya dihitung berurutan. Nilai $z = 0{,}3 \cdot 2 = 0{,}6$ positif sehingga $h = 0{,}6$, keluaran $\hat{y} = 1{,}0 \cdot 0{,}6 = 0{,}6$, dan loss $L = (0{,}6 - 1)^2 = 0{,}16$. Gradien kemudian dirakit dari belakang dengan mengalikan turunan setiap mata rantai:

Substitusi angkanya memberikan $\frac{\partial L}{\partial \hat{y}} = 2(0{,}6 - 1) = -0{,}8$, sehingga $\frac{\partial L}{\partial w_2} = -0{,}8 \cdot 0{,}6 = -0{,}48$. Untuk $w_1$, sinyal dirambatkan sebagai $-0{,}8 \cdot w_2 \cdot 1 = -0{,}8$ karena turunan ReLU pada $z > 0$ bernilai satu, Sinyal itu lalu dikalikan $\frac{\partial z}{\partial w_1} = x = 2$, sehingga $\frac{\partial L}{\partial w_1} = -1{,}6$. Perhatikan struktur pentingnya, yaitu sinyal yang sama mengalir ke setiap parameter dan hanya dikalikan turunan lokal masing-masing, dan itulah yang membuat algoritma ini efisien.

Verifikasi dengan autograd#

Kedua nilai manual tersebut dapat diverifikasi dengan PyTorch dalam beberapa baris. Kode berikut membangun grafik komputasi yang sama, memanggil backward, dan membandingkan hasilnya dengan angka tangan.

import torch

x = torch.tensor(2.0)
w1 = torch.tensor(0.3, requires_grad=True)
w2 = torch.tensor(1.0, requires_grad=True)
t = torch.tensor(1.0)

z = w1 * x
h = torch.relu(z)
y = w2 * h
L = (y - t) ** 2
L.backward()

print("z =", z.item(), "| h =", h.item(), "| y =", y.item(), "| L =", L.item())
print("dL/dw1 =", w1.grad.item(), "(manual: -1.6)")
print("dL/dw2 =", w2.grad.item(), "(manual: -0.48)")

z = 0.6000000238418579 | h = 0.6000000238418579 | y = 0.6000000238418579 | L = 0.15999998152256012
dL/dw1 = -1.5999999046325684 (manual: -1.6)
dL/dw2 = -0.47999998927116394 (manual: -0.48)

Keluarannya cocok persis dengan perhitungan tangan, termasuk tanda negatif yang menunjukkan kedua bobot perlu diperbesar agar loss turun. Verifikasi seperti ini bernilai lebih dari sekadar pembuktian, karena pola yang sama dapat dipakai untuk menguji implementasi gradien manual apa pun di masa depan, yaitu hitung manual, hitung autograd, dan bandingkan.

Mengapa menghitung mundur adalah keharusan#

Cara naif menghitung $\frac{\partial L}{\partial \theta_i}$ untuk setiap parameter adalah mengganggu satu parameter sedikit lalu mengukur perubahan loss, dan biayanya satu forward pass penuh per parameter. Pada model dengan seratus juta parameter, satu langkah pelatihan menuntut seratus juta forward pass, dan hal itu tidak terlaksana.

Backpropagation membalik urutannya dengan menghitung mundur sekali saja. Satu pass maju menyimpan nilai antara setiap operasi, dan satu pass mundur merambatkan sinyal gradien sambil mengalikannya dengan turunan lokal setiap operasi. Biaya totalnya sekitar dua kali satu forward pass, tidak bergantung pada jumlah parameter, dan setiap parameter menerima gradiennya pada perjalanan yang sama. Efisiensi inilah yang menjadikan pelatihan jaringan dalam mungkin dilakukan.

Yang autograd kerjakan sejak sekarang#

Setelah mekanikanya dipahami sekali, perhitungan gradien manual tidak pernah diulang lagi sepanjang jalur, sebagaimana dicatat aturan emas kurikulum ini. Topik Autograd menunjukkan bagaimana PyTorch merekam grafik komputasi dan menjalankan proses yang barusan diturunkan, dan sisa jalur memperlakukan gradien sebagai komoditas yang selalu tersedia.

Hal yang tetap layak dibawa dari topik ini adalah intuisi merambatnya sinyal. Gradien layer awal adalah hasil kali banyak turunan lokal, sehingga rantai yang panjang dapat mengecilkan sinyal hingga nyaris nol pada aktivasi yang tersaturasi, atau membesarkannya melebihi kendali pada skala yang salah. Fenomena vanishing dan exploding gradient yang muncul pada modul-modul selanjutnya adalah konsekuensi langsung dari perkalian berantai yang barusan dilihat.

Ringkasan#

• Backpropagation merambatkan sinyal gradien dari loss ke belakang dengan mengalikan turunan lokal setiap operasi satu kali.
• Pada jaringan contoh, gradien manual memberikan $-1{,}6$ untuk $w_1$ dan $-0{,}48$ untuk $w_2$, dan autograd menghasilkan angka yang identik.
• Perhitungan mundur berbiaya sekitar dua kali forward pass tanpa bergantung jumlah parameter, jauh lebih murah daripada mengganggu parameter satu per satu.
• Perkalian berantai panjang menjadi akar fenomena gradien yang menghilang atau meledak pada jaringan dalam.

Referensi#

• Backpropagation and Gradients — CS231n, Stanford — Catatan kuliah yang menurunkan backprop pada grafik komputasi dengan gaya sama.
• Automatic differentiation package — PyTorch — Dokumentasi autograd yang menjelaskan perekaman grafik dan perambatan mundur.
• Backpropagation — Dive into Deep Learning — Bab yang memuat notasi rantai forward dan backward secara formal.