Mengapa Koneksi Lompat Penting

Pola Residual

Setiap sublayer membungkus perhitungannya dalam koneksi residual. Output menambahkan kembali input:

x = x + Attention(LayerNorm(x))     # sublayer attention


[BLOCK_TYPE SECTION/STEP]
__BLOCK_N__
<translated content>
x = x + MLP(LayerNorm(x))           # Sub-layer MLP

Di dalam setiap sub-layer, fungsi Attention(...) atau MLP(...) menghasilkan delta. Blok tidak mengganti input; ia menambahkan koreksi yang dipelajari.

Mengapa Ini Penting

Tiga alasan koneksi residual mendominasi arsitektur dalam:

1. Aliran gradien. Selama backpropagation, penambahan memberikan jalur langsung bagi gradien dari output kembali ke input, melewati sublayer. Tumpukan 12 lapis tanpa residual akan kehilangan sinyal gradien jauh sebelum mencapai embeddings; dengan residual, magnitudo gradien tetap dapat digunakan melalui ratusan lapis.

2. Inisialisasi identitas. Pada inisialisasi, bobot sublayer menghasilkan output kecil. Koneksi residual berarti lapis N awalnya melewatkan hampir tidak berubah. Pelatihan mempelajari delta secara progresif dari titik awal yang berfungsi.

3. Pembelajaran komposisional. Setiap blok mempelajari penyempurnaan, bukan penggantian. Lapis 1 mungkin menambahkan informasi posisional. Lapis 2 mungkin menambahkan struktur sintaksis. Lapis 7 mungkin menambahkan hubungan semantik. Aliran residual terakumulasi.

Normalisasi Lapis

Sebelum setiap sublayer, LayerNorm menskalakan ulang representasi setiap token ke rata-rata nol & varians satu, kemudian menerapkan gain & bias per-fitur yang dipelajari:

y = gamma * (x - mean(x)) / sqrt(var(x) + epsilon) + beta

Rata-rata & varians dihitung melintasi dimensi d_model, secara terpisah untuk setiap token. Dua vektor yang dipelajari (gamma, beta, masing-masing bentuk [d_model]) mengembalikan skala ekspresif. Normalisasi menjaga aktivasi dalam rentang yang stabil secara numerik; tanpa itu, ketidakstabilan pelatihan kecil akan membesar menjadi gradien NaN.

Pre-Norm vs Post-Norm

Pilihan Halus Namun Kritis

Dua cara untuk menyambungkan layer norm ke dalam sublayer residual:

Post-norm (makalah asli 2017):

x = LayerNorm(x + Attention(x))

Layer norm berada setelah penjumlahan residual. Stream residual itu sendiri dinormalisasi di setiap lapisan.

Pre-norm (standar modern, digunakan di ANDREA):

x = x + Attention(LayerNorm(x))

Layer norm berada sebelum sublayer, di dalam cabang residual. Aliran residual tetap tidak dinormalisasi; hanya input ke sublayer yang diskalakan ulang.

Mengapa Pre-Norm Menang

Post-norm melatih dengan buruk tanpa pemanasan LR & penyetelan hiperparameter yang hati-hati. Gradien meledak di lapisan awal karena setiap layer norm mengacak keadaan akumulasi aliran residual. Makalah asli 2017 menggunakan post-norm dengan penyetelan ekstensif; pekerjaan selanjutnya (GPT-2, LLaMA, ANDREA) menstandardisasi pada pre-norm.

Pelatihan pre-norm stabil. Residual stream terakumulasi bersih di seluruh lapisan; hanya input sublapisan yang dinormalisasi untuk stabilitas numerik. Transformer modern secara default menggunakan pre-norm, & ANDREA mewarisi pilihan tersebut.

Persamaan Blok Akhir

Menggabungkan residual, layer norm pada posisi pre-norm, & kedua sublapisan memberikan blok lengkap ANDREA:

```python
def block_forward(x):
```
x = x + Attention(LayerNorm(x))   # sublayer attention
x = x + MLP(LayerNorm(x))         # sublayer MLP
return x

Dua sublayer, dua penambahan residual, dua layer norm (catatan: setiap sublayer memiliki layer norm sendiri; ANDREA-120M memiliki 24 layer norm di seluruh 12 blok ditambah satu di output akhir, jadi total 25). Ulangi 12 kali. Itulah batang utama ANDREA-120M.

Mengapa Pre-Norm Menstabilkan Pelatihan

Dua Lapisan Linear, Satu Aktivasi

Tiga Operasi

Sublayer MLP adalah perceptron dua lapis dengan aktivasi non-linear di antara lapisan-lapisan tersebut:

def mlp_forward(x):
h = x · W_1 + b_1        # perluas: d_model → mlp_dim
h = GELU(h)              # aktivasi non-linear
y = h · W_2 + b_2        # kontrak: mlp_dim → d_model
return y

Tiga operasi. Dua linear, satu non-linear. Linear pertama memperluas lebar; yang kedua menyusut kembali.

Rasio Ekspansi 4×

Transformer modern menetapkan mlp_dim = 4 × d_model. ANDREA-120M:

d_model = 768
mlp_dim = 4 × 768 = 3072
Bentuk W_1 = [768, 3072]      # ~2.36M parameter
Bentuk W_2 = [3072, 768]      # ~2.36M parameter
Parameter MLP per blok = 4.72M (mengabaikan bias)

Dua MLP berada di antara setiap pasangan sublayer perhatian (satu per blok). Dua belas blok × 4.72M ≈ 56.6M parameter MLP total di ANDREA-120M, kira-kira setengah dari semua parameter.

Mengapa 4×

Rasio 4× muncul secara empiris. Rasio yang lebih kecil mengurangi kapasitas model. Rasio yang lebih besar menghasilkan pengembalian yang semakin menurun per parameter yang digunakan. Selama dekade pencarian arsitektur, 4× tetap terbukti; ia muncul di GPT, BERT, T5, LLaMA, & ANDREA.

Pekerjaan terbaru (PaLM, Chinchilla) menemukan bahwa mekanisme gating (SwiGLU) dapat menggunakan ekspansi 8/3× dengan kapasitas yang sebanding pada biaya yang lebih rendah; ANDREA tetap menggunakan GELU klasik + 4× untuk kesederhanaan.

GELU: Aktivasi yang Halus

Apa yang Dihitung GELU

GELU (Gaussian Error Linear Unit) adalah aktivasi standar antara lapisan MLP di transformer modern. Rumusnya:

GELU(x) = x · Φ(x)

Φ(x) adalah fungsi distribusi kumulatif dari distribusi normal standar: probabilitas bahwa variabel acak Gaussian standar berada pada atau di bawah x. Dihitung secara numerik:

Φ(x) ≈ 0.5 × (1 + tanh(sqrt(2/π) × (x + 0.044715 × x³)))

Perilaku Berdasarkan Wilayah

- Untuk x positif besar: Φ(x) ≈ 1, sehingga GELU(x) ≈ x. Mirip ReLU.

- Untuk x negatif besar: Φ(x) ≈ 0, sehingga GELU(x) ≈ 0. Mirip ReLU.

- Dekat x = 0: Φ(x) ≈ 0.5, sehingga GELU(0) = 0 secara tepat. Transisi halus melalui titik asal.

Berbeda dengan ReLU, GELU membiarkan beberapa input negatif lolos, ditimbang oleh Φ(x). Input negatif kecil masih berkontribusi pada output negatif kecil, hanya sedikit lebih kecil daripada input penuh.

Mengapa GELU Lebih Unggul daripada ReLU

Secara empiris, transformer yang dilatih dengan GELU mencapai loss lebih rendah daripada transformer yang dilatih dengan ReLU pada jumlah parameter yang sama. Kelancaran di sekitar nol sangat penting: pemotongan keras ReLU di nol menghasilkan diskontinuitas gradien; kurva halus GELU memberikan gradien yang lebih bersih untuk backpropagation.

Mesin pelatihan ANDREA microgpt_cuda.cu menyertakan kernel CUDA GELU yang ditulis tangan. Kernel tersebut menggunakan aproksimasi tanh di atas; GPU modern menyertakan tanh sebagai operasi single-instruction.

Menghitung Parameter MLP

Dua Belas Blok Membentuk ANDREA-120M

Dari Blok ke Model

Forward pass lengkap ANDREA-120M:

def model_forward(token_ids):
x = token_embed(token_ids) + position_embed(positions)
for block_idx in range(n_layer):       # 12 blok
x = block_forward(x)               # attention + MLP w/ residuals
x = LayerNorm(x)                       # normalisasi akhir
logits = x · token_embed.T             # bobot terikat untuk proyeksi output
return logits

Enam baris. Bagian utama berada di dalam block_forward, yang dipanggil dua belas kali. Embeddings memulai pipeline; tied unembedding (matriks yang sama digunakan untuk lookup input, ditranspos untuk proyeksi output) mengakhiri.

Kedalaman Sebagai Komposisi

Setiap blok membaca residual stream, menghitung delta, & menambahkannya kembali. Setelah dua belas kali pass, stream berisi akumulasi kontribusi dari setiap blok. Secara internal, lapisan cenderung berspesialisasi:

- Lapisan awal (1-3): pola sintaksis, struktur posisional

- Lapisan tengah (4-8): hubungan kata, batas frasa

- Lapisan akhir (9-12): konten semantik, pengingatan fakta

Spesialisasi ini muncul dari tekanan pelatihan, bukan dari pilihan arsitektur. Desain blok seragam yang sama menghasilkan lapisan khusus ketika dilatih pada bahasa.

Total Parameter Blok

85M parameter di batang utama. Tambahkan ~13M di embedding token (8449 kosakata × 768 d_model × 2 untuk input/output yang diikat) ditambah normalisasi lapisan akhir, & jumlah parameter ANDREA-120M mencapai sekitar 120M. Desain blok menyumbang dua pertiga; embedding sisanya.

Melacak Satu Token Melalui Satu Blok