章节导语

175B参数的大模型跑不动？推理速度慢、显存不够、部署成本高——这是每个落地大模型的人都会遇到的墙。

模型压缩不是妥协，而是工程智慧。再强大的模型，如果跑不起来就等于零。通过量化、剪枝、知识蒸馏等技术，可以让百亿参数模型在消费级GPU上跑出可用的推理速度。

本文系统讲解模型压缩的四大核心技术：量化（从FP32到INT8/INT4）、剪枝（去掉不重要的权重）、知识蒸馏（用大模型教小模型）、神经网络架构搜索（自动找到高效结构）。每个技术都有完整原理讲解和实战代码，帮助你把大模型”压缩”到能跑、能用、能部署。

一、前置说明

1.1 学习路径

1.2 读者需要的基础

• 深度学习基础：了解神经网络、梯度下降、过拟合等概念
• PyTorch基础：能看懂和修改模型定义代码
• GPU概念：知道显存、算力的基本含义

1.3 学习目标

学完本文，你将能够：

• 理解模型压缩的核心思想——用更少的资源做同样的事
• 掌握量化的原理和实现方法
• 掌握剪枝的策略和实战技巧
• 理解知识蒸馏的工作机制
• 综合运用多种压缩技术

二、为什么需要模型压缩

2.1 大模型的”贵”问题

GPT-4、Claude、LLaMA这些大模型能力很强，但部署成本很高。以LLaMA-65B为例：

• 显存需求：65B参数 × 2字节（FP16）= 130GB显存。至少需要两张80GB显存的A100显卡。
• 推理成本：每秒处理几十个token，延迟几百毫秒，用户体验差。
• 能耗：大模型推理的电力消耗惊人，不适合移动设备和边缘场景。

这不是小团队能承受的。就算有大厂财力支持，时延问题也难以解决——没人愿意等10秒钟才得到一句回复。

2.2 压缩的核心思想

模型压缩的本质是：用更少的参数/计算量，达到接近原模型的效果。这不是简单的”丢弃”，而是找到一种更高效的信息表示方式。

打个比方：一本厚厚的专业词典，普通人记不住所有词条。但如果你把高频词汇和核心用法提炼出来，形成一本”精简词典”，虽然不能完全替代原版，但90%的场景够用了。模型压缩就是这个思路。

2.3 四大压缩技术一览

这四种技术可以单独使用，也可以组合使用。实际项目中，量化+剪枝是最常见的组合，能达到4-8倍的压缩效果。

三、量化技术详解

3.1 什么是量化

量化（Quantization）的核心是把FP32（32位浮点数）的权重转换成低精度的整数表示，比如INT8（8位整数）或INT4（4位整数）。

FP32的表示范围是-3.4×10³⁸到3.4×10³⁸，而INT8只有-128到127。精度差了256倍，但表示的信息量其实没少那么多——因为权重分布是有规律的。

量化过程可以简单理解为：找到权重的最大值和最小值，然后把原来的范围映射到INT8的范围。比如权重集中在-10到10之间，那就把-10映射到-128，10映射到127，中间的值等比例缩放。

3.2 量化类型

对称量化 vs 非对称量化

对称量化使用零点的对称范围。比如INT8时，范围是-127到127，零点固定在0。这种方式简单，但不适合权重分布不均匀的情况。

非对称量化使用完整的256个值。零点可以不在0，能更好地处理偏置分布。但计算时会多一步偏移量的处理。

动态量化 vs 静态量化

动态量化是在推理时实时量化权重。优点是不需要重新训练，缺点是每次推理都要做量化/反量化，有额外开销。

静态量化是提前做好量化，推理时直接使用。需要在部署前校准（用一批数据确定量化参数），但推理速度更快。

训练后量化（PTQ）vs 量化感知训练（QAT）

PTQ是训练好模型之后再量化，简单快捷，但精度可能有损失。

QAT是在训练过程中模拟量化，让模型适应低精度表示。精度更好，但需要重新训练或微调。

3.3 量化的精度影响

量化不是银弹。INT8相比FP16通常只有1-2%的精度损失，可以接受。但INT4的精度损失可能达到5-10%，需要谨慎使用。

哪些层适合量化，哪些不适合？

• 适合量化：Linear层（矩阵乘法）、Conv层（卷积）、LayerNorm
• 不适合量化：Embedding层、Softmax、LayerNorm的某些部分

现代LLQ（Low-Rank Quantization）技术通过混合精度策略，对不同层使用不同的量化位数，在压缩率和精度之间取得平衡。

四、剪枝技术详解

4.1 什么是剪枝

剪枝（Pruning）的核心是删除神经网络中不重要的权重或结构。想象一棵树，通过剪枝去掉枯枝败叶，主干能更健康地生长。

神经网络的权重并不是同等重要的。有的权重很大、影响显著，有的权重接近于零、几乎不起作用。剪枝就是识别并删除那些”不重要”的部分。

4.2 剪枝策略分类

非结构化剪枝 vs 结构化剪枝

非结构化剪枝可以删除任意位置的权重，压缩率高但不规则。GPU对规则的矩阵运算友好，这种稀疏结构很难加速。

结构化剪枝按组删除，比如删除整个神经元、整个注意力头、整个通道。压缩效果可能不如非结构化，但实际加速效果更好。

幅度剪枝（Magnitude Pruning）

最简单的方法：把绝对值最小的权重删掉。直观理解是”小权重不重要”。幅度剪枝假设权重大小和重要性正相关，这个假设大多数时候成立，但不完全准确。

梯度幅度剪枝（Gradient Magnitude Pruning）

考虑梯度信息，不仅看权重大小，还看梯度大小。梯度大说明参数需要经常更新，可能更重要。这种方法比纯幅度剪枝更精准。

Fisher信息剪枝

基于Fisher信息量评估参数重要性。Fisher信息衡量的是参数对模型loss的贡献度，贡献小的参数可以被剪掉。这是更科学的评估方式。

4.3 剪枝的时机和方式

剪枝可以在训练过程中进行，也可以在训练完成后进行。

训练中剪枝（Iterative Pruning）：训练一段时间，剪掉一些权重，继续训练，再剪掉更多……循环迭代。这种方式效果最好，但训练时间长。

训练后一次性剪枝：训练完成后直接剪枝到目标稀疏度。速度快，但效果往往不如迭代剪枝。

渐进式剪枝：从大到小逐步增加稀疏度，让模型有时间适应。这种方式比一次性剪枝更稳定。

4.4 稀疏度与精度的权衡

剪枝会损失精度，稀疏度越高，损失越大。但这个关系不是线性的。

研究表明：70-80%的稀疏度通常只带来1-2%的精度损失。超过这个范围，精度会急剧下降。

不同类型的网络对稀疏度的敏感度不同：

• CNN：对稀疏度容忍度高，90%稀疏度有时也能work
• RNN：中等敏感，50-70%稀疏度比较安全
• Transformer：敏感度因任务而异，建议从30-50%开始尝试

五、知识蒸馏详解

5.1 什么是知识蒸馏

知识蒸馏（Knowledge Distillation）的核心思想是：让小模型学习大模型的行为，”师徒传承”。

大模型不仅能给出正确答案，还能给出”软概率”——比如识别猫时，可能输出80%是猫、15%是狗、5%是豹猫。普通小模型只学到”这是猫”，但大模型学到的是”这更像猫而不是狗”。这种”暗知识”才是精华。

知识蒸馏就是让小模型学习大模型的输出分布，把大模型的”经验”传递下去。

5.2 蒸馏的温度参数

在蒸馏中，温度T是一个关键参数。普通的softmax是T=1。

当T>1时，输出分布会更”软”，各类别之间的差异会被放大。比如原来是[0.9, 0.1]，T=5时可能变成[0.6, 0.4]。这让小模型能学到更多”相对关系”信息。

温度的选择影响效果：

• T=1：普通softmax，等于没蒸馏
• T=2-5：常用范围，软化分布效果明显
• T过高：分布过于均匀，失去区分度

5.3 蒸馏的损失函数

蒸馏的总损失通常由两部分组成：

硬标签损失：小模型输出与真实标签的交叉熵。这是基础，让小模型学习正确答案。

软标签损失：小模型输出与大模型输出的KL散度。这是精华，让小模型学习大模型的”暗知识”。

总损失 = α × 硬标签损失 + (1-α) × 软标签损失

α是平衡系数，通常0.7-0.9效果好。α越大越重视真实标签，α越小越重视大模型的”经验”。

5.4 蒸馏的变体

自蒸馏（Self-Distillation）：用模型自己当老师。深层蒸馏到浅层，自己教自己。简单但有效。

多教师蒸馏：多个大模型同时教一个小模型。可以综合不同模型的优势。

对比蒸馏：不仅学正确答案，还学对比关系。比如”狗和猫的相似度vs狗和汽车的相似度”。

六、综合压缩策略

6.1 组合使用多种技术

实战中，单一技术往往不够。需要组合使用：

量化 + 剪枝是最常见的组合。先剪枝去掉不重要的结构，再量化剩下的权重。剪枝后的模型更紧凑，量化效果也更好。

蒸馏 + 量化：先用蒸馏得到小模型，再量化部署。这是很多LLM量化项目的标准流程。

剪枝 + 蒸馏：先剪枝初步压缩，再用蒸馏恢复精度。蒸馏相当于”精修”，弥补剪枝的精度损失。

6.2 压缩的常见问题

问题一：压缩后精度下降太多怎么办？

解决方案：先用蒸馏恢复精度，再做量化。蒸馏相当于”再训练”，能让模型适应压缩后的结构。

问题二：压缩后推理还是很慢？

可能是结构化问题。如果是非结构化剪枝，GPU不能有效加速。需要做结构化剪枝，或者用专门的稀疏矩阵计算库。

问题三：不知道该用多大的压缩比？

建议从4倍压缩开始测试。这个比例通常精度损失<2%，但推理速度能提升2-3倍。如果效果不够，再加大压缩比。

七、量化实战代码

7.1 PyTorch动态量化

import torch
import torch.nn as nn
from torch.quantization import quantize_dynamic

class SimpleModel(nn.Module):
    """待量化的简单模型"""
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(512, 256)
        self.fc2 = nn.Linear(256, 128)
        self.fc3 = nn.Linear(128, 10)
        self.relu = nn.ReLU()
    
    def forward(self, x):
        x = self.relu(self.fc1(x))
        x = self.relu(self.fc2(x))
        x = self.fc3(x)
        return x

def dynamic_quantize_model(model):
    """动态量化模型
    
    动态量化特点：
    - 权重在推理前量化，推理时实时反量化
    - 不需要校准数据
    - 实现简单，但推理速度提升有限
    """
    # 只量化Linear层
    quantized_model = quantize_dynamic(
        model,  # 待量化模型
        {nn.Linear},  # 要量化的层类型
        dtype=torch.qint8  # 量化精度
    )
    return quantized_model

def measure_model_size(model, name="Model"):
    """测量模型大小"""
    param_size = 0
    for param in model.parameters():
        param_size += param.nelement() * param.element_size()
    
    size_mb = param_size / 1024 / 1024
    print(f"{name} 大小: {size_mb:.2f} MB")
    return size_mb

# 使用
if __name__ == "__main__":
    # 创建模型
    model = SimpleModel()
    
    # 测量原始大小
    orig_size = measure_model_size(model, "原始模型")
    
    # 动态量化
    quantized_model = dynamic_quantize_model(model)
    
    # 测量量化后大小
    quant_size = measure_model_size(quantized_model, "量化模型")
    
    print(f"\n压缩比: {orig_size/quant_size:.2f}x")
    print("✅ 量化完成")

八、剪枝实战代码

8.1 幅度剪枝实现

import torch
import torch.nn as nn
import torch.nn.utils.prune as prune

class StructuredPruner:
    """结构化剪枝器
    
    支持多种剪枝策略：
    - random: 随机剪枝
    - magnitude: 幅度剪枝
    - l1_unstructured: L1范数非结构化剪枝
    - l1_structured: L1范数结构化剪枝（按通道）
    """
    
    @staticmethod
    def magnitude_pruning(model, sparsity=0.5):
        """幅度剪枝
        
        删除绝对值最小的权重
        
        参数:
            model: 待剪枝模型
            sparsity: 稀疏度（0.5 = 删除50%的权重）
        """
        for name, module in model.named_modules():
            if isinstance(module, nn.Linear):
                # 对每个Linear层进行剪枝
                prune.l1_unstructured(
                    module,
                    name='weight',  # 剪枝权重
                    amount=sparsity  # 稀疏度
                )
                # 也可以剪枝偏置
                if module.bias is not None:
                    prune.l1_unstructured(
                        module,
                        name='bias',
                        amount=sparsity
                    )
        return model
    
    @staticmethod
    def structured_pruning_by_channels(model, sparsity=0.3):
        """结构化剪枝（按通道）
        
        删除不重要的神经元通道
        剪枝后模型结构更规则，更容易加速
        """
        for name, module in model.named_modules():
            if isinstance(module, nn.Linear):
                # 计算每个输出通道的L1范数
                # 范数小的通道不重要，可以删除
                prune.ln_structured(
                    module,
                    name='weight',
                    amount=sparsity,
                    n=1,  # L1范数
                    dim=0  # 按输出通道剪枝
                )
        return model
    
    @staticmethod
    def remove_pruning(model):
        """移除剪枝装饰器，将剪枝结果永久化"""
        for name, module in model.named_modules():
            if isinstance(module, nn.Linear):
                if hasattr(module, 'weight_orig'):
                    prune.remove(module, 'weight')
        return model

# 使用
if __name__ == "__main__":
    model = SimpleModel()
    
    pruner = StructuredPruner()
    
    # 50%稀疏度剪枝
    print("执行幅度剪枝...")
    pruned_model = pruner.magnitude_pruning(model, sparsity=0.5)
    
    # 检查稀疏度
    total_weights = 0
    zero_weights = 0
    for name, param in pruned_model.named_parameters():
        if 'weight' in name:
            total_weights += param.numel()
            zero_weights += (param == 0).sum().item()
    
    actual_sparsity = zero_weights / total_weights
    print(f"实际稀疏度: {actual_sparsity:.2%}")
    print("✅ 剪枝完成")

九、知识蒸馏实战代码

9.1 蒸馏训练器

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import DataLoader

class DistillationTrainer:
    """知识蒸馏训练器
    
    用大模型（Teacher）指导小模型（Student）学习
    """
    
    def __init__(self, teacher_model, student_model, temperature=4.0, alpha=0.7):
        """
        参数:
            teacher_model: 教师模型（参数量大，效果好）
            student_model: 学生模型（参数量小，需要学习）
            temperature: 蒸馏温度，越高分布越软
            alpha: 硬标签损失的权重
        """
        self.teacher = teacher_model
        self.student = student_model
        self.temperature = temperature
        self.alpha = alpha
        
        # 教师模型不更新
        for param in self.teacher.parameters():
            param.requires_grad = False
    
    def distillation_loss(self, student_logits, teacher_logits):
        """蒸馏损失
        
        包含两部分：
        1. 软标签损失：学生模仿教师的输出分布
        2. 硬标签损失：学生学习真实标签
        """
        # 软标签损失：KL散度
        soft_student = F.log_softmax(student_logits / self.temperature, dim=-1)
        soft_teacher = F.softmax(teacher_logits / self.temperature, dim=-1)
        soft_loss = F.kl_div(soft_student, soft_teacher, reduction='batchmean')
        
        # 乘以T²，因为KL散度公式中前面有个T²系数
        soft_loss = soft_loss * (self.temperature ** 2)
        
        return soft_loss
    
    def train_step(self, batch, hard_labels):
        """单步训练"""
        inputs = batch
        
        # 教师前向传播（不计算梯度）
        with torch.no_grad():
            teacher_logits = self.teacher(inputs)
        
        # 学生前向传播
        student_logits = self.student(inputs)
        
        # 计算损失
        soft_loss = self.distillation_loss(student_logits, teacher_logits)
        hard_loss = F.cross_entropy(student_logits, hard_labels)
        
        total_loss = self.alpha * hard_loss + (1 - self.alpha) * soft_loss
        
        return total_loss, soft_loss, hard_loss

# 使用示例
if __name__ == "__main__":
    # 假设有教师和学生模型
    # teacher = LargeModel()
    # student = SmallModel()
    
    trainer = DistillationTrainer(
        teacher_model=None,  # 实际使用时传入
        student_model=None,  # 实际使用时传入
        temperature=4.0,
        alpha=0.7
    )
    
    print("✅ 蒸馏训练器已创建")

十、总结与练习

10.1 核心要点

量化的本质是精度转换。FP32到INT8的转换看似简单，但背后的量化参数选择、层类型适配、精度校准都有讲究。INT8是实战中最常用的精度，压缩2倍的同时保持>98%的精度。

剪枝的核心是识别重要性。幅度剪枝最简单但有效，结构化剪枝更实用但需要谨慎选择通道。70-80%稀疏度是安全区间，超过可能适得其反。

蒸馏的本质是信息传递。大模型的”软输出”包含比硬标签更丰富的信息。温度参数让这种信息传递更有效。蒸馏是压缩中精度损失最小的技术。

组合使用效果倍增。单一技术往往不够，量化+剪枝+蒸馏组合能实现4-8倍的压缩，同时把精度损失控制在2%以内。

10.2 实战检查清单

□ 确定压缩目标（显存限制/推理速度/部署平台）
□ 评估原模型大小和性能基准
□ 选择压缩技术（量化/剪枝/蒸馏）
□ 设计压缩比例（建议从4倍开始）
□ 执行压缩操作
□ 评估精度损失（与基准对比）
□ 如精度损失过大，执行精度恢复（蒸馏微调）
□ 部署测试，验证实际性能提升

10.3 延伸阅读

• LLM-QAT：LLM的量化感知训练方法
• SparseGPT：针对GPT系列的结构化剪枝
• AWQ：activation-aware权重量化
• TensorRT：NVIDIA的模型推理优化工具，支持量化加速

10.4 课后练习

基础题：对PyTorch的Linear层进行INT8量化，测量压缩效果。

进阶题：实现一个迭代剪枝流程，每轮剪枝10%，然后微调恢复精度，循环5轮达到50%稀疏度。

挑战题：使用知识蒸馏，用BERT-large教BERT-small，对比直接训练小模型的效果差异。