CONTOH PERHITUNGAN ALGORITMA BACKPROPAGATION

Beberapa waktu lalu saya dapat kesempatan untuk mengasisteni kegiatan kemkominfo
di UGM seputar AI. Salah satu topik yang dibicarakan adalah Backpropagation pada
Jaringan Saraf Tiruan (JST). Di postingan ini saya akan mencontohkan perhitungan
Backpropagation langkah per langkah, menggunakan arsitektur yang sederhana dan
dilanjutkan implementasi menggunakan Python.

Sebelum memulai, sebaiknya kita mengerti terlebih dahulu dasar-dasar untuk:

 Menghitung turunan satu variabel suatu persamaan

 Memahami cara perkalian matriks

Jika masih dirasa banyak yang lupa, silakan refresh kembali materi tersebut.

OVERVIEW

model / arsitektur JST sederhana

Sebelum kita mulai, kita ingat kembali beberapa poin penting dalam JST pada
ilustrasi di atas.
JST yang kita buat di atas terdiri dari 1 layer input (hijau) dan 1 layer output (biru).
Layer input kita terdiri dari 4 neuron (disimbolkan dengan xx) dan layer output kita
terdiri dari 3 neuron (disimbolkan dengan yy).
Layer input biasanya digunakan untuk menerima input berupa fitur suatu data.
Sedangkan layer output biasanya merepresentasikan prediksi kelas dari data tersebut.

Contoh datanya, misalkan diketahui sebuah data XX memiliki fitur sebagai berikut:
Fitur 1 Fitur 2 Fitur 3 Fitur 4

1.0 2.0 0.5 2.0

dan diketahui data tersebut termasuk pada kelas ke-“2”. Jika data tersebut diinputkan
ke dalam JST, maka:

1. Kita bisa petakan fitur-fitur tersebut pada XX, sehingga

diperoleh x1x1=1.0, x2x2=2.0, x3x3=0.5, x4x4=2.0
2. Sedangkan untuk kelas atau label, kita perlu mengubah bentuknya menjadi one-
hot encoding, yakni sebuah vektor yang semua isinya bernilai 0 kecuali pada
kelasnya. Misalnya untuk data dengan tiga kelas, kelas pertamanya bernilai [1,
0, 0], kelas keduanya bernilai [0, 1, 0], dan kelas ketiganya [0, 0, 1], sehingga
diperoleh t1t1=0, t2t2=1, t3t3=0. Variabel tt adalah variabel label.
3. JST akan menghitung nilai y1y1, y2y2, dan y3y3 berdasarkan input XX. Lalu
melalui proses pembelajaran, JST berusaha menghasilkan nilai yy yang sama
dengan nilai tt

Ada dua bagian utama pada JST, yakni forward propagation dan backward
propagation. pada forward propagation, JST akan mencoba menghasilkan nilai yy,
sedangkan pada backward propagation, JST akan memperbaiki dirinya (update
bobot) sehingga pada forward propagation berikutnya diharap bisa menghasilkan
nilai yy yang lebih baik atau lebih mendekati label aslinya.
FORWARD PROPAGATION
Forward propagation adalah proses perhitungan secara “maju” dari input
(disimbolkan xx) hingga diperoleh output model (disimbolkan yy). Misal pada
ilustrasi di atas, nilai y1y1, y2y2, dan y3y3 diperoleh dengan menghitung:
y1y2y3=σ(w11x1+w21x2+w31x3+w41x4+b1)=σ(w12x1+w22x2+w32x3+w42x4+b
2)=σ(w13x1+w23x2+w33x3+w43x4+b3)y1=σ(w11x1+w21x2+w31x3+w41x4+b1)y
2=σ(w12x1+w22x2+w32x3+w42x4+b2)y3=σ(w13x1+w23x2+w33x3+w43x4+b3)
atau bisa juga disingkat menjadi:

yj=σ(∑i=14wijxi+bj)yj=σ(∑i=14wijxi+bj)
Rumus di atas, sangat penting untuk dipahami, untuk penjelasannya simbol-
simbolnya:

 Simbol bibi menunjukkan nilai bias. Nilai bias ini mirip dengan nilai bobot
hanya saja tidak dikalikan dengan input. Tujuannya agar garis persamaan bisa
lebih kompleks (tidak selalu melewati titik origin).
 Semua nilai bobot ww dan bias bb awalnya diberikan nilai random, dan
diperbarui nilainya dengan proses backprop untuk meningkatkan kualitas
model.
 Angka 4 menunjukkan banyak neuron di layer sebelah kiri (layer input).
 Simbol σ()σ() (sigma) adalah simbol dari fungsi aktivasi. Artinya, setelah
proses perkalian input xx dan bobot ww lalu dilakukan penjumlahan semua,
langkah selanjutnya adalah mengenai hasil perhitungan tersebut dengan fungsi
aktivasi. Ada banyak fungsi aktivasi yang dapat dipilih salah satunya fungsi
aktivasi sigmoid yang bentuknya seperti ini:

σ(x)=11+e−xσ(x)=11+e−x
CONTOH FORWARD PROPAGATION
Misalkan diketahui input seperti tabel di atas X=[1,2,0.5,2]X=[1,2,0.5,2] dengan
nilai bobot dan bias di awal adalah sebagai berikut (nilai random, saya susun seperti
matrix agar mudah):
⎡⎣⎢⎢⎢w11=0.1w21=0.2w31=0.1w41=0.2w12=0.2w22=0.1w32=0.3w42=0.3w13=
0.3w23=0.3w33=0.2w43=0.1⎤⎦⎥⎥⎥[w11=0.1w12=0.2w13=0.3w21=0.2w22=0.1w23
=0.3w31=0.1w32=0.3w33=0.2w41=0.2w42=0.3w43=0.1]

[b1=0,b2=1,b3=2][b1=0,b2=1,b3=2]
Maka dapat kita hitung nilai y1y1 adalah:
y1=σ(w11x1+w21x2+w31x3+w41x4+b1)=σ(0.1×1+0.2×2+0.1×0.5+0.2×2+0)=
σ(0.95)=0.72y1=σ(w11x1+w21x2+w31x3+w41x4+b1)=σ(0.1×1+0.2×2+0.1×0.5+0.
2×2+0)=σ(0.95)=0.72
Dengan cara perhitungan yang sama dapat diperoleh juga
nilai y2y2 adalah 0.890.89 dan nilai y3y3 adalah 0.960.96. Sampai sini, coba
dipahami lagi prosesnya bagaimana bisa mendapatkan semua nilai yy.

ERROR
Dari perhitungan sebelumnya diperoleh nilai sebagai berikut:

[y1=0.72,y2=0.89,y3=0.96][y1=0.72,y2=0.89,y3=0.96]
Nilai tersebut adalah nilai prediksi, atau nilai yang dihasilkan oleh model JST kita.
Seperti disebutkan sebelumnya setiap data yang masuk memiliki label
atau nilai yy yang diharapkan, misalnya untuk data XX di atas kita ingin model kita
seharusnya bernilai berikut (untuk membedakan dengan yy kita beri simbol tt):
[t1=0,t2=1,t3=0][t1=0,t2=1,t3=0]
Dari sana tampak betapa bedanya nilai prediksi kita (yy) dengan nilai target (tt). Kita
bisa menghitung seberapa melenceng prediksi kita menggunakan rumus
untuk menghitung error. Yang paling sederhana adalah dengan rumus Mean Square
Error:
error=13∑i=13(targeti–prediksii)2error=13∑i=13(targeti–prediksii)2
sederhananya rumus tersebut menghitung selisih nilai target dan prediksi,
mengkuadratkannya, lalu merata-rata dari ketiga nilai tersebut (angka “3” diperoleh
dari arsitektur JST kita yang akan mengklasifikasikan data ke 3 kelas)

Sehingga untuk perhitungan kita di atas, dapat dihitung error EE yang dihasilkan
adalah sebesar:
E=13∑i=13(targeti–prediksii)2=13((t1–y1)2+(t2–y2)2+(t3−y3)2)=13((0–
0.72)2+(1–
0.89)2+(0−0.96)2)=13(0.518+0.012+0.921)=0.483 E=13∑i=13(targeti–
prediksii)2=13((t1–y1)2+(t2–y2)2+(t3−y3)2)=13((0–0.72)2+(1–
0.89)2+(0−0.96)2)=13(0.518+0.012+0.921)=0.483

Karena tujuan JST adalah untuk menghasikan nilai prediksi yy yang semirip mungkin
dengan tt, maka dapat disebut juga tujuan dari JST adalah meminimalkan nilai
error EE.

BACKPROPAGATION
Setelah mendapatkan nilai error, kita bisa mulai memperbaiki JST kita dengan
backpropagation. Sebenarnya istilah memperbaiki JST ini kurang tepat jika
menyebutnya Backpropagation, lebih tepatnya adalah Gradient Descent. Tapi ya di
Indonesia lebih umum menyebutnya Backpropagation kadang disingkat Backprop.

Rumus utamanya untuk memperbaiki suatu bobot ww berdasarkan error EE adalah:

wnew=wold–α∂E∂wwnew=wold–α∂E∂w
Rumus Ini juga berlaku untuk memperbaiki nilai bias:

bnew=bold–α∂E∂bbnew=bold–α∂E∂b
Simbol αα pada rumus di atas adalah learning rate, sebuah konstanta (biasanya antara
0-1) yang menentukan seberapa cepat proses pembelajaran model dilakukan. Di
artikel ini kita akan menggunakan nilai α=0.5α=0.5. Sedangkan
simbol ∂E∂w∂E∂w atau dibaca “turunan parsial EE terhadap ww” adalah proses
mencari nilai turunan EE terhadap variabel yang akan diperbarui, dalam contoh
ini ww. Proses mencari turunan inilah yang baru lebih tepat disebut
backpropagation. Karena ada banyak nilai ww, kita akan spesifikkan untuk
mengupdate nilai w11w11 terlebih dulu.
KONSEP CHAINING
Untuk menghitung ∂E∂w∂E∂w, pertama-tama kita coba berjalan mundur dulu. Dari
mana nilai EE didapatkan dan apa hubungannya dengan w11w11.

Nilai EE diperoleh dari rumus Mean Square Error:

E=13((t1–y1)2+(t2–y2)2+(t3−y3)2)E=13((t1–y1)2+(t2–y2)2+(t3−y3)2)
dari rumus di atas tidak ada variabel w11w11 tetapi kita bisa coba “jalan mundur”
lagi. Kita ingat-ingat lagi dari mana nilai setiap variabel yy berasal.
y1y2y3=σ(w11x1+w21x2+w31x3+w41x4+b1)=σ(w12x1+w22x2+w32x3+w42x4+b
2)=σ(w13x1+w23x2+w33x3+w43x4+b3)y1=σ(w11x1+w21x2+w31x3+w41x4+b1)y
2=σ(w12x1+w22x2+w32x3+w42x4+b2)y3=σ(w13x1+w23x2+w33x3+w43x4+b3)

dari sini terlihat variabel w11w11 ada di perhitungan y1y1 yang secara tidak langsung
berpengaruh ke nilai EE. Hal ini yang disebut dengan chaining atau rantaian.

DASAR TURUNAN
Setelah kita memahami hubungan EE dan w11w11 langkah selanjutnya adalah kita
pahami bagaimana dasar menghitung turunannya. Disini kita menggunakan turunan
parsial yang bedanya dengan turunan biasa adalah fungsi bisa mengandung lebih dari
satu variabel. Selain itu, kita tidak menggunakan simbol dd tetapi turunan parsial
menggunakan simbol ∂∂. Dari sekian banyak materi turunan jaman SMA kita cukup
mengingat beberapa aturan saja (aturan no. 5 tidak diajarkan di SMA):

1. jika f(x)=xnf(x)=xn maka ∂f(x)∂x=nxn−1∂f(x)∂x=nxn−1

 2. jika f(x)=u(x)+v(x)f(x)=u(x)+v(x) maka ∂f(x)∂x=∂u(x)∂x+∂v(x)∂x∂f(x)∂x=∂u(x)
∂x+∂v(x)∂x
3. jika f(x,y)=u(x)+v(y)f(x,y)=u(x)+v(y) maka ∂f(x)∂x=∂u(x)∂x+0∂f(x)∂x=∂u(x)∂
x+0
4. jika f(x)=f(g(x))f(x)=f(g(x)) maka ∂f(x)∂x=∂f(x)∂g(x)×∂g(x)∂x∂f(x)∂x=∂f(x)∂g(x)
×∂g(x)∂x
5. jika f(x)=σ(x)f(x)=σ(x) dengan σ(x)σ(x) adalah fungsi sigmoid,
maka ∂f(x)∂x=f(x)(1−f(x))∂f(x)∂x=f(x)(1−f(x))

MENGHITUNG TURUNAN
Nah, mari kita menghitung nilai ∂E∂w∂E∂w dengan beberapa langkah menggunakan
aturan perhitungan yang disebutkan sebelumnya.
Langkah 1
Menggunakan aturan no. 4 di atas kita bisa mengubah ∂E∂w11∂E∂w11 menjadi berikut:
∂E∂w11=∂E∂y1×∂y1∂w11∂E∂w11=∂E∂y1×∂y1∂w11
Kita selesaikan bagian pertamanya, menggunakan aturan no. 3 dan no. 4 di atas,
maka:

E∂E∂y1=13((t1–y1)2+(t2–y2)2+(t3−y3)2)=213(t1–y1)2−1−1+0+0=–23(t1–
y1)E=13((t1–y1)2+(t2–y2)2+(t3−y3)2)∂E∂y1=213(t1–y1)2−1−1+0+0=–23(t1–y1)
Langkah 2
Untuk bagian keduanya kita lihat kembali rumus asli untuk menghitung y1y1. Fungsi
sigma di sini bisa kita pecah menjadi fungsi yang lain. Misalnya kita
definisikan z1z1 adalah sebagai berikut:
z1=w11x1+w21x2+w31x3+w41x4+b1z1=w11x1+w21x2+w31x3+w41x4+b1
maka fungsi y1y1 menjadi
y1=σ(z1)y1=σ(z1)
Dengan aturan no. 4 kita bisa memecah kembali ∂y1∂w11∂y1∂w11 menjadi:
∂y1∂w11=∂y1∂z1×∂z1∂w11∂y1∂w11=∂y1∂z1×∂z1∂w11
Kita selesaikan bagian ∂y1∂z1∂y1∂z1 dengan aturan no. 5:
y1∂y1∂z1=σ(z1)=y1(1–y1)y1=σ(z1)∂y1∂z1=y1(1–y1)
lalu untuk bagian ∂z1∂w11∂z1∂w11 kita selesaikan menggunakan aturan no. 2 dan no. 3,
menjadi:
z1∂z1∂w11=w11x1+w21x2+w31x3+w41x4+b1=x1+0+0+0+0=x1z1=w11x1+w21x
2+w31x3+w41x4+b1∂z1∂w11=x1+0+0+0+0=x1
Gabungkan semua
Secara ringkas dari perhitungan-perhitungan di atas, maka nilai
dari ∂E∂w11∂E∂w11 adalah:
∂E∂w11=∂E∂y1×∂y1∂z1×∂z1∂w11=–23(t1–y1)×y1(1–
y1)×x1∂E∂w11=∂E∂y1×∂y1∂z1×∂z1∂w11=–23(t1–y1)×y1(1–y1)×x1
Jika diinputkan dengan angka maka:

∂E∂w11=23(t1–y1)×y1(1–y1)×x1=–23(0–0.72)×0.72(1–
0.72)×1=0.0967∂E∂w11=23(t1–y1)×y1(1–y1)×x1=–23(0–0.72)×0.72(1–
0.72)×1=0.0967

Sehingga untuk memperbarui bobot w11w11 nilai yang baru dengan

nilai α=0.5α=0.5 (contoh) adalah:
w11new=w11old–α∂E∂w11=0.1–(0.5)(0.0967)=0.0516w11new=w11old–
α∂E∂w11=0.1–(0.5)(0.0967)=0.0516

MENGUPDATE SEMUA
BOBOT
INGAT! perhitungan di atas belum selesai memperbarui semua bobot dan bias.
Proses di atas kita lakukan ke semua bobot ww dan bias bb.
Tetapi jangan takut, karena sudah dapat rumus turunannya, kita bisa langsung lihat
pola rumusnya. Misalnya untuk w21w21 kita bisa cukup mengubah bagian
nilai ∂z1∂w21∂z1∂w21 ketika menghitung turunan (karena w21w21 masih sama-sama
bagian dari y1y1).
 ∂E∂w21=∂E∂y1×∂y1∂z1×∂z1∂w21=23(t1–y1)×y1(1–y1)×x2=−23(0–
0.72)×0.72(1–0.72)×2=0.1934∂E∂w21=∂E∂y1×∂y1∂z1×∂z1∂w21=23(t1–
y1)×y1(1–y1)×x2=−23(0–0.72)×0.72(1–0.72)×2=0.1934

w21new=w21old–α∂E∂w21=0.2–(0.5)(0.1934)=0.1033w21new=w21old–
α∂E∂w21=0.2–(0.5)(0.1934)=0.1033

Namun, agak berbeda jika kita ingin memperbarui nilai w12w12 hal ini karena jika
diperhatikan w12w12 tidak ikut membangun nilai y1y1 tetapi berada
dipembentukan y2y2. Maka untuk menghitung turunannya menjadi beda:

∂E∂w12=∂E∂y2×∂y2∂z2×∂z2∂w12=23(t2–y2)×y2(1–y2)×x1=−23(1–
0.89)×0.89(1–0.89)×1=−0.0071∂E∂w12=∂E∂y2×∂y2∂z2×∂z2∂w12=23(t2–
y2)×y2(1–y2)×x1=−23(1–0.89)×0.89(1–0.89)×1=−0.0071
 w12new=w12old–α∂E∂w12=0.2–(0.5)(−0.0071)=0.2035w12new=w12old–
α∂E∂w12=0.2–(0.5)(−0.0071)=0.2035

EVALUASI
Setelah melakukan backpropagation untuk semua bobot dan bias, maka akan
diperoleh hasil bobot sebagai berikut:

⎡⎣⎢⎢⎢w11=0.051w21=0.103w31=0.075w41=0.103w12=0.203w22=0.106w32=0.
301w42=0.306w13=0.287w23=0.275w33=0.193w43=0.075⎤⎦⎥⎥⎥[w11=0.051w1
2=0.203w13=0.287w21=0.103w22=0.106w23=0.275w31=0.075w32=0.301w33=0.19
3w41=0.103w42=0.306w43=0.075]

[b1=−0.19,b2=1.01,b3=1.95][b1=−0.19,b2=1.01,b3=1.95]
Untuk mengevaluasi kita bisa mengecek kembali hasilnya dengan forward
propagation (tanpa perlu backpropagation). Jika kita lakukan forward propagation,
maka akan diperoleh nilai yy sebagai berikut:
[y1=0.57,y2=0.89,y3=0.95][y1=0.57,y2=0.89,y3=0.95]
Jika kita hitung errornya maka akan terjadi perubahan nilai dari sebelum dilakukan
backpropagation. Nilai error telah menjadi lebih kecil dari sebelumnya (error
sebelumnya 0.483):

E=13∑i=13(targeti–prediksii)2=13((t1–y1)2+(t2–y2)2+(t3−y3)2)=13((0–
0.57)2+(1–0.89)2+(0−0.95)2)=0.413 E=13∑i=13(targeti–prediksii)2=13((t1–
y1)2+(t2–y2)2+(t3−y3)2)=13((0–0.57)2+(1–0.89)2+(0−0.95)2)=0.413

Hal tersebut menandakan backpropagation kita telah berhasil

Proses di atas adalah proses iterasi 1 kali backpropagation. Pada kenyataannya proses
ini dilakukan berulang kali untuk mendapatkan hasil yang optimal dan juga dilakukan
untuk banyak data.

Proses implementasi akan dibahas di post selanjutnya insyaAllah. Sekian, jika ada
yang ditanyakan seputar rumus atau perhitungannya, silakan bertanya di kolom
komentar Terima kasih