Hướng Dẫn Xây Dựng Mô Hình Ngôn Ngữ Lớn (LLM) Từ Đầu và Những Kiến Thức Quý Giá

Tóm tắt: Xây dựng một mô hình ngôn ngữ lớn (LLM) tối giản không cần đến hàng trăm dòng code Python phức tạp. Qua quá trình này, bạn sẽ hiểu rõ cơ chế tokenization, attention và inference, từ đó nâng cao khả năng tích hợp API LLM thực tế. Bài viết cũng cung cấp ví dụ code, phương pháp kiểm thử API với Apidog, và những mẹo tối ưu quan trọng.

Giới thiệu

Nhiều nhà phát triển thường coi mô hình ngôn ngữ như một "hộp đen" kỳ bí – bạn nhập văn bản, và nó trả về token hoặc câu trả lời, nhưng không rõ bên trong có gì. Tuy nhiên, để debug tích hợp API, điều chỉnh tham số sampling hay xử lý lỗi tạo dữ liệu có cấu trúc, hiểu sâu về cấu trúc nội bộ của LLM là vô cùng cần thiết.

Mô hình GuppyLM đã gây chú ý trên HackerNews vì là một transformer nhẹ 8,7 triệu tham số được viết bằng Python, có thể huấn luyện dưới 1 giờ trên GPU thông thường. Mục đích của nó không phải cạnh tranh với GPT-4 mà để giúp ta hiểu rõ cách hoạt động bên trong của LLM.

Bài viết này sẽ hướng dẫn cách xây dựng một LLM nhỏ với các thành phần chính, vai trò của chúng và lý do việc hiểu rõ nội bộ giúp ích thế nào khi tích hợp API.

Apidog cung cấp môi trường test API AI mà không tiêu tốn credit thật, hỗ trợ kiểm tra streaming response, xác thực cấu trúc token và mô phỏng các trường hợp biên.

Mô hình ngôn ngữ "nhỏ" là gì?

• Các mô hình như GPT-4 có hàng trăm tỷ tham số, trong khi LLM nhỏ thường nằm trong khoảng 1 triệu đến 25 triệu tham số như GuppyLM (8.7M), nanoGPT (124M), MicroLM (1–2M).

Đặc điểm:

• Có thể train ngay trên laptop hoặc Google Colab
• Chạy được trên CPU với bộ nhớ hạn chế
• Dễ debug trực tiếp ở mức trọng số

Nhược điểm:

• Khả năng suy luận hạn chế
• Không tạo ra văn bản dài hoặc nhất quán được
• Không chứa nhiều kiến thức như mô hình lớn

Giá trị thực sự đến từ việc bạn thu nhận được kiến thức qua quá trình dựng và vận hành, chứ không phải chất lượng đầu ra tuyệt đối.

Các thành phần chính cấu tạo LLM

Một LLM gồm 4 phần cốt lõi:

1. Tokenizer

Chuyển văn bản thô thành chuỗi số nguyên – ví dụ "Hello, world!" → [15496, 11, 995, 0]. Mỗi số tương ứng với một đơn vị nhỏ như subword hay ký tự.

Trong áp dụng API, số lượng token ảnh hưởng trực tiếp đến độ trễ và chi phí. Hiểu chính xác tokenizer giúp bạn tối ưu prompt để tránh token bị cắt bỏ không cần thiết.

GuppyLM dùng token từng ký tự, còn GPT-4 và nhiều model khác dùng BPE với từ vựng 50-100 nghìn token.

2. Embedding layer

Chuyển token ID thành vector dày đặc (ví dụ 384 chiều). Các token có ý nghĩa gần nhau sẽ gần nhau trong không gian vector.

Ngoài ra còn thêm embedding vị trí giúp mạng nhận biết thứ tự token trong câu.

3. Transformer blocks

Đây là phần tính toán chính, gồm:

• Self-attention: Mỗi token tham chiếu các token khác để đánh giá ảnh hưởng với token kế tiếp. GuppyLM dùng 6 đầu attention với 6 lớp.

• Feed-forward network (FFN): Mạng đa tầng (ví dụ 2 lớp MLP) xử lý kết quả attention tiếp theo. GuppyLM dùng hàm kích hoạt ReLU, còn GPT-4 có thể dùng SwiGLU.

4. Output head

Chuyển output cuối cùng thành vector kích thước vocab, qua softmax thành xác suất. Token có xác suất cao nhất sẽ được chọn hoặc lấy mẫu để tạo ra chuỗi đầu ra.

Ví dụ xây dựng LLM tối giản với Python và PyTorch

Dưới đây là ví dụ rút gọn tham khảo GuppyLM, chỉ khoảng 120 triệu tham số với đầy đủ thành phần cơ bản.

import torch
import torch.nn as nn
import torch.nn.functional as F

# Hyperparameters
VOCAB_SIZE = 256     # mức ký tự ASCII
D_MODEL = 128        # chiều embedding
N_HEADS = 4          # số đầu attention
N_LAYERS = 3         # số lớp Transformer
SEQ_LEN = 64         # chiều dài context window
DROPOUT = 0.1

class SelfAttention(nn.Module):
    def __init__(self, d_model, n_heads):
        super().__init__()
        self.n_heads = n_heads
        self.head_dim = d_model // n_heads
        self.qkv = nn.Linear(d_model, 3 * d_model, bias=False)
        self.proj = nn.Linear(d_model, d_model, bias=False)
        self.dropout = nn.Dropout(DROPOUT)

    def forward(self, x):
        B, T, C = x.shape
        qkv = self.qkv(x).reshape(B, T, 3, self.n_heads, self.head_dim)
        q, k, v = qkv.unbind(dim=2)
        q, k, v = q.transpose(1, 2), k.transpose(1, 2), v.transpose(1, 2)

        scale = self.head_dim ** -0.5
        attn = (q @ k.transpose(-2, -1)) * scale
        mask = torch.triu(torch.ones(T, T, device=x.device), diagonal=1).bool()
        attn = attn.masked_fill(mask, float('-inf'))
        attn = F.softmax(attn, dim=-1)
        attn = self.dropout(attn)
        out = (attn @ v).transpose(1, 2).reshape(B, T, C)
        return self.proj(out)

class TransformerBlock(nn.Module):
    def __init__(self, d_model, n_heads):
        super().__init__()
        self.attn = SelfAttention(d_model, n_heads)
        self.ff = nn.Sequential(
            nn.Linear(d_model, 4 * d_model),
            nn.ReLU(),
            nn.Linear(4 * d_model, d_model),
            nn.Dropout(DROPOUT),
        )
        self.ln1 = nn.LayerNorm(d_model)
        self.ln2 = nn.LayerNorm(d_model)

    def forward(self, x):
        x = x + self.attn(self.ln1(x))
        x = x + self.ff(self.ln2(x))
        return x

class TinyLLM(nn.Module):
    def __init__(self):
        super().__init__()
        self.embed = nn.Embedding(VOCAB_SIZE, D_MODEL)
        self.pos_embed = nn.Embedding(SEQ_LEN, D_MODEL)
        self.blocks = nn.ModuleList([TransformerBlock(D_MODEL, N_HEADS) for _ in range(N_LAYERS)])
        self.ln_f = nn.LayerNorm(D_MODEL)
        self.head = nn.Linear(D_MODEL, VOCAB_SIZE, bias=False)

    def forward(self, idx):
        B, T = idx.shape
        tok_emb = self.embed(idx)
        pos = torch.arange(T, device=idx.device)
        pos_emb = self.pos_embed(pos)
        x = tok_emb + pos_emb
        for block in self.blocks:
            x = block(x)
        x = self.ln_f(x)
        logits = self.head(x)
        return logits

model = TinyLLM()
total_params = sum(p.numel() for p in model.parameters())
print(f"Model size: {total_params:,} parameters")  # khoảng 1.2M tham số

Bên cạnh đó, bạn có thể viết vòng huấn luyện (training loop) và hàm sinh văn bản (inference/generation) đơn giản để thử nghiệm.

Bài học từ kinh nghiệm xây dựng LLM về cách thức hoạt động API

• Temperature và sampling: Tham số temperature điều chỉnh độ ngẫu nhiên đầu ra qua softmax. Các API thường không dùng argmax tuyệt đối ngay cả khi temperature=0 để tránh kết quả lặp lại.

• Context window rất giới hạn: Mạng chỉ dựa vào số token trong cửa sổ context quy định, token ngoài phạm vi này bị loại bỏ hoàn toàn, do vậy API không thể "nhớ" toàn bộ lịch sử hội thoại mãi mãi.

• Streaming token = trực quan vòng lặp inference: Kiểu API streaming trả token một cách tuần tự giống như mô hình tạo từng token một, nếu bị ngắt quãng thì phải làm lại từ đầu.

• Xử lý output có cấu trúc khó khăn: Ví dụ khi tạo JSON hợp lệ, tất cả token phải đúng cấu trúc. Một số kỹ thuật như Outlines hay Guidance kiểm soát logits để đảm bảo cú pháp.

Kiểm thử tích hợp AI API với Apidog

Apidog cho phép xây dựng kịch bản test tập trung vào API AI, kiểm tra nhiều bước gọi API liên tiếp, đánh giá cấu trúc và nội dung trả về tự động.

• Ví dụ test Streaming Chat API:

  1. Tạo scenario gọi endpoint /v1/chat/completions

  2. Viết các assertion kiểm tra response.choices[0].finish_reason == "stop" và số token không vượt quá giới hạn

  3. Dùng kết quả trả về làm input cho vòng tiếp theo để mô phỏng hội thoại nhiều lượt

  4. Dùng smart mock của Apidog để giả lập các tình huống lỗi như timeout, lỗi bộ lọc nội dung

Ưu điểm là không tiêu tốn credit thật khi test và phát hiện lỗi do khác biệt schema giữa các model API.

{
  "assertions": [
    { "field": "response.usage.completion_tokens", "operator": "less_than", "value": 512 },
    { "field": "response.choices[0].finish_reason", "operator": "equals", "value": "stop" },
    { "field": "response.choices[0].message.content", "operator": "not_empty" }
  ]
}

Ứng dụng nâng cao: lượng tử hóa và tối ưu hóa inference

• Lượng tử hóa (Quantization): Từ trọng số float32 có thể chuyển sang 8-bit hoặc 4-bit integer giúp giảm bộ nhớ 4-8 lần với độ suy giảm chất lượng nhỏ. Ví dụ PyTorch có hỗ trợ động INT8.

• KV Cache: Khi sinh token liên tục, thay vì tính toán lại attention toàn bộ chuỗi, cache store key/value cho các token trước giúp giảm đáng kể độ trễ ở token thứ hai trở đi.

Khi nào nên dùng LLM nhỏ, khi nào dùng API sản phẩm?

Use Case	LLM nhỏ	API sản phẩm
Học hỏi cấu trúc model	Tối ưu	Quá tải
Prototyping ứng dụng mới	chất lượng chưa đủ tốt	Tối ưu
Dữ liệu riêng tư	Lựa chọn tốt	Phụ thuộc nhà cung cấp
Triển khai offline/edge	Có thể	Không khả thi
Ưu tiên chi phí lớn	Có thể nhưng phải đánh đổi	Đắt đỏ khi mở rộng
Nhiều inference liên tục	Không khả thi	Bắt buộc

Phần lớn nhà phát triển nên kết hợp dùng API chính thức để đạt hiệu năng/độ chính xác, cùng vận hành mô hình nhỏ để hiểu sâu và debug.

Kết luận

Bạn có thể xây dựng một LLM nhỏ chỉ trong vài ngày cuối tuần. Giá trị nằm ở việc hình thành mô hình tư duy về cách hoạt động của LLM từ GuppyLM đến GPT-4o, chứ không phải chất lượng mô hình. Kiến thức này cực kỳ hữu ích cho debug tích hợp, điều chỉnh tham số sampling, và thiết kế test API AI.

Dự án GuppyLM là điểm khởi đầu tuyệt vời: clone code, train với dữ liệu của bạn, và quan sát inference hoạt động để đổi mới cách bạn tích hợp API LLM trong thực tế.

Hãy tận dụng các kịch bản test của Apidog để xây dựng quy trình test AI API chặt chẽ như các hệ thống backend khác.

Câu hỏi thường gặp

• Mô hình nhỏ cần bao nhiêu tham số để tạo văn bản nhất quán?
  Khoảng 10-50 triệu tham số với dữ liệu chất lượng sẽ tạo được câu ngắn nhất quán. Dưới 1 triệu thì kết quả thường lạ và không rõ nghĩa.

• Có thể chạy LLM nhỏ không GPU không?
  Dưới 100 triệu tham số có thể chạy trên CPU, tuy inference sẽ chậm hơn. Mô hình 1.2 triệu tham số còn có thể chạy nhanh trên CPU laptop.

• Nên dùng dataset gì để train?
  Nên chọn plain text nguồn mở như Project Gutenberg, Wikipedia subcorpora. GuppyLM dùng tập hội thoại từ HuggingFace. Code generation có thể dùng CodeParrot hay The Stack.

• Khác biệt giữa temperature và top-k sampling?
  Temperature điều chỉnh độ ngẫu nhiên tổng thể trong phân phối, top-k lọc ra k token có xác suất cao rồi áp dụng temperature.

• Tại sao LLM hay lặp token?
  Do mô hình “overfit” phân bố token trước đó, gây lặp lại. API có thể dùng tham số như repetition_penalty để giảm tình trạng này.

• Thời gian train LLM nhỏ?
  Mô hình trên có thể train trong khoảng 2 giờ với 1 GPU như RTX 3060; lớn hơn cần multi-GPU và hàng ngày.

• Cách nhanh nhất chuyển mô hình nhỏ sang API?
  Sử dụng llama.cpp chuyển đổi sang định dạng GGUF, chạy llama-server cung cấp API OpenAI-compatible rồi test bằng Apidog.

• LLM lớn xử lý context vượt quá window thế nào?
  Dùng kỹ thuật như mở rộng RoPE positional encoding, attention trượt (sliding window), hoặc Retrieval-Augmented Generation để mở rộng context mà không thay đổi cấu trúc lõi.

---

Hy vọng bài viết cung cấp một cái nhìn toàn diện và thực tiễn cho các kỹ sư Việt Nam muốn hiểu rõ về cách xây dựng và tích hợp LLM từ bên trong lẫn bên ngoài.