ENID
Lensa ML

Cara Kerja Backpropagation

Langkah 1 dari 6: Prediksinya Salah

Network menebak Kucing = 0.62, padahal yang kita mau 1,0

Kucing
Hasil
0.57
→
Target
1.0
Anjing
Hasil
0.67
→
Target
0.0

Forward pass sudah berjalan. Network menjawab Kucing = 0.57, padahal jawaban yang benar 1.0. Backpropagation membuat network bisa memperbaiki diri: error dikirim ke belakang supaya setiap weight belajar dari kesalahan itu.

① Ukur error
② Cari andil tiap weight
③ Geser weight

Backpropagation menjawab pertanyaan tentang pembagian andil: network ini punya 36 weight, jadi weight mana yang menyebabkan jawaban salah, dan seberapa besar andilnya? Cara paling kasar adalah menggeser tiap weight satu per satu dan menjalankan ulang network untuk mengukur efeknya, yang berarti satu forward pass per weight. Backprop mendapatkan gradient semua weight dari satu forward pass dan satu backward pass, baik network-nya punya 36 weight maupun 70 miliar. Efisiensi inilah yang membuat training network besar menjadi mungkin.

Langkah 2 dari 6: Mengukur Kesalahan

Loss function menyatakan besar kesalahan sebagai satu angka

Kucing
prediksi
0.571
target
1.0
selisih
-0.429
kuadrat
…
Anjing
prediksi
0.671
target
0.0
selisih
+0.671
kuadrat
…

Loss function mengukur seberapa salah prediksinya. Ambil error tiap output, kuadratkan (supaya kesalahan yang lebih besar dihukum lebih berat), lalu jumlahkan. Training berusaha membuat satu angka ini sekecil mungkin.

L = (Kucing - 1.0)² + (Anjing - 0.0)² = 0.6348

Di sini loss-nya memakai jumlah kuadrat error. Model klasifikasi biasanya dilatih dengan cross-entropy: dengan output sigmoid atau softmax, cross-entropy menghasilkan gradient besar saat model yakin tetapi salah, sedangkan kuadrat error mendatar di situ sehingga proses belajar melambat. Apa pun loss-nya, backprop hanya butuh satu hal darinya, yaitu turunannya terhadap tiap output. Untuk kuadrat error, turunan itu adalah 2 × (output − target), dan dari sinilah backward pass dimulai.

Langkah 3 dari 6: Chain Rule

Cara perubahan kecil pada weight merambat sampai ke output

∂L∂outOutputerror output×∂out∂h₂Hidden 2andil layer×∂h₂∂h₁Hidden 1diteruskan mundur×∂h₁∂wInputpembaruan weight∂L/∂w = ∂L/∂out × ∂out/∂h₂ × ∂h₂/∂h₁ × ∂h₁/∂w

Chain rule mencari seberapa besar pengaruh satu weight terhadap loss akhir dengan mengalikan turunan lokal di setiap langkah sepanjang jalurnya. Setiap neuron cukup tahu hitungan lokalnya, lalu meneruskan andil kesalahan ke belakang.

Klik satu layer, atau biarkan berputar sendiri, untuk melihat turunan lokal mana saja yang dikalikan. Untuk weight w yang masuk ke neuron dengan weighted sum z dan output y, ∂L/∂w = ∂L/∂y · ∂y/∂z · ∂z/∂w. Faktor terakhir tidak lain adalah input yang lewat melalui w, sehingga weight yang menempel pada input mendekati nol nyaris tidak kebagian andil. Untuk sigmoid, faktor tengahnya adalah σ(z)(1 − σ(z)), yang tidak pernah lebih dari 0,25. Mengalikan beberapa faktor seperti itu menjadi salah satu alasan network sigmoid yang dalam mengalami vanishing gradient.

Langkah 4 dari 6: Gradient Mengalir ke Belakang

Lihat sinyal error merambat dari output kembali ke input

Sinyal error mengalir ke belakang
0.85Telinga runcing0.72Kumis0.91Tekstur bulu0.620.520.630.300.650.770.410.480.57δ=-0.105Kucing0.67δ=0.148AnjingInputHidden 1Hidden 2Outputerror mengalir ke belakang
Hidden 1
δ max 0.006
Hidden 2
δ max 0.025
Output
δ max 0.148

Delta (δ) setiap neuron menunjukkan bagiannya dalam kesalahan. Makin besar delta-nya, makin besar andil neuron itu terhadap error.

Pilih tiap layer dan bandingkan delta terbesarnya. Pada contoh ini delta mengecil saat bergerak mundur, dari sekitar 0,15 di output menjadi sekitar 0,006 di hidden layer pertama. Inilah masalah vanishing gradient dalam skala kecil. Delta tiap layer dihitung dari layer sesudahnya, jadi algoritma ini cukup berjalan mundur sekali dan memakai ulang semua yang sudah dihitung. Framework seperti PyTorch mengerjakan pencatatan ini secara otomatis untuk network apa pun yang kamu tulis, dengan teknik bernama reverse-mode automatic differentiation.

Langkah 5 dari 6: Menggeser Weight

Setiap weight mendapat koreksinya sendiri

Learning rate1.50
Loss sebelum
0.6348
↓
Loss sesudah
0.4957
Dari → kew lamaGradientLangkahw baruH2#1 → 1+0.600-0.0688+0.103+0.703H2#1 → 2+0.070+0.0970-0.145-0.075H2#2 → 1-0.460-0.0808+0.121-0.339H2#2 → 2+0.640+0.1140-0.171+0.469H2#3 → 1+0.040-0.0433+0.065+0.105H2#3 → 2-0.260+0.0611-0.092-0.352H2#4 → 1+0.480-0.0505+0.076+0.556H2#4 → 2+0.590+0.0713-0.107+0.483

weight baru = weight lama - learning rate × gradient. Gradient yang besar berarti weight itu berpengaruh besar pada error, jadi koreksinya juga lebih besar.

Geser learning rate dan bandingkan loss sebelum dan sesudah pembaruan. Learning rate kecil mengambil langkah yang aman tetapi lambat. Learning rate yang terlalu besar bisa melompati titik minimum dan membuat loss naik. Network ini bisa memakai nilai tinggi karena ukurannya kecil dan belajar dari satu contoh. Model besar sering dilatih dengan learning rate di bawah 0,001 dan memakai optimizer seperti Adam, yang menyesuaikan ukuran langkah tiap weight berdasarkan gradient terbarunya.

Langkah 6 dari 6: Ulangi Sampai Terlatih

Banyak putaran backprop. Lihat network akhirnya mengenali kucing

Lihat network mencapai konvergensi
0.85Telinga runcing0.72Kumis0.91Tekstur bulu0.620.520.630.300.650.770.410.480.57Kucingtarget 1.0err 0.4290.67Anjingtarget 0.0err 0.671InputHidden 1Hidden 2Output
Epoch
0
Loss
0.6348
Kucing
0.57
0.630lossepoch 160

Tekan Otomatis, atau jalankan satu epoch demi satu epoch, lalu lihat loss mendatar. Epoch awal memangkas loss dengan cepat karena gradient-nya besar. Di dekat titik minimum, gradient mengecil dan langkahnya ikut mengecil. Setiap epoch di sini terdiri dari satu forward pass, satu backward pass, dan satu pembaruan pada satu contoh. Pada dataset sungguhan, setiap pembaruan memakai mini-batch berisi beberapa contoh, dan satu epoch berarti model sudah melihat setiap contoh sekali.

Apa itu backpropagation?

Backpropagation adalah algoritma yang menghitung, untuk setiap weight di neural network, seberapa besar loss akan berubah kalau weight itu sedikit diubah. Besaran itu disebut gradient milik weight tersebut. Backprop menerapkan chain rule dari output layer mundur ke arah input dan memakai ulang hasil antara, sehingga satu backward pass menghasilkan gradient semua weight. Setelah itu, optimizer seperti gradient descent memakai gradient tersebut untuk memperbarui weight.

Metode ini dipopulerkan untuk neural network oleh Rumelhart, Hinton, dan Williams pada 1986, melanjutkan karya sebelumnya tentang reverse-mode differentiation. Semua framework deep learning modern, termasuk PyTorch dan JAX, menjalankan versi umumnya secara otomatis.

Ide utama

  • Backprop menghitung gradient dari loss terhadap setiap weight.
  • Backprop menerapkan chain rule per layer, dari output mundur ke input.
  • Satu backward pass, dengan biaya kira-kira dua kali forward pass, menghasilkan semua gradient sekaligus.
  • Gradient sebuah weight bergantung pada sinyal error yang sampai ke neuron-nya dan pada input yang dibawanya.
  • Gradient bisa mengecil saat melewati banyak layer ke belakang (vanishing gradient).
  • Backprop mencari gradient, sedangkan optimizer menentukan cara memakainya.

Pertanyaan umum

Apakah backpropagation sama dengan gradient descent?

Tidak. Backpropagation menghitung gradient. Gradient descent, atau optimizer lain seperti Adam, memakai gradient itu untuk mengubah weight. Backprop bisa dipasangkan dengan banyak optimizer yang berbeda.

Kenapa disebut backpropagation?

Sinyal error berawal dari output, tempat loss diukur, lalu dirambatkan mundur melewati network satu layer demi satu layer. Nama lengkapnya backward propagation of errors.

Bagaimana ReLU mengubah backpropagation?

Turunan ReLU bernilai 1 untuk input positif dan 0 untuk input negatif. Gradient melewati neuron yang aktif tanpa mengecil, dan ini membantu training network yang dalam. Namun, neuron yang negatif untuk semua input berhenti menerima gradient. Kegagalan ini disebut dead ReLU.

Kenapa backpropagation memakai banyak memori?

Backward pass membutuhkan aktivasi yang dihitung saat forward pass, jadi aktivasi itu disimpan di memori sampai gradient selesai dihitung. Kebutuhan memori bertambah seiring kedalaman network dan batch size. Gradient checkpointing menguranginya dengan hanya menyimpan sebagian aktivasi dan menghitung ulang sisanya saat backward pass.

Penjelasan terkait

Referensi

  1. Rumelhart, Hinton & Williams (1986), "Learning representations by back-propagating errors", Nature
  2. Baydin et al. (2018), "Automatic Differentiation in Machine Learning: a Survey"
  3. Chen et al. (2016), "Training Deep Nets with Sublinear Memory Cost"
  4. Nielsen, "Neural Networks and Deep Learning", chapter 2: How the backpropagation algorithm works
  5. Goodfellow, Bengio & Courville (2016), "Deep Learning", section 6.5: Back-Propagation

Terakhir diperbarui