ONE is preparing: 01 / INITIALIZING MODEL ROUTER. Evaluating routing across providers.
Current state
01 / INITIALIZING MODEL ROUTER.

Evaluating routing across providers.

Start learning
← Fine-tuning & Tối ưu

AI Builder

Chưng cất kiến thức

Vietnamese onlyThe learning content is available in Vietnamese only. The surrounding interface follows your language.

Kỹ thuật chuyển giao kiến thức từ mô hình lớn (teacher) sang mô hình nhỏ (student) hiệu quả hơn.

lesson105 minFine-tuning & Tối ưuAI Engineer

Dự đoán

GPT-4 rất giỏi nhưng quá lớn để chạy trên điện thoại. Cách nào tốt nhất để tạo phiên bản nhỏ mà vẫn giữ được phần lớn năng lực?

Ẩn dụ — giáo sư và sinh viên

Một giáo sư ngôn ngữ học đang chỉ dẫn sinh viên mới vào nghề, có hai cách dạy khác nhau.

Cách dạyGiáo sư nói gìSinh viên học được gì
Hard label (cổ điển)“Câu 1 đáp án là A, câu 2 đáp án là B”Thuộc bảng đáp án, nhưng không hiểu vì sao; bị động khi gặp bài mới
Soft label (chưng cất)“B cũng khá hợp lý, chỉ thiếu một chi tiết; C sai vì vi phạm quy tắc này”Cấu trúc của bài toán, nên suy ra được biến thể mới

Knowledge distillation là cách thứ hai áp dụng vào mạng nơ-ron. Teacher không chỉ cung cấp nhãn đúng mà còn cung cấp toàn bộ phân bố xác suất trên mọi lớp. Mỗi con số nhỏ là một gợi ý về cách teacher nhìn thế giới. Student hấp thụ các gợi ý đó và đạt năng lực vượt xa việc học từ hard label, dù kích thước chỉ bằng một nửa, một phần ba hoặc một phần mười.

Có thể đi xa hơn: teacher không chỉ thì thầm đáp án mà còn chỉ cách làm, ví dụ attention map hoặc hidden state trung gian. Khi student khớp cả quá trình đó chứ không chỉ đầu ra cuối, gọi là pattern distillation.

Khám phá — nhiệt độ và soft label

Teacher và student: teacher sâu và rộng, student nông và hẹp. Với pattern distillation, student còn khớp biểu diễn trung gian của teacher tại các tầng tương ứng.

Nhiệt độ chưng cất T làm mềm phân bố xác suất. T = 1 cho phân bố sắc nét; T = 20 cho phân bố rất mềm. Khi T tăng, entropy của teacher tăng, và loss distillation là KL divergence giữa phân bố student và teacher. Hinton nhân thêm T² để gradient không bị co lại.

Khoảnh khắc aha

Khi teacher nói “70% mèo, 15% chó, 10% thỏ”, student không chỉ biết đáp án là mèo mà còn biết mèo và chó giống nhau hơn mèo và cá. Thông tin ẩn này, dark knowledge, là lý do distillation hiệu quả hơn dạy bằng hard label. Điều đáng kinh ngạc: chính các xác suất nhỏ bị bỏ qua mới là phần quý giá nhất, vì chúng mô tả cấu trúc của không gian lớp. Hard label làm ta mù trước cấu trúc đó.

Thử thách

Teacher cho soft label [0,8; 0,15; 0,04; 0,01]. Hard label là [1, 0, 0, 0]. Thông tin nào bị mất khi dùng hard label?
Bạn huấn luyện student với α = 0 (chỉ soft loss). Sau 10 epoch, student bắt đầu phạm các lỗi mà teacher không hề có. Vấn đề gì?

Lý thuyết

Knowledge distillation (Hinton, Vinyals và Dean, 2015) huấn luyện student trên hỗn hợp hard label và soft label từ teacher. Đây là một cách nén mô hình thay thế cho lượng tử hoá và pruning, với ưu điểm đặc biệt: student có thể có kiến trúc hoàn toàn khác teacher.

L=α⋅LCE(y,y^s)+(1−α)⋅T2⋅DKL(σ(zt/T)∥σ(zs/T))\mathcal{L} = \alpha \cdot \mathcal{L}_{\text{CE}}(y, \hat{y}_s) + (1-\alpha) \cdot T^2 \cdot D_{\text{KL}}(\sigma(z_t/T) \| \sigma(z_s/T))

T là temperature; z_t và z_s là logit của teacher và student; α cân bằng giữa hard loss và soft loss. Nhân T² để gradient không bị thu nhỏ khi T tăng, một chi tiết kỹ thuật Hinton đưa ra ngay trong bài báo gốc.

Quy trình cơ bản gồm ba bước:

  • Teacher dự đoán: mô hình lớn đã huấn luyện tốt chạy trên dữ liệu, tạo soft label (logit hoặc xác suất sau softmax).
  • Làm mềm phân bố: chia logit cho T trước softmax. T cao làm phân bố phẳng hơn, lộ rõ thứ hạng tương đối của mọi lớp.
  • Student học: huấn luyện trên cả hard label và soft label, với trọng số α.

distillation_loss.py

import torch.nn.functional as F

def distillation_loss(
    student_logits,
    teacher_logits,
    labels,
    T: float = 4.0,
    alpha: float = 0.5,
):
    """Hàm loss distillation chuẩn Hinton 2015.

    Args:
        student_logits: output thô của student (chưa softmax), shape (B, C)
        teacher_logits: output thô của teacher, shape (B, C)
        labels:         ground truth hard labels, shape (B,)
        T:              temperature — càng cao, phân bố càng mềm
        alpha:          trọng số hard loss vs soft loss

    Trả về scalar loss để backprop.
    """
    # ---- Soft loss: KL divergence trên phân bố đã làm mềm ----
    soft_t = F.softmax(teacher_logits / T, dim=-1)
    log_soft_s = F.log_softmax(student_logits / T, dim=-1)
    soft_loss = F.kl_div(
        log_soft_s,
        soft_t,
        reduction="batchmean",
    ) * (T ** 2)  # nhân T^2 để bù gradient

    # ---- Hard loss: cross-entropy với ground truth ----
    hard_loss = F.cross_entropy(student_logits, labels)

    return alpha * hard_loss + (1 - alpha) * soft_loss


# ---- Vòng lặp huấn luyện ngắn gọn ----
for batch in loader:
    x, y = batch
    with torch.no_grad():
        t_logits = teacher(x)         # teacher đóng băng
    s_logits = student(x)
    loss = distillation_loss(s_logits, t_logits, y, T=4.0, alpha=0.5)

    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

Với các biến thể pattern distillation (TinyBERT, MobileBERT, DistilBERT), bổ sung loss trung gian, ví dụ buộc student khớp hidden state và attention map của teacher ở các tầng tương ứng:

pattern_distill.py

import torch
import torch.nn.functional as F

class PatternDistiller(torch.nn.Module):
    """Distill cả output cuối lẫn hidden state trung gian.

    Các tầng của student và teacher được ánh xạ qua student_to_teacher.
    """

    def __init__(self, student, teacher, student_to_teacher: dict[int, int]):
        super().__init__()
        self.student = student
        self.teacher = teacher
        self.teacher.eval()
        for p in self.teacher.parameters():
            p.requires_grad_(False)
        self.pattern_map = student_to_teacher
        # Projection nếu kích thước hidden khác nhau
        self.proj = torch.nn.Linear(
            student.hidden_size,
            teacher.hidden_size,
            bias=False,
        )

    def forward(self, x, labels, T=4.0, alpha=0.5, beta=0.1):
        s_out = self.student(x, output_hidden_states=True)
        with torch.no_grad():
            t_out = self.teacher(x, output_hidden_states=True)

        # 1) Logit loss (Hinton KD)
        logit_loss = (
            F.kl_div(
                F.log_softmax(s_out.logits / T, dim=-1),
                F.softmax(t_out.logits / T, dim=-1),
                reduction="batchmean",
            )
            * (T ** 2)
        )
        ce = F.cross_entropy(s_out.logits, labels)

        # 2) Hidden-state loss — MSE giữa các tầng tương ứng
        hidden_loss = 0.0
        for s_idx, t_idx in self.pattern_map.items():
            s_h = self.proj(s_out.hidden_states[s_idx])
            t_h = t_out.hidden_states[t_idx]
            hidden_loss = hidden_loss + F.mse_loss(s_h, t_h)

        return alpha * ce + (1 - alpha) * logit_loss + beta * hidden_loss

Vì sao nhân T²?

Gradient của cross-entropy trên soft label tỉ lệ với 1/T. Vì loss tính trên hai phân bố đều chia cho T, gradient tổng tỉ lệ với 1/T². Khi T tăng, tín hiệu giảm mạnh. Nhân lại T² giữ độ lớn gradient tương đương giữa soft loss và hard loss; nếu không, soft loss gần như vô hình khi T > 3.

∇zsLsoft=1T(σ(zs/T)−σ(zt/T))  ⟹  nhaˆn T2 để buˋ\nabla_{z_s} \mathcal{L}_{\text{soft}} = \frac{1}{T}\big(\sigma(z_s/T) - \sigma(z_t/T)\big) \implies \text{nhân } T^2 \text{ để bù}

Các biến thể nổi bật

  • FitNets (Romero, 2015): student khớp feature map ở một tầng trung gian của teacher.
  • Attention Transfer (Zagoruyko, 2017): khớp attention map (tổng bình phương feature theo kênh); dễ triển khai hơn FitNets.
  • TinyBERT (Jiao, 2020): distill bốn loại tín hiệu: embedding, attention, hidden state và dự đoán. Theo nguồn bài đạt 96,8% hiệu suất BERT với khoảng 1/7 tham số.
  • DistilBERT (Sanh, 2019): distill logit cùng ba loss. Kích thước 66 triệu, giữ khoảng 97% accuracy BERT trên GLUE.
  • MobileBERT (Sun, 2020): kiến trúc bottleneck và transfer tiến dần; chạy thời gian thực trên điện thoại.
  • Orca và Phi (Microsoft, 2023 đến 2024): distill chain-of-thought từ GPT-4 vào mô hình 1,3 đến 13 tỷ tham số.
  • MiniLLM (2023): dùng reverse KL thay cho forward KL, nên student học các mode quan trọng thay vì cố phủ mọi mode.

Ứng dụng thực tế

  • Phục vụ chi phí thấp: teacher lớn distill thành mô hình 7B cho tác vụ cụ thể như dịch, tóm tắt, phân loại.
  • On-device: DistilBERT và MobileBERT chạy trên điện thoại với độ trễ vài mili giây.
  • Edge: student 1 đến 3 triệu tham số triển khai trên vi điều khiển cho IoT.
  • Nén ensemble: distill một ensemble mười mô hình thành một mô hình đơn.
  • Bảo vệ quyền riêng tư: teacher huấn luyện trên dữ liệu nhạy cảm; student chỉ học qua soft label.

Các cạm bẫy

  • Teacher yếu: nếu teacher chỉ đạt 80% accuracy, student khó vượt được. Chọn teacher đủ mạnh trước.
  • Khoảng cách năng lực quá lớn: teacher 100 tỷ và student 100 triệu là quá xa. Dùng teacher assistant, một mô hình trung gian (ví dụ 10 tỷ), làm cầu nối.
  • Quên đóng băng teacher: nếu teacher vẫn có gradient, cả hai cùng cập nhật và loss mất ý nghĩa.
  • α sai: α = 0 làm student bắt chước cả sai lầm; α = 1 làm distillation mất tác dụng. Bắt đầu từ α = 0,5.
  • Dữ liệu distillation kém: dùng thêm dữ liệu không nhãn, teacher tạo nhãn cho nó, thường cải thiện mạnh.

Tóm tắt

  • Distillation dạy student bắt chước teacher qua soft label: không chỉ đáp án mà cả quá trình suy luận qua phân bố xác suất.
  • Dark knowledge: thông tin ẩn trong xác suất nhỏ giúp student tổng quát hoá tốt hơn hard label.
  • Temperature T: thấp (1 đến 3) sắc nét; vừa (4 đến 10) thường tốt nhất; cao (trên 10) tín hiệu yếu.
  • Loss = α·CE(hard) + (1−α)·T²·KL(soft). Nhân T² để bù gradient.
  • Pattern distillation khớp cả hidden state và attention; theo nguồn bài cải thiện khoảng 2 đến 4% so với chỉ dùng logit.
  • DistilBERT: nhỏ hơn 40%, nhanh hơn 60%, giữ 97% hiệu suất theo nguồn bài.

Continue the module

Lesson 6 of 8