第24课：模型压缩与量化

📖 本课概述

大模型好用但难部署。模型压缩让我们在保持性能的同时大幅减少模型大小和推理延迟。

📦 一、为什么需要压缩

✂️ 二、压缩方法分类

🔢 三、量化详解

3.1 量化原理

3.2 量化方式

训练后量化(PTQ)：训练完后直接量化，简单快速

量化感知训练(QAT)：训练时模拟量化，精度更好

3.3 PyTorch实现量化

import torch
import torch.nn as nn

# 模型压缩实验
class SmallModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(20, 128), nn.ReLU(),
            nn.Linear(128, 64), nn.ReLU(),
            nn.Linear(64, 10),
        )
    def forward(self, x):
        return self.net(x)

# 训练原始模型
torch.manual_seed(42)
X = torch.randn(500, 20)
y = torch.randint(0, 10, (500,))

model = SmallModel()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
loss_fn = nn.CrossEntropyLoss()

for epoch in range(100):
    optimizer.zero_grad()
    loss = loss_fn(model(X), y)
    loss.backward()
    optimizer.step()

# 原始精度
orig_acc = (model(X).argmax(1) == y).float().mean().item()
orig_size = sum(p.numel() * p.element_size() for p in model.parameters())
print(f"原始模型: acc={orig_acc:.2%}, 大小={orig_size/1024:.1f}KB")

# 量化：手动实现INT8
def quantize_tensor(tensor):
    xmin, xmax = tensor.min(), tensor.max()
    scale = (xmax - xmin) / 255
    zero_point = round(-xmin / scale)
    q = torch.clamp(torch.round(tensor / scale + zero_point), 0, 255).to(torch.uint8)
    return q, scale, zero_point

def dequantize_tensor(q, scale, zero_point):
    return (q.float() - zero_point) * scale

# 量化模型参数
print("\n=== 量化效果 ===")
for name, param in model.named_parameters():
    q, scale, zp = quantize_tensor(param.data)
    deq = dequantize_tensor(q, scale, zp)
    error = (param.data - deq).abs().mean().item()
    orig_bytes = param.numel() * 4
    quant_bytes = param.numel()  # INT8 = 1 byte
    print(f"{name}: 量化误差={error:.6f}, 大小 {orig_bytes}→{quant_bytes} ({quant_bytes/orig_bytes:.0%})")

# 剪枝：移除小权重
print("\n=== 剪枝效果 ===")
for sparsity in [0.3, 0.5, 0.7, 0.9]:
    model_copy = SmallModel()
    model_copy.load_state_dict(model.state_dict())
    
    # 按幅度剪枝
    total_params = 0
    pruned_params = 0
    for name, param in model_copy.named_parameters():
        threshold = torch.quantile(param.data.abs(), sparsity)
        mask = param.data.abs() > threshold
        param.data *= mask.float()
        total_params += param.numel()
        pruned_params += (mask == 0).sum().item()
    
    acc = (model_copy(X).argmax(1) == y).float().mean().item()
    print(f"稀疏度={sparsity:.0%}: 实际剪枝={pruned_params/total_params:.1%}, acc={acc:.2%}")

# 知识蒸馏概念
print("\n=== 知识蒸馏 ===")
print("教师模型: 原始SmallModel (3层)")
print("学生模型: 更小网络 (2层)")
student = nn.Sequential(nn.Linear(20, 32), nn.ReLU(), nn.Linear(32, 10))
student_params = sum(p.numel() for p in student.parameters())
teacher_params = sum(p.numel() for p in model.parameters())
print(f"教师参数量: {teacher_params:,}, 学生参数量: {student_params:,}")
print(f"压缩比: {teacher_params/student_params:.1f}x")

🔬 深入拓展

核心要点回顾

本课的核心知识点构成了训练技巧学习的重要一环。让我们从更高维度审视这些知识之间的关系：

• 理论层面：理解数学原理是正确应用的前提，每个公式背后都有直觉
• 工程层面：PyTorch提供了高效实现，但理解底层原理才能正确调试
• 实践层面：没有银弹，不同场景需要不同的策略组合

常见陷阱与最佳实践

与前后课程的联系

深度学习是一个整体——每一课的知识都不是孤立的：

• 优化器（第5课）的选择影响正则化（第6课）的效果
• 初始化（第7课）决定了训练能否开始
• CNN（第8-14课）的成功依赖训练技巧（第22-28课）
• Transformer（第20-21课）结合了注意力和位置编码
• 实战项目（第29-35课）综合运用所有知识

📖 延伸阅读

📝 练习

💡 模型压缩实践

压缩流程

• 先训练大模型（教师）
• 量化：INT8通常够用
• 剪枝：从细粒度到粗粒度
• 蒸馏：温度参数很重要

常见错误与解决方案

性能优化建议

🔬 深度拓展：从理论到实践

核心概念网络

理解本课内容需要将其置于更大的知识网络中。每个核心概念都不是孤立的，它们相互关联、相互支撑：

• 数学基础：线性代数、微积分、概率论是理解所有深度学习算法的根基
• 计算基础：自动微分、GPU并行计算让理论变为现实
• 工程基础：数据处理、模型设计、训练技巧的有机结合
• 领域知识：CV、NLP、语音等领域的先验知识指导模型设计

关键洞察与直觉

建立正确的直觉比记住公式更重要：

与其他课程的关联

本课作为训练技巧阶段的核心内容，与前后课程紧密关联：

面试常见问题

进阶学习路径

掌握本课内容后，可以通过以下方式继续深入：

• 阅读本课相关的一手论文，理解原始动机和推导
• 复现论文的实验结果，验证自己的理解
• 尝试改进方法，思考为什么现有方法有局限
• 在真实项目或Kaggle竞赛中应用
• 关注该方向的最新进展（arXiv、顶级会议）