上一篇把镜头放进芯片内部：矩阵单元、SRAM、HBM、NoC、DMA、低精度和编译器。这些单元为什么突然重要，答案不在芯片里，在模型怎么工作。

模型先把句子切成 token，再把 token 变成向量，然后一层一层做 Transformer 计算。芯片只是把这一路的计算和搬运接住。

这一篇慢下来，补模型这层地基：token 是什么，Transformer 一层在干什么，Q/K/V 为什么非有不可，最后一个字又是怎么被选出来的。

一、一条链，五个台阶

图｜前三篇关键概念连成一条链：文字到 token，token 到向量，层里加工，落到芯片，最后体现在指标上

先说一句能用一整篇的话：用户看到的是文字，模型看到的是 token 和向量，模型忙的是矩阵乘法和注意力，芯片吃力的是算、存、搬、排队同时发生。

你在手机上敲一句「DeepSeek 为什么要做推理芯片？」。人看到的是中文句子，模型看到的第一步是一串 token。

token 是模型眼里的字块。可能是一个汉字，可能是半个词，可能是标点、空格，也可能是代码里的一段符号。tokenizer 干两件事：切，然后编号。detokenizer 反过来，把模型吐出来的编号拼回人能读的字。

这一步为什么跟芯片有关。计费、排队、缓存、显存占用、计算量，最后都按 token 结算。输入长，要读的 token 多；输出长，要一轮一轮生成的 token 多。前面讲「一百万 token 花多少钱」，不是造了个新单位，是 token 本来就是推理服务的生产单位。

编号本身不能拿来理解。模型查一张表，把每个编号换成一长串数字，这一步叫 embedding。那串数字就是向量。

向量可以理解成模型内部的坐标。一个词在人眼里是一个词，在模型里是几百上千个数。没有哪一位能翻译成一个具体的中文意思，但整体会记下它和其他词的关系。「芯片」「算力」「HBM」「成本」进去以后，各是一串不同的数。接下来发生的事，就是让这些数在很多层里反复互相影响。

参数和权重。参数是训练留下来的一大堆数字，权重矩阵是其中很大的一类。推理时模型不重新学习，它拿输入向量去乘这些已经训好的矩阵。推理芯片绕不开矩阵乘法，原因就在这一步。

二、Transformer 是四十个车间

图｜Transformer 一层在做什么：输入向量、Attention、Norm 与残差、FFN 或 MoE、交给下一层

先把关系摆正。Transformer 是一整套架构，Attention 是里面最关键的一个模块。Transformer 包含注意力，注意力不等于 Transformer。只讲 Attention，等于只讲这座工厂里最忙的一台机器，前馈网络、归一化、残差、位置处理、输出投影都还没算。

一句话切成 token，每个 token 变成一串数，这些数一层一层往前走。每一层干两类活：先让每个 token 看上下文，判断该参考谁；再把取回来的信息加工一遍，交给下一层。

第一类活主要由 Attention 做。它回答的问题是：当前这个 token 要理解自己，该看前面哪些 token。

第二类活由 MLP、FFN 或者 MoE 专家做。可以先叫它们加工台。Attention 把上下文取回来，加工台把每个 token 的数重新整理一遍。

一层的顺序大致是这样：输入向量带着位置信息进来；Attention 让 token 之间交换上下文；残差把原来的信息接回来，免得深层里丢掉；Norm 把数值尺度压稳，免得越算越飘；MLP、FFN 或 MoE 再做一次更强的非线性加工；再过一次残差和 Norm，交给下一层。

非线性加工不用想复杂。Attention 负责查资料，MLP 或 MoE 负责消化资料。资料拿回来了，还得变成下一步更好用的表示。

四十层就是四十个车间，同一句话连着走四十遍。第一层出来的不是答案，是一版更好的中间表示；第二层接着整理；后面每一层继续修、补、压。大模型不是一句话一次想明白，是在很多层里重复同一类动作。

位置得单独说。模型眼里是一堆向量，没有位置信息，它不知道「DeepSeek」在前、「推理芯片」在后，也不知道哪个词该先出现。位置编码就是告诉它顺序。

聊天模型还有一条硬限制：生成下一个 token 时不能偷看未来。现在在写第 20 个 token，就只能看第 1 到第 19 个。这个限制靠 mask 做，mask 是一块遮板，把未来的位置盖住。

三层关系记牢：Transformer 是架构，Attention 是层里负责看上下文的模块，Q/K/V 是 Attention 里面用来完成匹配和取数的三种向量。这三件不是平级的东西。

听着像算法，落到芯片上全是硬件问题。Attention 和 MLP 都变成大批矩阵乘法，中间结果在 SRAM、HBM、NoC 之间来回搬，Norm、Softmax、采样这些小块算子还会把整齐的大矩阵节奏打断。所以推理芯片不能只看 TOPS。Transformer 的工作方式决定它要会算，也要会存、会搬、会排队。

三、Attention：Q 负责问，K 负责被找，V 负责给

图｜Q、K、V 和注意力机制：问、索引、权重、取内容，最后落成 KV Cache

大语言模型里最常见的是 Self-Attention，自注意力。「自」是说同一段文本里的 token 互相看，不是去查外部资料。

一句话理解：Attention 让每个 token 按比例参考其他 token。

看这句：「DeepSeek 发布模型后，它的推理成本下降了。」这里的「它」指谁，人会自然回头找「DeepSeek」或者「模型」。模型不会突然明白，它要把「它」这个 token 和前面所有 token 做一轮匹配，算出哪些位置更值得参考。

匹配不是找相同的字，比的是向量关系。把每个 token 变成一串数，再用数之间的相似度判断谁和谁更有关。

所以 Attention 的核心不是平均看所有人，是有重点地看。

可以想成开会。每个 token 是参会人。轮到某个 token 说话，它不会把所有人的话同等对待，而是按当前问题判断：谁的信息有用，谁可以少听。听多少，就是注意力权重。

开会要有三样东西。我想问什么；别人身上有没有线索；真被选中了，能给我什么内容。这三样就是 Q、K、V。

Q 是 Query，当前 token 拿着的问题：我要找什么信息。

K 是 Key，上下文里每个 token 贴的索引标签：我这里有什么线索。

V 是 Value，资料卡里真正的内容：你选中我，就把这份拿走。

K 和 V 来自同一个 token，用法不同。K 用来被匹配，V 用来被取。像一本书的目录和正文：目录帮你决定翻不翻到这一页，正文才是你真正读的东西。

流程五步。当前 token 生成 Q；上下文的 token 各生成 K；Q 和所有 K 做匹配，得出一排分数；分数过 mask 和 Softmax，变成一组比例；按比例加权读 V，得到当前 token 更新后的表示。

mask 挡不该看的位置。生成答案时，未来位置要被盖掉。

Softmax 把分数变比例。三个位置可能变成 70%、20%、10%，模型就知道第一个多参考，第二个少参考，第三个更少。

最后不是只取一个人的信息，是把多个位置的 V 按比例混起来。混完的结果，就是当前 token 的新表示。

这一步看着像在理解语言，底层是矩阵乘法和内存读写。上下文越长，要匹配的位置越多；并发越多，要存要读的历史越多。Decode 阶段老被 KV Cache、HBM 带宽和调度拖住，根子在这儿。

写正式一点。同一批输入向量 X 分别乘三组权重，得到 Q、K、V。

Q = X × Wq　　K = X × Wk　　V = X × Wv

三行都是矩阵乘法。Wq、Wk、Wv 是训练留下来的权重，推理时不重新学，只乘一遍。

然后 Q 和 K 做点积。点积是两串数的相似度，结果越大，说明当前 token 越该关注那个历史 token。

实际计算还会缩放，常见写法是除以根号 d，d 是向量维度。维度越高点积越大，分数一极端，Softmax 变得很尖锐，训练和推理都不稳。缩放是为了把分数拉回合适的范围。

再过 mask，过 Softmax，权重加起来等于 1，最后加权求和 V。

串成公式就是注意力那一行最常见的写法。

Attention(Q, K, V) = Softmax(QK^T / √d + mask) × V

不用背。中文读法是：先用 Q 和 K 算该看谁，再用权重去 V 里取内容。

多头 Attention 是同时从几个角度查资料。一个头盯语法，一个头盯远距离指代，一个头盯代码结构。几个头算完拼起来，再过一次输出投影，交给后面的 MLP 或 MoE。

对芯片来说，多头意味着更多矩阵、更麻烦的数据排布、更多中间结果。到了 Decode，新 token 只算自己的 Q，却要读历史上所有 token 存下来的 K 和 V。

KV Cache 就是从这儿来的。

Prefill 阶段把输入上下文里的 K 和 V 算出来存下；Decode 每出一个新 token，用它的 Q 去匹配历史 K，再按权重读历史 V。

为什么不叫 QKV Cache：历史 K 和 V 后面每一步都要用，所以要缓存；新 token 的 Q 每步现算，不用长期存。

这句得记住：Attention 让模型看懂上下文，KV Cache 让模型不用每次重算上下文，代价是 HBM 的容量和带宽压力变大。

Q/K/V 不是论文里的装饰词。它们直接决定了推理芯片为什么得盯矩阵乘法、SRAM、HBM、NoC、KV 管理和 Prefill/Decode 调度。

四、GEMM、TOPS，和那道屋顶线

GEMM 是通用矩阵乘法，一大张数字表乘另一大张数字表。

模型里 Q/K/V 投影、输出投影、FFN、MLP、专家计算，大部分最后都落成 GEMM 或类似的矩阵运算。它重复、规则、规模大，最适合交给专门的矩阵单元。

TOPS 和 FLOPS 在这一带冒出来。FLOPS 是每秒浮点运算次数，TOPS 是每秒万亿次操作，常用来标低精度整数或混合精度。它们像发动机的最高转速，不是路上真实的速度。

峰值高不等于跑得快。矩阵单元要吃数据，权重、激活、KV 送不到，乘法器就干等。

Roofline 缩成一句话：

能跑多快 = min（算得有多快，数据送得有多快）

写成上界：

可达到性能 ≤ min（计算峰值，算术强度 × 可持续内存带宽）

算术强度是每搬一字节数据，能顺手做多少次计算。Prefill 矩阵大，数据容易复用；Decode 一轮只出一个 token，更容易被带宽卡住。

五、Prefill 读题，Decode 写字，最后一步是选字

用户把问题发来，模型先把输入整体读一遍，这叫 Prefill，像先读题。

Prefill 输入 token 多，矩阵大，权重能被复用多次，矩阵单元容易忙起来。

读完题开始一个字一个字往外写，这叫 Decode，像逐字答题。

Decode 每轮通常只确认一个新 token，但它要回头看历史。历史越长，要读的 K/V 越多。瓶颈就从算不动，变成读不动。

所以上一篇要讲调度。长 Prefill 堵住 Decode，用户会看到答案突然停住；Decode 那边 HBM 或 KV 吃紧，字与字之间的间隔就变长。

几个指标在这儿出现。TTFT 是第一个 token 出来要多久，点完发送等第一句话，这个最明显。ITL 是后面 token 之间的间隔，决定输出顺不顺。P99 是最慢那 1% 请求的延迟，线上不能只看平均数，用户骂的往往是最慢那批。SLA 是服务承诺，goodput 是满足 SLA 之后真正有效的吞吐。无限排队能把 token/s 堆上去，不等于体验好。

还有最后一步：模型怎么决定下一个字块是哪个。

最后一层出来仍是一串向量。模型拿它乘一组输出权重，得到词表里每个 token 的分数，这些分数叫 logits。

词表是模型能选的候选清单，汉字、英文片段、标点、空格、代码片段都在里面。logits 越高，越倾向选它。

然后做概率转换和采样。temperature 放大或压低随机性，温度低更保守，温度高更容易选到偏门的 token。top-k 只在分数最高的 k 个里选，top-p 只在累计概率够高的一小堆里选，贪心解码干脆直接拿最高分。

这一步也和芯片有关。输出投影本身是一次大矩阵乘法，词表很大时照样吃算力和带宽；采样、停止词判断、格式约束、安全规则落在 Serving 系统。它通常不是最大瓶颈，但做粗了流式输出会卡，尾延迟也会难看。

最后 detokenizer 把选出来的 token 拼回文字，前端才看到字一个个跳出来。

六、KV Cache 和三种少存的办法

KV Cache 存的是已经算好的历史 K 和 V。

没有它，每生成一个新 token，都要把前面所有历史重算一遍，慢到没法用。

有了它，Prefill 先把历史 K/V 存起来，Decode 每轮只算新 token 的 Q，再去读历史 K/V。省了计算，多了内存占用和读写压力。

简化成一行：

KV Cache 大小 ≈ 层数 × 上下文长度 × KV 维度 × 2 × 每个数字字节数 × 并发数

这行不是拿去精算某个模型。真实模型还有 GQA、MQA、MLA、量化、分页、分片和压缩。

但它说明一件事：上下文越长，并发越高，KV Cache 越容易把 HBM 占满。

GQA 是多组 Query 共享较少的 K/V；MQA 更进一步，让更多头共一份 K/V；MLA 是 DeepSeek 那条线上更激进的压缩，用更低维的表示减小 KV 压力。细节不用先背，目标都一样：少存一点，少读一点。

PagedAttention 干的是分页。不给每个请求预留一大块连续显存，把 KV 切成块，用块表管。浪费少了，请求进出、共享前缀、回收空间都方便。

FlashAttention 干的是少走远路。别把巨大的 Attention 中间表写回 HBM 再读回来，切成小块，在 SRAM 里边读边算。它不改注意力的数学结果，只降搬运次数。

两个方向说的是同一件事：推理芯片真正难的，不只是算得快，还要少走远路、少搬重复数据。

七、片上那六个词

图｜SRAM、HBM、NoC 和 DMA：算之外，芯片还要把数据在正确的时间送到正确的地方

SRAM 是芯片内部很近的小工作台。容量小，速度快，面积贵。放当前 tile、部分和、热点权重、一小段 KV。

HBM 是封装内的高速大仓库。容量比 SRAM 大得多，带宽也高，但仍然更远，贵，难封装，供应还紧张。

NoC 是片上网络，芯片内部的道路系统。矩阵单元、SRAM、HBM 控制器、向量单元、控制核，都得从这条路上走。

DMA 是专门搬货的。HBM 到 SRAM，SRAM 回 HBM，它负责成批搬，让计算单元别亲自干等。

tile 是分块。大矩阵塞不进片上存储，编译器把它切成小块，一块一块搬进来算。

bank 是存储分区。SRAM 分成多个 bank 好并行读写，多个请求同时打到同一个 bank 就冲突，速度掉下来。

这几个词一通，上一篇的架构就清楚了：矩阵单元负责算，SRAM 负责近处复用，HBM 负责容量和带宽，NoC 负责片内搬，DMA 负责批量搬，编译器负责安排谁什么时候去哪。

八、MoE、低精度，和软件那层

MoE 是混合专家。工厂里排很多专家工位，每个 token 只去少数几个，不是全部跑一遍。

好处是省计算，代价是路由、排序、token dispatch、all-to-all 通信和专家负载均衡。

all-reduce、all-gather、all-to-all 是多卡通信里的三个常见动作。all-reduce 是几张卡都算完，把结果汇成一份；all-gather 是每张卡交出一部分，最后大家都拼齐；all-to-all 是每张卡给其他卡发不同的数据，MoE 分发专家时最常撞上。

低精度是另一条线。FP16、BF16、FP8、INT8、INT4 都是数字格式，位数越少，存得越省，带宽压力越小，矩阵单元理论上也能做得更密。

但不能乱用。权重可以低精度，激活可以低精度，通信可以低精度，累加往往还得更高精度。不然误差一层层攒，答案质量就掉。

编译器在这儿像排程员。它决定算子能不能融合，矩阵怎么分块，数据放哪个 bank，DMA 什么时候搬，哪些中间结果留片上，哪些必须写回 HBM。

所以「芯片支持 Transformer」这句话太粗。真要问的是：支持哪些 Attention 变体，支持哪些低精度格式，KV 怎么管，MoE 怎么通信，编译器能不能把真实模型跑顺。

RTL 是寄存器传输级描述。芯片设计师写的硬件逻辑草图，但它不是普通软件代码，它描述的是每个时钟周期怎么传数、怎么算、怎么存状态。

ISA 是指令集架构，定义软件能对硬件下什么命令。芯片有自己的矩阵指令、DMA 指令、同步指令，编译器就得把模型算子翻成这些命令。

kernel 在这儿不是操作系统内核，是一个高性能算子程序，比如一个 GEMM kernel、一个 Attention kernel。它决定某个算子在具体芯片上到底怎么跑。

runtime 负责调度 kernel、管显存、处理同步、分配缓存、上报错误。driver 让操作系统、框架和硬件能对话。

这几层不成熟，参数再漂亮也进不了生产。客户不是跑一次 demo，是要一直上线模型、升版本、定位错、恢复故障。

九、一条请求把前面几篇串起来

图｜一条请求怎样落到硬件和服务指标：读题、逐字输出、选字、调度，最后看线上指标

拿一条请求走一遍。用户上传一份三万字合同，让模型总结风险。

请求进网关，鉴权、限流、路由先过一遍。tokenizer 把合同切成 token，输入很长，Prefill 会变重。

token 变成向量，进多层 Transformer。每层生成 Q、K、V，用 Attention 回看上下文，再用 MLP 或 MoE 加工。

Prefill 把历史 K/V 写进 KV Cache。合同越长，KV 越大；同时在线的人越多，HBM 越容易被占满。

Decode 开始逐字出答案，每一轮新 token 都要读历史 K/V。小批量 Decode 卡住，常常不是 GEMM 算不过来，是 HBM 带宽、KV 管理或者 NoC 通信跟不上。

模型用了 MoE，router 就得给 token 选专家。专家分散在几张卡上，token dispatch 就变成 all-to-all。某个专家太热，尾延迟立刻难看。

编译器把 Q/K/V、GEMM、Softmax、Norm、量化翻成 kernel 和硬件指令，runtime 和 Serving 系统再管采样、停止词、格式约束和流式返回。DMA 搬数据，SRAM 尽量留住热点，NoC 管片内运输。

Serving 那边继续盯 TTFT、ITL、P99、错误率和 goodput。单位 token 成本，只有在这些指标达标以后才有意义。

这条链把前五篇串起来了。第一篇讲成本，因为 token 是生产单位，账最后落到每百万 token。第二篇讲服务系统，排队、批处理、KV 管理、P/D 解耦决定芯片有没有被喂饱。第三篇讲芯片内部，矩阵单元、SRAM、NoC、HBM、低精度、编译器得一起配平。这一篇补模型，是为了后面讲制造、产业链和公司时，判断不悬空。

十、一张词表

这些词后面还会反复出现。不用背英文，记住它对应哪个生产环节就够了。

表 1 · 从上往下读，基本就是一条从文字到芯片的链

十一、结论

把一个词讲清楚不难，难的是把词连起来。

文字变 token，token 变向量，Transformer 反复做 Attention 和矩阵计算，KV Cache 存住历史，Prefill 读题，Decode 写字，logits 和采样选出下一个 token，detokenizer 再把它们拼回文字。芯片在这一整条链上做配平：算力、存储、带宽、通信、软件。

写这类文章最容易掉进的坑，是把缩写堆成碑。Transformer、QKV、GEMM、NoC、SRAM、HBM 排成一排，看着很专业，读者从第二段就掉线了。

反过来也一样。只讲比喻，讲完读者还是不知道一颗芯片贵在哪、卡在哪。比喻可以入门，砖得是真的。