LLM蒸馏：MiniLLM与GKD

在大语言模型时代，如何将超大模型的知识迁移到可部署的小模型是一个核心挑战。本文深入探讨两种重要的LLM蒸馏方法：MiniLLM和GKD（Generalized Knowledge Distillation），它们针对自回归生成模型的特殊性提出了有效的解决方案。

1. 概述：LLM蒸馏的挑战

1.1 自回归模型的特殊性

与分类模型不同，LLM作为自回归生成模型具有独特的特性：

特性	分类模型蒸馏	自回归LLM蒸馏
输出空间	有限类别（数百到数千）	巨大词表（通常32000-128000）
生成过程	单次前向传播	逐token自回归生成
暴露偏差	不存在	严重（Teacher Forcing vs 自生成）
分布形状	相对集中	多峰分布，高熵
优化目标	类别对齐	序列分布匹配

1.2 标准KD对LLM的问题

传统的知识蒸馏方法（如Hinton等人的开创性工作）假设输出分布是相对”尖锐”的，学生的任务是学习教师在正确类别上的高概率。然而，这一假设在LLM场景下不再成立：

问题一：多峰分布的挑战

LLM对同一问题可能生成多个合理的响应。教师的输出分布通常是多峰的：

p_{T} (y ∣ x) = k = 1 \sum K α_{k} \cdot δ (y - y_{k}^{*})

其中 $y_{k}^{*}$ 是第 $k$ 种合理回复， $α_{k}$ 是对应的概率质量。

问题二：巨大输出空间

词表大小通常在32000以上，意味着每一步的蒸馏损失需要计算跨词表的KL散度：

D_{K L} (p_{S} ∥ p_{T}) = v \in V \sum p_{S} (v) lo g \frac{p _{S} ( v )}{p _{T} ( v )}

这导致梯度信号分散，难以聚焦于关键token。

问题三：序列级一致性

标准KD优化令牌级的分布匹配，但生成的全局质量（如连贯性、流畅性）无法通过令牌级损失直接优化。

1.3 知识类型与蒸馏策略

LLM中的知识可分为三类，对应不同的蒸馏策略：

知识类型	描述	蒸馏方法
表层知识	词汇选择、短语搭配	软标签蒸馏
结构知识	推理路径、论证结构	Chain-of-Thought蒸馏
隐式偏好	生成风格、安全边界	偏好对齐蒸馏

2. MiniLLM方法

2.1 核心思想：反向KL散度

MiniLLM由Gu等人于2024年提出¹，其核心洞察是：对于生成式LLM，反向KL散度（Reverse KL）比标准KL更合适。

数学定义对比：

标准KL散度： $D_{K L} (p_{T} ∥ p_{S}) = \sum_{y} p_{T} (y) lo g \frac{p _{T} ( y )}{p _{S} ( y )}$
反向KL散度： $D_{K L} (p_{S} ∥ p_{T}) = \sum_{y} p_{S} (y) lo g \frac{p _{S} ( y )}{p _{T} ( y )}$

2.2 标准KL vs 反向KL

这两种散度在多峰分布上有本质不同的行为：

标准KL（覆盖模式）：

学生的质量函数 $p_{S}$ 需要覆盖教师的所有模式
会将概率质量分配到教师低概率区域
结果：模糊生成，学生尝试匹配所有可能的输出

反向KL（模式寻求）：

学生的质量函数 $p_{S}$ 包含在教师的一个模式中
学生选择一个最可能的模式并完美匹配
结果：尖锐生成，学生专注于教师分布的一个峰

D_{K L} (p_{S} ∥ p_{T}) \approx 0 当 p_{S} (y) > 0 \Rightarrow p_{T} (y) > 0

2.3 MiniLLM目标函数推导

MiniLLM使用反向KL作为蒸馏损失的核心：

L_{M ini LL M} = D_{K L} (p_{S} ∥ p_{T}) = t \sum v \in V \sum p_{S} (v ∣ y_{< t}) lo g \frac{p _{S} ( v ∣ y _{< t} )}{p _{T} ( v ∣ y _{< t} )}

展开形式：

L_{M ini LL M} = 期望教师负对数似然 - t \sum v \sum p_{S} (v ∣ y_{< t}) lo g p_{T} (v ∣ y_{< t}) - 学生熵 H (p_{S})

其中 $H (p_{S})$ 是学生模型在每一步的熵。

2.4 生成质量优化技术

2.4.1 混合目标函数

MiniLLM采用多目标优化来平衡不同方面：

L_{t o t a l} = L_{L M} + λ_{1} L_{K L} + λ_{2} L_{l e n g t h}

其中：

$L_{L M} = - lo g p_{S} (y^{*} ∣ x)$ ：标准语言建模损失
$L_{K L} = D_{K L} (p_{S} ∥ p_{T})$ ：反向KL蒸馏损失
$L_{l e n g t h}$ ：长度控制损失，防止过度压缩

2.4.2 教师采样策略

使用教师模型采样而非贪婪解码来生成训练数据：

def teacher_sample(teacher_model, prompt, temperature=0.7, top_p=0.9):
    """教师采样生成多样化的训练序列"""
    inputs = tokenizer(prompt, return_tensors="pt").to(teacher_model.device)
    
    with torch.no_grad():
        outputs = teacher_model.generate(
            **inputs,
            max_new_tokens=256,
            temperature=temperature,
            top_p=top_p,
            do_sample=True,
            num_return_sequences=4  # 生成多条候选序列
        )
    
    return [tokenizer.decode(seq, skip_special_tokens=True) for seq in outputs]

为什么采样优于贪婪：

捕获教师分布的多样性
避免学生过度拟合教师的单一贪婪路径
暴露更多”次优但合理”的生成模式

2.4.3 渐进式训练

MiniLLM采用两阶段训练策略：

阶段	目标	训练数据
阶段1：知识获取	学习教师的核心知识	标准微调数据 + 蒸馏数据
阶段2：质量精炼	优化生成质量	高质量样本 + 长度控制

3. GKD（广义知识蒸馏）

3.1 离线蒸馏 vs 在线蒸馏

传统的知识蒸馏通常是离线的：先训练教师，再固定教师生成软标签，最后训练学生。

类型	特点	优势	劣势
离线蒸馏	固定教师生成数据	效率高，可并行	暴露偏差，分布偏移
在线蒸馏	师生同步更新	动态适应，暴露偏差小	计算开销大

3.2 GKD框架

GKD（Generalized Knowledge Distillation）由Agarwal等人于2024年提出²，是一个统一的蒸馏框架，涵盖了多种蒸馏策略。

核心定义：GKD将知识蒸馏形式化为师生分布对齐问题：

θ_{S} min E_{x \sim D} [E_{y \sim π_{S} (\cdot ∣ x)} [r (x, y)]] + β \cdot D (π_{S} ∥ π_{T})

其中 $r (x, y)$ 是奖励函数， $D$ 是分布散度。

3.3 师生分布对齐

GKD的关键洞见是：蒸馏过程中学生分布应该逐步接近教师分布，但不能过于接近。

过于接近的问题：

学生完全复制教师，丧失探索新模式的机会
无法超越教师的学习

GKD的正则化视角：

L_{G KD} = (1 - α) \cdot L_{t a s k} + α \cdot D_{K L} (π_{S} ∥ π_{T})

其中 $α$ 控制蒸馏强度。

3.4 On-Policy采样的重要性

GKD强调On-Policy（在线策略）采样的重要性：

Off-Policy问题：

使用历史策略生成的数据训练当前策略
导致分布偏移，梯度估计有偏

On-Policy解决方案：

每轮迭代都从当前学生策略采样新数据
保证训练数据与当前策略一致

class GKD Trainer:
    def __init__(self, student, teacher, beta=0.1):
        self.student = student
        self.teacher = teacher
        self.beta = beta  # KL正则化权重
    
    def on_policy_step(self, prompts):
        """GKD的on-policy训练步骤"""
        # Step 1: 从当前学生策略采样
        student_responses = self.student.sample(prompts)
        
        # Step 2: 计算KL散度损失（On-Policy）
        kl_losses = []
        for prompt, response in zip(prompts, student_responses):
            student_logits = self.student.get_logits(prompt, response)
            teacher_logits = self.teacher.get_logits(prompt, response)
            
            kl_loss = self.compute_kl_divergence(student_logits, teacher_logits)
            kl_losses.append(kl_loss)
        
        # Step 3: 反向传播更新学生
        total_loss = self.task_loss + self.beta * mean(kl_losses)
        total_loss.backward()
        
        return total_loss.item()

3.5 GKD与MiniLLM的关系

方面	GKD	MiniLLM
核心机制	师生分布对齐的正则化	反向KL散度
采样策略	On-Policy	Off-Policy + 采样
优化目标	任务损失 + KL正则化	反向KL + 长度控制
适用场景	通用蒸馏框架	生成质量优化

GKD可以视为MiniLLM的理论推广：MiniLLM是GKD在 $β = 1$ 、使用反向KL时的特例。

4. 技术细节

4.1 温度调度

温度参数 $τ$ 控制教师分布的”尖锐度”：

p_{τ} (y) = \frac{exp ( z _{y} / τ )}{\sum _{i} exp ( z _{i} / τ )}

温度调度策略：

策略	描述	适用场景
固定低温（ $τ < 1$ ）	分布更尖锐，强化主要模式	知识聚焦
固定高温（ $τ > 1$ ）	分布更平滑，保留多样性	探索充分
退火温度	从高到低逐渐降低	平衡探索与收敛
自适应温度	根据训练阶段动态调整	课程学习

def temperature_schedule(epoch, total_epochs, T_init=2.0, T_final=0.5):
    """余弦退火温度调度"""
    if epoch < total_epochs * 0.3:
        return T_init
    else:
        progress = (epoch - total_epochs * 0.3) / (total_epochs * 0.7)
        return T_final + 0.5 * (T_init - T_final) * (1 + np.cos(np.pi * progress))

4.2 令牌级 vs 序列级蒸馏

令牌级蒸馏：

在每个位置计算教师与学生的KL散度
梯度信号丰富，但可能优化局部最优

L_{t o k e n} = - t \sum v \sum p_{T} (v ∣ x, y_{< t}) lo g p_{S} (v ∣ x, y_{< t})

序列级蒸馏：

计算整个序列的分布匹配
捕获全局依赖，但训练不稳定

L_{se q} = - lo g p_{S} (y^{*} ∣ x) + λ \cdot D_{K L} (p_{S} (y ∣ x) ∥ p_{T} (y ∣ x))

混合策略：GKD和MiniLLM通常采用令牌级蒸馏为主、序列级指标为辅的策略。

4.3 渐进式蒸馏策略

思想：从简单到复杂，逐步增加蒸馏难度。

阶段	学生能力	蒸馏难度	教师温度
阶段1	弱	低	1.0
阶段2	中	中	1.5
阶段3	强	高	2.0

课程学习：

def curriculum_distillation(student, teacher, dataloader, epochs):
    """课程蒸馏：难度渐进增加"""
    for epoch in range(epochs):
        # 计算当前难度等级
        difficulty = min(1.0, epoch / (epochs * 0.6))
        
        # 根据难度筛选/加权样本
        current_data = filter_by_difficulty(dataloader, threshold=difficulty)
        
        # 调整温度
        T = 1.0 + difficulty  # 从1.0线性增加到2.0
        
        # 训练
        train_step(student, teacher, current_data, temperature=T)

4.4 轻量化方法：LoRA蒸馏

将LoRA与蒸馏结合，既压缩模型又保持性能：

LoRA蒸馏流程：

class LoRA_Distillation:
    def __init__(self, student_model, teacher_model, rank=16, alpha=32):
        # 冻结原始权重
        self.student = student_model
        self.student.freeze_base()
        
        # 注入LoRA适配器
        self.lora_config = LoRAConfig(rank=rank, alpha=alpha)
        apply_lora(self.student, self.lora_config)
        
        self.teacher = teacher_model
        self.teacher.eval()
    
    def distill_step(self, inputs):
        """LoRA蒸馏步骤"""
        # 教师前向（冻结）
        with torch.no_grad():
            teacher_logits = self.teacher(**inputs).logits
        
        # 学生前向（仅LoRA参数可学习）
        student_logits = self.student(**inputs).logits
        
        # 计算蒸馏损失
        kl_loss = F.kl_div(
            F.log_softmax(student_logits / self.temperature, dim=-1),
            F.softmax(teacher_logits / self.temperature, dim=-1),
            reduction='batchmean'
        ) * (self.temperature ** 2)
        
        # 反向传播（仅更新LoRA参数）
        kl_loss.backward()
        
        return kl_loss.item()

LoRA蒸馏的优势：

参数量小：仅需训练 $\sim 2 \times d_{m o d e l} \times r$ 参数
内存高效：大幅降低GPU显存需求
知识保留：LoRA能有效捕捉教师的关键知识模式

5. 代码实现

5.1 MiniLLM训练代码

#include <bits/stdc++.h>
using namespace std;
 
// MiniLLM核心训练循环（C++伪代码）
struct MiniLLMTrainer {
    float temperature = 1.0;
    float kl_weight = 0.5;
    float length_penalty = 0.1;
    
    // 反向KL散度计算
    float reverse_kl_divergence(
        const vector<float>& student_logits,
        const vector<float>& teacher_logits,
        int vocab_size
    ) {
        // 使用Log-Softmax稳定计算
        vector<float> student_logprob(vocab_size);
        vector<float> teacher_logprob(vocab_size);
        
        float max_logit = *max_element(student_logits.begin(), student_logits.end());
        float sum_exp = 0.0f;
        for (int i = 0; i < vocab_size; i++) {
            sum_exp += exp(student_logits[i] - max_logit);
        }
        float log_sum_exp = max_logit + log(sum_exp);
        
        for (int i = 0; i < vocab_size; i++) {
            student_logprob[i] = student_logits[i] - log_sum_exp;
        }
        
        // 教师logprob类似计算...
        max_logit = *max_element(teacher_logits.begin(), teacher_logits.end());
        sum_exp = 0.0f;
        for (int i = 0; i < vocab_size; i++) {
            sum_exp += exp(teacher_logits[i] - max_logit);
        }
        log_sum_exp = max_logit + log(sum_exp);
        
        for (int i = 0; i < vocab_size; i++) {
            teacher_logprob[i] = teacher_logits[i] - log_sum_exp;
        }
        
        // 反向KL: D_KL(p_S || p_T) = sum p_S * (log p_S - log p_T)
        float kl_div = 0.0f;
        float entropy = 0.0f;
        float max_student = *max_element(student_logits.begin(), student_logits.end());
        sum_exp = 0.0f;
        for (int i = 0; i < vocab_size; i++) {
            sum_exp += exp(student_logits[i] - max_student);
        }
        log_sum_exp = max_student + log(sum_exp);
        
        for (int i = 0; i < vocab_size; i++) {
            float p = exp(student_logits[i] - log_sum_exp);
            kl_div += p * (student_logprob[i] - teacher_logprob[i]);
            if (p > 1e-10) {
                entropy -= p * log(p);
            }
        }
        
        return kl_div;
    }
    
    float compute_loss(
        const vector<vector<float>>& student_logits_seq,
        const vector<vector<float>>& teacher_logits_seq,
        const vector<int>& target_ids,
        int seq_len
    ) {
        float total_loss = 0.0f;
        
        for (int t = 0; t < seq_len; t++) {
            // 语言建模损失
            float lm_loss = -student_logits_seq[t][target_ids[t]];
            
            // 反向KL蒸馏损失
            float kl_loss = reverse_kl_divergence(
                student_logits_seq[t],
                teacher_logits_seq[t],
                student_logits_seq[t].size()
            );
            
            // 长度惩罚（可选）
            float len_penalty = length_penalty * t / seq_len;
            
            total_loss += lm_loss + kl_weight * kl_loss + len_penalty;
        }
        
        return total_loss / seq_len;
    }
};

5.2 GKD训练代码

#include <bits/stdc++.h>
using namespace std;
 
struct GKDTrainer {
    float beta;              // KL正则化权重
    float clip_epsilon;       // PPO风格的裁剪范围
    int num_samples;         // 每条prompt的采样数
    
    GKDTrainer(float b = 0.1, float eps = 0.2, int n = 4)
        : beta(b), clip_epsilon(eps), num_samples(n) {}
    
    // On-Policy采样
    vector<int> sample_student(const Model& student, const vector<int>& prompt_ids) {
        vector<int> output_ids = prompt_ids;
        int max_len = 256;
        
        for (int step = 0; step < max_len; step++) {
            auto logits = student.forward(output_ids);
            int next_token = sample_topp(logits.back(), 0.9);  // Top-p采样
            if (next_token == EOS_TOKEN) break;
            output_ids.push_back(next_token);
        }
        return output_ids;
    }
    
    // KL散度计算（标准KL用于GKD）
    float kl_divergence(
        const vector<float>& student_logprob,
        const vector<float>& teacher_logprob
    ) {
        float kl = 0.0f;
        for (size_t i = 0; i < student_logprob.size(); i++) {
            float p = exp(student_logprob[i]);
            if (p > 1e-10) {
                kl += p * (student_logprob[i] - teacher_logprob[i]);
            }
        }
        return kl;
    }
    
    // GKD损失计算
    pair<float, map<string, float>> compute_gkd_loss(
        Model& student,
        const Model& teacher,
        const vector<int>& prompt_ids,
        const vector<int>& response_ids
    ) {
        // 任务损失（语言建模）
        float task_loss = 0.0f;
        auto student_logits = student.forward(prompt_ids, response_ids);
        
        for (size_t t = 0; t < response_ids.size(); t++) {
            task_loss -= student_logits[t][response_ids[t]];
        }
        task_loss /= response_ids.size();
        
        // KL正则化损失（On-Policy）
        auto teacher_logits = teacher.forward(prompt_ids, response_ids);
        float kl_loss = 0.0f;
        
        for (size_t t = 0; t < response_ids.size(); t++) {
            vector<float> s_logprob = log_softmax(student_logits[t]);
            vector<float> t_logprob = log_softmax(teacher_logits[t]);
            kl_loss += kl_divergence(s_logprob, t_logprob);
        }
        kl_loss /= response_ids.size();
        
        // GKD总损失
        float total_loss = (1 - beta) * task_loss + beta * kl_loss;
        
        return {total_loss, {{"task_loss", task_loss}, {"kl_loss", kl_loss}}};
    }
    
    // 训练步骤
    void train_step(
        Model& student,
        const Model& teacher,
        const vector<vector<int>>& prompts
    ) {
        student.train();
        teacher.eval();
        
        float total_loss = 0.0f;
        int batch_size = prompts.size();
        
        for (int i = 0; i < batch_size; i++) {
            // On-Policy采样（从当前学生策略）
            auto response = sample_student(student, prompts[i]);
            
            // 计算GKD损失
            auto [loss, metrics] = compute_gkd_loss(student, teacher, prompts[i], response);
            
            // 反向传播
            student.backward(loss);
            student.step();
            student.zero_grad();
            
            total_loss += loss;
        }
        
        cout << "GKD Loss: " << total_loss / batch_size << endl;
    }
};

5.3 关键超参数设置

超参数	推荐值	说明
蒸馏温度 $τ$	1.5 - 3.0	控制教师分布的平滑度
KL权重 $β$	0.1 - 0.5	蒸馏损失的相对权重
采样温度	0.5 - 0.9	教师采样时的温度
Top-p	0.85 - 0.95	核采样阈值
LoRA rank	8 - 32	轻量化蒸馏的秩
训练步数	1000 - 10000	根据模型大小调整

6. 实验结果

6.1 压缩比与性能权衡

实验表明，MiniLLM和GKD在不同压缩比下都能保持较好的性能：

压缩比	教师模型	学生模型	保留性能
4x	LLaMA-7B	LLaMA-1.3B	~95%
8x	LLaMA-7B	LLaMA-0.8B	~90%
16x	LLaMA-7B	LLaMA-0.4B	~85%
10x	GPT-3.5	GPT-2-small	~88%

6.2 不同蒸馏方法的对比

方法	困惑度(PPL)	生成质量	训练效率	计算开销
标准KD	中等	模糊	高	低
MiniLLM	较低	清晰	中	中
GKD	较低	良好	中	中
MiniLLM + LoRA	低	良好	高	低

6.3 生成质量评估

生成质量评估通常使用多个指标：

指标	测量内容	MiniLLM vs 标准KD
困惑度(PPL)	语言流畅性	相当或更优
多样性(Dist-1/2)	n-gram多样性	显著提升
MAUVE	分布对齐	明显改善
人类评估	整体质量	更受偏好

7. 蒸馏与其他技术的结合

7.1 蒸馏 + RLHF

将知识蒸馏与GRPO等强化学习方法结合：

流程：

阶段1：蒸馏预训练：使用MiniLLM/GKD将教师知识迁移到学生
阶段2：偏好对齐：使用GRPO进一步优化学生模型的偏好

class DistillThenRLHFPipeline:
    def __init__(self, teacher, student):
        self.teacher = teacher
        self.student = student
        self.distiller = MiniLLMTrainer()
        self.rl_trainer = GRPOTrainer()
    
    def train(self, prompts, reward_model, num_distill_steps=5000, num_rl_steps=1000):
        # 阶段1：知识蒸馏
        print("阶段1：知识蒸馏...")
        for step in range(num_distill_steps):
            batch = sample_batch(prompts, batch_size=16)
            teacher_outputs = self.teacher.generate(batch)
            loss = self.distiller.distill_step(self.student, teacher_outputs)
            
            if step % 100 == 0:
                print(f"蒸馏步骤 {step}, 损失: {loss:.4f}")
        
        # 阶段2：RLHF偏好对齐
        print("阶段2：RLHF偏好对齐...")
        self.student = self.rl_trainer.train(self.student, prompts, reward_model, num_rl_steps)
        
        return self.student

7.2 蒸馏 + 量化

蒸馏与量化结合可以实现更极致的压缩：

量化方法	精度	蒸馏兼容性	压缩效果
FP16	高	完全兼容	2x
INT8	中	兼容	4x
INT4	中低	需要校准	8x
GPTQ	中	蒸馏后应用	4-8x

蒸馏感知量化（DAQ）：

class DistillationAwareQuantization:
    def __init__(self, bit_width=4):
        self.bit_width = bit_width
    
    def quantize_with_distillation(self, student, teacher, calibration_data):
        """蒸馏感知的量化训练"""
        
        # Step 1: 蒸馏训练获得连续权重
        print("蒸馏训练中...")
        distiller = MiniLLMTrainer(beta=0.2)
        for _ in range(5000):
            batch = sample_batch(calibration_data)
            distiller.distill_step(student, teacher, batch)
        
        # Step 2: 蒸馏感知的量化微调
        print("量化微调中...")
        for epoch in range(10):
            for batch in calibration_data:
                # 前向：量化前传
                quantized_logits = self.quantize_forward(student, batch)
                
                # 计算蒸馏损失
                with torch.no_grad():
                    teacher_logits = teacher(**batch).logits
                
                loss = F.kl_div(
                    F.log_softmax(quantized_logits / 2.0, dim=-1),
                    F.softmax(teacher_logits / 2.0, dim=-1)
                )
                
                # 反向传播到量化参数
                loss.backward()
        
        return student

7.3 多教师蒸馏

使用多个教师模型进行蒸馏，融合不同教师的知识：

多教师策略：

策略	方法	优势	劣势
平均融合	$L = \frac{1}{K} \sum_{k} D_{K L} (p_{S} ∥ p_{T_{k}})$	简单稳定	可能冲突
加权融合	根据教师质量动态加权	灵活	需调参
专家路由	不同样本用不同教师	专业化	复杂

class MultiTeacherDistillation:
    def __init__(self, teachers, alpha_k=None):
        """
        teachers: 教师模型列表
        alpha_k: 各教师的权重（归一化）
        """
        self.teachers = teachers
        self.K = len(teachers)
        
        if alpha_k is None:
            self.alpha_k = [1.0 / self.K] * self.K
        else:
            self.alpha_k = [a / sum(alpha_k) for a in alpha_k]
    
    def multi_teacher_loss(self, student_logits, input_ids):
        """计算多教师蒸馏损失"""
        total_loss = 0.0
        
        for k, teacher in enumerate(self.teachers):
            with torch.no_grad():
                teacher_logits = teacher(input_ids).logits
            
            # 计算反向KL
            teacher_logprob = F.log_softmax(teacher_logits / self.temperature, dim=-1)
            student_logprob = F.log_softmax(student_logits / self.temperature, dim=-1)
            
            # 反向KL: sum p_S * (log p_S - log p_T)
            kl_loss = F.kl_div(student_logprob, teacher_logprob, reduction='batchmean')
            
            total_loss += self.alpha_k[k] * kl_loss
        
        return total_loss * (self.temperature ** 2)

总结

MiniLLM和GKD代表了LLM蒸馏领域的两项重要进展：

方面	MiniLLM	GKD
核心创新	反向KL散度优化生成质量	On-Policy采样 + 广义正则化框架
理论贡献	解释了为什么反向KL适合生成任务	统一了离线/在线蒸馏
实践价值	生成更清晰、多样的文本	训练更稳定、性能更优

这两种方法可以结合使用：使用MiniLLM的反向KL损失，结合GKD的On-Policy采样策略，往往能取得最佳效果。

Metaphor

探索

LLM蒸馏：MiniLLM与GKD

LLM蒸馏：MiniLLM与GKD

1. 概述：LLM蒸馏的挑战

1.1 自回归模型的特殊性

1.2 标准KD对LLM的问题

1.3 知识类型与蒸馏策略

2. MiniLLM方法

2.1 核心思想：反向KL散度

2.2 标准KL vs 反向KL

2.3 MiniLLM目标函数推导

2.4 生成质量优化技术

2.4.1 混合目标函数

2.4.2 教师采样策略

2.4.3 渐进式训练

3. GKD（广义知识蒸馏）

3.1 离线蒸馏 vs 在线蒸馏

3.2 GKD框架

3.3 师生分布对齐

3.4 On-Policy采样的重要性

3.5 GKD与MiniLLM的关系

4. 技术细节

4.1 温度调度

4.2 令牌级 vs 序列级蒸馏

4.3 渐进式蒸馏策略

4.4 轻量化方法：LoRA蒸馏

5. 代码实现

5.1 MiniLLM训练代码

5.2 GKD训练代码

5.3 关键超参数设置

6. 实验结果

6.1 压缩比与性能权衡

6.2 不同蒸馏方法的对比

6.3 生成质量评估

7. 蒸馏与其他技术的结合

7.1 蒸馏 + RLHF

7.2 蒸馏 + 量化

7.3 多教师蒸馏

总结

参考资料

相关主题

Footnotes

关系图谱

目录