Dari Teks ke Jawaban: Anatomi Lengkap Proses Inferensi Large Language Model, Langkah demi Langkah

Bagaimana sebuah kalimat sederhana seperti “Halo, apa kabar?” berubah menjadi rangkaian angka, melewati lapisan-lapisan Transformer, lalu kembali menjadi kata yang bermakna. Sebuah pembedahan 15 langkah dari tokenisasi hingga token pertama yang dihasilkan model.

Pengantar

Ketika Anda mengetik sebuah pertanyaan pada model bahasa besar (Large Language Model, LLM) dan dalam sekejap muncul jawaban yang koheren, ada serangkaian operasi matematika padat yang berjalan di balik layar. Model tidak “memahami” kata dalam pengertian manusiawi, ia mengubah teks menjadi vektor angka, menghitung hubungan antar kata melalui mekanisme attention, lalu memproyeksikan hasilnya kembali ke ruang kosakata untuk memprediksi kata berikutnya. Artikel ini membedah keseluruhan alur tersebut secara berurutan, menggunakan arsitektur bergaya GPT (decoder-only Transformer) sebagai contoh konkret dengan dimensi model \(d_{\text{model}} = 768\), 12 attention head, dimensi per head \(d_k = 64\), lapisan feed-forward 3072, dan kosakata sekitar 50.000 token.

Alur di bawah ini menelusuri satu kalimat masukan sampai model menghasilkan satu token keluaran pertama, kemudian mengulang siklus tersebut secara autoregressive hingga kalimat jawaban selesai.

Bagian 1: Dari Teks Menjadi Angka

Langkah 1: Tokenisasi

Teks masukan dipecah menjadi unit-unit sub-kata (subword) lalu dipetakan ke ID numerik berdasarkan kosakata model. Pemecahan sub-kata, misalnya melalui Byte Pair Encoding, memungkinkan model menangani kata langka atau baru tanpa kehabisan kosakata.

  • Masukan: "Halo, apa kabar?"
  • Keluaran (ilustratif): [2572, 3058, 2573, 102]

Langkah 2: Pencarian Embedding (Embedding Lookup)

Setiap ID token digunakan untuk mengambil baris yang bersesuaian dari matriks embedding berukuran \(\text{vocab\_size} \times d_{\text{model}}\). Hasilnya adalah vektor padat yang merepresentasikan makna token.

$$ \mathbf{E}_i = \text{EmbeddingMatrix}[\text{token\_id}_i] $$
  • Keluaran: 4 vektor, masing-masing berdimensi 768.
  • Contoh: \(\mathbf{E}_1 = [0{,}5,\ 0{,}2,\ -0{,}3,\ \dots,\ 0{,}7]\)  (768 nilai).

Langkah 3: Penambahan Positional Encoding

Transformer memproses semua token secara paralel dan tidak memiliki gagasan urutan bawaan. Karena itu, informasi posisi ditambahkan langsung ke embedding token sebelum masuk ke blok Transformer. Inilah yang membuat model tahu bahwa “apa kabar” berbeda dari “kabar apa”.

$$ \mathbf{h}^{(0)}_i = \mathbf{E}_i + \mathbf{P}_i $$
  • Keluaran: 4 vektor keadaan awal (hidden state), masing-masing berdimensi 768.

Catatan penting. Dimensi embedding sama dengan dimensi tersembunyi model (\(d_{\text{model}} = 768\)). Tidak ada proyeksi yang “memperbesar” embedding ke dimensi lain sebelum blok Transformer, vektor 768 dari Langkah 2 langsung menjadi keadaan tersembunyi yang diproses berulang oleh setiap blok.

Bagian 2: Inti Transformer: Self-Attention

Langkah 4: Proyeksi Query, Key, dan Value

Setiap vektor keadaan tersembunyi diproyeksikan menjadi tiga vektor berbeda, Query (Q), Key (K), dan Value (V), melalui perkalian dengan matriks bobot terlatih. Q, K, dan V inilah bahan baku mekanisme attention.

$$ q_{ij} = \sum_k h_{ik}\, W^{Q}_{kj} + b^{Q}_{j} \qquad k_{ij} = \sum_k h_{ik}\, W^{K}_{kj} + b^{K}_{j} \qquad v_{ij} = \sum_k h_{ik}\, W^{V}_{kj} + b^{V}_{j} $$
  • Masukan: keadaan tersembunyi 768-dimensi (4 token).
  • Keluaran: tiga himpunan vektor (Q, K, V). Dengan 12 head, total 768 dimensi dibagi menjadi 12 × 64; setiap head bekerja pada potongan berdimensi \(d_k = 64\).

Langkah 5: Skor Attention

Untuk setiap token, model mengukur seberapa relevan token lain terhadapnya dengan menghitung hasil kali titik (dot product) antara Query token tersebut dan Key seluruh token, lalu diskalakan dengan \(\sqrt{d_k}\) agar nilainya stabil.

$$ \text{score}_{ij} = \frac{\sum_k q_{ik}\, k_{jk}}{\sqrt{d_k}} $$

Keluaran: matriks 4×4 (kemiripan setiap token terhadap semua token). Contoh:

$$ \begin{bmatrix} 8{,}2 & 3{,}1 & 5{,}4 & 2{,}1 \\ 3{,}5 & 7{,}8 & 4{,}2 & 1{,}9 \\ 6{,}1 & 4{,}5 & 9{,}2 & 3{,}8 \\ 2{,}3 & 1{,}8 & 3{,}5 & 6{,}9 \end{bmatrix} $$

Langkah 6: Masking Kausal + Softmax

Pada model generatif bergaya GPT, sebuah token hanya boleh “melihat” dirinya sendiri dan token-token sebelumnya, bukan token masa depan. Karena itu, sebelum softmax, posisi masa depan pada matriks skor diberi nilai \(-\infty\) (causal mask). Softmax kemudian mengubah skor menjadi distribusi probabilitas yang berjumlah 1 pada setiap baris.

$$ \text{attention}_{ij} = \frac{\exp(\text{score}_{ij})}{\sum_{j'} \exp(\text{score}_{ij'})} $$

Keluaran: matriks probabilitas 4×4. Contoh:

$$ \begin{bmatrix} 0{,}35 & 0{,}15 & 0{,}25 & 0{,}25 \\ 0{,}20 & 0{,}50 & 0{,}20 & 0{,}10 \\ 0{,}15 & 0{,}20 & 0{,}55 & 0{,}10 \\ 0{,}10 & 0{,}10 & 0{,}20 & 0{,}60 \end{bmatrix} $$

Langkah 7: Keluaran Attention

Bobot probabilitas dipakai untuk merata-rata vektor Value: token yang mendapat bobot besar menyumbang lebih banyak. Keluaran dari seluruh head lalu digabung (concatenate) dan diproyeksikan kembali melalui matriks keluaran \(W^{O}\).

$$ \mathbf{output}_i = \sum_j \text{attention}_{ij}\, \mathbf{v}_j \qquad\longrightarrow\qquad \mathbf{z}_i = \text{Concat}(\text{head}_1,\dots,\text{head}_{12})\, W^{O} $$
  • Keluaran: 4 vektor, masing-masing kembali berdimensi 768.
  • Contoh: \(\mathbf{z}_1 = [1{,}8,\ 2{,}9,\ 0{,}2,\ \dots,\ 1{,}5]\).

Langkah 8: Residual + Layer Normalization (Sub-lapisan Attention)

Keluaran attention ditambahkan kembali ke masukannya (koneksi residual / skip connection) lalu dinormalisasi. Residual menjaga aliran gradien pada jaringan yang dalam, sementara normalisasi menstabilkan distribusi nilai antar-lapisan.

$$ \mathbf{a}_i = \text{LayerNorm}\!\left(\mathbf{h}_i + \mathbf{z}_i\right) $$

Bagian 3: Feed-Forward Network

Langkah 9: Feed-Forward Lapisan 1 (Ekspansi)

Setiap posisi token diproses secara independen oleh jaringan dua lapis. Lapisan pertama memperluas dimensi dari 768 ke 3072 (ekspansi 4×), memberi model ruang representasi yang lebih kaya.

$$ \text{ff1}_{ij} = \sum_k a_{ik}\, W^{\text{ff1}}_{kj} + b^{\text{ff1}}_{j} \qquad (768 \rightarrow 3072) $$
  • Keluaran: 4 vektor, masing-masing berdimensi 3072.

Langkah 10: Fungsi Aktivasi Non-linear

Fungsi aktivasi non-linear diterapkan agar jaringan dapat memodelkan hubungan yang tidak linear. Transformer bergaya GPT dan BERT umumnya memakai GELU, sementara Transformer orisinal memakai ReLU.

$$ \text{ReLU}(x) = \max(0,\ x) \qquad\qquad \text{GELU}(x) = x\,\Phi(x) $$

dengan \(\Phi(x)\) adalah fungsi distribusi kumulatif Gaussian standar. Tidak seperti ReLU yang memutus seluruh nilai negatif menjadi nol, GELU memberi bobot masukan secara halus.

Langkah 11: Feed-Forward Lapisan 2 (Proyeksi Balik)

Lapisan kedua memproyeksikan representasi kembali ke dimensi model semula, dari 3072 ke 768, agar dapat dijumlahkan dengan jalur residual.

$$ \text{ff2}_{ij} = \sum_k g_{ik}\, W^{\text{ff2}}_{kj} + b^{\text{ff2}}_{j} \qquad (3072 \rightarrow 768) $$

dengan \(g\) adalah keluaran fungsi aktivasi dari Langkah 10.

Langkah 12: Residual + Layer Normalization (Sub-lapisan Feed-Forward)

Sekali lagi, keluaran feed-forward ditambahkan ke masukannya lalu dinormalisasi, menghasilkan keadaan tersembunyi akhir dari blok ini.

$$ \mathbf{h}^{\text{out}}_i = \text{LayerNorm}\!\left(\mathbf{a}_i + \mathbf{ff2}_i\right) $$

Ulangi Langkah 4–12 untuk setiap blok Transformer. Model bergaya GPT-2 kecil memiliki 12 blok; model yang lebih besar dapat memiliki puluhan hingga ratusan blok, masing-masing berisi Attention + Feed-Forward + Normalization. Keluaran satu blok menjadi masukan blok berikutnya.

Bagian 4: Dari Angka Kembali Menjadi Kata

Langkah 13: Proyeksi Keluaran (Output Projection)

Setelah blok terakhir, keadaan tersembunyi diproyeksikan ke ruang kosakata melalui matriks keluaran (yang pada banyak model “diikat”/weight-tied dengan matriks embedding). Hasilnya adalah skor mentah (logits) untuk setiap token dalam kosakata.

$$ \text{logits}_{ij} = \sum_k h^{\text{out}}_{ik}\, W^{\text{output}}_{kj} + b^{\text{output}}_{j} \qquad (768 \rightarrow \sim 50{.}000) $$
  • Keluaran: vektor berdimensi \(\approx 50.000\) untuk posisi token terakhir.

Langkah 14: Softmax Akhir

Logits diubah menjadi distribusi probabilitas atas seluruh kosakata. Setiap nilai kini berada di rentang 0–1 dan seluruhnya berjumlah 1.

$$ \text{prob}_i = \frac{\exp(\text{logits}_i)}{\sum_j \exp(\text{logits}_j)} $$
  • Contoh: \([0{,}001,\ 0{,}002,\ 0{,}85,\ 0{,}05,\ \dots]\), nilai 0,85 adalah probabilitas token kandidat “Saya”.

Langkah 15: Pemilihan Token, Decode, dan Pengulangan

Token berikutnya dipilih dari distribusi probabilitas. Strategi paling sederhana adalah argmax (mengambil probabilitas tertinggi); dalam praktik, strategi sampling seperti temperature, top-k, atau top-p sering dipakai untuk mengontrol kreativitas keluaran.

$$ \text{predicted\_token} = \arg\max_i\, \text{prob}_i $$

ID token terpilih (misalnya 5021) lalu di-decode kembali menjadi teks (“Saya”). Token ini ditambahkan ke urutan masukan, dan seluruh siklus prediksi diulang untuk menghasilkan token berikutnya, proses autoregressive, hingga muncul token akhir [EOS] atau tercapai panjang maksimum.

Hasil akhir: “Saya sedang belajar machine learning.”

Ringkasan Alur

Secara ringkas, inferensi LLM adalah siklus teks → angka → angka → teks. Teks diubah menjadi vektor (Langkah 1–3), diproses berulang oleh blok-blok Transformer yang mengombinasikan self-attention dan feed-forward (Langkah 4–12), lalu diproyeksikan kembali ke kosakata untuk memprediksi satu token (Langkah 13–15). Token itu diumpankan kembali sebagai masukan, dan siklus berlanjut sampai jawaban lengkap terbentuk. Kesederhanaan operasi dasarnya, perkalian matriks, softmax, dan normalisasi, yang diulang miliaran kali itulah yang, secara mengejutkan, menghasilkan bahasa yang koheren.

Referensi

  1. Vaswani, A., Shazeer, N., Parmar, N., Uszkoreit, J., Jones, L., Gomez, A. N., Kaiser, Ł., & Polosukhin, I. (2017). Attention Is All You Need. Advances in Neural Information Processing Systems 30. arXiv:1706.03762. https://arxiv.org/abs/1706.03762
  2. Devlin, J., Chang, M.-W., Lee, K., & Toutanova, K. (2019). BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding. NAACL-HLT 2019, 4171–4186. DOI: 10.18653/v1/N19-1423
  3. Sennrich, R., Haddow, B., & Birch, A. (2016). Neural Machine Translation of Rare Words with Subword Units. ACL 2016, 1715–1725. DOI: 10.18653/v1/P16-1162
  4. Ba, J. L., Kiros, J. R., & Hinton, G. E. (2016). Layer Normalization. arXiv:1607.06450. https://arxiv.org/abs/1607.06450
  5. Hendrycks, D., & Gimpel, K. (2016). Gaussian Error Linear Units (GELUs). arXiv:1606.08415. https://arxiv.org/abs/1606.08415

Catatan: makalah Attention Is All You Need dan Layer Normalization diterbitkan melalui NeurIPS/arXiv dan tidak memiliki DOI formal; keduanya diidentifikasi melalui nomor arXiv yang stabil. DOI untuk BERT dan Subword Units telah diverifikasi resolvabel melalui doi.org.