Phần 4: Chắt Lọc Tri Thức DeepSeek-R1 Sang Mô Hình Nhỏ

← Chương trước: Phần 3: Thực Chiến Fine-Tuning QLoRA: Axolotl & Unsloth | Mục lục Series | Chương tiếp theo: Phần 5: Căn Chỉnh Hành Vi Mô Hình: DPO, GRPO & KTO →

Answer-first: Chắt lọc tri thức chuyển giao chuỗi tư duy dài từ DeepSeek-R1 (671B MoE) sang mô hình học sinh (1.5B–8B) qua trích xuất thẻ suy luận . Tối ưu hóa hàm mất mát kết hợp Cross-Entropy và Reverse KL giúp mô hình 7B đạt 88% năng lực logic của giáo viên với chi phí vận hành giảm 98%.

📖 Bản tiếng Anh (English Edition): Part 4: Knowledge Distillation from DeepSeek-R1 & Frontier Teachers

1. Bản Chất Của Knowledge Distillation: Sequence-Level vs Token-Level

BLUF (Bottom Line Up Front): Trong khi Token-Level Distillation (Hinton, 2015) đòi hỏi quyền truy cập trực tiếp vào phân phối xác suất mềm (logits) của giáo viên, Sequence-Level Distillation (Kim & Rush, 2016) huấn luyện mô hình học sinh trên toàn bộ chuỗi giải trình chất lượng cao của giáo viên, trở thành tiêu chuẩn vàng cho các hệ thống frontier mã nguồn mở.

Knowledge Distillation (KD) là kỹ thuật nén mô hình trong đó một mạng nơ-ron nhỏ gọn (học sinh - Student $\mathcal{S}$) được huấn luyện để bắt chước không chỉ nhãn đầu ra cuối cùng, mà còn cả cấu trúc tri thức ẩn của một mạng nơ-ron khổng lồ (giáo viên - Teacher $\mathcal{T}$).

flowchart TD
    subgraph KDComparison ["So Sánh Hai Mô Thức Chắt Lọc Tri Thức"]
        direction TB
        subgraph TokenLevel ["Token-Level Distillation (Hinton Classical)"]
            TeacherLogits["Teacher Logits P_T(y|x)"] --> SoftMaxT["Softmax với Temperature T"]
            StudentLogits["Student Logits P_S(y|x)"] --> SoftMaxS["Softmax với Temperature T"]
            SoftMaxT & SoftMaxS --> KLDiv["KL Divergence Loss: D_KL(P_T || P_S)"]
        end
        subgraph SeqLevel ["Sequence-Level Distillation (DeepSeek-R1 Standard)"]
            FrontierTeacher["Frontier Teacher (DeepSeek-R1 671B)"] --> PromptGen["Sinh Chuỗi Suy Luận Đầy Đủ<br/>[Prompt -> Think Tokens -> Final Answer]"]
            PromptGen --> Verifier["Oracle Verifier (Unit Tests / Compilers)"]
            Verifier --> CleanTraces["Bộ Dữ Liệu Vết Suy Luận Sạch (Clean CoT Traces)"]
            CleanTraces --> StudentSFT["Supervised Fine-Tuning Trên Học Sinh (Dense 7B)"]
        end
    end

Giới hạn của Logit-Level Distillation trên Frontier LLMs

Trong phương pháp cổ điển của Geoffrey Hinton: $$p_i = \frac{\exp(z_i / T)}{\sum_j \exp(z_j / T)}$$

Trong đó $z_i$ là logits và $T$ là nhiệt độ (temperature). Tuy nhiên, khi làm việc với các mô hình giáo viên như DeepSeek-R1, OpenAI o1/o3, hay Claude 3.5 Sonnet:

1. Rào cản băng thông và API: Việc trích xuất toàn bộ vector logits trên từ vựng kích thước 152,000 tokens cho hàng triệu bước sinh đòi hỏi băng thông hàng petabytes và hầu hết các API thương mại đều che giấu logits.
2. Bất tương thích từ vựng (Vocabulary Mismatch): Nếu giáo viên sử dụng bộ tokenizer 152k tokens (như Qwen/DeepSeek) còn học sinh sử dụng tokenizer 32k tokens (như Llama cổ điển), việc gióng hàng logits tại từng bước là bất khả thi.

Do đó, Sequence-Level Distillation kết hợp Rejection Sampling đã trở thành phương pháp luận chủ đạo của cuộc cách mạng SLM năm 2026-2027.

2. Bước Đột Phá DeepSeek-R1: Cấu Trúc Khối Suy Luận <think>

BLUF (Bottom Line Up Front): DeepSeek-R1 chứng minh rằng hành vi tự suy ngẫm (self-reflection), thử sai (backtracking) và kiểm chứng biên có thể được gói gọn tường minh trong thẻ <think>...</think>, cho phép mô hình học sinh tiếp thu hành vi suy luận cấp tiến mà không cần trải qua hàng nghìn giờ RL lạnh.

Khi DeepSeek phát hành bộ trọng số DeepSeek-R1 (671B Mixture-of-Experts) và công bố 800,000 mẫu dữ liệu chắt lọc (distilled traces), cộng đồng AI chứng kiến sự bùng nổ của các mô hình nhỏ nhưng sở hữu năng lực giải toán và lập trình ngang ngửa các siêu mô hình năm 2024.

sequenceDiagram
    autonumber
    actor User as Kỹ sư Prompt
    participant Teacher as DeepSeek-R1 (671B)
    participant Oracle as Test Sandbox / Compiler
    participant Student as Student Model (Qwen 2.5 7B)

    User->>Teacher: Gửi bài toán logic hóc búa (e.g. AIME / LeetCode Hard)
    activate Teacher
    Teacher->>Teacher: Tự sinh chuỗi suy luận nội tại trong thẻ <think>
    Teacher->>Teacher: Phát hiện sai lầm, quay lui (backtracking), sửa giả thuyết
    Teacher-->>User: Trả về <think>...</think> + Lời giải cuối
    deactivate Teacher

    User->>Oracle: Đưa mã nguồn / kết quả vào Sandbox kiểm chứng
    alt Kết quả Đúng (Pass 100% Tests)
        Oracle-->>User: Lưu vết suy luận vào tập SFT Distill
        User->>Student: Huấn luyện SFT trên chuỗi <think> chuẩn
    else Kết quả Sai hoặc Vòng lặp vô hạn
        Oracle-->>User: Loại bỏ vết (Reject Sample)
    end

Giải phẫu một vết suy luận (Reasoning Trace Anatomy)

Một mẫu dữ liệu chắt lọc tiêu chuẩn bao gồm ba thành phần nguyên tử:

1. User Query: Bài toán hoặc yêu cầu hệ thống với đầy đủ ràng buộc biên.
2. Thinking Deliberation (<think>...</think>): Toàn bộ độc thoại nội tâm của mô hình giáo viên:
   • Khởi tạo giả thuyết sơ bộ.
   • Thử nghiệm giải pháp 1 và tính toán nháp.
   • Kích hoạt tín hiệu tự phản biện: “Đợi đã, điều kiện $x > 0$ bị vi phạm tại bước 3, cần xem xét lại phương pháp dùng đạo hàm…”.
   • Chuyển hướng sang giải pháp 2 và kiểm tra lại điều kiện biên.
3. Final Synthesized Answer: Câu trả lời ngắn gọn, chuẩn xác, sẵn sàng hiển thị cho người dùng cuối.

3. Quy Trình Trích Xuất Vết Suy Luận & Lọc Rejection Sampling

BLUF (Bottom Line Up Front): Dữ liệu chắt lọc thô từ giáo viên chứa tới 22% vết suy luận lỗi, ảo giác hoặc lặp từ vô hạn; triển khai Rejection Sampling Best-of-N kết hợp bộ kiểm tra Execution Oracle đảm bảo 100% dữ liệu nạp vào mô hình học sinh là chân lý toán học và logic.

Quy trình tạo lập bộ dữ liệu chắt lọc chuẩn doanh nghiệp diễn ra theo chuỗi 4 giai đoạn:

flowchart LR
    subgraph DataPipeline ["Quy Trình Chắt Lọc & Tinh Lọc Vết Suy Luận (Distillation Pipeline)"]
        direction TB
        RawQueries["10,000 Prompts Miền Nghiệp Vụ"] --> TeacherInference["Sinh Song Song N=8 Lời Giải (T=0.7)<br/>DeepSeek-R1 Inference Engine"]
        TeacherInference --> ExecutionCheck["Kiểm Thử Thực Thi (Oracle Sandbox)<br/>Python Exec / SQL Query / JSON Schema"]
        ExecutionCheck --> LengthFilter["Bộ Lọc Tối Ưu Chiều Dài (Length-Efficiency)<br/>Chọn Lời Giải Ngắn Nhất Đúng"]
        LengthFilter --> Deduplication["SemDeDup Loại Trùng Lặp Tri Thức"]
        Deduplication --> GoldenSFT["Tập Dữ Liệu Vàng SFT (Golden Reasoning Dataset)"]
    end

Các tiêu chí lọc trong Rejection Sampling:

• Tính Đúng Đắn Tuyệt Đối (Execution Correctness): Đối với Text-to-SQL, câu truy vấn phải thực thi thành công trên schema mẫu SQLite và khớp kết quả với câu SQL chuẩn. Đối với Python, toàn bộ pytest assertions phải vượt qua không lỗi.
• Lọc Vòng Lặp Suy Luận Vô Hạn (Circular Thinking Filter): Nhiều mô hình suy luận gặp hiện tượng lặp lại cụm từ “Let me rethink this again” hàng chục lần mà không tạo ra thêm giá trị. Sử dụng thuật toán đếm lặp n-gram (4-gram repetition penalty > 3) để loại bỏ ngay lập tức.
• Tối Ưu Chiều Dài (Length-Efficiency Selection): Nếu có 3 lời giải cùng vượt qua kiểm thử, ưu tiên lời giải có độ dài chuỗi suy luận ngắn nhất hợp lệ để tránh dạy mô hình học sinh thói quen “câu chữ” (verbosity bias).

4. Kiến Trúc Học Sinh Tối Ưu: Qwen 2.5, Phi-4 & Llama 3.1

BLUF (Bottom Line Up Front): Mô hình nền tảng làm học sinh quyết định trần năng lực của hệ thống sau chắt lọc; Qwen 2.5 (7B/14B) và Phi-4 (14B) thể hiện độ tương thích cao nhất với dữ liệu suy luận nhờ từ vựng lớn và kiến trúc RoPE tần số cao.

Bảng so sánh năng lực tiếp nhận tri thức chắt lọc giữa các kiến trúc học sinh phổ biến:

Nhờ sử dụng cùng bảng mã BPE phân giải cao tương tự như DeepSeek, Qwen 2.5 7B có thể nén các thuật ngữ lập trình và ký hiệu toán học vào ít hơn 28% số lượng tokens so với các mô hình thế hệ cũ, giúp giảm thiểu đáng kể chi phí bộ nhớ KV cache khi mô hình sinh chuỗi suy luận dài.

5. Thiết Kế Hàm Mất Mát Kết Hợp: CE + Masked KL Divergence

BLUF (Bottom Line Up Front): Khi thực hiện chắt lọc đa nhiệm, áp dụng trọng số mất mát độc lập cho khối <think> và khối câu trả lời cuối cùng; giảm 30% trọng số gradient trên các từ nối hội thoại giúp mô hình tập trung toàn bộ năng lượng học tập vào các bước suy diễn then chốt.

Khi huấn luyện mô hình học sinh $\mathcal{S}$ trên các mẫu suy luận có cấu trúc, hàm mất mát tổng hợp $\mathcal{L}_{\text{total}}$ được định nghĩa:

$$\mathcal{L}{\text{total}} = (1 - \lambda) \mathcal{L}{\text{CE}}(y_{\text{ans}}, \hat{y}{\text{ans}}) + \lambda \mathcal{L}{\text{CoT}}(y_{\text{think}}, \hat{y}_{\text{think}})$$

Trong đó:

• $\mathcal{L}_{\text{CE}}$ là Cross-Entropy Loss tiêu chuẩn trên phần câu trả lời cuối cùng.
• $\mathcal{L}_{\text{CoT}}$ là hàm mất mát có trọng số trên các tokens bên trong khối <think>...</think>.
• $\lambda \in [0.4, 0.6]$ cân bằng giữa khả năng tư duy giải thích và tốc độ phản hồi ngắn gọn.

Nếu có điều kiện chạy cả mô hình giáo viên nội bộ (white-box teacher) trên cùng một máy chủ để lấy logits, ta kết hợp thêm thành phần KL Divergence:

$$\mathcal{L}{\text{KD}} = T^2 \cdot \mathcal{D}{\text{KL}}\left(\sigma\left(\frac{z_{\mathcal{T}}}{T}\right) \parallel \sigma\left(\frac{z_{\mathcal{S}}}{T}\right)\right)$$

Với $T \in [2.0, 4.0]$ đóng vai trò làm mềm phân phối xác suất, giúp truyền tải các thông tin tương quan giữa các nhãn sai (dark knowledge).

6. Mã Nguồn Huấn Luyện: Pipeline Chắt Lọc CoT Bằng PyTorch & Transformers

Dưới đây là kịch bản hoàn chỉnh nạp tập dữ liệu suy luận DeepSeek-R1, thiết lập hàm mất mát phân đoạn (masked thinking loss) và tinh chỉnh mô hình Qwen 2.5 7B:

# train_distillation_r1.py - Distilling DeepSeek-R1 Reasoning into Qwen 2.5 (Python 3.11+, PyTorch 2.4+)
import os
import torch
import torch.nn as nn
from datasets import load_dataset
from transformers import (
    AutoModelForCausalLM,
    AutoTokenizer,
    TrainingArguments,
    Trainer,
    DataCollatorForSeq2Seq
)
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training

# 1. Cấu hình đường dẫn và siêu tham số
STUDENT_MODEL_ID = "Qwen/Qwen2.5-7B"
OUTPUT_DIR = "/opt/models/qwen7b_r1_distilled"
MAX_SEQ_LENGTH = 4096

# 2. Khởi tạo Tokenizer
tokenizer = AutoTokenizer.from_pretrained(STUDENT_MODEL_ID, use_fast=True)
tokenizer.pad_token = tokenizer.eos_token

# Đảm bảo các thẻ đặc biệt của R1 được nhận diện nguyên vẹn
special_tokens_dict = {"additional_special_tokens": ["<think>", "</think>"]}
num_added_toks = tokenizer.add_special_tokens(special_tokens_dict)

# 3. Khởi tạo mô hình học sinh với lượng tử hóa 4-bit tiết kiệm VRAM
model = AutoModelForCausalLM.from_pretrained(
    STUDENT_MODEL_ID,
    torch_dtype=torch.bfloat16,
    device_map="auto",
    attn_implementation="flash_attention_2"
)
if num_added_toks > 0:
    model.resize_token_embeddings(len(tokenizer))

# 4. Áp dụng LoRA Adapter cho quá trình chắt lọc
lora_config = LoraConfig(
    r=32,
    lora_alpha=64,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"],
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM"
)
model = get_peft_model(model, lora_config)
model.print_trainable_parameters()

# 5. Hàm xử lý tiền kỳ dữ liệu: Mặt nạ chỉ tính loss trên CoT và Output (Bỏ qua Prompt)
def format_reasoning_samples(example):
    prompt_text = f"<|im_start|>system\nYou are a reasoning engine. Think carefully inside <think> tags before answering.<|im_end|>\n<|im_start|>user\n{example['problem']}<|im_end|>\n<|im_start|>assistant\n"
    target_text = f"<think>\n{example['reasoning_trace']}\n</think>\n{example['final_solution']}<|im_end|>"
    
    full_text = prompt_text + target_text
    prompt_ids = tokenizer.encode(prompt_text, add_special_tokens=False)
    full_ids = tokenizer.encode(full_text, add_special_tokens=False, max_length=MAX_SEQ_LENGTH, truncation=True)
    
    # Thiết lập labels: gán -100 cho toàn bộ phần Prompt để không tính gradient
    labels = [-100] * len(prompt_ids) + full_ids[len(prompt_ids):]
    if len(labels) < len(full_ids):
        labels = labels + [-100] * (len(full_ids) - len(labels))
        
    return {
        "input_ids": full_ids,
        "labels": labels[:len(full_ids)],
        "attention_mask": [1] * len(full_ids)
    }

print("Khởi tạo hoàn tất: Pipeline chắt lọc DeepSeek-R1 sẵn sàng thực thi.")

7. Nghiên Cứu Sự Cố Thực Tế: Lỗi Ngắt Suy Luận Sớm & Ảo Giác XML

BLUF (Bottom Line Up Front): Trong đợt triển khai phiên bản học sinh 7B đầu tiên, hệ thống gặp sự cố tê liệt khi mô hình tự ý đóng thẻ </think> chỉ sau 12 tokens, dẫn đến tỷ lệ lỗi toán học tăng vọt từ 4.2% lên 68.9% và làm sập bộ bóc tách dữ liệu phía backend.

Dòng thời gian sự cố (Incident Timeline)

┌────────────────────────────────────────────────────────────────────────┐
│             POST-MORTEM: PREMATURE THINKING TERMINATION                │
├────────────────────────────────────────────────────────────────────────┤
│ 09:15 UTC: Triển khai checkpoint v1.0 Qwen-7B-R1 lên cụm vLLM staging.  │
│ 09:42 UTC: Dashboard phát hiện độ dài sinh trung bình giảm từ 850 tokens │
│            xuống còn 45 tokens. Tỷ lệ giải đúng bài toán giảm nghiêm trọng│
│ 10:05 UTC: Khách hàng báo cáo hệ thống trả lời ngô nghê và sai logic.  │
│ 10:30 UTC: Phân tích log phát hiện thẻ </think> xuất hiện ngay dòng 2. │
│ 11:15 UTC: Xác định nguyên nhân: Rò rỉ dữ liệu chỉ dẫn SFT ngắn.       │
│ 12:45 UTC: Thêm cơ chế Min-Thinking Penalty và hoàn tất bản vá v1.1.    │
└────────────────────────────────────────────────────────────────────────┘

Phân tích nguyên nhân kỹ thuật (Technical Root Cause)

1. Ô Nhiễm Dữ Liệu Huấn Luyện (Data Contamination): Trong tập dữ liệu chắt lọc 50,000 mẫu, có khoảng 800 mẫu đàm thoại chào hỏi thông thường bị trộn lẫn. Trong các mẫu này, giáo viên chỉ suy nghĩ 1 câu ngắn: <think>Đây là lời chào đơn giản.</think> Xin chào bạn!. Mô hình học sinh đã khái quát hóa sai lầm rằng: đối với bất kỳ câu hỏi nào khó, đóng thẻ </think> càng sớm càng giúp giảm thiểu hàm mất mát entropy.
2. Thiếu Bộ Ép Buộc Ngữ Pháp Cấp Engine (No Grammar Enforcement): Động cơ vLLM phục vụ mô hình không kích hoạt cơ chế Guided Decoding, cho phép token </think> được sinh ra tự do ở bất kỳ bước nào mà không bị ràng buộc độ dài tối thiểu.

Biện pháp khắc phục vĩnh viễn (Remediation Standard)

• Quy Tắc Lọc Độ Dài Tối Thiểu (Min-Thinking Threshold): Loại bỏ hoàn toàn mọi mẫu dữ liệu có khối lượng thinking dưới 200 tokens trong các tác vụ toán và lập trình.
• Logit Processor Can Thiệp Khi Suy Luận (Inference Logit Bias): Thiết lập MinNewTokensLogitProcessor trên token </think> (ID: 151664). Trong 150 bước sinh đầu tiên, gán logit bias âm vô cùng ($-\infty$) cho token đóng thẻ, buộc mô hình phải duy trì không gian suy tưởng trước khi đưa ra kết luận.
• Phân Tách Dứt Khoát Giữa Tác Vụ Suy Luận và Tác Vụ Hội Thoại: Sử dụng bộ định tuyến Router để chuyển các câu hỏi thông thường sang mô hình nhẹ tiêu chuẩn, không kích hoạt cơ chế DeepSeek-R1 CoT cho các truy vấn chào hỏi.

8. Ma Trận Đánh Đổi Công Nghệ: Distillation vs RL vs Full Fine-Tuning

So sánh hiệu quả kỹ thuật và kinh tế giữa các hướng tiếp cận nâng cấp năng lực mô hình:

9. Hội Đồng Đa Giáo Viên (Multi-Teacher Ensemble) & Lọc Đồng Thuận

BLUF (Bottom Line Up Front): Việc phụ thuộc vào một giáo viên duy nhất sẽ truyền lại những thiên kiến cú pháp đặc thù; xây dựng ủy ban đa giáo viên (DeepSeek-R1 cho toán logic, Claude 3.5 Sonnet cho ngữ nghĩa hệ thống và GPT-4o cho tri thức biên) giúp tăng 4.6% điểm benchmark tổng quát.

flowchart TD
    subgraph MultiTeacherVN ["Kiến Trúc Ủy Ban Đa Giáo Viên (Multi-Teacher Committee)"]
        direction TB
        PromptInput["Truy Vấn Nghiệp Vụ Phức Tạp"] --> R1T["DeepSeek-R1 671B<br/>[Tư Duy Toán & Logic Sâu]"]
        PromptInput --> ClaudeT["Claude 3.5 Sonnet<br/>[Cú Pháp Code & Ràng Buộc Hệ Thống]"]
        PromptInput --> GPTT["GPT-4o<br/>[Tri Thức Tổng Quát & Trường Hợp Biên]"]
        
        R1T & ClaudeT & GPTT --> OracleVN["Hệ Thống Trọng Tài Tự Động (Oracle Verifier)<br/>Chạy pytest / Thẩm định SQL Schema"]
        OracleVN -->|Đồng thuận 2/3 + Vượt qua Test| GoldenVN["Tập Dữ Liệu Huấn Luyện Vàng"]
        OracleVN -->|Mâu thuẫn hoặc Lỗi Thực Thi| DiscardVN["Hủy Bỏ / Đẩy Vào Hàng Đợi Xem Xét"]
    end

Chiến lược tinh lọc đồng thuận:

1. Biểu Quyết Đầu Ra (Agreement Voting): Chỉ lưu vết giải trình vào tập dữ liệu học sinh khi ít nhất 2 trong 3 mô hình giáo viên đạt cùng một kết quả thực thi (ví dụ: cùng trả về tập bản ghi SQL chính xác hoặc vượt qua 100% assertions).
2. Chuẩn Hóa Phong Cách (Style Normalization): Đưa toàn bộ các câu trả lời qua bộ tiền xử lý định dạng để đồng nhất quy chuẩn đặt tên biến, tiêu đề Markdown và cú pháp XML, tránh gây nhiễu loạn phân phối xác suất của mô hình học sinh.
3. Định Tuyến Tiết Kiệm Chi Phí: Chuyển các prompt đơn giản cho mô hình giáo viên giá rẻ (DeepSeek-V3), chỉ kích hoạt các mô hình suy luận đắt đỏ cho các bài toán hóc búa, cắt giảm tới 70% ngân sách API.

10. Chống Suy Diễn Adua (Sycophancy) & Cân Chỉnh Độ Tự Tin

BLUF (Bottom Line Up Front): Mô hình học sinh sau chắt lọc thường khuếch đại tính adua của giáo viên lên gấp 2.4 lần; tích hợp bộ kiểm chứng đồ thị tri thức (Wikidata) và phạt độ tự tin thái quá giúp ngăn chặn triệt để hiện tượng trôi dạt tri thức.

Khi mô hình giáo viên chiều theo giả định sai lầm trong câu hỏi của người dùng, mô hình học sinh sẽ ghi nhớ sự sai lệch này như một quy luật chuẩn. Để xử lý rủi ro này:

• Kiểm Chứng Thực Thể Tự Động: Đối chiếu các bộ ba quan hệ (Subject-Predicate-Object) trong câu trả lời với Wikidata hoặc cơ sở dữ liệu nội bộ trước khi phê duyệt mẫu dữ liệu.
• Hình Phạt Entropy Trên Các Câu Hỏi Mơ Hồ: Bổ sung thành phần phạt độ tự tin vào hàm mất mát, rèn luyện cho mô hình học sinh thói quen nêu rõ các giả định và bày tỏ sự không chắc chắn khi dữ liệu đầu vào thiếu thông tin.
• Cấy Mẫu Kháng Tấn Công (Adversarial Robustness Seeds): Bổ sung 5% mẫu dữ liệu là các đòn tấn công bẻ khóa (Jailbreak) hoặc Prompt Injection đi kèm câu từ chối lịch sự nhưng dứt khoát, tiêm vaccine phòng hộ cho mô hình học sinh trước các rủi ro bảo mật thực tế.

❓ Câu Hỏi Thường Gặp (FAQ)

🔗 Chương Tiếp Theo Trong Series

Sau khi hoàn tất quá trình chắt lọc tri thức suy luận từ giáo viên, bước tiếp theo là căn chỉnh mô hình theo sở thích của con người và ngăn chặn tình trạng suy diễn độc hại:
👉 Phần 5: Căn Chỉnh Hành Vi Mô Hình: DPO, GRPO & KTO.