Belajar AI - Deep Learning & Neural Network Dasar

#Pendahuluan

Setelah di episode 4 kalian memahami pipeline ML klasik — split, fit, predict, evaluate — episode ini adalah jembatan ke deep learning: ML yang memakai neural network bertingkat. Ini adalah teknologi di balik GPT, Claude, Gemini, dan semua model besar yang kita pakai sehari-hari.

Mengapa episode ini penting? Karena semua istilah keren di dunia AI modern — "parameter", "training loop", "gradient", "overfitting" — berakar dari mekanika neural network yang akan kita bedah sekarang. Memahami satu neuron dan cara ia belajar berarti memahami bagaimana setiap model AI di 2026 bekerja.

#Neural Network: Neuron Buatan

#Satu Neuron

Neuron buatan meniru versi sederhana dari neuron biologis: menerima banyak input, menjumlahkannya dengan bobot, lalu memutuskan "seberapa aktif" ia lewat fungsi aktivasi.

Secara matematis: output = activation(sum(wi * xi) + bias). Bobot (w) adalah hal yang dipelajari selama training — ia menentukan seberapa penting tiap input.

#Fungsi Aktivasi

Fungsi aktivasi menambahkan non-linearitas — tanpanya, berapa pun lapisannya, seluruh jaringan hanya menjadi regresi linear. Tiga yang paling umum:

import torch.nn as nn
 
relu = nn.ReLU()
sigmoid = nn.Sigmoid()
softmax = nn.Softmax(dim=1)

#Layer dan Arsitektur

Neural network adalah tumpukan layer: input layer (menerima fitur), hidden layers (mengekstrak pola), dan output layer (menghasilkan prediksi). "Deep" berarti punya banyak hidden layer — inilah yang memungkinkan model belajar hierarki: layer pertama melihat tepi gambar, layer tengah melihat bentuk, layer akhir melihat objek.

#Cara Neural Network Belajar

#Forward Pass

Data mengalir dari input ke output: setiap neuron menghitung sum(wi * xi) + bias, lalu mengaktifkannya. Hasil akhir dibandingkan dengan label sebenarnya, menghasilkan loss — seberapa jauh prediksi dari kebenaran.

#Backpropagation dan Gradient Descent

Inilah jantung deep learning. Backpropagation menghitung, mundur dari output, seberapa besar setiap bobot berkontribusi pada error. Lalu gradient descent memperbarui bobot berlawanan arah gradient — seperti menuruni bukit dengan langkah kecil sampai mencapai lembah (loss minimum).

optimizer.zero_grad()
outputs = model(images)          # forward
loss = criterion(outputs, labels)
loss.backward()                  # backprop: hitung gradient
optimizer.step()                 # update bobot

Empat baris ini — zero_grad, forward, backward, step — adalah loop training yang sama untuk hampir semua model modern, dari MNIST kecil sampai LLM besar. Biasakan melihatnya sebagai satu siklus.

#Learning Rate

Learning rate menentukan besar langkah gradient descent. Terlalu besar: melompat melewati lembah (loss berosilasi). Terlalu kecil: merangkak sangat lambat (butuh ribuan epoch). Ini hyperparameter pertama yang perlu kalian perhatikan saat model tidak konvergen.

#Praktik: NN Sederhana untuk MNIST

MNIST adalah dataset ikonik: 70.000 gambar digit tulisan tangan (28x28 pixel). Tugasnya: mengenali digit 0-9. Ini adalah "hello world" deep learning.

#1. Install PyTorch

pip install torch torchvision

#2. Siapkan Data dan Definisikan Model

import torch
import torch.nn as nn
import torch.nn.functional as F
from torchvision import datasets, transforms
 
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.1307,), (0.3081,))
])
 
train = datasets.MNIST("./data", train=True, download=True, transform=transform)
loader = torch.utils.data.DataLoader(train, batch_size=64, shuffle=True)
 
class Net(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(28 * 28, 128)   # flatten -> hidden
        self.fc2 = nn.Linear(128, 10)        # hidden  -> output (10 digit)
 
    def forward(self, x):
        x = x.view(-1, 28 * 28)
        x = F.relu(self.fc1(x))
        return self.fc2(x)

Perhatikan strukturnya: 784 input → 128 hidden → 10 output. Jaringan ini masih sangat dangkal — cukup untuk MNIST, dan cukup untuk memahami konsep.

#3. Loop Training

model = Net()
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
 
for epoch in range(3):
    for images, labels in loader:
        optimizer.zero_grad()
        outputs = model(images)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
    print(f"epoch {epoch + 1}: loss = {loss.item():.4f}")

Setelah 3 epoch, loss turun dari angka tinggi menuju sekitar 0.1-0.2 — dan model seharusnya akurat di atas 95% pada data uji.

#Overfitting: Musuh Utama Deep Learning

Overfitting terjadi ketika model menghafal data latih alih-alih belajar pola umum. Gejalanya klasik: akurasi train sangat tinggi, akurasi test jauh tertinggal. Ini karena model punya kapasitas (parameter) terlalu besar relatif terhadap jumlah data.

Strategi mitigasi standar:

• Early stopping: berhenti saat loss validasi mulai naik.
• Dropout: menonaktifkan neuron acak saat training agar model tidak bergantung pada satu neuron.
• Data augmentation: memperbanyak variasi data latih.
• Regularization (L2): menghukum bobot yang terlalu besar.

class NetWithDropout(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(28 * 28, 128)
        self.fc2 = nn.Linear(128, 10)
        self.dropout = nn.Dropout(0.5)
 
    def forward(self, x):
        x = x.view(-1, 28 * 28)
        x = F.relu(self.fc1(x))
        x = self.dropout(x)
        return self.fc2(x)

#Penutup

Inti yang harus dibawa pulang:

• Neuron buatan menghitung sum(wi * xi) + bias lalu memasukkannya ke fungsi aktivasi; bobot adalah yang dipelajari.
• Forward pass menghasilkan prediksi, backpropagation menghitung gradient, gradient descent memperbarui bobot — empat baris loop training.
• "Deep" berarti banyak layer; layer mengekstrak hierarki pola.
• Overfitting adalah gap train-test; lawan dengan early stopping, dropout, augmentation, dan regularisasi.

Di episode 6 selanjutnya kita akan berkenalan dengan dua cabang aplikasi AI yang paling terlihat: NLP & Computer Vision — tokenization, embeddings, dan aplikasi NLP seperti sentiment & summarization, plus klasifikasi gambar, object detection, serta CNN dan vision transformer. Sampai jumpa di episode 6!