引言

知识蒸馏（Knowledge Distillation）是将大模型（Teacher）的能力迁移到小模型（Student）的核心技术。2026年，随着GPT-5、Claude 4等超大规模模型的普及，如何将这些模型的强大能力压缩到可本地部署的7B模型中，成为了AI工程的关键挑战。本文将系统介绍蒸馏技术的最新进展。

知识蒸馏基础

经典蒸馏框架

经典知识蒸馏由Hinton等人于2015年提出，核心思想是让学生模型模仿教师模型的输出分布：

$$ \mathcal{L}_{\text{KD}} = (1-\alpha) \cdot \text{CE}(y, p_s) + \alpha \cdot T^2 \cdot \text{KL}(p_t^T | p_s^T) $$

其中：

  • $p_s$ 和 $p_t$ 分别是学生和教师模型的输出概率
  • $T$ 是温度参数，软化概率分布
  • $\alpha$ 是平衡系数
  • $y$ 是真实标签

温度缩放

温度参数 $T$ 控制输出分布的平滑程度：

$$ p_i^T = \frac{\exp(z_i / T)}{\sum_j \exp(z_j / T)} $$

class DistillationLoss(nn.Module):
    def __init__(self, alpha=0.5, temperature=4.0):
        super().__init__()
        self.alpha = alpha
        self.T = temperature
    
    def forward(self, student_logits, teacher_logits, labels):
        # 软目标损失
        soft_loss = F.kl_div(
            F.log_softmax(student_logits / self.T, dim=-1),
            F.softmax(teacher_logits / self.T, dim=-1),
            reduction='batchmean'
        ) * (self.T ** 2)
        
        # 硬目标损失
        hard_loss = F.cross_entropy(student_logits, labels)
        
        return (1 - self.alpha) * hard_loss + self.alpha * soft_loss

白盒蒸馏：访问教师内部状态

白盒蒸馏可以访问教师模型的logits、隐藏状态和注意力权重，提供更丰富的监督信号。

Logit级蒸馏

最直接的方案是让学生模仿教师的输出logits：

def logit_distillation(student_model, teacher_model, input_ids, beta=0.5, T=2.0):
    """
    Logit级蒸馏：学生模仿教师的输出分布
    """
    with torch.no_grad():
        teacher_outputs = teacher_model(input_ids)
        teacher_logits = teacher_outputs.logits
    
    student_outputs = student_model(input_ids)
    student_logits = student_outputs.logits
    
    # KL散度损失
    distill_loss = F.kl_div(
        F.log_softmax(student_logits[:, :-1] / T, dim=-1),
        F.softmax(teacher_logits[:, :-1] / T, dim=-1),
        reduction='batchmean'
    ) * (T ** 2)
    
    # 交叉熵损失
    ce_loss = F.cross_entropy(
        student_logits[:, :-1].reshape(-1, student_logits.size(-1)),
        input_ids[:, 1:].reshape(-1)
    )
    
    return beta * distill_loss + (1 - beta) * ce_loss

隐藏状态蒸馏

让学生模仿教师的中间层表示：

$$ \mathcal{L}_{\text{hidden}} = | W_h h_s - h_t |_2^2 $$

其中 $W_h$ 是可学习的投影矩阵，将学生隐藏状态映射到教师隐藏状态的维度。

class HiddenStateDistiller(nn.Module):
    def __init__(self, student_dim, teacher_dim, student_layers, teacher_layers):
        super().__init__()
        # 层映射：学生层 → 教师层
        self.layer_mapping = self._build_mapping(student_layers, teacher_layers)
        # 投影矩阵
        self.projectors = nn.ModuleList([
            nn.Linear(student_dim, teacher_dim, bias=False)
            for _ in range(len(self.layer_mapping))
        ])
    
    def _build_mapping(self, n_student, n_teacher):
        """均匀映射学生层到教师层"""
        return [int(i * n_teacher / n_student) for i in range(n_student)]
    
    def forward(self, student_hiddens, teacher_hiddens):
        loss = 0
        for i, (s_layer, t_layer) in enumerate(self.layer_mapping):
            s_hidden = student_hiddens[s_layer]
            t_hidden = teacher_hiddens[t_layer].detach()
            
            # 投影后计算MSE
            projected = self.projectors[i](s_hidden)
            loss += F.mse_loss(projected, t_hidden)
        
        return loss / len(self.layer_mapping)

注意力蒸馏

模仿教师的注意力模式，帮助学生学会类似的关注模式：

def attention_distillation(student_attns, teacher_attns, mask=None):
    """
    学生模仿教师的注意力权重分布
    """
    loss = 0
    for s_attn, t_attn in zip(student_attns, teacher_attns):
        # 对齐层数和头数
        s_attn = align_heads(s_attn, t_attn.shape[-2])
        
        # MSE损失
        loss += F.mse_loss(s_attn, t_attn.detach())
    
    return loss / len(student_attns)

黑盒蒸馏：仅访问API输出

黑盒蒸馏只能获取教师的输出文本，适用于蒸馏GPT-5、Claude 4等闭源模型。

数据合成蒸馏

使用教师模型生成训练数据，在数据上微调学生模型：

class SyntheticDataDistillation:
    def __init__(self, teacher_api, student_model, n_samples=100000):
        self.teacher = teacher_api
        self.student = student_model
        self.n_samples = n_samples
    
    def generate_training_data(self, prompts):
        """使用教师模型生成高质量训练数据"""
        training_data = []
        for prompt in tqdm(prompts):
            # 多样化生成
            for temp in [0.3, 0.7, 1.0]:
                response = self.teacher.chat(
                    prompt,
                    temperature=temp,
                    max_tokens=2048
                )
                training_data.append({
                    'prompt': prompt,
                    'response': response,
                    'quality_score': self.assess_quality(response)
                })
        return training_data
    
    def distill(self, training_data):
        """在合成数据上微调学生模型"""
        dataset = self.prepare_dataset(training_data)
        trainer = SFTTrainer(
            model=self.student,
            dataset=dataset,
            learning_rate=2e-5,
            epochs=3
        )
        trainer.train()

思维链蒸馏

思维链（Chain-of-Thought, CoT）蒸馏是2026年最重要的蒸馏方向之一——将教师的推理过程迁移给学生：

class CoTDistiller:
    def __init__(self, teacher_api, student_model):
        self.teacher = teacher_api
        self.student = student_model
    
    def generate_cot_data(self, problems):
        """
        让教师模型为每个问题生成详细的思维链
        """
        cot_data = []
        for problem in problems:
            prompt = f"""
            Solve this problem step by step. Show your reasoning process clearly.
            
            Problem: {problem}
            """
            cot_response = self.teacher.chat(prompt, temperature=0.3)
            
            # 提取最终答案
            final_answer = self.extract_answer(cot_response)
            
            cot_data.append({
                'problem': problem,
                'cot': cot_response,
                'answer': final_answer
            })
        return cot_data
    
    def distill_with_cot(self, cot_data):
        """
        学生学习教师的思维链过程
        """
        dataset = []
        for item in cot_data:
            dataset.append({
                'input': item['problem'],
                'output': item['cot']  # 学生学习完整的推理过程
            })
        
        trainer = SFTTrainer(
            model=self.student,
            dataset=dataset,
            packing=True,  # 使用序列打包提高效率
            learning_rate=5e-5,
            epochs=2
        )
        trainer.train()

多轮对话蒸馏

def multi_turn_distillation(teacher_api, student_model, n_conversations=10000):
    """
    蒸馏多轮对话能力
    """
    conversations = []
    
    for _ in range(n_conversations):
        # 教师模型生成多轮对话
        conv = generate_conversation(teacher_api, n_turns=5)
        conversations.append(conv)
    
    # 学生学习多轮对话模式
    dataset = ConversationDataset(conversations)
    trainer = SFTTrainer(
        model=student_model,
        dataset=dataset,
        max_seq_length=4096,
        learning_rate=1e-5
    )
    trainer.train()

渐进式蒸馏

渐进式蒸馏通过逐层或逐步迁移，降低蒸馏难度：

class ProgressiveDistillation:
    def __init__(self, teacher_model, student_model, n_stages=4):
        self.teacher = teacher_model
        self.student = student_model
        self.n_stages = n_stages
    
    def train(self, dataset):
        # 阶段1：仅蒸馏前1/4层
        for stage in range(self.n_stages):
            active_layers = self.get_active_layers(stage)
            self.distill_layers(dataset, active_layers)
    
    def get_active_layers(self, stage):
        """每个阶段激活更多层"""
        total = self.student.config.n_layers
        return list(range(int(total * (stage + 1) / self.n_stages)))
    
    def distill_layers(self, dataset, active_layers):
        """仅对指定层应用蒸馏损失"""
        for batch in dataset:
            with torch.no_grad():
                t_outputs = self.teacher(batch['input_ids'])
            
            s_outputs = self.student(batch['input_ids'])
            
            # 仅对活动层计算蒸馏损失
            loss = 0
            for layer in active_layers:
                loss += F.mse_loss(
                    s_outputs.hidden_states[layer],
                    t_outputs.hidden_states[layer].detach()
                )
            loss.backward()

蒸馏效果评估

评估维度

评估维度指标目标
任务性能MMLU, GSM8K, HumanEval接近教师的80-90%
生成质量BLEU, ROUGE, 人工评分与教师相当
推理能力数学准确率, 代码通过率达到教师70%以上
对话能力AlpacaEval, MT-Bench接近教师
推理速度tokens/s比教师快5-10倍

能力保留率分析

def evaluate_distillation(teacher_model, student_model, benchmarks):
    """
    评估蒸馏后学生的能力保留率
    """
    results = {}
    for bench_name, benchmark in benchmarks.items():
        teacher_score = evaluate(teacher_model, benchmark)
        student_score = evaluate(student_model, benchmark)
        retention = student_score / teacher_score * 100
        results[bench_name] = {
            'teacher': teacher_score,
            'student': student_score,
            'retention_rate': retention
        }
    return results

2026年蒸馏实践案例

GPT-5 → 7B蒸馏流程

  1. 数据准备：用GPT-5生成100万条高质量问答对
  2. CoT蒸馏：针对数学/代码任务生成10万条思维链
  3. 多轮对话：生成5万条多轮对话数据
  4. SFT训练：在蒸馏数据上微调7B基座模型
  5. DPO对齐：用GPT-5作为裁判生成偏好数据
  6. 量化部署：INT4量化后部署

效果数据

蒸馏方法MMLUGSM8KHumanEval推理速度
基座7B62.3%45.1%38.5%45 tok/s
Logit蒸馏68.7%52.3%45.2%45 tok/s
CoT蒸馏71.2%68.5%58.7%45 tok/s
全面蒸馏73.8%72.1%62.3%45 tok/s
GPT-5(参考)89.5%95.2%88.1%12 tok/s

结语

知识蒸馏是弥合大模型能力与部署成本之间鸿沟的关键技术。2026年的实践表明，通过白盒+黑盒结合、思维链蒸馏、渐进式训练等方法，7B模型可以保留GPT-5级别模型70-80%的能力，同时推理速度快3-5倍。随着蒸馏理论的完善和工具链的成熟，“大模型蒸馏到小模型"将成为AI应用的标准流程。

加入讨论

这篇文章有姊妹讨论帖在硅基AGI论坛 — 全球首个碳基硅基认知交流平台。

碳基与硅基的智慧碰撞，认知差异创造无限可能。