Bài 1: LLM là gì? Phân biệt với ML / DL truyền thống

Sau bài học, bạn sẽ:

• Định nghĩa được LLM (Large Language Model) và hiểu "large" cụ thể là bao nhiêu parameter.
• Phân biệt được LLM với ML cổ điển (Series 2) và DL trước Transformer như RNN / LSTM (Series 3).
• Nhớ được công thức "LLM = Transformer Decoder + Scale + Data + Compute".
• Hiểu hai pretraining objective phổ biến: Causal LM (GPT) và Masked LM (BERT).
• Biết khái niệm emergent abilities và vì sao chỉ xuất hiện ở scale lớn.
• Phân biệt được 3 loại kiến trúc: decoder-only, encoder-only, encoder-decoder.
• Liệt kê được các giới hạn quan trọng của LLM: hallucination, knowledge cutoff, tokenizer artifact, bias, cost.
• Xác định được vị trí của LLM trong workflow của một AI Engineer (sử dụng API, fine-tune, RAG, agent).

Bài này là bài mở đầu Series 4: LLM & Generative AI. Bạn đã hoàn tất Series 1 (Math), Series 2 (ML), Series 3 (DL) — phần lớn nội dung dưới đây sẽ tham chiếu trực tiếp đến kiến thức từ ba series đó.

LLM (Large Language Model) là một neural network rất lớn — từ vài tỉ đến hàng nghìn tỉ tham số — được huấn luyện trên một khối lượng văn bản khổng lồ (hàng terabyte text từ web, sách, code, paper) để học phân phối xác suất của ngôn ngữ tự nhiên.

Bài toán cốt lõi LLM giải: cho một chuỗi token \( x_1, x_2, \dots, x_{t-1} \), ước lượng phân phối \( P(x_t \mid x_1, \dots, x_{t-1}) \) trên toàn vocabulary. Đây là language modeling kinh điển — chỉ khác là bây giờ model rất lớn và data rất nhiều.

Vì model học phân phối của text, nên ngoài "dự đoán token kế tiếp" nó còn dùng được cho rất nhiều task khác qua prompting: trả lời câu hỏi, dịch, tóm tắt, viết code, suy luận từng bước. Không phải vì model "biết" làm những việc đó, mà vì những việc đó tồn tại trong text training dưới dạng pattern.

"Generative AI" là từ rộng hơn — bao gồm cả image / audio / video generation. Series này tập trung vào nhánh text (LLM) vì đó là phần mà một AI Engineer thường làm việc trực tiếp nhất.

Không có ngưỡng chính thức để gọi một model là "large", nhưng trong thực tế cộng đồng thường lấy mốc khoảng 1 tỉ parameter trở lên. Dưới ngưỡng đó hay được gọi là SLM (Small Language Model).

Số parameter của một số model tham khảo:

• GPT-2 (OpenAI, 2019): 1.5B parameter — mở màn cho thế hệ "decoder-only scale up".
• GPT-3 (OpenAI, 2020): 175B parameter — lần đầu cho thấy in-context learning ở scale lớn.
• GPT-4 (OpenAI, 2023): không công bố chính thức; ước lượng phổ biến \( \sim 1.7 \)T parameter dạng MoE (Mixture of Experts).
• Claude Opus (Anthropic): không công bố chi tiết số parameter.
• Llama 3.1 405B (Meta, 2024): 405B parameter, open-weight.
• DeepSeek-V3 (DeepSeek, 2024): 671B parameter MoE, ~37B active mỗi token.

Số parameter chỉ là một chiều của "lớn". Hai chiều còn lại quan trọng không kém: kích thước training corpus (Llama 3 train trên ~15T token, DeepSeek-V3 ~14.8T token) và compute (đo bằng FLOPs hoặc GPU-giờ).

Có một quy luật thực nghiệm gọi là scaling laws (Kaplan 2020, Hoffmann 2022) cho thấy loss giảm theo hàm power-law khi tăng đồng thời cả parameter, data, và compute. Đây là lý do thị trường liên tục train model lớn hơn.

Series 2 (ML cổ điển) làm việc theo công thức:

1. Thu thập dataset có label.
2. Làm feature engineering thủ công: TF-IDF, n-gram, one-hot, hand-crafted feature.
3. Train một shallow model: logistic regression, SVM, random forest, gradient boosting.
4. Mỗi task tách rời và cần một model riêng.

LLM đảo ngược cả ba bước:

1. Không cần label thủ công trong pretraining — dùng self-supervised (xem Bước 7).
2. Không feature engineering — model học representation trực tiếp từ raw text qua embedding + attention.
3. Một model nhiều task — cùng một LLM làm phân loại, dịch, tóm tắt, code, QA thông qua prompt.

Đánh đổi: ML cổ điển vẫn vượt LLM ở các task có data ít, feature rõ ràng, yêu cầu interpretable cao, hoặc cần latency cực thấp (ví dụ fraud detection real-time, churn prediction trên tabular data). Đây cũng là lý do ML cổ điển vẫn còn rất nhiều ở các vị trí thực tế.

LLM chỉ "đáng dùng" khi: (1) đầu vào là text / dạng tự do, (2) task khó mô tả bằng feature, (3) chấp nhận được chi phí gọi API hoặc chạy GPU.

Series 3 đã đi qua RNN và LSTM — kiến trúc chuẩn cho NLP giai đoạn 2014-2017. Hai vấn đề cốt lõi của RNN / LSTM khiến chúng không thể scale lên thành LLM:

• Tuần tự: tính \( h_t \) phải đợi xong \( h_{t-1} \) — không tận dụng được GPU song song.
• Vanishing gradient: với chuỗi dài hàng nghìn token, gradient suy giảm về 0 trước khi propagate ngược tới đầu chuỗi. LSTM giảm nhẹ nhưng không khắc phục hoàn toàn.

Transformer (Vaswani et al., 2017) thay thế recurrence bằng self-attention: mỗi token nhìn trực tiếp tới mọi token còn lại trong context cùng một lúc. Hệ quả:

• Tất cả token tính song song trong cùng một forward pass — phù hợp GPU.
• Khoảng cách giữa hai token bất kỳ là \( O(1) \) bước (so với \( O(n) \) ở RNN) → information không bị "rơi" trên đường dài.
• Scale tốt: gần như tuyến tính theo số GPU thêm vào, miễn là batch size và memory đủ.

Đây là điều kiện cần để xuất hiện LLM. Mọi LLM modern (GPT, Claude, Llama, DeepSeek, Gemini, Mistral...) đều là biến thể của Transformer. Module 2 của series sẽ mổ xẻ chi tiết kiến trúc này; ở đây chỉ cần nhớ: Transformer = kiến trúc nền tảng, không có Transformer thì không có LLM.

Một cách rút gọn để nhớ:

\[ \text{LLM} = \text{Transformer Decoder} + \text{Scale} + \text{Data} + \text{Compute} \]

Bốn thành phần ấy:

• Architecture: Transformer (chi tiết trong Module 2). Phần lớn LLM hiện đại dùng biến thể decoder-only cho generation.
• Scale: hàng tỉ đến hàng nghìn tỉ parameter.
• Data: hàng terabyte text — crawl web (Common Crawl), sách, Wikipedia, code (GitHub), paper khoa học, dialog.
• Compute: hàng triệu GPU-giờ trên cluster A100 / H100 / TPU. Ước lượng public: GPT-4 vào khoảng \( 2 \times 10^{25} \) FLOPs, Llama 3 405B khoảng \( 3.8 \times 10^{25} \) FLOPs.

Thiếu bất kỳ thành phần nào, model sẽ không có khả năng emerge (Bước 8). Đây cũng là lý do chỉ một số ít tổ chức (OpenAI, Anthropic, Google, Meta, DeepSeek, xAI, Mistral, Qwen) có khả năng train LLM frontier từ đầu — chi phí pretraining một model 100B+ rơi vào hàng chục triệu đến hàng trăm triệu USD.

Pretraining là giai đoạn train tốn nhất — model "đọc" hàng terabyte text để học phân phối ngôn ngữ. Có hai objective phổ biến:

Causal Language Modeling (CLM) — dòng GPT, Claude, Llama:

\[ \mathcal{L}_{\text{CLM}} = - \sum_{t=1}^{T} \log P(x_t \mid x_1, \dots, x_{t-1}) \]

Model nhìn các token trước và dự đoán token kế tiếp. Đây là autoregressive — khi inference, model sinh từng token một, dùng output làm input cho bước sau.

Masked Language Modeling (MLM) — dòng BERT:

Một số token (~15%) bị thay bằng [MASK]; model học dự đoán token gốc. Khác CLM ở chỗ MLM nhìn được cả trái lẫn phải của vị trí mask — phù hợp cho representation learning, không phải cho generation.

Cả hai đều self-supervised: label được tạo trực tiếp từ chính text (token kế tiếp / token bị mask), không cần con người ghi nhãn thủ công. Đây là lý do duy nhất khiến LLM có thể tận dụng nguyên cả internet làm training data.

Sau pretraining còn các giai đoạn khác (instruction tuning, RLHF) — sẽ đi chi tiết ở Module 8.

Một hiện tượng quan sát được khi model lớn lên: một số khả năng không xuất hiện ở model nhỏ, không tăng dần theo scale, mà nhảy lên ở một ngưỡng nhất định. Wei et al. 2022 gọi đây là emergent abilities of large language models.

Các khả năng emerge phổ biến:

• In-context learning (few-shot): cho vài ví dụ trong prompt, model làm được task mới mà không cần fine-tune. Xuất hiện rõ từ GPT-3 (175B).
• Chain-of-thought reasoning: khi yêu cầu model suy luận từng bước, độ chính xác trên task math / logic tăng đáng kể — chỉ ở model đủ lớn.
• Instruction following: hiểu và làm theo chỉ dẫn dạng ngôn ngữ tự nhiên (cần thêm instruction tuning để rõ rệt).

Lưu ý: "emergence" là một khái niệm thực nghiệm đang gây tranh cãi. Schaeffer et al. 2023 lập luận rằng nhiều "emergence" thực chất là artifact của metric (discrete metrics nhảy bậc, trong khi loss giảm liên tục). Trong thực tế kỹ thuật, bạn cần biết: một số khả năng chỉ có ở model lớn — chứ chưa cần đào sâu vào lý thuyết.

Mốc chính (mỗi năm chỉ chọn vài model có ảnh hưởng đến hệ sinh thái hiện tại):

• 2017: Attention is All You Need (Vaswani et al.) — Transformer.
• 2018: BERT (Google) — encoder-only; GPT-1 (OpenAI) — decoder-only.
• 2019: GPT-2 (1.5B) — scale tăng nhưng OpenAI ban đầu hạn chế release vì "lo ngại misuse".
• 2020: GPT-3 (175B) — bước nhảy scale đáng kể; in-context learning rõ rệt.
• 2022: ChatGPT — GPT-3.5 + RLHF + dialog interface, đưa LLM tới end-user.
• 2023: GPT-4, Claude (Anthropic), Llama 2 (Meta, open-weight), Mistral 7B.
• 2024: Llama 3 / 3.1, Claude 3 series, GPT-4o (multimodal), Gemini 1.5, DeepSeek-V3, Qwen 2.
• 2025-2026: dòng reasoning models tách riêng — o1 / o3 (OpenAI), DeepSeek-R1, Claude 3.7 Sonnet (reasoning mode); multimodal trở thành mặc định; framework agents trưởng thành.

Quan sát chung: chu kỳ release model mới rút ngắn dần (vài tháng / lần thay vì hàng năm), khoảng cách giữa closed-source và open-source thu hẹp; chi phí cho mỗi 1M token giảm liên tục (GPT-3.5 năm 2022 đắt hơn GPT-4o-mini năm 2024 vài chục lần).

Phân loại theo kiến trúc Transformer (xem Module 2):

• Decoder-only (autoregressive): GPT, Claude, Llama, Mistral, DeepSeek, Qwen, Gemini. Mạnh ở generation: chat, code, viết bài. Là dòng chiếm đa số trong thị trường LLM API hiện nay.
• Encoder-only (bidirectional): BERT, RoBERTa, DeBERTa. Mạnh ở representation — sinh embedding cho classification, NER, similarity search. Hay được dùng trong vector database, retrieval, ranking.
• Encoder-Decoder (seq2seq): T5, BART, mT5. Phù hợp các task có cấu trúc input → output rõ ràng như translation, summarization. Ít phổ biến hơn ở scale lớn.

Trong Series 4, mặc định khi nói "LLM" tức là decoder-only. Khi cần tới encoder-only (Module 6 — RAG, embedding) thì sẽ nói rõ.

Các nhóm sản phẩm dùng LLM phổ biến trong industry hiện nay:

• Chatbot / assistant: ChatGPT, Claude, Gemini, Copilot dạng tổng quát.
• Code generation: GitHub Copilot, Cursor, Claude Code, Windsurf — autocomplete, refactor, sinh test.
• Search / RAG: Perplexity, You.com, Notion AI, GitHub Search — kết hợp LLM với retrieval trên kho dữ liệu nội bộ.
• Translation: DeepL (vẫn dùng NMT chuyên biệt), nhưng Google Translate, GPT, Claude cũng cạnh tranh được ở các cặp ngôn ngữ có data dồi dào.
• Content writing: trợ lý viết blog, social, email marketing.
• Customer support: trả lời tier-1 ticket, phân loại intent, tóm tắt lịch sử hội thoại.
• Agent / automation: LLM gọi tool, browse, thao tác file / shell — đang là hướng phát triển nóng 2024-2026.

Không phải task nào cũng phù hợp LLM. Các bài toán có structured data (fraud detection, credit scoring, demand forecasting) thường dùng gradient boosting (XGBoost, LightGBM) hiệu quả hơn cả về accuracy lẫn cost.

Hai nhóm chính:

• Closed-source (API only): OpenAI (GPT-4o, o-series), Anthropic (Claude), Google (Gemini), xAI (Grok). Không công bố weight; người dùng truy cập qua API.
• Open-weight: Llama (Meta), Mistral, Qwen (Alibaba), DeepSeek, Phi (Microsoft), Gemma (Google). Tải weight về tự host.

Lưu ý thuật ngữ: "open-weight" khác "open-source" theo nghĩa nghiêm. Phần lớn các model gọi là "open" hiện nay chỉ release weight + license cho phép dùng — code training và dataset thường vẫn đóng.

Trade-off khi chọn:

• Quality: closed-source frontier hiện vẫn nhỉnh hơn ở các benchmark khó (MMLU-Pro, GPQA, math olympiad). Khoảng cách thu hẹp, không còn lớn như 2023.
• Cost: API trả theo token; self-host trả theo GPU-giờ. Self-host rẻ hơn khi load cao và ổn định; đắt hơn khi load thấp.
• Privacy / compliance: dữ liệu nhạy cảm (y tế, tài chính, nội bộ doanh nghiệp) hay yêu cầu self-host để không gửi ra ngoài.
• Customization: open-weight cho phép fine-tune sâu, swap tokenizer, sửa kiến trúc. Closed-source chỉ cho fine-tune giới hạn qua API.
• Latency / availability: self-host có thể tối ưu latency cho region cụ thể, không phụ thuộc vào uptime của vendor.

Phần quan trọng nhất khi bắt đầu làm việc với LLM — biết rõ những gì LLM không làm được:

• Hallucination: model sinh ra fact không tồn tại nhưng trình bày rất tự tin (sai tên, sai số liệu, citation giả). Hệ quả trực tiếp của objective "predict next token" — model học sinh ra chuỗi nghe có vẻ đúng, không học cơ chế xác minh sự thật. Module 9 sẽ đi vào cách đo và giảm hallucination.
• Knowledge cutoff: model chỉ biết dữ liệu đến thời điểm pretraining kết thúc. Sự kiện sau cutoff phải lấy từ tool external (search, RAG).
• Tokenizer artifact: vì LLM nhìn token chứ không nhìn từng ký tự, các task ở tầng character (đếm chữ cái, đảo ngược chuỗi, ghép vần) hay sai. Module 1 (Bài 2-5) sẽ làm rõ.
• Reasoning có giới hạn: model không hiểu theo nghĩa con người. Nó match pattern rất tốt và có thể chain-of-thought nhưng dễ bại trên các bài toán cần nhiều bước logic chính xác, đặc biệt khi dữ liệu kiểu đó hiếm trong pretraining.
• Bias: training data từ internet kéo theo thiên kiến giới, chủng tộc, văn hoá, chính trị. Một số đã được làm giảm qua RLHF nhưng không thể loại bỏ hoàn toàn.
• Cost: API tính theo token, gọi nhiều thì tốn. Self-host cần GPU memory đáng kể (Llama 70B fp16 cần \( \sim 140 \)GB).
• Context window: dù đã rất lớn (Claude / Gemini hỗ trợ \( \ge 1 \)M token), context vẫn hữu hạn. Tài liệu rất lớn vẫn cần RAG hoặc chunking.

Một AI Engineer trưởng thành là người biết khi nào không dùng LLM, hoặc biết kết hợp LLM với phương pháp khác (retrieval, rule, code execution, ML truyền thống) để bù những giới hạn này.

Ranh giới giữa nghiên cứu (research) và kỹ thuật (engineering) trên LLM khá rõ:

• Researcher ở các lab lớn (OpenAI, Anthropic, DeepMind, Meta FAIR, DeepSeek...) — train LLM từ đầu, thiết kế kiến trúc, alignment.
• AI Engineer — phần lớn người học lộ trình này — không train LLM từ đầu. Họ dùng LLM đã có để giải bài toán cụ thể.

Bốn nhóm thao tác chính của một AI Engineer với LLM:

1. Sử dụng qua API hoặc local — gọi OpenAI / Anthropic / Gemini, hoặc chạy Llama / Mistral / Qwen self-host. Đây là 80% công việc.
2. Prompt engineering — viết prompt, system instruction, few-shot example để model làm đúng task. Module 4.
3. RAG — gắn knowledge ngoài vào prompt bằng retrieval. Module 6 (Bài 35-41).
4. Fine-tuning — chỉnh model nhỏ (LoRA, QLoRA) cho task chuyên biệt khi prompt + RAG chưa đủ. Module 8 (Bài 47-53).
5. Agent / tool use — cho LLM gọi function / tool để thao tác ngoài. Module 7 (Bài 42-46).

Train LLM từ đầu nằm ngoài scope thực tế của AI Engineer (chi phí, infra, data). Series này chỉ giải thích nó ở mức cần để debug và quyết định kiến trúc — không hướng dẫn pretraining.

Series 4 chia thành 9 module, tổng cộng 59 bài:

• Module 1 — Foundation LLM (Bài 1-7): token, BPE, vocabulary, embedding, context window.
• Module 2 — Transformer (Bài 8-14): attention, self-attention, multi-head, positional encoding, decoder-only / encoder-only / encoder-decoder.
• Module 3 — Hugging Face (Bài 15-20): Hub, Transformers library, Pipeline, AutoModel, chạy SLM trên máy cá nhân.
• Module 4 — Prompt Engineering (Bài 21-30): System / User / Assistant, zero-shot, few-shot, CoT, structured output, sampling.
• Module 5 — API & Apps (Bài 31-34): OpenAI API, Anthropic Claude API, streaming, cost optimization.
• Module 6 — RAG (Bài 35-41): embedding model, vector DB, chunking, retrieval, re-ranking, QA trên PDF.
• Module 7 — Function Calling (Bài 42-46): tool schema, workflow, parallel / sequential, error handling.
• Module 8 — Fine-tuning (Bài 47-53): LoRA, QLoRA, instruction tuning, RLHF / DPO intuition.
• Module 9 — Evaluation (Bài 54-59): BLEU / ROUGE / BERTScore, LLM-as-Judge, RAG eval, benchmark.

Bài kế tiếp (Bài 2: Tokenization) đi sâu vào lý do LLM chia text thành token và tokenizer hoạt động ra sao.

Một LLM call đầu tiên qua Anthropic SDK — 5 dòng:

from anthropic import Anthropic

client = Anthropic()
msg = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Giải thích LLM trong 2 câu."}],
)
print(msg.content[0].text)

Yêu cầu: cài SDK pip install anthropic và đặt biến môi trường ANTHROPIC_API_KEY. SDK đọc key từ env tự động — không cần truyền tay.

Tương đương phía OpenAI:

from openai import OpenAI

client = OpenAI()
resp = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "Giải thích LLM trong 2 câu."}],
)
print(resp.choices[0].message.content)

Chi tiết về API, message format, streaming, cost — sẽ ở Module 5 (Bài 31-34). Mục đích đoạn code ở đây chỉ để bạn thấy: gọi LLM không phức tạp về mặt code; phần khó là biết khi nào dùng và prompt thế nào.

Series 4 dạy cách build ứng dụng LLM. Series 5 (System Deployment / MLOps) dạy cách đưa ứng dụng đó lên production: serving (vLLM, TGI, Triton), monitoring, scaling, cost tracking, A/B test, failover, observability.

Hai series này bổ sung trực tiếp cho nhau — phần lớn AI Engineer trong industry phải làm cả hai phần. Series 6 (Projects & Job) sẽ tổng hợp lại thành capstone project và hướng dẫn portfolio / phỏng vấn.

Bài 1 — Phân loại task. Với 5 task dưới đây, xác định task nào nên dùng LLM, task nào nên dùng ML cổ điển hoặc DL chuyên biệt. Giải thích ngắn:

1. Dịch một đoạn văn bản tiếng Anh sang tiếng Việt.
2. Phân loại sentiment (positive / negative / neutral) cho 1 triệu review sản phẩm mỗi ngày.
3. Sinh code Python từ mô tả tự nhiên.
4. Phát hiện giao dịch gian lận trong hệ thống thanh toán real-time (latency < 50ms).
5. Phân loại ảnh sản phẩm vào 1000 danh mục e-commerce.

Bài 2 — Open vs Closed. Lập bảng so sánh ưu / nhược điểm của closed-source LLM (ví dụ Claude API) và open-weight LLM (ví dụ Llama 3.1 70B self-host) trên 5 tiêu chí: quality, cost, privacy, customization, latency. Mỗi tiêu chí 1-2 dòng.

Bài 3 — Estimate cost. Bạn build một chatbot tiếng Việt, mỗi tháng phục vụ 200,000 lượt chat. Trung bình mỗi lượt:

• Input: 800 token (system prompt + history).
• Output: 300 token.

Giá tham khảo GPT-4o-mini: $0.15 / 1M input token, $0.60 / 1M output token. Tính tổng chi phí API ước tính cho 1 tháng. Sau đó tính lại nếu chuyển sang model có giá $3 / 1M input và $15 / 1M output (xấp xỉ tier cao hơn). Bao nhiêu lần đắt hơn?

• LLM là neural network rất lớn (tỉ đến nghìn tỉ parameter) train trên hàng terabyte text bằng self-supervised objective.
• "LLM = Transformer Decoder + Scale + Data + Compute". Không Transformer thì không có LLM.
• Khác ML cổ điển: không feature engineering, không một-model-một-task; khác DL trước Transformer: song song được, không vanishing gradient trên chuỗi dài.
• Hai pretraining objective chính: Causal LM (GPT, Claude, Llama) và Masked LM (BERT). Cả hai đều self-supervised.
• Một số khả năng (in-context learning, CoT, instruction following) chỉ emerge khi scale đủ lớn — vẫn là khái niệm thực nghiệm còn tranh cãi.
• 3 loại kiến trúc: decoder-only (chat, code), encoder-only (embedding, classification), encoder-decoder (translation, summarization).
• Giới hạn cần nhớ: hallucination, knowledge cutoff, tokenizer artifact, reasoning có giới hạn, bias, cost, context finite.
• AI Engineer phần lớn dùng LLM (API / self-host), prompt, RAG, fine-tune, agent — không train từ đầu.
• Series 4 gồm 9 module, 59 bài; bài kế tiếp đi vào tokenization.