想象你是一位仓库管理员，面前是一间堆满箱子的仓库——这是大模型里所有的权重，足足有几十亿个箱子。你仔细一看，发现大部分箱子里只有一点点货物（数值接近 0），甚至有些是空箱。搬运整个仓库无疑是一场灾难，尤其是当仓库缩到手机那么小（端侧部署）时。聪明的做法是：先扔掉那些几乎没货的箱子（稀疏化），剩下装满货的箱子按顺序记在一本小账本上（Sparse Matrix），搬运时只照着账本走。这就是非结构化稀疏化与 Sparse Matrix 加速的直觉——不是优化搬运速度，而是让搬运清单本身变短。这篇文章会带你从仓库管理的视角，一步步看懂稀疏化、CSR/CSC 账本记法、稀疏矩阵乘法加速的原理，以及它们如何让大模型在手机和边缘设备上“轻装上阵”。

岗位关联

掌握稀疏化与稀疏矩阵加速，意味着你懂得以最少的算力和内存把大模型塞进手机、芯片等受限设备——这是端侧 AI 落地的核心工程能力。

目录
  1. 可视化演示
  2. 稀疏化基本概念
  3. 结构化与非结构化
  4. CSR/CSC 存储
  5. 稀疏矩阵乘法原理
  6. 端侧加速实现
  7. 工程部署实践
  8. 效果评估与趋势
  9. AI 应用场景
  10. Python 演示
  11. 常见误区
  12. 面试题

可视化演示

展示系统处理流水线、实时性能指标曲线及多方案对比分析，包含数据流转、吞吐延迟监控与方案评估。

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

系统可视化 处理流程：输入→处理→模型→输出 性能监控：实时指标 P=L×T

稀疏化基本概念

仓库管理员走进堆满货物的大仓库，一眼望去全是箱子。可当他仔细清点，发现许多箱子里的货物少得可怜——这些就是大模型里的低权重。权重是模型从数据中学到的“货物价值”，绝对值接近 0 的权重对最终输出几乎无贡献，却在搬运（推理计算）时占据了大量空间和算力。把这类箱子从清单上划掉，就是稀疏化的起点。

在深度学习里，稀疏化（Sparsification）指通过剪枝（Pruning）等手段，将权重矩阵中接近 0 的元素置为 0，使矩阵变得“稀疏”。稀疏度（Sparsity）是衡量稀疏程度的指标，计算公式为：

剪枝的核心思路是“先评估箱子价值，再决定去留”：训练完成后，根据权重绝对值大小排序，把低于阈值的权重置零。对端侧部署来说，稀疏化的意义如同搬家前先扔掉闲置旧物——模型占用的内存变小，搬运（推理）时的计算量也直线下降，让手机、智能家居芯片等小仓库能装下大模型。

搬空仓库前，管理员会给每个箱子贴好价值标签——这正是稀疏化要做的第一件事。只有先把“值得保留的货物”认清楚，后面的账本与搬运路线才有着落。

Sparsity=NzerosNtotal=1−NnonzeroNtotal\text{Sparsity}=\frac{N_{\text{zeros}}}{N_{\text{total}}} \displaystyle=1-\frac{N_{\text{nonzero}}}{N_{\text{total}}}
稀疏度就是仓库里空箱子（零权重）占总箱数的比例。稀疏度越高，说明可以扔掉的空箱越多，后续搬运越省力。
  1. 分子——零元素个数$N_{\text{zeros}}$ 表示权重矩阵中数值为 0 的元素总数，对应仓库中完全无货的箱子数。
    NzerosN_{\text{zeros}}
  2. 分母——总元素个数$N_{\text{total}}$ 是所有权重的数量，代表仓库里所有箱子的总数。
    NtotalN_{\text{total}}
  3. 比值——零元素占比两者相除得到 0 到 1 之间的数值，描述仓库里空箱的比例。
    NzerosNtotal\frac{N_{\text{zeros}}}{N_{\text{total}}}
  4. 等价的补数——非零占比$1-\frac{N_{\text{nonzero}}}{N_{\text{total}}}$ 说明“空箱率”，其中非零元素占比越高，空箱率越低。
    1−NnonzeroNtotal1-\frac{N_{\text{nonzero}}}{N_{\text{total}}}

结构化与非结构化

扔空箱子也有讲究。一种做法是“整齐划一”：每 4 个箱子一组，规定每组只能留 2 个（2:4 结构化稀疏）。这种规律性极强的清理方式叫 N:M 结构化剪枝，硬件设计者最喜欢——因为规则固定，芯片可以用特殊的电路高效跳过被清空的仓位。另一种做法是“哪里有空箱就扔哪里”，完全按箱子实际价值来，不管排列是否齐整，这叫非结构化剪枝。

非结构化剪枝的自由度最高，同等稀疏度下精度损失通常更小，因为保留的都是真正重要的权重。但它也有代价：非零元素分布毫无规律，压缩后的存储和计算都更复杂，传统硬件不便直接加速。结构化剪枝的规律性让硬件可以批量跳过空位，实际加速效果更明显，但约束多了，精度会略受影响。两者对比，像极了“按货架规则整理仓库”与“见缝插针塞货”两种管理哲学。

非结构化稀疏化的压缩率上限通常更高，因为它的剪枝粒度是单个权重，比结构化剪枝更精细：

这就好比收纳爱好者的两条路线：结构化剪枝像用统一规格的收纳盒，空间利用率略低但取放方便；非结构化剪枝像见缝插针地塞满每个角落，空间用到极致，但找东西时要多翻几本账。

压缩率非结构化≈11−Sparsity\text{压缩率}_{非结构化}\approx \frac{1}{1-\text{Sparsity}}
稀疏度 90% 时，非结构化压缩率理论上逼近 10 倍——相当于仓库面积缩小 10 倍。
  1. 1 减去稀疏度——剩余占比$1-\text{Sparsity}$ 是保留的非零比例，比如稀疏度 90% 时剩下 10% 的箱子。
    1−Sparsity1-\text{Sparsity}
  2. 取倒数——面积缩放$\frac{1}{1-\text{Sparsity}}$ 表示仓库可缩小的倍数。剩 10% 的箱子，仓库面积理论上可为原来的 1/10。
    11−Sparsity\frac{1}{1-\text{Sparsity}}
  3. 近似符号——理论极限实际存储还需额外记索引（账本），因此压缩率是近似值，达不到完全 10 倍。
    ≈\approx

CSR/CSC 存储

仓库整理完毕后，管理员面对的核心问题变成：怎么记住剩下的箱子在哪里？如果还是用原来满仓位的图纸标注，等于没有省空间。于是账本技术登场——CSR 与 CSC 是两种经典的稀疏矩阵存储格式。

CSR（Compressed Sparse Row，压缩稀疏行）按行记账：三个数组解决问题。第一个数组叫“行指针”（row_ptr），记录每一行的第一个非零元素在整个“非零值列表”中的起始位置；第二个数组是“列索引”（col_idx），记录每个非零元素在哪一列；第三个数组就是“非零值”（values）本身。想象仓库里每排货架有一个“本排起始货位编号”，每个箱子贴一个“第几列”的标签，值班室再放一张按行排列的货物价值表——取货时顺着编号就能精准定位。

CSC（Compressed Sparse Column）原理一模一样，只是把“行”换成“列”。选择哪种取决于数据访问模式：如果矩阵按行参与计算（如稀疏矩阵乘向量），CSR 更适合；按列访问频繁时用 CSC 更高效。账本虽好，也有额外开销——每存一个非零值，就要随带存一个列索引（或行索引）。但对高稀疏度矩阵，账本的开销远小于省下的空间。

CSR 的总存储量估算如下：

账本的精髓在于：不记录任何空位的信息。只要稀疏度足够高，这份“只记有货位置”的账本就能比原来那幅满仓位的图纸小得多，让仓库（内存）大大瘦身。

MemCSR=2×Nnnz+(R+1)\text{Mem}_{\text{CSR}}= 2 \times N_{\text{nnz}} + (R+1)
存储量等于“非零值 + 列索引 + 行指针”，R 为矩阵行数。账本虽然多记了位置信息，但省掉了所有零元素的空间。
  1. 非零值的存储$N_{\text{nnz}}$ 个非零元素需要一个等长的数组 values 存放。
    NnnzN_{\text{nnz}}
  2. 列索引的成本每个非零值都要配套一个列索引，因此再花一份 $N_{\text{nnz}}$ 的存储。
    NnnzN_{\text{nnz}}
  3. 行指针的成本每行一个起始偏移记录，共 $R+1$ 个元素（多出的 1 是末尾哨兵，标记结束位置）。
    R+1R+1
  4. 总存储量三者相加，得到 CSR 账本的总大小。
    2×Nnnz+(R+1)2 \times N_{\text{nnz}} + (R+1)

稀疏矩阵乘法原理

有了账本，搬运工该怎么干活？稠密矩阵乘法要求对每一对元素都做一次乘加操作，如同搬运工经过每个仓位都停下来检查一遍。稀疏矩阵乘法则依据账本，只对非零元素做运算——从 A 的第 i 行取一个非零值 $A[i][k]$，从 B 的第 k 列取一个非零值 $B[k][j]$，两者相乘累加到结果矩阵 $C[i][j]$。

稀疏矩阵乘法的基本公式与稠密乘法相同，但执行顺序完全不同：

稀疏感知调度进一步优化了执行顺序：把 A 的每一行与 B 的对应列的非零元素匹配起来，只对“两边都有货”的组合进行乘加。累加器被长期复用，避免重复初始化；按账本顺序访问内存，让数据在缓存中更有连续性。这就像老练的搬运工同时拿着两张货单，先找两边都有货的组合再动手，而不是盲目地往每个货位跑。

稀疏矩阵乘法的惊人之处在于：搬运工看一眼账本，就知道哪些货位压根不用去——计算量只剩原来的“非零比例”。这也是非结构化稀疏化能加速大模型推理的根本原因。

C[i][j]=∑kA[i][k]⋅B[k][j]（仅对非零乘积项累加）C[i][j] = \sum_{k} A[i][k] \cdot B[k][j]\quad \text{（仅对非零乘积项累加）}
不是所有 k 都参与计算——账本上不存在的 k 直接跳过。搬运工只挑两边都有货的组合搬，空仓对空仓直接略过。
  1. 结果矩阵的定位$C[i][j]$ 是第 i 行第 j 列的结果值，对应仓库中一个目标货位的最终堆积量。
    C[i][j]C[i][j]
  2. 求和范围$\sum_{k}$ 表示对所有可能的中间位置 k 求和，但在稀疏矩阵里 k 只取有货的列。
    ∑k\sum_{k}
  3. 乘加运算$A[i][k] \cdot B[k][j]$ 是“取 A 的第 i 行、第 k 列的值，乘以 B 的第 k 行、第 j 列的值”。如果 A 在 (i,k) 或 B 在 (k,j) 处是空箱，该乘积为 0，整体跳过。
    A[i][k]⋅B[k][j]A[i][k] \cdot B[k][j]

端侧加速实现

手机芯片的仓库比云端服务器小得多，算力、内存、带宽全都受限。这时稀疏化的价值彻底体现：模型变成稀疏矩阵后，内存占用下降，但要想真正跑得快，还要靠底层硬件的配合。

ARM 架构的移动芯片普遍支持 NEON 向量指令，它像一架能同时搬运 4 或 8 只箱子的叉车。稀疏矩阵算子设计时，把同一行的连续非零元素装进 NEON 寄存器，一次性与对应的右矩阵元素乘加。算子融合技术则把相邻的多个操作合并成一次搬运——比如把“乘加”与“激活函数”直接拼在一起，减少中间结果的读写。缓存友好设计让非零元素按内存顺序紧凑放置，使叉车能“一路顺路多搬”，而不是东奔西跑。

稀疏化与量化是一对天然搭档。量化（如 INT8）把每个权重从 32 位浮点压成 8 位整数，如同把每只箱子换成更小的集装箱。两者叠加后，仓库面积急剧缩小，搬运速度进一步加快。移动端推理引擎（如 MNN、TFLite、CoreML）专门实现了稀疏算子，对稀疏度在 50% 以上的模型提供显著加速。

端侧加速的核心思路可以用一句话概括：少搬运，多复用。NEON 指令负责“多箱并搬”，算子融合负责“减少空跑”，量化负责“箱子变小”。三者协同作用的结果是——大模型在手机上也能以实时速度运行。

工程部署实践

理论清楚了，怎么在实际项目中落地？仓库整理从来不是一次性的工作，而是一套循环流程。

第一步是剪枝训练。常用方法是“训练—剪枝—微调”三步循环：先在完整模型上训练，让模型学到“哪些货重要”；然后根据权重绝对值等指标做非结构化剪枝，把不重要的权重置零；最后在稀疏模型上继续训练（微调），让剩余的权重重新适应并恢复精度。这种迭代式剪枝可以逐轮提高稀疏度，避免一次性剪枝导致的精度断崖下降。

第二步是考虑“什么时候剪”：训练前剪枝（从头训练稀疏模型）、训练后剪枝（先训好再剪）、动态剪枝（训练中周期性地剪）各有适用场景。对端侧部署来说，训练后剪枝最省事，但精度损失较大；迭代剪枝效果最好，但工程成本高。

第三步是接入推理引擎。MindSpore Lite、ONNX Runtime 等框架都提供了稀疏模型算子，部署时只需把剪枝后的权重转成稀疏格式（如 CSR），再调用稀疏算子推理。调参经验上，稀疏度 50%-70% 是非结构化剪枝的甜区：精度损失小、加速收益明显；超过 90% 后精度可能急剧下滑，需要更精细的微调和学习率调度。

整个工程流程，就像管理一处要长期维持的仓库：先全面盘点货物价值（训练），再分轮次清理空箱（迭代剪枝），每轮清理后都要重新码放货物并培训搬运工（微调），最后用标准化的账本（CSR 格式）和高效叉车（稀疏算子）把搬运效率提上去。

效果评估与趋势

仓库整理的效果，最终要拿数据说话。评估稀疏化方案通常关注三个指标：压缩率（模型尺寸减小比例）、实测加速比（真实设备上的推理延迟降低倍数）、精度损失（与原始模型的准确率差距）。

压缩率与加速比并不总成正比。压缩率取决于存储格式的理论极限，而实测加速还受硬件的稀疏支持程度、算子实现质量、缓存命中率等因素影响。有些情况下模型减小 70%，端侧推理速度却只提升 1.5 倍——因为非结构化稀疏矩阵在通用处理器上仍要花额外时间查找非零位置。这提醒工程师：选不选稀疏化、选什么稀疏度，都要在真实设备上实测。

精度与稀疏度的关系中存在一个“拐点”：稀疏度较低时精度几乎无损，超过某一阈值后精度迅速下降。找到这个拐点，是模型压缩工程师的核心技能。硬件趋势上看，新一代 AI 芯片（如 NVIDIA Ampere 之后的架构）已经内置稀疏计算单元，可直接跳过零值计算；移动端芯片也逐步加入类似的稀疏支持。这意味着非结构化稀疏化的“加速红利”将越来越大。

从当前生态看，非结构化稀疏化与 Sparse Matrix 加速是端侧大模型落地的关键拼图。它没有魔法，本质是用“整理+记账”的工程方法换取了存储和计算的效率。随着硬件跟进和工具链成熟，稀疏化将像今天的量化一样，成为大多数 AI 工程师的标配技能——而你已经理解了它最核心的直觉与原理。

AI 应用场景

手机端的大语言模型推理加速

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

解决的问题：大语言模型动辄数十亿参数，直接部署在手机内存和算力都吃不消。传统做法是直接截断或降低精度，但精度损失明显。非结构化稀疏化将权重矩阵中大量低价值权重清零，配合 CSR 存储将模型压缩 3-5 倍，再结合 INT8 量化，让 7B 模型在旗舰手机上以可交互速度运行。

具体案例：某团队在手机端部署 7B 对话模型时，先做 70% 稀疏度的迭代剪枝，再用 LoRA 微调恢复精度，最后转成稀疏 INT8 格式接入 MNN 引擎。实测内存占用从 14GB 降至 3.8GB，首 token 延迟从 3 秒降至 0.8 秒。

边缘设备的视觉模型压缩

阶段：模型轻量化

解决的问题：工业质检摄像头、智能门锁等边缘设备的芯片算力远逊于手机，且对实时性要求极高。稀疏化通过裁剪 CNN 中冗余卷积核的权重，使每帧推理计算量大幅降低，让模型在低功耗 MCU 上也能跑出每秒 30 帧的检测速度。

具体案例：某智能安防方案在摄像头端部署 YOLOv5s 做人脸检测，对卷积层做 60% 非结构化剪枝后，再联合 INT8 量化，模型从 14MB 减至 4.2MB，检测帧率从 18 FPS 提升到 32 FPS，精度仅下降 0.7%。

Python 演示

python73 行
"""稀疏矩阵乘法演示：CSR 格式存储与稀疏乘法通过计算量对比展示稀疏加速的基本原理。"""import random  def build_sparse_matrix(rows, cols, sparsity, seed=42):    """生成稀疏矩阵，返回 dense 表示和 CSR 格式"""    random.seed(seed)    dense = []    for _ in range(rows):        row = []        for _ in range(cols):            if random.random() < sparsity:                row.append(0.0)            else:                row.append(round(random.uniform(0.1, 1.0), 2))        dense.append(row)    # 转 CSR    values, col_idx, row_ptr = [], [], [0]    for r in range(rows):        for c in range(cols):            if abs(dense[r][c]) > 1e-6:                values.append(dense[r][c])                col_idx.append(c)        row_ptr.append(len(values))    return dense, (values, col_idx, row_ptr)  def dense_mul(A, B):    """稠密矩阵乘法：所有元素参与计算"""    rows, K, cols = len(A), len(A[0]), len(B[0])    C = [[0.0 for _ in range(cols)] for _ in range(rows)]    ops = 0    for i in range(rows):        for j in range(cols):            for k in range(K):                C[i][j] += A[i][k] * B[k][j]                ops += 1    return C, ops  def csr_mul(A_csr, B, rows, K, cols):    """CSR 稀疏矩阵乘法：只对有非零值的行做运算"""    values, col_idx, row_ptr = A_csr    C = [[0.0 for _ in range(cols)] for _ in range(rows)]    ops = 0    for i in range(rows):        for ptr in range(row_ptr[i], row_ptr[i + 1]):            k = col_idx[ptr]            a_val = values[ptr]            for j in range(cols):                C[i][j] += a_val * B[k][j]                ops += 1    return C, ops  def main():    rows, K, cols = 64, 64, 32    sparsity = 0.9  # 90% 稀疏度    A_dense, A_csr = build_sparse_matrix(rows, K, sparsity)    B_dense, _ = build_sparse_matrix(K, cols, 0.0, seed=7)    _, ops_dense = dense_mul(A_dense, B_dense)    _, ops_sparse = csr_mul(A_csr, B_dense, rows, K, cols)    print("稠密乘法乘加次数:", ops_dense)    print("稀疏乘法乘加次数:", ops_sparse)    print("计算量节省比例: {:.1f}%".format(        (1 - ops_sparse / ops_dense) * 100))  if __name__ == "__main__":    main()
目的：用纯 Python 实现 CSR 稀疏格式的矩阵乘法，定量比较稠密乘法与稀疏乘法的计算量差异，演示稀疏化带来的加速原理。
  1. dense, (values, col_idx, row_ptr) = build_sparse_matrix(rows, cols, sparsity)生成稠密矩阵并同时转成 CSR 账本格式：values 装非零值，col_idx 记录列位置，row_ptr 记录每行起始偏移。
  2. if abs(dense[r][c]) > 1e-6:稀疏化判断：绝对值接近 0 的权重视为“空箱”，不写入账本。
  3. C[i][j] += A[i][k] * B[k][j]稠密乘法每一个 k 都参与计算，对应搬运工检查每个仓位。
  4. for ptr in range(row_ptr[i], row_ptr[i + 1]):只用行指针区间定位第 i 行的非零元素，跳过零元。
  5. ops += 1统计乘加次数，用于对比两种方式的计算量。
  6. (1 - ops_sparse / ops_dense) * 100计算量节省比例，90% 稀疏度下可节省约 90% 的乘加操作。

常见误区

误区做过稀疏化后，保存的模型文件一定会立刻变小很多，可以直接用更小的存储空间部署。

正解稀疏化只把权重置零，如果保存格式仍是稠密矩阵，文件大小几乎不变。必须配合 CSR/CSC 等稀疏存储格式，才能真正压缩文件体积。仓库里虽然空箱很多，但如果还用原来的图纸记录每个仓位，图纸不会变小。

为何常见：人们容易把“稀疏化”与“压缩”直接等同起来，忽略了存储格式这一关键中间步骤。

误区只要矩阵是稀疏的，推理速度就一定能比原来快好几倍。

正解理论计算量确实减少了，但实际速度取决于硬件是否支持稀疏计算、算子实现是否高效、稀疏度是否足够高。在普通 CPU 上跑非结构化稀疏矩阵，查找索引本身就有额外开销，可能比稠密乘法还慢。没配叉车的仓库，光有账本也快不起来。

为何常见：人们从“计算量减少”直接外推“时间加快”，忽略了硬件访存和调度开销。

误区稀疏度越高，模型越小、推理越快，所以应该尽量追求 95% 以上的稀疏度。

正解稀疏度过高时，剩余权重无法承载原始知识，精度会急剧下降；而且过高的稀疏度会让非零元素分布更零散，索引开销占比增大，边际收益递减。选择合适的稀疏度（通常在 50%-80%）需要在精度和效率之间找平衡。

为何常见：工程师看到稀疏度与计算量线性相关，容易忽视精度拐点和实际加速比的非线性特征。

误区非结构化剪枝比结构化剪枝精度好，所以可以大胆剪，基本不损失精度。

正解非结构化剪枝的修剪粒度细，同等稀疏度下精度确实优于结构化剪枝，但并非无损失。剪掉任何权重都会对输出产生扰动，只是程度不同；必须通过微调把精度拉回来，直接剪完不微调仍然会明显掉点。

为何常见：“非结构化=自由度高=精度好”的直观印象让人忽略了剪枝本身的破坏性。

面试题

Q1. 稀疏度（Sparsity）的定义是什么？

单选题 · easy

  • A.矩阵中非零元素的数量
  • B.矩阵中零元素占总元素的比例← 正确答案
  • C.模型中权重值的绝对值总和
  • D.矩阵压缩前后的存储空间比值

答案：B。稀疏度 = 零元素个数 ÷ 总元素个数，反映仓库里空箱的比例。A 描述的是非零元个数，C 与稀疏无关，D 是压缩率的概念。

Q2. CSR 格式中三个核心数组分别是什么？

单选题 · mid

  • A.非零值、列索引、行指针← 正确答案
  • B.零值、行索引、列指针
  • C.权重、偏置、梯度
  • D.行号、列号、矩阵维度

答案：A。CSR 用 values（非零值）、col_idx（列索引）、row_ptr（行指针）三个数组记账。B 的“零值”和“列指针”说法错误，C 是神经网络的参数概念，D 缺少实际存储数据。

Q3. 非结构化稀疏化相比结构化稀疏化的主要优势是什么？

单选题 · mid

  • A.硬件加速更容易实现
  • B.剪枝粒度更细，精度保持更好← 正确答案
  • C.不需要重新训练模型
  • D.存储格式永远比 CSR 简单

答案：B。非结构化剪枝逐权重判断，自由度更高，同等稀疏度下保留的都是真正重要的权重，精度更好。A 是结构化剪枝的优势，C 说法错误，D 存储格式与是否结构化无关。

Q4. 稀疏矩阵乘法的核心优化思想是什么？

单选题 · mid

  • A.对所有 k 求和但忽略精度
  • B.只对非零乘积项做乘加累加← 正确答案
  • C.把稠密矩阵转为高精度浮点
  • D.将矩阵乘法转换为加法运算

答案：B。稀疏矩阵乘法依据账本（CSR/CSC）确定非零位置，跳过零元计算，只对两边都有货的组合做乘加。A 忽略了零元，C 与稀疏无关，D 说法不正确。

Q5. 关于 N:M 结构化剪枝，下列说法正确的是？

单选题 · hard

  • A.任意选择 N 个权重保留，M 个清零
  • B.每组 M 个权重中保留 N 个，硬件规整← 正确答案
  • C.只保留模型最后的 N 层、剪掉 M 层
  • D.要求稀疏度恰好等于 N 除以 M 的平方

答案：B。N:M 结构化剪枝将权重分组，每组 M 个权重中保留最重要的 N 个（如 2:4），规则固定让硬件可以批量跳过空位。A 忽略了分组规则，C 是剪层概念，D 稀疏度公式错误。

Q6. 以下哪些手段可以协同稀疏化提升端侧推理速度？

多选题 · mid

  • A.INT8 量化让每个权重占用更少位数← 正确答案
  • B.ARM NEON 向量指令批量搬运非零数据← 正确答案
  • C.算子融合减少中间结果的读写← 正确答案
  • D.增加模型层数以提升表达力

答案：ABC。稀疏化、量化、向量指令、算子融合是端侧加速的四个协同手段。D 增加层数只会加大计算量，与加速背道而驰。

Q7. 剪枝—微调循环中“微调”的作用是什么？

单选题 · easy

  • A.让稀疏模型权重重新适应数据，恢复精度← 正确答案
  • B.把稀疏矩阵转为稠密矩阵
  • C.将浮点模型转换为整数模型
  • D.增加新的训练数据总量

答案：A。剪枝置零权重会扰动输出，微调让剩余非零权重继续学习，补偿被剪掉的信息。B 是存储格式转换，C 是量化，D 与微调对权重的调整不同。

Q8. 关于 CSR 存储的索引开销，说法正确的有？

多选题 · hard

  • A.每个非零值需要配套一个列索引← 正确答案
  • B.行指针数组长度等于矩阵行数加一← 正确答案
  • C.稀疏度越高，索引开销占比越小
  • D.CSR 不需要存储任何行号信息

答案：AB。CSR 存 value+col_idx+row_ptr，每个非零值配一个列索引，row_ptr 长度是行数+1（末尾哨兵）。C 错误：稀疏度越高非零元越少，索引占比反而可能上升。D 错误：行指针隐含了行号信息，所以不需要显式行号，但 row_ptr 本身是行位置索引，需结合 C 判断。

Q9. 90% 稀疏度、非结构化剪枝的模型，理论压缩率约为多少？

单选题 · hard

  • A.1.1 倍
  • B.90 倍
  • C.10 倍← 正确答案
  • D.9 倍

答案：C。理论压缩率 = 1/(1-稀疏度) = 1/0.1 = 10 倍。A 接近零压缩，B 与公式相悖，D 忽略了 10 倍的计算依据（剩余 10% 非零）。

Q10. 以下哪些属于非结构化稀疏化的应用场景？

多选题 · easy

  • A.手机端大语言模型的推理加速← 正确答案
  • B.边缘摄像头视觉模型的轻量化← 正确答案
  • C.云端训练超大模型的分布式并行
  • D.智能穿戴低功耗芯片的模型部署← 正确答案

答案：ABD。非结构化稀疏化主要服务于端侧、边缘等资源受限设备的模型压缩部署。A、B、D 都是典型端侧场景。C 的分布式训练关注的是并行通信开销，与稀疏部署无关。