Tambah dokumentasi arsitektur Split Multi-Head Total

README.md

@@ -0,0 +1,192 @@
+---
+license: cc-by-4.0
+language:
+- id
+tags:
+- transformer
+- multi-head-attention
+- block-diagonal
+- architecture
+---
+
+# Split Multi-Head Total: Transformer dengan Proyeksi Block-Diagonal per Head
+
+Artikel asli: https://catatanwildanardiansyah.blogspot.com/2026/10/split-multi-head-total-transformer.html
+
+**Ringkasan.** Split Multi-Head Total (SMHT) adalah varian Transformer decoder yang membatasi semua proyeksi linear di dalam blok, yaitu Q, K, V, W_O, dan dua lapisan FFN, menjadi block-diagonal per head. Vektor berdimensi `d_model` dipecah menjadi `H` potongan, dan potongan ke-`i` hanya diproses oleh bobot milik head ke-`i`. Dokumen ini menjelaskan strukturnya, menelusuri cara kerjanya dari token masukan sampai logit keluaran langkah demi langkah, lalu menghitung jumlah parameternya.
+
+## 1. Notasi
+
+| Simbol | Arti |
+| --- | --- |
+| `B, L` | ukuran batch, panjang sekuens (jumlah token) |
+| `V` | ukuran kosakata |
+| `d_model` | dimensi vektor tiap token di seluruh model |
+| `H` | jumlah head; harus membagi `d_model` dan `d_ff` |
+| `d_head` | `d_model / H`, lebar satu potongan |
+| `d_ff`, `d_ff_head` | lebar hidden FFN, dan `d_ff / H` |
+
+Semua proyeksi linear di dalam blok tidak memakai bias.
+
+## 2. Gagasan inti: dari matriks padat ke block-diagonal
+
+Pada Transformer standar, proyeksi Q, K, dan V dibagi per head, tetapi setiap head membaca seluruh `d_model` dari inputnya. Setelah attention, matriks W_O berukuran penuh `d_model × d_model` mencampur semua head. FFN juga berupa dua matriks padat penuh.
+
+SMHT mengganti setiap matriks padat itu dengan matriks block-diagonal berisi `H` blok kecil. Head ke-`i` hanya membaca potongan ke-`i` dari vektor, dan hanya menulis ke potongan ke-`i` dari keluaran. Dengan `H = 4`, matriks proyeksi yang efektif berbentuk:
+
+~~~text
+[ A  0  0  0 ]
+[ 0  B  0  0 ]
+[ 0  0  C  0 ]
+[ 0  0  0  D ]
+~~~
+
+A, B, C, dan D adalah matriks `d_head × d_head`, masing-masing milik satu head. Angka 0 tidak disimpan sebagai parameter.
+
+## 3. Struktur model
+
+~~~text
+token_ids                                       (B, L)
+  → Embedding token + Embedding posisi           (B, L, d_model)
+  → [ Blok SMHT ] × N                            (B, L, d_model)
+  → LayerNorm akhir                              (B, L, d_model)
+  → LM head: Linear(d_model → V, tanpa bias)     (B, L, V)
+
+Blok SMHT (pre-norm):
+  x = x + SplitWO( SplitAttention( LayerNorm(x) ) )
+  x = x + SplitFFN( LayerNorm(x) )
+~~~
+
+Embedding posisi bersifat terpelajar (tabel dengan `max_seq` baris), bukan sinusoidal. LayerNorm, kedua embedding, dan LM head tetap padat (tidak dipecah). Weight tying antara embedding token dan LM head bersifat opsional.
+
+## 4. Cara kerja langkah demi langkah
+
+Agar mudah dilacak, bagian ini memakai model mini: `V = 100`, `max_seq = 16`, `d_model = 8`, `H = 4` (jadi `d_head = 2`), `d_ff = 16` (jadi `d_ff_head = 4`), satu blok, `B = 1`, dan masukan 4 token (`L = 4`). Pada model sebenarnya hanya angkanya yang lebih besar; langkahnya sama. Bentuk tensor ditulis dalam urutan `(B, ...)`.
+
+### Langkah 0: masukan
+
+`token_ids` berbentuk `(1, 4)`, berisi bilangan bulat dalam rentang `[0, V)`, misalnya `[17, 52, 3, 88]`.
+
+### Langkah 1: embedding token → (1, 4, 8)
+
+Tabel `E` berukuran `100 × 8` dibaca per baris: token 17 menjadi baris ke-17 dari `E`, dan seterusnya. Setiap token kini berupa vektor 8 dimensi.
+
+### Langkah 2: embedding posisi, lalu dijumlahkan → (1, 4, 8)
+
+Tabel `P` berukuran `16 × 8` dibaca pada baris 0 sampai 3 (posisi tiap token) dan dijumlahkan elemen demi elemen: `x0 = E[token] + P[posisi]`. Mulai titik ini, 8 dimensi tiap token dibagi menjadi 4 potongan: dimensi `[0,1]` milik head 0, `[2,3]` milik head 1, `[4,5]` milik head 2, dan `[6,7]` milik head 3. Pembagian ini tetap sama di seluruh blok.
+
+### Langkah 3: blok SMHT, sub-lapisan attention
+
+**3a. LayerNorm pertama → (1, 4, 8).** Untuk tiap token secara terpisah, dihitung rata-rata μ dan varians σ² atas 8 dimensinya, lalu (x − μ) / √(σ² + ε) · γ + β. Parameter γ dan β berukuran 8 dan tidak dipecah per head. Perhatikan bahwa μ dan σ² dihitung dari seluruh dimensi, jadi semua potongan berbagi dua angka ini.
+
+**3b. Pecah menjadi head → (1, 4, 4, 2).** Vektor 8 dimensi di-*reshape* menjadi 4 potongan berisi 2 dimensi. Langkah ini hanya mengubah bentuk tensor dan tidak ada perhitungan. Sumbu ketiga sekarang adalah sumbu head.
+
+**3c. Proyeksi Q, K, V per head → masing-masing (1, 4, 4, 2).** Head `h` punya tiga matriks `2 × 2` sendiri: `Wq[h]`, `Wk[h]`, `Wv[h]`. Untuk tiap token:
+
+~~~text
+q_h = x_h · Wq[h]
+k_h = x_h · Wk[h]
+v_h = x_h · Wv[h]
+~~~
+
+Semua head dihitung serentak dengan satu `einsum` atas bobot berbentuk `(H, d_head, d_head)`:
+
+~~~python
+# head h memakai Wq[h]
+q = torch.einsum('blhd,hde->bhle', x, Wq)
+~~~
+
+Head 0 hanya membaca dimensi 0 dan 1, sehingga tidak melihat dimensi 2 sampai 7.
+
+**3d. Skor attention dan softmax → (1, 4, 4, 4).** Untuk tiap head: `S_h = q_h · k_hᵀ / √d_head`, yaitu matriks `4 × 4` berisi kemiripan setiap pasang posisi, dibagi √2. Lalu diterapkan mask kausal: elemen pada posisi kolom `s` yang lebih besar dari baris `t` diisi −∞, agar token tidak melihat token sesudahnya. Setelah softmax per baris, baris ke-`t` berisi bobot perhatian atas posisi `0..t` yang jumlahnya 1. Tiap head memiliki peta perhatiannya sendiri, dihitung hanya dari potongannya.
+
+**3e. Menimbang value → (1, 4, 4, 2).** `A_h = softmax(S_h) · v_h`. Setiap token kini berisi campuran value dari token-token sebelumnya, di dalam potongannya.
+
+**3f. Konkatenasi head → (1, 4, 8).** Sumbu head dikembalikan ke samping sumbu `d_head` lalu digabung, sehingga hasil head `h` kembali menempati dimensi `2h` dan `2h+1`. Tiap potongan tetap berada di posisinya semula.
+
+**3g. W_O per head → (1, 4, 8).** Hasil dipecah lagi menjadi `(1, 4, 4, 2)` dan tiap potongan dikalikan `Wo[h]` (`2 × 2`): `y_h = A_h · Wo[h]`, lalu digabung kembali. Tidak ada matriks `8 × 8` yang mencampur potongan sesudahnya.
+
+**3h. Koneksi residual → (1, 4, 8).** `x1 = x0 + y`, penjumlahan elemen demi elemen.
+
+### Langkah 3 (lanjutan): sub-lapisan FFN
+
+**3i. LayerNorm kedua → (1, 4, 8).** Sama seperti 3a, dengan γ dan β miliknya sendiri.
+
+**3j. Pecah menjadi head → (1, 4, 4, 2).** Sama seperti 3b.
+
+**3k. FFN per head → (1, 4, 4, 2).** Head `h` punya dua matriks: `W1[h]` berukuran `2 × 4` dan `W2[h]` berukuran `4 × 2`.
+
+~~~text
+u_h = GELU( x_h · W1[h] )
+z_h = u_h · W2[h]
+~~~
+
+Di sini `u_h` berbentuk `(1, 4, 4)`, yaitu potongan 2 dimensi dilebarkan menjadi 4, dan `z_h` berbentuk `(1, 4, 2)`, yaitu dikembalikan menjadi 2 dimensi. Bobot seluruh head berbentuk `W1: (4, 2, 4)` dan `W2: (4, 4, 2)`.
+
+**3l. Konkatenasi dan residual → (1, 4, 8).** Hasil `z_h` digabung menjadi `(1, 4, 8)`, lalu `x2 = x1 + z`. Bila ada `N` blok, `x2` menjadi masukan blok berikutnya, yang bobotnya terpisah dari blok ini.
+
+### Langkah 4: LayerNorm akhir → (1, 4, 8)
+
+Sama seperti 3a, dengan parameter sendiri.
+
+### Langkah 5: LM head → (1, 4, 100)
+
+Matriks padat `U` berukuran `8 × 100` (tanpa bias) dikalikan ke tiap vektor token: `logits = x · U`. Pada langkah inilah seluruh 8 dimensi, dari semua potongan, digabung menjadi 100 skor. Bila weight tying dipakai, `U = Eᵀ`.
+
+### Langkah 6: membaca keluaran
+
+Logit pada posisi `t` adalah 100 skor untuk token yang mungkin muncul *sesudah* posisi `t`. Softmax atas sumbu terakhir mengubahnya menjadi distribusi probabilitas. Saat menghasilkan teks, distribusi pada posisi terakhir (`L − 1`) dipakai untuk memilih token berikutnya.
+
+## 5. Jumlah parameter
+
+- **Q, K, V:** standar `3 · d_model²`; SMHT `3 · d_model · d_head`. Model mini: 192 → 48.
+- **W_O:** standar `d_model²`; SMHT `d_model · d_head`. Model mini: 64 → 16.
+- **FFN:** standar `2 · d_model · d_ff`; SMHT `2 · d_model · d_ff_head`. Model mini: 256 → 64.
+- **Total satu blok:** pada SMHT setiap proyeksi bernilai `1/H` dari standar. Model mini: 512 → 128.
+- **LayerNorm** (2 per blok + 1 akhir): `2 · d_model` per LayerNorm, sama untuk keduanya. Model mini: 3 × 16 = 48.
+- **Embedding token, embedding posisi, LM head:** `V · d_model`, `max_seq · d_model`, `V · d_model`, sama untuk keduanya. Model mini: 800, 128, 800.
+
+Total model mini dengan SMHT: 800 + 128 + 128 + 48 + 800 = **1.904** parameter. Bila `H` dan `d_model` besar, bagian blok menjadi sangat kecil dibanding embedding dan LM head.
+
+## 6. Sifat struktural
+
+### 6.1 H Transformer sempit yang berjalan paralel
+
+Karena semua bobot block-diagonal, potongan ke-`i` berevolusi seperti Transformer berlebar `d_head` dengan satu head attention dan hidden FFN selebar `d_ff_head`. SMHT dapat dibaca sebagai `H` model sempit yang berbagi satu lintasan komputasi.
+
+### 6.2 Titik kopling antar potongan
+
+1. **LayerNorm** (langkah 3a, 3i, 4): rata-rata dan varians dihitung atas seluruh `d_model`, sehingga semua potongan berbagi dua angka per token.
+2. **LM head** (langkah 5): karena linear atas hasil konkatenasi, logit kosakata ke-`v` adalah jumlah kontribusi tiap potongan: `logit_v = Σ_i ⟨U_v[i], z_i⟩`.
+
+Koneksi residual hanya menjumlahkan dimensi yang sama dengan dimensi yang sama, jadi tidak mencampur potongan. Menambah jumlah blok juga tidak menambah pencampuran, kecuali lewat LayerNorm.
+
+### 6.3 Kasus H = 1
+
+Seluruh bobot menjadi matriks padat `d_model × d_model`, dan FFN-nya `d_model → d_ff → d_model`. Ini identik dengan Transformer standar satu head. Untuk `H > 1`, SMHT dan Transformer multi-head standar adalah dua arsitektur yang berbeda, sebab pada yang standar tiap head membaca seluruh `d_model` dan W_O mencampur semua head.
+
+### 6.4 Kasus H = d_model (d_head = 1)
+
+Setiap potongan berupa satu channel skalar. Q, K, dan V adalah skalar: dengan `a = Wq · Wk`, skor antara posisi `t` dan `s` adalah `a · x_t · x_s`. FFN-nya adalah fungsi skalar `GELU(w1 · x) · w2` bila `d_ff_head = 1`.
+
+## 7. Ruang lingkup
+
+Dokumen ini hanya menjelaskan struktur dan cara kerja arsitektur SMHT. Kualitas model, kecepatan, dan perbandingan dengan Transformer standar tidak dibahas dan tidak diklaim.
+
+## Referensi
+
+1. Vaswani, A., et al. (2017). *Attention Is All You Need*. NeurIPS.
+2. Ba, J. L., Kiros, J. R., Hinton, G. E. (2016). *Layer Normalization*. arXiv:1607.06450.
+3. Hendrycks, D., Gimpel, K. (2016). *Gaussian Error Linear Units (GELUs)*. arXiv:1606.08415.
+
+*Catatan penulisan: naskah ini disusun dengan bantuan AI, dan rumus serta jumlah parameternya dihitung ulang secara manual.*
+
+---
+
+**Ahmad Wildan Ardiansyah**
+
+D4 Teknik Jaringan Telekomunikasi Digital
+
+Teknik Elektro
+
+Politeknik Negeri Malang