Bedah Anatomi Teknis Large Language Models (LLM)

Di permukaan, Generative AI seperti GPT-4, Claude, atau Llama 3 tampak seperti sihir. Kita mengetikkan instruksi dalam bahasa natural, dan mesin membalas dengan penalaran yang seolah-olah memiliki kesadaran. Namun, bagi kita yang hidup di dunia code dan logic, "sihir" adalah kata lain untuk "abstraksi yang belum dipahami".

Artikel ini tidak akan membahas dampak sosial atau etika AI. Kita akan membongkar kap mesinnya. Kita akan menelusuri perjalanan sebuah string teks mulai dari input, dikonversi menjadi representasi vektor, diproses melalui lapisan-lapisan Transformer, hingga probabilitas output dihasilkan.

Ini adalah panduan teknis komprehensif tentang bagaimana tumpukan matriks dan kalkulus dapat meniru bahasa manusia.

Bab 1: Representasi Data (Dari String ke Aljabar)

Komputer tidak memahami linguistik; ia hanya memahami numerik. Tantangan pertama dalam NLP (Natural Language Processing) adalah mengubah semantik menjadi matematik.

1.1 Tokenization: Byte-Pair Encoding (BPE)

Langkah pertama bukanlah memecah kalimat berdasarkan spasi (kata), melainkan sub-word units atau token. Model modern menggunakan algoritma seperti Byte-Pair Encoding (BPE).

Secara teknis, BPE bekerja dengan mengompresi karakter yang sering muncul bersamaan menjadi satu token unik.

Kata "apple" mungkin satu token.
Kata "antidisestablishmentarianism" mungkin dipecah menjadi ["anti", "dis", "establish", "ment", "arian", "ism"].

Setiap token ini kemudian dipetakan ke integer unik (Index ID) berdasarkan vocabulary model (misalnya, GPT-4 memiliki vocab size sekitar 100k token).

1.2 Vector Embeddings & The High-Dimensional Space

Di sinilah magis matematika dimulai. Integer ID tadi hanyalah penunjuk. "Makna" sebenarnya disimpan dalam Vector Embedding.

Setiap token direpresentasikan sebagai vektor floating-point berdimensi tinggi ($d_{model}$). Untuk model standar seperti GPT-3, dimensinya adalah 12.288.

Bayangkan sebuah ruang koordinat dengan 12.288 sumbu. Setiap kata adalah satu titik di ruang ini.

Semantic Proximity: Kata-kata dengan makna mirip akan memiliki Cosine Similarity yang tinggi (sudut vektor berdekatan).
Linear Substructures: Kita bisa melakukan operasi aritmatika pada makna. Contoh klasik Word2Vec berlaku di sini:

$Vector(King) - Vector(Man) + Vector(Woman) \approx Vector(Queen)$

Ini bukan sekadar analogi; ini adalah hasil operasi dot product pada matriks embedding yang telah dilatih pada miliaran teks.

Bab 2: Arsitektur Inti (The Transformer)

Pada tahun 2017, tim Google Brain merilis paper "Attention is All You Need". Ini mengubah segalanya. Sebelum Transformer, kita menggunakan RNN (Recurrent Neural Networks) atau LSTM yang memproses data secara sekuensial (kata per kata), yang lambat dan sudah lupa konteks awal saat mencapai akhir kalimat.

Transformer memungkinkan Parallel Processing dan Long-Range Dependency. Mari kita bedah komponen utamanya.

2.1 Positional Encoding

Karena Transformer memproses semua token input secara paralel (sekaligus), ia tidak tahu urutan kata. "Saya makan ikan" dan "Ikan makan saya" akan terlihat sama bagi model tanpa informasi posisi.

Untuk mengatasinya, kita menambahkan vektor Positional Encoding ke vektor Embedding awal. Secara matematis, ini sering menggunakan fungsi sinus dan cosinus dengan frekuensi berbeda:

PE_{(pos, 2i)} = \sin(pos / 10000^{2i/d_{model}})

PE_{(pos, 2i+1)} = \cos(pos / 10000^{2i/d_{model}})

Ini memberikan "sidik jari" unik pada setiap posisi token, memungkinkan model membedakan urutan relatif dan absolut.

2.2 The Heart: Self-Attention Mechanism

Ini adalah komponen terpenting. Self-Attention memungkinkan model untuk menimbang pentingnya setiap token terhadap token lainnya dalam satu context window.

Mekanisme ini memecah vektor input menjadi tiga proyeksi vektor baru melalui perkalian matriks linear yang dapat dipelajari (learnable weights):

Query ( $Q$ ): Apa yang sedang saya cari?
Key ( $K$ ): Apa identitas saya?
Value ( $V$ ): Apa informasi yang saya bawa?

Rumus Scaled Dot-Product Attention:

Attention(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V

Mari kita bedah langkah per langkah:

$QK^T$ (MatMul): Menghitung dot product antara Query satu token dengan Key seluruh token lain. Hasilnya adalah skor relevansi. Jika token A (Subjek) sangat berkaitan dengan token B (Verba), skornya tinggi.
Scale ( $\sqrt{d_k}$ ): Membagi dengan akar dimensi key untuk mencegah gradien meledak (vanishing/exploding gradients) saat masuk ke softmax.
Softmax: Mengubah skor mentah menjadi distribusi probabilitas (total 1). Ini menentukan seberapa banyak "perhatian" harus diberikan ke token lain.
Multiply by $V$ : Mengalikan skor atensi dengan vektor Value. Ini adalah proses "mengambil informasi" dari token yang relevan.

2.3 Multi-Head Attention

Satu mekanisme atensi mungkin hanya fokus pada hubungan sintaksis (Subjek-Predikat). Untuk menangkap nuansa lain (misal: referensi anafora, nada emosi), Transformer menjalankan mekanisme di atas beberapa kali secara paralel (disebut "Heads").

Setiap Head memiliki matriks bobot $W_Q, W_K, W_V$ yang berbeda, sehingga setiap Head belajar aspek bahasa yang berbeda. Hasil dari semua Head kemudian digabungkan (concatenated) dan diproyeksikan kembali.

2.4 Feed-Forward Networks (FFN)

Setelah Attention (yang bertugas mencampur informasi antar token), data masuk ke FFN. Ini adalah Multilayer Perceptron (MLP) standar yang diterapkan pada setiap posisi token secara independen.

Biasanya terdiri dari dua lapisan linear dengan fungsi aktivasi non-linear di tengahnya (seperti GELU atau Swish):

FFN(x) = \text{GELU}(xW_1 + b_1)W_2 + b_2

FFN sering dianggap sebagai "Key-Value Memory" statis tempat model menyimpan pengetahuan faktual yang dipelajari selama training.

2.5 Add & Norm (Residual Connections)

Setiap sub-layer (Attention dan FFN) dikelilingi oleh koneksi residual (skip connection) dan normalisasi lapisan (Layer Normalization):

Output = LayerNorm(x + Sublayer(x))

Koneksi residual ( $x + ...$ ) sangat krusial bagi Deep Learning. Ini memungkinkan gradien mengalir bebas melalui jaringan yang sangat dalam (ratusan layer) tanpa hilang (vanishing gradient), memungkinkan kita melatih model dengan ratusan miliar parameter.

Bab 3: Proses Pembelajaran (Training Dynamics)

Memiliki arsitektur saja tidak cukup. Model harus dilatih. Untuk LLM, prosesnya terbagi menjadi dua fase utama: Pre-training dan Fine-tuning.

3.1 Pre-training: Self-Supervised Learning

LLM tidak dilatih dengan data berlabel (seperti klasifikasi gambar kucing/anjing). Ia dilatih dengan Self-Supervised Learning pada triliunan token teks.

Tugas utamanya sederhana: Next Token Prediction.

Diberikan urutan token $w_1, w_2, ..., w_t$, model harus memprediksi token $w_{t+1}$.

Secara matematis, kita ingin memaksimalkan Likelihood:

L(\theta) = \sum_t \log P(w_t | w_{t-k}, ..., w_{t-1}; \theta)

Loss Function: Kita menggunakan Cross-Entropy Loss untuk mengukur jarak antara distribusi probabilitas prediksi model dengan token yang sebenarnya muncul di dataset.

Optimization:

Algoritma seperti AdamW (Adam dengan Weight Decay) digunakan untuk mengupdate miliaran parameter ($\theta$) melalui Backpropagation.

Karena ukuran model yang masif, teknik seperti Mixed Precision Training (menggunakan format FP16 atau BF16 alih-alih FP32) dan Data Parallelism di ribuan GPU sangat mutlak diperlukan.

3.2 Post-Training: SFT & RLHF

Setelah pre-training, kita mendapatkan "Base Model". Model ini pintar melengkapi kalimat, tapi tidak bisa mengikuti instruksi. Jika Anda tanya "Resep kue?", dia mungkin menjawab "adalah salah satu yang paling dicari..." (hanya melengkapi kalimat).

Untuk membuatnya menjadi asisten (seperti ChatGPT), kita butuh fase penyelarasan (Alignment):

Supervised Fine-Tuning (SFT): Model dilatih ulang pada dataset instruksi-jawaban berkualitas tinggi yang ditulis manusia. Ini mengajarkan format dialog.
RLHF (Reinforcement Learning from Human Feedback):
- Reward Model (RM): Kita melatih model kecil lain untuk menilai kualitas jawaban (Manusia memberi ranking A lebih baik dari B).
- PPO (Proximal Policy Optimization): Kita menggunakan algoritma Reinforcement Learning untuk "menghukum" LLM jika menghasilkan jawaban buruk dan "memberi hadiah" jika jawabannya bagus (skor tinggi dari RM), tanpa merusak kemampuan bahasa dasarnya (dijaga dengan KL-Divergence penalty).

Bab 4: Inference (Saat Kode Dijalankan)

Apa yang terjadi saat Anda menekan Enter di prompt chat?

4.1 Autoregressive Generation

LLM menghasilkan teks satu token setiap kalinya.

Prompt masuk, diproses oleh seluruh layer Transformer.
Layer terakhir menghasilkan vektor logits (skor mentah) untuk 50.000+ kemungkinan token selanjutnya.
Logits dinormalisasi menjadi probabilitas menggunakan Softmax.
Satu token dipilih (sampling).
Token terpilih ditambahkan ke input awal, dan proses diulang (loop) untuk memprediksi token berikutnya.

4.2 KV Cache (Optimasi Kritis)

Tanpa optimasi, model harus menghitung ulang atensi untuk seluruh token masa lalu setiap kali membuat token baru. Ini sangat boros ($O(n^2)$).

Dalam produksi, kita menggunakan Key-Value (KV) Cache. Kita menyimpan matriks K dan V dari token-token sebelumnya di memori GPU, sehingga kita hanya perlu menghitung matriks Q untuk token terbaru dan mengalikannya dengan cache yang ada. Ini mempercepat inferensi secara linear.

4.3 Decoding Strategies (Temperature & Sampling)

Bagaimana cara memilih token dari distribusi probabilitas?

Kita tidak selalu mengambil probabilitas tertinggi (Greedy Decoding) karena hasilnya akan repetitif dan membosankan. Kita menggunakan parameter hiper:

Temperature ($T$): Menskalakan logits sebelum softmax.

$p_i = \frac{\exp(z_i / T)}{\sum \exp(z_j / T)}$
- $T < 1$ : Memperbesar beda antara probabilitas tinggi dan rendah (lebih percaya diri/deterministik).
- $T > 1$ : Meratakan distribusi (lebih acak/kreatif).
Top-K Sampling: Hanya mempertimbangkan $K$ token teratas, sisanya dipangkas (probability = 0).
Top-P (Nucleus) Sampling: Mengambil token teratas hingga kumulatif probabilitas mencapai $P$ (misal 0.9). Ini lebih dinamis daripada Top-K.

Bab 5: Keterbatasan Teknis (The Engineering Bottlenecks)

Sebagai teknisi, kita harus tahu di mana sistem ini akan break.

5.1 Context Window & Quadratic Complexity

Mekanisme Self-Attention memiliki kompleksitas komputasi $O(N^2)$ terhadap panjang sekuens ($N$). Jika panjang konteks input naik 2x lipat, beban komputasi naik 4x lipat.

Inilah mengapa "Context Window" (misal 128k token di GPT-4) sangat mahal. Teknik seperti Ring Attention atau FlashAttention (IO-aware optimization) diciptakan untuk memitigasi ini, tapi batas fisiknya tetap pada VRAM GPU.

5.2 Hallucinations (Fitur, Bukan Bug)

Secara arsitektur, LLM tidak memiliki modul "verifikasi fakta". Ia hanya memprediksi kata yang paling mungkin secara statistik. Jika data training mengandung miskonsepsi, atau jika "ruang vektor" memaksanya menghubungkan konsep yang tidak terkait demi kelancaran kalimat, ia akan berbohong. Dalam teori informasi, halusinasi adalah creative generation yang tidak kita inginkan. Tidak ada switch "off" untuk ini di level arsitektur saat ini; hanya mitigasi lewat Retrieval-Augmented Generation (RAG).

5.3 Statelessness

Model itu sendiri statis (frozen weights). Ia tidak "belajar" dari percakapan Anda secara real-time (kecuali bobotnya di-update, yang mana sangat mahal). Ilusi "memori" dalam chat hanyalah kita (developer) mengirim ulang seluruh riwayat chat (user + assistant + user...) ke dalam prompt setiap kali ada pesan baru.

Kesimpulan: Apa Artinya Bagi Kita (Programmer)?

Memahami LLM secara teknis mengubah cara kita memandangnya.

Kita berhenti melihatnya sebagai "otak digital" dan mulai melihatnya sebagai:

Lossy Compression dari Pengetahuan Internet yang dapat di-query menggunakan Bahasa Natural.

Sebagai programmer, pergeseran paradigma terbesarnya adalah:

Probabilistic Programming: Kode kita tidak lagi deterministik ( $Input A \rightarrow Output B$ ). Kita sekarang mengelola probabilitas dan ketidakpastian.
Prompt Engineering adalah Hyperparameter Tuning: Mengubah kata dalam prompt sebenarnya adalah mengubah vektor input $Q, K, V$ agar hasil operasi matriks jatuh di area Latent Space yang kita inginkan.

Era "Software 2.0" (istilah Andrej Karpathy) telah tiba, di mana sebagian logika aplikasi tidak lagi ditulis dalam C++ atau Python, tetapi dipelajari sebagai bobot dalam jaringan saraf. Dan memahami arsitektur di atas adalah kunci untuk tidak hanya menjadi pengguna API, tetapi arsitek solusi AI yang robust.