Bài 19: Chạy SLM (Small Language Model) trên máy cá nhân

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

• Hiểu định nghĩa SLM, ranh giới phân biệt với LLM lớn, và lý do nó tồn tại.
• Biết 5 lý do chọn chạy local (privacy, cost, latency, offline, customization) và trade-off đi kèm.
• Nhớ tên + size của top SLM open weight 2024-2026: Llama 3.2, Qwen 2.5, Phi-3 / Phi-4, Gemma 2 / 3, Mistral.
• Ước lượng được RAM / VRAM cần cho model 1B-14B ở FP16 và Q4.
• Phân biệt 3 cách chạy: transformers (Python, control cao), Ollama (CLI, beginner-friendly), llama.cpp (C++, efficient nhất).
• Hiểu GGUF format và các mức quantization Q4 / Q5 / Q8, biết khi nào nên dùng mức nào.
• Biết Apple Silicon dùng Metal Performance Shaders để inference SLM nhanh.
• Biết khi nào nên dừng chạy local và chuyển sang cloud API.

SLM (Small Language Model) là LLM ở quy mô nhỏ, đủ để chạy trên hardware tiêu dùng. Không có định nghĩa chính thức nào về ngưỡng "nhỏ", quy ước phổ biến trong cộng đồng 2024-2026:

• Dưới 10B tham số: SLM.
• 10B-70B: mid-size LLM (chạy được trên 1 GPU consumer cao cấp khi quantize).
• Trên 70B: large LLM (cần multi-GPU server hoặc cloud).

Trước 2023, model dưới 10B thường yếu rõ rệt. Từ Llama 2 7B (2023), Mistral 7B (2023) và đặc biệt Phi-3 (2024) trở đi, SLM bắt đầu đạt chất lượng "đủ dùng" cho nhiều task ứng dụng — nhờ training data sạch hơn, kỹ thuật distillation và synthetic data.

Khái niệm SLM chính thức được Microsoft phổ biến qua paper Phi-3 ("Phi-3 Technical Report", arXiv:2404.14219, 2024) và sau đó qua dòng Phi-4. Meta dùng tên gọi tương tự với Llama 3.2 1B / 3B (2024).

Năm lý do điển hình để chọn SLM local thay vì gọi API:

• Privacy: data không rời máy người dùng. Quan trọng cho dữ liệu y tế, pháp lý, nội bộ doanh nghiệp, hoặc khi tuân thủ GDPR / HIPAA.
• Cost: chỉ trả tiền điện sau khi setup. Không có phí per-token. Phù hợp use case lưu lượng cao kéo dài (vd index hàng triệu document).
• Latency: không round-trip qua mạng. Trên GPU hoặc Apple Silicon, latency có thể thấp hơn API đáng kể, đặc biệt với prompt ngắn.
• Offline: hoạt động không cần internet. Quan trọng cho edge device, on-device assistant, máy cá nhân khi đi lại.
• Customization: full control mọi tham số (temperature, top-p, sampling, logit bias), fine-tune được, swap model bất cứ lúc nào.

• Quality: SLM 1B-7B kém GPT-4 / Claude trên phần lớn task đòi hỏi reasoning sâu, kiến thức rộng hoặc code phức tạp. Khoảng cách hẹp lại với task đơn giản (paraphrase, classification, extraction).
• Hardware: cần GPU rời, Apple Silicon, hoặc CPU mạnh + đủ RAM. Một số laptop văn phòng cũ không chạy nổi 7B model.
• Setup: phải cài driver, tool, model. Không "plug and play" như API.
• Maintain: tự lo update model, security patch, monitor, scale khi traffic tăng.
• Hệ sinh thái: thiếu một số tính năng built-in của API thương mại (tool calling chuẩn, safety filter, multimodal nâng cao).

Quyết định local hay API thường dựa vào tổng hợp: data có nhạy cảm không, lưu lượng bao nhiêu, chất lượng cần đến đâu, có hardware sẵn không.

Các series open weight phổ biến cho chạy local (sắp xếp theo nhà phát hành):

• Llama 3.2 1B / 3B (Meta, 2024) — bản nhỏ của Llama 3, optimize cho mobile / edge.
• Qwen 2.5 0.5B / 1.5B / 3B / 7B (Alibaba, 2024-2025) — đa ngôn ngữ tốt, license Apache 2.0 cho phần lớn checkpoint, hỗ trợ tiếng Việt.
• Phi-3 mini 3.8B, Phi-4 14B (Microsoft, 2024) — đặc trưng: train trên synthetic data cao chất lượng, hiệu năng / size tốt.
• Gemma 2 2B / 9B, Gemma 3 (Google, 2024-2025) — open weights, license Gemma riêng.
• Mistral 7B (2023) — kinh điển, Apache 2.0. Mistral Nemo 12B (2024) — bản mới hơn, context dài.
• DeepSeek-V3, R1 (DeepSeek) — bản đầy đủ là MoE rất lớn (>600B param tổng, ~37B kích hoạt), không thuộc nhóm SLM; nhưng họ có một số bản nhỏ và distilled (vd R1 distill 1.5B / 7B / 14B) chạy được local.

Chọn bản nào tuỳ task: tiếng Việt → ưu tiên Qwen 2.5; reasoning + math nhỏ → Phi-4; mobile-first → Llama 3.2 1B; general balanced → Llama 3.1 8B Instruct hoặc Mistral 7B. Đọc model card và benchmark riêng trước khi chốt.

Ước lượng thô (rough — phụ thuộc framework, batch size, context length):

• 1-2B model: ~4GB RAM (CPU) hoặc ~4GB VRAM (FP16). Q4 chỉ cần ~1-2GB.
• 3-4B model: ~8GB RAM, ~8GB VRAM (FP16). Q4 chỉ ~3GB.
• 7-8B model: ~16GB RAM, ~16GB VRAM (FP16). Q4 chỉ ~6GB — chạy được trên GPU consumer 8GB hoặc Apple Silicon 16GB.
• 14B model (vd Phi-4, Mistral Nemo 12B): ~32GB RAM, ~24GB VRAM (FP16). Q4 chỉ ~12GB.

Trên Apple Silicon, RAM là unified memory dùng chung CPU/GPU, nên dung lượng RAM = giới hạn model. Trên PC + GPU rời, VRAM là yếu tố quyết định khi inference trên GPU; nếu thiếu, có thể offload một phần layer sang CPU (chậm hơn nhưng vẫn chạy).

Ba lựa chọn phổ biến, mỗi cái phù hợp một use case:

• Hugging Face transformers — Python, control cao, dễ tích hợp pipeline ML. Tốt nhất cho researcher, fine-tune, viết code Python.
• Ollama — CLI + HTTP server, beginner-friendly, một lệnh là chạy. Tốt nhất cho người mới, prototype nhanh, dev tích hợp app.
• llama.cpp — C++ engine, hiệu năng cao nhất trên CPU + Apple Silicon. Tốt nhất khi đẩy hiệu suất, deploy embedded, hoặc nền tảng cho Ollama / LM Studio (cả hai dùng llama.cpp bên dưới).

Ba mục tiếp theo trình bày từng cách kèm code minimal.

Recap nhanh từ Bài 16 / 18 — load Qwen 2.5 1.5B Instruct và sinh câu trả lời:

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

model_id = "Qwen/Qwen2.5-1.5B-Instruct"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,
    device_map="auto",
)

messages = [{"role": "user", "content": "Xin chào, bạn là ai?"}]
text = tokenizer.apply_chat_template(
    messages, tokenize=False, add_generation_prompt=True,
)
inputs = tokenizer(text, return_tensors="pt").to(model.device)

outputs = model.generate(**inputs, max_new_tokens=200)
reply = tokenizer.decode(
    outputs[0][inputs.input_ids.shape[1]:], skip_special_tokens=True,
)
print(reply)

device_map="auto" tự chọn GPU / MPS (Apple) / CPU theo thứ tự ưu tiên. bfloat16 tiết kiệm một nửa bộ nhớ so với FP32 mà gần như không mất chất lượng trên model hiện đại.

Ollama là tool quản lý + chạy LLM local qua CLI, build trên nền llama.cpp. Cài đặt:

brew install ollama          # macOS

# Hoặc: curl -fsSL https://ollama.com/install.sh | sh   (Linux)
# Hoặc: download installer từ ollama.com (Windows)

ollama serve &              # chạy server nền (port 11434)

Pull model và chat tương tác:

ollama pull llama3.2:1b      # tải model (Q4 mặc định)
ollama run llama3.2:1b       # mở chat CLI

Model registry tại ollama.com/library liệt kê hàng trăm model: qwen2.5, phi3, gemma2, mistral, llama3.1… Mỗi tên có nhiều tag tương ứng size / quantization, ví dụ qwen2.5:7b-instruct-q4_K_M.

Sau khi ollama serve chạy, có HTTP API ở localhost:11434 — gọi từ bất kỳ ngôn ngữ nào.

Gói ollama trên PyPI là client mỏng cho HTTP API:

import ollama

response = ollama.chat(
    model="llama3.2:1b",
    messages=[{"role": "user", "content": "Xin chào!"}],
)
print(response["message"]["content"])

Hỗ trợ streaming bằng stream=True, embed bằng ollama.embeddings(), multimodal (vision) với model như llama3.2-vision. Vì Ollama tương thích OpenAI-style chat completion qua endpoint /v1/chat/completions, bạn có thể dùng client openai trỏ base_url="http://localhost:11434/v1" để swap LLM mà không sửa code app.

llama.cpp (Georgi Gerganov, 2023+) là implementation C/C++ của inference LLM, tối ưu cho CPU và Apple Silicon (Metal). Đặc điểm:

• Không phụ thuộc PyTorch / CUDA cho CPU; trên GPU NVIDIA / AMD / Metal đều có backend riêng.
• Hỗ trợ quantization Q2 đến Q8 (xem mục tiếp).
• Dùng format GGUF chuẩn.
• Engine bên dưới của Ollama, LM Studio, GPT4All, Jan…

Wrapper Python llama-cpp-python:

pip install llama-cpp-python

from llama_cpp import Llama

llm = Llama(
    model_path="qwen2.5-1.5b-instruct-q4_k_m.gguf",
    n_ctx=2048,
    n_gpu_layers=-1,  # -1 = full GPU (Metal / CUDA) nếu build có
)

out = llm.create_chat_completion(
    messages=[{"role": "user", "content": "Xin chào!"}],
    max_tokens=200,
)
print(out["choices"][0]["message"]["content"])

So với Ollama: ít abstraction hơn, code Python control sâu hơn, phù hợp khi nhúng engine vào app desktop / mobile mà không muốn chạy daemon.

Quantization là kỹ thuật giảm độ chính xác trọng số (vd từ 16-bit float xuống 4-bit int) để tiết kiệm bộ nhớ và tăng tốc inference, đổi lại có thể mất chút chất lượng.

• FP16 / BF16: 16-bit, "full precision" theo chuẩn LLM hiện đại. Mất rất ít so với FP32.
• Q8_0: 8-bit, chất lượng gần như FP16, dung lượng giảm 50%.
• Q5_K_M: 5-bit balanced; ít người dùng hơn Q4 và Q8.
• Q4_K_M: 4-bit, mức "vàng" mặc định trên Ollama / llama.cpp — dung lượng nhỏ ~1/4 so với FP16, chất lượng giảm nhẹ (vài % trên benchmark đa số).
• Q3, Q2: 3-bit / 2-bit, rất nén nhưng degrade rõ rệt; chỉ dùng khi bí RAM.

Quy tắc chung 2024-2026: mặc định Q4_K_M; nếu RAM dư dả và muốn chất lượng cao hơn → Q8_0 hoặc FP16; nếu bí RAM mà vẫn phải chạy được → Q3_K_S. Test trên dataset thực tế của bạn để xác nhận chất lượng vẫn chấp nhận được.

GGUF (GPT-Generated Unified Format) là format file chuẩn của llama.cpp từ giữa 2023 (thay cho GGML cũ). Đặc điểm:

• Single file: trọng số + tokenizer + metadata + chat template gói chung. Dễ phân phối, không phải kèm config rời.
• Hỗ trợ nhiều quantization scheme trong cùng cấu trúc.
• Backward compatible — file GGUF cũ vẫn đọc được bằng phiên bản llama.cpp mới hơn.

Trên Hugging Face, một số contributor chuyên publish bản GGUF của model phổ biến: TheBloke (đến đầu 2024), bartowski, mradermacher… Search <model name> GGUF trên Hub.

Convert từ checkpoint Hugging Face sang GGUF: dùng script convert_hf_to_gguf.py trong repo ggerganov/llama.cpp, sau đó quantize bằng tool llama-quantize.

Chip M1 / M2 / M3 / M4 là lựa chọn hợp lý cho chạy SLM local nhờ:

• Unified memory: CPU và GPU chia sẻ RAM, không cần copy data qua bus → giảm bottleneck.
• Metal Performance Shaders (MPS): backend GPU native của Apple, được hỗ trợ trong llama.cpp (Metal backend), PyTorch (torch.backends.mps), MLX.
• Băng thông memory cao ở bản Pro / Max / Ultra — yếu tố quyết định tốc độ inference LLM.

Trên Mac, framework MLX (Apple, 2023) cũng đáng theo dõi — thiết kế dành riêng cho Apple Silicon, có dòng mlx-lm để load và chạy SLM. Performance tương đương hoặc nhanh hơn llama.cpp cho một số model, đặc biệt khi training / fine-tune nhẹ.

vLLM (UC Berkeley, 2023) là inference server dành cho production: high throughput trên GPU server. Khác Ollama / llama.cpp ở chỗ:

• Continuous batching: gộp request đến cùng lúc, xử lý đồng thời thay vì xếp hàng.
• PagedAttention (paper Kwon et al., 2023): quản lý KV cache theo trang, giảm fragmentation và scale token / sec đáng kể.
• API tương thích OpenAI Chat Completions; thay endpoint là dùng được.

vLLM hợp với GPU server và workload nhiều user đồng thời — không phải lựa chọn cho laptop CPU. Series 5 (Deployment) trong lộ trình AI Engineer sẽ deep-dive vLLM, TGI (Text Generation Inference), Triton.

Cho người dùng không quen terminal hoặc cần chat UI sẵn:

• LM Studio — desktop app (Win / Mac / Linux), tìm model GGUF trực tiếp từ Hub, click run, có HTTP server tương thích OpenAI.
• GPT4All (Nomic AI) — desktop app open source, có model catalog cura, hỗ trợ document Q&A đơn giản.
• Jan — desktop app open source (Electron), nhấn mạnh privacy, plugin extension.

Cả ba đều dùng llama.cpp bên dưới. Chọn cái nào tuỳ sở thích UI; khi cần code hoá thì chuyển sang Ollama hoặc llama-cpp-python.

Tốc độ tham khảo (rough, M1 Mac 16GB unified memory, llama.cpp Metal backend, prompt ngắn, batch=1):

• Llama 3.2 1B Q4: ~50 token/s.
• Qwen 2.5 1.5B Q4: ~40 token/s.
• Phi-3 mini 3.8B Q4: ~25 token/s.
• Mistral 7B / Llama 3.1 8B Q4: ~15 token/s.
• Mistral Nemo 12B Q4: ~8 token/s.

Số liệu có thể chênh ±20% tuỳ build llama.cpp, nhiệt độ máy, độ dài context. Mục tiêu: bạn có cảm giác ước lượng — chat 1B-3B feel real-time, 7B feel "chậm hơn ChatGPT một chút", 12B trở lên chậm rõ rệt trên Mac 16GB.

• Cần chất lượng cao: task reasoning sâu, math nâng cao, code lớn — GPT-4 class / Claude class vẫn cách biệt rõ so với SLM 7B.
• Lưu lượng cao trên web: hàng nghìn request / giờ — chạy trên laptop không kham; cần GPU server và vLLM (hoặc dùng API thẳng cho rẻ và đơn giản hơn).
• Không có hardware: laptop 8GB RAM không SSD nhanh — dùng API free / paid sẽ ổn hơn.
• Cần multimodal mạnh: vision / audio chất lượng cao; cloud API thường có lợi thế ở đây.

Một pattern phổ biến 2024-2026 là kết hợp local + cloud:

• Task đơn giản (paraphrase, classify, extract field): SLM local, miễn phí, nhanh.
• Task phức tạp (reasoning, multi-step, code lớn): chuyển sang cloud LLM.
• Data nhạy cảm: local, không gửi đi.
• Data public: cloud cho chất lượng tốt hơn.

Router pattern: một classifier nhẹ (hoặc rule đơn giản) quyết định request đi local hay cloud. Kết quả: cost giảm rõ, latency cải thiện ở task dễ, vẫn giữ chất lượng cho task khó. Module 7 (Agents) và Series 5 (Deployment) sẽ chạm lại pattern này.

Sau khi chạy được SLM local, bước tiếp theo là gắn UI để dùng / share:

• Streamlit hoặc Gradio: vài chục dòng Python là có chat UI, host được trên HF Spaces.
• Web app: dùng Ollama HTTP API + bất kỳ frontend nào (Next.js, SvelteKit…).
• Desktop: Tauri / Electron gọi llama-cpp-python hoặc Ollama daemon.

Bài này không deep-dive UI; Series 5 (Deployment) có hẳn module cho phần này.

Đoạn dưới gộp 3 cách chạy + đo tốc độ thô để bạn so sánh.

import time
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# === 1) transformers ===
model_id = "Qwen/Qwen2.5-1.5B-Instruct"
tok = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id, torch_dtype=torch.bfloat16, device_map="auto",
)

prompt = "Giải thích ngắn gọn vì sao bầu trời màu xanh."
inputs = tok(prompt, return_tensors="pt").to(model.device)

t0 = time.time()
out = model.generate(**inputs, max_new_tokens=100)
dt = time.time() - t0
n_new = out.shape[1] - inputs.input_ids.shape[1]
print(f"transformers: {n_new / dt:.1f} tok/s on {model.device}")

# === 2) Ollama ===
# Yêu cầu: `ollama serve` đang chạy + `ollama pull llama3.2:1b`
import ollama
t0 = time.time()
resp = ollama.chat(
    model="llama3.2:1b",
    messages=[{"role": "user", "content": prompt}],
    options={"num_predict": 100},
)
dt = time.time() - t0
print(f"ollama (llama3.2:1b): {resp['eval_count'] / dt:.1f} tok/s")

# === 3) llama-cpp-python với GGUF Q4 ===
# pip install llama-cpp-python; tải sẵn file .gguf
from llama_cpp import Llama
llm = Llama(
    model_path="qwen2.5-1.5b-instruct-q4_k_m.gguf",
    n_ctx=2048,
    n_gpu_layers=-1,
)
t0 = time.time()
out = llm.create_chat_completion(
    messages=[{"role": "user", "content": prompt}],
    max_tokens=100,
)
dt = time.time() - t0
n = out["usage"]["completion_tokens"]
print(f"llama.cpp (Q4): {n / dt:.1f} tok/s")

So sánh ba số tok/s sẽ thấy: trên cùng máy, llama.cpp Q4 thường nhanh nhất do model nhỏ + engine tối ưu; transformers + bfloat16 chậm hơn vì model nặng gấp 4 lần và overhead Python lớn hơn.

Bài 1 — Setup Ollama. Cài Ollama theo OS bạn dùng. Pull một model 1B-2B (gợi ý: llama3.2:1b hoặc qwen2.5:1.5b). Mở chat CLI, hỏi 5 câu khác nhau (1 toán đơn giản, 1 fact, 1 viết code, 1 paraphrase tiếng Việt, 1 reasoning). Ghi lại: thời gian phản hồi cảm nhận, chất lượng từng câu (1-5).

Bài 2 — Chạy SLM với transformers. Lặp lại pipeline ở Bước 8 với meta-llama/Llama-3.2-1B-Instruct. Đo tok/s bằng cách chia (token mới sinh) / (thời gian generate). So sánh khi device_map="auto" với "cpu" cố định.

Bài 3 — Tải và chạy 1 file GGUF. Tìm trên Hub một bản GGUF của Qwen 2.5 1.5B Instruct (gợi ý: search "Qwen2.5-1.5B-Instruct GGUF"). Tải bản Q4_K_M. Chạy bằng llama-cpp-python. So sánh tok/s với cách dùng transformers ở Bài 2.

Bài 4 — Q4 vs FP16. Chọn cùng 1 model (vd Phi-3 mini). Tải hai bản: FP16 (qua transformers) và Q4_K_M (qua llama.cpp / Ollama). Cho cùng 5 câu hỏi (1 fact, 1 code, 1 math, 1 paraphrase, 1 reasoning). Note khác biệt chất lượng và tốc độ.

Bài 5 — Hybrid router (optional). Viết một function nhận prompt, nếu có chứa từ khoá "code" hoặc dài hơn 1000 ký tự → chuyển sang OpenAI API (hoặc Anthropic), ngược lại → Ollama local. Log mỗi request đi route nào.

• SLM = LLM dưới ~10B param, đủ nhỏ chạy trên laptop / Apple Silicon. Khái niệm được Microsoft phổ biến qua Phi-3 (2024).
• Năm lý do chạy local: privacy, cost, latency, offline, customization. Trade-off: quality thấp hơn LLM lớn, cần hardware, cần setup, cần maintain.
• Top SLM 2024-2026: Llama 3.2 1B/3B, Qwen 2.5 0.5B-7B, Phi-3 / Phi-4, Gemma 2 / 3, Mistral 7B, Mistral Nemo 12B.
• Hardware rough: 1-2B cần ~4GB; 7-8B cần ~16GB FP16 hoặc ~6GB Q4; 14B cần ~24GB FP16 hoặc ~12GB Q4.
• Ba cách chạy: transformers (Python, control cao), Ollama (CLI, beginner-friendly), llama.cpp (C++, efficient nhất, engine của Ollama / LM Studio).
• Quantization: FP16 / BF16 full precision; Q8_0 gần FP16; Q4_K_M là mặc định cân bằng; Q3 / Q2 degrade rõ.
• GGUF: format chuẩn của llama.cpp; single file gồm weight + tokenizer + chat template. Hub có nhiều contributor publish GGUF (bartowski, mradermacher).
• Apple Silicon: unified memory + Metal + MLX, lựa chọn tốt cho chạy SLM cá nhân.
• vLLM cho production GPU server (continuous batching, PagedAttention); LM Studio / GPT4All / Jan cho user thích GUI.
• Benchmark thô M1 16GB: Llama 3.2 1B Q4 ~50 tok/s, Mistral 7B Q4 ~15 tok/s, Mistral Nemo 12B Q4 ~8 tok/s.
• Không chạy local khi cần chất lượng cao, traffic lớn, không có hardware. Pattern phổ biến: hybrid local + cloud theo độ phức tạp / độ nhạy data.
• Bài 20 chuyển sang thư viện datasets — chuẩn bị data để train hoặc evaluate model.