Feed Forward Neural Network

Feed Forward Neural Network (FFNN) adalah arsitektur artificial neural network di mana informasi mengalir satu arah dari input ke output tanpa loops.

#Link to this headingIntroduction to ANN

#Link to this headingWhy ANN?

ANN terbukti berhasil di berbagai sektor. ANN cocok untuk masalah dengan karakteristik:

• Instances direpresentasikan oleh banyak attribute-value pairs
• Target function bisa discrete-valued, real-valued, atau vektor
• Training examples boleh mengandung noise/errors
• Waktu training yang lama dapat diterima
• Evaluasi cepat dari fungsi target yang dipelajari diperlukan
• Kemampuan manusia memahami hasil pembelajaran tidak penting

#Link to this headingWhat is ANN?

Perceptron (termasuk Adaline): satu unit/neuron, fungsi estimasi.

Artificial Neural Network: banyak computational units yang menjadi intelligent hanya melalui interaksi satu sama lain, terinspirasi dari otak, dan terdiri dari komposisi banyak fungsi berbeda.

#Link to this headingAdaline (ADAptive LInear NEuron)

Single layer Neural Network dengan update rule:

$w \leftarrow w + \eta (y - \hat{y}) \cdot x$

Error menggunakan Squared Error loss function. Disebut juga Widrow-Hoff rule atau LMS rule, yang merupakan bridge antara Perceptron dan FFNN.

#Link to this headingArsitektur ANN

Arsitektur FFNN terdiri dari:

• Input layer: $d$ input neurons ($x_1, x_2, \ldots, x_d$)
• Hidden layer(s): satu atau lebih layer tersembunyi
• Output layer: $m$ output neurons ($o_1, \ldots, o_m$)

Setiap layer terhubung sepenuhnya (fully connected) ke layer berikutnya.

#Link to this headingJenis Arsitektur ANN

#Link to this headingJumlah Parameter

Total parameter = jumlah bobot + jumlah bias.

$\text{Param per layer} = (\text{input units} + 1) \times \text{output units}$

Contoh: Input (8), HL1 (12), HL2 (8), Output (1):

$\text{Total} = (8+1) \times 12 + (12+1) \times 8 + (8+1) \times 1 = 108 + 104 + 9 = \mathbf{221}$

Implementasi Keras:

from keras.models import Sequential
from keras.layers import Dense
 
model = Sequential()
model.add(Dense(12, input_dim=8, activation='relu'))
model.add(Dense(8, activation='relu'))
model.add(Dense(1, activation='sigmoid'))
 
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
model.fit(X, y, epochs=150, batch_size=10)

#Link to this headingForward Propagation

Informasi mengalir melalui network dari input ke output untuk menghitung prediksi.

#Link to this headingFormula Forward Propagation

Untuk input vector $\mathbf{x}$, dengan bobot $W_{xh}$ (input ke hidden), bias $\mathbf{c}$ (hidden), bobot $W_{hy}$ (hidden ke output), dan bias $\mathbf{b}$ (output):

$f(\mathbf{x};\, W_{xh}, \mathbf{c}, W_{hy}, \mathbf{b}) = f_2\!\left(W_{hy}^T \cdot f_1\!\left(W_{xh}^T \cdot \mathbf{x} + \mathbf{c}\right) + \mathbf{b}\right)$

Jika bias dimasukkan ke dalam matriks bobot:

$f(\mathbf{x};\, W_{xh}, W_{hy}) = f_2\!\left(W_{hy}^T \cdot f_1\!\left(W_{xh}^T \cdot \mathbf{x}\right)\right)$

#Link to this headingForward Propagation dengan Mini-batch

Untuk input mini-batch $X$ (matriks):

$f(X;\, W_{xh}, \mathbf{c}, W_{hy}, \mathbf{b}) = f_2\!\left(f_1(X \cdot W_{xh} + \mathbf{c}) \cdot W_{hy} + \mathbf{b}\right)$

#Link to this headingContoh: XOR (Sigmoid)

$h_1 = \sigma(-10 + 20x_1 + 20x_2), \quad h_2 = \sigma(30 - 20x_1 - 20x_2)$

$y = \sigma(-30 + 20h_1 + 20h_2)$

#Link to this headingContoh: XOR (ReLU & Linear)

$h_1 = \text{ReLU}(0 + x_1 + x_2), \quad h_2 = \text{ReLU}(-1 + x_1 + x_2)$

$y = 0 + h_1 - 2h_2$

Verifikasi untuk $(x_1=1, x_2=1)$: $h_1 = \text{ReLU}(2) = 2$, $h_2 = \text{ReLU}(1) = 1$, $y = 2 - 2(1) = 0$ ✓

#Link to this headingFungsi Aktivasi

#Link to this headingBackpropagation

Backpropagation adalah algoritma untuk melatih FFNN dengan cara menghitung gradient error terhadap setiap bobot menggunakan chain rule.

#Link to this headingProsedur Learning

1. Forward propagation: hitung output $y$ untuk input $x$
2. Backward propagation: hitung error term $\delta$ untuk setiap neuron
3. Update setiap bobot berdasarkan error term

#Link to this headingBackpropagation untuk MLP

#Link to this headingError Term untuk Output Unit

Untuk output unit dengan loss function $E$ (squared error):

$\delta_o = \frac{\partial E}{\partial \text{net}_o} = -(t - o) \cdot f'(\text{net}_o)$

Jika menggunakan aktivasi sigmoid:

$\delta_o = -(t - o) \cdot o(1 - o)$

#Link to this headingError Term untuk Hidden Unit

Untuk hidden unit $h$ yang terhubung ke beberapa output units:

$\delta_h = f'(\text{net}_h) \cdot \sum_{k \in \text{outputs}} w_{hk} \cdot \delta_k$

Jika hidden unit menggunakan sigmoid:

$\delta_h = o_h(1 - o_h) \cdot \sum_{k \in \text{outputs}} w_{hk} \cdot \delta_k$

#Link to this headingWeight Update Rule

$w_{ij}^{\text{new}} = w_{ij}^{\text{old}} - \eta \cdot \frac{\partial E}{\partial w_{ij}} = w_{ij}^{\text{old}} - \eta \cdot \delta_j \cdot x_i$

Karena $\delta$ sudah mengandung tanda negatif dari $-(t-o)$, ini ekuivalen dengan:

$w_{ij}^{\text{new}} = w_{ij}^{\text{old}} + \eta \cdot (t - o) \cdot f'(\text{net}) \cdot x_i$

Initialize all weights to small random values
Until termination condition is met:
    For each training example <x, t>:
        // Forward pass
        Compute output o for each unit
 
        // Backward pass (output units)
        For each output unit k:
            δ_k = o_k(1 - o_k)(t_k - o_k)
 
        // Backward pass (hidden units, from output back to first hidden)
        For each hidden unit h:
            δ_h = o_h(1 - o_h) * Σ(w_hk * δ_k)
 
        // Weight update
        For each weight w_ij:
            w_ij = w_ij + η * δ_j * x_i

Termination conditions:

• Jumlah iterasi tetap
• Error pada training examples $<$ threshold
• Error pada validation set memenuhi kriteria

#Link to this headingContoh Backpropagation

Arsitektur: 2 input, 2 hidden (sigmoid), 2 output (sigmoid), $\eta = 0.5$.

Setup:

• $i_1 = 0.05$, $i_2 = 0.10$
• $w_1 = 0.15$, $w_2 = 0.20$, $w_3 = 0.25$, $w_4 = 0.30$ (input → hidden)
• $w_5 = 0.40$, $w_6 = 0.45$, $w_7 = 0.50$, $w_8 = 0.55$ (hidden → output)
• $b_1 = 0.35$ (bias hidden), $b_2 = 0.60$ (bias output)
• Target: $t_1 = 0.01$, $t_2 = 0.99$

#Link to this headingForward Pass

Hidden layer:

$\text{net}_{h_1} = w_1 i_1 + w_2 i_2 + b_1 = 0.15(0.05) + 0.20(0.10) + 0.35 = 0.3775$ $o_{h_1} = \sigma(0.3775) = 0.5933$

$\text{net}_{h_2} = w_3 i_1 + w_4 i_2 + b_1 = 0.25(0.05) + 0.30(0.10) + 0.35 = 0.3925$ $o_{h_2} = \sigma(0.3925) = 0.5969$

Output layer:

$\text{net}_{o_1} = w_5 o_{h_1} + w_6 o_{h_2} + b_2 = 0.40(0.5933) + 0.45(0.5969) + 0.60 = 1.1059$ $o_1 = \sigma(1.1059) = 0.7514$

$\text{net}_{o_2} = w_7 o_{h_1} + w_8 o_{h_2} + b_2 = 0.50(0.5933) + 0.55(0.5969) + 0.60 = 1.2250$ $o_2 = \sigma(1.2250) = 0.7729$

Total Error:

$E = \frac{1}{2}(t_1 - o_1)^2 + \frac{1}{2}(t_2 - o_2)^2 = \frac{1}{2}(0.01 - 0.7514)^2 + \frac{1}{2}(0.99 - 0.7729)^2 = 0.2748 + 0.0236 = \mathbf{0.2984}$

#Link to this headingBackward Pass

Error term output units (konvensi Mitchell: $\delta = (t-o) \cdot f'$):

$\delta_{o_1} = o_1(1 - o_1)(t_1 - o_1) = 0.7514 \times 0.2486 \times (-0.7414) = \mathbf{-0.1385}$

$\delta_{o_2} = o_2(1 - o_2)(t_2 - o_2) = 0.7729 \times 0.2271 \times 0.2171 = \mathbf{0.0381}$

Error term hidden units:

$\delta_{h_1} = o_{h_1}(1 - o_{h_1}) \cdot (w_5 \delta_{o_1} + w_7 \delta_{o_2}) = 0.5933 \times 0.4067 \times (0.40 \times (-0.1385) + 0.50 \times 0.0381) = \mathbf{-0.00876}$

$\delta_{h_2} = o_{h_2}(1 - o_{h_2}) \cdot (w_6 \delta_{o_1} + w_8 \delta_{o_2}) = 0.5969 \times 0.4031 \times (0.45 \times (-0.1385) + 0.55 \times 0.0381) = \mathbf{-0.00994}$

#Link to this headingWeight Update

Output layer weights ($w = w + \eta \cdot \delta_j \cdot x_i$):

Hidden layer weights:

#Link to this headingArsitektur untuk Klasifikasi Digit

Klasifikasi digit tulisan tangan (MNIST 28×28 = 784 piksel) menggunakan FFNN:

Input (784) → Hidden 1 (128, ReLU) → Hidden 2 (64, ReLU) → Output (10, Softmax)

#Link to this headingRingkasan