2022-10-23

Backpropagation

Apa itu Backpropagation

Backpropagation sangat penting dalam proses pelatihan model deep learning karena memungkinkan perhitungan gradien yang efisien yang diperlukan untuk memperbarui bobot dan bias jaringan saraf. Dengan meminimalkan kesalahan antara keluaran prediksi dan keluaran aktual, backpropagation memungkinkan jaringan saraf untuk belajar dan beradaptasi dengan data baru, meningkatkan kinerjanya.

Algoritma Backpropagation

Dalam bab ini, saya akan mengeksplorasi algoritma backpropagation dan perannya dalam pelatihan jaringan saraf deep learning. Kita akan membahas konsep matematika penting seperti aturan rantai dan penurunan gradien, sebelum membahas algoritma secara detail dan memberikan pseudocode untuk implementasinya.

Aturan Rantai dalam Kalkulus

Aturan rantai adalah konsep dasar dalam kalkulus yang memungkinkan kita menghitung turunan dari fungsi komposit. Aturan ini memainkan peran penting dalam backpropagation, karena membantu kita menghitung gradien dari fungsi kerugian terhadap bobot dan bias dalam jaringan.

\frac{dy}{dx} = \frac{dy}{dg(x)} \cdot \frac{dg(x)}{dx}

Diberikan fungsi komposit $y = f(g(x))$ , aturan rantai menyatakan bahwa turunan $y$ terhadap $x$ adalah hasil kali turunan $f$ terhadap $g(x)$ dan turunan $g(x)$ terhadap $x$ :

Fungsi Kerugian

Fungsi kerugian, juga dikenal sebagai fungsi biaya atau fungsi tujuan, mengukur perbedaan antara keluaran prediksi dan keluaran aktual (target) dari jaringan saraf. Fungsi kerugian umum meliputi mean squared error (MSE) untuk tugas regresi dan cross-entropy untuk tugas klasifikasi.

Sebagai contoh, mean squared error didefinisikan sebagai:

L = \frac{1}{N}\sum_{i=1}^{N}(y_i - \hat{y}_i)^2

di mana $N$ adalah jumlah sampel, $y_i$ adalah keluaran aktual, dan $\hat{y}_i$ adalah keluaran prediksi.

Penurunan Gradien

Penurunan gradien adalah algoritma optimasi yang digunakan untuk meminimalkan fungsi kerugian dengan iteratif memperbarui bobot dan bias dalam jaringan. Ide dasarnya adalah menghitung gradien fungsi kerugian terhadap parameter dan kemudian memperbarui parameter dengan mengambil langkah proporsional terhadap negatif gradien.

Aturan umum untuk memperbarui bobot menggunakan penurunan gradien adalah:

w_{t+1} = w_t - \eta \frac{\partial L}{\partial w_t}

di mana $w_t$ adalah bobot saat ini, $w_{t+1}$ adalah bobot yang diperbarui, $\eta$ adalah tingkat pembelajaran, dan $\frac{\partial L}{\partial w_t}$ adalah gradien dari fungsi kerugian terhadap bobot.

Algoritma secara Detail

Algoritma backpropagation terdiri dari dua langkah utama: langkah maju dan langkah mundur.

Langkah Maju
Pada langkah maju, data input diproses melalui jaringan untuk menghitung keluaran prediksi. Ini melibatkan penghitungan jumlah terbobot dari masukan dan bias untuk setiap neuron dan menerapkan fungsi aktivasi untuk menghasilkan keluaran neuron.

-Langkah Mundur
Pada langkah mundur, gradien dari fungsi kerugian terhadap bobot dan bias dihitung menggunakan aturan rantai. Gradien tersebut kemudian digunakan untuk memperbarui bobot dan bias menggunakan penurunan gradien.

Algoritma backpropagation dapat diringkas sebagai berikut:

Lakukan langkah maju untuk menghitung keluaran prediksi.
Hitung kerugian menggunakan fungsi kerugian.
Hitung gradien dari fungsi kerugian terhadap aktivasi lapisan keluaran.
Hitung gradien dari fungsi kerugian terhadap bobot dan bias dalam jaringan menggunakan aturan rantai.
Perbarui bobot dan bias menggunakan penurunan gradien.

Turunan Backpropagation

Dalam bab ini, saya akan turunkan algoritma backpropagation langkah demi langkah, menggunakan aturan rantai dan metode optimasi penurunan gradien. Kita akan terlebih dahulu mendefinisikan notasi yang diperlukan dan kemudian melanjutkan untuk turunkan persamaan pembaruan untuk bobot dan bias dalam jaringan.

Notasi

Mari kita definisikan notasi berikut untuk jaringan saraf kita:

$L$ : Jumlah lapisan dalam jaringan.
$N_l$ : Jumlah neuron dalam lapisan $l$ .
$w^l_{jk}$ : Bobot yang menghubungkan neuron $k$ di lapisan $l-1$ dengan neuron $j$ di lapisan $l$ .
$b^l_j$ : Bias untuk neuron $j$ di lapisan $l$ .
$a^l_j$ : Aktivasi neuron $j$ di lapisan $l$ .
$z^l_j$ : Jumlah terbobot dari masukan dan bias untuk neuron $j$ di lapisan $l$ , didefinisikan sebagai $z^l_j = \sum_k w^l_{jk} a^{l-1}_k + b^l_j$ .
$f^l$ : Fungsi aktivasi untuk neuron di lapisan $l$ .
$L(\mathbf{y}, \mathbf{\hat{y}})$ : Fungsi kerugian, di mana $\mathbf{y}$ mewakili keluaran aktual dan $\mathbf{\hat{y}}$ mewakili keluaran prediksi.

Turunan Algoritma Backpropagation

Untuk menurunkan algoritma backpropagation, kita perlu menghitung gradien dari fungsi kerugian terhadap bobot dan bias. Kita akan mulai dengan menghitung gradien terhadap aktivasi lapisan keluaran.

Langkah 1: Hitung gradien dari fungsi kerugian terhadap aktivasi lapisan keluaran

\frac{\partial L}{\partial a^{L}_j}

Langkah 2: Hitung error term untuk neuron di lapisan keluaran

Kita definisikan error term untuk neuron $j$ di lapisan $L$ sebagai $\delta^L_j$ :

\delta^L_j = \frac{\partial L}{\partial z^{L}_j}

Using the chain rule, we can express $\delta^L_j$ as:

\delta^L_j = \frac{\partial L}{\partial a^{L}_j} \cdot f'^{L}(z^{L}_j)

Langkah 3: Hitung error term untuk neuron di lapisan tersembunyi

Untuk lapisan tersembunyi, kita dapat menghitung error term menggunakan error term dari lapisan berikutnya (lapisan $l+1$ ) dan aturan rantai:

\delta^l_j = \frac{\partial L}{\partial z^{l}_j} = \sum_k \frac{\partial L}{\partial z^{l+1}_k} \cdot \frac{\partial z^{l+1}_k}{\partial z^{l}_j} = \sum_k \delta^{l+1}_k \cdot \frac{\partial z^{l+1}_k}{\partial z^{l}_j}

Dengan menerapkan aturan rantai sekali lagi:

\delta^l_j = \sum_k \delta^{l+1}_k \cdot w^{l+1}_{kj} \cdot f'^{l}(z^{l}_j)

Langkah 4: Hitung gradien dari fungsi kerugian terhadap bobot

Sekarang bahwa kita memiliki error term untuk semua neuron dalam jaringan, kita dapat menghitung gradien dari fungsi kerugian terhadap bobot. Dengan aturan rantai, kita dapatkan:

\frac{\partial L}{\partial w^l_{jk}} = \delta^l_j \cdot a^{l-1}_k

Langkah 5: Hitung gradien dari fungsi kerugian terhadap bias

Demikian pula, kita dapat menghitung gradien dari fungsi kerugian terhadap bias:

\frac{\partial L}{\partial b^l_j} = \delta^l_j

Langkah 6: Perbarui bobot dan bias menggunakan penurunan gradien

Dengan gradien dari fungsi kerugian terhadap bobot dan bias, kita sekarang dapat memperbarui mereka menggunakan metode penurunan gradien:

w^l_{jk} \leftarrow w^l_{jk} - \eta \delta^l_j \cdot a^{l-1}_k

b^l_j \leftarrow b^l_j - \eta \delta^l_j

Dengan menerapkan persamaan pembaruan ini secara iteratif selama proses pelatihan, algoritma backpropagation memungkinkan jaringan saraf untuk belajar dan beradaptasi dengan data input, sehingga meminimalkan fungsi kerugian.

Jaringan Saraf Forward Propagation dengan Backpropagation Menggunakan Python

Berikut adalah contoh implementasi jaringan saraf feedforward sederhana dengan backpropagation menggunakan Python dan Numpy.

python

import numpy as np

# Activation function and its derivative
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

def sigmoid_derivative(x):
    return sigmoid(x) * (1 - sigmoid(x))

# Initialize network
def initialize_network(input_nodes, hidden_nodes, output_nodes):
    network = {
        "W1": np.random.randn(hidden_nodes, input_nodes) * 0.1,
        "b1": np.zeros((hidden_nodes, 1)),
        "W2": np.random.randn(output_nodes, hidden_nodes) * 0.1,
        "b2": np.zeros((output_nodes, 1))
    }
    return network

# Forward pass
def forward_pass(network, X):
    W1, b1, W2, b2 = network["W1"], network["b1"], network["W2"], network["b2"]
    Z1 = np.dot(W1, X) + b1
    A1 = sigmoid(Z1)
    Z2 = np.dot(W2, A1) + b2
    A2 = sigmoid(Z2)

    return Z1, A1, Z2, A2

# Backward pass
def backward_pass(network, X, y, Z1, A1, Z2, A2, learning_rate):
    m = X.shape[1]
    dZ2 = A2 - y
    dW2 = (1 / m) * np.dot(dZ2, A1.T)
    db2 = (1 / m) * np.sum(dZ2, axis=1, keepdims=True)
    dZ1 = np.dot(network["W2"].T, dZ2) * sigmoid_derivative(Z1)
    dW1 = (1 / m) * np.dot(dZ1, X.T)
    db1 = (1 / m) * np.sum(dZ1, axis=1, keepdims=True)

    network["W1"] -= learning_rate * dW1
    network["b1"] -= learning_rate * db1
    network["W2"] -= learning_rate * dW2
    network["b2"] -= learning_rate * db2

# Training the network
def train_network(network, X, y, epochs, learning_rate):
    for i in range(epochs):
        Z1, A1, Z2, A2 = forward_pass(network, X)
        backward_pass(network, X, y, Z1, A1, Z2, A2, learning_rate)

# Example
input_nodes = 2
hidden_nodes = 3
output_nodes = 1
network = initialize_network(input_nodes, hidden_nodes, output_nodes)

# Training data (XOR problem)
X = np.array([[0, 0, 1, 1], [0, 1, 0, 1]])
y = np.array([[0, 1, 1, 0]])

epochs = 10000
learning_rate = 0.1

train_network(network, X, y, epochs, learning_rate)

# Testing
Z1, A1, Z2, A2 = forward_pass(network, X)
predictions = (A2 > 0.5).astype(int)
print("Predictions:", predictions)

Implementasi ini menunjukkan jaringan saraf feedforward sederhana dengan satu lapisan tersembunyi. Dengan menyesuaikan arsitektur dan parameter pelatihan, jaringan ini dapat disesuaikan untuk menyelesaikan masalah yang lebih kompleks.