Belajar Deep Learning - Transformer: Arsitektur & Attention

#Pendahuluan

Di episode 11 kalian melihat LSTM yang memproses sequence berurutan. Masalah utamanya ada dua: paralelisasi sulit (setiap langkah menunggu langkah sebelumnya) dan konteks jauh yang rapuh. Pada 2017, makalah "Attention is All You Need" menjawab keduanya dengan ide yang tampak sederhana: buang recurrency, andalkan attention saja.

Transformer adalah arsitektur yang mendasari hampir semua AI modern — GPT, BERT, LLaMA, CLIP, dan seluruh model multimodal. Episode ini adalah salah satu yang paling penting di series ini: pahami mekanikanya dengan baik, dan semua episode berikutnya (LLM, fine-tuning, inference) menjadi penerapan dari satu pola.

#Self-Attention: Inti Transformer

#Ide Dasar

Untuk setiap token dalam sequence, self-attention menghitung seberapa relevan token lain terhadap token ini, lalu mengumpulkan informasi dari token yang relevan. Kata "bank" dalam "tepi bank" vs "bank data" mendapat konteks berbeda justru karena attention.

Setiap token diproyeksikan menjadi tiga vektor:

• Query (Q): apa yang saya cari?
• Key (K): apa yang saya tawarkan?
• Value (V): informasi yang saya bawa.

Skor perhatian dihitung sebagai dot product antara query token i dan semua key, dinormalisasi dengan softmax, lalu dipakai sebagai bobot penjumlahan value:

Attention(Q, K, V) = softmax(Q * K^T / sqrt(d_k)) * V

Pembagi sqrt(d_k) mencegah dot product membesar seiring dimensi, menjaga gradien tetap stabil.

#Paralelisasi

Perbedaan krusial dari RNN: semua pasangan token dihitung sekaligus dalam satu operasi matriks. Tidak ada ketergantungan berurutan — itulah yang memungkinkan training di ribuan GPU. Konteks juga menjadi global: setiap token bisa langsung melihat semua token lain, bukan hanya yang dekat.

#Multi-Head Attention

Satu set Q/K/V hanya menangkap satu "tipe hubungan". Multi-head menjalankan beberapa set proyeksi paralel, masing-masing belajar jenis relasi berbeda (sintaksis, referensi, semantik), lalu hasilnya digabung. Setiap head adalah lensa berbeda untuk melihat sequence yang sama:

MultiHead = Concat(head1, head2, ..., head8) * W_o

#Positional Encoding

Attention tidak memiliki rasa urutan — "A lalu B" sama dengan "B lalu A". Transformer menambahkan informasi posisi lewat positional encoding yang dijumlahkan ke embedding sebelum masuk attention. Makalah asli memakai pola sinus-kosinus; model modern sering memakai rotary positional encoding (RoPE) yang lebih baik untuk generalisasi panjang sequence.

#Blok Transformer: Residual + Normalization

Satu blok encoder terdiri dari: multi-head attention → add & norm (residual + LayerNorm) → feed-forward (dua layer Linear dengan GELU di tengah) → add & norm. Pola residual dari episode 7 kembali: setiap sublayer menghasilkan x + sublayer(x), menjamin aliran gradien.

Satu blok transformer

import torch.nn as nn
 
class TransformerBlock(nn.Module):
    def __init__(self, d_model=128, n_heads=4, ff=512):
        super().__init__()
        self.attn = nn.MultiheadAttention(d_model, n_heads, batch_first=True)
        self.norm1 = nn.LayerNorm(d_model)
        self.ff = nn.Sequential(nn.Linear(d_model, ff), nn.GELU(), nn.Linear(ff, d_model))
        self.norm2 = nn.LayerNorm(d_model)
 
    def forward(self, x):
        h = x + self.attn(x, x, x)[0]   # residual self-attention
        h = self.norm1(h)
        return self.norm2(h + self.ff(h))

#Encoder-Decoder dan Keturunannya

Arsitektur lengkap punya dua sisi: encoder membaca seluruh sequence (kapan saja bisa melihat kiri dan kanan — bidirectional), decoder menghasilkan output satu token demi satu token dengan masked self-attention (hanya boleh melihat token sebelumnya, bukan masa depan).

Keluarga model modern adalah variasi dari pola ini:

#Praktik: Transformer Kecil

Untuk sequence modeling sederhana, satu encoder di atas sudah cukup. Tambahkan input embedding dan head output:

Transformer kecil

class TinyTransformer(nn.Module):
    def __init__(self, vocab, d_model=128, n_heads=4, n_blocks=2, max_len=256):
        super().__init__()
        self.embed = nn.Embedding(vocab, d_model)
        self.pos = nn.Embedding(max_len, d_model)
        self.blocks = nn.Sequential(*[
            TransformerBlock(d_model, n_heads) for _ in range(n_blocks)
        ])
        self.head = nn.Linear(d_model, vocab)
 
    def forward(self, tokens):
        positions = torch.arange(tokens.size(1), device=tokens.device)
        x = self.embed(tokens) + self.pos(positions)
        return self.head(self.blocks(x))

Ini "mini GPT": embedding + posisi + N blok transformer + head vocab. Latih dengan CrossEntropyLoss untuk memprediksi token berikutnya, dan kalian punya model generasi teks sendiri — konsep yang sama dengan model dengan ratusan miliar parameter, hanya skalanya beda.

#Common Pitfalls

• Masking lupa: decoder harus memakai causal mask, jika tidak ia bisa "menyontek" dengan melihat token masa depan. PyTorch nn.Transformer default memakai mask yang benar jika is_causal=True.
• Skala attention salah: lupa membagi sqrt(d_k) membuat softmax jenuh dan gradien mati.
• Posisi melampaui max_len: posisi di luar max_len error. Untuk input panjang, gunakan RoPE atau naikkan max_len.
• Kurang normalization: LayerNorm dan residual adalah alasan transformer bisa sedalam ini — jangan dibuang saat bereksperimen.

#Penutup

Pada episode 12 ini, kalian telah membedah jantung arsitektur modern.

Inti yang harus dibawa pulang:

• Self-attention menghitung relevansi antar token secara paralel dengan Q/K/V.
• Multi-head membiarkan beberapa jenis relasi dipelajari sekaligus.
• Positional encoding menambahkan informasi urutan; RoPE adalah versi modern.
• Blok = attention + residual/norm + feed-forward; encoder/decoder untuk tugas berbeda.
• GPT/LLaMA = decoder-only; BERT = encoder-only; T5 = encoder-decoder.

Di episode 13 selanjutnya kita akan mempercepat training: GPU & distributed training — mixed precision AMP/BF16, optimasi memori, gradient accumulation, lalu DistributedDataParallel (DDP) dan FSDP untuk training multi-GPU. Sampai jumpa di episode 13!