大模型算法岗面试必备：Transformer六阶段学习路线与实战

很多准备大模型算法岗面试的同学，第一个遇到的问题往往不是“算法太难”，而是“考点太散”。今天翻到一篇讲自注意力的文章，明天刷到一个多卡训练的视频，后天看到一个 LoRA 微调的教程，每份材料都只覆盖一个点，但面试官问的是整个链路。如果你也有这种感觉，这篇文章会帮你把零散知识串成一条完整的学习主线。

本文围绕大模型算法岗的核心技能，把 Transformer 的学习拆成六个阶段：自注意力机制、整体架构、多头注意力、大模型训练、多卡并行、微调与部署。每个阶段都会结合面试高频考点来展开，附带代码示例和实践建议。无论你是刚开始入门 Transformer 的新手，还是准备冲刺大模型算法岗的进阶开发者，都可以把这篇文章当作一份系统化的复习提纲。

1. 为什么要以大模型算法岗的视角重新学习 Transformer

1.1 面试考的不只是“懂概念”

大模型算法岗的面试和普通算法岗有本质区别。普通算法岗可能考你一个具体的机器学习模型，比如决策树、XGBoost，你只要讲清楚原理、损失函数、调参思路就差不多了。但大模型算法岗不一样，它默认你掌握了深度学习和 NLP 的基础，然后在这个基础上去考察你对整个大模型技术栈的理解。

这个技术栈可以拆成四层：

• 底层：Transformer 架构本身，包括自注意力、多头注意力、位置编码、残差连接、LayerNorm 等基础组件。
• 中间层：大模型的训练技术，包括数据并行、模型并行、流水线并行、混合精度、梯度累积、ZeRO 等。
• 应用层：微调与对齐，包括 LoRA、QLoRA、P-Tuning、RLHF、DPO 等。
• 工程层：部署与推理优化，包括量化、KV Cache、vLLM、TensorRT-LLM 等。

面试官不会直接问你“Transformer 是什么”，而是会问“自注意力为什么需要缩放”“多头注意力的 head 数怎么选”“多卡训练时梯度怎么同步”“LoRA 为什么能减少显存占用”。这些问题背后考查的，是你是否真正理解 Transformer 从理论到工程的完整闭环。

1.2 六阶段学习法怎么划分

我把大模型算法岗的核心技能划分为六个阶段，每个阶段对应一类高频考点：

下面我们按这个顺序逐个展开。每个阶段都会给出概念解释、原理拆解和可运行的代码片段，方便你边看边练。

2. 阶段一：从词向量到自注意力机制

2.1 为什么不满足于 RNN / LSTM

在 Transformer 出现之前，NLP 领域最主流的序列建模工具是 RNN 及其变体 LSTM、GRU。RNN 的核心思路是“逐步处理”： t 时刻的隐藏状态 h_t 由当前输入 x_t 和上一个隐藏状态 h_{t-1} 共同决定。

这种结构有两个天然缺陷：

• 无法并行计算。每个时间步都依赖前一个时间步的输出，训练速度非常慢。
• 长距离依赖问题。虽然 LSTM 通过门控机制缓解了梯度消失，但信息在传递过程中仍会衰减，处理超长文本时效果有限。

那能不能让序列中的每个位置直接和其他所有位置建立联系？这就是自注意力机制的核心思想。它把序列建模问题变成了一个“全连接”问题：每个 token 都可以直接计算与所有 token 的相关性，而不需要通过中间步骤传递。

2.2 注意力公式的直觉理解

自注意力机制最经典的公式如下：

Attention(Q, K, V) = softmax(Q * K^T / sqrt(d_k)) * V

这个公式看起来很抽象，但用直觉来理解并不难。

假设你正在阅读一句话：“小明因为考试成绩不理想，所以他今天心情不好。” 当你读到“他”这个字的时候，你自然知道“他”指的是“小明”。这个过程就是“注意力”：查询（Query）是“他”，键（Key）是句子中所有词的身份信息，值（Value）是每个词携带的具体语义。通过计算“他”和“小明”之间的相似度，得到注意力权重，再把所有词的 Value 按权重加权求和，就得到了“他”在这个上下文中的表示。

拆开来看：

• Query：当前 token 想要查询什么。
• Key：其他 token 能够提供什么索引信息。
• Value：其他 token 的实际内容信息。
• Q 和 K 做点积：衡量两个 token 之前的匹配程度。
• 除以 sqrt(d_k)：防止点积结果过大导致 softmax 梯度消失。
• softmax：把匹配程度归一化成权重。
• 乘以 V：把所有 token 的信息按权重融合起来。

2.3 因果自注意力

在训语言模型的时候，我们不能让模型看到未来的 token。比如预测“今天天气”的下一个词时，模型不能提前看到“很好”。这种只允许当前位置关注左侧信息的注意力机制，叫做因果自注意力（Causal Self-Attention），也叫掩码自注意力。

实现时通常用一个上三角掩码矩阵，把未来位置的注意力权重置为负无穷，这样 softmax 之后对应位置的权重就趋近于 0。

2.4 自注意力的 PyTorch 实现

下面我们写一个最小版的自注意力实现，不使用 PyTorch 内置的nn.MultiheadAttention，而是手写核心逻辑，方便理解原理。

# 文件路径：attention.py import torch import torch.nn as nn import torch.nn.functional as F class SelfAttention(nn.Module): def __init__(self, d_model, d_k, d_v): super().__init__() self.d_k = d_k # 将输入映射到 Q、K、V 空间 self.w_q = nn.Linear(d_model, d_k) self.w_k = nn.Linear(d_model, d_k) self.w_v = nn.Linear(d_model, d_v) def forward(self, x, mask=None): # x shape: [batch_size, seq_len, d_model] Q = self.w_q(x) # [batch_size, seq_len, d_k] K = self.w_k(x) V = self.w_v(x) # 计算 Q 和 K 的点积，并缩放 scores = torch.matmul(Q, K.transpose(-2, -1)) / (self.d_k ** 0.5) # 因果掩码：上三角矩阵置为负无穷 if mask is not None: scores = scores.masked_fill(mask == 0, -1e9) attn_weights = F.softmax(scores, dim=-1) output = torch.matmul(attn_weights, V) return output, attn_weights # 测试 torch.manual_seed(42) batch_size, seq_len, d_model, d_k, d_v = 2, 4, 16, 8, 8 x = torch.randn(batch_size, seq_len, d_model) attn = SelfAttention(d_model, d_k, d_v) output, weights = attn(x) print("输出 shape:", output.shape) print("注意力权重 shape:", weights.shape)

运行后输出：

输出 shape: torch.Size([2, 4, 8]) 注意力权重 shape: torch.Size([2, 4, 4])

这里有几个容易忽略的细节：

• Q和K的维度不一定要等于d_model，可以设成更小的d_k，从而降低计算量。
• 除以sqrt(d_k)是必须的。如果d_k = 64，点积结果的方差会比较大，softmax 的梯度会非常小。
• 因果掩码的值最好用-1e9这种足够小的负数，而不是 0，因为 0 经过 softmax 后仍然有非零权重。

3. 阶段二：Transformer 整体架构与位置编码

3.1 宏观架构：Encoder-Decoder 与 Decoder-only

Transformer 原始论文提出的架构包含 Encoder 和 Decoder 两部分：

• Encoder：负责把输入序列编码成语义表示，适合理解类任务，比如文本分类、命名实体识别。
• Decoder：负责生成输出序列，适合生成类任务，比如机器翻译、文本摘要。

但到了大模型时代，主流的 GPT 系列模型采用的是 Decoder-only 架构。原因主要是：Decoder-only 结构更适合自回归生成，而且在下游任务上不需要像 Encoder-Decoder 那样额外设计复杂的注意力掩码机制。

一个标准的 Transformer Block 包含四个核心组件：

• 多头自注意力（Multi-Head Self-Attention）
• 前馈神经网络（Feed-Forward Network, FFN）
• 残差连接（Residual Connection）
• 归一化层（LayerNorm）

前馈神经网络通常是一个两层的全连接网络，中间用 ReLU 或 GELU 激活函数，例如：

FFN(x) = GELU(x * W1 + b1) * W2 + b2

这里 W1 和 W2 的维度通常是d_model到4 * d_model再到d_model。扩大中间维度是为了给模型提供更强的非线性表达能力。

3.2 位置编码：为什么需要它

自注意力机制本身没有任何顺序概念。如果把“我喜欢你”和“你喜欢我”传给同一个自注意力模块，计算出来的结果完全一样，因为 self-attention 是对集合进行操作，打乱 token 的顺序不会改变输出。

为了让模型感知位置信息，Transformer 引入了位置编码。

原始 Transformer 使用的是正弦余弦位置编码，公式如下：

PE(pos, 2i) = sin(pos / 10000^(2i / d_model)) PE(pos, 2i+1) = cos(pos / 10000^(2i / d_model))

其中pos表示 token 在序列中的位置，i表示维度索引。

为什么选择正弦余弦函数？有两个好处：

• 不同位置的编码向量是确定的，不随训练数据变化。
• 正弦余弦函数具有相对位置表达能力，模型可以通过线性变换感知位置之间的相对距离。

3.3 位置编码的 PyTorch 实现

# 文件路径：positional_encoding.py import torch import math def positional_encoding(seq_len, d_model): pe = torch.zeros(seq_len, d_model) position = torch.arange(0, seq_len, dtype=torch.float).unsqueeze(1) # 对偶数和奇数维度使用不同的频率 div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model)) pe[:, 0::2] = torch.sin(position * div_term) pe[:, 1::2] = torch.cos(position * div_term) return pe pe = positional_encoding(seq_len=10, d_model=16) print("位置编码 shape:", pe.shape)

运行输出：

位置编码 shape: torch.Size([10, 16])

在真实的大模型中，现在更常用的是可学习的绝对位置编码、RoPE（旋转位置编码）和 ALiBi。特别是 RoPE，它被 LLaMA、ChatGLM 等模型广泛使用，因为它能让模型更好地处理超出训练长度的文本。

看这一段时，建议手推一下position和div_term的广播过程，理解形状如何从[seq_len, 1]和[d_model/2]变成[seq_len, d_model/2]。面试中如果手撕位置编码，这个细节是常考的点。

4. 阶段三：多头自注意力机制

4.1 为什么需要多个头

自注意力机制已经可以让每个 token 关注所有其他 token，那为什么还要用多头？

原因在于，单头注意力只能学习一种注意力模式。但真实语言中的“注意力”有很多种：可能有的头在关注语法关系，有的头在关注共指关系，有的头在关注距离较近的词。使用多个头，相当于让模型同时学习多种不同的注意力模式，然后把它们拼接起来。

多头注意力的计算流程如下：

1. 将输入 x 分别映射到 Q、K、V。
2. 把 Q、K、V 按 head 数拆分成多份。例如 d_model = 512，head 数 = 8，每个 head 的维度就是 64。
3. 每个 head 独立计算注意力。
4. 把所有 head 的输出拼接起来。
5. 通过一个输出投影矩阵映射回 d_model 维度。

4.2 多头注意力的 PyTorch 实现

# 文件路径：multi_head_attention.py import torch import torch.nn as nn import torch.nn.functional as F class MultiHeadAttention(nn.Module): def __init__(self, d_model, num_heads): super().__init__() assert d_model % num_heads == 0, "d_model must be divisible by num_heads" self.d_model = d_model self.num_heads = num_heads self.d_k = d_model // num_heads self.w_q = nn.Linear(d_model, d_model) self.w_k = nn.Linear(d_model, d_model) self.w_v = nn.Linear(d_model, d_model) self.w_out = nn.Linear(d_model, d_model) def forward(self, x, mask=None): batch_size, seq_len, _ = x.shape # 1. 线性投影 Q = self.w_q(x) K = self.w_k(x) V = self.w_v(x) # 2. 拆分成多头 # view 后会得到 [batch_size, seq_len, num_heads, d_k] # transpose 后得到 [batch_size, num_heads, seq_len, d_k] Q = Q.view(batch_size, seq_len, self.num_heads, self.d_k).transpose(1, 2) K = K.view(batch_size, seq_len, self.num_heads, self.d_k).transpose(1, 2) V = V.view(batch_size, seq_len, self.num_heads, self.d_k).transpose(1, 2) # 3. 缩放点积注意力 scores = torch.matmul(Q, K.transpose(-2, -1)) / (self.d_k ** 0.5) if mask is not None: scores = scores.masked_fill(mask == 0, -1e9) attn_weights = F.softmax(scores, dim=-1) output = torch.matmul(attn_weights, V) # 4. 拼接多头结果 output = output.transpose(1, 2).contiguous().view(batch_size, seq_len, self.d_model) # 5. 输出投影 output = self.w_out(output) return output, attn_weights # 测试 torch.manual_seed(42) batch_size, seq_len, d_model, num_heads = 2, 6, 16, 4 x = torch.randn(batch_size, seq_len, d_model) mha = MultiHeadAttention(d_model, num_heads) output, weights = mha(x) print("输出 shape:", output.shape) print("多头注意力权重 shape:", weights.shape)

运行输出：

输出 shape: torch.Size([2, 6, 16]) 多头注意力权重 shape: torch.Size([2, 4, 6, 6])

面试中关于多头注意力，最常问的坑点有两个：

• 为什么d_model必须能被num_heads整除？因为每个 head 的维度是d_model / num_heads，如果不整除，拆分时无法均匀分配。
• 多头之间是并行计算，不是串行。很多初学者误以为多头是“先跑一个头，再跑另一个头”，实际上所有头在同一个矩阵运算中完成。

4.3 多头注意力的计算复杂度

多头注意力的计算复杂度和头数无关，这是容易被忽略的点。无论拆成多少个 head，总的计算量基本不变，因为 Q、K、V 的总维度还是d_model。

真正影响复杂度的是序列长度。自注意力的复杂度是 O(n²)，n 是序列长度。这也是为什么在处理超长文本时，原始 Transformer 会遇到瓶颈，后续才衍生出 Longformer、FlashAttention 等优化方案。FlashAttention 通过分块计算和重计算，把显存占用从 O(n²) 降到 O(n)，是当前大模型训练中最常用的注意力优化手段之一。

5. 阶段四：大模型训练与多卡并行

5.1 为什么单卡跑不动大模型

大模型训练的第一个门槛是显存。以 7B 参数模型为例，如果用 FP16 混合精度训练，参数量本身占 14GB 显存；优化器状态（如 Adam 需要维护一阶动量和二阶动量）再占 28GB 左右；梯度占 14GB；再加上激活值和中间变量，单张 80GB 的 A100 都可能不够用。

所以，大模型训练必须依赖多卡并行。面试中常考的并行策略主要有以下几种：

• 数据并行：每张卡持有完整的模型副本，把数据切分成多份分别计算，然后同步梯度。
• 张量并行：把一个层的权重矩阵切分成多块，分别放在不同 GPU 上计算，计算完成后通过 AllReduce 同步结果。
• 流水线并行：把模型的不同层切分到不同 GPU 上，前向传播时按顺序流过各层。

这三种并行策略的核心区别可以用一句话概括：数据并行是把数据切开，张量并行是把参数切开，流水线并行是把层切开。

5.2 ZeRO 与显存优化

微软提出的 ZeRO（Zero Redundancy Optimizer）是目前大模型训练中最重要的显存优化技术。它的核心思想是：既然数据并行需要每张卡都保存一份完整的模型参数、梯度和优化器状态，那能不能把这些状态分散到不同卡上，各卡只保存一份分片？

ZeRO 分为三个阶段：

• ZeRO-1：优化器状态分片，显存占用降低约 4 倍。
• ZeRO-2：优化器状态 + 梯度分片。
• ZeRO-3：优化器状态 + 梯度 + 模型参数全部分片。

使用 DeepSpeed 时，只需要在配置文件中指定zero_optimization.stage即可开启不同阶段的 ZeRO。

5.3 多卡训练的最小示例

下面给出一个基于 PyTorch 官方DistributedDataParallel的最小多卡训练示例。这里主要演示分布式初始化和梯度同步的关键步骤，实际项目需要根据显存和模型规模调整并行策略。

# 文件路径：train_ddp.py import os import torch import torch.distributed as dist import torch.nn as nn import torch.optim as optim from torch.nn.parallel import DistributedDataParallel as DDP def init_process(local_rank): """初始化分布式环境""" dist.init_process_group( backend="nccl", init_method="env://", rank=local_rank, world_size=int(os.environ["WORLD_SIZE"]), ) torch.cuda.set_device(local_rank) class SimpleTransformerBlock(nn.Module): """一个简化版 Transformer Block，用于演示多卡训练""" def __init__(self, d_model=64, num_heads=4): super().__init__() self.attn = nn.MultiheadAttention(d_model, num_heads, batch_first=True) self.ffn = nn.Sequential( nn.Linear(d_model, d_model * 4), nn.GELU(), nn.Linear(d_model * 4, d_model), ) self.norm1 = nn.LayerNorm(d_model) self.norm2 = nn.LayerNorm(d_model) def forward(self, x): attn_out, _ = self.attn(x, x, x) x = self.norm1(x + attn_out) ffn_out = self.ffn(x) x = self.norm2(x + ffn_out) return x def train(local_rank): init_process(local_rank) device = torch.device(f"cuda:{local_rank}") model = SimpleTransformerBlock(d_model=64, num_heads=4).to(device) model = DDP(model, device_ids=[local_rank], output_device=local_rank) optimizer = optim.AdamW(model.parameters(), lr=1e-4) loss_fn = nn.MSELoss() for step in range(10): # 模拟一个 batch 的输入数据 x = torch.randn(8, 32, 64).to(device) target = torch.randn(8, 32, 64).to(device) output = model(x) loss = loss_fn(output, target) optimizer.zero_grad() loss.backward() optimizer.step() # rank 0 打印日志 if local_rank == 0: print(f"step {step}, loss: {loss.item():.4f}") dist.destroy_process_group() if __name__ == "__main__": local_rank = int(os.environ["LOCAL_RANK"]) train(local_rank)

使用torchrun启动多卡训练：

torchrun --nproc_per_node=2 train_ddp.py

DDP的原理是：每个进程维护一个模型副本，前向传播时各进程独立处理自己的数据切片，反向传播时通过 AllReduce 操作把所有进程的梯度求平均，然后各进程用平均后的梯度更新模型。所以DDP在模型参数层面是一致的，只是数据处理不同。

5.4 混合精度训练

大模型训练除了并行策略，还有个必不可少的优化是混合精度训练。通常模型参数以 FP16 存储，梯度计算在 FP16 下完成，优化器状态和主权重保存在 FP32，通过一个损失缩放系数避免 FP16 下梯度下溢。

PyTorch 提供了torch.cuda.amp来自动处理这些细节。使用混合精度后，显存占用可以降低近一半，训练速度在支持 Tensor Core 的 GPU 上也有明显提升。

scaler = torch.cuda.amp.GradScaler() for step in range(10): with torch.cuda.amp.autocast(): output = model(x) loss = loss_fn(output, target) optimizer.zero_grad() scaler.scale(loss).backward() scaler.step(optimizer) scaler.update()

需要注意的是，混合精度并不是“所有层都用 FP16”。某些算子如 LayerNorm、Softmax 在 FP16 下容易精度损失，因此会自动回退到 FP32 计算。

6. 阶段五：大模型微调与部署

6.1 全参微调为什么昂贵

一个 7B 模型的全参微调，即使只训练一个 epoch，也需要数十张 A100 GPU。对于个人开发者和中小团队来说，这个成本几乎不可接受。而且全参微调后，每个任务都要保存一份完整的模型副本，存储成本也非常高。

LoRA（Low-Rank Adaptation）的出现解决了这个问题。它的核心思想是：在冻结原模型权重的情况下，向模型中注入可训练的低秩分解矩阵。

具体来说，对于原始权重矩阵 W_0，LoRA 不直接更新 W_0，而是学习一个增量 Delta_W，并通过低秩分解表示为两个小矩阵的乘积：

W = W_0 + Delta_W = W_0 + B * A

其中 A 的维度是r * d，B 的维度是d * r，r 是秩，通常设置为 8 或 16。训练时只更新 A 和 B，参数量只有原来的千分之一甚至万分之一，显存占用大幅下降。

6.2 使用 Hugging Face PEFT 实现 LoRA 微调

下面给出一个使用 Hugging Facetransformers和peft库实现 LoRA 微调的示例框架。完整代码需要根据数据集格式调整，这里重点展示 LoRA 配置和注入方式。

# 文件路径：lora_finetune.py from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments from peft import LoraConfig, get_peft_model, TaskType model_name = "your-model-path" # 替换为你需要微调的模型 # 1. 加载基础模型和分词器 model = AutoModelForCausalLM.from_pretrained( model_name, torch_dtype="auto", device_map="auto", ) tokenizer = AutoTokenizer.from_pretrained(model_name) # 2. 配置 LoRA lora_config = LoraConfig( task_type=TaskType.CAUSAL_LM, r=8, # 秩的大小 lora_alpha=32, # 缩放因子 lora_dropout=0.1, # dropout 概率 target_modules=["q_proj", "k_proj", "v_proj", "o_proj"], ) # 3. 注入 LoRA peft_model = get_peft_model(model, lora_config) peft_model.print_trainable_parameters()

target_modules指定了要注入 LoRA 的模块。在 LLaMA 系列模型中，通常选择q_proj、k_proj、v_proj和o_proj。不同模型的内部模块名可能不同，可以通过打印模型结构来确认。

训练完成后，LoRA 的权重只有几十到几百 MB，可以单独保存和加载，部署时只需要在基础模型上叠加这个低秩矩阵即可。

6.3 大模型部署与推理优化

微调之后就是部署。大模型部署最核心的挑战是推理速度。自回归生成时，每生成一个 token，都需要遍历整个模型的 Attention 计算。

KV Cache 是加速推理最常用的手段。在生成第 n 个 token 时，前 n-1 个 token 的 Key 和 Value 已经计算过，没有必要重新计算一遍。KV Cache 把这些中间结果缓存起来，推理时直接读取，可以显著降低计算量。

当前主流的大模型部署框架如 vLLM，除了 KV Cache 外，还做了 PagedAttention、连续批处理等优化。如果你在本地或云端部署开源大模型，可以直接使用这些框架，而不需要自己实现推理引擎。

对于个人开发者，Ollama 是目前最简单的本地大模型部署工具之一。它封装了模型下载、推理、API 服务等流程，一条命令就能启动一个兼容 OpenAI API 格式的本地服务。这类工具的好处是上手快，适合验证模型效果或搭建 Demo；但如果对并发性能和自定义控制有更高要求，还是推荐直接使用 vLLM。

7. 阶段六：面试高频问答与工程最佳实践

7.1 高频面试问题速查

下面整理了大模型算法岗面试中出现频率较高的问题，以及参考答案的核心思路。

7.2 显存不足的排查清单

训练或推理大模型时，最常见的报错就是CUDA out of memory。遇到这个问题，按以下顺序排查：

1. 确认当前占用显存的是什么。用nvidia-smi查看进程情况。
2. 检查 batch size 是否过大。显存不足时最先尝试减小 batch size。
3. 检查是否启用了混合精度。FP16 能把激活显存减半。
4. 检查模型加载方式。推理时使用torch_dtype="float16"或device_map="auto"可以减少显存占用。
5. 检查是否有显存碎片。如果同一个进程反复申请和释放大量显存，可能产生碎片，使用PYTORCH_CUDA_ALLOC_CONF=max_split_size_mb:128可以缓解。
6. 考虑使用梯度累积来替代增大 batch size。梯度累积不适合解决显存不足，但它可以模拟大 batch 的训练效果。

7.3 工程实践中的通用建议

最后，结合大模型算法岗的日常工作场景，分享几条比较实用的工程建议。

第一，版本管理要严格。大模型相关的开源项目更新非常快，transformers、peft、deepspeed等库的 API 经常发生变化。项目里一定要锁定版本号，最好用requirements.txt或pyproject.toml记录依赖，避免“昨天还能跑，今天突然报错”的情况。

第二，优先看源码而不是文档。很多开源模型的文档并不完整，或者更新滞后。遇到问题先打开模型源码看config.json和模型的forward方法，往往比读文档更有效。

第三，训练之前先验证数据。大模型训练失败最常见的原因不是代码问题，而是数据问题：数据重复、标签错位、空文本、中文编码错误。一个小技巧是：先用一个很小的样本集跑通整个训练流程，确认 loss 能下降，再上全量数据。

第四，多卡训练前先在单卡上跑通。不要一上来就调多卡环境，先确保单卡训练代码逻辑正确，再切到分布式环境。多卡环境的报错通常来自网络通信和进程同步，和模型本身的代码逻辑没什么关系，分开排查效率更高。

第五，推理和训练用不同的优化思路。训练阶段重点看吞吐，也就是每秒处理多少 token；推理阶段重点看延迟，也就是首 token 延迟和每个 token 的生成速度。这两个优化目标不同，采用的策略也不同。

8. 总结与后续学习方向

到这里，我们把大模型算法岗的六阶段核心技能完整过了一遍：从自注意力的数学原理，到 Transformer 的完整架构，再到多头注意力的实现细节，然后扩展到多卡训练、混合精度、LoRA 微调和推理优化。

回头看这六个阶段，其实它们各自解决的是不同层面的问题：

• 自注意力和多头注意力解决了“模型怎么理解序列”的问题。
• Transformer 整体架构解决了“模型怎么堆叠和训练”的问题。
• 多卡并行和混合精度解决了“显存不够、速度太慢”的问题。
• LoRA 微调解决了“全参微调太贵”的问题。
• 推理优化解决了“模型上线后响应太慢”的问题。

建议你按这个顺序动手实践：先跑通SelfAttention和MultiHeadAttention的两个手写代码块，再用 Hugging Face 加载一个开源小模型做 LoRA 微调，最后用torchrun在单机多卡上跑一遍DDP训练。只有亲手写过这些核心代码，面试中才经得起追问。

后续可以继续深入的方向包括：FlashAttention 的原理与实现、MoE 混合专家模型、RLHF 与 DPO 对齐技术、模型量化（GPTQ、AWQ）、长文本外推（RoPE 的缩放与插值）等。这些方向都是大模型算法岗的深度加分项，但前提是基础框架先搭建扎实。

如果你正处在准备面试的阶段，建议把今天的六个阶段整理成自己的知识脑图，每学完一个知识点，就问自己三个问题：它的输入输出是什么？它解决了什么问题？如果让我手写一个最小实现，我能写出来吗？把每个知识点都过一遍这三问，比刷十篇“十分钟理解大模型”的文章都管用。