18b · 知识蒸馏

   同一个 Linear 层：W 的形状 [4096, 4096]，FP16

   ① 量化：形状不变，每个数从 16 bit 变 4 bit
      [4096, 4096] FP16  →  [4096, 4096] INT4       ⭐ 改的是【数值精度】

   ② 剪枝：数值精度不变，把一部分位置变成 0（或者直接删掉行列）
      [4096, 4096] FP16  →  [4096, 4096] 里 90% 是 0   （非结构化）
                         →  [4096, 2048] FP16          （结构化）⭐ 改的是【连接/尺寸】

   ③ 蒸馏：这一层本身没变，是【整个模型换成另一个更小的模型】
      32 层 × 4096  →  16 层 × 2048，权重全部重新学
                                                     ⭐ 改的是【模型本身】

   硬标签（真实 one-hot）：
   猫=1  老虎=0  狗=0  汽车=0  卡车=0
        ↑ 老虎和汽车在标签里【一样错】

   teacher 的软标签（softmax 输出）：
   猫=0.87  老虎=0.12  狗=0.008  汽车=0.001  卡车=0.001
        ⭐ 老虎的概率是汽车的【120 倍】
        → teacher 在告诉学生：「猫更像老虎，一点都不像汽车」

   ⭐ 信息量的角度：
   · 硬标签：一个样本只给 log2(5) ≈ 2.3 bit 的监督
   · 软标签：一个样本给的是整个 5 维分布 —— 连续值，信息多得多

   → 这就是为什么【同样的数据量下】，蒸馏出来的小模型
     常常比拿硬标签从零训练的同尺寸模型强

   同一组 teacher logits [6.0, 4.0, 0.5, 0.2, -1.0]，不同 T：

   T=1  → [0.875, 0.118, 0.004, 0.003, 0.001]   非目标类几乎全是 0，暗知识看不见
   T=2  → [0.659, 0.243, 0.042, 0.036, 0.020]
   T=4  → [0.441, 0.268, 0.112, 0.103, 0.077]   ⭐ 类间差异清楚了
   T=8  → [0.314, 0.245, 0.158, 0.152, 0.131]
   T→∞ → 均匀分布，什么信息都没有了 💀

import torch
import torch.nn.functional as F

teacher  = torch.tensor([[6.0, 4.0, 0.5, 0.2, -1.0]])
student0 = torch.tensor([[7.233, 3.765, -1.243, 0.655, -1.868]])   # 训练中期：已接近 teacher

def soft_loss_and_grad(T, scale):
    s = student0.clone().requires_grad_(True)
    loss = F.kl_div(F.log_softmax(s / T, dim=-1),          # 学生用 log_softmax
                    F.softmax(teacher / T, dim=-1),        # teacher 用 softmax
                    reduction="batchmean")
    if scale:
        loss = loss * T * T                                # ⭐ T² 缩放就这一行
    loss.backward()
    return loss.item(), s.grad.norm().item()

print(f"{'T':<5}{'loss(raw)':>12}{'|grad|raw':>12}{'loss(xT2)':>12}{'|grad|xT2':>12}")
for T in [1.0, 2.0, 4.0, 8.0, 16.0]:
    l1, g1 = soft_loss_and_grad(T, scale=False)
    l2, g2 = soft_loss_and_grad(T, scale=True)
    print(f"{T:<5}{l1:>12.6f}{g1:>12.6f}{l2:>12.6f}{g2:>12.6f}")

   T        loss(raw)   |grad|raw    loss(xT2)   |grad|xT2
   1.0       0.086481    0.128587     0.086481    0.128587
   2.0       0.073135    0.090805     0.292538    0.363222
   4.0       0.030420    0.030387     0.486713    0.486194
   8.0       0.008472    0.007675     0.542194    0.491218
   16.0      0.002127    0.001868     0.544426    0.478094

   ⭐ 看 |grad|raw 那一列：4→8→16，每翻一倍 T，梯度缩小【正好约 4 倍】
      0.0304 → 0.00768 → 0.00187   （3.96×、4.11×）—— 这就是 1/T²
   ⭐ 看 |grad|xT2 那一列：0.486 → 0.491 → 0.478，稳定住了

   ⚠️ teacher 和 student 必须【同 tokenizer、同词表】
      不然两边的 logits 根本对不上位置

   → 这就是为什么各家的小模型基本都是
     「同一家、同一个 tokenizer 的大模型」蒸出来的

   ⭐ 等价于：在 teacher 的"众数序列"上做最大似然
      信号比 token 级弱（每个位置只有 1 个 token，没有分布）

   ✅ 但工程上简单太多：
      · tokenizer 不同也行、架构不同也行
      · teacher 可以只是一个 API
      · 数据可以离线生成一次、反复用

   ⭐ 立项时必须回答的三个问题：
   ① 数据是哪个模型生成的？它的条款/许可怎么写的？
   ② 这个小模型会不会对外提供服务、会不会和 teacher 构成竞争？
   ③ 生成记录留存了吗（哪个模型、哪个版本、什么时候、什么 prompt）？

from collections import defaultdict

def stratified_report(rows, groups):
    """rows: (分组, teacher是否正确, student是否正确) 的列表"""
    n, t, s = defaultdict(int), defaultdict(int), defaultdict(int)
    for g, ok_t, ok_s in rows:
        n[g] += 1; t[g] += ok_t; s[g] += ok_s
    N = sum(n.values())
    T, S = sum(t.values()) / N, sum(s.values()) / N
    print(f"{'分组':<10}{'样本数':>8}{'teacher':>10}{'student':>10}{'Δ(pp)':>9}")
    print(f"{'全体':<10}{N:>8}{T:>10.3f}{S:>10.3f}{(S - T) * 100:>+9.2f}")
    worst = None
    for g in groups:
        d = (s[g] / n[g] - t[g] / n[g]) * 100      # ⭐ 每个分组【单独】算 Δ
        print(f"{g:<10}{n[g]:>8}{t[g]/n[g]:>10.3f}{s[g]/n[g]:>10.3f}{d:>+9.2f}")
        if worst is None or d < worst[1]:
            worst = (g, d)
    print(f"\n最差分组: {worst[0]}  Δ={worst[1]:+.2f}pp   (全体只有 {(S-T)*100:+.2f}pp)")
    return worst

groups = ["主力人群", "次要A", "次要B", "长尾C", "长尾D"]
size   = [8000, 1200, 500, 200, 100]
acc_t  = [0.940, 0.920, 0.900, 0.880, 0.850]
acc_s  = [0.933, 0.915, 0.880, 0.800, 0.700]
rows = []
for g, n_, at, as_ in zip(groups, size, acc_t, acc_s):
    rows += [(g, 1 if i < round(n_ * at) else 0,
                 1 if i < round(n_ * as_) else 0) for i in range(n_)]

worst = stratified_report(rows, groups)
assert worst[1] > -3.0, f"⭐ 分组 {worst[0]} 掉了 {worst[1]:.1f}pp，阻塞上线"

   分组             样本数   teacher   student    Δ(pp)
   全体           10000     0.933     0.923    -1.03
   主力人群        8000     0.940     0.933    -0.70
   次要A           1200     0.920     0.915    -0.50
   次要B            500     0.900     0.880    -2.00
   长尾C            200     0.880     0.800    -8.00
   长尾D            100     0.850     0.700   -15.00      💀

   最差分组: 长尾D  Δ=-15.00pp   (全体只有 -1.03pp)

   ① 评测集是从【蒸馏数据里随机切】的
      → 分布和蒸馏数据完全一样，长尾 D 只有 100 条
      → 在整体指标里权重只有 1%，掉 15pp 只贡献 0.15pp

   ② ⭐ 更深的原因：软标签在低频类上【本来就没信息】
      teacher 自己在长尾 D 上就不自信（softmax 接近均匀）
      → 蒸馏信号 ≈ 噪声 → 学生等于在这些类上【什么都没学到】
      → 蒸馏对长尾的伤害是【系统性的】，不是偶然

   ③ 验收只看了一个整体 accuracy 数字，没有分层

   假设 7B teacher → 1.3B student，用 1.3B 的一次前向当作 1 个单位：

   ① student 训练（前向 + 反向）≈ 3 个单位
   ② ⭐ teacher 前向 ≈ 7/1.3 ≈ 5.4 个单位
   ──────────────────────────────────────
   合计 ≈ 8.4 个单位

   ⭐ 其中 【5.4/8.4 ≈ 64% 的算力花在 teacher 身上】
     → 蒸馏 1.3B 比从零训练同样的 1.3B 贵【约 2.8 倍】

   词表 128k，只存 top-50：每 token ≈ 50 × (4 值 + 4 索引) = 400 字节

   100B token × 400 字节 = 40 TB    ⚠️
   1T   token × 400 字节 = 400 TB   💀

   → 所以实践里通常是：
     · 小规模、要多轮训练 → 离线缓存 top-k（k 取 5~20）
     · 大规模 → 在线跑 teacher，认下那 64% 的算力
     · 或者干脆用【序列级蒸馏】，只存 teacher 生成的文本（便宜几百倍）⭐

   💀 最危险的闭环：
     teacher 生成数据 → 学生学 → 【在同一批数据上评估学生】

   为什么这是错的：
   ① 学生在上面得分高，只说明它学会了【模仿 teacher】，
      不说明它学会了【任务】
   ② ⭐ teacher 的错误被当成了标准答案 ——
      学生把错误学得越像，分数越高 💀
   ③ 分布完全一致，没有任何泛化信号

   ✅ 正确做法：
   · 评测集来自【另一个时间窗 / 另一个采样源】，人工标注
   · 必须分层（第五节）
   · 必须有一批 teacher 也会答错的样本，用来看错误有没有被继承