企业官网建设流程全解析

简介：这份PPT资源围绕《Attention Is All You Need》论文，对Transformer架构与Attention机制做了系统拆解，适合NLP初学者、算法工程师以及需要快速梳理论文脉络、掌握模型核心要点的研读者。内容先从RNN难以并行和CNN局部感受野受限两大痛点引入，说明Transformer出现的原因，随后详细展开Self-Attention与Multi-head Self-attention的组成原理，并解释Attention如何从大量信息中筛选重要内容。针对计算过程，PPT梳理了Query、Key、Value的概念，以及Scale Dot Product Attention、Multi-head Attention、Concat三个主要环节，让读者理解权重归一化和多头合并的具体逻辑；同时结合机器翻译、文本分类、命名实体识别等典型任务，说明Transformer的并行计算和长序列处理能力。资源为单个pptx文件，约2.85MB，共1个文件，页面结构清晰、要点密集，可直接用于组会汇报、课堂讲解或论文阅读辅助，省去自行整理笔记的时间。目前已有1994人学习/下载，适合作为Transformer与Attention机制的入门讲解材料。

1. Attention Is All You Need：一篇标题背后的工程真相与落地路径

如果你是在搜索引擎里敲下“Attention Is All You Need”这句话再点进来的，大概率不是为了重温那篇论文的摘要。你可能是在某个模型架构里看到它，在某个仓库的 README 里读到它，或者是在面试中被问到“你为什么选择 Transformer”。这篇文章想讲的不是论文解读，而是把这个标题翻译成一个响亮的工程判断：抛弃循环和卷积，只用注意力机制，能建出更好用的模型。对于做 NLP、做序列建模、甚至做多模态对齐的工程师来说，这个判断意味着更短的训练时间、更好的长距离依赖建模，以及一套从单卡到集群都能复用的搭建流程。我会从一个可运行的代码骨架出发，带你重新审视这条路上真正的收益与暗礁——尤其是那些论文里没写、但训练时一定会踩的坑。

2. 注意力机制的核心工作方式：为什么说“注意力即全部”

这一章名字起得直白，因为这里解决的是第一类问题：原理到底是什么，它凭什么能替代循环和卷积。你不用去翻原论文的公式证明，也不用把 Multi-Head 背得滚瓜烂熟——我打算先把它拆成你能自己推演出来的数学直觉，然后给你一段不用深度学习框架也能看懂的最小实现。

2.1 缩放点积注意力：从“找相关”到“加权求和”

注意力机制本质上是在解决一个问题：给定一个查询 q，一堆键 k 和值 v，我该怎么从 v 里把和 q 最相关的内容筛出来。这里的直觉很像检索：你拿一个问句去查数据库，数据库里每个条目都有个标题（键）和正文（值），你是靠标题和问句的相似度来判断该读哪条正文的。

具体到缩放点积注意力，相似度的计算是点积。点积越大，代表两个向量方向越接近。但点积有个毛病：维度越高，点积的数值会越大，进了 softmax 之后梯度会变得很小。所以论文里给点积结果除了一个缩放因子，这就是名字里“缩放”这个词的来源。公式我用自然语言描述一下：先算 q 和所有 k 的点积，再除以维度 d_k 的平方根，然后经过 softmax 归一化成权重，最后用这些权重去加权求和所有的 v。

这里有个关键细节：softmax 之前必须加 mask，尤其是在解码器里。你预测第 t 个词的时候，不应该看到第 t+1 个词的信息。工程上这个叫 look-ahead mask，实现起来就是在点积结果矩阵的上三角部分加上一个负无穷大的数，这样 softmax 之后这些位置的权重就变成 0 了。我见过不少新手第一次写 Transformer，漏了这一步，训练 loss 能降，但生成的时候输出全是乱的，还以为是自己采样策略写错了，其实根子在这里。

2.2 用 numpy 写一个最小版本：看懂形状比看懂公式重要

为了让你彻底明白这个机制，我贴一段用 numpy 实现的缩放点积注意力。这段代码没有任何框架依赖，你能一行行跑通，也能直接看到每个参数的含义。代码重点是让矩阵形状的变化过程可见，这比背公式有用得多。

import numpy as np def scaled_dot_product_attention(query, key, value, mask=None): """ 缩放的缩放点积注意力，自己实现一遍，形状全在手 query: (batch, ..., seq_len_q, dim_k) key: (batch, ..., seq_len_k, dim_k) value: (batch, ..., seq_len_v, dim_v) mask: (batch, ..., seq_len_q, seq_len_v) 或 None """ dim_k = query.shape[-1] # 1. 计算点积注意力分数，形状变成 (batch, ..., seq_len_q, seq_len_k) scores = np.matmul(query, np.swapaxes(key, -1, -2)) # 2. 缩放，防止内积数值过大导致梯度消失，这是论文里的关键调节旋钮 scores = scores / np.sqrt(dim_k) # 3. 对未来的信息进行遮蔽，填入 -inf，在 softmax 后权重趋向于 0 if mask is not None: scores = np.where(mask == 0, -1e9, scores) # 4. 在 key 的维度上做 softmax，让每一行权重和为 1 exp_scores = np.exp(scores - np.max(scores, axis=-1, keepdims=True)) weights = exp_scores / np.sum(exp_scores, axis=-1, keepdims=True) # 5. 对 value 做加权求和，形状回到 (batch, ..., seq_len_q, dim_v) output = np.matmul(weights, value) return output, weights # 用一个具体例子验证形状：batch=2, seq=5, dim=4 q = np.random.randn(2, 5, 4) k = np.random.randn(2, 5, 4) v = np.random.randn(2, 5, 4) out, w = scaled_dot_product_attention(q, k, v) print("输出形状:", out.shape) # 期望是 (2, 5, 4) print("注意力权重形状:", w.shape) # 期望是 (2, 5, 5)

这段代码里最值得看的是第 3 步的 mask 处理和第 2 步的缩放。mask 我用的是-1e9，而不是负无穷，因为在实际的 fp16 混合精度训练里，负无穷在某些硬件上会表现异常，而-1e9是个够用且安全的替代。第 4 步的 softmax 我做了数值稳定处理，先减去最大值再求指数，避免指数爆炸。

你注意到没有，query 和 key 的维度必须一致，因为要做点积；而 value 的维度可以和它们不同，因为输出形状只跟 value 有关。这就是为什么 Transformer 里有的模块会把 embedding 维度拆开用，本质是在控制计算量和信息容量的权衡。

2.3 为什么这样做能替代循环网络：长距离依赖与并行

循环网络的痛点在于，信息是一步一步传递的，要记住 100 步之前的信息，得经过 100 次非线性变换，信息在传递过程中会丢失或混入噪音。LSTM 和 GRU 加了门控机制缓解了这个问题，但它仍然是串行的：t 时刻计算依赖 t-1 时刻的结果，这种串行结构让 GPU 的优势发挥不出来。

注意力机制把这个问题直接抹掉了。在自注意力层，序列里任意两个位置之间的依赖强度，是由它们的直接交互算出来的，不需要中间隔着一个一个单元去传。所以它天然适合捕捉长距离依赖。你可以把注意力矩阵想象成一个全连接图，每个 token 都能看到序列里的每个 token，只是权重不同。

更实际的好处是并行。循环网络在 GPU 上跑，实际利用率往往很低，因为无法充分打满矩阵运算单元。而注意力机制的核心操作是矩阵乘法，天然是并行的。这也是“Attention Is All You Need”这个标题的底气之一：不是说注意力更聪明，而是说它在现代硬件上更高效。我们后面代码跑起来就能感受到，100 步的序列，用循环网络可能需要 100 次串行计算，而用 Transformer 就是一次大矩阵乘法的事。

3. 多头注意力是实战主力：把单一注意力变成多路特征提取器

就算你弄懂了缩放点积注意力，离能用的 Transformer 还差一大截。论文里的 Multi-Head Attention 是把注意力拆成多组，每组有不同的线性投影，让模型能同时关注不同的位置关系。这一章要解决的是：多头是怎么回事，头数怎么选，训练时哪几个参数最值得调。

3.1 多头注意力的实现：切分维度与拼接

多头注意力的设计思路其实不复杂：与其用 512 维的向量去算一次注意力，不如把它拆成 8 个 64 维的子空间，每个子空间独立做注意力计算，然后拼接回 512 维。这样做的好处是每组注意力可以关注不同的关系。比如在机器翻译里，可能一个头关注语法依赖，另一个头关注指代关系，第三个头关注位置相近的词。

这里有一个工程细节：切分维度的时候要保持连续，不要用 reshape 之后再做转置然后把顺序搞乱。我写代码的时候习惯先把一整个 seq 维度的多头计算矩阵化，这样效率高很多，下面给出一个能直接跑的 TensorFlow 风格多头注意力实现。

def multi_head_attention(x, d_model, num_heads, mask=None): """ 一个直白的多头注意力实现，函数式风格，看形状变化 x: (batch, seq_len, d_model) d_model: 模型维度，需要能被 num_heads 整除 mask: 和单头注意力的 mask 形状一致，或者 None """ batch_size, seq_len, _ = x.shape depth = d_model // num_heads # 每个头的维度 # 1. 生成三组线性变换 q = np.random.randn(d_model, d_model) k = np.random.randn(d_model, d_model) v = np.random.randn(d_model, d_model) # 2. 线性投影 + 重新塑形，分离出多头维度 qx = np.matmul(x, q) kx = np.matmul(x, k) vx = np.matmul(x, v) # 3. 把 d_model 拆成 num_heads 和 depth 两个维度 # 注意 reshape 要按顺序来，head 维在最前面，方便后面拼接 qx = qx.reshape(batch_size, seq_len, num_heads, depth).transpose(0, 2, 1, 3) kx = kx.reshape(batch_size, seq_len, num_heads, depth).transpose(0, 2, 1, 3) vx = vx.reshape(batch_size, seq_len, num_heads, depth).transpose(0, 2, 1, 3) # 4. 用前面写的单头函数，这里 mask 可以广播到所有头上 output, _ = scaled_dot_product_attention(qx, kx, vx, mask) # 5. 把 head 维拼接回去，回到 (batch, seq_len, d_model) output = output.transpose(0, 2, 1, 3).reshape(batch_size, seq_len, d_model) # 6. 最后再做一次输出投影，允许跨头混合信息 output = np.matmul(output, np.random.randn(d_model, d_model)) return output # 测试：输入 2 个句子，每句 5 个词，模型维度 8，分成 2 个头 x = np.random.randn(2, 5, 8) y = multi_head_attention(x, d_model=8, num_heads=2) print("多头输出形状:", y.shape) # (2, 5, 8)

这段代码里我最想让你注意的是第 3 步的 reshape 顺序。如果不小心把reshape(batch, seq, num_heads, depth)写成reshape(batch, num_heads, seq, depth)，维度数目没错，但语义就全错了。这种错在图形化界面里很难看出来，只有训练到后期 loss 不降你才会发现，到时候定位问题会非常痛苦。所以我现在每写一个带 reshape 的层都会在旁边注明形状流转。

另一个值得注意的点是最后一步输出投影。论文里在多头拼接之后还有一个线性层，这会让不同头之间的信息产生交互。有些实现把这一步省了，不能说完全不行，但表达能力会明显下降，尤其当任务需要多个头协同决策的时候。

3.2 头数怎么选：8 头的经验、边界与代价

头数是 Transformer 里少数几个你不需要做太多实验就能定的超参。常见做法是在 8 和 16 之间选，我个人给的基准是 d_model 为 512 时用 8 个头，每个头 64 维。这已经是经过千锤百炼的经验值了。

头数变大的收益并不是线性的。头数越多，每个头的维度越小，单个头的表达能力就会被限制。我见过有人把 d_model 设为 128，然后头数设 16，每个头平均只有 8 维，注意力权重基本退化成某种均匀分布，什么关系都学不出来。这时候你去看注意力矩阵，会发现每个头长得差不多，这就是典型的维度不足。

反过来，头数太少也不行。2 个头的时候，模型基本只能同时关注到两种不同的关系，在长文本建模上会表现出明显的吃力。另外头数要和 d_model 成对调整，不要单独动一边。如果你想增加模型容量，优先加大 d_model 而不是加头数。头数定了之后，depth 的计算是 d_model 除以 head，所以要保证整除，否则 reshape 会直接报错。

3.3 位置编码：为什么纯注意力需要外部注入位置信息

注意力机制本身对位置是没有任何概念的。你输入“我爱吃饭”和“饭吃爱我”这两句话，在自注意力里面计算出来的表示几乎一模一样。这对序列建模来说是不能接受的。做机器翻译的时候，“我打你”和“你打我”意思完全相反，模型必须知道词出现的顺序。

原文的方案是给每个位置加一个固定频率的正弦余弦信号，做成位置编码矩阵，加在输入 embedding 上。这段信号的数学设计让模型可以通过线性变换感知相对位置。后来很多实现改用可学习的位置 embedding，直接让模型从数据里学每个位置会更好。

我个人的经验是：短序列场景用可学习位置 embedding 更好，因为数据量足够，模型能学到细微的位置差异；长序列要小心，可学习位置 embedding 在测试时如果遇到比训练时更长的序列，会直接崩掉。正弦余弦编码没有这个限制，外推到任意长度都能用。你现在搭 Transformer，我推荐先上可学习 embedding，但要提前把最大长度设到你会遇到的最长序列再乘个系数，别抠得太紧。

4. 搭一个能训练的简易 Transformer：从数据到损失函数的完整管线

原理说得再多，最后还是要落在能跑的代码上。这一章会把 Transformer 的完整组件捏合起来，做一个中文短文本分类的 demo。选择分类任务而不是机器翻译，是因为它数据好准备，不用配解码器，一套 encoder 就够用，让你把注意力集中到训练流程上。

4.1 数据准备的最小流程：分词、padding 与 mask 对齐

做任何 Transformer 模型，第一步永远是让数据变成矩阵。中文文本要先用分词语料库切成 token 序列，然后映射成 ID。这里有个特别容易出错的点：padding 之后，mask 和位置编码序列必须和 padding 后的长度完全匹配。我踩过坑，padding 长度是 50，位置编码只生成了 49 个，结果就是最后一个位置的向量全是 0，模型输出和预期完全对不上。

下面这一段代码我强烈建议你直接抄过去当工具函数用，它把原始文本转换成 Transformer 能吃进的格式，同时一次性帮你把 mask 给算好了。

import numpy as np # 一个超简单的迷你词典，实际项目里会换成一个 BERT 的分词字典 mini_vocab = {"我": 1, "爱": 2, "吃": 3, "饭": 4, "你": 5, "[PAD]": 0} MAX_LEN = 8 def prepare_batch(texts): """ 把一批中文句子转成模型输入：token_ids + mask texts: 字符串列表 """ batch_ids = [] batch_mask = [] for t in texts: # 1. 每个 token 转成 id，查不到的置为 0 ids = [mini_vocab.get(ch, 0) for ch in t] # 2. 截断到 MAX_LEN，避免过长序列拉爆显存 if len(ids) > MAX_LEN: ids = ids[:MAX_LEN] # 3. 把 id 序列 pad 到 MAX_LEN，缺失部分补 0 padded_ids = ids + [mini_vocab["[PAD]"]] * (MAX_LEN - len(ids)) batch_ids.append(padded_ids) # 4. 只有真实 token 的位置置 1，padding 位置置 0 mask = [1] * len(ids) + [0] * (MAX_LEN - len(ids)) batch_mask.append(mask) return np.array(batch_ids), np.array(batch_mask) texts = ["我爱你", "我爱吃饭", "你爱吃我"] ids, mask = prepare_batch(texts) print("token ids:\n", ids) print("mask:\n", mask)

这里有两处值得停下来细说。第 3 步里补的 padding token ID 是 0，和[PAD]的 ID 一致，这要求词典里你必须把 0 留出来。很多分词工具默认从 1 开始编号，你直接拼上 vocab 就会遇到 0 变成未知词的 bug。另一个是 mask 的形状是 (batch, seq_len)，但注意力机制里我们最终需要的 mask 形状是 (batch, seq_len, seq_len) 或至少广播后能变成那样。你后面用框架的时候需要做一次维度扩展，一般是mask[:, None, :]这种方式，让它从 (batch, 1, seq_len) 顶到 (batch, seq_len, seq_len)。

补充一个实际生产环境的细节：不要只存 token_ids，把 mask 一起存起来。很多预处理脚本只存了 ids，到训练时再现场生成 mask，万一某些样本被截断或后处理过，mask 就对不齐了。这是我整理训练数据时的血泪经验。

4.2 用基础框架组装 Transformer Encoder：经典残差与层归一化

真正训练的时候你不会用纯 numpy，效率太低了。我们来看一段使用深度学习框架的标准写法，为了通用性我用伪代码风格的 TensorFlow/ Keras 层来描述。你完全可以通过这套结构想象出 PyTorch 里面怎么组织，核心组件是一样的：嵌入层、位置编码、多头注意力、前馈网络、残差连接和层归一化。

# 伪代码，用框架层来组织，重点在结构，不重点在某个具体版本 API # 1. 输入层：token_ids 先查 embedding 表 x = Embedding(input_dim=vocab_size, output_dim=d_model)(token_ids) # 2. 位置编码信号直接加到 embedding 上，让模型感知顺序 x = Add()([x, positional_encoding[:, :tf.shape(x)[1], :]]) # 3. 第一层编码块：多头注意力 + 残差 + LayerNorm attn_out = MultiHeadAttention(num_heads=8, key_dim=64)(x, mask=mask) x = LayerNormalization(epsilon=1e-6)(Add()([x, attn_out])) # 4. 前馈网络：两层线性变换，中间用 ReLU 激活 ffn_out = Dense(units=2048, activation="relu")(x) ffn_out = Dense(units=d_model)(ffn_out) x = LayerNormalization(epsilon=1e-6)(Add()([x, ffn_out])) # 5. 最后接一个分类头，输出类别概率 logits = Dense(units=num_classes)(x[:, 0, :]) # 取 [CLS] 类似的首位

我这么写的意图是让你看到编码器部分的核心拼接：每一层（子层）都是“子层计算 -> 残差相加 -> LayerNorm”。注意 LayerNorm 加在了残差和之后，而不是之前，这叫后置归一化。原论文用的就是这个方案。但实际训练中你会发现后置归一化在深模型里容易不稳定，所以很多实现改成了前置归一化，即“LayerNorm -> 子层计算 -> 残差相加”。这两种方案都有大量成功案例，我给你的建议是：基座模型用后置，深模型（超过 12 层）用前置更稳。这是被大量实验验证过的方向。

关于 mask 的传入，注意我把原始 mask 传给了 MultiHeadAttention，框架内部的逻辑会自动把 mask 扩展成对序列每个位置可见的矩阵。如果你自己写注意力层，这块很容易出错。一个常见的检查方法是加一列调试输出，打印注意力层的输入和输出形状是否如预期，同时确认 mask 在层的内部是否正确传递，这一条能帮你省去后面很多无用功。

4.3 损失函数与优化器选择：标签平滑和学习率预热的实战配置

模型结构搭完，训练配置才是真正决定成败的地方。Transformer 训练有两个标准和传统的配置跟 CNN 或 LSTM 完全不一样：一是学习率要预热（warmup），二是标签平滑（label smoothing）的损失函数在机器翻译和分类上都有奇效。

学习率预热的意思是在训练最初几千步，把学习率从一个极小的值慢慢线性升到设定峰值，然后再按余弦或者倒数方式衰减。原理是 Transformer 的层归一化和残差结构在初始化阶段参数很不稳定，如果一开始学习率太大，参数更新会震荡甚至直接飞出正常区域。很多新手一上来就发现 loss 变成 NaN，十有八九跟这个有关。

标签平滑是把 one-hot 的标签改成软标签，比如真实类别概率是 0.9，其他类别平分剩下的 0.1。这能防止模型过度自信，在训练后期提升泛化能力。我实际用的值多是 0.1，太大会导致正确类别学习不足。

优化器选择上，Adam 是主流，但要把 beta2 调大一点，常用 0.98。这个细节是为了让 Adam 在训练后期有更平稳的梯度估计。配合学习率预热，这套组合几乎成了 Transformer 训练的默认班级，你按这个来基本上能复现出和论文接近收敛曲线的效果。

5. 训练与排查必备经验：那些实测中的常见注意点与避坑记录

这一章是全文另起炉灶的关键章节。我在多个项目里反复被同一个问题折磨，每次都要翻一段代码才能想起来。这里把这些坑集中写出来，每条都按“现象 -> 原因 -> 解决”的结构给到你，让你少走我当年走过的弯路。

5.1 注意力得分出现大量负值或 NaN：排查数据溢出

现象：训练刚开始几十步，loss 快速增长，最终出现 NaN，或者 attention 权重矩阵里出现大量 0 和 1 两极分化的情况。

原因：大部分情况是没有做缩放，或者是在 fp16 混合精度下，分数经过 softmax 之前出现了溢出。另一个常见原因是 mask 值是 0 的地方被设置成负无穷，在 fp16 下负无穷会被解析成 NaN。

解决：先检查代码里是否用了scores / np.sqrt(dim_k)。如果没有，这就是主因。另外把 mask 填充值从-inf改成-1e9，在 fp16 下这个值足够小，但不会引入 NaN。还有一个习惯值得养成：在注意力分数进入 softmax 前打印它的 min、max、mean，如果 max 和 min 差值超过 10 倍，就要警惕。

5.2 位置编码外推让长序列崩溃：训练时长度不能拍脑袋

现象：训练时最大序列长度设为 128，模型表现不错；拿到线上处理 200 词的句子，结果输出完全乱了，甚至报错。

原因：你用了可学习位置 embedding，训练时只见过 128 个位置，到第 129 个位置没有对应的向量。如果是正弦余弦编码，不会报错，但模型从没见过这么长的位置范围，泛化能力仍然不可靠。

解决：最可靠的办法是训练时就按实际业务的最大长度来定。另一个做法是采用相对位置编码，或者基于旋转位置编码的变体，这类设计天然支持外推。如果暂时不想换编码方案，至少要保证在数据处理时对超长文本做截断，并在上线前用一批长文本压测。

5.3 多头注意力每个头学到的模式都一样：信息瓶颈

现象：训练完成后可视化注意力矩阵，发现 8 个头的注意力模式一模一样，没有分化和多样性。

原因：最常见的是每个头的维度太小，或者 d_model 本身不够。另一种可能是初始化不合理导致多个头陷入相同的局部最优。

解决：先把 d_model 往上调，比如从 128 调到 256，头数保持 8。如果还不行，检查代码里 reshape 和 transpose 的顺序，看是不是不同头之间共享了同一份数据。还有一种操作是在多头注意力输出投影前加一个 dropout，dropout 可以破坏头之间的耦合，促使它们学到不同的特征。再有就是换个初始化方式，把权重初始化范围调小，多头分化情况往往会好转。

5.4 训练 loss 下降正常但验证指标不动：过拟合在哪一层

现象：训练集 loss 一路降到很低，但验证集准确率稳定一段时间后开始下降或震荡，你以为是模型复杂度太高，减了层数和宽度，效果反而更差。

原因：Transformer 在中小数据集上极易过拟合。它的容量太大了，几十万条样本根本喂不饱它。验证指标不动的原因往往是正则化不足，而不是容量不够。

解决：增加正则化强度几乎总是有用的。具体做三件事：把注意力层的 dropout 调到 0.1 以上；在 embedding 层加 dropout，一般推荐 0.1 到 0.3 之间；标签平滑保持开启。如果数据量只有几万条，考虑用一个预训练模型做迁移，别从零训练一个全尺寸 Transformer。数据量少于 10 万条、任务相对简单时，从零训练一个 4 层的小 Transformer 往往比大模型效果更好。

5.5 mask 在注意力里是“倒”的：一个让我调试两小时的隐性点

现象：模型训练时 loss 可以下降，但推理结果经常出现重复的 token 或者直接复读句子，总感觉模型像没看见后半句。

原因：在使用类似 Keras 的 MultiHeadAttention 层，或者一些开源实现时，mask 并不是“1 代表有效、0 代表无效”，而是正好反过来——True 代表这个位置被遮住不参与计算。如果你用我们预处理里生成的 mask 直接传入，语义就反了，等于把真实 token 给蒙上了。

解决：传入前先核对预期行为。最简单的办法是构造一个只有两个 token 的样本，手动跑一次前向，把输出的注意力矩阵打印出来，观察哪个位置权重为 0。如果有效 token 位置权重为 0，说明 mask 语义反了，把 mask 取反再传。这一个检查动作看起来不起眼，但能在训练失误发生前拦截掉大半问题。

6. 让注意力更省更快的两个进阶技巧：解锁长序列与降显存

Transformer 走到今天，原始架构的副产品是复杂度问题和显存消耗。最后这一章我想聊两个进阶方向，也是我目前在实际项目里最常用到的两个技巧。它们不会改变你前面搭好的代码结构，但能让你的模型跑更长的序列、省更多的显存，这往往是生产环境里最直接的收益。

第一个技巧是在自注意力计算中引入局部窗口，也就是常见的稀疏注意力思路。它的做法是每个 token 只和自己周围固定大小的窗口邻居计算注意力，窗口设多大完全取决于任务。如果任务是长文档理解，全局依赖很重要，窗口可以设大些，比如 512。它的原理是：很多任务中，与当前位置强相关的键其实都集中在它附近，遥远的 token 用少量全局 token 来代表就够了。这个技巧的落地代价是代码里有额外的索引和窗口 mask 逻辑，但换来的是显存从 O(n^2) 降到 O(n*window)。我测试过把窗口设为 512 时，长文本效果和全量注意力几乎没差别，速度却快了不少。

第二个技巧是键值缓存，也就是推理时的 KV Cache。做自回归生成时，如果要一步步生成序列，每一步都要重新计算前面所有 token 的键和值，这是极大的浪费。把前面步骤的键值向量缓存下来，每步只计算新 token 的键值，然后追加到缓存里，生成的显存占用从每个 token 的 O(n*dim) 直降到 O(dim)，速度也能提升好几倍。实现不复杂，就是你写推理循环的时候，维护两个列表存 k 和 v，每次生成新 token 时把它们 append 进去。如果用了框架内置的生成函数，一般传一个参数把缓存开关打开就行。

这两个技巧之后，你手里的模型基本已经具备面对真实业务复杂度的能力了。我会继续在每次搭新模型的时候，把注意力矩阵的可视化脚本留在工程里，一有异常就先看它在学什么。希望这篇笔记能帮你在调参的道路上少几次翻车，多一把趁手的工具。希望帮到你。

本文还有配套的精品资源，点击获取