| --- |
| 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 |
| |
