LLM Architecture và Fundamentals

Input Text: "Why is the sky blue?"
                │
                ▼ Tokenizer (BPE)
    [Why] [is] [the] [sky] [blue] [?]   ← Token IDs (ví dụ: [8699, 338, 278, 14744, 7254, 29973])
                │
                ▼ Embedding + Positional Encoding
    [E₁]  [E₂] [E₃]  [E₄]  [E₅] [E₆]   ← Mỗi Eᵢ là vector [hidden_dim] chiều (768 hoặc 4096...)
                │
                ▼ Transformer Blocks × N (N=32 ở Llama 3 8B, N=96 ở GPT-4)
    ┌────────────────────────────────────────────────────────────┐
    │  Block 1                                                    │
    │   ┌──────────────────┐       ┌──────────────────────────┐  │
    │   │  Self-Attention  │  ──►  │    Feed-Forward Network   │  │
    │   │   (multi-head)   │       │   (2 Linear + Activation) │  │
    │   └──────────────────┘       └──────────────────────────┘  │
    │   + Residual Connection + Layer Normalization (mỗi bước)    │
    └────────────────────────────────────────────────────────────┘
                ⋮  (lặp N block)
                │
                ▼ Linear (unembedding) + Softmax
    [P(Why), P(is), P(the), ..., P(blue), ...]  ← Xác suất mỗi token trong vocab
                │
                ▼ Sampling (dựa vào Temperature, Top-p)
    "Because of Rayleigh scattering..."          ← Token được chọn

Ban đầu, vocab = tất cả ký tự đơn lẻ:
  {'h', 'e', 'l', 'o', ' ', 'w', 'r', ...}

Corpus ví dụ: "low low low lower lower newest newest"

Vòng lặp 1: đếm cặp ký tự hay đứng cạnh nhau nhất
  → ('l', 'o') xuất hiện nhiều nhất → ghép thành 'lo'
  Vocab: {'h', 'e', 'lo', ' ', 'w', 'r', ...}

Vòng lặp 2: đếm lại
  → ('lo', 'w') → ghép thành 'low'
  Vocab: {'h', 'e', 'low', 'er', ' ', 'new', ...}

Tiếp tục cho đến khi vocab đạt kích thước target (Llama 3: 128,256 tokens)

"The quick brown fox" → 4 tokens (1 từ ≈ 1 token)
"Con cáo nâu nhanh"   → ~8-10 tokens (tùy model, vì mỗi từ tiếng Việt có thể đến 2-3 tokens)

Llama 3 8B parameters:
  Embedding Matrix = vocab_size × hidden_dim
                   = 128,256  ×  4,096
                   ≈ 500 triệu params
  → ~25% tổng model size chỉ là bảng tra cứu token!
  
Vocab lớn hơn → Embedding Layer nặng hơn → RAM nhiều hơn
Vocab nhỏ hơn → Mỗi từ dùng nhiều token hơn → Context window nhét ít thông tin hơn

x_i (vector 4096 chiều)
    │
    ├── × W_Q → Query: "Token này đang hỏi gì?"
    ├── × W_K → Key:   "Token này cung cấp thông tin gì?"
    └── × W_V → Value: "Nếu khớp, token này đưa dữ liệu gì?"

Step 1: Tính similarity score
  Score = Q × K^T
  Kết quả: Matrix [seq_len × seq_len]
  Score[i][j] = "Token i quan tâm đến Token j bao nhiêu?"

Step 2: Scale để tránh gradient vanish
  Score / sqrt(d_k)
  Lý do: Khi d_k lớn (ví dụ: 128), giá trị dot product có thể rất lớn
  → softmax bị saturated → gradient ≈ 0 → model không học được

Step 3: Masking (với Decoder-only)
  Che đi Score[i][j] với j > i (không được nhìn về tương lai)
  → Đảm bảo model chỉ dùng thông tin từ quá khứ khi predict

Step 4: Softmax → Attention Weights
  Biến Score thành xác suất (tổng mỗi hàng = 1.0)
  Ví dụ: Token "it" nhìn vào "The animal" với 0.7, "didn't" với 0.1, "cross" với 0.2

Step 5: Weighted sum với V
  Output = Attention_Weights × V
  → Mỗi token nhận được "tin tức tổng hợp" từ các token khác

Input: "John kicked the ball. It bounced away."
                                 │
                         Token "It" đang xem:

Head 1 → "It" refers to "ball" (coreference, quan hệ tham chiếu)
Head 2 → "It" comes after "." (syntactic, quan hệ cú pháp)
Head 3 → relationship với "bounce" (semantic role)
Head 4 → relates to objects in sentence (entity tracking)

Concat kết quả của N_heads heads → Linear projection → Output

N = 1,000 tokens  → Attention matrix: 1,000 × 1,000 = 1M entries → OK
N = 10,000 tokens → 10K × 10K = 100M entries → Bắt đầu nặng
N = 100,000 tokens → 100K × 100K = 10B entries → Tốn hàng chục GB chỉ cho 1 request!

Sinh token thứ 5:
  Phải tính Attention của token 5 với token [1,2,3,4,5] → 5 phép tính

Sinh token thứ 100:
  Phải tính Attention của token 100 với token [1..100] → 100 phép tính

Sinh token thứ 1000:
  → 1000 phép tính, đa phần là RE-COMPUTE những token đã tính rồi!

Prefill Phase (xử lý full prompt):
  Prompt: "Tóm tắt lịch sử Việt Nam cho tôi"
  → Tính Q, K, V cho toàn bộ 10 tokens một lượt (Matrix multiplication song song)
  → Lưu K, V của 10 tokens vào bộ nhớ (KV Cache)
  → GPU: Compute-Bound (parallel matrix ops)

Decode Phase (sinh response từng token):
  Token 11: Load KV Cache [1..10] + tính Q,K,V mới cho token 11 → append vào cache
  Token 12: Load KV Cache [1..11] + tính Q,K,V mới cho token 12 → append vào cache
  ...
  → GPU: Memory-Bound (bandwidth của VRAM là bottleneck, không phải compute cores)

Công thức:
  KV Cache size = 2               (K và V)
               × N_layers         (số transformer blocks)
               × N_heads          (số attention heads)
               × head_dim         (kích thước mỗi head)
               × seq_len          (số token trong context)
               × dtype_bytes      (2 bytes với float16)

Ví dụ thực tế — Llama 3 8B với 1 request, context 4096 tokens:
  2 × 32 × 32 × 128 × 4096 × 2 bytes = 2 GB

→ Chỉ 1 concurrent request đã tốn 2GB VRAM cho KV Cache!
→ Server GPU A100 (80GB VRAM) sau khi load model (~16GB), còn ~64GB
→ Tối đa ~32 concurrent requests nếu context window 4096
→ User gõ dài hơn (8K, 16K tokens) → số concurrent giảm mạnh

Thiết kế API Gateway:
  - Rate limit theo token, không chỉ theo request
  - Monitor VRAM utilization, set limit concurrent req/GPU
  - Long-running conversations tốn VRAM hơn short ones

Tối ưu chi phí:
  - Trim unnecessary system prompt (mỗi token tốn thêm KV Cache)
  - Chia nhỏ conversation: cuộc chat 1000-turn tích KV Cache khổng lồ
  - Prefix caching: nếu nhiều request cùng share 1 phần context dài
    (ví dụ: document analysis), cache K,V của phần đó và reuse
    → GPT-4 Turbo, Claude 3.5 đều support tính năng này

T = 0 (≈ Greedy):   Chọn argmax, hoàn toàn deterministic
T = 0.7 (default):  Hơi ngẫu nhiên, vẫn coherent → code generation, QA
T = 1.0:            Sampling theo xác suất gốc của model
T > 1.5:            Rất ngẫu nhiên, có thể vô nghĩa → creative writing

vocab sorted by prob: [0.35, 0.25, 0.20, 0.10, 0.05, 0.03, ...]

top_p = 0.9:
  token 1: 0.35 → cumsum = 0.35 (< 0.9, keep)
  token 2: 0.25 → cumsum = 0.60 (< 0.9, keep)
  token 3: 0.20 → cumsum = 0.80 (< 0.9, keep)
  token 4: 0.10 → cumsum = 0.90 (= 0.9, keep)
  token 5+: loại bỏ hoàn toàn (prob = 0)

Llama 3 so sánh:
                    8B          70B         405B
Hidden dim:       4,096       8,192        16,384
Layers (N):          32          80           126
Attention heads:     32          64           128
Context:         128K        128K          128K
VRAM (fp16):      ~16GB        ~140GB       ~810GB

Năng lực tăng theo scale:
  7B:  Tốt cho task đơn giản, code cơ bản, Q&A ngắn
  70B: Reasoning phức tạp, code production-quality, multi-step tasks
  405B: Research-level, đối thủ GPT-4