NPU：专用矩阵计算单元

可视化演示

展示Tensor Core GEMM运算流程、精度演进吞吐量对比及维度对齐检查三种核心模式，直观呈现专用矩阵计算单元的工作原理与优化策略。

芯片架构定位

奶茶街上三种店铺，恰好对应三类计算芯片：CPU 是“全能家庭厨房”，什么菜都会做，但一道菜一道菜地出；GPU 是“连锁大食堂”，工人成百上千，能同时炒很多菜，可工人们仍需在不同窗口间来回切换；NPU 则是“珍珠奶茶全自动流水线”，只做配方固定的奶茶，却把这件事做到每小时上万杯的极致。为什么 AI 时代需要这样一条“偏科”的流水线？因为神经网络的计算高度重复——矩阵乘加占据了绝对主导，继续用通用厨房来炒这盘“大菜”，成本太高、速度太慢。

从技术上看，CPU 遵循冯诺依曼架构，指令和数据都要经过内存总线搬运，而执行一个乘加操作往往要先经历取指令、译码、访存等多个步骤，真正“干活”的时间占比很低。GPU 通过大量线程缓解了并行度问题，但仍为图形渲染保留了通用性包袱。NPU 的设计定位，就是砍掉一切非核心功能，只保留矩阵乘累加所需的硬件资源——大量的 MAC 单元、紧凑的片上缓存、极简的控制逻辑。但这也带出一个新问题：程序里不是所有部分都能被加速。

店长不会让珍珠奶茶流水线去切水果、煮面条，同样 NPU 也不擅长处理控制流和复杂 IO。真正聪明的架构是“CPU 掌勺、NPU 专攻奶茶”——各司其职，整体效率才最高。这也是如今几乎所有 AI 芯片都采用异构架构的根本原因。

矩阵单元原理

珍珠奶茶流水线的灵魂，是那个“配茶工位”。工位只做一个动作：左手取一杯茶、右手取一勺珍珠，两者混合搅拌后放进杯中。这个“一取一混一放”的原子动作，在 NPU 里就叫乘累加（MAC，Multiply-Accumulate）——取操作数 a 与 b 相乘，再把结果累加到寄存器 c 上。一条 MAC 指令完成“乘”和“加”两件事，而矩阵乘法本质上就是无数个 MAC 的叠加。

一个 MAC 单元太慢，NPU 便把成千上万个 MAC 单元排成整齐的阵列——比如 32×32 的阵列就有 1024 个 MAC。阵列规模直接决定理论峰值算力。同时，为了让工位不停歇，还要设计数据流模式：是让权重“驻留”在工位里反复使用（权重驻留），还是让输入数据“驻留”在工位里被多个权重扫描（输入驻留），抑或让部分和“驻留”在阵列中累积（输出驻留）。此外，每个工位旁都配了“小料台”——片上 SRAM 缓存，让工位就近取料，避免每次运算都跑去仓库（主内存）搬数据。

配茶工位旁边的小料台，是整条流水线不停工的秘密：珍珠、奶、茶都放在手边，一次取用、多次调配。NPU 的片上存储设计，正是把“最热的数据”放在离计算单元最近的地方，从根上缓解冯诺依曼瓶颈中的访存压力。

关键计算算法

店长接到一张 100 杯奶茶的大订单，怎么让流水线满负荷运转？三个妙招：一是把订单拆成 10 杯一批（矩阵分块），每批在小料台上独立完成，不必来回往返大仓库；二是让珍珠沿着传送带依次流过每个工位（脉动阵列），工位不用自己去取，珍珠自己“流”到面前；三是一粒珍珠可以被多个工位共用（数据复用），省去重复搬运。这三点，正是 NPU 上矩阵计算算法的核心思想。

脉动阵列是其中最著名的设计：计算单元（PE）排列成规则网格，数据从阵列边缘流入，在相邻 PE 间“脉动式”传递，每个 PE 只与邻居通信，大大减少了全局互连和访存开销。数据复用则分为时间复用（同一数据被多次读取参与多次计算）和空间复用（同一数据同时广播给多个 PE 使用）。分块矩阵乘法则是把大的矩阵切成 b×b 的小块，让小块完全放入片上缓存，从而把片外访存降到最低。那么，分块到底带来多少收益？

至于 Winograd 变换，则是“配方优化”的极致：把卷积的乘法次数用更少的乘法替代。比如 F(2,3) 的 Winograd 卷积，原本 6 次乘法可以压缩到 4 次，以少量加法换来乘法量的大幅下降——毕竟在硬件里，乘法比加法贵得多。

店长的三个妙招合在一起，本质都是同一个目标：让流水线一直有活干，而不是等着原料。分块是备料策略，脉动阵列是传送带设计，数据复用是共享规则，Winograd 是配方改良——它们共同决定了 NPU 能把矩阵乘法的效率推到多高。

性能特性指标

当奶茶店要采购流水线时，老板会看四个指标：每小时产多少杯（产量）、工人们是不是一直忙着（忙碌率）、每度电能做多少杯（能效比）、传送带会不会堵（带宽）。NPU 的性能考核，恰好对应这四件事。

TOPS（Tera Operations Per Second） 是衡量 NPU 理论算力的招牌数字，代表每秒执行的万亿次操作。它由 MAC 阵列规模和时钟频率直接决定：

然而，理论 TOPS 只是“纸面产量”。真正决定快慢的是 MAC 利用率——实际完成的运算量与理论峰值的比值。如果数据没喂饱、算子形状不匹配、片上存储放不下，利用率可能只有两三成。能效比（TOPS/W） 在手机、车载等端侧场景格外关键：同样做一次推理，功耗越低续航越长。带宽与时延则是隐形天花板：即使算力充裕，若数据搬运速度跟不上，计算单元依然会“等米下锅”。

店长最后发现，店里最堵的不是工位，而是那条传送带——加宽传送带（提升带宽）比添置新工位（增加 MAC）更立竿见影。NPU 的性能优化，往往不是堆算力，而是先治好“访存堵车”这个慢性病。

优化映射策略

流水线买回来了，但如何把“100 杯奶茶的订单”变成流水线上每一秒的具体动作？这就需要一张排程表：把大订单拆成小批量、把原料摆放位置调整到工位最顺手的地方、把高峰期的任务错峰排开。在 NPU 的世界里，这张排程表就是编译器和运行时的工作。

算子映射把神经网络中的每一层（卷积、全连接、注意力机制）翻译成 MAC 阵列能执行的指令序列。同样一个卷积，可以切成不同方向的循环展开，映射质量直接影响利用率。访存优化则负责数据布局：把张量从 NCHW 重排成 NHWC，让访问更连续；把多个算子“融合”成一个，减少中间结果写回内存的次数。编译调度负责整体规划——图优化、常量折叠、内存分配，像店长一样决定谁先谁后。指令流水线则让取指、译码、执行三个环节重叠进行，流水线一旦“灌满”，每个周期都有指令完成。

店长的排程表越精细，工位的空闲时间就越少。同理，编译器把算子映射、数据布局、指令流水都安排好，NPU 才能从“纸面 TOPS”变成“真实帧率”。这也是为什么同样一颗芯片，有的团队跑出 80% 利用率，有的只有 30%——差距不在硬件，而在映射策略。

工程应用实践

当流水线在中央工厂验证成功，店长开始把它复制到街边小店、移动餐车甚至机场候机厅。每个场景的“菜单”不同、供电能力不同、空间大小不同，于是出现了各种“轻量化版本”：把配方简化成 8 位整数量化配方，把设备体积压缩到极致。这就是 NPU 从云端走向端侧的工程故事。

在端侧推理中，手机厂商把 NPU 集成进 SoC，专门跑人脸解锁、实时翻译、背景虚化，让 AI 功能在本地完成，既低延迟又保护隐私；自动驾驶汽车则使用车规级 NPU，在毫秒级内完成车道线检测与行人识别，对能效比和可靠性要求极高。在云端训练与推理一侧，NPU 集群承担大模型训练和推理服务，通过批量调度与量化压缩，在功耗预算内提供尽可能高的吞吐。能效策略的核心之一就是 INT8 量化——把 FP32 的模型压缩成 INT8，计算量减半、访存流量降为四分之一。量化背后是这样一个映射公式：

整个工程链条离不开生态工具链：模型先用 PyTorch 训练，导出为 ONNX 等中间格式，再经厂商 SDK 和编译器转换成 NPU 指令，最后配合算子库和调试工具完成性能调优。就像奶茶店的“中央配方 + 门店 SOP + 设备手册”，一环缺了，流水线都转不起来。

从中央工厂到街边小店，NPU 的每一次落地，都是“专用化”与“场景化”的胜利：配方可以被压缩，设备可以被缩小，但那条只做矩阵乘累加的流水线初心不变——用最专一的硬件，换取最极致的效率。

AI 应用场景

Python 演示

import numpy as npimport time def matmul_naive(A, B):    # 朴素三层循环实现矩阵乘法, 模拟CPU逐元素计算    n = A.shape[0]    C = np.zeros((n, n))    for i in range(n):        for j in range(n):            for k in range(n):                C[i, j] += A[i, k] * B[k, j]    return C def matmul_blocked(A, B, block=32):    # 分块矩阵乘法, 模拟NPU片上缓存数据复用    n = A.shape[0]    C = np.zeros((n, n))    for i in range(0, n, block):        for j in range(0, n, block):            for k in range(0, n, block):                for ii in range(i, min(i + block, n)):                    for jj in range(j, min(j + block, n)):                        s = 0.0                        for kk in range(k, min(k + block, n)):                            s += A[ii, kk] * B[kk, jj]                        C[ii, jj] += s    return C def compute_tops(mac_count, freq_hz):    # 根据MAC阵列规模估算理论算力TOPS    flops = 2 * mac_count * freq_hz    return flops / 1e12 if __name__ == "__main__":    np.random.seed(42)    n = 128    A = np.random.rand(n, n)    B = np.random.rand(n, n)     t0 = time.time()    C1 = matmul_naive(A, B)    t1 = time.time()    print("朴素乘法耗时: {:.3f} 秒".format(t1 - t0))     t0 = time.time()    C2 = matmul_blocked(A, B, block=32)    t1 = time.time()    print("分块乘法耗时: {:.3f} 秒".format(t1 - t0))     ok = np.allclose(C1, C2, atol=1e-6)    print("两种方法结果一致: {}".format(ok))     tops = compute_tops(mac_count=1024, freq_hz=1e9)    print("1024个MAC, 1GHz理论算力: {:.2f} TOPS".format(tops))

1. for i in range(0, n, block):按 block 大小切分行，把大矩阵化成能放入“片上缓存”的小块。
2. s += A[ii, kk] * B[kk, jj]这就是一次乘累加（MAC）：相乘再加到局部累加器 s 上。
3. C[ii, jj] += s将小块内累积的完整内积结果写回输出矩阵，减少中间读写。
4. flops = 2 * mac_count * freq_hz理论峰值 = MAC 数 × 频率 × 2（乘加算两次操作）。
5. np.allclose(C1, C2, atol=1e-6)校验分块与朴素版本结果是否一致，证明分块在数值上等价。

常见误区

面试题