Fine-tuning mô hình mã nguồn mở Llama 3 phục vụ nghiệp vụ chuyên biệt

Trong làn sóng triển khai Trí tuệ Nhân tạo Tạo sinh (Generative AI) cấp độ doanh nghiệp năm 2026, các mô hình ngôn ngữ lớn mã nguồn mở thuộc họ Meta Llama 3 (Llama 3.1 8B/70B, Llama 3.3 70B-Instruct) và thế hệ kế nhiệm Llama 4 đã trở thành nền tảng tiêu chuẩn để xây dựng trợ lý nghiệp vụ nội bộ nhờ khả năng bảo mật dữ liệu tuyệt đối tại chỗ (On-Premises / Private Cloud). Tuy nhiên, khi đưa mô hình gốc (Base / Instruct Pretrained Checkpoint) vào các bài toán đặc thù như phân tích hợp đồng pháp lý Việt Nam, trích xuất báo cáo tài chính ngân hàng thành cấu trúc JSON/SQL phức tạp hay chẩn đoán y khoa, việc nhồi nhét hàng nghìn token hướng dẫn vào System Prompt không chỉ đẩy độ trễ Time-To-First-Token (TTFT) tăng vọt mà vẫn thường xuyên gặp lỗi sai lệch định dạng hoặc ảo giác (Hallucination).

Giải pháp cốt lõi để khắc phục triệt để giới hạn này là thực hiện fine-tuning mô hình Llama 3 với LoRA và QLoRA nhằm tinh chỉnh trực tiếp trọng số nội tại của mạng nơ-ron theo miền nghiệp vụ chuyên biệt. Bài viết kỹ thuật chuyên sâu này hướng dẫn toàn diện quy trình Parameter-Efficient Fine-Tuning (PEFT) chuẩn Production năm 2026: từ ma trận phân tách ranh giới giữa RAG và Fine-Tuning, giải phẫu toán học LoRA / rsLoRA / DoRA và lượng tử hóa 4-bit NormalFloat (NF4 QLoRA), công thức định lượng bộ nhớ GPU VRAM, thiết kế pipeline dữ liệu với Completion-Only Loss Masking, huấn luyện thực chiến bằng HuggingFace TRL (SFTTrainer & DPOTrainer), tăng tốc hạt nhân Triton với Unsloth / PyTorch torchtune, đến quy trình hợp nhất trọng số safetensors không suy giảm độ chính xác.

---

1. Khi nào Doanh nghiệp cần Fine-Tuning Llama 3 thay vì chỉ dùng Prompt Engineering hoặc RAG?

Sai lầm chiến lược phổ biến nhất của các đội ngũ kỹ thuật khi mới bắt tay vào dự án LLM là dùng sai công cụ cho bài toán: cố gắng dùng Fine-Tuning để dạy mô hình nhớ danh mục giá sản phẩm thay đổi hàng giờ, hoặc ngược lại, cố gắng dùng RAG (Retrieval-Augmented Generation) để ép mô hình tuân thủ một cấu trúc đầu ra DSL/JSON 40 trường phức tạp.

flowchart LR
    RawData["Dữ liệu Nghiệp vụ Thô (Logs, Hợp đồng, Giao dịch)"] --> Scrub["Lọc PII, Khử trùng lặp MinHash & Chuẩn hóa Llama 3 Chat Template"]
    Scrub --> LossMask["Completion-Only Loss Masking (Chỉ tính Gradient trên Assistant Tokens)"]
    LossMask --> QLoRASFT["Huấn luyện SFT với QLoRA 4-bit NF4 + DoRA/rsLoRA + FlashAttention-2"]
    QLoRASFT --> DPOAlign["Căn chỉnh Hành vi bằng DPO / ORPO (Triệt tiêu Hallucination)"]
    DPOAlign --> MergeBF16["Merge Adapter vào Base Model chuẩn BFloat16 (Xuất Sharded Safetensors)"]
    MergeBF16 --> EvalGate["Kiểm định lm-evaluation-harness & Phục vụ trên vLLM / TensorRT-LLM"]

1.1. Ma trận quyết định kỹ thuật: RAG (Bổ sung tri thức động) vs Fine-Tuning (Thay đổi hành vi, định dạng và ngôn ngữ chuyên ngành)

Như chúng ta đã phân tích trong kiến trúc xây dựng ứng dụng AI RAG với Python và LangChain cùng tầng điều phối tích hợp mô hình ngôn ngữ lớn LLM vào sản phẩm với LangChain và LlamaIndex, RAG và Fine-Tuning không hề loại trừ nhau mà giải quyết hai trục trực giao của hệ thống AI doanh nghiệp:

Chiều Đánh giá Kỹ thuật	Prompt Engineering + RAG (Kết hợp Vector Database Milvus/Qdrant)	Fine-Tuning (SFT + DPO với LoRA / QLoRA)	Kiến trúc Lai RAFT (Domain-Adapted Fine-Tuning + RAG)
Mục tiêu cốt lõi	Cung cấp tri thức sự kiện động (External Non-Parametric Knowledge) cập nhật theo thời gian thực.	Thay đổi hành vi nội tại, văn phong chuyên ngành, khả năng suy luận đặc thù và tuân thủ định dạng nghiêm ngặt (Parametric Behavior).	Mô hình hiểu sâu thuật ngữ ngành đồng thời trích xuất chính xác từ tài liệu truy hồi mới nhất.
Độ dài System Prompt lúc Suy luận	Rất dài (1,500 – 4,000 tokens ví dụ Few-Shot + ngữ cảnh truy hồi), gây tốn VRAM KV Cache.	Cực ngắn (50 – 150 tokens): Toàn bộ quy tắc và ví dụ Few-Shot đã được "nén" vào trọng số, giảm 60% – 75% độ trễ Prefill.	Trung bình (chỉ chứa ngữ cảnh tài liệu RAG, không cần kèm hàng chục ví dụ Few-Shot).
Khả năng ép chuẩn JSON Schema / Tool Calling	Dễ bị gãy cấu trúc trên các mô hình nhỏ (8B) khi gặp đầu vào phức tạp.	Đạt độ tin cậy > 99%: Giúp mô hình Llama-3.1-8B đạt chất lượng gọi hàm ngang ngửa mô hình 70B thương mại.	Xuất sắc cả về độ chính xác dữ liệu lẫn cấu trúc JSON đầu ra.
Tần suất cập nhật dữ liệu	Tức thì (chỉ cần cập nhật Vector Index trong vài mili-giây).	Theo chu kỳ phát hành phiên bản mô hình (hàng tuần hoặc hàng tháng).	Tri thức cập nhật tức thì qua RAG; kỹ năng suy luận cập nhật theo chu kỳ Fine-Tuning.

1.2. Giải phẫu kiến trúc Meta Llama 3 (Llama 3.1 / 3.3): GQA, Bộ từ vựng 128K Tiktoken và 7 lớp chiếu tuyến tính

Để cấu hình fine-tuning mô hình Llama 3 với LoRA và QLoRA đạt độ hội tụ cao nhất, kỹ sư ML phải nắm vững 3 thay đổi kiến trúc cốt lõi bên trong khối Transformer của họ mô hình Meta Llama 3 (Llama-3.1-8B-Instruct và Llama-3.3-70B-Instruct):

1. Bộ từ vựng 128,256 tokens dựa trên tiktoken: Khác với Llama 2 chỉ có 32,000 tokens (khiến văn bản tiếng Việt bị băm nhỏ thành rất nhiều byte-fallback tokens), bộ từ vựng 128K của Llama 3 nén văn bản tiếng Việt và mã nguồn hiệu quả hơn đáng kể, đồng thời sử dụng bộ thẻ điều khiển đặc biệt (<|begin_of_text|>, <|start_header_id|>, <|end_header_id|>, <|eot_id|>, <|eom_id|> cho gọi công cụ đa bước).
2. Grouped-Query Attention (GQA) với 8 Key-Value Heads và RoPE theta = 500,000: Cả phiên bản 8B (32 Query Heads) và 70B (64 Query Heads) đều gom nhóm chia sẻ thành 8 Key-Value Heads (num_key_value_heads = 8) và mở rộng tần số cơ sở Rotary Position Embeddings để hỗ trợ cửa sổ ngữ cảnh dài tới 128,000 tokens.
3. Bảy lớp chiếu tuyến tính (7 Linear Projections) trong mỗi tầng Transformer Decoder:
   • Khối Self-Attention gồm 4 ma trận trọng số: q_proj, k_proj, v_proj, và o_proj.
   • Khối mạng truyền thẳng SwiGLU MLP gồm 3 ma trận trọng số: gate_proj, up_proj, và down_proj.
   • Quy tắc thực chiến quan trọng: Các hướng dẫn lỗi thời thường chỉ gắn bộ điều hợp LoRA vào 2 lớp q_proj và v_proj. Nghiên cứu thực nghiệm từ bài báo QLoRA (Dettmers et al.) và tài liệu chuẩn của HuggingFace PEFT chỉ rõ: bắt buộc phải gắn LoRA lên toàn bộ 7 lớp tuyến tính (target_modules="all-linear") — đặc biệt là các lớp SwiGLU gate_proj, up_proj, down_proj nơi lưu trữ phần lớn năng lực biểu diễn ngữ nghĩa miền — để thu hồi 100% độ chính xác tương đương với Full Fine-Tuning!

---

2. Cơ sở Toán học và Định lượng VRAM: Full Fine-Tuning vs LoRA, QLoRA và DoRA

Tại sao chúng ta không thể chạy Full Fine-Tuning (cập nhật toàn bộ 8 tỷ hoặc 70 tỷ tham số) trên các máy chủ GPU thông dụng của doanh nghiệp? Hãy làm một phép tính định lượng bộ nhớ GPU VRAM ở độ chính xác hỗn hợp chuẩn BFloat16:

• Với mô hình Llama-3.1-8B ($8 times 10^9$ tham số):
  • Trọng số mô hình (Weights ở BF16 — 2 bytes/param): $approx 16text{ GB}$.
  • Đạo hàm bậc nhất (Gradients ở BF16 — 2 bytes/param): $approx 16text{ GB}$.
  • Trạng thái bộ tối ưu hóa AdamW (FP32 Master Weights 4 bytes + First Moment $m_t$ 4 bytes + Second Moment $v_t$ 4 bytes = 12 bytes/param): $approx 96text{ GB}$.
  • Bộ nhớ kích hoạt trung gian (Activations phụ thuộc vào Batch Size và chiều dài chuỗi): $approx 12text{ GB} - 32text{ GB}$.
  • Tổng cộng: Full Fine-Tuning cho một mô hình 8B đòi hỏi từ 140 GB đến 160 GB VRAM (vượt quá một card NVIDIA H100 80GB đơn lẻ), và với mô hình 70B con số này vượt ngưỡng 1,100 GB VRAM!

flowchart TD
    InputX["Vector Đầu vào x (BF16 Hidden State)"] --> BranchBase["Nhánh Trọng số Gốc W0 (Đóng băng ở dạng 4-bit NormalFloat NF4)"]
    InputX --> BranchLoRA["Nhánh Thích nghi Hạng thấp LoRA / DoRA (Trainable BF16)"]

    BranchBase --> Dequant["Double Dequantization trên Thanh ghi GPU (NF4 -> BF16)"]
    BranchLoRA --> MatA["Ma trận Giảm chiều A (d x r, khởi tạo Gaussian, r = 32)"]
    MatA --> MatB["Ma trận Tăng chiều B (r x k, khởi tạo bằng 0)"]
    MatB --> Scale["Nhân Hệ số Tỷ lệ rsLoRA: alpha / sqrt(r)"]

    Dequant --> SumNode(("Cộng Tín hiệu: h = W0*x + Scale*(B*A*x)"))
    Scale --> SumNode
    SumNode --> OutputH["Vector Đầu ra h (BF16) -> Chỉ cập nhật Gradient cho A & B qua Paged AdamW 8-bit"]

2.1. Phân rã hạng thấp LoRA ($Delta W = frac{alpha}{r} B A$), Rank-Stabilized rsLoRA và DoRA (Weight-Decomposed LoRA)

Để giải quyết bài toán VRAM, kỹ thuật LoRA (Low-Rank Adaptation — Hu et al.) dựa trên phát hiện toán học rằng khi tinh chỉnh mô hình ngôn ngữ lớn cho một tác vụ chuyên biệt, ma trận cập nhật trọng số $Delta W$ có "hạng nội tại" (Intrinsic Rank) rất thấp. Thay vì cập nhật trực tiếp ma trận trọng số gốc $W_0 in mathbb{R}^{d times k}$, LoRA đóng băng hoàn toàn $W_0$ (requires_grad = False) và chèn song song hai ma trận hạng thấp khả huấn luyện $B in mathbb{R}^{d times r}$ và $A in mathbb{R}^{r times k}$ với hạng $r ll min(d, k)$ (thường chọn $r in {16, 32, 64}$ trong khi $d = 4096$):

$$h = W_0 x + Delta W x = W_0 x + frac{alpha}{r} B A x$$

Trong đó:

• Ma trận $A$ được khởi tạo theo phân phối chuẩn Gaussian $mathcal{N}(0, sigma^2)$ và ma trận $B$ được khởi tạo bằng $0$, đảm bảo tại bước huấn luyện đầu tiên ($t = 0$), $Delta W = B A = 0$ (mô hình giữ nguyên hành vi gốc 100%).
• Vì số lượng tham số cần huấn luyện giảm đi tới 98% – 99% (chỉ khoảng 80 triệu tham số cho cả 7 lớp tuyến tính của Llama-3.1-8B với $r = 32$), toàn bộ bộ nhớ Gradients và AdamW Optimizer States thu nhỏ từ 112 GB xuống chỉ còn chưa đầy 1.2 GB VRAM!
• Nâng cấp 2026 với rsLoRA và DoRA (PEFT v0.13+):
  • Rank-Stabilized LoRA (use_rslora=True): Khi tăng hạng $r$ lên cao ($r = 64$ hoặc $128$) để học khối lượng kiến thức miền lớn, hệ số tỷ lệ cổ điển $frac{alpha}{r}$ làm suy yếu biên độ cập nhật gradient. rsLoRA thay thế bằng hệ số chuẩn hóa toán học $frac{alpha}{sqrt{r}}$, giúp mô hình ổn định tuyệt đối ở mọi giá trị $r$.
  • Weight-Decomposed Low-Rank Adaptation (use_dora=True — Liu et al., ICML 2024): Phân tách trọng số thành hai thành phần độc lập là Độ lớn (Magnitude vector $m in mathbb{R}^{1 times k}$) và Hướng (Directional matrix $V = W_0 + BA$) theo công thức $W' = m frac{W_0 + BA}{|W_0 + BA|_c}$, giúp động học học tập của LoRA bám sát Full Fine-Tuning hơn nữa trên các bài toán suy luận phức tạp.

2.2. Kỹ thuật lượng tử hóa 4-bit NormalFloat (NF4), Double Quantization và Bảng tính toán VRAM thực tế

Mặc dù LoRA đã triệt tiêu chi phí bộ nhớ của Optimizer, bản thân trọng số gốc $W_0$ ở định dạng BFloat16 của Llama-3.3-70B vẫn chiếm tới 140 GB VRAM. QLoRA (Quantized LoRA — Dettmers et al.) kết hợp 3 đột phá kỹ thuật trong thư viện bitsandbytes v0.45+ để nén ma trận gốc $W_0$ xuống 4-bit mà không làm giảm chất lượng:

1. Kiểu dữ liệu 4-bit NormalFloat (NF4): Trọng số của mạng nơ-ron đã huấn luyện luôn tuân theo phân phối chuẩn tâm không $mathcal{N}(0, sigma^2)$. NF4 chia các mức lượng tử hóa 4-bit ($2^4 = 16$ giá trị) sao cho mỗi khoảng chứa xác suất phân bố trọng số bằng nhau (Information-Theoretically Optimal Quantile Quantization). Khi tính toán lượt truyền xuôi (Forward) và truyền ngược (Backward), trọng số NF4 được giải lượng tử hóa tức thời trên thanh ghi GPU sang bfloat16 (bnb_4bit_compute_dtype=torch.bfloat16) để nhân ma trận với nhánh LoRA.
2. Lượng tử hóa kép (Double Quantization — bnb_4bit_use_double_quant=True): Lượng tử hóa chính các hằng số tỷ lệ (Absmax Quantization Constants) từ FP32 theo từng khối 64 tham số xuống FP8, giúp tiết kiệm thêm 0.373 bits/tham số (giảm thêm ~3.2 GB VRAM trên mô hình 70B).
3. Bộ tối ưu hóa phân trang (Paged Optimizers — optim="paged_adamw_8bit"): Sử dụng cơ chế CUDA Unified Memory để tự động chuyển trang (page-out) các trạng thái của AdamW từ VRAM sang RAM hệ thống khi gặp các chuỗi đầu vào đột biến chiều dài, ngăn chặn triệt để lỗi CUDA Out of Memory.

Phương pháp Tinh chỉnh	Mô hình Llama-3.1-8B (seq_len=4096)	Mô hình Llama-3.3-70B (seq_len=4096)	Phần cứng GPU Tối thiểu Khuyến nghị (Production)
Full Fine-Tuning (BF16 + AdamW)	~148 GB VRAM	~1,120 GB VRAM	Cụm 2x–16x NVIDIA H100 80GB nối mạng NVLink / InfiniBand (FSDP).
LoRA / DoRA (BF16 Base Weights, $r=32$)	~21.5 GB VRAM	~156 GB VRAM	1x NVIDIA L40S 48GB (cho bản 8B) hoặc 2x A100/H100 80GB (cho bản 70B).
QLoRA (4-bit NF4 + Double Quant, $r=32$)	~8.4 GB VRAM	~43.5 GB VRAM	1x GPU 16GB–24GB (cho bản 8B) hoặc chỉ 1x L40S 48GB / A100 80GB (cho bản 70B)!
QLoRA + Unsloth Triton Kernels ($r=32$)	~5.8 GB VRAM	~36.2 GB VRAM	Giảm thêm 30% VRAM nhờ tính toán Cross-Entropy Loss theo từng khối (Chunked Logits).

---

3. Thiết kế Pipeline Dữ liệu Huấn luyện (Dataset Curation) và Completion-Only Loss Masking

Trong thực tế triển khai fine-tuning mô hình Llama 3 với LoRA và QLoRA, 80% chất lượng mô hình đầu ra được quyết định bởi độ sạch của tập dữ liệu huấn luyện (Data-Centric AI): một tập dữ liệu gồm 3,000 mẫu hội thoại chuẩn xác, đã khử nhiễu và định dạng đúng Chat Template luôn đánh bại một tập dữ liệu 100,000 mẫu thu thập thô chưa qua kiểm duyệt.

3.1. Chuẩn hóa Chat Template của Llama 3 (<|begin_of_text|>, <|start_header_id|>) và lọc nhiễu dữ liệu

Mọi mẫu dữ liệu đưa vào tinh chỉnh Llama-3.1-Instruct hoặc Llama-3.3-Instruct bắt buộc phải tuân thủ chính xác định dạng thẻ điều khiển gốc của Meta thông qua phương thức tokenizer.apply_chat_template(messages, tokenize=False):

• Cấu trúc chuẩn của một lượt hội thoại:
  <|begin_of_text|><|start_header_id|>system<|end_header_id|>nn{system_prompt}<|eot_id|><|start_header_id|>user<|end_header_id|>nn{user_query}<|eot_id|><|start_header_id|>assistant<|end_header_id|>nn{assistant_response}<|eot_id|>
• Cạm bẫy chết người với pad_token và eos_token: Mặc định, bộ từ vựng của Llama 3 không định nghĩa thẻ <pad> riêng. Nhiều lập trình viên gán bừa tokenizer.pad_token = tokenizer.eos_token (<|eot_id|>). Khi đó, bộ Collator sẽ gán nhãn -100 (bỏ qua khi tính hàm mất mát) cho toàn bộ các thẻ pad_token, vô tình che khuất luôn cả thẻ kết thúc câu <|eot_id|> thật sự ở cuối câu trả lời! Hậu quả là mô hình sau khi fine-tune không bao giờ học được cách phát sinh thẻ <|eot_id|> để dừng lại, dẫn đến hiện tượng nói lặp vô tận cho tới khi chạm giới hạn max_tokens. Giải pháp chuẩn là gán tokenizer.pad_token = "<|finetune_right_pad_id|>" (Token ID 128004 được Meta thiết kế sẵn chuyên dụng cho việc đệm khi fine-tuning trong bộ từ vựng Llama 3!).

3.2. Kỹ thuật Completion-Only Loss Masking (DataCollatorForCompletionOnlyLM) chống học vẹt System/User Prompt

Trong quá trình huấn luyện có giám sát (Supervised Fine-Tuning — SFT) thông thường, hàm mất mát Cross-Entropy được tính trên toàn bộ chuỗi token (bao gồm cả System Prompt và câu hỏi của User). Điều này gây lãng phí năng lực biểu diễn của các ma trận hạng thấp $A, B$ vào việc "học thuộc lòng" câu hỏi của người dùng thay vì tập trung tối ưu hóa câu trả lời của Assistant.

Bằng cách sử dụng DataCollatorForCompletionOnlyLM (trong trl v0.12+) với mẫu mốc phản hồi response_template = "<|start_header_id|>assistant<|end_header_id|>nn", toàn bộ các token thuộc System Prompt và User Prompt đều được gán nhãn labels = -100 (hàm torch.nn.CrossEntropyLoss tự động bỏ qua mọi vị trí có label == -100), đảm bảo đạo hàm cập nhật trọng số LoRA chỉ tính toán thuần túy trên phần nội dung trả lời của mô hình:

# file: prepare_llama3_completion_only_dataset.py
# Runtime: Python 3.13+ | Dependencies: transformers>=4.46.0, trl>=0.12.0, datasets>=3.1.0
from __future__ import annotations

from datasets import Dataset
from transformers import AutoTokenizer
from trl import DataCollatorForCompletionOnlyLM

MODEL_ID = "meta-llama/Llama-3.1-8B-Instruct"

def build_verified_llama3_tokenizer_and_collator(model_id: str = MODEL_ID):
    tokenizer = AutoTokenizer.from_pretrained(model_id, use_fast=True)

    # QUY TẮC SỐNG CÒN: Sử dụng token đệm chuyên dụng <|finetune_right_pad_id|> (ID 128004)
    # Tuyệt đối không gán pad_token = eos_token để tránh làm mất gradient của thẻ <|eot_id|>!
    tokenizer.pad_token = "<|finetune_right_pad_id|>"
    tokenizer.padding_side = "right"

    # Khởi tạo Collator chỉ tính Cross-Entropy Loss trên phần trả lời sau thẻ assistant
    response_template = "<|start_header_id|>assistant<|end_header_id|>nn"
    collator = DataCollatorForCompletionOnlyLM(
        response_template=response_template,
        tokenizer=tokenizer,
    )
    return tokenizer, collator

def format_enterprise_chat_record(record: dict, tokenizer) -> dict[str, str]:
    """Chuyển đổi bản ghi nghiệp vụ sang chuẩn Llama 3 ChatML bằng apply_chat_template."""
    messages = [
        {
            "role": "system",
            "content": (
                "Bạn là Chuyên gia Phân tích Rủi ro Tín dụng của hệ thống Infoteck FinTech. "
                "Hãy trích xuất thông tin hồ sơ vay và trả về duy nhất định dạng JSON hợp lệ."
            ),
        },
        {"role": "user", "content": record["raw_document"]},
        {"role": "assistant", "content": record["verified_json_output"]},
    ]
    formatted_text = tokenizer.apply_chat_template(
        messages,
        tokenize=False,
        add_generation_prompt=False,
    )
    return {"text": formatted_text}

if __name__ == "__main__":
    tok, data_collator = build_verified_llama3_tokenizer_and_collator()
    sample_data = Dataset.from_list([
        {
            "raw_document": "Khách hàng Công ty TNHH Hạ tầng Số Việt, MST 0109887211, đề nghị cấp hạn mức tín dụng 15.5 tỷ VND trong 12 tháng.",
            "verified_json_output": '{"entity_name":"Công ty TNHH Hạ tầng Số Việt","tax_id":"0109887211","requested_amount_vnd":15500000000,"tenor_months":12}',
        }
    ])
    formatted_ds = sample_data.map(format_enterprise_chat_record, fn_kwargs={"tokenizer": tok})
    batch = data_collator([tok(formatted_ds[0]["text"], truncation=True, max_length=2048)])
    masked_tokens = int((batch["labels"][0] == -100).sum())
    active_tokens = int((batch["labels"][0] != -100).sum())
    print(f"Masked Prompt Tokens (-100): {masked_tokens} | Active Completion Tokens: {active_tokens}")

---

4. Triển khai Huấn luyện Thực chiến với HuggingFace TRL (SFTTrainer), PEFT và FlashAttention-2

Khi bước vào giai đoạn huấn luyện trên PyTorch 2.5+ / 2.6, việc phối hợp đồng bộ giữa BitsAndBytesConfig, LoraConfig, SFTConfig và hạt nhân tăng tốc FlashAttention-2 quyết định trực tiếp tốc độ huấn luyện (tokens/sec) cũng như khả năng tổng quát hóa của mô hình.

4.1. Cấu hình BitsAndBytesConfig, LoraConfig và SFTConfig chuẩn Production trên PyTorch 2.5+

Trong bảng cấu hình siêu tham số (Hyperparameters) cho QLoRA / DoRA trên Llama 3, hãy áp dụng bộ quy tắc chuẩn đã được kiểm chứng thực nghiệm:

• Hạng r và hệ số lora_alpha: Với các tác vụ ép khuôn định dạng JSON hoặc phân loại nghiệp vụ hẹp, chọn r = 16, lora_alpha = 32; với các tác vụ đòi hỏi nạp thêm thuật ngữ chuyên ngành sâu (pháp lý, y tế, tài chính tiếng Việt), chọn r = 32, lora_alpha = 64 (quy tắc vàng lora_alpha = 2 * r) kết hợp use_rslora=True hoặc use_dora=True.
• Tốc độ học (learning_rate) và lịch trình Cosine: Đặt learning_rate = 2e-4 cho mô hình 8B (hoặc 1e-4 cho mô hình 70B), sử dụng lr_scheduler_type = "cosine" với warmup_ratio = 0.05.
• Kỹ thuật NEFTune (neftune_noise_alpha = 5.0): Bơm một lượng nhiễu đồng nhất nhỏ (Uniform Noise $frac{alpha}{sqrt{L cdot d}}$) vào vector nhúng (Embedding Layer) trong quá trình huấn luyện SFT giúp ngăn chặn hiện tượng quá khớp (Overfitting) trên tập dữ liệu nhỏ và cải thiện rõ rệt chất lượng tuân thủ chỉ thị.

# file: train_llama3_qlora_sft_production.py
# Runtime: Python 3.13+ | PyTorch 2.5+ | transformers>=4.46, peft>=0.13, trl>=0.12, bitsandbytes>=0.45
from __future__ import annotations

import torch
from datasets import load_dataset
from peft import LoraConfig, prepare_model_for_kbit_training
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
from trl import DataCollatorForCompletionOnlyLM, SFTConfig, SFTTrainer

MODEL_ID = "meta-llama/Llama-3.1-8B-Instruct"
OUTPUT_DIR = "./checkpoints/llama31-8b-fintech-qlora"

def run_production_sft_training() -> None:
    # 1. Cấu hình lượng tử hóa 4-bit NormalFloat (NF4) + Double Quantization + BFloat16 Compute
    bnb_config = BitsAndBytesConfig(
        load_in_4bit=True,
        bnb_4bit_quant_type="nf4",
        bnb_4bit_use_double_quant=True,
        bnb_4bit_compute_dtype=torch.bfloat16,
    )

    # 2. Nạp Tokenizer và thiết lập thẻ đệm chuẩn Llama 3
    tokenizer = AutoTokenizer.from_pretrained(MODEL_ID, use_fast=True)
    tokenizer.pad_token = "<|finetune_right_pad_id|>"
    tokenizer.padding_side = "right"

    # 3. Nạp Base Model với FlashAttention-2 để giảm độ phức tạp bộ nhớ từ O(N^2) xuống O(N)
    model = AutoModelForCausalLM.from_pretrained(
        MODEL_ID,
        quantization_config=bnb_config,
        attn_implementation="flash_attention_2",
        torch_dtype=torch.bfloat16,
        device_map="auto",
    )
    model.config.use_cache = False  # Bắt buộc tắt KV Cache khi bật Gradient Checkpointing
    model = prepare_model_for_kbit_training(model, use_gradient_checkpointing=True)

    # 4. Cấu hình LoRA / rsLoRA nhắm vào toàn bộ 7 lớp chiếu tuyến tính (Attention + SwiGLU MLP)
    peft_config = LoraConfig(
        r=32,
        lora_alpha=64,
        lora_dropout=0.05,
        bias="none",
        task_type="CAUSAL_LM",
        use_rslora=True,
        target_modules=[
            "q_proj", "k_proj", "v_proj", "o_proj",
            "gate_proj", "up_proj", "down_proj",
        ],
    )

    # 5. Thiết lập Completion-Only Loss Masking
    collator = DataCollatorForCompletionOnlyLM(
        response_template="<|start_header_id|>assistant<|end_header_id|>nn",
        tokenizer=tokenizer,
    )

    # 6. Cấu hình SFTConfig chuẩn TRL v0.12+
    sft_config = SFTConfig(
        output_dir=OUTPUT_DIR,
        dataset_text_field="text",
        max_seq_length=4096,
        num_train_epochs=3,
        per_device_train_batch_size=4,
        gradient_accumulation_steps=8,  # Effective Batch Size = 4 * 8 = 32
        learning_rate=2e-4,
        lr_scheduler_type="cosine",
        warmup_ratio=0.05,
        weight_decay=0.01,
        optim="paged_adamw_8bit",
        bf16=True,
        gradient_checkpointing=True,
        gradient_checkpointing_kwargs={"use_reentrant": False},
        neftune_noise_alpha=5.0,
        logging_steps=10,
        save_strategy="steps",
        save_steps=100,
        eval_strategy="steps",
        eval_steps=100,
        report_to="tensorboard",
        seed=2026,
    )

    dataset = load_dataset("json", data_files={"train": "data/train_chat.jsonl", "eval": "data/val_chat.jsonl"})

    trainer = SFTTrainer(
        model=model,
        train_dataset=dataset["train"],
        eval_dataset=dataset["eval"],
        peft_config=peft_config,
        data_collator=collator,
        processing_class=tokenizer,
        args=sft_config,
    )

    trainer.train()
    trainer.save_model(f"{OUTPUT_DIR}/final_adapter")
    tokenizer.save_pretrained(f"{OUTPUT_DIR}/final_adapter")

if __name__ == "__main__":
    run_production_sft_training()

4.2. Căn chỉnh hành vi sau SFT với Direct Preference Optimization (DPO / ORPO) giảm thiểu ảo giác (Hallucination)

Giai đoạn SFT dạy mô hình cách bắt chước câu trả lời mẫu (tăng xác suất của các token đúng), nhưng chưa dạy mô hình biết từ chối các câu trả lời trông có vẻ hợp lý nhưng chứa thông tin bịa đặt (Hallucinated Facts) hoặc vi phạm chính sách bảo mật. Thay vì phải huấn luyện một mô hình phần thưởng riêng biệt (Reward Model) phức tạp bằng thuật toán PPO (RLHF truyền thống), kiến trúc chuẩn năm 2026 sử dụng Direct Preference Optimization (DPOTrainer trong trl v0.12+) trên tập dữ liệu gồm các bộ ba (prompt, chosen, rejected).

DPO tối ưu hóa trực tiếp chính sách của mô hình ngôn ngữ để tối đa hóa biên độ xác suất logarit giữa câu trả lời chuẩn xác (chosen) và câu trả lời bịa đặt/sai cấu trúc (rejected) với hệ số kiểm soát độ lệch KL beta = 0.1 và tốc độ học cực nhỏ (learning_rate = 5e-6):

# file: align_llama3_dpo_preference.py
# Runtime: Python 3.13+ | Căn chỉnh hậu SFT bằng Direct Preference Optimization (DPO)
from __future__ import annotations

import torch
from datasets import load_dataset
from peft import PeftModel
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
from trl import DPOConfig, DPOTrainer

BASE_MODEL_ID = "meta-llama/Llama-3.1-8B-Instruct"
SFT_ADAPTER_PATH = "./checkpoints/llama31-8b-fintech-qlora/final_adapter"
DPO_OUTPUT_DIR = "./checkpoints/llama31-8b-fintech-dpo"

def run_dpo_alignment() -> None:
    bnb_config = BitsAndBytesConfig(
        load_in_4bit=True,
        bnb_4bit_quant_type="nf4",
        bnb_4bit_use_double_quant=True,
        bnb_4bit_compute_dtype=torch.bfloat16,
    )
    tokenizer = AutoTokenizer.from_pretrained(SFT_ADAPTER_PATH)

    base_model = AutoModelForCausalLM.from_pretrained(
        BASE_MODEL_ID,
        quantization_config=bnb_config,
        attn_implementation="flash_attention_2",
        torch_dtype=torch.bfloat16,
        device_map="auto",
    )

    # Nạp Adapter SFT làm điểm khởi đầu khả huấn luyện cho giai đoạn DPO
    model = PeftModel.from_pretrained(base_model, SFT_ADAPTER_PATH, is_trainable=True)

    dpo_args = DPOConfig(
        output_dir=DPO_OUTPUT_DIR,
        beta=0.1,  # Hệ số phạt độ phân kỳ KL so với mô hình tham chiếu SFT
        learning_rate=5e-6,
        lr_scheduler_type="cosine",
        per_device_train_batch_size=2,
        gradient_accumulation_steps=8,
        num_train_epochs=1,
        max_length=2048,
        max_prompt_length=1024,
        optim="paged_adamw_8bit",
        bf16=True,
        gradient_checkpointing=True,
        logging_steps=10,
    )

    # Dataset chứa 3 cột chuẩn: "prompt", "chosen" (chuẩn xác), "rejected" (chứa ảo giác/lỗi JSON)
    pref_dataset = load_dataset("json", data_files={"train": "data/dpo_preferences.jsonl"})["train"]

    dpo_trainer = DPOTrainer(
        model=model,
        ref_model=None,  # TRL tự động tắt tạm thời PEFT adapter để tính logprobs của mô hình tham chiếu!
        args=dpo_args,
        train_dataset=pref_dataset,
        processing_class=tokenizer,
    )
    dpo_trainer.train()
    dpo_trainer.save_model(f"{DPO_OUTPUT_DIR}/final_aligned_adapter")

if __name__ == "__main__":
    run_dpo_alignment()

---

5. Hợp nhất Trọng số (Merge & Unload), Chuyển đổi Safetensors và Kiểm định chất lượng Mô hình

Sau khi hoàn tất huấn luyện QLoRA/DPO, thư mục đầu ra chỉ chứa tệp trọng số bộ điều hợp adapter_model.safetensors (dung lượng khoảng 160 MB – 320 MB). Để triển khai lên các cụm suy luận tốc độ cao đã phân tích trong bài so sánh kiến trúc Inference LLM với vLLM, TensorRT-LLM và TGI, bạn cần nắm vững quy trình hợp nhất trọng số chuẩn xác.

5.1. Quy trình chống suy giảm độ chính xác khi Merge LoRA Adapter vào Base Model (FP16/BF16 vs NF4)

[!WARNING]
Cấm tuyệt đối gọi model.merge_and_unload() trực tiếp trên đối tượng mô hình đang nạp ở chế độ 4-bit NF4!
Nếu bạn hợp nhất ma trận $Delta W = frac{alpha}{r} B A$ (BFloat16) trực tiếp vào trọng số cơ sở đã bị lượng tử hóa 4-bit trong bộ nhớ, sai số làm tròn của quá trình giải lượng tử hóa NF4 sẽ bị "nướng cứng" vĩnh viễn vào ma trận trọng số cuối cùng, gây sụt giảm nghiêm trọng điểm Perplexity và độ chính xác suy luận.

Quy trình hợp nhất không suy hao (Lossless Adapter Merge) bắt buộc phải thực hiện theo 3 bước:

1. Khởi tạo một tiến trình Python sạch, nạp lại mô hình gốc meta-llama/Llama-3.1-8B-Instruct ở độ chính xác gốc torch.bfloat16 (trên CPU có RAM >= 32 GB hoặc trên GPU) mà không truyền BitsAndBytesConfig.
2. Nạp chồng bộ điều hợp LoRA lên mô hình BFloat16 đó bằng PeftModel.from_pretrained(base_model, adapter_path).
3. Gọi .merge_and_unload() để cộng chính xác ma trận $Delta W$ vào $W_0$ trên không gian 16-bit, sau đó lưu xuất định dạng safetensors phân mảnh (max_shard_size="4GB"):

# file: lossless_merge_lora_to_bf16_safetensors.py
# Runtime: Python 3.13+ | Hợp nhất Adapter LoRA vào Base Model chuẩn BFloat16 không suy hao
from __future__ import annotations

import torch
from peft import PeftModel
from transformers import AutoModelForCausalLM, AutoTokenizer

BASE_MODEL_ID = "meta-llama/Llama-3.1-8B-Instruct"
ADAPTER_DIR = "./checkpoints/llama31-8b-fintech-dpo/final_aligned_adapter"
MERGED_EXPORT_DIR = "./exported_models/llama31-8b-fintech-merged-bf16"

def export_merged_safetensors() -> None:
    print("[1/3] Nạp Base Model gốc ở độ chính xác chuẩn torch.bfloat16 (Không 4-bit)...")
    base_model = AutoModelForCausalLM.from_pretrained(
        BASE_MODEL_ID,
        torch_dtype=torch.bfloat16,
        device_map="cpu",  # Dùng CPU RAM để tránh giới hạn VRAM khi merge mô hình lớn
        low_cpu_mem_usage=True,
    )
    tokenizer = AutoTokenizer.from_pretrained(ADAPTER_DIR)

    print("[2/3] Áp dụng PeftModel và thực thi phép cộng ma trận W_merged = W_0 + (alpha/r)*B*A...")
    peft_model = PeftModel.from_pretrained(base_model, ADAPTER_DIR, torch_dtype=torch.bfloat16)
    merged_model = peft_model.merge_and_unload(progressbar=True)

    print(f"[3/3] Lưu xuất mô hình hoàn chỉnh định dạng Sharded Safetensors tới {MERGED_EXPORT_DIR}...")
    merged_model.save_pretrained(
        MERGED_EXPORT_DIR,
        safe_serialization=True,
        max_shard_size="4GB",
    )
    tokenizer.save_pretrained(MERGED_EXPORT_DIR)
    print("Hoàn tất xuất mô hình sẵn sàng cho vLLM / TensorRT-LLM!")

if __name__ == "__main__":
    export_merged_safetensors()

5.2. Đánh giá định lượng bằng lm-evaluation-harness, Perplexity và kiểm thử hồi quy nghiệp vụ

Trước khi cấp phép đưa mô hình đã tinh chỉnh lên môi trường Production, chúng ta phải chạy bộ kiểm định tự động gồm hai nhánh:

1. Đánh giá độ chính xác tác vụ đích (Task-Specific Golden Test Set): Đo tỷ lệ xuất JSON hợp lệ theo Pydantic Schema (JSON Schema Validity Rate >= 99.5%) và điểm F1-Score trích xuất trường dữ liệu trên tập kiểm thử độc lập (Hold-out Test Set tối thiểu 500 mẫu thực tế).
2. Kiểm tra chống quên thảm khốc (Catastrophic Forgetting Evaluation) bằng lm-evaluation-harness (EleutherAI) & PyTorch torchtune: Đảm bảo mô hình sau khi học nghiệp vụ chuyên ngành không bị suy thoái khả năng suy luận logic tổng quát trên các bộ chuẩn MMLU, GSM8K và IFEval:

#!/usr/bin/env bash
# file: evaluate_and_benchmark_llama3.sh
set -euo pipefail

MERGED_MODEL="./exported_models/llama31-8b-fintech-merged-bf16"

# 1. Chạy huấn luyện phân tán FSDP2 thay thế qua công cụ chính thức PyTorch torchtune (tùy chọn)
# tune run --nnodes 1 --nproc_per_node 4 lora_finetune_distributed 
#   --config llama3_1/8B_qlora_distributed

# 2. Kiểm định năng lực tuân thủ chỉ thị (IFEval) và suy luận toán học (GSM8K) bằng lm_eval
lm_eval --model vllm 
  --model_args pretrained="${MERGED_MODEL}",tensor_parallel_size=1,dtype=bfloat16,gpu_memory_utilization=0.85 
  --tasks ifeval,gsm8k 
  --batch_size auto 
  --output_path ./eval_results/llama31_fintech_benchmark.json

---

6. Chiến lược Vận hành MLOps cho Mô hình Llama 3 Tinh chỉnh & Tài liệu Tham khảo Chuẩn Kỹ thuật

6.1. Triển khai kiến trúc Multi-LoRA Serving và quản trị phiên bản Adapter trong doanh nghiệp

Nếu doanh nghiệp của bạn có 10 phòng ban khác nhau (Pháp chế, Thẩm định Tín dụng, Chăm sóc Khách hàng, Phân tích Mã nguồn, Nhân sự...), bạn không cần phải hợp nhất và triển khai 10 cụm GPU chạy 10 bản sao mô hình Llama-3.1-8B riêng biệt. Thay vào đó, hãy tận dụng kiến trúc Dynamic Multi-LoRA Serving trên vLLM (--enable-lora --max-loras 8 --max-lora-rank 64): chỉ nạp duy nhất 1 bản trọng số gốc Llama-3.1-8B-Instruct vào VRAM, và truyền động tên Adapter ("model": "lora-legal-v2" hoặc "model": "lora-fintech-v4") trong từng yêu cầu API để dùng chung 100% hạ tầng GPU với chi phí vận hành tối ưu nhất.

6.2. Checklist kiểm toán chất lượng Adapter trước khi đưa lên Production

Trước khi đăng ký Adapter vào Model Registry, hãy kiểm chứng đủ 5 điều kiện: (1) tokenizer.pad_token đã trỏ về <|finetune_right_pad_id|> (128004), (2) target_modules bao phủ đủ 7 lớp chiếu tuyến tính, (3) Loss trên tập Validation hội tụ mượt không bị bật ngược (Overfitting), (4) Đã hợp nhất vào Base Model chuẩn torch.bfloat16 thay vì NF4, và (5) Vượt qua bộ kiểm thử hồi quy lm_eval mà không suy giảm quá 1.5% điểm IFEval.

6.3. Tài liệu tham khảo & Nguồn chuẩn kỹ thuật (Primary Technical References)

1. Meta AI — The Llama 3 Herd of Models (Official Architectural & Training Technical Report, arXiv:2407.21783)
2. Hu et al. — LoRA: Low-Rank Adaptation of Large Language Models (ICLR / arXiv:2106.09685)
3. Dettmers et al. — QLoRA: Efficient Finetuning of Quantized LLMs (NeurIPS / arXiv:2305.14314)
4. Liu et al. — DoRA: Weight-Decomposed Low-Rank Adaptation (ICML / arXiv:2402.09353)
5. HuggingFace PEFT Official Documentation — LoRA, QLoRA, rsLoRA, and DoRA Configuration Guide
6. HuggingFace TRL (Transformer Reinforcement Learning) — SFTTrainer & DPOTrainer Official Documentation
7. PyTorch torchtune Official Documentation — Native PyTorch LLM Fine-Tuning Recipes & FSDP2