Modul 3: Forward Propagation - Kursus Neural Network

🏗️ Membangun Arsitektur

Di Modul 2, kita hanya punya satu neuron. Tapi satu neuron saja tidak cukup pintar untuk menyelesaikan masalah yang kompleks (seperti mengenali wajah). Kita butuh ribuan, bahkan jutaan neuron yang bekerja sama.

Kita menyusun neuron-neuron ini dalam lapisan-lapisan (Layers):

Input Layer: Layer 0 (Awal data masuk).
Hidden Layers: Layer 1, 2, dst. (Tempat "Magic" terjadi).
Output Layer: Layer terakhir (Hasil prediksi).

Istilah Penting: Deep Learning

Jika sebuah Neural Network memiliki banyak Hidden Layer (lebih dari 1), maka ia disebut "Deep Neural Network". Inilah asal mula istilah Deep Learning.

🚀 Bagaimana Data Mengalir? (Forward Pass)

Proses mengalirnya data dari Input -> Hidden -> Output disebut Forward Propagation. Mari kita lihat apa yang terjadi di setiap layer secara matematis.

Arsitektur Neural Network Sederhana

                                graph LR
                                    subgraph Input Layer
                                        x1((x1))
                                        x2((x2))
                                    end
                                    subgraph Hidden Layer
                                        h1((h1))
                                        h2((h2))
                                        h3((h3))
                                    end
                                    subgraph Output Layer
                                        y((y))
                                    end
                                    x1 --> h1
                                    x1 --> h2
                                    x1 --> h3
                                    x2 --> h1
                                    x2 --> h2
                                    x2 --> h3
                                    h1 --> y
                                    h2 --> y
                                    h3 --> y
                                    style Input Layer fill:#f1f5f9,stroke:#94a3b8,color:#1e293b
                                    style Hidden Layer fill:#d1fae5,stroke:#0f766e,color:#1e293b
                                    style Output Layer fill:#fffbeb,stroke:#f59e0b,color:#1e293b

Langkah 1: Matriks Bobot ($W$)

Bayangkan Layer 1 punya 3 neuron, dan Layer 2 punya 4 neuron. Setiap neuron di Layer 1 terhubung ke *setiap* neuron di Layer 2. Ini berarti kita butuh banyak sekali bobot ($w$)! Untuk mempermudah perhitungan (dan agar komputer bisa menghitung cepat), kita menggunakan Matriks.

Z^{[l]} = W^{[l]} \cdot A^{[l-1]} + b^{[l]}

$Z^{[l]}$ = Input terbobot di layer saat ini ($l$).
$W^{[l]}$ = Matriks bobot yang menghubungkan layer sebelumnya ke layer ini.
$A^{[l-1]}$ = Aktivasi (output) dari layer sebelumnya.
$b^{[l]}$ = Vektor bias untuk layer ini.

Contoh Perhitungan: Perkalian Matriks

Misalkan kita punya Input $X$ (2 fitur) dan Hidden Layer dengan 2 neuron.

Input ($X$): $\begin{bmatrix} 2 \\ 3 \end{bmatrix}$

Bobot ($W$): $\begin{bmatrix} 1 & 2 \\ 3 & 4 \end{bmatrix}$

Bias ($b$): $\begin{bmatrix} 1 \\ 1 \end{bmatrix}$

Hitung $Z = W \cdot X + b$:

\begin{bmatrix} 1 & 2 \\ 3 & 4 \end{bmatrix} \cdot \begin{bmatrix} 2 \\ 3 \end{bmatrix} + \begin{bmatrix} 1 \\ 1 \end{bmatrix} = \begin{bmatrix} (1\cdot2) + (2\cdot3) \\ (3\cdot2) + (4\cdot3) \end{bmatrix} + \begin{bmatrix} 1 \\ 1 \end{bmatrix} $$ $$ = \begin{bmatrix} 2+6 \\ 6+12 \end{bmatrix} + \begin{bmatrix} 1 \\ 1 \end{bmatrix} = \begin{bmatrix} 8 \\ 18 \end{bmatrix} + \begin{bmatrix} 1 \\ 1 \end{bmatrix} = \begin{bmatrix} 9 \\ 19 \end{bmatrix}

Langkah 2: Menghitung Aktivasi ($A$)

Setelah mendapatkan $Z$, kita masukkan ke fungsi aktivasi (misal: ReLU atau Sigmoid) untuk mendapatkan output layer tersebut ($A$).

A^{[l]} = g(Z^{[l]})

Nilai $A$ ini kemudian menjadi input untuk layer berikutnya ($A^{[l]}$ menjadi $A^{[l-1]}$ bagi layer selanjutnya), dan begitu seterusnya sampai Output Layer.

💻 Contoh Sederhana

Misalkan kita punya jaringan sederhana: [Input (2 neuron)] -> [Hidden (3 neuron)] -> [Output (1 neuron)].

Pseudocode Python (NumPy)

# Input data (misal: 2 fitur)
X = np.array([0.5, 0.1])

# Layer 1 (Hidden)
Z1 = np.dot(W1, X) + b1
A1 = relu(Z1) # Aktivasi ReLU

# Layer 2 (Output)
Z2 = np.dot(W2, A1) + b2
A2 = sigmoid(Z2) # Prediksi akhir (karena ini klasifikasi biner)

y_hat = A2

Hasil akhirnya, y_hat, adalah prediksi kita. Tapi... apakah prediksi ini benar? Bagaimana kita tahu? Kita akan membahasnya di Modul 4: Loss Function.