NPU：专用矩阵单元

可视化演示

展示NPU专用矩阵单元核心：MAC阵列微架构（4x4乘加阵列A/W输入→O输出）、脉动数据流（权重固定数据波前传播部分和累积）和多精度计算模式（INT8/FP16/BF16/TF32吞吐量对比）,三模式理解NPU矩阵计算原理。

矩阵乘法基础

中央厨房接到一个大单：给幼儿园做营养套餐。每种套餐要把 3 种食材按不同配比混合，再装进 4 种口味的餐盒。厨师长发现，只要把“食材量”和“配方系数”相乘，再加到一起，就是一道菜——这个“乘一下再加起来”的动作反复出现，成了后厨的命脉。

在深度学习中，全连接层和卷积层干的正是这件事。输入特征就是食材，权重矩阵就是配方，输出就是成菜。一个全连接层把 1024 个输入映射到 1024 个输出，就需要约 100 万次乘加。于是芯片设计师不再依赖 CPU 里那种什么都能干的通用计算单元，而是专门做一批只会“乘加”的小部件，这就是专用矩阵单元的由来。

矩阵乘法有严格的数学定义。给定输入矩阵 $A$（尺寸 $M \times K$）与权重矩阵 $B$（尺寸 $K \times N$），输出矩阵 $C$（尺寸 $M \times N$）中每个元素，都是 A 的一行与 B 的一列做点积：

这一节说明白了：矩阵乘法本质是一堆乘加的批发。后厨只要准备一台能快速做“食材 × 系数 + 已有成品”的灶台，就能撑起整条生产线。下面我们看看，把灶台铺开能快到什么程度。

MAC阵列架构

一个灶台一次只能出一道菜。幼儿园有 1200 个孩子，每道菜要 100 次乘加，单枪匹马得忙到天黑。怎么办？答案是“灶台矩阵”：把 16 个灶台排成 4 行 4 列，每人负责一道菜的一部分，同一时刻 16 份套餐在同步制作。这个灶台矩阵在芯片里就叫 MAC 阵列。

MAC 是 Multiply-Accumulate（乘加）的缩写。一个 MAC 单元由三部分组成：一个乘法器、一个加法器、一个保存累加值的寄存器。它的行为像记账：在老账本上添一笔新账，账越记越厚，但永远只有“乘、加、存”三个动作。

阵列规模是设计的第一颗旋钮。常见 NPU 采用 16×16、32×32 甚至更大的 MAC 阵列，一个时钟周期内所有单元同时做一次乘加，所以 16×16 阵列一拍能做 256 次 MAC。权重驻留是另一项关键布局：每个 PE（处理单元）内嵌寄存器存放权重，计算时权重不动、输入流经，避免每算一步都去片外取一次配方。

有了灶台矩阵，16 道菜同时开火。但新问题来了：食材和配方怎么送到每个灶台手上？如果每道菜都跑一趟中央仓库，再快的灶台也得饿肚子。于是，聪明的后厨设计了传送带——这就是脉动数据流。

脉动数据流

传统厨房里，厨师每做一道菜都要去中央冰箱取料，取料路上的时间比炒菜还多。脉动厨房的解决办法是：把灶台连成传送带，食材从头上下来，每个灶台取一点，做完递给下一位，最后一位把成品装盘。每个灶台只跟左右邻居打交道，谁也不用跑远路。

这个思想在芯片里叫脉动阵列（Systolic Array）：数据像脉搏一样，一个周期从相邻的计算单元“泵”到下一个单元。每个 PE 的输出就是下一个 PE 的输入，整片阵列像一条流动的河。权重驻留时，数据只沿一个方向流动，访问片外内存的次数大幅下降。

经典脉动调度可以这样描述：第 r 行 c 列的 PE，在第 t 个时钟周期收到左邻居和上邻居传来的数据：

由于所有搬运都发生在芯片内部相邻单元之间，不再反复访问片外 DRAM，整个阵列每周期处理一条“波前”对角线。当波前扫过全部 $2N-1$ 条对角线时，一次矩阵乘法完成，这就是可视化演示里那条斜向亮带的含义。

传送带让灶台永不待料，数据每周期向前推进一格，所有灶台保持满负荷。不过传送带再快，也要看食材用什么度量衡——下一节讲精度档位。

精度模式

中央厨房里有几种称量工具：大中小容量的标准量杯、家庭电子秤，还有一种“量程很大但刻度粗”的工业大秤。同样是称食材，用大秤速度快、省电，但每勺分量可能偏差一点；用精细秤更准，却更慢更费电。芯片里的数值也有类似的“称量工具”，这就是精度模式。

FP32 用 32 位存一个浮点数：1 位符号 + 8 位指数 + 23 位尾数。FP16 砍到 16 位：1 + 5 + 10，尾数精细但指数只有 5 位，能表示的范围很小。BF16 也是 16 位，但格式是 1 + 8 + 7：指数位和 FP32 一样多，范围一样大，只是尾数只有 7 位，精度较粗。INT8 则直接映射到 8 位整数网格，速度最快、能效最高。

INT8 量化的核心是一个缩放因子 s，把浮点数映射到整数区间：

精度对硬件的影响非常直接：INT8 的乘加电路面积约为 FP16 的四分之一，功耗更低，所以同一块芯片的 INT8 峰值算力往往是 FP16 的两倍以上。BF16 保留了大动态范围，训练大模型时梯度不容易溢出，成为 AI 加速器的新宠。

量杯、家用秤、工业大秤各有各的用武之地。NPU 把几种精度电路做进同一个矩阵单元，运行时可切换，就像后厨按订单类型换工具。工具选对了，剩下的问题是：怎么安排人手和物料？这就引出数据流模式。

数据流模式

厨房有两种物料：食材（输入）和配方（权重）。想让矩阵阵列出菜最快，得决定“谁站着不动、谁来回跑”。三种经典分工：配方卡钉在灶台上不动，食材流过台面；食材桶摆在一旁，配方卡和成品锅轮流过来取；成品锅钉在灶台上，食材和配方都流过来加料。

这三种分工在芯片术语中叫 Weight Stationary（WS，权重固定）、Input Stationary（IS，输入固定）、Output Stationary（OS，输出固定）。它们决定了谁被反复利用、谁被不断搬动，直接影响访存次数和能效。用集合语言表示：

实际产品中常见混合数据流：在阵列的行方向用 WS、列方向用 OS，两边优势都要。推理场景权重固定不变，一批批输入数据反复到来，WS 让权重永不挪窝；训练场景反向传播需要频繁累加部分和，OS 让累加器待着不动，能省下大量搬运。

定好分工，就该算产能了：一个阵列一个周期能做多少次乘加？一秒能做多少次？这就是吞吐量。

吞吐量分析

园长问：这套灶台一小时能出多少份套餐？厨师长掏出公式：灶台数 × 每道菜的动作数 × 灶台开火的频率。芯片里对应三个量：阵列中 MAC 单元总数、每次 MAC 包含的乘与加两个动作、芯片运行的主频。

峰值吞吐量是矩阵单元最重要的性能指标之一，它只由硬件结构决定，与软件无关：

如果矩阵的形状和阵列不匹配，部分 MAC 单元会空转，实际吞吐低于峰值，这个比值叫利用率。比如矩阵维度是 10×10，硬塞进 16×16 阵列，只有约 39% 的灶台在干活。计算密度则把面积成本纳入考量：同样的面积能塞下更多 MAC、跑出更高频率，密度越高，单位面积的算力越值钱。

吞吐量这张成绩单告诉我们：灶台越多、开火越快，出菜就越快。但灶台多了，电费单也会变厚——下一节算算能效这笔账。

能效权衡

菜做得好，账也得算。后厨的电费单按“每道菜耗多少度电”来考核。芯片界有个对应的金标准：TOPS/W——每瓦特功耗能完成多少万亿次操作。能效是 AI 芯片最重要的指标之一，尤其在手机、汽车等功耗受限的场景里，它甚至比峰值算力更关键。

能效与三个因素强相关：精度、时钟频率和电压。INT8 的乘加电路面积小、翻转少，同样阵列下能效可达 FP16 的 4 到 8 倍；电压从 1V 降到 0.7V，动态功耗约降一半，所以许多 NPU 用“低电压 + 高并行”来换能效。公式如下：

除了精度和电压，利用率也直接决定能效：空转的 MAC 单元虽然没干活，却依然在漏电、在翻转，白白消耗功率。因此数据流模式的选择、批处理的大小、算子与阵列的匹配度，都会影响真实能效。设计矩阵单元时，阵列规模、频率、精度、数据流四个旋钮相互牵制，最终要落在“应用最需要的那个平衡点”上。

至此，中央厨房的完整图景浮现出来：矩阵乘法是菜谱，MAC 阵列是灶台，脉动传送带与三种分工是流水线，精度档位是称量工具，而吞吐和能效是两张成绩单。NPU 矩阵单元的微架构设计，就是在这张成绩单上不断逼近最优点。

AI 应用场景

Python 演示

import struct  def bf16_truncate(value):    """把 float32 截断为 bf16 再还原为 float32, 保留高位 16 位"""    bits = struct.unpack('>I', struct.pack('>f', value))[0]    return struct.unpack('>f', struct.pack('>I', bits & 0xFFFF0000))[0]  def fp16_truncate(value):    """把 float32 转成 fp16 再还原, 用 struct 的 e 格式"""    return struct.unpack('>e', struct.pack('>e', value))[0]  class MatrixUnit:    """模拟 NPU 专用矩阵单元: MAC 阵列 + 可切换精度"""     def __init__(self, rows, cols, precision='bf16'):        self.rows = rows        self.cols = cols        self.precision = precision        self.weights = None        self.mac_count = 0        self.cycle_count = 0     def load_weights(self, weights):        self.weights = weights     def quantize(self, value):        if self.precision == 'int8':            q = int(round(value / 0.1))            q = max(-128, min(127, q))            return q * 0.1        if self.precision == 'fp16':            return fp16_truncate(value)        if self.precision == 'bf16':            return bf16_truncate(value)        return value     def multiply(self, A, B):        """三重循环模拟 MAC 阵列逐层累加, 统计乘加次数"""        K = len(B)        rows, cols = len(A), len(B[0])        C = [[0.0 for _ in range(cols)] for _ in range(rows)]        for i in range(rows):            for j in range(cols):                for k in range(K):                    term = self.quantize(A[i][k] * self.weights[k][j])                    C[i][j] = self.quantize(C[i][j] + term)                    self.mac_count += 1                self.cycle_count += 1        return C  def main():    A = [[0.1, 0.2, 0.3],         [0.4, 0.5, 0.6]]    B = [[1.0, 2.0],         [3.0, 4.0],         [5.0, 6.0]]     for precision in ['fp32', 'bf16', 'fp16', 'int8']:        unit = MatrixUnit(rows=2, cols=3, precision=precision)        unit.load_weights(B)        C = unit.multiply(A, B)        print(precision, 'C =', C, 'MACs =', unit.mac_count)  if __name__ == '__main__':    main()

1. class MatrixUnit用 Python 类模拟专用矩阵单元，rows/cols 对应阵列规模，precision 对应精度档位。
2. def quantize(self, value)按精度模式对数值做量化：INT8 走缩放取整，FP16/BF16 走截断模拟。
3. bits & 0xFFFF0000把 float32 的低 16 位尾数清掉，等价于 BF16 的舍入方式。
4. term = self.quantize(A[i][k] * self.weights[k][j])模拟 MAC 单元的“乘”：食材 × 配方系数后立即量化。
5. C[i][j] = self.quantize(C[i][j] + term)模拟 MAC 单元的“加”：累加时再次量化，体现反复截断的累积误差。
6. self.mac_count += 1每执行一次乘加就计数，对应吞吐公式里的 $N_{\text{MAC}}$ 可累计次数。
7. main()` 中遍历 `['fp32', 'bf16', 'fp16', 'int8']对比四种精度的输出矩阵，观察 INT8 偏差最大、BF16 范围稳。

常见误区

面试题