EE6316 Integrated Circuits for AI 中文复习笔记（持续更新）

EE6316 Integrated Circuits for AI 课程复习笔记

第一章：AI 芯片为什么必须重新设计？

Week 1 · Motivation & Fundamentals

如果只记住这一章的一句话，应该是：

神经网络需要大量乘加，但现代 AI 芯片真正昂贵的部分，往往不是“算”，而是把权重和中间数据搬到计算单元。

这句话把本章所有内容串在了一起。GPU、TPU、量化、稀疏、脉动阵列、计算存内和神经形态计算，看起来是不同技术，实际都在回答同一个问题：怎样用更少的数据移动，完成更多有效计算？

本章先建立直觉，再完成四道计算题。第一次阅读建议顺着正文走；考前复习时，可以直接跳到末尾的“本章复习页”。

1. 从一次乘加开始理解 AI 芯片

神经网络中的一个人工神经元，可以写成：

\[\begin{aligned} u &= \sum_i w_i x_i + b, \\ y &= \phi(u). \end{aligned}\]

这里有两类性质不同的数据。\(w_i\) 和偏置 \(b\) 是训练得到的模型参数；推理时它们通常保持不变。\(x_i\) 是当前样本送入神经元的输入，也称为 activation（激活值）；它会随着样本和网络层而变化。神经元先得到加权和 \(u\)，再由 \(\phi\)（例如 ReLU）引入非线性，产生输出激活值 \(y\)。

每一项 \(w_ix_i\) 都要先相乘，再加到正在累积的部分和中。这种“乘一次、加一次”的基本操作称为 MAC（multiply-accumulate，乘加）。一个神经元需要一串 MAC；一整层神经网络要计算许多这样的加权和，因此可以整理成向量–矩阵乘法，即 VMM（vector-matrix multiplication）。

需要留意性能口径：有些资料把一次 MAC 计为 1 次 operation，有些把“乘”和“加”分别计算而记为 2 次。比较 TOP/s 时必须确认双方使用同一种计数方式。

这类计算有两个特点：

1. 运算量很大，但形式非常规则；
2. 同一批权重和激活会被反复读取。

规则性让并行计算成为可能，反复读取则带来了本章最重要的瓶颈——数据移动。设计 AI 芯片时，不能只问“乘法器有多快”，还要问：

• 权重存在哪里？
• 每个权重会被搬运几次？
• 数据从片外 DRAM 到片上计算单元，需要多少时间和能量？

接下来所有硬件指标与架构设计，都是对这三个问题的进一步回答。

2. 快、耗电和高效，是三件不同的事

数据中心和边缘设备都需要 AI 算力，但约束完全不同。数据中心主要受供电、散热和部署成本限制；智能眼镜、手机、无人机等边缘设备还受电池、体积和温升限制。

例如，自动驾驶系统可能需要约 60 TOP/s，同时允许几十瓦的功耗；智能眼镜的计算需求可能只有约 2.7 TOP/s，功耗预算却可能只有 0.1 W。后者的绝对算力较小，但要求的能效高达：

\[\eta = \frac{2.7\ \mathrm{TOP/s}}{0.1\ \mathrm{W}} = 27\ \mathrm{TOP/s/W}\]

所以，计算量较小不代表硬件更容易设计；功耗预算越紧，能效要求反而越高。

三个最容易混淆的指标

三者之间只有一组核心关系：

\[\eta=\frac{R}{P} \qquad\Longleftrightarrow\qquad P=\frac{R}{\eta} \qquad\Longleftrightarrow\qquad R=\eta P\]

\(T\)（tera）表示 10¹²。TOP/s 泛指每秒万亿次操作，TFLOP/s 特指每秒万亿次浮点操作；只有运算定义相同，两个数值才适合直接比较。

一个常见误区是把高吞吐率等同于高能效。多放几张相同 GPU，确实能提高总吞吐率，但总功耗也会近似按相同比例增长，所以系统能效不会自动改善。

为什么课程用人脑作为参照？

人脑可以在很低功耗下完成感知、决策和学习，因此经常被用来建立能效的数量级直觉。

若取每日能量消耗约 516 kcal：

\[\begin{aligned} E &= 516\ \mathrm{kcal}\times 4184\ \mathrm{J/kcal} \\ &= 2{,}158{,}944\ \mathrm{J}, \\ P &= \frac{E}{86{,}400\ \mathrm{s}} \\ &\approx 24.99\ \mathrm{W}\approx 25\ \mathrm{W}. \end{aligned}\]

再把脑的计算规模粗略估成 10¹⁸ ops/s，也就是 10⁶ TOP/s，则估算能效为：

\[\eta_{\mathrm{brain}} \approx \frac{10^6\ \mathrm{TOP/s}}{25\ \mathrm{W}} \approx 40{,}000\ \mathrm{TOP/s/W}\]

图 1　横轴是吞吐率，纵轴是每瓦吞吐率，两轴都是对数坐标。越向右表示越快，越向上表示越省电，因此右上角才是理想方向。脑的估算点位于右上方；ReRAM 计算存内芯片的能效明显高于常规 GPU/ASIC，但仍与脑的估算值存在差距。

口径提醒：生物神经事件并不等于数字芯片上的浮点运算。这组数字适合训练数量级估算，不是严格的跨系统性能排名。

练习 1.1：堆多少张 V100 才能达到脑的估算吞吐率？

题目
NVIDIA V100 GPU 在 FP16 模式下的吞吐率为 125 TFLOP/s，能效为 0.357 TFLOP/s/W。人脑的估算吞吐率约为 10⁶ TFLOP/s（10¹⁸ ops/s），功耗约为 25 W。假设可以把多张 V100 理想地并行运行，仅靠增加 V100 数量来达到人脑的绝对吞吐率：
（a）需要多少张 V100？
（b）每张 V100 的功耗是多少？
（c）整个集群的总功耗是多少？它是人脑 25 W 功耗的多少倍？

先用目标吞吐率除以单卡吞吐率：

\[N=\frac{10^6}{125}=8{,}000\ \text{张}\]

再由 \(P=R/\eta\) 求单卡功耗：

\[P_{\mathrm{card}}=\frac{125}{0.357}\approx 350\ \mathrm{W}\]

因此集群总功耗为：

\[\begin{aligned} P_{\mathrm{total}} &=8{,}000\times350\ \mathrm{W} \\ &=2.8\times10^6\ \mathrm{W} \\ &=2.8\ \mathrm{MW}. \end{aligned}\]

与人脑的 25 W 相比：

\[\frac{2.8\times10^6\ \mathrm{W}}{25\ \mathrm{W}}=112{,}000\]

最终需要约 8,000 张 V100、2.8 MW 功耗，是脑估算功耗的 112,000 倍。

这个例子说明：吞吐率可以靠堆芯片扩展，能效不能。 也可以直接用系统能效校验：相同 GPU 理想并联后，能效仍是 0.357 TFLOP/s/W，因此 10⁶÷0.357≈2.8 MW，结果一致。

练习 1.2：ReRAM CIM 比常规 ASIC 接近脑多少？

题目
人脑的估算能效为 40,000 TFLOP/s/W；常规 ASIC TPUv7（2025）的能效为 4.8 TFLOP/s/W；ReRAM CIM（2023，计算存内研究芯片）的能效为 1,286.4 TFLOP/s/W。
（a）ReRAM CIM 的能效距离人脑还差多少倍？
（b）TPUv7 的能效距离人脑还差多少倍？与 TPUv7 相比，ReRAM CIM 在能效上接近人脑多少倍？

分别计算它们与脑的差距：

\[\begin{aligned} \frac{\eta_{\mathrm{brain}}}{\eta_{\mathrm{ReRAM}}} &=\frac{40{,}000}{1{,}286.4}\approx31, \\ \frac{\eta_{\mathrm{brain}}}{\eta_{\mathrm{TPUv7}}} &=\frac{40{,}000}{4.8}\approx8{,}333. \end{aligned}\]

ReRAM 仍比脑的估算能效低约 31 倍，TPUv7 则低约 8,333 倍。再比较两款芯片：

\[\frac{\eta_{\mathrm{ReRAM}}}{\eta_{\mathrm{TPUv7}}} =\frac{1{,}286.4}{4.8}=268\approx270\]

因此，ReRAM CIM 在本题数据下比 TPUv7 接近脑级能效约 270 倍。写成 268 或约 270 都可以，差异只来自四舍五入。

3. 真正的瓶颈：模型在增长，数据却搬不动

AI 芯片并不是把所有数据都放在计算单元旁边。现代加速器通常有一套从“小而快”到“大而慢”的存储层次：

这里说 DRAM “更远”，不仅指物理距离，还指一次访问要经过更长的连线、接口和控制路径。模型越大，越难把所有权重留在片上，数据就越需要在这些层级之间往返。

图 2　紫色曲线表示模型参数量，青色曲线表示单个加速器能够承载的存储规模。两条曲线间不断扩大的区域，代表模型的数据需求与单卡容量、供给能力之间的缺口。

只考虑权重本体时，模型需要的存储量很容易估算。为避免与前文的偏置 \(b\) 混淆，这里用 \(b_w\) 表示“每个权重占多少 bit”：

\[M_{\mathrm{weight}} =N_{\mathrm{param}}\times\frac{b_w}{8}\ \mathrm{Byte}\]

其中，\(N_{\mathrm{param}}\) 是权重数量，除以 8 是把 bit 换成 Byte。例如 FP32 的 \(b_w=32\)，INT8 的 \(b_w=8\)。

以 70 亿参数模型为例：

\[\begin{aligned} M_{\mathrm{FP32}}&=7\times10^9\times\frac{32}{8}\ \mathrm{Byte}\approx28\ \mathrm{GB},\\ M_{\mathrm{INT8}}&=7\times10^9\times\frac{8}{8}\ \mathrm{Byte}\approx7\ \mathrm{GB}. \end{aligned}\]

这里，FP32 表示每个数占 32 bit，INT8 表示每个数占 8 bit。真实运行还需要激活、运行时缓冲区，以及 Transformer 的 KV cache；训练时还要存梯度和优化器状态。因此 28 GB 和 7 GB 只是权重本体，不是完整显存需求。

内存墙不只是一面“容量墙”

Memory wall（内存墙）至少包含三种限制：

• 容量：模型和中间状态放不下；
• 带宽：单位时间内送不到足够多的数据；
• 能耗：数据能够送到，但搬运本身过于耗电。

以一个 10B 参数、FP32 权重的模型为例，仅权重就有：

\[10^{10}\times4\ \mathrm{Byte}=40\ \mathrm{GB}\]

如果每生成一个 token 都要读取一次全部权重，而内存带宽是 1 TB/s≈1000 GB/s，那么仅由带宽决定的理想上限是：

\[r_{\mathrm{token}} \leq\frac{1000\ \mathrm{GB/s}}{40\ \mathrm{GB/token}} =25\ \mathrm{token/s}\]

这个估算还没有计入 KV cache、激活和带宽利用率损失。它揭示了一个反直觉现象：即使继续增加乘法器，实际速度也可能不再提高，因为乘法器大部分时间都在等数据。

图 3　计算与存储在冯·诺依曼体系中物理分离。数据从寄存器、片上 SRAM/Cache 到片外 DRAM，移动距离越远，通常延迟越高、能耗也越大。

数据移动究竟贵多少？

下面是一组用于建立数量级直觉的参考能耗。pJ 是皮焦耳，1 pJ=10⁻¹² J。

于是：

\[\begin{aligned} \frac{E_{\mathrm{DRAM}}}{E_{\mathrm{SRAM}}}&=\frac{640}{5}=128,\\ \frac{E_{\mathrm{DRAM}}}{E_{\mathrm{mul}}}&=\frac{640}{3.1}\approx206. \end{aligned}\]

一次片外 DRAM 读取的参考能耗，约为一次 32-bit 整数乘法的 206 倍。这就是“数据移动比计算贵”的定量依据。

练习 1.3：1000 个权重的能量花在哪里？

题目
某神经网络层有 1000 个权重，每个权重都需要从 DRAM 读取一次，并参与一次 32-bit 整数乘法。已知一次 32-bit 整数乘法消耗 3.1 pJ，一次 32-bit DRAM 读取消耗 640 pJ。
（a）1000 次乘法共消耗多少能量？
（b）读取 1000 个权重共消耗多少能量？
（c）数据读取能耗是乘法能耗的多少倍？
（d）若只考虑这两项，数据移动和计算分别占总能耗的百分之多少？

\[\begin{aligned} E_{\mathrm{mul}}&=1000\times3.1\ \mathrm{pJ}=3{,}100\ \mathrm{pJ},\\ E_{\mathrm{read}}&=1000\times640\ \mathrm{pJ}=640{,}000\ \mathrm{pJ}. \end{aligned}\]

两者之比为：

\[\frac{640{,}000}{3{,}100}\approx206\]

数据移动在两项总能耗中的占比为：

\[\frac{640{,}000}{640{,}000+3{,}100}\times100\%\approx99.52\%\]

若再计入 1000 次、每次 0.1 pJ 的 32-bit 整数加法，1000 次 MAC 的算术能耗变为 3,100+100=3,200 pJ；连同 DRAM 读取后的总能耗是 643,200 pJ，其中数据移动仍占约 99.50%。这里的 3,200 pJ 不是“含访存的总能耗”。

所以，在这组假设下，把乘法器能耗减半对总能耗帮助很小；少做一次 DRAM 访问，收益反而可能更大。当然，如果权重能够被缓存并反复复用，DRAM 占比就会下降。计算时必须先写清数据从哪里读取、读取几次。

4. AI 硬件的解法：少搬、少存，或者原地算

面对内存墙，硬件设计并不是只有一种答案。可以把主要方案按激进程度分成三层。

第一层：让数据留得更久

Cache、scratchpad 和定制 dataflow 的目标，是把高复用数据留在片上。脉动阵列（systolic array）则让数据在相邻的处理单元 PE 之间流动，而不是每次计算后都写回全局存储。

这类方法不改变神经网络的数学结果，只改变数据何时移动、移动到哪里。其核心收益来自复用：一个权重只从 DRAM 取一次，却能参与多次 MAC。

第二层：减少必须移动的数据

量化（quantization）降低每个数的位宽。例如从 FP32 变成 INT8，权重本体缩小为原来的 1/4。在访存主导、并假设传输能耗近似随 bit 数缩放的题目中，能耗也可能接近下降 75%。实际系统还要付出缩放参数、量化/反量化、异常值处理和精度损失等代价。

稀疏（sparsity）则减少真正需要处理的非零数。若权重密度为 \(d_w\)、激活密度为 \(d_a\)，并近似认为二者独立，则：

\[\begin{aligned} f_{\mathrm{effective}}&=d_wd_a,\\ f_{\mathrm{skipped}}&=1-d_wd_a. \end{aligned}\]

若权重和激活密度都是 50%，有效 MAC 只有 0.5×0.5=25%，理论上 75% 可以跳过。

但零值不会自动带来加速。若硬件仍按稠密格式读取并执行，零也会照常消耗带宽和计算。真正的稀疏加速需要索引编码、跳过机制和负载均衡。结构化稀疏更容易利用，例如 2:4 稀疏表示每连续 4 个值中只有 2 个非零。

可以这样区分二者：

量化减少每个数的 bit；稀疏减少必须移动和计算的数。

第三层：把计算搬到数据旁边

计算存内（CIM, compute-in-memory）不再把权重不断搬出存储阵列，而是在阵列内部或附近完成运算。ReRAM（resistive random-access memory，阻变存储器）可以用器件的不同电阻状态保存权重；写成电导 \(G=1/R\) 后，器件还能通过电压—电流关系直接参与乘法。把许多 ReRAM 单元排成阵列，就有机会同时完成大量乘加。

这条路线最有可能大幅减少权重搬运，但也更依赖器件特性、转换电路、精度控制和校准。后文会专门解释其工作方式。

为什么必须做软硬件协同设计？

一项算法优化只有被硬件识别和利用，才会转化成真实收益；一项硬件能力也需要编译器和软件栈把模型正确映射上去。这个共同设计过程称为 codesign（协同设计）。

• GPU 提供大规模并行硬件，CUDA 提供可编程接口和软件生态；
• TPU 用脉动阵列、定制数据流和存储层次提高数据复用；
• 结构化稀疏让算法产生硬件容易跳过的零值模式；
• LLM 加速器则需要共同处理带宽、KV cache、低比特量化和异常值问题。

评价一个方案时，不能只看峰值 TOP/s，还要同时看三个维度：能效是否高、灵活性是否足以支持不同模型、可扩展性是否能够跨芯片和系统增长。ASIC 往往更高效但灵活性较低，GPU 更灵活却要承担通用控制开销，这些都是设计权衡。

5. 把 pJ 推到 W：量化为什么能显著降低 LLM 功耗？

前面比较的是单次操作能量。要得到整台加速器的平均功耗，需要先算每个 token 的能量，再乘生成速度。

练习 1.4：10B 模型的简化功耗估算

已知条件：

• 模型有 100 亿，也就是 10¹⁰ 个权重；
• 每生成一个 token，每个权重从 DRAM 读取一次并完成一次 MAC；
• 生成速度为 20 token/s；
• 32-bit 基线：DRAM 读取 640 pJ、乘法 3.1 pJ、加法 0.1 pJ；
• INT8：DRAM 读取 160 pJ、乘法 0.2 pJ、加法 0.03 pJ。

题目
（a）使用 32-bit 数据时，每生成一个 token 共消耗多少能量？
（b）以 20 token/s 运行时，平均功耗是多少？
（c）该功耗是人脑 25 W 功耗的多少倍？
（d）使用 INT8 重做（a）和（b），求新的每 token 能量、平均功耗，以及相对 32-bit 基线的功耗降低百分比。

先算 32-bit 基线。每处理一个权重需要：

\[E_{\mathrm{weight,32}}=640+3.1+0.1=643.2\ \mathrm{pJ}\]

每个 token 要处理 10¹⁰ 个权重：

\[\begin{aligned} E_{\mathrm{token}} &=643.2\ \mathrm{pJ}\times10^{10}\\ &=643.2\times10^{-12}\times10^{10}\ \mathrm{J}\\ &=6.432\ \mathrm{J/token}. \end{aligned}\]

再乘生成速度：

\[\begin{aligned} P&=6.432\ \mathrm{J/token}\times20\ \mathrm{token/s}\\ &=128.64\ \mathrm{J/s}\\ &\approx129\ \mathrm{W}. \end{aligned}\]

与 25 W 的脑功耗参照相比，约为 128.64÷25≈5.15 倍。

INT8 的步骤完全相同：

\[\begin{aligned} E_{\mathrm{weight,INT8}} &=160+0.2+0.03=160.23\ \mathrm{pJ},\\ E_{\mathrm{token,INT8}} &=160.23\ \mathrm{pJ}\times10^{10}=1.6023\ \mathrm{J/token},\\ P_{\mathrm{INT8}} &=1.6023\times20\approx32.05\ \mathrm{W}. \end{aligned}\]

功耗降低比例为：

\[\frac{128.64-32.05}{128.64}\times100\%\approx75.1\%\]

结果恰好接近 75%，是因为本题由 DRAM 能耗主导，而从 32 bit 降到 8 bit，传输位数正好缩小到 1/4。

不要误读这个结果：129 W 不是所有 10B 模型的实测功耗。它来自“每个 token 完整读取一次权重、忽略缓存和其他系统开销”的简化模型。考试重点是掌握 pJ/weight → J/token → W 的单位链条。

6. 进一步的路线：让电路物理直接完成乘加

数字加速器仍然需要明确执行乘法和加法。神经形态与模拟/混合信号计算尝试更进一步：让电导、电压和电流的物理关系直接表示计算。

从人工神经元到电路

图 4　左侧是生物神经元，右侧是对应的人工模型。输入 \(x_i\) 乘突触权重 \(w_i\) 后在求和节点累加，再经过激活函数产生输出。

McCulloch–Pitts 阈值模型可以写成：

\[y= \begin{cases} 1,&\sum_i w_ix_i\geq\theta,\\ 0,&\text{其他情况}. \end{cases}\]

其中 \(\theta\) 是阈值：加权和达到或超过 \(\theta\) 时输出 1，否则输出 0。它是帮助理解“加权求和 + 判决”的简化二值模型；现代神经网络更常用 ReLU 等连续激活函数。阈值判断本身可以由比较器完成，真正占据大量资源的，是高维输入下反复出现的 \(w_ix_i\) 乘法、累加，以及相应的数据读取。

KCL 为什么相当于一个求和器？

图 5　多个电流汇入同一节点。确定电流方向后，基尔霍夫电流定律直接给出输出电流等于输入电流之和。

基尔霍夫电流定律（KCL）规定节点电流的代数和为零。如果 \(I_1,I_2,I_3\) 流入，\(I_{\mathrm{OUT}}\) 流出：

\[I_{\mathrm{OUT}}=I_1+I_2+I_3\]

从计算角度看，这就是三输入加法。它不是由软件逐条执行加法指令，而是由电荷守恒和电路连接自然得到结果。

如果再用电导 \(G_{ij}\) 表示权重、用电压 \(V_i\) 表示输入，根据欧姆定律，每个器件产生：

\[I_{ij}=G_{ij}V_i\]

同一列上的电流按 KCL 自动相加：

\[I_j=\sum_iG_{ij}V_i\]

这正是向量–矩阵乘法的一列：欧姆定律完成“乘”，KCL 完成“加”，而权重保存在器件电导中，不需要每次从外部取出。

这类计算也不是免费的。模拟和混合信号电路会受到噪声、器件失配、温度漂移和有限精度影响；ADC/DAC（模数/数模转换器）、外围控制和校准也会消耗面积与能量。准确的评价应该是：它用精度与鲁棒性方面的代价，换取潜在的并行度和能效优势。

7. AI 芯片也有安全边界

AI 加速器会保存模型权重、用户输入和中间激活，因此性能之外还要考虑安全。常用的分析框架是 CIA：

图 6　左侧是机密性、完整性和可用性三类后果；右侧沿片外内存、片上加速器和供应链标出可能的攻击入口。

遇到安全分析题，可以按三步回答：

攻击发生在哪里
→ 攻击者做了什么
→ 破坏了 CIA 中的哪一项

例如，监听片外内存总线主要破坏机密性；用电压或时钟扰动制造 bit flip 主要破坏完整性，也可能导致系统不可用；硬件木马则可能同时影响三者。

8. 本章复习页

到这里，正文的逻辑可以压缩成一条链：

神经网络需要大量 MAC / VMM
→ 权重和激活必须被反复读取
→ 存储容量、带宽和搬运能耗成为瓶颈
→ 用复用、量化、稀疏减少数据移动
→ 用 CIM 和神经形态计算进一步靠近“原地计算”

必会公式

四道练习的最终结果

计算题最容易丢分的地方

1. TFLOP/s 除以 TFLOP/s/W，单位消去后才得到 W；
2. 1 MW=10⁶ W，不能直接拿 2.8 和 25 相除；
3. 1 pJ=10⁻¹² J，乘权重数时不要丢掉指数；
4. 百分比降低使用 (旧值−新值)/旧值×100%；
5. 任何能耗结论都要先说明位宽、数据位置、访问次数和复用假设。

简答题可以这样组织

为什么需要 AI 专用硬件？

神经网络具有高吞吐需求和规则的乘加结构，但模型规模使系统受数据搬运限制。专用架构通过并行数据流、片上复用、低精度、稀疏和近存/存内计算提高能效。

为什么量化有效？

量化不仅降低算术成本，还减少权重和激活的容量、带宽与传输能耗；在访存主导的系统中，后者通常是主要收益。

为什么稀疏不一定加速？

如果硬件仍按稠密格式读取并计算，零值不会自动节能。只有硬件能够识别稀疏结构、跳过零值并保持负载均衡，数学稀疏才会变成真实收益。

CIM 解决什么问题？

CIM 把运算移到存储阵列内部或附近，核心目标是减少权重在存储与计算单元之间的反复搬运。

展开自测题与答案

1. 某加速器吞吐率为 200 TOP/s、功耗为 50 W。求能效；若目标为 1000 TOP/s，理想并行需要几颗、总功耗多少？
   答案：4 TOP/s/W；需要 5 颗；总功耗 250 W。
2. 一个 13B 参数模型只计算权重本体，FP32 与 INT8 分别需要多少 GB？
   答案：13×10⁹×32/8≈52 GB；INT8 为 13 GB。
3. 权重密度 40%，激活密度 25%。有效 MAC 和可跳过 MAC 各占多少？
   答案：有效比例 0.4×0.25=10%；可跳过比例 90%。
4. 用 KCL 和欧姆定律说明电导阵列如何完成 VMM。
   答案：电压 \(V_i\) 施加到电导 \(G_{ij}\) 上产生 \(I_{ij}=G_{ij}V_i\)；同列电流由 KCL 相加，得到 \(I_j=\sum_iG_{ij}V_i\)，即矩阵的一列点积。

9. 结语

学习 AI 硬件时，不要从产品型号和峰值算力开始背。更有效的分析顺序是：先确定工作负载需要多少吞吐率，再看功耗预算；接着判断能量主要花在算术、片上存储还是片外访问；最后再评价量化、稀疏、数据复用或 CIM 是否真的减少了最贵的那一部分。

本章最终要建立的不是一张芯片参数表，而是一种判断方法：

让正确的数据留在正确的位置，以尽可能少的移动完成尽可能多的有效计算。

延伸阅读

1. B.-S. Liang, “AI Compute Architecture and Evolution Trends,” IEEE Circuits and Systems Magazine, 2026.
2. Y. Chen et al., “Circuits to Systems: Codesigning Efficient AI Hardware,” IEEE Design & Test, 2025.
3. K. Lee et al., “Secure Machine Learning Hardware: Challenges and Progress,” IEEE Circuits and Systems Magazine, 2025.
4. M. Horowitz, “Computing's Energy Problem (and What We Can Do About It),” ISSCC 2014.

第二章：从 AI 模型到加速器硬件

Week 2 · From AI Models to Accelerator Hardware
本章承接第一章的“减少数据移动”，进一步回答：一个训练好的模型究竟怎样变成芯片能够执行的工作？

第一章从能耗角度说明了为什么需要 AI 专用硬件；这一章开始进入真正的映射过程。我们会从一层 CNN 出发，把卷积依次改写成点积和矩阵乘法，再观察 SIMD 与脉动阵列如何执行同一组运算。随后加入量化、剪枝和稀疏，最后把这些结果汇总成一套完整的加速器设计方法。

本章的主线可以先记成一句话：

高效 AI 硬件的关键，是让模型的运算形式、数值表示和数据流与硬件结构相匹配，并让处理单元尽可能持续地做有效工作。

1. 卷积为什么最终会变成矩阵乘法？

张量（tensor）只是按多个维度组织的一组数。彩色图像可以表示成形状为 H×W×C 的三维张量，其中 H 是高度，W 是宽度，C 是通道数。例如一张 5×5×3 图像包含 5 行、5 列以及红、绿、蓝 3 个通道；张量中的每个数就是一个像素通道值。

卷积层使用一个较小的滤波器（filter，也常称 kernel）在输入上滑动。若输入有 \(C_{\mathrm{in}}\) 个通道，一个滤波器的完整形状就是 \(K_h\times K_w\times C_{\mathrm{in}}\)。它在某个位置覆盖的输入小块称为 patch，patch 与滤波器形状完全相同。两者逐项相乘并求和，得到一个标量；让同一个滤波器扫过所有位置，会得到一张二维输出 feature map。使用 \(C_{\mathrm{out}}\) 个不同滤波器，就得到 \(C_{\mathrm{out}}\) 个输出通道。

训练阶段决定滤波器中的权重；这里讨论的是推理阶段，即权重固定后，怎样高效地对不同 patch 重复执行同一种点积。

图 7　一个 3×3 滤波器覆盖输入图像中的 3×3 区域。9 对元素逐项相乘并求和，得到输出特征图中的一个数；滤波器移动到下一个位置后重复同样的计算。

图中的第一个输出为：

\[\begin{aligned} &1\times1+2\times0+0\times(-1)\\ &\quad+0\times1+1\times0+3\times(-1)\\ &\quad+2\times1+1\times0+0\times(-1)\\ &=1-3+2=0. \end{aligned}\]

这就是一个 9 项点积。若输入有多个通道，点积长度还要乘输入通道数：

\[K=K_hK_wC_{\mathrm{in}}\]

在不考虑 dilation（滤波器元素之间额外插空）的常见情形下，卷积输出的空间尺寸为：

\[\begin{aligned} H_{\mathrm{out}}&=\left\lfloor\frac{H_{\mathrm{in}}+2P_h-K_h}{S_h}\right\rfloor+1,\\ W_{\mathrm{out}}&=\left\lfloor\frac{W_{\mathrm{in}}+2P_w-K_w}{S_w}\right\rfloor+1. \end{aligned}\]

符号含义如下：\(H_{\mathrm{in}},W_{\mathrm{in}}\) 是输入高和宽；\(K_h,K_w\) 是滤波器高和宽；\(P_h,P_w\) 是在上下、左右各补多少圈零；\(S_h,S_w\) 是滤波器每次移动多少格，也就是 stride。向下取整是因为滤波器只有完整落在允许区域内时才产生输出。输出总元素数和总 MAC 数分别是：

\[\begin{aligned} N_{\mathrm{output}}&=H_{\mathrm{out}}W_{\mathrm{out}}C_{\mathrm{out}},\\ N_{\mathrm{MAC}}&=N_{\mathrm{output}}K_hK_wC_{\mathrm{in}}. \end{aligned}\]

从许多点积到 GEMM

把每个输入 patch 展平成一行，把每个滤波器展平成一列，就能把卷积改写为：

\[A_{M\times K}B_{K\times N}=C_{M\times N}\]

• A(M×K)：每一行是一个展平后的输入 patch；\(M=H_{\mathrm{out}}W_{\mathrm{out}}\) 是 patch 数，\(K=K_hK_wC_{\mathrm{in}}\) 是每个 patch 的长度；
• B(K×N)：每一列是一个展平后的滤波器，\(N=C_{\mathrm{out}}\)；
• C(M×N)：每个元素都是“一个 patch 与一个滤波器”的点积，最后再把它重排成 \(H_{\mathrm{out}}\times W_{\mathrm{out}}\times C_{\mathrm{out}}\)。

这种把 patch 收集成矩阵的写法常称为 im2col，得到的一般矩阵乘法称为 GEMM（general matrix-matrix multiplication）。数学没有改变，只是把大量重复点积整理成了硬件更容易并行处理的形式。实际加速器不一定真的把整个 \(A\) 写进内存；它也可以边生成 patch、边送入阵列，从而避免 im2col 对重叠像素的重复存储。

练习 2.1：从卷积数到点积

题目
已知有 4 个图像 patch 和 3 个滤波器。
（a）一共需要多少个点积？
（b）若每个 patch 含有 9 个值，一共需要多少次乘法？
（c）为什么同一套硬件计算引擎可以复用于所有滤波器？

每个 patch 都要与每个滤波器计算一次点积，因此：

\[N_{\mathrm{dot}}=4\times3=12\]

每个点积含 9 次乘法：

\[N_{\mathrm{mul}}=12\times9=108\]

同一硬件能够复用，是因为所有输出都执行相同的“逐项相乘再累加”流程；变化的只是输入值和权重值，而不是计算结构。

2. SIMD：用一条指令控制多条计算通道

一个长度为 9 的点积可以写成：

\[y=x_0w_0+x_1w_1+\cdots+x_8w_8\]

九次乘法彼此没有数据依赖，可以并行执行。SIMD（Single Instruction, Multiple Data，单指令多数据）正是利用这种数据级并行：控制器只发出一条向量指令，多条 lane 同时对不同数据执行它。lane 可以理解为一条独立的算术通道；各 lane 得到的乘积还要经过 reduction（归约）相加，或者逐周期累积进 accumulator，才能形成最终点积。

图 8　四条 SIMD lane 每周期最多完成四次乘法。长度为 9 的点积需要三个周期；最后一个周期只有一条 lane 有效，因此单个点积的 lane 利用率为 9/12=75%。每周期得到的部分和还要继续归约和累加。

设点积长度为 L，SIMD 宽度为 W，则：

\[\begin{aligned} N_{\mathrm{inst}}&=\left\lceil\frac{L}{W}\right\rceil,\\ N_{\mathrm{slot}}&=W\left\lceil\frac{L}{W}\right\rceil,\\ U_{\mathrm{lane}}&=\frac{L}{W\left\lceil L/W\right\rceil}. \end{aligned}\]

这里的 lane-slot 是“一条 lane 占用一个周期”的计算机会。只有执行有效乘法的 slot 才算有用工作。

SIMD 的优势是可编程、适应不同形状；不足是权重仍可能反复从寄存器或共享存储送入 lane，乘积还要进入归约网络。它解决了“如何并行算”，但没有彻底解决“如何复用数据”。

练习 2.2：SIMD lane 利用率

题目
一个四通道 SIMD 单元计算长度为 10 的点积。
（a）需要多少条向量乘法指令？
（b）总共有多少个 lane-slot，其中多少个执行有效运算？
（c）计算 lane 利用率。
（d）当存在许多相互独立的点积时，怎样改善利用率？

指令数向上取整：

\[N_{\mathrm{inst}}=\left\lceil\frac{10}{4}\right\rceil=3\]

三条指令一共提供：

\[N_{\mathrm{slot}}=3\times4=12\]

其中 10 个有效，因此：

\[U_{\mathrm{lane}}=\frac{10}{12}=83.3\%\]

最后两个 slot 会空闲。如果指令格式和数据布局允许，可以把另一个独立点积的项装入这些空闲 lane；本质上是把不同任务重新打包，使每条向量指令更接近满载。

3. 脉动阵列：让数据在 PE 邻居之间流动

脉动阵列（systolic array）由规则排列的处理单元 PE 组成。每个 PE 通常包含一个 MAC 和少量本地寄存器：它接收 activation a、读取本地权重 w、计算 a×w、加到传入的部分和 p，再把数据转发给相邻 PE。

图 9　左侧是单个 PE，右侧是九个 PE 组成的 3×3 阵列。权重可以保留在本地寄存器中，activation 横向传播，partial sum 纵向传播；数据不必在每次 MAC 后返回中央寄存器文件。

“Systolic”描述的是像心跳一样有节奏的邻接数据移动，不是一种新的数学运算。每个时钟沿，数据向相邻 PE 前进一步；为了让正确的 activation、weight 和 partial sum 在同一时刻相遇，不同输入会被刻意错开，形成对角传播的计算波前。

一个 3×3 VMM 例子

给定：

\[\mathbf{x}=\begin{bmatrix}2&1&3\end{bmatrix},\qquad W=\begin{bmatrix} 1&2&0\\ 0&1&3\\ 2&1&1 \end{bmatrix}\]

这里把 \(\mathbf{x}\) 定义为 1×3 行向量，因此正确的矩阵关系是 \(\mathbf{y}=\mathbf{x}W\)，结果为 1×3。\(W\) 的三列分别与 \(\mathbf{x}\) 做点积：

\[\begin{aligned} y_1&=2\times1+1\times0+3\times2=8,\\ y_2&=2\times2+1\times1+3\times1=8,\\ y_3&=2\times0+1\times3+3\times1=6,\\ \mathbf{y}&=\begin{bmatrix}8&8&6\end{bmatrix}. \end{aligned}\]

若把 W 固定在九个 PE 中，activation 向右移动、部分和向下移动，三个结果会在不同周期依次离开三列。继续每周期送入新的输入向量，就能把 VMM 流水化；多行输入依次通过同一个 W，最终就是矩阵乘法 C=AW。

填充、稳定输出与排空

流水线刚启动时，数据还没有走到输出端，这段时间称为 fill latency；输入结束后，阵列中仍有尚未完成的数据，需要 drain。长数据流能够把一次填充和排空成本分摊到许多结果上，短任务则可能大部分时间都花在延迟上。

本课程计算题采用下面的简化模型：一次 tile 产生 R×C 个输出，\(K\) 是每个输出点积的归约长度：

\[T_{\mathrm{tile}}=K+R+C-2\]

这里的 \(R\) 和 \(C\) 分别指 tile 的行数和列数，不是输出矩阵名称 \(C\)。公式中的 \(K\) 个周期用于完成点积，额外的 \(R+C-2\) 反映计算波前穿过阵列的填充与排空。实际设计的周期数取决于阵列数据流、输入错位方式和 tile 调度；计算题应使用题目明确给出的模型。

数据流决定“谁留在 PE 里”

“Stationary”只表示某一类数据为了复用而尽量留在本地，并不是所有数据都停止移动。不存在对所有任务都最优的数据流；选择时要检查数据复用、PE 寄存器容量、层形状能否填满阵列，以及任务是否足够长，能够摊薄 fill/drain 成本。

练习 2.3：流水线效率

题目
一个 2×2 阵列需要 3 个周期产生第一个结果，此后每周期产生一个结果。现在处理 100 个向量。
（a）总共需要多少周期？
（b）第一个结果出现之前的周期占总周期多少？
（c）若把最初 3 个周期整体视作初始延迟，它占总执行时间多少？
（d）若只处理一个向量，这个阵列还是否有吸引力？为什么？

第一个结果在第 3 周期出现，剩余 99 个结果各增加一个周期：

\[T_{\mathrm{total}}=3+99=102\ \mathrm{cycles}\]

真正发生在第一个结果之前的是第 1、2 周期：

\[\frac{2}{102}\times100\%=1.96\%\]

若按题目要求把包含首个输出周期在内的 3-cycle 初始延迟与总时间比较：

\[\frac{3}{102}\times100\%=2.94\%\]

只处理一个向量时，全部 3 个周期都是等待首个结果的延迟，没有稳定输出阶段，阵列的流水优势无法发挥。长数据流才适合摊薄启动成本。

SIMD 和脉动阵列怎样选择？

两者执行的数学完全相同。真正不同的是控制、通信和复用方式。

4. 量化：把连续数值映射到有限整数代码

硬件不能精确保存任意实数，只能存有限位数的 bit pattern。浮点格式用符号、指数和尾数覆盖较大动态范围；整数格式的取值通常均匀分布，算术电路更简单。量化的目标是在可接受精度损失下，用更少 bit 表示权重或 activation。

图 10　量化需要先选实数范围和整数代码范围，再计算 scale、舍入并截断，最后反量化检查误差。舍入误差与 clipping error 的成因不同，不能混为一谈。

通用量化公式

先用代表性校准数据确定需要覆盖的实数范围 [x_min,x_max]，再选择整数代码范围 [q_min,q_max]。例如无符号 3-bit 的代码范围是 [0,7]，有符号 INT8 常见范围是 [-128,127]。scale 为：

\[s=\frac{x_{\max}-x_{\min}}{q_{\max}-q_{\min}}\]

\(s\) 表示相邻两个整数代码在实数轴上的间距。zero-point \(z\) 是“实数 0 对应哪个整数代码”；常用求法是先把 \(x_{\min}\) 对齐到 \(q_{\min}\)，再舍入并截断：

\[z=\operatorname{clip}\!\left(\operatorname{round}\!\left(q_{\min}-\frac{x_{\min}}{s}\right),q_{\min},q_{\max}\right)\]

得到 \(s\) 和 \(z\) 后，量化与反量化为：

\[\begin{aligned} q&=\operatorname{clip}\!\left(\operatorname{round}\!\left(\frac{x}{s}\right)+z,\ q_{\min},q_{\max}\right),\\ \hat{x}&=s(q-z). \end{aligned}\]

• rounding error（舍入误差）：\(x/s\) 不在整数点上，必须舍入到邻近代码；
• clipping error（截断误差）：\(x\) 超出校准范围，代码只能饱和在 \(q_{\min}\) 或 \(q_{\max}\)；
• dequantization（反量化）：用 \(\hat{x}=s(q-z)\) 重建近似实数，便于评估误差。

对称量化通常让实数零对应整数零，算术更简单；非对称量化用非零 z 平移代码范围，更适合 ReLU 后的单边 activation，但计算时需要处理 zero-point。

Per-tensor quantization 为整个张量使用一个 scale，元数据和硬件简单；per-channel quantization 为每个输出通道单独设置 scale，通常能减小权重量化误差，但需要存储并应用更多 scale。

还要注意：低位宽输入不代表 accumulator 也能同样窄。8-bit×8-bit 的乘积可能需要约 16 bit，许多乘积继续累加时还需要更宽的 accumulator。通常先用宽累加器完成点积，最后才重新缩放、舍入、截断并存回低精度。

练习 2.4：量化四个 activation

题目
给定 x=[0.10,0.40,1.30,2.00]，使用 3-bit 无符号代码 q=0,...,7，校准范围为 [0,1.75]，采用 z=0。
（a）计算 scale s。
（b）求每个数对应的整数代码 q=clip(round(x/s),0,7)。
（c）反量化得到 x_hat=sq，计算误差 x_hat-x，并区分舍入误差与 clipping error。

第一步计算 scale：

\[s=\frac{1.75-0}{7-0}=0.25\]

然后逐个除以 s、舍入并截断：

最后一个值先得到代码 8，但 3-bit 无符号数最多表示 7，因此饱和到 7。扩大校准范围可以减少 clipping，却会增大 s，使代码间距变粗、舍入误差可能增大；缩小范围则相反。

练习 2.5：INT8 是否真的划算？

题目
某层有 4 MB 的 FP32 权重，量化为 INT8 后仍能保持精度。
（a）新的权重存储量是多少？
（b）若传输能耗与移动 bit 数成正比，理想权重传输能耗降低多少？
（c）权重存储缩小 4 倍，是否保证总能耗或执行时间也改善 4 倍？解释原因。

FP32 每个值 32 bit，INT8 每个值 8 bit：

\[M_{\mathrm{INT8}}=4\ \mathrm{MB}\times\frac{8}{32}=1\ \mathrm{MB}\]

移动 bit 数变为原来的 1/4，所以理想权重传输能耗也变为 1/4，可表述为“低 4 倍”或“降低 75%”。

但总能耗和时间不保证改善 4 倍。累加器可能仍然较宽，scale 转换与 clipping 会增加工作，有些层可能保留高精度，控制、内存和空闲周期成本也不会按位宽同比例消失。真正收益取决于硬件是否原生支持低精度，以及工作负载中究竟哪部分占主导。

5. 剪枝与稀疏：删掉数学工作，不等于删掉硬件成本

模型压缩是一个总称，目标是在精度仍可接受的前提下，减少存储、算术或两者。量化减少每个值的 bit；剪枝（pruning）则根据重要性移除权重或更大的结构。常见流程是：

训练稠密模型
→ 评估权重或结构的重要性
→ 删除低重要度项
→ fine-tune 恢复精度
→ 编码成硬件支持的稀疏模式

剪枝产生零值，稀疏度描述零值所占比例：

\[\begin{aligned} \mathrm{density}&=\frac{N_{\mathrm{nonzero}}}{N_{\mathrm{total}}},\\ \mathrm{sparsity}&=\frac{N_{\mathrm{zero}}}{N_{\mathrm{total}}}=1-\mathrm{density}. \end{aligned}\]

不同稀疏模式的硬件代价不同

图 11　从左到右分别是非结构化、2:4 结构化、块稀疏和通道/滤波器剪枝。模式越规则，硬件越容易定位非零值并保持整齐的数据流；模式越自由，往往需要越多索引和控制。

零值出现后，硬件可能有四种反应：

1. 照常计算：没有能耗或周期收益；
2. 抑制切换：MAC 动态能耗可能下降，但周期不变；
3. 跳过运算：MAC 和周期都可能减少，但需要选择与负载均衡；
4. 压缩位置：存储和传输可能减少，但需要 mask、index 和解码器。

所以，pruned MAC count 只是数学机会，不是保证的加速。稀疏只有在“跳过的工作价值”大于“元数据与控制开销”时才划算。

练习 2.6：剪枝后硬件能省多少工作？

题目
给定权重向量 w=[0.82,-0.03,0.41,0.01,-0.56,0.07]，删除所有满足 |w|<0.05 的权重。
（a）写出剪枝后的向量。
（b）计算 density 和 sparsity。
（c）六次乘法中有多少次在数学上不再需要？
（d）为什么普通的稠密 SIMD 仍可能执行相同数量的指令？

-0.03 和 0.01 的绝对值小于 0.05：

\[\mathbf{w}_{\mathrm{pruned}}= \begin{bmatrix}0.82&0&0.41&0&-0.56&0.07\end{bmatrix}\]

六个位置中有四个非零、两个为零：

\[\mathrm{density}=\frac{4}{6}=66.7\%,\qquad \mathrm{sparsity}=\frac{2}{6}=33.3\%\]

数学上有两次乘法可以删除。但普通稠密 SIMD 的 lane 与位置固定，若数据仍按稠密向量存放、指令调度也没有跳过或重新打包，这两个零值仍会占用 lane，所以指令数可能完全不变。

练习 2.7：稀疏执行的 break-even point

题目
某层的稠密实现消耗 100 个能量单位。剪枝后只剩 40% 的 MAC；稀疏执行额外产生 18 个能量单位的元数据处理、零检测、索引和控制开销。
（a）求稀疏实现的总能耗，以及相对稠密实现节省的能量。
（b）稀疏在此处是否划算？稀疏处理开销最多可以是多少，仍能节能？
（c）若开销增加到 65 个能量单位，结果如何？

假设算术能耗与剩余 MAC 比例线性缩放：

\[\begin{aligned} E_{\mathrm{sparse}}&=0.40\times100+18=58,\\ E_{\mathrm{saved}}&=100-58=42. \end{aligned}\]

所以节省 42 个单位，也就是 42%。设额外开销为 E_overhead，要优于稠密执行必须满足：

\[40+E_{\mathrm{overhead}}<100 \quad\Longrightarrow\quad E_{\mathrm{overhead}}<60\]

60 是 break-even overhead：开销等于 60 时，两种方案都消耗 100；只有严格小于 60 才真正节能。

若开销增加到 65：

\[E_{\mathrm{sparse}}=40+65=105\]

稀疏方案反而比稠密方案多消耗 5%。这道题的核心不是 42%，而是会写出：

\[E_{\mathrm{net\ gain}} =E_{\mathrm{skipped\ work}}-E_{\mathrm{sparse\ overhead}}\]

6. 从训练好的 CNN 到一颗简单加速器

把模型落到硬件，不是直接选择“GPU 还是 ASIC”，而是连续完成七个具体决定：

理解模型与 tensor shape
→ 计算 dot product 和 MAC 数
→ 选择数值精度
→ 选择 PE 阵列与 dataflow
→ 用 buffer 持续供给数据
→ 与软件参考结果验证
→ 正确解读 peak 与 sustained 指标

考虑下面这层完整给定的 CNN，不需要再从课件补充条件：

• 输入：8×8×1 灰度图像；
• 四个滤波器，每个为 3×3×1；
• stride 为 1、无 padding；
• 一次处理一张图，目标是低延迟。

输出空间尺寸为 8-3+1=6。四个滤波器分别产生一个输出通道，所以输出张量形状是 6×6×4，共有：

\[N_{\mathrm{output}}=6\times6\times4=144\]

每个输出是长度为 9 的点积：

\[\begin{aligned} N_{\mathrm{MAC/output}}&=3\times3\times1=9,\\ N_{\mathrm{MAC,total}}&=144\times9=1{,}296. \end{aligned}\]

每个滤波器会在 36 个空间位置复用。一个教学型设计可以选择 3×3 PE 阵列，把某一个滤波器的 9 个权重分别留在 9 个 PE 中，再依次送入 36 个 patch；四个滤波器可以分时加载，也可以在硬件资源足够时由多组阵列并行处理。

图 12　输入 buffer（片上暂存区）保存图像 patch，weight buffer 提供滤波器，MAC array 执行点积，output buffer 保存结果，controller 生成地址并管理启动、停止和 valid 信号。真正的加速器不只有 MAC 阵列，数据供给和控制同样不可缺少。

控制器可以重复以下顺序：加载 9 个权重、选择 3×3 patch、启动阵列、等待 valid output、保存结果，再前进到下一个 patch 或滤波器。

实现后必须与软件参考逐层验证：

这套流程也适用于 RNN 和 Transformer：硬件仍在执行 MAC 与矩阵运算，只是 tensor shape、依赖关系、复用机会和验证目标不同。

7. 读芯片参数时，不要被 peak TOPS 误导

一条完整的性能声明至少要说明 precision、batch size、sparsity pattern 和 utilization。

还要先区分 latency（延迟） 与 throughput（吞吐率）：延迟是一项任务从输入到输出花多久，吞吐率是稳定运行时每秒完成多少任务或运算。增大 batch 往往能提高吞吐率，却可能让单个请求等待更久；因此交互式系统不能只追求最高 TOPS。

Precision 决定哪种算术产生了这个 TOPS。INT8 和 FP16 不能只看数值大小直接比较；低精度还必须满足模型精度要求，accumulator 也可能比输入更宽。

Batch size 是一次共同处理的独立输入数。大 batch 更容易复用权重并填满阵列，吞吐率可能更高；batch 1 更符合交互式低延迟，却更容易让大阵列闲置。比较芯片时必须固定 batch 和延迟目标。

Peak performance 假设每个算术单元每周期都做有效工作；sustained performance 则计入流水线填充、空闲 PE、数据供给、控制和不支持的算子：

\[U=\frac{R_{\mathrm{sustained}}}{R_{\mathrm{peak}}},\qquad R_{\mathrm{sustained}}\leq R_{\mathrm{peak}}\]

Sparse TOPS 还可能把被跳过的操作也计入“等效吞吐率”。看到稀疏性能时，要确认是非结构化、block sparse 还是 2:4，模型是否真的满足该模式，以及 dense 与 sparse 数值是否使用同一计数口径。

此外还要确认一次 MAC 被记作 1 次还是 2 次 operation。若计数口径、精度、batch 或稀疏模式不同，两个 TOPS 数字即使单位相同也不能直接比较。

练习 2.8：解读一条加速器规格

题目
某加速器的 peak performance 为 20 INT8 TOPS，sustained utilization 为 60%；支持 2:4 sparse mode，并宣传为 2 倍性能；公布数字使用 batch size 8。
（a）稠密 sustained rate 是多少？
（b）宣传口径下的 sparse-equivalent sustained rate 是多少？
（c）为什么 batch-1 CNN 可能达不到这个性能？

稠密持续性能为：

\[R_{\mathrm{dense}}=20\ \mathrm{TOPS}\times0.60=12\ \mathrm{TOPS}\]

若假设稀疏模式仍有 60% 利用率，而且模型严格满足 2:4：

\[R_{\mathrm{sparse,eq}}=2\times12\ \mathrm{TOPS}=24\ \mathrm{TOPS}\]

24 TOPS 是按“若这些零值也执行，本来需要多少操作”计算的等效速率，不代表物理 MAC 单元真的每秒执行 24 万亿次非零运算。

Batch 1 的权重复用较少，阵列也可能难以填满；端到端延迟还包含预处理、数据搬运、控制和非阵列算子。因此不能把 batch 8 的等效峰值直接当作 batch 1 的真实性能。

8. 同一套分析怎样延伸到 LLM？

LLM 先把文字切成 token（词或子词编号），再把每个 token 映射成长度为 \(d_{\mathrm{model}}\) 的向量。若输入共有 \(N\) 个 token，把这些向量按行堆叠，就得到 \(X\in\mathbb{R}^{N\times d_{\mathrm{model}}}\)。Transformer 的投影层和 feed-forward network 仍然是矩阵乘法；self-attention 则用三组线性投影构造 Q、K、V：

\[\begin{aligned} Q&=XW_Q, & K&=XW_K, & V&=XW_V,\\ \operatorname{Attention}(Q,K,V) &=\operatorname{softmax}\!\left(\frac{QK^{\mathsf T}}{\sqrt{d_k}}\right)V. \end{aligned}\]

直观上，Q（query）表示每个 token “想找什么”，K（key）表示每个 token “可按什么特征被匹配”，V（value）是匹配成功后要汇入输出的信息。计算顺序是：

1. \(QK^{\mathsf T}\) 计算每个 query 与所有 key 的相似度，得到注意力分数矩阵；
2. 除以 \(\sqrt{d_k}\) 防止点积随维度增大而数值过大；
3. softmax 把每一行分数归一化为权重；
4. 再乘 \(V\)，得到对各 value 的加权组合。

因此 self-attention 不是“一个神秘的新算子”，而是投影矩阵乘法、\(QK^{\mathsf T}\)、softmax 和“权重乘 \(V\)”的组合。序列长度 \(N\) 决定注意力矩阵的行列数，也直接影响计算量和存储量。

Prefill 与 decode 是两种不同负载

Prefill 是一次读入整段 prompt，并为其中所有 token 建立中间状态。许多 token 可以同时参与矩阵计算，因此更接近大规模矩阵—矩阵乘法，通常更容易填满 SIMD lane 或脉动阵列。

Decode 是在已有上下文后一次只生成一个新 token。第 \(t\) 个新 token 依赖前面所有 token，所以不同生成步之间存在串行依赖；batch 1 时主要出现较窄的矩阵—向量运算，大阵列可能有大量 PE 空闲。也就是说，prefill 的瓶颈和 decode 的瓶颈可能完全不同。

图 13　Prefill 同时处理整段 prompt，通常产生较大的矩阵—矩阵运算，容易填满脉动阵列；decode 每次只生成一个 token，包含更多矩阵—向量运算和跨 token 串行依赖，batch 1 时可能严重低利用大阵列。一个 peak TOPS 无法预测两个阶段。

生成新 token 时，过去 token 的 K 和 V 不会改变。KV cache 把它们保留下来，使下一步只需计算新 token 的 K、V，而不必重新计算全部历史。代价是：上下文越长，缓存越大，而且每个 decode 步骤都要读取越来越多的历史 K、V。

在 batch size 为 1、常规 multi-head attention、每层所有 K 或 V 合计宽度等于 hidden dimension 的简化假设下，KV cache 的近似大小是：

\[M_{\mathrm{KV}}\approx 2N_{\mathrm{layer}}N_{\mathrm{token}}d_{\mathrm{hidden}}b_{\mathrm{value}}\]

其中，\(N_{\mathrm{layer}}\) 是层数，\(N_{\mathrm{token}}\) 是已缓存 token 数，\(d_{\mathrm{hidden}}\) 是每个 token 在每层保存的 K 或 V 的总维度，\(b_{\mathrm{value}}\) 是每个数占用的 Byte；系数 2 对应 K 与 V。以 32 层、2048 token、hidden dimension 4096、FP16（2 Byte/value）为例：

\[\begin{aligned} M_{\mathrm{KV}} &=2\times32\times2048\times4096\times2\ \mathrm{Byte}\\ &=1{,}073{,}741{,}824\ \mathrm{Byte}\\ &\approx1.0\ \mathrm{GiB}. \end{aligned}\]

因此 LLM 压缩不只针对权重，还可能针对 activation 和 KV cache。权重量化减少模型容量与权重流量；KV cache 量化能延长相同显存下的 context，但误差会进入 attention；稀疏只有在硬件支持相应模式时才减少真实工作。采用 grouped-query 或 multi-query attention 时，K/V 头数更少，实际 cache 会小于上面的常规 MHA 估算；考试计算应以题目给定的结构为准。

练习 2.9：7B 模型能否持续供给 decoder？

题目
一个模型有 70 亿个权重，目标生成速度为 20 token/s。简化假设：每生成一个 token，所有权重读取一次。FP16、INT8、INT4 分别占 2、1、0.5 Byte/weight。
（a）计算三种格式的模型存储量。
（b）计算达到 20 token/s 所需的理想权重带宽。
（c）是哪项技术产生了这些节省？
（d）为什么仅凭这些结果仍不知道真实延迟？

存储量等于权重数乘每权重字节数：

节省来自量化：每个权重使用更少 bit，因此存储和传输量同步降低。

这些数值是在“每生成一个 token，全部权重恰好读取一次”的简化模型下得到的理想权重带宽需求：它忽略额外流量，因此对该模型是乐观值；若部分权重能长期留在更近的缓存中，片外带宽需求又可能降低。真实延迟还取决于计算时间、缓存与分片、batch size、KV cache 流量、其他算子、内存有效带宽以及阵列的 sustained utilization，所以不能只凭模型大小推断 token latency。

9. 综合练习 2.10：把一层 CNN 完整映射到硬件

这道题把本章知识串成一次设计决策，题设在 (a)-(f) 中保持不变。

统一题设
CNN 层接收 6×6×1 输入，使用三个 3×3 滤波器，stride 为 1、无 padding。候选硬件为：四通道 SIMD，每周期完成 4 个 MAC；3×3 output-stationary 脉动阵列，每个 PE 每周期完成 1 个 MAC。
脉动阵列每个 tile 的延迟为 \(T_{\mathrm{tile}}=K+R+C-2\)；tile 顺序执行且周期数相同；除非特别说明，忽略内存传输与指令开销。

（a）把卷积写成 C=AB，求矩阵形状与总 MAC 数

问题（a）：把卷积转换为 C=AB。写出 A、B、C 的维度，并计算总 MAC 数。

无 padding、stride 1，因此输出高度和宽度都是：

\[H_{\mathrm{out}}=W_{\mathrm{out}}=6-3+1=4\]

共有 4×4=16 个空间位置。每个 patch 有 3×3×1=9 个值，三个滤波器对应三列：

\[A_{16\times9}B_{9\times3}=C_{16\times3}\]

这里三个维度都有明确含义：(A) 的 16 行分别代表 16 个空间位置上的展平 patch，每行含 9 个输入值；(B) 的 3 列分别代表三个展平后的滤波器，每列含 9 个权重；(C) 的每一行对应一个空间位置，每一列对应一个输出通道。因此 (C_{i,j}) 就是第 (i) 个 patch 与第 (j) 个滤波器的长度为 9 的点积。

总 MAC 数：

\[N_{\mathrm{MAC}}=16\times9\times3=432\ \mathrm{MACs}\]

C 有 16×3=48 个输出，每个输出需要 9 个 MAC，交叉检查同样得到 48×9=432。

（b）映射到 3×3 脉动阵列，求 tile、延迟和利用率

问题（b）：把 C(16×3) 映射到 3×3 脉动阵列，计算 tile 数、总延迟和 PE utilization。

输出矩阵 C 有 16 行、3 列；阵列每个 tile 处理 3 行、3 列：

\[\begin{aligned} N_{\mathrm{row\ tile}}&=\left\lceil\frac{16}{3}\right\rceil=6,\\ N_{\mathrm{column\ tile}}&=\left\lceil\frac{3}{3}\right\rceil=1,\\ N_{\mathrm{tile}}&=6\times1=6. \end{aligned}\]

前五个 row tile 各产生 3 行有效输出，最后一个 row tile 只剩第 16 行有效，阵列中另外两行没有有用输出。题设又规定六个 tile 顺序执行，因此总延迟是单个 tile 延迟的六倍；如果真实硬件允许 tile 重叠，必须另建时序模型，不能直接套用这里的乘法。

每个 tile 的归约长度 K=9，阵列行列数 R=C=3：

\[\begin{aligned} T_{\mathrm{tile}}&=9+3+3-2=13\ \mathrm{cycles},\\ T_{\mathrm{total}}&=6\times13=78\ \mathrm{cycles}. \end{aligned}\]

九个 PE 在 78 周期中共有：

\[N_{\mathrm{peak\ slot}}=9\times78=702\]

真正有效的 MAC 是 432：

\[\begin{aligned} U_{\mathrm{PE}}&=\frac{432}{702}=61.5\%,\\ R_{\mathrm{sustained}}&=\frac{432}{78}=5.54\ \mathrm{MACs/cycle}. \end{aligned}\]

峰值是 9 MACs/cycle，实际只有 5.54，原因包括每个 tile 的 fill/drain，以及最后一个 row tile 只有一行有效输出，另外两行 PE 没有有用工作。

（c）计算四通道 SIMD 理想延迟并比较

问题（c）：计算四通道 SIMD 的理想延迟，与（b）的脉动阵列延迟比较，并解释真实性能为什么可能低于 peak performance。

官方计算采用一个乐观的吞吐量假设：调度器可以交错处理多个彼此独立的输出点积，把某个点积末尾未占满的 lane 用于另一个点积，使四条 lane 每周期都执行有效 MAC；同时忽略水平归约、数据加载和控制开销。在这个假设下：

\[T_{\mathrm{SIMD}}=\frac{432}{4}=108\ \mathrm{cycles}\]

为什么这里容易算出另一个答案？若 SIMD 一次只处理一个长度为 9 的点积，而且一条指令不能混装两个不同输出的 MAC，那么每个输出需要 (lceil9/4\rceil=3) 个周期，48 个输出就是：

\[T_{\mathrm{SIMD,no\ cross\text{-}dot\ packing}}=48\times3=144\ \mathrm{cycles}\]

所以 108 cycles 不是无条件成立的硬件事实，而是“所有 lane 始终有有效工作”的题设理想值；144 cycles 则对应不允许跨点积填充 lane 的保守调度。考试时应先写明采用哪一种调度假设，再代入周期数。本题按给定的理想满载假设继续使用 108 cycles。

题设模型下：

\[\begin{aligned} T_{\mathrm{systolic}}&=78\ \mathrm{cycles},\\ \Delta T&=108-78=30\ \mathrm{cycles}. \end{aligned}\]

脉动阵列少 30 周期。但两者的真实性能都可能低于理想值：SIMD 有 reduction、数据加载、循环控制和 lane 空闲；脉动阵列也只有 61.5% PE 利用率。正确结论是比较该层形状下的 sustained performance，而不是只比较 4 条 lane 和 9 个 PE。

（d）从 FP16 改为 INT8，求存储量与降低比例

问题（d）：存储的输入矩阵、权重矩阵和最终输出矩阵从 FP16 改为 INT8。计算两种表示的总存储量及降低百分比，并指出 INT8 的另一项硬件收益。

题目要求统计存储的 A、B、C：

\[\begin{aligned} N_A&=16\times9=144,\\ N_B&=9\times3=27,\\ N_C&=16\times3=48,\\ N_{\mathrm{total}}&=144+27+48=219. \end{aligned}\]

这里的 (A) 是 im2col 后的输入矩阵，相邻 patch 会重复包含同一输入像素，因此 144 并不等于原始输入的 36 个值。真实加速器若边生成 patch、边送入阵列而不完整存下 (A)，所需输入缓冲可能不同；本题明确要求统计已存储的 (A、B、C)，所以使用 219 个元素。

因此：

\[\begin{aligned} M_{\mathrm{FP16}}&=219\times2\ \mathrm{Byte}=438\ \mathrm{Byte},\\ M_{\mathrm{INT8}}&=219\times1\ \mathrm{Byte}=219\ \mathrm{Byte},\\ \mathrm{reduction}&=\frac{438-219}{438}\times100\%=50\%. \end{aligned}\]

除存储减半外，若硬件原生支持 INT8，还可能降低传输能耗、算术能耗和乘法器面积；但内部 accumulator 仍可能需要更宽位数。

（e）50% 权重剪枝后，比较稀疏与稠密 INT8 能耗

问题（e）：剪枝使 50% 权重变为零。每个剩余 MAC 消耗 1 个能量单位，稀疏索引与控制额外消耗 120 个单位。比较稀疏与稠密 INT8 能耗。

题目进一步给定：50% 权重为零；每个剩余 MAC 消耗 1 个能量单位；稀疏索引与控制固定消耗 120 个单位。

\[\begin{aligned} N_{\mathrm{MAC,remain}}&=0.50\times432=216,\\ E_{\mathrm{dense}}&=432\times1=432,\\ E_{\mathrm{sparse}}&=216+120=336. \end{aligned}\]

节能比例：

\[\frac{432-336}{432}\times100\%=22.2\%\]

50% sparsity 只得到 22.2% 节能，因为索引和控制吃掉了一部分收益。Break-even 条件是：

\[216+E_{\mathrm{overhead}}<432 \quad\Longrightarrow\quad E_{\mathrm{overhead}}<216\]

开销等于 216 时，稀疏与稠密都消耗 432；再高就不值得启用稀疏执行。

（f）给出最终架构与数值配置建议

问题（f）：为这一层推荐计算架构和数值配置，并用 workload shape、latency、utilization、量化节省、稀疏开销以及对其他 layer shape 的灵活性支持结论。

在题设假设下，一个有数据支持的建议是：

常规稠密计算使用 INT8 脉动阵列；只有当剪枝模式被硬件高效支持时才开启 sparse execution。

理由需要引用前面的数字，而不是只写“脉动阵列更快”：

• C=A(16×9)B(9×3) 天然适合矩阵阵列；
• 估算延迟为 78 cycles，低于四通道 SIMD 的理想 108 cycles；
• INT8 把题目统计的输入、权重和输出存储量减半；
• 61.5% 利用率说明 9 MACs/cycle 峰值明显高估实际性能；
• 稀疏可节能 22.2%，但只有硬件支持其模式，收益才可能兑现；
• 对许多小型或不规则 layer shape，SIMD 仍可能因为灵活性而更合适。

这就是完整综合题的答题方式：每个结论都要与前一问的数字相连，最后再说明适用条件和 trade-off。

10. 本章复习页

必会公式

十组练习结果速查

综合题答题顺序

1. 表示模型运算：先求输出尺寸、矩阵形状和 MAC 数；
2. 映射工作负载：求 tile、周期、有效工作和 utilization；
3. 比较架构：使用 sustained performance，不只看 peak；
4. 量化数值表示：计算 bit、Byte、accumulator 和数据移动；
5. 检验稀疏收益：把 skipped work 与 metadata/control overhead 相减；
6. 做设计决定：引用计算结果，再写 trade-off 和适用假设。

最常见的失分原因，是算完数字后没有把它用于最后的架构选择。强答案应该形成：

工作负载形状
→ 硬件映射结果
→ 利用率与真实瓶颈
→ 数值/稀疏收益
→ 有条件的架构建议

11. 本章结论

第二章真正要掌握的不是某一种阵列，而是一套从模型到硬件的翻译方法：

1. 卷积是大量重复点积，可以整理成 GEMM；
2. SIMD 用共享指令开发并行性，脉动阵列用空间数据流组织复用；
3. Peak performance 只有在 lane 和 PE 持续满载时才成立；
4. 量化减少每个值的 bit，稀疏减少值和 MAC，但两者都有额外成本；
5. 一项压缩是否有价值，必须同时检查精度、硬件支持和 sustained utilization；
6. 同样的方法可以继续分析 Transformer、LLM prefill、decode 和 KV cache。

一句话收束：

不是把模型“塞进”一颗芯片，而是把模型的计算、数值和数据流重新组织成硬件能够持续高效执行的形式。

延伸阅读

1. H. T. Kung, “Why Systolic Architectures?,” Computer, 1982.
2. V. Sze et al., “Efficient Processing of Deep Neural Networks: A Tutorial and Survey,” Proceedings of the IEEE, 2017.
3. A. Gholami et al., “A Survey of Quantization Methods for Efficient Neural Network Inference,” 2021.
4. A. Vaswani et al., “Attention Is All You Need,” NeurIPS, 2017.