想象你是一位园艺师，面对一棵枝繁叶茂的果树。叶子虽多，真正结果实的只有一部分枝条——那些多余的枝叶每天消耗大量养分（算力）和水分（存储），贡献却微乎其微。你要做的，就是拿起剪刀，把不结果的枝叶剪掉。AI 模型就是这样一棵“果树”：训练好的神经网络里，大量权重参数冗余得近乎多余，它们对预测结果影响甚微，却占据着宝贵的存储空间，消耗着昂贵的计算资源。在手机、摄像头、车载芯片这类边缘设备上，内存和算力就像“贫瘠的土壤”，容不下枝繁叶茂的巨型模型。稀疏化（Sparsification）的思路简单而巧妙：找出冗余参数，把它们“剪掉”（置零），让模型更轻、更快，同时精度几乎不变。

岗位关联

在边缘 AI 计算领域，稀疏化是把大模型“塞进”小芯片的利器。掌握它，你就有能力在精度与效率的钢丝上起舞，让 AI 真正下沉到万物互联的每个角落。

目录
  1. 可视化演示
  2. 稀疏化概述：果园的修剪之道
  3. 核心概念：密度与两种剪法
  4. 非结构化稀疏：零散修剪小叶片
  5. 结构化稀疏：整枝整干地修剪
  6. 剪枝策略：何时剪、如何剪
  7. 硬件支持：不同工具的适配性
  8. 工程选型：因地制宜的修剪方案
  9. AI 应用场景
  10. Python 演示
  11. 常见误区
  12. 面试题

可视化演示

动态展示非结构化稀疏、结构化稀疏、剪枝训练策略与硬件稀疏加速四个视角，直观理解模型压缩中精度与效率的平衡。

本节配有交互动效（进入视口后自动加载，约 3KB）。

稀疏化概述：果园的修剪之道

我们把果园交给一位老园艺师。他看到的不是整棵树的宏观轮廓，而是一根根具体的枝条：哪根挂果多，哪根只长叶子不结果，心里都有一本账。修剪的第一步是清点——哪些枝叶值得留，哪些必须剪。稀疏化的起点，正是这样一次彻底清点：模型里有海量权重，有多少在默默干活，有多少只是挂名的“冗员”？

神经网络的权重参数，就是这一根根“枝条”。训练完成后，大量权重绝对值极小，对输出的贡献几乎为零。把它们置为零，模型行为几乎不变——这就是“修剪”的底气。稀疏化通过零值化冗余参数，减少了矩阵运算中的有效计算量和存储需求，尤其适合内存和算力都捉襟见肘的边缘设备。

衡量修剪空间大小，靠的是稀疏度这一指标。老园艺师拿本子记下：这棵树一共多少根枝条，其中多少根在挂果、多少根在空耗养分。稀疏度就是那个“空耗比例”——它决定了这棵树能剪到什么程度。

老园艺师清点完果园，心里有了底：原来挂果的枝条只占六成，四成在白吃养分。稀疏度这个数字，就是园艺师账本上的“冗余比例”——它告诉我们，这棵模型的修剪空间有多大。

S=1−NnzN\displaystyle S = 1 - \frac{N_{nz}}{N}
这个公式算的是“被剪掉的比例”：权重里零值参数占总参数的比例，S 越大说明模型越“瘦”。
  1. 参数总数 N模型权重矩阵中所有参数的数量，相当于果园里所有枝条的总数。
    N=权重总参数个数\displaystyle N = \text{权重总参数个数}
  2. 非零参数个数 Nnz剪枝后仍然“活着”的权重数目，对应仍在结果的枝条数。
    Nnz=非零参数个数\displaystyle N_{nz} = \text{非零参数个数}
  3. 相除得密度非零参数占全部参数的比例，反映模型“枝繁叶茂”的程度。
    NnzN=密度\displaystyle \frac{N_{nz}}{N} = \text{密度}
  4. 1 减得稀疏度用 1 减去密度，就得到被剪掉的冗余比例。
    S=1−NnzN\displaystyle S = 1 - \frac{N_{nz}}{N}

核心概念：密度与两种剪法

确定了修剪空间，园艺师面临两种选择：是零散地摘掉枯叶，还是整枝整干地锯掉废枝？这是两种截然不同的修剪哲学。对应到模型压缩，就是非结构化稀疏与结构化稀疏——前者以单个权重为粒度逐个置零，灵活但零散；后者以通道、块或核为整块单位置零，整齐但“杀伤面”更大。

“密度”是非零参数占总参数的比例，与稀疏度互为补数：密度 = 1 - 稀疏度。剪得越多，密度越低，模型越“骨感”。真正影响工程效果的是粒度差异：粒度越细，理论上可剪的空间越大、精度损失越小，但零值散落各处、存储不规整，硬件难以高效跳过；粒度越粗，硬件实现简单、加速立竿见影，但一整块被剪的参数里可能混着重要权重，精度更容易受损。

园艺师拿着两把工具——小剪刀和修枝锯。小剪刀灵活但费工，修枝锯痛快但误伤难免。选哪把，取决于果园的土壤（硬件）和果树的状态（模型结构）。

Density=NnzN=1−S\displaystyle \text{Density} = \frac{N_{nz}}{N} = 1 - S
密度是稀疏度的“反义词”：两者加起来恒等于 1，一个在说留下来的多不多，一个在说剪掉的多不多。
  1. 非零参数个数 Nnz权重中“活下来”的参数，如同果园中仍结果的枝条。
    Nnz=非零参数的个数\displaystyle N_{nz} = \text{非零参数的个数}
  2. 除以 N 得密度非零占比就是模型的“枝繁叶茂程度”。
    NnzN=模型密度\displaystyle \frac{N_{nz}}{N} = \text{模型密度}
  3. 与 S 互补密度等于 1 减稀疏度，剪得越多、密度越低，二者此消彼长。
    1−S=1−(1−NnzN)=NnzN\displaystyle 1 - S = 1 - \left(1 - \frac{N_{nz}}{N}\right) = \frac{N_{nz}}{N}

非结构化稀疏：零散修剪小叶片

老园艺师足够耐心，一片片地检查叶片。看到枯黄的、挡光的、几乎不参与光合作用的叶子，就轻轻剪掉。这种精细到每一片叶子的修剪，就是非结构化稀疏——把每个权重当作独立的“叶片”，按规则逐个置零。

最常用的规则是幅度剪枝：绝对值小于阈值 τ 的权重，被视为冗余，直接归零。这样做精度损失通常较小，因为绝对值小的参数本来就贡献微弱。然而问题随之而来：置零后的权重在内存中零零散散，无法用紧凑连续的布局表达，计算单元想跳过这些零值，还得额外判断位置——就像园丁为了一片枯叶，得在整个树冠里来回穿梭。

硬件上的尴尬在于，通用处理器执行矩阵乘法时，并不会因为你告诉它“这里有零”就节省计算周期——它照样老老实实把每个数乘一遍。因此非结构化稀疏的实际收益，更多体现在存储端（配合稀疏编码）而非计算端。它在精度友好和硬件不友好之间，摆出了一道选择题。

细碎修剪能最大程度保住果树的生机，但费时费力。非结构化稀疏正是如此——精度友好，却给存储和计算出了道难题。

wi←0,if ∣wi∣<τ\displaystyle w_i \leftarrow 0, \quad \text{if } |w_i| < \tau
这条规则像园艺师的“红线”：哪个叶子的“营养值”低于红线，就剪掉哪片，让它从计算中彻底退出。
  1. 第 i 个权重 wi这就是其中一片“叶子”，卷积核或矩阵里一个具体的参数。
    wi=第 i 个权重\displaystyle w_i = \text{第 } i \text{ 个权重}
  2. 权重的绝对值 |wi|衡量这片叶子值不值得留——绝对值越大，对输出的贡献通常越重要。
    ∣wi∣=权重绝对值\displaystyle |w_i| = \text{权重绝对值}
  3. 剪枝阈值 τ园艺师心里的“营养红线”，低于它就要被剪。
    τ=剪枝阈值\displaystyle \tau = \text{剪枝阈值}
  4. 条件置零条件成立就把该权重变成零，永不再参与前向计算的乘法累加。
    wi←0,if ∣wi∣<τ\displaystyle w_i \leftarrow 0, \quad \text{if } |w_i| < \tau

结构化稀疏：整枝整干地修剪

果园的另一头，老园艺师握着修枝锯，几锯下去锯掉一整根枝条。痛快是痛快，但必须事先判断这枝到底结不结果。结构化稀疏就是这么干的——不再单个剪权重，而是整块、整通道、整核地剪掉。

判断哪根枝条该锯，常用 L1 范数衡量通道重要性：把某个通道里所有权重的绝对值加起来，总和越小，说明该通道整体贡献越弱，优先被剪。这种剪法下，权重矩阵变成“瘦长条”，存储连续、计算规整，硬件可以轻松跳过整块数据——园艺师锯掉整根枝条后，切口整整齐齐，后续护理也方便。

当然，粒度粗也会误伤：一个通道里可能有一两个重要权重，却也随大流被一刀切掉了。块稀疏、核级稀疏则是更细一档的结构化方式，它们卡在“完全零散”和“整通道”之间，尽量兼顾灵活与规整。工程上常说结构化稀疏“硬件友好”，正是因为它的切口干净，计算单元能成块地跳过零数据。

整枝修剪干净利落，果树通风透光都好了，但锯错了枝也真心疼。结构化稀疏是工程上“性价比”更高的选择，因为硬件喜欢整齐的切口。

Ic=∑i=1H∑j=1W∣Wc,i,j∣\displaystyle I_c = \sum_{i=1}^{H} \sum_{j=1}^{W} |W_{c,i,j}|
这个公式算的是某个通道的“总营养值”：把通道里所有权重的绝对值累加，得分越高越值得保留。
  1. 通道 c 的权重 Wc,i,j第 c 个通道中位于 (i,j) 位置的具体参数，类似枝条上的一簇叶片。
    Wc,i,j=通道 c 的权重\displaystyle W_{c,i,j} = \text{通道 } c \text{ 的权重}
  2. 双重求和 ∑∑把该通道所有位置上的权重绝对值都加起来，H 和 W 是通道的高与宽。
    ∑i=1H∑j=1W=遍历整个通道\displaystyle \sum_{i=1}^{H} \sum_{j=1}^{W} = \text{遍历整个通道}
  3. 通道重要性 IcL1 范数越大，通道越重要，越应该保留；越小则越可能被锯掉。
    Ic=通道 L1 范数得分\displaystyle I_c = \text{通道 L1 范数得分}

剪枝策略：何时剪、如何剪

修剪不是一次性的。老园艺师讲究“四季修剪”——冬天重剪整形，春天轻疏花芽，剪完还要及时施肥浇水。模型的剪枝同样讲究策略和节奏，不同的时令对应不同的剪法。

剪枝策略大体分三类：训练后剪枝（模型训练完，直接剪一刀）、稀疏训练（训练全程边训边剪）、迭代剪枝与重训练（剪 → 训 → 再剪，循环往复）。其中迭代剪枝加微调是工业界最常用的“冬剪 + 春养”组合拳：每轮只剪一小部分低重要度权重，剪完立刻重训练恢复精度，再进入下一轮修剪。

用掩码 M 表示每个权重的生死状态：活着记 1，被剪记 0。训练时梯度只在存活的权重上更新，被剪掉的参数保持零值不再复活。少量多次的节奏，让模型像被温柔地精雕细琢，而不是挨一记猛斧——一次性猛剪 90% 的权重，精度往往瞬间崩盘；分十次每次剪 9%，中间不断恢复，最终却能平稳到达同样的稀疏度。

园艺师每次只剪几枝、剪完就施肥，来年果树照常开花结果。迭代剪枝正是这种“温柔而坚定”的修剪节奏，把精度损失降到了最低。

W(t+1)=arg⁡min⁡WL(W⊙M(t))\displaystyle W^{(t+1)} = \arg\min_{W} \mathcal{L}(W \odot M^{(t)})
这是“修剪后继续养护”的数学表达：在每个剪枝掩码约束下，重新找到让损失最小的那一组权重。
  1. 第 t 轮掩码 M(t)记录了这轮“哪些枝条活着、哪些被剪”，是一个只含 0 和 1 的矩阵。
    M(t)=第 t 轮剪枝掩码\displaystyle M^{(t)} = \text{第 } t \text{ 轮剪枝掩码}
  2. 逐元素乘 ⊙用掩码把被剪权重强制归零，活着的位置才保留原值。
    W⊙M(t)=掩码后的权重\displaystyle W \odot M^{(t)} = \text{掩码后的权重}
  3. 损失函数 L衡量模型预测与真实标签偏差的目标函数。
    L(⋅)=损失函数\displaystyle \mathcal{L}(\cdot) = \text{损失函数}
  4. argmin 寻优在保持剪枝结构不变的前提下，寻找让损失降到最低的新权重。
    arg⁡min⁡W=寻找最优权重\displaystyle \arg\min_{W} = \text{寻找最优权重}

硬件支持：不同工具的适配性

剪法再好，也得有趁手的工具。老园艺师的工具房里有三样宝贝：小巧的修枝剪、省力的修枝锯、自动修剪机。用对工具，事半功倍；用错工具，事倍功半。模型的稀疏模式最终要在硬件上执行才有意义，所以必须先看硬件认不认这套“剪法”。

GPU、CPU 和专用 NPU 对稀疏计算的支持天差地别。通用 CPU 说：“零？我照样乘加。”——自动修剪机根本不看叶子，把整棵树粗犷地推一遍。NVIDIA Ampere 架构则引入了 2:4 结构化稀疏：每 4 个连续权重里强制保留 2 个非零值，硬件可以跳过一半的乘加运算，实现约 2 倍加速。专用 NPU 更灵活，通过稀疏存储格式和零值跳过逻辑，对非结构化稀疏也能部分加速。

存储格式也是关键一环。稀疏矩阵常用的 CSR（压缩稀疏行）等格式，把非零值紧凑排列并附上索引，让内存占用大幅下降。但索引本身也有开销，稀疏度不够高时甚至可能“越省越费”。理解这一现实很重要：不以硬件为准的稀疏化，往往是纸面上的稀疏，不是工程上的加速。

修枝剪再精巧，面对粗壮老枝也无能为力；自动修剪机再快，对精细盆景也束手无策。硬件选型，决定了稀疏化收益的天花板。

Speedup=NtotalNnz×α\displaystyle \text{Speedup} = \frac{N_{\text{total}}}{N_{\text{nz}}} \times \alpha
理论加速比要乘以一个“硬件效率系数”才接近真实效果，而这个系数的大小，完全取决于工具的脾气。
  1. 总计算量 Ntotal未剪枝时矩阵乘法需要执行的计算次数。
    Ntotal=总计算量\displaystyle N_{\text{total}} = \text{总计算量}
  2. 非零计算量 Nnz剪完后实际有效的那部分计算。
    Nnz=非零计算量\displaystyle N_{\text{nz}} = \text{非零计算量}
  3. 理论加速比两者相除，是理想的加速倍数，相当于“零越多越快”。
    NtotalNnz=理论加速比\displaystyle \frac{N_{\text{total}}}{N_{\text{nz}}} = \text{理论加速比}
  4. 硬件效率系数 α0 到 1 之间的折扣，刻画硬件真正能利用稀疏性的程度。
    α=硬件效率系数\displaystyle \alpha = \text{硬件效率系数}

工程选型：因地制宜的修剪方案

老园艺师最后的智慧，在于因地制宜——砧木壮的果树可以狠剪，弱小的树苗只能轻剪。他从不追求剪枝数量最多，而是追求果园总产量最高。工程选型同样要算总账：目标硬件支持什么粒度的稀疏？模型精度能承受多少损失？重训练预算够不够？

小型模型往边缘芯片上部署，通常选结构化剪枝加稀疏训练，因为硬件收益明确、落地快；大模型推理服务跑在专用 NPU 上，可以尝试较高稀疏度的非结构化剪枝，在存储和带宽上换取更激进的压缩率。评估方案时要从体积缩减率、推理延迟、精度变化、再训练成本四个维度打分——不存在放之四海皆准的“最优方案”，只有结合场景的“最合适方案”。

工具链的成熟度常被忽略：你剪得再好，如果框架不支持稀疏算子的高效执行，一切都白搭。成熟的稀疏工具链（例如 PyTorch 的 torch.sparse、NVIDIA 的 ASP 等）能大大降低工程成本，让“剪刀”真正落到代码里。

园艺师的笔记本上记着每棵树的修剪档案：品种、树龄、工具、时令。模型稀疏化工程，就是一门把“剪刀下的艺术”变成“可量化收益”的手艺。

Benefit=ΔRsizeΔLoss\displaystyle \text{Benefit} = \frac{\Delta R_{\text{size}}}{\Delta \text{Loss}}
这个式子把修剪方案的“性价比”算得明明白白：每损失一点精度，能换来多大的模型瘦身。
  1. 体积缩减率 ΔRsize剪完之后模型参数量的下降比例，瘦身越狠，分子越大。
    ΔRsize=参数量缩减率\displaystyle \Delta R_{\text{size}} = \text{参数量缩减率}
  2. 精度损失 ΔLoss剪枝带来的模型精度下降幅度，损失越小，分母越小。
    ΔLoss=精度损失\displaystyle \Delta \text{Loss} = \text{精度损失}
  3. 综合收益 Benefit两者相除，表示“每付出单位精度代价换来的瘦身收益”。
    Benefit=ΔRsizeΔLoss\displaystyle \text{Benefit} = \frac{\Delta R_{\text{size}}}{\Delta \text{Loss}}

AI 应用场景

边缘端视觉模型部署

阶段：模型压缩与部署优化

解决的问题：手机端图像分类模型动辄几十 MB，边缘芯片内存小、算力弱，直接部署会卡顿且耗电。传统方式要么忍痛降低分辨率，要么改用小模型但精度跳水。

具体案例：某智能门锁团队在 4MB 内存的 MCU 上部署人脸识别模型，先用结构化通道剪枝砍掉 40% 的卷积通道，再做 2:4 结构化稀疏，最终模型从 18MB 减到 6MB，单次推理延迟从 320ms 降到 95ms，识别准确率仅下降 1.2%，真正做到了“果园修剪后照样硕果累累”。

大语言模型推理加速

阶段：推理服务性能优化

解决的问题：LLM 推理时巨大的矩阵乘法让 GPU 忙得不可开交，token 生成成本居高不下。传统做法只能堆更多显卡，烧钱且能耗高。

具体案例：某 AI 公司对部署在 GPU 上的 7B 对话模型做 2:4 结构化稀疏，配合 NVIDIA 稀疏张量核心，矩阵乘法速度提升约 1.8 倍，显存占用下降 30%，推理吞吐翻倍。用户无感，账单有感——“修剪机”精准地砍掉了不结果的枝干。

自动驾驶实时感知

阶段：车规级模型轻量化

解决的问题：车载芯片对功耗和延迟要求极其苛刻，感知模型必须在毫秒级完成目标检测，同时不能牺牲安全性。

具体案例：某自动驾驶方案商在域控制器上部署 3D 目标检测模型，采用稀疏训练与迭代剪枝结合的策略，将模型稀疏度做到 65%，在专用 NPU 上通过零值跳过逻辑获得约 2.3 倍加速，检测精度只掉了 0.8%，成功满足前装量产对实时性和安全性的双重标准。

Python 演示

python57 行
import numpy as np  def magnitude_prune(weights, sparsity=0.5):    """非结构化剪枝: 按绝对值阈值将最小的一部分权重置零。"""    threshold = np.percentile(np.abs(weights), sparsity * 100)    mask = np.abs(weights) > threshold    return weights * mask, mask  def channel_prune(weights, ratio=0.25):    """结构化剪枝: 按通道L1范数剪掉低重要性通道。"""    norms = np.abs(weights).reshape(weights.shape[0], -1).sum(axis=1)    keep_num = int(weights.shape[0] * (1 - ratio))    keep_idx = np.argsort(norms)[-keep_num:]    mask = np.zeros_like(weights, dtype=bool)    mask[keep_idx, :] = True    return weights * mask, mask  def measure_sparsity(weights):    """计算稀疏度: 零值参数占总参数的比例。"""    return float(np.mean(weights == 0))  def mock_accuracy(mask, original_acc=0.90):    """模拟精度: 保留参数比例越高, 精度损失越小。"""    kept_ratio = float(mask.mean())    acc_drop = (1.0 - kept_ratio) * 0.15    return max(0.0, original_acc - acc_drop)  def main():    rng = np.random.default_rng(42)    conv_weight = rng.normal(0, 0.05, size=(32, 3, 3, 3))     print("原始非零比例: {:.1%}".format(1.0 - measure_sparsity(conv_weight)))    print("原始模拟精度: 90.0%")    print()     pruned_uw, mask_uw = magnitude_prune(conv_weight, 0.6)    print("非结构化剪枝(目标稀疏度60%):")    print("  实际稀疏度: {:.1%}".format(measure_sparsity(pruned_uw)))    print("  模拟精度: {:.2f}%".format(mock_accuracy(mask_uw) * 100))    print()     pruned_cw, mask_cw = channel_prune(conv_weight, 0.25)    print("结构化剪枝(剪掉25%通道):")    print("  实际稀疏度: {:.1%}".format(measure_sparsity(pruned_cw)))    print("  模拟精度: {:.2f}%".format(mock_accuracy(mask_cw) * 100))    print()     print("结论: 结构化剪枝稀疏度较低但硬件友好, 非结构化剪枝压缩潜力大但受硬件限制。")  if __name__ == "__main__":    main()
目的：用一个小型卷积权重张量演示两种核心剪枝——非结构化幅度剪枝与结构化通道剪枝，并对比它们的稀疏度与模拟精度表现。
  1. threshold = np.percentile(np.abs(weights), sparsity * 100)用分位数算出“营养红线”，低于它的权重都被视为冗余
  2. mask = np.abs(weights) > threshold生成 0/1 掩码，等于给每片叶子贴上“留”或“剪”的标签
  3. norms = np.abs(weights).reshape(weights.shape[0], -1).sum(axis=1)把每个通道的权重绝对值加起来，得到整根枝条的“营养总量”
  4. keep_idx = np.argsort(norms)[-keep_num:]只保留营养最足的那几根枝条，其余整通道锯掉
  5. np.mean(weights == 0)一行代码算出稀疏度，对应公式里的 S
  6. acc_drop = (1.0 - kept_ratio) * 0.15模拟“剪得越多、精度掉得越多”的经验规律

常见误区

误区很多人以为稀疏化就是把权重置零、导出小模型，一步到位。剪完模型还能用，何必再训练？直接部署不就行了？

正解一次猛剪往往让模型“伤筋动骨”，精度掉得厉害。就像园艺师冬天重剪之后，必须施肥浇水，果树才能缓过来。工业界标准做法是剪枝后微调：让存活权重重新适应被剪掉的结构，把精度“补”回来。迭代剪枝 + 重训练，正是“少量多次 + 及时养护”的修剪哲学。

为何常见：因为很多教程只展示了“剪完文件变小”这一步，忽略了表格下方的重训练细节，初学者自然以为万事大吉。

误区稀疏度越高，模型越小越快，那是不是剪到 90% 甚至 95% 才叫厉害？有些人追求“极致稀疏”数字，把它当成炫耀的资本。

正解稀疏度不是越高越好，而是“够用就好”。剪到一定程度后，存活权重难以弥补信息的缺失，精度会断崖式下跌——好比把结果实的枝条也锯掉了。合适的稀疏度取决于任务容错度：图像分类可能容忍 70% 稀疏，但自动驾驶感知可能连 50% 都要反复斟酌。

为何常见：因为“稀疏度”是个直观的数字，容易拿来横向比较，而精度损失是模糊的、需要长期评估的，数字好看自然更吸睛。

误区既然零值不用算，那我做非结构化稀疏，理论上能减少那么多计算量，肯定到处都能加速吧？GPU 上不跑得更快？

正解零值跳过需要硬件支持才能兑现。通用 CPU/GPU 在稠密计算时代设计，遇到零也会照常乘加，非结构化零值反而破坏了访存连续性，可能更慢。只有支持稀疏张量核心的 GPU 或专用 NPU 才能真正把零值转成加速。理论加速比乘上硬件效率系数，才是现实。

为何常见：因为算法课上的“稀疏矩阵计算复杂度更低”是数学理想，工程上还有访存模式、指令流水这些“物理约束”。

误区既然结构化稀疏硬件友好、工程好用，那它一定也比非结构化稀疏省更多的存储和计算吧？大家都去用结构化就好了。

正解恰恰相反，非结构化稀疏在同等精度下能达到更高的稀疏度，因为它的粒度细、可剪的空间大。结构化稀疏把整块权重连锅端，误伤率高，能剪的比例反而有限。两者各有侧重：非结构化“剪得多但硬件拿不到”，结构化“剪得少但硬件全兑现”。选谁，取决于你缺的是存储还是算力。

为何常见：因为“硬件友好”听起来就像“全都更好”，其实它只是“更容易受益于硬件”，压缩力度上反而是弱项。

面试题

Q1. 稀疏化的本质是什么？

单选题 · easy

  • A.将冗余权重置零以减少计算量← 正确答案
  • B.将模型各层参数全部量化
  • C.将模型注意力层数不断减少
  • D.用更小的模型替换原模型

答案：A。稀疏化通过把冗余参数置零来压缩模型，就像园艺师剪掉不结果的枯枝。量化（B）是降低数值精度，减少层数（C）和换小模型（D）属于别的压缩手段，与稀疏化的核心理念不同。

Q2. 非结构化稀疏与结构化稀疏的核心区别是什么？

单选题 · mid

  • A.剪枝的粒度一个是权重一个是块← 正确答案
  • B.非结构化稀疏存储上更加节省内存
  • C.两者在算法实现上没有任何区别
  • D.结构化稀疏剪的是梯度而非权重

答案：A。非结构化稀疏以单个权重为粒度置零，结构化稀疏以通道、块或核为单位整体剪掉。B 说法不准确，非结构化零值散乱，存储格式反而更复杂；C 显然错误；D 混淆了剪枝对象，剪的是权重不是梯度。

Q3. 以下哪些是常见的稀疏剪枝策略？

多选题 · mid

  • A.训练完成后直接剪枝← 正确答案
  • B.训练过程中持续剪枝← 正确答案
  • C.剪枝后微调恢复精度← 正确答案
  • D.学习率预热与退火

答案：ABC。训练后剪枝、稀疏训练（边训边剪）、迭代剪枝与重训练都是主流策略。学习率预热与退火是通用训练技巧，不是剪枝策略，好比浇水施肥的时机不属于修剪本身。

Q4. 为什么非结构化稀疏在通用硬件上难以获得实际加速？

单选题 · hard

  • A.零值在内存中散乱，硬件难跳过计算← 正确答案
  • B.非结构化稀疏会让模型精度大幅下降
  • C.剪枝后模型的所有权重都变成零值
  • D.非结构化稀疏无法减小模型体积

答案：A。非结构化稀疏的零值没有规律地散落在权重矩阵里，通用处理器缺少“跳过零值”的电路逻辑，反而破坏了访存连续性。精度下降（B）是剪得过多时的结果而非原因；C、D 更是明显与事实相反。

Q5. 稀疏度的定义是什么？

单选题 · easy

  • A.零值参数占全部参数的比例← 正确答案
  • B.非零参数占全部参数的比例
  • C.模型体积与训练数据量的比值
  • D.训练时间占总训练流程的比例

答案：A。稀疏度 S = 1 - Nnz/N，即零值参数占比。B 是密度的定义；C 和 D 与稀疏化毫无关系。好比果园里被剪掉的枝条占总枝条的比例。

Q6. 通道剪枝属于哪种稀疏模式？

单选题 · mid

  • A.属于结构化稀疏的一种方式← 正确答案
  • B.属于非结构化稀疏方式
  • C.属于动态稀疏的一种方式
  • D.属于混合精度训练方式

答案：A。通道剪枝把整个通道作为剪枝单位，切面整齐、硬件友好，是结构化稀疏的典型代表。非结构化稀疏是逐权重操作的，两者粒度完全不同。

Q7. 关于稀疏化与硬件支持，以下说法正确的是？

多选题 · hard

  • A.GPU张量核心支持2:4结构化稀疏加速← 正确答案
  • B.稀疏度越高硬件实际加速效果越成比例提升
  • C.专用NPU支持跳过零值计算以降延迟← 正确答案
  • D.所有硬件对稀疏计算的支持程度相同

答案：AC。NVIDIA Ampere 及后续 GPU 支持 2:4 结构化稀疏加速，专用 NPU 也有零值跳过逻辑。B 错误：稀疏度超过硬件支持的模式后，额外稀疏无法换加速；D 错误：不同硬件对稀疏的支持差异巨大。

Q8. 剪枝后通常需要做什么来恢复精度？

单选题 · mid

  • A.对保留的非零权重进行微调训练← 正确答案
  • B.将学习率调大后重新训练一轮
  • C.继续剪掉更多的权重参数即可
  • D.剪枝完成后不需要任何额外操作

答案：A。剪枝后必须微调（重训练）存活的非零权重，让它们补偿被剪掉参数的贡献。学习率盲目调大（B）会破坏已有参数，更多剪枝（C）雪上加霜，不做处理（D）则精度损失无处修复。

Q9. 以下哪种剪枝方式对硬件最友好？

单选题 · easy

  • A.2:4结构化稀疏模式最受硬件青睐← 正确答案
  • B.随机对权重逐元素置零更受欢迎
  • C.按绝对值大小逐个置零更好实现
  • D.均匀分布随机剪枝最利于硬件

答案：A。2:4 结构化稀疏每 4 个权重保留 2 个，规律整齐，GPU 能成块跳过零计算，是硬件最喜欢的“切口”。逐元素随机置零（B、C、D）都是非结构化稀疏，零值散乱，硬件难以高效利用。

Q10. 工程选型时，评价稀疏化方案需要综合考虑哪些因素？

多选题 · hard

  • A.目标硬件对稀疏计算的支持能力← 正确答案
  • B.剪枝后模型精度的损失程度← 正确答案
  • C.重训练所需的额外算力成本← 正确答案
  • D.部署工具链的成熟程度与生态← 正确答案

答案：ABCD。四个维度缺一不可：硬件支持决定加速能否兑现，精度损失决定方案是否可用，重训练成本决定工程预算，工具链成熟度决定落地效率。稀疏化选型不是单看稀疏度一个数字，而是像园艺师一样算果园的“综合收成”。