Jaringan Syaraf Maju Dijelaskan: Tutorial Lengkap

Saat meninjau Algoritma Machine Learning, ada sangat sedikit konsep yang sefondasional Jaringan Syaraf Maju (Feed-Forward Neural Network/FFNN). Jika Anda pernah membangun jaringan saraf pertama Anda, besar kemungkinan itu adalah tipe feed-forward. Mereka dapat ditemui hampir di mana-mana — dari masalah klasifikasi sederhana hingga menopang lapisan dalam arsitektur yang dalam. 

Pertama, izinkan saya menunjukkan di mana Jaringan Syaraf Maju berada dalam gambaran besarnya:

Dalam tutorial ini, saya akan menjelaskan apa sebenarnya Jaringan Syaraf Maju itu, bagaimana perkembangannya, dan mengapa masih relevan hingga kini, serta mengulas contoh dunia nyata.

Apa itu Jaringan Syaraf Maju?

Secara intuitif, cara terbaik mendeskripsikan arsitektur jaringan seperti ini adalah "Data hanya mengalir maju, tanpa loop."

Pada intinya, sebuah FFNN memproses data sehingga mengalir satu arah, dari input ke output. Tidak ada pengulangan kembali, tidak ada rekursi, dan tidak ada siklus (kecuali backpropagation, yang akan kita bahas sebentar lagi). 

Saat pertama kali mempelajarinya, gambaran mental yang paling membantu saya adalah ban berjalan di pabrik. 

Mengapa? 

Karena setiap langkah dalam proses (atau setiap lapisan dalam jaringan) melakukan sesuatu yang sederhana pada input sebelum meneruskannya ke langkah berikutnya.

Begini cara kerjanya:

1. Input masuk ke lapisan pertama (lapisan input).
2. Input ditransformasikan oleh bobot dan bias lalu dilewatkan melalui fungsi aktivasi.
3. Proses ini berlanjut melalui satu atau lebih lapisan tersembunyi.
4. Terakhir, lapisan output membuat prediksi.

Sebelum saya menunjukkan seperti apa arsitektur jaringan tersebut, saya ingin meluruskan salah kaprah yang umum:

"Jaringan Syaraf Maju sama dengan MLP."

Untuk meluruskan salah kaprah ini, kita perlu menelusuri sejarah awal Deep Learning. 

Sejarah awal deep learning

Perceptron: Kita mulai dengan Perceptron, yang ditemukan pada 1950-an oleh Frank Rosenblatt. Ini adalah pengklasifikasi biner satu lapis, dan meskipun tidak bisa menyelesaikan semuanya (seperti masalah XOR), ia meletakkan dasar bagi jaringan saraf.

Secara sederhana, perceptron bekerja seperti ini:

1. Input: Setiap input (seperti x_1, x_2, dll.) memiliki bobot terkait (w_1, w_2, dll.).
2. Jumlah berbobot: Input dikalikan dengan bobotnya dan dijumlahkan bersama, beserta sebuah bias: z = w1*x1 + w2*x2+ ... + b.
3. Aktivasi: Hasilnya dilewatkan melalui fungsi langkah (aktivasi). Jika nilainya di atas ambang, perceptron menghasilkan 1; jika tidak, menghasilkan 0.

Intinya, perceptron adalah pengklasifikasi linear, artinya hanya dapat menggambar batas keputusan garis lurus (atau hiperbidang). Di satu sisi, Perceptron memiliki kelebihan seperti sangat sederhana dan elegan (karena terinspirasi biologi) serta murah secara komputasi. Namun di sisi lain, ia tidak dapat menyelesaikan masalah yang tidak dapat dipisahkan secara linear, seperti masalah XOR. 

Multi-Layer Perceptrons (MLP): Melompat beberapa dekade, pada 1980-an, para peneliti menyadari bahwa jika Anda menumpuk beberapa perceptron dan menambahkan fungsi aktivasi non-linear, Anda dapat menyelesaikan masalah yang lebih kompleks. Struktur ini dikenal sebagai Multi-Layer Perceptron.

Begini cara kerjanya: 

1. Lapisan Input: Menerima fitur mentah dari dataset.
2. Lapisan Tersembunyi: Satu atau lebih lapisan perceptron yang menerapkan transformasi. Setiap neuron melakukan z = w*x + b dan melewatkannya melalui fungsi aktivasi non-linear seperti sigmoid, tanh, dll. 
3. Lapisan Output: Lapisan terakhir menghasilkan prediksi akhir (misalnya, probabilitas kelas, nilai regresi).

Penambahan aktivasi non-linear ini sangat krusial. Tanpa aktivasi, menumpuk lapisan hanya akan mereduksi menjadi satu transformasi linear. Dengan aktivasi, MLP dapat merepresentasikan fungsi non-linear yang sangat kompleks.

Ini mengarah pada salah satu hasil paling terkenal dalam teori jaringan saraf: Teorema Aproksimasi Universal. 

Teorema ini menyatakan bahwa jaringan saraf dengan hanya satu lapisan tersembunyi — selama memiliki fungsi aktivasi non-linear dan jumlah neuron yang cukup — dapat mendekati fungsi kontinu apa pun pada domain terbatas. 

Era Deep Learning: Memasuki 2010-an, kita memasuki era deep learning. Dengan GPU dan big data, FFNN berkembang menjadi arsitektur yang lebih dalam dan lebih kuat, menjadi fondasi bagi CNN, RNN, dan Transformer, yang pada dasarnya merupakan tempat kita berada sekarang.

Jadi, kembali ke salah kaprah awal, kini kita tahu:

• Feed-Forward Neural Network (FFNN). Kategori umum untuk jaringan saraf apa pun di mana data mengalir satu arah (input → tersembunyi → output), tanpa loop.
• Multi-Layer Perceptron (MLP). Jenis FFNN yang secara khusus memiliki setidaknya satu lapisan tersembunyi dari perceptron (neuron dengan bobot, bias, dan aktivasi).

Dengan kata lain, semua MLP adalah FFNN, tetapi tidak semua FFNN adalah MLP. Ini adalah poin yang sangat penting untuk diingat. Salah kaprah umum lainnya adalah tentang perceptron satu lapis (yaitu, hanya input ke output).

Perceptron satu lapis adalah FFNN, tetapi bukan MLP! Baru setelah kita menambahkan lapisan tersembunyi, ia menjadi MLP.

Pembedaan ini penting karena MLP mampu melakukan aproksimasi fungsi universal (dengan unit tersembunyi yang cukup dan fungsi aktivasi non-linear), sedangkan perceptron satu lapis yang sederhana terbatas dalam apa yang bisa direpresentasikan.

Arsitektur Jaringan Syaraf Maju

Dari bagian sebelumnya, kita telah banyak belajar tentang FFNN, namun sederhananya mereka dapat dianggap sebagai tumpukan transformasi sederhana. Ada banyak komponen berbeda yang membentuk sebuah FFNN, jadi mari kita telusuri lebih detail, khususnya struktur MLP. 

Dalam MLP, ada tiga jenis Lapisan: Input, Tersembunyi, dan Output, yang telah kita singgung sebelumnya. 

Perhatikan diagram di atas sambil kita jelajahi lapisan-lapisan ini lebih jauh. 

Lapisan input

Ini adalah titik masuk jaringan.  Setiap neuron di sini merepresentasikan satu fitur dari dataset. Penting, lapisan input tidak melakukan perhitungan apa pun — ia hanya meneruskan angka mentah ke depan. Dalam contoh kita, karena hanya ada dua neuron di Lapisan Input, ini berarti dataset kita berisi dua fitur (atau kita hanya mempertimbangkan dua fitur dari dataset kita). 

Lapisan tersembunyi

Inilah tempat perhitungan yang sesungguhnya terjadi. Kita memiliki dua lapisan tersembunyi, masing-masing berisi empat neuron. Setiap neuron di lapisan tersembunyi melakukan tiga hal ini:

1. Jumlah berbobot: Setiap input dikalikan dengan bobot dan kemudian semuanya dijumlahkan. 
2. Bias: Sebuah bias konstan ditambahkan untuk memberi keleluasaan dalam menggeser fungsi.
3. Fungsi aktivasi: Fungsi pereduksi non-linear seperti ReLU, tanh, atau sigmoid diterapkan. Langkah inilah yang memungkinkan jaringan mempelajari pola yang kompleks dan non-linear.

Lapisan output

Lapisan output menghasilkan prediksi akhir, dan desainnya bergantung pada masalah yang ingin kita selesaikan:

• Regresi seperti memprediksi harga rumah. Dalam kasus ini, lapisan output berisi satu neuron tanpa aktivasi (linear). Mengapa linear? Karena kita tidak ingin mereduksi nilai; harga rumah bisa berupa bilangan riil apa pun.
• Klasifikasi biner (keputusan ya/tidak), seperti memprediksi apakah sebuah email adalah spam atau bukan. Di sini, lapisan output adalah satu neuron dengan aktivasi sigmoid. Mengapa sigmoid? Karena kita ingin jaringan menghasilkan nilai antara 0 dan 1 (karena kita memprediksi probabilitas). 
• Klasifikasi multikelas (3 kelas atau lebih) — seperti mengklasifikasikan gambar menjadi berbagai hewan. Lapisan output akan memiliki satu neuron per kelas, dengan aktivasi softmax. Mengapa softmax? Karena ia mengubah skor mentah menjadi probabilitas yang jumlahnya 1 (misalnya, 70% kucing, 20% anjing, 10% kuda).

Sebagai referensi, berikut adalah diagram yang menunjukkan sembilan bentuk fungsi aktivasi umum yang digunakan dalam FFNN dan Deep Learning secara umum. 

Sebelum melanjutkan, penting juga untuk dicatat bahwa setiap neuron pada satu lapisan terhubung ke setiap neuron pada lapisan berikutnya (itulah mengapa disebut fully-connected). 

Kembali ke contoh kita, kita memiliki:

Params = (2⋅4+4)+(4⋅4+4)+(4⋅1+1)=12+20+5=37

Setiap kurung menunjukkan jumlah parameter antara lapisan berturutan, di mana jumlah neuron lapisan sebelumnya dan saat ini dikalikan lalu jumlah bias (yaitu jumlah neuron di lapisan saat ini) ditambahkan. Cobalah lakukan perhitungan ini pada contoh jaringan saraf lain juga untuk latihan!

Melatih Jaringan Syaraf Maju

Dalam Deep Learning, pelatihan terbagi menjadi dua langkah: forward pass/propagation dan backpropagation. Secara sederhana, Forward propagation memberi kita prediksi, sedangkan Backpropagation adalah cara kita belajar dari kesalahan. 

Forward propagation 

Semua yang telah kita bahas sejauh ini berada di bawah forward propagation. Singkatnya, saat data bergerak melalui MLP, setiap lapisan melakukan dua langkah yang sama, yang secara matematis dapat ditulis dengan persamaan ini:

Di sini z adalah output setelah mengalikan output lapisan sebelumnya dengan bobot lapisan saat ini dan menjumlahkan bias, juga dikenal sebagai Langkah Linear. 

Secara alami, jika lapisan sebelumnya adalah lapisan input, maka ini akan berupa x alih-alih al-1. Langkah berikutnya adalah Langkah Aktivasi. Untuk membuatnya lebih ketat secara matematis, kita dapat menuliskan Bobot dan Bias sebagai berikut:

Backpropagation

Setelah kita menerima output, bagaimana kita memberi tahu jaringan apakah itu benar atau tidak? Atau lebih baik lagi, bagaimana cara membuat jaringan menjadi lebih baik pada tugas yang diberikan. Di sinilah Backpropagation berperan. Kita dapat menganggapnya sebagai sistem umpan balik bagi jaringan, yang memberi tahu model seberapa melesetnya dan bagaimana menyesuaikan diri. Kita dapat merincinya seperti ini:

1. Bandingkan prediksi: Lihat apa yang diprediksi model (ŷ) dan berapa jawaban sebenarnya (y).
2. Hitung galat: Kita menggunakan fungsi loss untuk mengukur seberapa salah prediksinya, seperti MSE.
3. Backpropagate (melalui aturan rantai): Gradien terhadap semua bias dan bobot dihitung. ∂L/∂w,∂L/∂b .
4. Pembaruan Gradient Descent: Parameter masing-masing diperbarui untuk mengurangi loss menggunakan aturan berikut:

Di sini, η adalah laju pembelajaran (learning rate), sebuah parameter yang dapat diubah untuk menentukan seberapa besar perubahan parameter pada setiap pembaruan. 

Selama banyak putaran proses ini, jaringan secara bertahap belajar dan meningkat dalam tugasnya.

Agar lebih jelas, mari kita lalui contoh kecil bersama. Misalkan kita memiliki:

• Input: x = 2
• Target output: y=4
• Prediksi: ŷ = 3

Sekarang mari kita jalani langkah-langkahnya. 

1. Bandingkan prediksi: ŷ =3, y = 4
2. Galat: Untuk contoh ini, kita akan menggunakan MSE: L=(y−y^​)2=(4−3)2=1
3. Backpropagate: Jaringan menghitung seberapa besar setiap bobot dan bias menyebabkan galat ini menggunakan turunan, lalu kita memperbarui masing-masing parameter menggunakan langkah pembaruan gradient descent. 

Ngoding Jaringan Syaraf Maju di PyTorch

Kita telah membahas matematika yang relevan untuk membangun FFNN (khususnya MLP). Untuk melangkah lebih jauh, kita akan mengodekannya di PyTorch. 

Multilayer perceptron

# Imports we will be needing
import torch
import torch.nn as nn
import torch.optim as optim

X,y = dataset # Here will be our dataset 

# We have created a MLP here using nn.Sequential()
model = nn.Sequential(
    nn.Linear(2, 4),  # input layer → hidden layer (2 → 4)
    nn.ReLU(),        # relu activation function
    nn.Linear(4, 4), # hidden layer 1 → hidden layer 2 (4 → 4)
    nn.ReLU(), 
    nn.Linear(4, 1)   # hidden layer 2 → output (4 → 1)
)


criterion = nn.MSELoss()         # regression loss, i.e our loss function
optimizer = optim.SGD(model.parameters(), lr=0.1) # Optimizer using the Stochastic Gradient Descent

# Training Loop
EPOCHS = 200 # Number of epochs we will be training for
for epoch in range(EPOCHS):
    # Forward pass
    outputs = model(X)
    loss = criterion(outputs, y)

    # Backward pass
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()Didukung oleh

Pada titik ini, Anda seharusnya dapat memetakan kode PyTorch ke langkah-langkah matematis yang kita bahas sebelumnya. Namun, Anda mungkin memiliki pertanyaan tentang Epoch.

Sebuah epoch adalah satu putaran lengkap seluruh dataset pelatihan melalui jaringan saraf. Misalnya, anggap kita memiliki 1.000 data pelatihan dan ukuran batch = 100, maka setelah jaringan melihat semua 1.000 gambar (yaitu 10 batch), itulah 1 epoch. Pelatihan biasanya memerlukan banyak epoch agar model terus meningkatkan bobotnya.

Convolutional neural network

Saya juga ingin menyinggung FFNN lain secara singkat, salah satu yang sangat terkenal adalah Convolutional Neural Network (CNN). 

Meskipun CNN juga memuat MLP di bagian akhir, pada awalnya ia berisi lapisan khusus yang disebut Lapisan Konvolusi dan Lapisan Pooling. Membahas Lapisan Konvolusi terlebih dahulu, ini penting karena hanya melihat area lokal kecil dari input pada satu waktu menggunakan sebuah filter (atau kernel).

Ini sangat berguna saat mengklasifikasikan gambar karena:

• Lapisan padat (dense) akan memperlakukan setiap piksel secara terpisah, mengabaikan struktur spasial.
• Sebaliknya, lapisan konvolusi dapat mendeteksi tepi, tekstur, dan bentuk pada petak kecil — lalu menggabungkannya menjadi pola yang lebih kompleks saat kita melangkah lebih dalam.

Bersamaan dengan lapisan konvolusi, CNN juga menggunakan lapisan pooling.

Perlu dicatat bahwa lapisan Pooling tidak mempelajari parameter, melainkan menurunkan sampel (downsample) peta fitur agar menjadi lebih kecil dan lebih mudah ditangani.

• Yang paling umum adalah Max Pooling, yang mengambil nilai maksimum dari setiap area kecil (misalnya, jendela 2×2).
• Pooling membuat jaringan lebih efisien dan juga memberikan invarian translasi (jaringan lebih peduli apakah suatu fitur ada, bukan tepat di mana posisinya).

Kita dapat menulis kode CNN menggunakan PyTorch seperti ini:

class SimpleCNN(nn.Module): # Define our model as a class
    def __init__(self):
        super().__init__()
        self.conv = nn.Conv2d(1, 8, 3)     # 1→8 channels, 3x3 kernel
        self.pool = nn.MaxPool2d(2, 2)
        self.fc   = nn.Linear(8*13*13, 10) # flatten → 10 classes

    def forward(self, x): # Forward propagation function 
        x = self.pool(torch.relu(self.conv(x)))
        x = x.view(x.size(0), -1)          # flatten
        return self.fc(x)Didukung oleh

Pada kode di atas, kita membuat CNN yang sangat sederhana, terdiri dari satu lapisan konvolusi, satu lapisan pooling, dan satu lapisan linear. 

Contoh lain jaringan syaraf maju

Kita telah membahas dua contoh FFNN yang sangat terkenal dan penting, namun ada banyak contoh lain yang revolusioner di domainnya masing-masing, seperti:

1. Transformer: setiap blok berisi bagian MLP/FFN (setelah self-attention, "lapisan feed-forward" melebarkan + mengecilkan dimensi).
2. Vision Transformers (ViT): menerapkan blok transformer (dengan FFNN di dalamnya) pada potongan gambar.
3. Autoencoder (yang dasar): encoder + decoder keduanya dibangun dari FFNN.
4. Sistem rekomendasi (berbasis MLP): misalnya Wide & Deep untuk pemeringkatan dan prediksi.

Penutup

Semoga Anda menyadari betapa pentingnya FFNN dalam bidang AI. Tanpa ini, lanskap modern deep learning tidak akan ada.

Untuk melanjutkan, saya sangat menyarankan menguasai backpropagation dan mendalami fungsi aktivasi. Karena ini adalah fondasi Deep Learning, saya juga merekomendasikan mempelajari Deep Learning dengan PyTorch.