大模型稀疏训练：计算效率与精度平衡

调研日期：2026-05-22 | 所属领域：大模型训练

第一部分：概念剖析

1.1 定义澄清

通行定义：大模型稀疏训练是指在训练或推理过程中，通过选择性激活模型的部分参数（而非全部参数），在保持模型表达能力的同时显著降低计算和存储开销的技术体系。其核心思想是利用神经网络中天然存在的冗余——大量权重接近零、大量神经元输出为零或接近零——通过结构性手段"跳过"这些冗余计算。

常见误解：

1. "稀疏 = 剪枝"：剪枝（Pruning）是稀疏化的一种手段，但并非全部。稀疏训练还包括稀疏激活（如 ReLU 天然稀疏）、Mixture-of-Experts（MoE）路由稀疏、稀疏注意力等多种形式。剪枝是"参数级的稀疏"，MoE 是"架构级的稀疏"。

2. "稀疏一定降低精度"：最新研究表明，在适当的稀疏度下（如 50% 结构化稀疏），经精心设计的稀疏模型可以达到甚至超越稠密模型的精度。SparseForge 在 2:4 稀疏度下以 5B tokens 重训练即超越稠密基线（57.27% vs 56.43% 零样本准确率）。

3. "稀疏度越高越好"：稀疏度与精度之间存在非线性的"悬崖效应"——在某些临界点（如 70% 以上），精度可能急剧下降。不同层对稀疏的容忍度差异极大，需要非均匀分配才能达到最优平衡。

4. "稀疏训练的加速立即可见"：非结构化稀疏在通用 GPU 上几乎没有实际加速效果（需要特殊硬件或内核支持）。只有结构化稀疏（2:4、N:M）或 MoE 的路由稀疏才能在现有硬件上获得真实加速。

边界辨析：

1.2 核心架构

┌────────────────────────────────────────────────────────────┐
│              大模型稀疏训练系统架构                          │
├────────────────────────────────────────────────────────────┤
│                                                            │
│  训练阶段:                                                  │
│  ┌──────────┐   ┌──────────┐   ┌──────────┐   ┌─────────┐ │
│  │ 前向传播  │ → │ 稀疏掩码  │ → │ 反向传播  │ → │ 参数更新 │ │
│  │ (仅激活   │   │ 动态调整  │   │ (梯度通   │   │ (剪枝+  │ │
│  │ 子集参数) │   │ 或固定)  │   │ 过掩码)  │   │ 生长)   │ │
│  └──────────┘   └──────────┘   └──────────┘   └─────────┘ │
│       │              │              │              │       │
│       ▼              ▼              ▼              ▼       │
│  ┌────────────────────────────────────────────────────┐    │
│  │              稀疏模式控制器                          │    │
│  │  ┌──────┐  ┌──────┐  ┌──────┐  ┌──────┐          │    │
│  │  │Weight│  │Activ.│  │Attn. │  │MoE   │          │    │
│  │  │Prune │  │Prune │  │Mask  │  │Route │          │    │
│  │  └──────┘  └──────┘  └──────┘  └──────┘          │    │
│  └────────────────────────────────────────────────────┘    │
│                                                            │
│  推理阶段:                                                  │
│  ┌──────────┐   ┌──────────┐   ┌──────────┐               │
│  │ 输入编码  │ → │ 稀疏计算  │ → │ 输出解码  │               │
│  │          │   │ (跳过零)  │   │          │               │
│  └──────────┘   └──────────┘   └──────────┘               │
│                                                            │
└────────────────────────────────────────────────────────────┘

组件说明：

1.3 数学形式化

公式 1：权重稀疏的掩码操作

解释：对权重矩阵 $\mathbf{W}$ 应用二进制掩码 $\mathbf{M}$，$s$ 为稀疏度（零元素占比）。这个简单的点乘操作是所有稀疏化方法的基础。

公式 2：SparseGPT 的逐层误差补偿

解释：SparseGPT 的核心——在剪枝第 $q$ 个权重时，用最优脑外科医生（OBS）框架估计其对输出的影响，其中 $\mathbf{H} = 2\mathbf{X}\mathbf{X}^{\top}$ 是 Hessian 矩阵近似。分母 $[\mathbf{H}^{-1}]_{qq}$ 刻画了该权重的"可补偿性"。

公式 3：MoE 的稀疏路由策略

解释：MoE 通过一个轻量级门控网络 $G$ 将输入 $x$ 路由到 $E$ 个专家中得分最高的 $k$ 个（通常 $k \ll E$）。$\epsilon\cdot\text{Softplus}(\mathbf{W}_n x)$ 是用于负载均衡的噪声项。活跃参数比例为 $k/E$。

公式 4：精度-效率的帕累托前沿

解释：稀疏训练的核心权衡——精度损失 $\mathcal{L}_{\text{sparse}}(s)$ 随稀疏度 $s$ 超线性增长（$\beta > 1$），而计算成本 $\text{Cost}(s)$ 线性下降。最优操作点是在 $s$ 空间中寻找 $\mathcal{L}$ 与 $\text{Cost}$ 的平衡点。Google DeepMind 的 Compression Scaling Laws 进一步揭示 $\alpha$ 和 $\beta$ 与模型规模、数据量的幂律关系。

公式 5：动态稀疏训练（DST）的梯度信号保留

解释：DST 的核心——梯度只在稀疏子集上传播（掩码 $\mathbf{M}$），同时掩码本身随训练动态演化：定期剪掉不重要权重，生长新的连接。这使得稀疏结构本身也成为学习的对象。

1.4 实现逻辑（Python 伪代码）

import torch
import torch.nn as nn

class SparseLinear(nn.Module):
    """稀疏线性层 - 体现稀疏训练的核心抽象"""
    def __init__(self, in_features: int, out_features: int, sparsity: float = 0.5):
        super().__init__()
        self.weight = nn.Parameter(torch.randn(out_features, in_features))
        self.sparsity = sparsity
        # 可学习/固定的二进制掩码
        self.register_buffer('mask', self._init_mask(sparsity))

    def _init_mask(self, sparsity: float) -> torch.Tensor:
        """初始化稀疏掩码"""
        mask = torch.ones_like(self.weight)
        n_zeros = int(self.weight.numel() * sparsity)
        flat_idx = torch.topk(self.weight.abs().view(-1), n_zeros, largest=False).indices
        mask.view(-1)[flat_idx] = 0
        return mask

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        # 前向：仅激活掩码对应参数
        return nn.functional.linear(x, self.weight * self.mask)


class DynamicSparseTrainer:
    """动态稀疏训练器 - 体现稀疏训练的关键算法逻辑"""
    def __init__(self, model: nn.Module, sparsity: float = 0.7,
                 grow_fraction: float = 0.3, dense_update_interval: int = 100):
        self.model = model
        self.target_sparsity = sparsity
        self.grow_fraction = grow_fraction
        self.interval = dense_update_interval
        self.step_count = 0

    def step(self, loss: torch.Tensor):
        """执行一次稀疏训练步骤"""
        loss.backward()
        self.step_count += 1

        # 定期更新稀疏结构（剪枝+生长）
        if self.step_count % self.interval == 0:
            for module in self.model.modules():
                if isinstance(module, SparseLinear):
                    self._update_sparsity(module)

    def _update_sparsity(self, layer: SparseLinear):
        """核心算法：基于梯度的稀疏结构演化"""
        with torch.no_grad():
            # 1. 计算重要性分数（权重 × 梯度幅值）
            importance = layer.weight.abs() * layer.grad.abs()

            # 2. 按分数排序，保留最重要参数
            n_keep = int(layer.weight.numel() * (1 - self.target_sparsity))
            n_current_active = layer.mask.sum().item()
            n_prune = int(n_current_active * self.grow_fraction)
            n_grow = n_prune  # 保持总稀疏度不变

            # 3. 剪枝：移除当前活跃中最不重要的 n_prune 个
            active_importance = importance * layer.mask
            prune_idx = torch.topk(active_importance.view(-1), n_prune,
                                   largest=False).indices
            layer.mask.view(-1)[prune_idx] = 0

            # 4. 生长：在当前不活跃中最可能被需要的 n_grow 个
            inactive_importance = importance * (1 - layer.mask)
            grow_idx = torch.topk(inactive_importance.view(-1), n_grow,
                                  largest=True).indices
            layer.mask.view(-1)[grow_idx] = 1


class MoELayer(nn.Module):
    """混合专家层 - 架构级稀疏的体现"""
    def __init__(self, n_experts: int = 8, top_k: int = 2, d_model: int = 768):
        super().__init__()
        self.n_experts = n_experts
        self.top_k = top_k
        # 轻量级路由网络
        self.gate = nn.Linear(d_model, n_experts, bias=False)
        # 专家网络
        self.experts = nn.ModuleList([
            nn.Sequential(
                nn.Linear(d_model, d_model * 4),
                nn.GELU(),
                nn.Linear(d_model * 4, d_model)
            ) for _ in range(n_experts)
        ])

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        # 仅激活 top-k 个专家，实现架构级稀疏
        scores = self.gate(x)                   # [batch, n_experts]
        weights = torch.softmax(scores, dim=-1)
        top_k_weights, top_k_indices = torch.topk(weights, self.top_k,
                                                  dim=-1)
        top_k_weights = top_k_weights / top_k_weights.sum(dim=-1, keepdim=True)

        # 仅计算 top-k 个专家
        output = torch.zeros_like(x)
        for i, expert in enumerate(self.experts):
            mask = (top_k_indices == i).any(dim=-1)
            if mask.any():
                output[mask] += expert(x[mask]) * \
                    top_k_weights[mask][:, (top_k_indices[mask] == i).float()]
        return output

1.5 性能指标

1.6 扩展性与安全性

水平扩展：

• MoE 的专家并行：不同专家可分配到不同 GPU 上独立计算，路由层协调负载。DeepSpeed-MoE 支持千卡级专家并行训练。
• 数据并行 + 模型并行：稀疏模型可结合 ZeRO-3 等优化策略，在保持稀疏结构的同时扩大数据并行规模。FSMoE 在 DeepSpeed-MoE 基础上再提升 1.2-3.0×。
• 动态稀疏训练的分布式挑战：参数剪枝/生长需要在各 GPU 间同步掩码状态，通信开销随卡数增长。

垂直扩展：

• 单节点上限：2:4 半结构化稀疏是 NVIDIA GPU 原生支持的稀疏模式，可提供约 2× 加速，理论 FLOPS 上限受限于 Tensor Core 的稀疏计算能力。
• 精度-稀疏度曲线：模型越大，对高稀疏度的容忍度越高（Llama-4-Maverick 400B 在 90% 激活稀疏度下仍能保持鲁棒性）。
• 硬件利用瓶颈：非结构化稀疏在 GPU 上无法利用 Tensor Core，退化为基础 CUDA 内核计算，实际加速比远低于理论值。

安全考量：

• 稀疏对抗攻击：稀疏模型可能更易受到结构化对抗扰动——攻击者可能针对特定稀疏模式设计对抗样本，干扰模型的关键稀疏路径。
• 信息泄露：稀疏掩码本身可能泄露训练数据信息。可学习掩码（如 MaskLLM）的分布可能被逆向工程。
• 计算侧信道：不同稀疏模式的计算时间差异可被用作侧信道，推断输入属性（如 SecretGen 攻击）。
• 鲁棒性退化：高稀疏度下模型的泛化边界会收缩，专家路由模型在 OOD 样本上可能表现不稳定。

第二部分：行业情报

2.1 GitHub 热门项目

2.2 关键论文（12 篇）

2.3 系统化技术博客（10 篇）

2.4 技术演进时间线

2016 ── Deep Compression (Han et al.)：剪枝+量化+哈夫曼编码的三阶段压缩框架 → 奠定现代模型压缩方法论基础
2017 ──  Lottery Ticket Hypothesis (Frankle & Carbin)：发现"中奖彩票"子网络可以独立训练至全模型精度 → 开启稀疏训练理论新方向
2019 ──  Switch Transformer (Google)：首个大规模 MoE 语言模型（1.6T 参数），引入 Top-1 路由 → 架构级稀疏进入主流视野
2020 ──  GSP (Rigging the Lottery)：首次将 LTH 引入 Transformer → 稀疏训练开始关注大模型
2021 ──  GLaM (Google)：用 64 专家的 MoE 架构在 1/3 能耗下超越 GPT-3 → 验证了 MoE 规模化的可行性
2022 ──  DST (Dynamic Sparse Training)：参数剪枝与生长动态交替 → 打破静态稀疏，结构本身可学习
2023 ──  SparseGPT (IST)：首次实现百亿参数 LLM 的 one-shot 剪枝（ICML 2023） → 剪枝不再需要重训练
      ──  Mixtral 8x7B (Mistral)：首个成功的开源 MoE 模型 → MoE 普及化
2024 ──  Wanda (ICLR 2024)：极简方法的惊人效果 → 重新审视复杂方法的必要性
      ──  LLM-Shearing / Sheared LLaMA (ICLR 2024)：结构化剪枝 + 动态数据加载 → 剪枝可用于加速预训练
      ──  MaskLLM (NeurIPS 2024 Spotlight)：可学习 N:M 稀疏 → 稀疏掩码本身可跨任务迁移
      ──  DeepSeek-V2：创新 MoE 架构（Multi-Head Latent Attention + DeepSeekMoE） → 国产 MoE 路线崛起
2025 ──  Compression Scaling Laws (Google DeepMind)：稀疏/量化的统一缩放律 → 稀疏训练有了理论基础
      ──  MoE vs Dense 系统化对比研究：公平比较下的条件性结论 → 从业者有了选型依据
      ──  Elsa (ICLR 2026)：ADMM 驱动 90% 极致稀疏 → 突破 50-60% 的稀疏上限
      ──  OBR (ICLR 2026)：W4A4KV4 + 50% 稀疏联合压缩 → 稀疏+量化的最优结合
      ──  Intra-Expert Activation Sparsity：发现 MoE 专家内 90% 天然稀疏 → 开辟新优化维度
      ──  MLPerf Training v6.0 GPT-OSS 20B MoE Benchmark：首个标准化稀疏预训练基准 → 行业标准建立
2026 ──  SparseForge：5B tokens 恢复超越稠密 → 微调成本断崖式下降
      ──  Full Attention Strikes Back：100 训练步内从全注意力到稀疏注意力 → 训练极度高效化
      ──  DECO MoE：20% 激活匹配稠密性能 → 边缘端 MoE 可行
      ──  当前状态：稀疏训练已从"能否做"进入"如何做得更好"阶段，精度-效率平衡的帕累托前沿正在被快速推进

第三部分：方案对比

3.1 历史发展时间线

2020 前 ── 权重剪枝（Magnitude Pruning / L1 正则化）→ 简单直接但效果有限
2021-2022 ── 结构化剪枝 + LTH（彩票假说）→ 理论突破但实践成本高
2023 ── SparseGPT / Wanda：One-shot 后训练剪枝 → 成本巨降，普及化
2023-2024 ── MoE 大规模应用（Mixtral, DeepSeek, Qwen-MoE）→ 架构级稀疏成为主流
2024-2025 ── N:M 半结构化稀疏 + 可学习掩码 → 硬件友好的稀疏模式
2025-2026 ── 统一框架（联合剪枝+量化+蒸馏）+ 极致稀疏（90%+）→ 精度-效率平衡进入新阶段
2026 ── 当前状态：从"单点技术"走向"系统工程"，多种稀疏技术的组合使用成为标配

3.2 六种方案横向对比

方案 A：One-Shot 后训练剪枝（SparseGPT / Wanda）

方案 B：结构化剪枝 + 重训练（Sheared LLaMA / LLM-Pruner）

方案 C：动态稀疏训练（DST / RigL / SET）

方案 D：混合专家模型（MoE - Switch Transformer / Mixtral / DeepSeekMoE）

方案 E：半结构化 N:M 稀疏（MaskLLM / 2:4 稀疏）

方案 F：联合压缩（OBR / Prune-Quantize-Distill Pipeline）

3.3 技术细节对比

3.4 选型建议

第四部分：精华整合

4.1 The One 公式

解释：稀疏训练的核心是在"跳过不需要的计算"和"确保跳过的不重要"之间找到平衡，同时避免非结构化带来的硬件效率损失。最成功的方案（如 OBR、SparseForge）都是在精度保持、结构化设计、低成本实施这三个角力点上同时取得进展。

4.2 一句话解释

稀疏训练就像给大模型做"定向手术"——不是去掉整个器官（模型压缩），而是让它在工作时只激活所需的一小部分脑细胞，其余保持休眠，这样既能保持思维能力，又大幅降低了能耗。

4.3 核心架构图

                       精度要求
                          ↑
                          │
              ┌───────────┼───────────┐
              │           │           │
        结构化剪枝   半结构化N:M   非结构化剪枝
        (真实加速)   (TensorCore)  (理论加速)
              │           │           │
              └───────────┼───────────┘
                          │
                    联合压缩(剪枝+量化+蒸馏)
                     ─── 最优精度-效率 ───→ 稀疏度增加

4.4 STAR 总结

4.5 理解确认问题

问题：假设你有一个 7B 参数的 Llama-2 模型部署在 8×A100 服务器上，当前推理延迟过高。你要在以下三种方案中选择：

• (A) 使用 Wanda 剪枝到 70% 非结构化稀疏
• (B) 使用 MaskLLM 训练 2:4 半结构化稀疏
• (C) 使用 SparseGPT 剪枝到 50% 结构化稀疏并按层非均匀分配

问：哪种方案能实际降低延迟？为什么？

参考答案：(B) 和 (C) 都能带来实际加速。原因：

• (A) ❌ 不可选：70% 非结构化稀疏在 A100 上无法利用 Tensor Core，退化为基础 CUDA 内核计算，没有实际速度提升。而且 Wanda 在高稀疏度（70%）下的精度退化远严重于 SparseGPT。
• (B) ✅ 可选：2:4 半结构化稀疏是 NVIDIA Ampere+ 架构 Tensor Core 原生支持的稀疏模式（2× 加速），MaskLLM 的可学习掩码可在目标领域微调中恢复精度。这是"真实加速"方案。
• (C) ✅ 可选：非均匀层间稀疏分配（OWL 方法）+ 结构化模式，可在 50% 整体稀疏度下获得接近 2× 的加速（配合 DeepSparse 等引擎），且由于是逐层自适应，精度保持更优。
• 最优选：在 B200 或 H100 上，推荐 B + INT8 量化组合，可实现约 3-4× 端到端加速，且精度损失小于 1%。

报告结束 | 调研日期：2026-05-22 | 调研框架版本：v2.0