能不能用 FPGA 做一块 Transformer 专用推理电路

用 GPU 跑一个 80 亿参数的模型，比如 Llama 3.1 8B，只给一个人用，一块 H100 每秒大约能吐出 140 个 token¹。生成一个 token，模型要做大约 160 亿次浮点运算（每个参数一次乘法一次加法），一秒 140 个就是 2.2 万亿次。H100 的标称算力是每秒 989 万亿次²。

两个数一除，不到 0.3%。也就是说，这块三万美元的卡，在给一个人写字的时候，绝大部分乘法器是闲着的。

这就让人想问：GPU 是为各种计算设计的通用芯片，如果我们只跑 Transformer，能不能为它专门搭一块电路？FPGA 正好能搭出任意电路，而且不用去流片。这样一块专用电路，会不会更快、更省电、更便宜？它又会卡在哪里？

一、推理时芯片在等什么

现象：算力用不满

先弄清楚那 99.7% 的乘法器为什么闲着。大模型生成文字分两段：先把用户的整段输入一次性算完（prefill），然后一个 token 一个 token 地往外写（decode）。我们和模型聊天时看到的“逐字往外蹦”，就是 decode。

decode 每写一个 token，都要让这个 token 依次穿过模型的每一层，每一层都要用到这一层的全部权重。80 亿个参数，每个用 16 位浮点存，一共 16 GB。所以每生成一个 token，芯片就要把 16 GB 的权重从显存里完整地读一遍，而读进来的每个参数只参与一次乘法和一次加法。

图 1 · 批大小为 1 时，生成一个 token 的时间几乎全花在读权重上，乘法器 99% 以上的时间在等数据

图 1 把账算了出来。H100 的显存带宽是 3.35 TB/s，读完 16 GB 要 4.8 毫秒；而 160 亿次运算，按 989 TFLOPS 算只要 0.016 毫秒。这块芯片的“算力 ÷ 带宽”约为 295，意思是每从显存读进 1 个字节，它有能力做 295 次运算；decode 却只给了它 1 次。所以单用户 decode 的速度上限由带宽决定：3.35 TB/s ÷ 16 GB ≈ 209 token/s，实际能做到的一百二三十到一百四十，就是带宽用到了六七成。

原因：读一遍权重，只服务了一个 token

问题不在乘法器不够快，而在读进来的每个权重只用了一次。这件事有一个直接的推论：如果同一时刻有很多用户，每人都要生成下一个 token，那么读一遍权重，就可以让这些 token 一起用。读权重的时间不变，产出却翻了很多倍。这就是推理服务里的“批处理”（batching）。

我们在一台 4 核的 CPU 机器上模拟了这件事³。取一个 512 MB 的权重矩阵（远大于 CPU 缓存），分别乘上 1 个、2 个……512 个 token 的激活向量，看完成一次要多久。

同一个 512 MB 的权重矩阵，一次乘上 B 个 token（4 核 Xeon，numpy）

批大小 B	一次用时	等效 token/s	等效读权重带宽
1	12.8 ms	78	41.8 GB/s
4	26.5 ms	151	20.3 GB/s
16	28.7 ms	558	18.7 GB/s
64	47.5 ms	1347	11.3 GB/s
256	134.5 ms	1903	4.0 GB/s

B=1 时 numpy 走的是矩阵 × 向量的专门路径，带宽用得最好；B≥2 换成矩阵 × 矩阵的路径，所以 B=2 到 16 的用时差不多，都是 26–29 ms。

表 1 · 批大小从 4 涨到 16，用时几乎不变，产出翻了近 4 倍：读一遍权重的成本被多个 token 分摊了

表 1 里最值得看的是 B 从 4 到 16 那一段：一次的用时从 26.5 毫秒只涨到 28.7 毫秒，产出却从每秒 151 个 token 涨到 558 个。再往后，计算量追上来了，用时才开始明显增加，到 256 时 CPU 已经主要在算而不是在等。GPU 上是同样的规律，只是拐点更靠后：H100 每读 1 字节能算 295 次，批要到一两百才会被算力卡住。

这就是 GPU 服务大模型的基本做法：把很多用户的请求拼成一批，让那 99% 闲着的乘法器忙起来。可是批处理只解决了“很多人同时用”的情况。对一个用户来说，他的下一个 token 必须等上一个 token 算完，批再大也帮不了他的延迟。

那么，如果不靠批处理，而是从电路本身下手，能把这一个用户的 token 做得更快、更省吗？

二、专用电路能省在哪里

通用处理器为“通用”付的钱

要回答这个问题，先得知道一块芯片的能量花在了哪里。Horowitz 在 2014 年 ISSCC 的主题报告里，把 45 nm 工艺下各种操作的能耗摆在一起比较⁴，结果如图 2。

图 2 · 真正做运算的那一下只要几 pJ，取指令和从片外取数据要贵一到三个数量级

真正做乘加的那一下，只要几 pJ。可是在通用处理器上，为了执行这一下，要先取一条指令、译码、调度、读写寄存器，这些加起来约 70 pJ，是运算本身的十几倍以上。数据如果不在手边，要从 DRAM 取，一次就是 1 到 2 nJ，又贵了几百倍。Horowitz 由此得出一个结论：专用硬件比处理器高效两到三个数量级，而省下来的主要不是运算，而是指令和数据搬运。

GPU 已经比 CPU 好很多：一条指令驱动几十个线程，Tensor Core 一条指令做一整块矩阵乘，指令开销被摊薄了。但前两节的账告诉我们，decode 时的大头是图 2 最下面那一行：每个 token 都要从显存搬 16 GB。

专用电路的三根杠杆

把这些放在一起，一块只为 Transformer 设计的电路，能在三个地方动手：

去掉指令。 计算的顺序在设计电路时就定好了，数据从一个单元直接流到下一个单元，不再取指、译码、调度。
位宽按需定。 GPU 的乘法器只有几种固定位宽。专用电路可以给权重用 4 bit、3 bit，甚至只用 −1、0、+1 三个值，每个权重占的字节少了，读一遍权重的时间就短了，乘法器也跟着变小。
数据不出芯片。 一层算完的中间结果直接送进下一级，不写回显存；如果片上存储够大，连权重都放在片上，彻底不用每个 token 去片外搬一趟。

FPGA 正好能把这三件事都做出来：它的查找表能搭出任意位宽的运算单元，布线能把单元连成固定的流水线，芯片上还散布着几千块小存储。那么，真在 FPGA 上把 Transformer 搭成一条流水线，效果怎么样？

三、在 FPGA 上搭一条推理流水线

已经做出来的：FlightLLM

这件事已经有人做了，而且做得相当完整。FlightLLM 是发表在 FPGA 2024 上的一项工作，在一块 AMD Alveo U280 加速卡上跑 LLaMA2-7B⁵。U280 是一张数据中心用的 FPGA 卡，带 8 GB HBM，带宽 460 GB/s，大约八千美元⁶。

它基本就是把上一节的三根杠杆都用上了。权重压到平均 3.5 bit，并做了 N:M 结构化稀疏（每 M 个权重里只留 N 个非零）；注意力也用块稀疏，只算一部分位置。计算组织成一条按层走的流水线，GPU 上拆成好几个 kernel 的步骤，在这里是几个相邻的专用单元，激活在单元之间直接传（图 3）。

图 3 · GPU 上一层要分几趟进出显存，FPGA 上一层是一条直通的流水线，带宽利用率因此更高

图 3 只是示意，GPU 这边的算子融合（比如 FlashAttention）也能把一部分中间结果留在片上，但在批大小为 1 时，GPU 的带宽确实用得不好：FlightLLM 测到 A100 只用到 28.6%，换上优化过的推理框架是 57.4%；它自己在 U280 上是 65.9%。

结果是这样的：和 V100S 比，FlightLLM 每焦耳能生成的 token 多 6.0 倍；和优化过的 A100 比，多 3.8 倍。按“每美元每秒能生成多少 token”算，比 V100S 好 1.8 倍。另一篇在 U280 上做 GPT 推理的工作也得到相近的结论：decode 比 A100 快 1.9 倍，能效高 5.7 倍⁷。做 FPGA 推理服务器的 Positron 公司，在 Agilex 7 FPGA 上做出了产品，自称比 H100 有 3.5 倍的性价比和能效¹。

所以第一个问题的答案是肯定的：为 Transformer 搭的 FPGA 流水线，在单用户 decode 上确实能比 GPU 省几倍电，单 token 也更便宜。

不足：比的是谁

但仔细看这些对比，会发现两个问题。

一是 GPU 那一边用的是 16 位权重，FPGA 这一边是 3.5 bit。读一遍权重的字节数差了四倍多，而 decode 的速度正是由读多少字节决定的。如果 GPU 也把权重压到 4 bit，差距会小很多：FlightLLM 自己列出的 A100 加 INT4 的对照是每秒 196.8 个 token，而它在更新的 Versal VHK158 上是 92.5 个。

二是这些对比几乎都在批大小为 1 的条件下做。前面看到，批处理是 GPU 服务大模型的基本做法，那才是数据中心里的常态。

把这两点都算进去，FPGA 还便宜吗？

四、带宽这道墙

原因：FPGA 卡的显存带宽小得多

decode 的速度上限是“带宽 ÷ 权重字节数”，那就先比带宽。U280 的 HBM 是 460 GB/s，新一代的 Alveo V80 是 820 GB/s⁸，H100 是 3.35 TB/s，差了 4 到 7 倍。FPGA 再怎么把带宽用满，也追不上带宽本身的差距；它能赢，靠的是把权重压得更小，而 GPU 也能压。

批处理一来，差距就更大了。FPGA 卡上的乘法器（DSP）只有一万个上下，批稍微大一点就被算力卡住；H100 每读 1 字节能算 295 次，批到一两百都还在“等带宽”的那一段，产出几乎随批大小线性增长。

估算：每百万 token 多少钱

我们按“每一步的用时 = 读权重的时间和计算时间里较大的那个”做了一个粗略的估算³，模型是 Llama 3.1 8B。成本只算硬件按三年摊销加上满功耗的电费（0.1 美元/度），H100 按三万美元，FPGA 用厂商标价；带宽利用率 GPU 取 45%–60%、FPGA 取 65%，算力利用率 GPU 取 50%、FPGA 取 70%。这些都是假设，表 2 看数量级就好。

Llama 3.1 8B decode 的屋顶线估算（只算权重，不算 KV cache）

设备 · 权重精度	token/s	焦耳/token	美元/百万 token
批大小 1：一个用户
H100 · FP16	126	5.6	2.68
H100 · INT4	377	1.9	0.89
U280 · 3.5 bit	87	2.6	1.05
V80 · 4 bit	133	1.4	0.79
批大小 64：很多用户同时用
H100 · FP16	8040	0.087	0.042
H100 · INT4	24120	0.029	0.014
U280 · 3.5 bit	178	1.3	0.51
V80 · 4 bit	285	0.67	0.37

功耗按标称最大值算，FPGA 的实际功耗通常低得多，所以 FPGA 那几行的焦耳/token 偏保守。FPGA 的算力只按 DSP 每拍一次乘加估算，批到 8 左右就饱和了。

表 2 · 一个用户时，FPGA 能和 16 位的 GPU 拉开差距，但和同样压到 4 bit 的 GPU 差不多；用户一多，GPU 每 token 的成本低一个数量级

表 2 的上半部分和 FlightLLM 的结论吻合：一个用户、GPU 用 16 位权重时，FPGA 每百万 token 便宜一半以上，能耗也低一半。可是一旦 GPU 也用 4 bit，两边就差不多了。下半部分才是数据中心真正的账：64 个用户同时用，H100 读一遍权重能产出 64 个 token，每百万 token 的成本降到一两分美元，FPGA 卡在自己的算力上，比它贵二三十倍。

这样看，“FPGA 专用电路降低推理成本”这个说法要加上条件。在一个用户、对延迟敏感、或者功耗受限的场合（边缘设备、机柜供电紧张的机房），它能赢；在大批量的云端服务里，GPU 靠批处理把读权重的成本摊薄了，FPGA 赢不了。

到这里，FPGA 的专用电路其实只用上了三根杠杆里的前两根：去掉指令、压低位宽。权重还在片外的 HBM 里，每个 token 照样要读一遍，带宽墙一点没动。如果把权重整个搬进芯片里呢？

五、把权重搬进芯片

片上存储有多快

FPGA 芯片上散布着几千块小存储：U280 有 2016 块 BRAM 和 960 块 UltraRAM⁶，每一块都有自己的读写口，每个时钟周期都能同时出数。按块数粗略算，片上的总带宽在 10 TB/s 量级，是它那 460 GB/s HBM 的二十多倍，而且读片上存储的能耗比读片外低一两个数量级（回看图 2）。

TerEffic（2025）就是这么做的⁹。它用三值权重：每个权重只能是 −1、0 或 +1，5 个权重打包成 8 bit，平均 1.6 bit。乘法也就不需要乘法器了，乘以 +1 是原样，乘以 −1 是取负，乘以 0 是丢掉，用查找表搭一个选择器就够。这样两块 U280 能把一个 3.7 亿参数的模型全部放进片上存储，单用户每秒生成 16300 个 token，是前面 7B 模型速度的上百倍。

不足：片上装不下大模型

问题是，16300 token/s 的是一个 3.7 亿参数的小模型，而且要两块卡。每块 U280 的片上存储大约 41 MB，按 1.6 bit 一个权重，只能装两亿出头。图 4 把几种芯片的片上容量和几个模型的大小放在一起。

图 4 · 片上存储和模型之间差了两到三个数量级，只有整片晶圆大小的芯片才装得下几十亿参数

8B 模型压到 4 bit 也有 4 GB，是 V80 片上容量的近 50 倍。这不是 FPGA 独有的难题：专门走“全 SRAM”路线的 Groq，每片也只有 230 MB，演示 Llama 2 70B 用了 576 片¹⁰；Cerebras 干脆把一整片晶圆做成一块芯片，才有 44 GB 的片上存储¹¹。权重放在片上，速度确实快，代价是要很多芯片一起扛，每片都要买、都要供电。

片上存储装不下，是因为存储块本身占地方。那如果不“存”权重，而是把权重直接做成电路的一部分呢？

六、把权重焊进电路

实验：权重可改和权重写死，面积差多少

到目前为止，权重都是“数据”：放在存储里，算的时候读出来，送进乘法器。可推理时权重根本不变，那么完全可以把它当成常数，直接写进电路。乘以一个已知的常数，电路能简单很多：乘以 0 的那根线可以整个删掉，乘以 +1 就是一根导线，乘以 −1 只要一个取负；乘以 37 这样的整数，也可以化成几次移位和加法。

为了看看到底能省多少，我们用开源综合工具 yosys 做了个实验³。电路是一个 64 元点积，激活是 8 位整数；权重分成 8 位、4 位、三值三种，每种又分两种写法：一种是权重从端口送进来（可以随时换，相当于通用电路），一种是写死成常数（换一组随机权重各综合三次）。全部综合到 Xilinx 7 系列的 6 输入查找表上，不用 DSP，只看用了多少个查找表。每种写法都先用 Icarus Verilog 随机仿真了 200 组输入，结果全对。

64 元点积综合到 Xilinx 7 系列，用了多少个查找表（LUT6，不用 DSP）

权重	从端口送进来（可改）	写死成常数（3 组随机权重）	省了
8 位整数	14529	4915、5113、4483	约 3 倍
4 位整数	7271	2267、2513、2508	约 3 倍
三值 −1/0/+1	2618	793、884、844	约 3 倍

开源 yosys 综合出来的面积比厂商工具 Vivado 大，绝对值只作参考，看同一列、同一行之间的比例。

表 3 · 位宽从 8 位降到三值省了 5 倍多，权重从可改变成写死又省了 3 倍，两样叠起来差 17 倍

表 3 里有两条线索。竖着看，位宽越小越省：8 位可改要 14529 个查找表，三值可改只要 2618 个，因为乘法器变成了选择器。横着看，写死的版本都只有可改版本的三分之一左右。图 5 拿四个输入画出了三值的情况。

图 5 · 权重写死以后，选择器和存权重的寄存器都没了，权重为 0 的输入连线也一起消失

可改的版本要为每个输入准备一个选择器，还要有地方存权重；写死以后，选择器消失了，权重为 0 的输入（我们的随机权重里约占三分之一）连线都不用接。这就是“专用”这两个字能走到的最远处：电路就是这一个模型，别的什么都不是。

不足：一个模型要上万块 FPGA

可是把这个数放大到真模型上，就看出问题了。三值写死的点积，平均每个权重大约要 13 个查找表（840 ÷ 64）。一个 80 亿参数的模型，就是大约 1000 亿个查找表；目前最大的 FPGA 之一 VP1902 有 846 万个，算下来要一万多块。哪怕 Vivado 能把面积再压掉一半，也是几千块。

而且这样的电路算得太“多”了：它在每个时钟周期把整个模型完整地算一遍，跑在 200 MHz 上，相当于每秒能处理两亿个 token。一个用户根本用不完。要是让同一块电路分时复用，轮流算不同的层，权重就又得存起来、读出来，又回到了第五节的容量问题。

FPGA 本身的“可编程”也有代价。同样一个电路做在 FPGA 上，面积大约是做成专用芯片（ASIC）的 35 倍（大量用硬核乘法器和存储块时能降到 5 倍左右），速度慢三四倍，动态功耗高 14 倍左右¹²。FPGA 用这些代价换来了“能重新烧写”，可一块焊死了模型的电路，恰恰用不上重新烧写。

解决：交给 ASIC

所以“把模型焊进电路”这条路，最后走向了 ASIC。2026 年初，一家叫 Taalas 的公司发布了 HC1 芯片，把 Llama 3.1 8B 直接做进了芯片：815 平方毫米、530 亿个晶体管，权重用 3 bit 和 6 bit 的混合格式，一张卡约 200 W，厂商称每个用户每秒能生成约 17000 个 token¹³。它的代价也写得很清楚：这块芯片只能跑这一个基础模型，最多加个 LoRA 微调；换模型，就得重新流片。

这里 FPGA 反而找到了自己的位置。模型结构每半年就变一次（分组注意力、混合专家、新的位置编码……），直接去流片风险很大，FPGA 正好可以先把架构跑通、拿去卖、收集反馈，再把成熟的设计做成 ASIC。前面提到的 Positron 就是这么走的：第一代产品 Atlas 用 FPGA，第二代 Asimov 改成自研 ASIC，并说以后都保持“FPGA 先行、ASIC 跟进”的节奏¹⁴。

七、回到开头

开头那块 H100，给一个人写字时不到 0.3% 的乘法器在干活。现在我们知道，这不是乘法器设计得不好，而是每个 token 都要把 16 GB 权重从显存搬一遍，乘法器在等数据。专用电路能做的，就是想办法不让它等，而三条路各有各的代价：

让很多 token 共用一次读取（批处理）：GPU 的做法，成本最低，但帮不了单个用户的延迟。
让每次读取更少、更顺（低位宽、稀疏、流水线）：FPGA 推理加速器的做法，单用户时能比 16 位的 GPU 省几倍电，但卡在 FPGA 卡的显存带宽上。
干脆不读（权重放在片上，或者焊进电路）：速度能高出一两个数量级，但芯片要装得下整个模型，FPGA 只装得下小模型，大模型要靠成百上千块芯片或者专门流片。

小结

decode 时芯片在等什么？ 等权重。每生成一个 token 要把全部权重从显存读一遍，每个权重只用一次，单用户时乘法器 99% 以上的时间闲着。批处理能让多个 token 共用一次读取，这是 GPU 服务大模型的基本做法。
专用电路能省在哪？ 运算本身只要几 pJ，取指令约 70 pJ，从 DRAM 取数 1–2 nJ。专用电路省的是指令和数据搬运：计算顺序写死、位宽按需、数据不出芯片。
FPGA 流水线效果如何？ FlightLLM 在 U280 上跑 LLaMA2-7B，3.5 bit 权重加稀疏，带宽利用率 65.9%，能效是 GPU 的 3.8 到 6 倍，单用户场景下每 token 也更便宜。
能降低成本吗？ 要看场景。GPU 也压到 4 bit 时，单用户的成本差不多；用户一多，GPU 靠批处理把成本压低一个数量级，FPGA 卡在 460–820 GB/s 的显存带宽和一万个上下的 DSP 上。边缘、低延迟、功耗受限时 FPGA 有优势，云端大批量服务时 GPU 更便宜。
把权重搬进芯片呢？ 片上存储快得多，3.7 亿参数的三值模型在两块 U280 上能跑到每秒 16300 个 token，但一块 FPGA 的片上存储只装得下两亿权重左右。
把权重焊进电路呢？ 我们的综合实验里，写死权重比可改省约 3 倍面积，三值写死比 8 位可改省 17 倍；但 8B 模型按这样算要一万多块 FPGA。这条路的终点是 ASIC（Taalas HC1），FPGA 适合做它的原型和小模型的载体。

想自己试的话，综合实验只需要 yosys 和 Python：gen_dot.py 生成六种点积写法，run_synth.sh 逐个综合并统计查找表，改一下点积长度或权重位宽就能看到面积怎么变³。