Backpropagation

Backpropagation adalah sebuah algoritma yang digunakan dalam jaringan saraf tiruan (neural network) untuk menghitung gradien dari fungsi biaya (cost function) terhadap parameter-parameter yang ada dalam jaringan tersebut. Algoritma ini digunakan dalam proses pelatihan (training) jaringan saraf tiruan dengan mengoptimalkan parameter-parameter tersebut.

Proses backpropagation terdiri dari dua tahap: tahap maju (forward pass) dan tahap mundur (backward pass).

Pada tahap maju, input data diberikan kepada jaringan saraf tiruan dan diteruskan melalui setiap lapisan (layer) jaringan, dari lapisan input ke lapisan output. Selama tahap ini, nilai output dari setiap neuron di setiap lapisan dihitung menggunakan fungsi aktivasi yang telah ditentukan.

Setelah tahap maju selesai, tahap mundur dimulai. Pada tahap ini, gradien dari fungsi biaya terhadap setiap parameter dalam jaringan dihitung menggunakan aturan rantai (chain rule) dari kalkulus. Gradien ini menunjukkan sejauh mana perubahan pada parameter-parameter tersebut akan mempengaruhi nilai fungsi biaya. Gradien ini diteruskan mundur melalui jaringan, dari lapisan output ke lapisan input.

Setelah gradien dihitung, algoritma optimisasi seperti gradien turun (gradient descent) dapat digunakan untuk memperbarui parameter-parameter jaringan berdasarkan gradien tersebut. Tujuan utama dari backpropagation adalah untuk menemukan nilai-nilai parameter yang meminimalkan fungsi biaya, sehingga jaringan dapat melakukan prediksi atau klasifikasi dengan akurasi yang tinggi.

Dengan menggunakan backpropagation, jaringan saraf tiruan dapat belajar dan menyesuaikan bobot dan biasnya secara otomatis selama proses pelatihan. Ini memungkinkan jaringan saraf untuk mempelajari pola-pola yang terdapat dalam data pelatihan dan menghasilkan prediksi yang lebih baik pada data yang belum pernah dilihat sebelumnya.

import pandas as pd
import numpy as np

# Baca file Excel
data = {'x1': [0.2, 0.4, 0.3, 0.2],
        'x2': [0.4, 0.3, 0.2, 0.5],
        'y': [0.2, 0.1, 0.1, 0.3]}
df = pd.DataFrame(data)
print(df)
data_array = df.values

# Mengambil fitur X
X = data_array[:, :-1]

# Mengambil target y
y = data_array[:, -1:]

print("Fitur (X):")
print(X)
print("Target (y):")
print(y)

    x1   x2    y
0  0.2  0.4  0.2
1  0.4  0.3  0.1
2  0.3  0.2  0.1
3  0.2  0.5  0.3
Fitur (X):
[[0.2 0.4]
 [0.4 0.3]
 [0.3 0.2]
 [0.2 0.5]]
Target (y):
[[0.2]
 [0.1]
 [0.1]
 [0.3]]

# Fungsi aktivasi sigmoid
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

# Derivatif dari fungsi sigmoid
def sigmoid_derivative(x):
    return x * (1 - x)

# Kelas untuk jaringan saraf tiruan
class NeuralNetwork:
    def __init__(self, input_size, hidden_size, output_size):
        # Inisialisasi bobot secara acak
        self.weights1 = np.random.randn(input_size, hidden_size)
        self.weights2 = np.random.randn(hidden_size, output_size)
    
    def forward(self, X):
        # Propagasi maju (menghitung nilai output)
        self.hidden = sigmoid(np.dot(X, self.weights1))  # Menghitung nilai hidden layer
        self.output = sigmoid(np.dot(self.hidden, self.weights2))  # Menghitung nilai output layer
    
    def backward(self, X, y, learning_rate):
        # Hitung gradien dan perbarui bobot
        self.error = y - self.output  # Menghitung error
        self.delta_output = self.error * sigmoid_derivative(self.output)  # Menghitung delta output layer
        self.hidden_error = self.delta_output.dot(self.weights2.T)  # Menghitung error hidden layer
        self.delta_hidden = self.hidden_error * sigmoid_derivative(self.hidden)  # Menghitung delta hidden layer
        
        # Perbarui bobot menggunakan metode backpropagation
        self.weights2 += self.hidden.T.dot(self.delta_output) * learning_rate  # Perbarui bobot output layer
        self.weights1 += X.T.dot(self.delta_hidden) * learning_rate  # Perbarui bobot hidden layer
    
    def train(self, X, y, iterasi, learning_rate):
        for _ in range(iterasi):
            self.forward(X)
            self.backward(X, y, learning_rate)
    
    def predict(self, X):
        self.forward(X)
        return self.output

# Inisialisasi jaringan saraf tiruan
input_size = 2
hidden_size = 4
output_size = 1
learning_rate = 0.1
iterasi = 4

nn = NeuralNetwork(input_size, hidden_size, output_size)

# Melatih jaringan saraf tiruan
nn.train(X, y, iterasi, learning_rate)

# Melakukan prediksi
print("Hasil prediksi:")
for i in range(len(X)):
    output = nn.predict(X[i])
    print(X[i], "->", output)

Hasil prediksi:
[0.2 0.4] -> [0.54285168]
[0.4 0.3] -> [0.54254931]
[0.3 0.2] -> [0.55147115]
[0.2 0.5] -> [0.53720151]