AI Infra Foundation

Transformer 与大模型基础

整体架构 · Embedding/位置编码/Tokenizer · Attention · 训练稳定性 · 面试高频题

transformerattentionembeddingtokenizerinterview

Module Switcher

Transformer 内容模块

架构与输入2

核心机制2

计算分析4

面试2

内容模块

整体架构

基础★☆☆⏱ 15 min

一句话结论

Transformer 的核心是用 self-attention 在序列内建立全局依赖，再用 FFN 做逐 token 非线性变换。

复习定位

维度	内容
所属模块	Transformer 与大模型基础
章节类型	概念类
解决问题	围绕 Transformer 架构、输入表示、Attention、训练稳定性和面试高频题建立大模型基础答案。
面试抓手	先讲整体数据流，再讲每层组件和残差归一化。

架构图

Transformer model architecture from Attention Is All You Need, Figure 1 — Transformer 原始 Encoder-Decoder 架构图。来源：Vaswani et al., Attention Is All You Need, Figure 1（arXiv:1706.03762）。

这张图是原论文的标准架构图，适合建立全局结构；后面的内容会补充现代 Decoder-only 大模型和 Pre-LN/RMSNorm 等工程变体。

核心概念

Transformer 不是一个“Attention 模块”，而是一套可堆叠的序列建模骨架。它把每个 token 表示沿着两条路径推进：

残差主干路径：保存并累积 token 表示，让深层网络仍然可训练。
Attention 混合路径：让 token 之间交换信息，建立上下文依赖。
FFN 变换路径：对每个 token 独立做非线性投影，提供容量和知识存储。
归一化路径：控制激活尺度，稳定训练和长层数堆叠。

系统链路

文本输入

tokenizer 切分成 token id

Embedding

token id 查表得到向量，叠加位置或旋转位置信息

Attention

通过 Q/K/V 让 token 间交换信息

Residual + Norm

保持梯度通路并稳定激活分布

FFN

对每个 token 独立扩维、激活、降维

LM Head

Decoder-only 模型投影到词表并预测下一个 token

关键机制

Encoder、Decoder 和 Decoder-only 的边界

架构	注意力可见性	代表模型	适合任务	系统含义
Encoder-only	双向，任意 token 可看全句	BERT	分类、抽取、embedding	没有自回归 decode，推理通常一次前向完成
Encoder-Decoder	Encoder 双向，Decoder 因果 + cross-attn	T5、原始 Transformer	翻译、摘要、seq2seq	Decoder 每步还要读 Encoder memory
Decoder-only	因果 mask，只能看历史 token	GPT、LLaMA	生成、对话、代码	当前 LLM serving 主流，KV cache 是核心状态

Pre-LN 与 Post-LN

原始 Transformer 更接近 Post-LN：

$$ x_{l+1} = \operatorname{LayerNorm}(x_l + \operatorname{Sublayer}(x_l)) $$

现代大模型更常用 Pre-LN 或 RMSNorm 变体：

$$ x_{l+1} = x_l + \operatorname{Sublayer}(\operatorname{Norm}(x_l)) $$

Pre-LN 的好处是梯度主干更直接，深层训练更稳定；代价是最后通常还需要一个 final norm，并且不同实现会影响激活尺度和初始化策略。

Attention 和 FFN 的职责不同

模块	做什么	资源特征	深度理解
Attention	token 间通信，决定“谁看谁”	prefill 有 $O(n^2d)$，decode 读 KV cache	更像动态路由和上下文聚合
FFN / MLP	每个 token 独立变换	参数量和 FLOPs 通常占大头	更像逐 token 的非线性记忆库
Norm	控制尺度	算子小但常 memory-bound	保证深层堆叠的数值稳定
Residual	保留主干信息	几乎纯读写	提供梯度高速通道

深度追问

追问	回答抓手
为什么 Attention 本身不懂顺序？	Attention 对 token 集合是置换等变的，必须注入位置编码或 RoPE。
为什么 Decoder 需要 causal mask？	自回归训练时不能看未来 token，否则 teacher forcing 会泄漏答案。
为什么现代 LLM 多是 Decoder-only？	统一输入输出为 next-token prediction，训练数据形式简单，推理状态可用 KV cache 增量维护。
为什么 FFN 很重要？	参数和计算量大，提供模型容量；很多事实知识和非线性变换能力在 FFN 中体现。
为什么 Transformer 适合 GPU？	大部分核心算子是 GEMM/attention block，可批量并行；但 decode 阶段会转向 memory-bound。

关联模块

GPU 硬件与资源共享：提供硬件、显存、互联和利用率诊断基础。
LLM 推理系统 / 分布式训练：提供大模型系统中的实际落点。
Kubernetes / 调度与集群：提供平台、资源和多租户治理语境。
专题综合题 / 论文工作：把基础知识组织成可复述的方案和项目叙事。

内容模块

输入处理

基础★☆☆⏱ 15 min

一句话结论

输入侧要把文本变成 token id，再映射为 embedding，并叠加位置信息。

复习定位

维度	内容
所属模块	Transformer 与大模型基础
章节类型	概念类
解决问题	围绕 Transformer 架构、输入表示、Attention、训练稳定性和面试高频题建立大模型基础答案。
面试抓手	区分 tokenizer、embedding、position encoding 的职责。

输入处理三件套：从文字到向量

模型不能直接吃文字，必须先把文字变成数字向量。整条链路是：

文本 →（Tokenizer）→ token →（查词表）→ input_ids →（Embedding 查表）→ 词向量 →（+ 位置编码）→ 送入第一层

记住顺序：Tokenizer 切词 → Embedding 查表变向量 → 加位置编码 → 进 Transformer block。

1. Tokenizer：怎么把文本切成 token

Tokenizer 用特定算法（如 BPE 或 WordPiece）把连续文本切成更小的单元——token。token 可以是完整单词、词根、词缀，甚至单个字符。然后在预先构建的词表（vocab）里查每个 token，映射成唯一的整数编号（token id）。最终一段文本变成一串 token id 序列，这才是模型的真正输入。

算法	核心思想	代表模型
BPE（Byte Pair Encoding）	从字符开始，反复合并出现频率最高的相邻字符对，直到词表达到设定大小	GPT 系列
WordPiece	和 BPE 类似，但合并时选「能最大提升语言模型似然」的字符对	BERT
SentencePiece	不依赖空格分词，直接在原始字节流上做，适合中文/多语言	LLaMA、T5

为什么不直接用单词或单字？用整词：词表会爆炸，且遇到没见过的词（OOV）就歇菜；用单字：序列太长、语义颗粒太碎。子词（subword）是折中：常见词当整体，罕见词拆成词根词缀，既控制词表大小又能处理生词。

2. Embedding：是什么、在哪里

模型维护一个可学习的 Embedding 矩阵，形状是 [vocab_size, hidden_size]。每个 token id 对应矩阵的一行。所谓 Embedding 就是用 token id 去这个矩阵里查表（取出对应那一行向量）。

位置：在模型最前端，紧跟 Tokenizer 之后、第一个 Transformer block 之前。
本质：就是一次查表（lookup），不是矩阵乘法。把离散的整数 id 变成稠密的连续向量。
可学习：这个矩阵是模型参数，训练中会被反向传播更新，语义相近的词向量会逐渐靠近。

一句话：Embedding = 一张可训练的查找表，把 token id 翻译成模型能理解的向量。

3. 位置编码：为什么需要、好处是什么

为什么需要：Transformer 不像 RNN 那样一个一个按顺序处理，而是一次性看全局、所有 token 并行计算。Attention 本身是「无序」的——打乱输入顺序，算出来的结果只是跟着换位置，模型分不清「猫追狗」和「狗追猫」。所以必须额外注入位置信息，让模型知道每个 token 在序列中的绝对或相对位置。

好处：

保留单词在序列中的顺序信息，让模型能区分词序不同导致的语义差异。
让模型有能力建模相对距离（谁离谁近、谁在前谁在后）。

方案	做法	特点
正弦/余弦（原文）	用不同频率的 sin/cos 函数算出固定位置向量，和 Embedding 相加	不用学习、可外推到更长序列
可学习位置编码	像 Embedding 一样维护一张可训练的位置向量表	BERT 用，简单但难外推到训练没见过的长度
RoPE（旋转位置编码）	通过旋转 Q/K 向量来编码相对位置	LLaMA 等主流大模型在用，外推性好

面试答法：因为 Transformer 用全局并行计算、没有 RNN 的天然顺序，Attention 本身对位置不敏感，所以要用位置编码把顺序信息补回来。

关联模块

GPU 硬件与资源共享：提供硬件、显存、互联和利用率诊断基础。
LLM 推理系统 / 分布式训练：提供大模型系统中的实际落点。
Kubernetes / 调度与集群：提供平台、资源和多租户治理语境。
专题综合题 / 论文工作：把基础知识组织成可复述的方案和项目叙事。

内容模块

Attention 机制

进阶★☆☆⏱ 25 min

一句话结论

Self-Attention 用 Q/K/V 计算 token 间相关性，Multi-Head 则让不同 head 学不同关系子空间。

复习定位

维度	内容
所属模块	Transformer 与大模型基础
章节类型	机制类
解决问题	围绕 Transformer 架构、输入表示、Attention、训练稳定性和面试高频题建立大模型基础答案。
面试抓手	必须讲清 QK^T、softmax、加权求和和多头拼接。

Self-Attention：核心三步

注意力的本质是「加权求和」：每个 token 输出 = 其它所有 token 的 value 的加权平均，权重由「我和你有多相关」决定。

每个 token 投影出三个向量：Q（Query，我要找什么）、K（Key，我能提供什么）、V（Value，我的实际内容）。
用 Q 和所有 K 做点积得到相关性分数，除以 √d_k 缩放，再 softmax 归一化成权重。
用权重对所有 V 加权求和，得到这个 token 的新表示。

公式：

$$ \operatorname{Attention}(Q,K,V) = \operatorname{softmax}\left(\frac{QK^\top}{\sqrt{d_k}}\right)V $$

为什么要除以 √d_k？因为维度大时点积数值会很大，softmax 会进入梯度极小的饱和区，缩放是为了稳定梯度。

Multi-Head vs Single-Head：区别和好处

Single-Head 只在一个空间里算一次注意力。Multi-Head 把 hidden_size 拆成多个并行的子空间（head），每个 head 独立算一次注意力，再把结果拼接起来过一个输出投影。

维度	Single-Head	Multi-Head
建模角度	只能学一种关注模式	每个头学不同模式（语法、语义、位置…）
表达能力	较弱	能捕获更丰富的依赖关系
计算成本	差不多（总维度不变，只是拆开算）	差不多，且天然可并行

Multi-Head 的好处：

多角度建模：每个头关注不同子空间特征，类似 CNN 里的多个卷积核。
表达能力更强：相比单头能同时捕获多种依赖。
并行性好：多个头之间互不依赖，天然并行。

注意：拆成多头不增加总参数量和计算量——总维度 hidden_size 是固定的，只是切成 num_heads 份分别算。

手撕 Multi-Head Attention（带 KV Cache）

import torch
import torch.nn as nn
import torch.nn.functional as F


class MultiHeadAttention(nn.Module):
    def __init__(self, hidden_size, num_heads):
        super().__init__()
        self.num_heads = num_heads
        self.head_dim = hidden_size // num_heads
        self.q_linear = nn.Linear(hidden_size, hidden_size)
        self.k_linear = nn.Linear(hidden_size, hidden_size)
        self.v_linear = nn.Linear(hidden_size, hidden_size)
        self.o_linear = nn.Linear(hidden_size, hidden_size)

    def forward(self, hidden_state, causal_mask=None,
                past_key_value=None, use_cache=False):
        batch_size = hidden_state.size(0)
        query = self.q_linear(hidden_state)
        key   = self.k_linear(hidden_state)
        value = self.v_linear(hidden_state)

        # 多头拆分: [B, S, H] -> [B, num_heads, S, head_dim]
        query = query.view(batch_size, -1, self.num_heads, self.head_dim).transpose(1, 2)
        key   = key.view(batch_size,   -1, self.num_heads, self.head_dim).transpose(1, 2)
        value = value.view(batch_size, -1, self.num_heads, self.head_dim).transpose(1, 2)

        # 拼接 KV cache: 把历史的 key/value 接到前面
        if past_key_value is not None:
            past_key, past_value = past_key_value
            key   = torch.cat([past_key,   key],   dim=2)
            value = torch.cat([past_value, value], dim=2)

        new_past_key_value = (key, value) if use_cache else None

        # 注意力打分 + 缩放
        attention_scores = torch.matmul(query, key.transpose(-1, -2)) \
                           / torch.sqrt(torch.tensor(self.head_dim, dtype=torch.float32))

        # 因果掩码: 把不能看的位置加上一个极大负数, softmax 后趋近 0
        if causal_mask is not None:
            attention_scores += causal_mask * -1e9

        attention_probs = F.softmax(attention_scores, dim=-1)
        output = torch.matmul(attention_probs, value)

        # 合并多头: [B, num_heads, S, head_dim] -> [B, S, H]
        output = output.transpose(1, 2).contiguous() \
                       .view(batch_size, -1, self.num_heads * self.head_dim)
        output = self.o_linear(output)

        return (output, new_past_key_value) if use_cache else output

手撕代码逐段讲解（面试要能口述）

四个 Linear：q/k/v 把输入投影成查询、键、值；o_linear 是多头拼接后的输出投影。
view + transpose：把 [B, S, hidden] 切成 [B, num_heads, S, head_dim]，让每个头独立算。transpose(1,2) 是为了把 head 维提到前面，方便 batch 矩阵乘。
KV cache：自回归生成时，前面 token 的 K/V 不变，缓存下来避免重复计算，每步只算新 token 的 Q。这是推理加速的关键。
除以 √head_dim：缩放点积，防止 softmax 饱和、梯度消失。
causal_mask * -1e9：给「未来位置」加一个极大负数，softmax 后这些位置权重≈0，实现「不能看未来」。
合并多头：transpose 回来、contiguous（保证内存连续）、view 拼回 hidden_size，最后过 o_linear。

易错点：contiguous() 不能省——transpose 后内存不连续，直接 view 会报错。

Attention vs Feed Forward：各自的作用

模块	作用	一句话
Attention	在 token 之间做信息交互，捕获序列依赖关系	「谁该关注谁」——做混合/通信
Feed Forward (FFN)	对每个 token 独立做非线性变换，提升表达能力	承担「知识存储」，做加工/记忆

形象比喻：Attention 是「开会，大家交换信息」；FFN 是「会后各自回去消化、加工」。一层 Transformer 就是「交流一次 + 各自加工一次」。研究还发现大模型的事实知识大量存储在 FFN 层里。

关联模块

GPU 硬件与资源共享：提供硬件、显存、互联和利用率诊断基础。
LLM 推理系统 / 分布式训练：提供大模型系统中的实际落点。
Kubernetes / 调度与集群：提供平台、资源和多租户治理语境。
专题综合题 / 论文工作：把基础知识组织成可复述的方案和项目叙事。

内容模块

训练稳定性

进阶★☆☆⏱ 15 min

一句话结论

Transformer 训练稳定性依赖残差、归一化、初始化、warmup、梯度裁剪和混合精度。

复习定位

维度	内容
所属模块	Transformer 与大模型基础
章节类型	概念类
解决问题	围绕 Transformer 架构、输入表示、Attention、训练稳定性和面试高频题建立大模型基础答案。
面试抓手	回答时把梯度稳定、数值稳定和吞吐优化分开。

先搞懂：什么是梯度消失/爆炸

深层网络靠反向传播更新参数，梯度要从最后一层「逐层相乘」传回最前面。

梯度消失：每层梯度都小于 1，连乘后越传越小，最后趋近 0 → 浅层参数几乎不更新，学不动。
梯度爆炸：每层梯度都大于 1，连乘后越传越大 → 参数剧烈震荡、loss 变 NaN，训练发散。

大模型层数很深（几十上百层），这个问题尤其严重，所以需要一整套技术来稳住训练。

大模型怎么处理（六个手段，按重要性记）

手段	解决什么	原理
残差连接（Residual）	梯度消失	`y = x + F(x)`，梯度有一条「直通车」绕过 F 直达浅层，不会被连乘衰减
LayerNorm / RMSNorm	激活值不稳定	对每层激活做归一化，稳定分布，让梯度幅度可控
合理初始化（Xavier/Kaiming）	初始梯度过大/过小	让各层输入输出的方差保持一致，避免一开始就消失或爆炸
梯度裁剪（Gradient Clipping）	梯度爆炸	梯度范数超过阈值就等比例缩小，硬性封顶
学习率 warmup + decay	训练初期发散	先用小学习率慢慢升（warmup），再逐渐衰减，避免一开始步子太大
混合精度 + Loss Scaling	FP16 梯度下溢	FP16 表示范围小，小梯度会变 0；把 loss 乘大再算梯度，更新前再除回来

残差连接为什么最关键

残差是 Transformer 能堆几十层的头号功臣。反向传播时 y = x + F(x) 的梯度是 1 + F'(x)，那个常数 1 保证了即使 F'(x) 很小，梯度也不会衰减到 0——相当于给梯度修了一条高速公路，可以直通传回浅层。

面试金句：残差连接把「乘法传播」变成了「加法传播」，从根本上缓解了梯度消失。

LayerNorm vs BatchNorm vs RMSNorm

方法	归一化维度	为什么用在这
BatchNorm	对一个 batch 内同一特征归一化	依赖 batch 统计量，序列长度可变、batch 小的时候不稳定，NLP 一般不用
LayerNorm	对单个样本的所有特征归一化	不依赖 batch，对每个 token 独立做，原始 Transformer 用
RMSNorm	只用均方根缩放，不减均值	比 LayerNorm 少算一步、更快，效果相当，LLaMA 等主流大模型用

另外还有 Pre-Norm vs Post-Norm：原文是 Post-Norm（先残差后归一），现代大模型多用 Pre-Norm（先归一再进子层，x + F(LN(x))），训练更稳定、更容易收敛。

关联模块

GPU 硬件与资源共享：提供硬件、显存、互联和利用率诊断基础。
LLM 推理系统 / 分布式训练：提供大模型系统中的实际落点。
Kubernetes / 调度与集群：提供平台、资源和多租户治理语境。
专题综合题 / 论文工作：把基础知识组织成可复述的方案和项目叙事。

内容模块

FLOPs 逐步推导

进阶★☆☆⏱ 18 min

一句话结论

单层 Transformer FLOPs 可以拆成线性层的 $nd^2$ 项和 attention 的 $n^2d$ 项。

复习定位

维度	内容
所属模块	Transformer 与大模型基础
章节类型	机制类（含公式）
解决问题	围绕 Transformer 架构、计算量、Roofline、算子瓶颈和大模型推理/训练性能建立深度答案。
面试抓手	记住矩阵乘 $2MNK$，再数 QKV、输出投影、FFN 和两次 attention matmul。

先不用一上来背公式，而是把单层 Transformer 的计算量理解成两类：一类是各种线性层带来的 $nd^2$ 项，另一类是 Attention 两次大矩阵乘带来的 $n^2d$ 项。最终结论是：

$$ \text{总FLOPs} = 24nd^2 + 4n^2d $$

下面一步步推出它。

1. 单层主要算两件事

一个 Transformer Encoder Layer 主要包括 Self-Attention 和 FFN（前馈网络）两部分，所以：

$$ \text{总FLOPs} = \text{Attention 的 FLOPs} + \text{FFN 的 FLOPs} $$

2. 先理解矩阵乘法为什么是 $2MNK$

两个矩阵相乘：

$$ A_{M \times N} \times B_{N \times K} = C_{M \times K} $$

输出矩阵 $C$ 有 $M \times K$ 个元素，每个元素是一次长度为 $N$ 的向量点积：

$$ c_{ij} = a_{i1}b_{1j} + a_{i2}b_{2j} + \dots + a_{iN}b_{Nj} $$

一个元素约需 $N$ 次乘法 + $N$ 次加法 = $2N$ 次运算，共 $M \times K$ 个元素，所以：

$$ \text{FLOPs} = 2MNK $$

这是后面所有推导的基础。

3. Attention 部分

设输入 $X \in \mathbb{R}^{n \times d}$，其中 $n$ 是 token 数，$d$ 是每个 token 的向量维度。

3.1 QKV 投影：$6nd^2$

输入 $X$ 分别乘三个权重得到 Q、K、V：

$$ Q = XW_Q,\quad K = XW_K,\quad V = XW_V $$

其中 $X$ 是 $n \times d$，$W_Q, W_K, W_V$ 是 $d \times d$。一次投影是 $n \times d$ 乘 $d \times d$，按 $2MNK$（$M=n, N=d, K=d$）得 $2nd^2$。三次合计：

$$ 3 \times 2nd^2 = 6nd^2 $$

3.2 计算 $QK^\top$：$2n^2d$

Q 是 $n \times d$，$K^\top$ 是 $d \times n$，相乘得到 $n \times n$ 的注意力矩阵。按 $2MNK$（$M=n, N=d, K=n$）：

$$ 2 \times n \times d \times n = 2n^2 d $$

$n^2$ 的来源很关键：每个 token 都要和每个 token 算相关性，产生一个 $n \times n$ 矩阵。

3.3 注意力权重乘 V：$2n^2d$

Softmax 后的权重矩阵是 $n \times n$，V 是 $n \times d$，相乘得到 $n \times d$。按 $2MNK$（$M=n, N=n, K=d$）：

$$ 2 \times n \times n \times d = 2n^2 d $$

3.4 输出投影：$2nd^2$

Attention 输出后再过一个输出线性层，$n \times d$ 乘 $d \times d$，得 $2nd^2$。

3.5 Attention 总和

步骤	FLOPs
QKV 投影	$6nd^2$
$QK^\top$	$2n^2d$
权重乘 V	$2n^2d$
输出投影	$2nd^2$

$$ \text{Attention} = 6nd^2 + 2n^2d + 2n^2d + 2nd^2 = 8nd^2 + 4n^2d $$

4. FFN 部分

FFN 是两层线性层，维度变化 $d \rightarrow 4d \rightarrow d$。

4.1 第一层 $d \rightarrow 4d$：输入 $n \times d$，权重 $d \times 4d$：

$$ 2 \times n \times d \times 4d = 8nd^2 $$

4.2 第二层 $4d \rightarrow d$：输入 $n \times 4d$，权重 $4d \times d$：

$$ 2 \times n \times 4d \times d = 8nd^2 $$

4.3 FFN 总和：

$$ \text{FFN} = 8nd^2 + 8nd^2 = 16nd^2 $$

5. 合起来

$$ \text{Attention} = 8nd^2 + 4n^2d,\qquad \text{FFN} = 16nd^2 $$

$$ \text{总FLOPs} = 8nd^2 + 4n^2d + 16nd^2 = 24nd^2 + 4n^2d $$

6. 一句话理解

> Transformer 单层的计算量由两部分组成：线性层带来的 $nd^2$，和 Attention 两次大矩阵乘带来的 $n^2d$。

$24nd^2$：来自 QKV 投影、输出投影、FFN；
$4n^2d$：来自 $QK^\top$ 和注意力权重乘 V。

当 $n \ll d$ 时线性层（$nd^2$）占主导；当 $n$ 很大时注意力的 $n^2d$ 项成为瓶颈。

最容易卡住的点：为什么 $QK^\top$ 是 $2n^2d$

如果卡在这一步，可以这样想：有 $n$ 个 query、$n$ 个 key，每个 query 都要和每个 key 算一次相似度，所以一共 $n\times n$ 个相似度；每个相似度是两个 $d$ 维向量点积，约 $2d$ 次运算；总共 $n\times n\times 2d = 2n^2d$。

这就是 Attention 对序列长度是平方复杂度（$O(n^2)$）的根本原因，也是长上下文和 FlashAttention 要解决的核心问题。

Q: 现场默写单层 Transformer 的 FLOPs，你怎么快速推？

只记一个基本公式 $2MNK$，然后数有几个矩阵乘：QKV 三次投影 + 输出投影是 4 个 $n\times d$ 乘 $d\times d$，各 $2nd^2$，合 $8nd^2$；FFN 两层是 $8nd^2 \times 2 = 16nd^2$；这两类都是 $nd^2$，合 $24nd^2$。再加注意力两次大矩阵乘 $QK^\top$ 和权重乘 V，各 $2n^2d$，合 $4n^2d$。最终 $24nd^2 + 4n^2d$。整模型再乘层数，训练含反向约再 ×3。

关联模块

GPU 硬件与资源共享：提供 SM、HBM、NVLink、MIG/MPS、利用率诊断等底层直觉。
LLM 推理系统：提供 Prefill/Decode、KV Cache、Serving Engine 和推理优化语境。
Kubernetes 核心：提供调度、资源模型、控制器和扩展机制。
分布式训练 / 调度与集群：提供多卡通信、队列、公平性、拓扑和容错背景。

内容模块

Roofline 分析

进阶★☆☆⏱ 16 min

一句话结论

Roofline 用算术强度把 Transformer 算子分成 compute-bound 和 memory-bound。

复习定位

维度	内容
所属模块	Transformer 与大模型基础
章节类型	机制类（含公式）
解决问题	围绕 Transformer 架构、计算量、Roofline、算子瓶颈和大模型推理/训练性能建立深度答案。
面试抓手	公式必须讲 FLOPs、bytes 和 ridge point。

本页只讲 Transformer 场景下怎么用 Roofline

完整的 Roofline 定义、公式、图和 VGG/MobileNet 例子统一放在 性能预测与建模 / Roofline Model。本页只回答一个问题：Transformer 里的哪些算子更可能 compute-bound，哪些更可能 memory-bound？

概念	本页用法
算术强度	判断一个 Transformer kernel 的数据复用程度
机器平衡点	A100 约 156 FLOPs/Byte，低于它通常更偏 memory-bound
优化方向	memory-bound 优先减少 HBM 读写；compute-bound 优先提高 Tensor Core 利用率

跳转记忆：模型公式和通用图看性能预测；Transformer 具体算子分类看本页。

哪些操作 compute-bound，哪些 memory-bound

操作	瓶颈	原因
大 batch 矩阵乘（QKV、FFN）	compute-bound	计算量随 batch 增长快，数据搬运增长慢，算术强度高
逐 token decode（batch 小）	memory-bound	矩阵乘退化成 GEMV，算术强度低，瓶颈是读权重带宽
Softmax、LayerNorm 等 element-wise	memory-bound	计算量相对访存量很小

串到 Prefill / Decode

阶段	计算形态	瓶颈	关键指标
Prefill	多 token 并行，大矩阵乘	compute-bound	TTFT
Decode	batch 小，GEMV，反复读权重	memory-bound	TPOT

两阶段瓶颈相反，优化手段也相反：prefill 靠 chunked prefill、提高 TensorCore 利用率；decode 靠 continuous batching 摊销权重读取、靠 KV cache 量化和 PagedAttention 降带宽与显存压力。

Q: 怎么判断一个 kernel 是 compute-bound 还是 memory-bound？

算它的算术强度（FLOPs ÷ 访存 bytes），和机器平衡点（峰值算力 ÷ 峰值带宽）比较。高于平衡点就是 compute-bound，低于就是 memory-bound。比如 A100 平衡点 ≈ 312 TFLOPS / 2 TB/s ≈ 156 FLOP/byte，而 batch=1 decode 算术强度约为 1，远低于平衡点，是典型 memory-bound。

Q: Roofline 模型在面试中怎么完整回答？

我会先定义横轴和纵轴：横轴是算术强度 FLOPs/Byte，纵轴是实际性能 FLOPs/s。然后给公式：可达性能上限等于 min(峰值算力, 峰值带宽 × 算术强度)。图上斜线是 memory roof，水平线是 compute roof，交点 ridge point 是机器平衡点。如果 kernel 落在斜线区域，优化方向是减少访存、提高数据复用、融合算子；如果落在水平线区域，优化方向是提高 Tensor Core 利用率、优化 tile、使用低精度或减少 FLOPs。

一句话：Roofline 用 FLOPs/Byte 判断 kernel 是缺数据还是缺算力。

关联模块

性能预测与建模 / Roofline Model：完整 Roofline 公式、图、硬件 ridge point 和 VGG/MobileNet 例子。
GPU 硬件与资源共享：提供 SM、HBM、NVLink、MIG/MPS、利用率诊断等底层直觉。
LLM 推理系统：提供 Prefill/Decode、KV Cache、Serving Engine 和推理优化语境。
Kubernetes 核心：提供调度、资源模型、控制器和扩展机制。
分布式训练 / 调度与集群：提供多卡通信、队列、公平性、拓扑和容错背景。

内容模块

Decode 为何 Memory-bound

精通★☆☆⏱ 18 min

一句话结论

70B FP16 batch=1 decode 的算术强度约为 $1\,\mathrm{FLOP/byte}$，远低于 A100 平衡点，因此是 memory-bound。

复习定位

维度	内容
所属模块	Transformer 与大模型基础
章节类型	机制类（含公式）
解决问题	围绕 Transformer 架构、计算量、Roofline、算子瓶颈和大模型推理/训练性能建立深度答案。
面试抓手	按计算量、访存量、算术强度三步算。

这一节用 Roofline 模型完整算清一个高频面试题：70B FP16 模型在 A100 上 decode、batch=1、每次只生成 1 个 token，为什么是显存带宽瓶颈（memory-bound）而不是算力瓶颈？ 核心是三步——算计算量、算访存量、算算术强度，再和机器平衡点比较。

1. 为什么前向 FLOPs ≈ 2 × 参数量 × token 数

生成一个 token 时，模型里的权重基本都要参与一次矩阵乘。矩阵乘里一个权重参数通常对应一次乘法 + 一次加法：

$$ 1\text{ 个参数} \approx 2\text{ FLOPs} $$

所以：

$$ \text{FLOPs} \approx 2 \times \text{参数量} \times \text{生成 token 数} $$

70B 模型生成 1 个 token：

$$ 2 \times 70 \times 10^9 \times 1 = 1.4 \times 10^{11}\text{ FLOPs} = 140\text{ GFLOPs} $$

注意这是每生成 1 个 token 的计算量。

2. 为什么访存量 ≈ 140 GB

权重是 FP16，每个参数占 $2$ bytes：

$$ 70 \times 10^9 \times 2\text{ bytes} = 140 \times 10^9\text{ bytes} \approx 140\text{ GB} $$

在 batch=1 decode 时，每生成一个 token，都要把整套权重从 HBM 显存读一遍。关键反差是：计算一个 token 只需 140 GFLOPs，但必须读 140 GB 权重。

3. 算术强度怎么算

$$ \text{算术强度} = \frac{\text{计算量 FLOPs}}{\text{访存量 bytes}} = \frac{1.4 \times 10^{11}}{1.4 \times 10^{11}} = 1\text{ FLOP/byte} $$

含义：每从显存读取 1 byte，只能做约 1 次浮点运算。这个值非常低。

4. 为什么是 memory-bound

A100：理论算力约 $312$ TFLOPS，显存带宽约 $2$ TB/s。机器平衡点：

$$ \frac{312\text{ TFLOPS}}{2\text{ TB/s}} = 156\text{ FLOP/byte} $$

含义：一个任务的算术强度要达到 156 FLOP/byte，才可能把 A100 的计算单元喂饱。而 decode batch=1 只有 $1$ FLOP/byte，远小于 156，所以算力用不满，瓶颈是：

> 显存带宽不够快，权重读得太慢，计算单元大部分时间在等数据。

结论：memory-bound。

5. 换成时间直觉更好理解

只看算力：A100 算力 $312 \times 10^{12}$ FLOPs/s，算 1 个 token 需 $1.4 \times 10^{11}$ FLOPs：

$$ \frac{1.4 \times 10^{11}}{312 \times 10^{12}} \approx 0.45\text{ ms} $$

看显存带宽：读 $140$ GB 权重，带宽 $2$ TB/s = $2000$ GB/s：

$$ \frac{140\text{ GB}}{2000\text{ GB/s}} = 0.07\text{ s} = 70\text{ ms} $$

计算只要约 $0.45$ ms，读权重要约 $70$ ms，相差两个数量级。所以实际速度主要被显存带宽限制，而不是矩阵乘算力。

6. 核心结论

项目	数值
参数量	70B
权重精度	FP16
每 token 计算量	约 140 GFLOPs
每 token 访存量	约 140 GB
算术强度	约 1 FLOP/byte
A100 平衡点	约 156 FLOP/byte
结论	memory-bound

> batch=1 decode 时，每生成一个 token，计算量相对权重读取量太少，GPU 算力用不满，主要卡在显存带宽。

7. 为什么 batch 变大能改善

batch 从 1 变成 $B$，同一份权重可以服务 $B$ 个 token。计算量约变成 $2 \times \text{参数量} \times B$，而权重读取仍近似 $\text{参数量} \times 2\text{ bytes}$，所以算术强度变成：

$$ \frac{2 \times \text{参数量} \times B}{2 \times \text{参数量}} = B\text{ FLOP/byte} $$

batch	算术强度	状态
1	约 1 FLOP/byte	严重 memory-bound
8	约 8 FLOP/byte	仍 memory-bound
64	约 64 FLOP/byte	接近平衡点
156	约 156 FLOP/byte	接近 A100 平衡点，趋向 compute-bound

更大的 batch 复用权重、提高算术强度，让任务从 memory-bound 逐渐接近 compute-bound——这就是 continuous batching 提升吞吐的根本原因。

Q: 一句话总结这道题。

70B FP16 模型 batch=1 decode 每生成 1 个 token，需约 140 GFLOPs 计算，但要读约 140 GB 权重，算术强度只有 1 FLOP/byte，远低于 A100 的约 156 FLOP/byte 平衡点，所以瓶颈是显存带宽（memory-bound），不是 GPU 算力。加大 batch 复用权重可把算术强度提到约 $B$ FLOP/byte，逐渐趋向 compute-bound。

关联模块

GPU 硬件与资源共享：提供 SM、HBM、NVLink、MIG/MPS、利用率诊断等底层直觉。
LLM 推理系统：提供 Prefill/Decode、KV Cache、Serving Engine 和推理优化语境。
Kubernetes 核心：提供调度、资源模型、控制器和扩展机制。
分布式训练 / 调度与集群：提供多卡通信、队列、公平性、拓扑和容错背景。

内容模块

逐算子 Bound 分类

精通★☆☆⏱ 18 min

一句话结论

Transformer 不是整体只有一种瓶颈，prefill/decode、GEMM/softmax/layernorm/embedding 的 bound 类型不同。

复习定位

维度	内容
所属模块	Transformer 与大模型基础
章节类型	机制类
解决问题	围绕 Transformer 架构、计算量、Roofline、算子瓶颈和大模型推理/训练性能建立深度答案。
面试抓手	按算子分类，避免“一句话说全模型 compute-bound”。

判断一个算子是 compute-bound 还是 memory-bound，核心看算术强度：

$$ \text{算术强度} = \frac{\text{FLOPs}}{\text{访存 bytes}} $$

算术强度高于机器平衡点（A100 ≈ $\frac{312\text{ TFLOPS}}{2\text{ TB/s}} \approx 156$ FLOP/byte）就 compute-bound，远低于就 memory-bound。下面把 Transformer 各算子按这个标准过一遍。

一句话记忆

大而方的矩阵乘通常 compute-bound；小 batch、单 token、逐元素操作、归一化、softmax、KV cache 读写通常 memory-bound。

Prefill：大量 token 并行，GEMM 大、权重复用充分 → 偏 compute-bound。
Decode batch=1：每次只生成一个 token，反复读权重和 KV cache → 偏 memory-bound。
Elementwise / reduction（LayerNorm、RMSNorm、Residual、RoPE、Softmax）→ 多数 memory-bound。
多卡通信（AllReduce、AllGather）→ communication-bound，不属于单卡 compute/memory 二分。

逐算子细分类（Prefill vs Decode batch=1）

组件	Prefill	Decode batch=1	说明
QKV / 输出投影	compute-bound	memory-bound（GEMV）	decode 权重复用差
FFN up/gate/down	compute-bound	memory-bound（GEMV）	FFN 参数量大，decode 读权重成本高
$QK^\top$ score	compute-bound	memory-bound	decode 扫 K cache
Attention × V	compute-bound	memory-bound	decode 扫 V cache
Softmax	memory/latency-bound	memory/latency-bound	reduction + exp，复用低
LayerNorm / RMSNorm	memory-bound	memory-bound	逐元素 + reduction
Residual add	memory-bound	memory-bound	几乎纯读写
RoPE	memory-bound	memory-bound	elementwise
激活 GELU/SiLU	memory-bound	memory-bound	可与 GEMM 融合
Embedding lookup	memory-bound	memory-bound	查表，几乎无计算
KV cache 写	memory-bound	memory-bound	纯写显存
KV cache 读	不突出	memory-bound	decode 核心瓶颈
LM head	compute / memory	多偏 memory-bound	取决于 batch/vocab
Sampling / top-k/p	latency/memory-bound	latency/memory-bound	非大矩阵乘
AllReduce / AllGather	communication-bound		多卡通信瓶颈

为什么大矩阵乘是 compute-bound

QKV/输出投影、FFN 两层、LM head 本质都是 $Y=XW$。矩阵乘 $[M,K]\times[K,N]$ 计算量约 $2MKN$，访存量约 $MK+KN+MN$。当 $M,N,K$ 都大时 FLOPs 增长远快于访存，数据复用高，算术强度高 → compute-bound，能喂饱 TensorCore。

但 decode batch=1 时退化：输入变成"瘦"矩阵 $[1,H]$，权重 $[H,H]$ 几乎没有 batch 维复用，每层大量时间花在从 HBM 读 $W_q,W_k,W_v,W_o,W_{up},W_{gate},W_{down}$ → 转为 memory-bound。这正是 70B FP16（权重约 140GB）单 token decode memory-bound 的根因。

Attention 在两阶段的瓶颈相反

Prefill：处理整段 prompt，$QK^\top$ 形状 $[B,h,S,D]\times[B,h,D,S]\to[B,h,S,S]$，计算量 $O(B\cdot h\cdot S^2\cdot D)$，$S$ 大时是大矩阵乘 → compute-bound。FlashAttention 减少 attention matrix 的 HBM 读写后更接近高效 GEMM。

Decode：query 长度为 1（$[B,h,1,D]$），但要扫历史 KV cache（$[B,h,S,D]$）。每个新 token 都要从 HBM 读大量 K/V，但每个元素参与计算很少 → memory-bound。这就是长上下文 decode 越来越慢的原因：不是单 token 计算爆炸，而是每步要读更长的 KV cache。

为什么逐元素/归一化类必然 memory-bound

以 Residual add $y=x+f(x)$ 为例（FP16）：读 $x$、读 $f(x)$、写 $y$ 共约 6 bytes，只做 1 FLOP，算术强度约 $\frac{1}{6}$ FLOP/byte，远低于 156 → 必然 memory-bound。LayerNorm/RMSNorm、RoPE、Embedding lookup、Softmax 同理：计算量相对访存量都很小。工程上常把它们与相邻 GEMM 融合（kernel fusion）来减少 HBM 往返。

训练 vs 推理

训练：大部分时间在大矩阵乘（forward GEMM、backward input/weight GEMM）→ compute-bound；但 optimizer step（如 Adam 更新 $m,v$）要读写 parameter/gradient/m/v 多份状态，每参数计算有限 → memory-bound。

推理：prefill 偏 compute-bound，decode 偏 memory-bound——这是 LLM serving 最重要的区别，也决定了 prefill/decode 分离部署、continuous batching 等优化方向。

Q: 同一个 FFN，为什么 prefill 是 compute-bound，decode 却 memory-bound？

看权重复用。prefill 一次处理 $B\times S$ 个 token，同一份 FFN 权重被大量 token 复用，算术强度高；decode batch=1 每次只过 1 个 token，权重几乎零复用，时间几乎全花在从 HBM 读那两层大权重上，算术强度掉到接近 GEMV 水平 → memory-bound。

Q: 为什么长上下文 decode 越来越慢？

不是单 token 计算复杂度爆炸，而是 decode attention 是 memory-bound 的，每生成一个新 token 都要从 HBM 读一遍历史 KV cache。上下文越长，KV cache 越大，每步读取量线性增长，所以越来越慢。优化方向是降 KV cache 带宽/容量压力：PagedAttention、KV cache 量化、MQA/GQA、FlashAttention 等。

关联模块

GPU 硬件与资源共享：提供 SM、HBM、NVLink、MIG/MPS、利用率诊断等底层直觉。
LLM 推理系统：提供 Prefill/Decode、KV Cache、Serving Engine 和推理优化语境。
Kubernetes 核心：提供调度、资源模型、控制器和扩展机制。
分布式训练 / 调度与集群：提供多卡通信、队列、公平性、拓扑和容错背景。

内容模块

面试高频题

精通★☆☆⏱ 20 min

一句话结论

Transformer 面试要把架构、Attention、复杂度、训练稳定和推理系统连接起来。

复习定位

维度	内容
所属模块	Transformer 与大模型基础
章节类型	面试收束类
解决问题	围绕 Transformer 架构、输入表示、Attention、训练稳定性和面试高频题建立大模型基础答案。
面试抓手	用可展开问答和追问表收束。

Transformer 面试高频题

把前面知识点压缩成可背诵的问答，点击展开。先盖住答案自己说一遍，再对照。

Q: 介绍一下 Transformer 的整体结构。

两大部分

Encoder 处理输入序列输出上下文表示，每层 = Multi-Head Self-Attention + Feed Forward，子层都带残差和 Layer Norm。Decoder 处理目标序列输出预测，每层 = Masked Self-Attention（防止看未来）+ Encoder-Decoder Cross-Attention（交叉注意力）+ Feed Forward，同样带残差和 Layer Norm。

额外组件

最前端是 Tokenizer + Embedding + 位置编码，最末端是 Linear + Softmax 输出层。

核心一句：纯注意力架构，抛弃 RNN/CNN，靠 Self-Attention 做 token 间交互、FFN 做单 token 加工，残差+归一化让深层可训练。

Q: Embedding 是什么，它在什么位置？

是什么

文本先由 Tokenizer 切成 token，按词表映射成整数 input_ids。模型维护一个可学习的 Embedding 矩阵 [vocab_size, hidden_size]，用 token id 查表取出对应行向量，就得到 token 向量。本质是查表，不是矩阵乘。

位置

在模型最前端，紧跟 Tokenizer 之后、第一个 Transformer block 之前，之后还要加上位置编码。

Embedding = 一张可训练的查找表，把离散 token id 翻译成稠密向量。

Q: 为什么要位置编码？好处是什么？

为什么

Transformer 不用 RNN 结构，而是一次性看全局、所有 token 并行计算。Attention 本身对顺序不敏感（打乱输入只是结果跟着换位），无法利用单词顺序信息。所以要用位置编码把顺序补回来。

好处

保存单词在序列中的绝对或相对位置，让模型能区分词序不同导致的语义差异，并建模 token 之间的相对距离。

主流方案：原文正弦余弦、BERT 可学习位置编码、LLaMA 的 RoPE 旋转位置编码（外推性好）。

Q: Tokenizer 是怎么做的？

流程

用 BPE / WordPiece 等算法把连续文本切成更小的单元（token），可以是整词、词根、词缀甚至单字。然后在预构建的词表里查每个 token，映射成唯一的整数编号（token id）。一段文本就变成一串 token id，成为模型输入。

为什么用子词

整词词表会爆炸且无法处理生词（OOV），单字序列太长语义太碎。子词是折中：常见词当整体、罕见词拆词根词缀，既控制词表大小又能处理生词。

BPE：合并高频字符对；WordPiece：合并最大化似然的字符对；SentencePiece：不依赖空格，适合中文/多语言。

Q: Self-Attention 的计算流程？为什么要除以 √d_k？

流程

每个 token 投影出 Q、K、V；用 Q 和所有 K 点积得相关性分数，除以 √d_k 缩放后 softmax 成权重；用权重对所有 V 加权求和。公式 softmax(Q·Kᵀ/√d_k)·V。

为什么除以 √d_k

维度大时点积数值会很大，softmax 进入梯度极小的饱和区，会导致梯度消失。除以 √d_k 把方差拉回来，稳定梯度。

Q: Multi-Head 和 Single-Head 的区别？Multi-Head 好在哪？

区别

Single-Head 只在一个空间算一次注意力；Multi-Head 把 hidden_size 拆成多个并行子空间，每个 head 独立算注意力再拼接过输出投影。总维度不变，所以参数量和计算量基本一样，只是切开算。

好处

多角度建模：每个头关注不同子空间特征（语法、语义、位置）。
表达能力更强：能同时捕获更丰富的依赖。
并行性好：多头之间天然并行。

Q: Attention 和 Feed Forward 各自的作用？

Attention

在 token 之间做信息交互，捕获序列依赖关系——「谁该关注谁」，做的是混合/通信。

Feed Forward

对每个 token 独立做非线性变换，提升表达能力，承担「知识存储」作用，做的是加工/记忆。

比喻：Attention 是「开会交换信息」，FFN 是「会后各自消化加工」。

Q: 手撕 Multi-Head Attention 时，KV cache 和 causal mask 各起什么作用？

KV cache

自回归生成时，前面 token 的 K/V 不变，缓存下来避免重复计算，每步只算新 token 的 Q 和它的 K/V，再 cat 到历史后面。是推理加速的关键。

causal mask

给「未来位置」加一个极大负数（mask * -1e9），softmax 后这些位置权重≈0，实现「只能看到自己和左边、不能偷看未来」。

易错点

合并多头前必须 contiguous()，因为 transpose 后内存不连续，直接 view 会报错。

Q: 大模型怎么处理梯度消失和梯度爆炸？

六个手段

残差连接：梯度有直通车直达浅层，最关键。
LayerNorm / RMSNorm：稳定每层激活分布。
合理初始化（Xavier/Kaiming）：保持各层方差一致。
梯度裁剪：梯度范数超阈值就缩小，防爆炸。
学习率 warmup + decay：避免训练初期发散。
混合精度 + Loss Scaling：解决 FP16 梯度下溢。

金句：残差连接把「乘法传播」变成「加法传播」，y=x+F(x) 的梯度是 1+F'(x)，那个 1 保证梯度不衰减。

Q: 为什么 NLP 用 LayerNorm 而不是 BatchNorm？

原因

BatchNorm 对 batch 内同一特征归一化，依赖 batch 统计量。NLP 里序列长度可变、batch 可能很小，batch 统计不稳定。LayerNorm 对单个样本的所有特征归一化，不依赖 batch，对每个 token 独立做，更适合变长序列。

RMSNorm 是 LayerNorm 的简化版（只做均方根缩放、不减均值），更快、效果相当，LLaMA 等主流大模型在用。

Q: Encoder-only、Decoder-only、Encoder-Decoder 有什么区别？

三种

Encoder-only（BERT）：双向注意力，擅长理解类任务（分类、抽取）。
Decoder-only（GPT/LLaMA）：单向因果注意力，擅长生成，当前主流大模型。
Encoder-Decoder（原始 Transformer / T5）：两半都有，擅长翻译、摘要等 seq2seq。

现在说「大模型」基本默认 Decoder-only：靠因果掩码自回归地一个一个 token 往外吐。

关联模块

GPU 硬件与资源共享：提供硬件、显存、互联和利用率诊断基础。
LLM 推理系统 / 分布式训练：提供大模型系统中的实际落点。
Kubernetes / 调度与集群：提供平台、资源和多租户治理语境。
专题综合题 / 论文工作：把基础知识组织成可复述的方案和项目叙事。

内容模块

可视化资源

基础★★☆⏱ 10 min

一句话结论

Transformer Explainer 是一个适合“建立动态直觉”的交互式可视化项目，建议配合本站的 Attention、FLOPs/Roofline 和推理系统章节使用：它负责看懂 token 如何流过模型，我们负责补齐公式、系统瓶颈和面试回答。

资源入口

visual

Transformer Explainer

Georgia Tech Polo Club 的交互式 Transformer 可视化，可逐步观察 token、attention、MLP、logits 和生成过程。

怎么用它学习

你要理解什么	在 Explainer 里看什么	回到本站补什么
Token 怎么进入模型	输入 token、embedding、position 的变化	`输入处理`：Tokenizer、Embedding、位置编码边界
Attention 怎么混合信息	attention heads 对不同 token 的权重	`Attention 机制`：Q/K/V、mask、multi-head 公式
每层在做什么	residual stream、attention block、MLP block 的变化	`整体架构`：残差主干、Norm、FFN 职责
生成为何逐 token 进行	next-token logits 和采样过程	`LLM 推理系统`：prefill/decode、KV cache、TPOT
为什么算子有不同瓶颈	attention/MLP 的结构和张量形状	`计算分析`：FLOPs、Roofline、memory-bound 判定

常见误区

误区	正确理解
看懂可视化就等于懂 Transformer	可视化建立直觉，但还要补张量形状、复杂度、mask、KV cache 和系统瓶颈。
attention head 的颜色就是固定语义	head 的行为是 learned pattern，不要过度解释某个 head 的单次可视化。
可视化里的小模型能代表线上 LLM 性能	小模型适合理解机制，线上 LLM 还要看显存、并行、batching、KV cache 和 serving engine。
Transformer 架构图已经够了	架构图是静态结构，Explainer 补动态过程，本站补工程和面试表达。

关联模块

整体架构：静态结构和 Encoder/Decoder/Decoder-only 边界。
Attention 机制：Q/K/V、Multi-Head、causal mask 和手撕代码。
计算分析：FLOPs、Roofline、逐算子 compute/memory-bound 分类。
LLM 推理系统：Prefill/Decode、KV Cache、Serving Engine 和线上性能。

模块	做什么	资源特征	深度理解
Attention	token 间通信，决定“谁看谁”	prefill 有 \(O(n^2d)\)，decode 读 KV cache	更像动态路由和上下文聚合
FFN / MLP	每个 token 独立变换	参数量和 FLOPs 通常占大头	更像逐 token 的非线性记忆库
Norm	控制尺度	算子小但常 memory-bound	保证深层堆叠的数值稳定
Residual	保留主干信息	几乎纯读写	提供梯度高速通道