GPT原理通俗拆解：Transformer、自注意力与训练全流程

我最早啃GPT原理的时候，啃了快三周才把自注意力那部分弄明白。后来给身边同学讲了一遍又一遍，发现大多数人卡住的根本不是数学，而是脑子里缺一张“从输入到输出”的完整地图。这篇博文我就用最直白的方式，把GPT从零到一拆开揉碎讲一遍，你不需要先精通深度学习，只要会一点Python基础，了解最基本的神经网络概念，就能顺着这条线走下来。读完你能清楚回答三个问题：GPT到底是什么结构，为什么它能一个字一个字地生成内容，以及那些听起来很高端的“预训练、微调、RLHF”到底各自在做什么。

这本来是我给组内新人做的入门笔记，整理成文送给所有想真正搞懂GPT的人。我不敢说比教材更严谨，但在“让原理变得可触摸”这件事上，我踩过很多坑，也知道你最需要什么。

1. 先把大模型拆成你能把握的四层结构

1.1 一个朴素的提问：GPT到底在做什么

很多人一听到“大模型原理”就头皮发麻，以为要学一堆矩阵分解、概率图模型。其实GPT的本职工作朴素得让你意外：给定前面已经出现的文本，预测下一个最可能出现的词。就这么简单。它本质上是一个自回归语言模型，每次只预测一个token（可以暂时把token理解为“一个被切出来的小词块”），预测完把结果拼回序列末尾，再接着预测下一个，如此循环，直到输出结束。

举个例子，你输入“今天天气真”，模型会计算下一个token的概率分布，可能是“好”（概率最高），也可能是“不错”“棒”“差”。它挑一个（按照概率采样），拼上之后变成“今天天气真好”，再继续预测“今天天气真好的”后面接什么。一遍一遍滚下去，就生成了完整句子。

所以理解GPT的核心，就是理解一个函数：

[ P(w_t | w_1, w_2, ..., w_{t-1}) ]

也就是“在已知前文的情况下，下一个词的概率”。大模型的所有复杂度，所有注意力机制、多层Transformer、海量参数，本质上都是在逼近这一个条件概率分布。

1.2 从宏观到微观的四层解剖

我把GPT拆成四层来理解：数据处理层、网络结构层、训练目标层、生成策略层。

• 数据处理层：把原始文本切成模型能处理的token序列，再把token映射成向量。
• 网络结构层：由几十甚至上百个Transformer解码器块堆叠而成，负责对输入向量序列做层层“理解”和“重构”。
• 训练目标层：通过预测下一个词来调整网络参数，让模型学到的条件概率分布越来越贴近真实语言数据。
• 生成策略层：训练完成后，用采样、温度、Top-p等策略控制实际生成效果。

大多数教程讲GPT都在第二层里打转，讲了半天QKV、多头注意力，把新手吓跑。但我的经验是，先把四层框架搭在脑子里，再逐个击破，整个学习过程会顺畅得多。

2. Tokenization与Embedding：模型看到的不是文字，是数字

2.1 为什么不能直接把文字丢给神经网络

神经网络能处理的是向量和矩阵，不能处理字符串。所以第一步得把文本变成一串数字索引，这个环节叫Tokenization（分词）。大多数现代大模型用的是一种叫BPE（Byte Pair Encoding，字节对编码）的子词分词方法。

BPE的思路很巧妙。它先建立一个基础词表，包括所有单个字符（或字节），然后统计语料里出现频率最高的相邻字符对，把它们合并成一个新token，反复迭代，直到词表达到预设大小。这样“unbelievable”可能被切成“un”、“believ”、“able”这样的子词，既能覆盖常见词根，又能组合出没见过的生词，还能控制词表规模。

我早期犯过的错误是拿英文的分词逻辑去套中文文本。中文没有天然空格分隔，BPE会把常见汉字组合逐渐合并成词，效果尚可，但词表里会有大量单字token。不同模型对中文的分词策略差异很大，你在实际使用中不必深究，只要知道“切分出来的token不一定等于词，也可能比词小或比词大”就行了。

2.2 从索引到向量：Token Embedding

分词之后，每个token获得一个整数ID，比如“你”= 345，“好”= 12。但这个整数不能直接输入网络——整数的大小关系毫无意义，345不应该是12的28.75倍。所以需要一张嵌入表（Embedding Table），把每个整数ID映射成一个固定维度的向量。

嵌入表的大小是 vocab_size × hidden_size。如果词表有5万个token，每个token映射成512维向量，这张表就有2560万个参数。嵌入向量一开始是随机初始化的，训练过程中不断调整，最终让语义相近的token在向量空间里距离更近。这就是“词的向量化表示”，也是所谓“大模型理解语言”的起点。

用PyTorch实现极为简单：

import torch.nn as nn vocab_size = 50000 hidden_size = 512 embedding_table = nn.Embedding(vocab_size, hidden_size) token_ids = torch.tensor([[345, 12, 789, 2333]]) hidden_states = embedding_table(token_ids) # hidden_states shape: (1, 4, 512)

2.3 别忘了位置信息：Positional Encoding

Transformer结构中，所有token是同时进入网络的（不像循环神经网络那样一个一个走），这就带来一个问题：模型本身看不到顺序。你给它“我爱你”和“你爱我”，如果不加位置信息，网络眼里这两个序列在自注意力计算里可能一模一样（取决于注意力权重）。

所以必须给每个位置加上位置编码。早期Transformer用的是正弦余弦函数生成的固定位置编码，后来GPT系列干脆直接用可学习的位置嵌入（Learned Position Embedding），也就是像token embedding一样，维护一张位置表，每个位置一个可学习的向量。

在GPT里，输入序列一般长这样：

[ H = TokenEmbedding(x) + PositionEmbedding(pos) ]

就是把token向量和位置向量逐元素相加。代码上可以这样理解：

max_seq_len = 1024 pos_embedding = nn.Embedding(max_seq_len, hidden_size) pos_ids = torch.arange(seq_len).unsqueeze(0) # 每个token的位置下标 h = token_embedding(token_ids) + pos_embedding(pos_ids)

合并之后，序列信息才真正“进入”模型。

3. 自注意力机制：让每个词都能看见整个句子

3.1 QKV到底是什么

自注意力是整个Transformer的发动机，GPT的核心也在这。我一直觉得，理解自注意力不需要一上来就背公式，先想明白一个问题：句子里的每个词，应该参考哪些词来决定自己该“表示”成什么？

比如“我做了一个苹果派，它很好吃”，这个“它”指的是“苹果派”。模型在编码“它”这个词的时候，应该让“它”从“苹果派”那里获取信息，而不是从“我”“做”“了”那里获取。自注意力就是让序列里任意两个位置都能相互“通信”的机制。

实现方式是每个token生成三个向量：Query（查询）、Key（键）、Value（值）。打个比方：你在图书馆里查资料，Query是你的搜索关键词，Key是每本书的标题标签，Value是书的内容。你先拿Query去和所有Key做匹配，算出一个相关度，然后按相关度去加权提取Value。在注意力里，这个相关度就是注意力权重。

数学写出来就是：

[ \text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V ]

其中(d_k)是Query向量的维度。除以(\sqrt{d_k})是为了防止点积数值过大把softmax推入饱和区导致梯度消失。

3.2 多头注意力：让模型拥有多套“视角”

一个注意力头只能学一种匹配模式，比如有的头偏向语法依赖，有的头偏向邻近词。为了让模型同时从多个角度理解序列，Transformer使用多头注意力：把Q、K、V各切成h份，每份走一个独立的注意力计算，最后拼接起来再经过一个线性层。

例如hidden_size是512，头数h是8，那么每个头的维度就是512/8=64。8个头各算各的，代表8种不同“关系视角”。这种设计极大提升了模型表达能力。

用PyTorch从零实现一个多头注意力关键部分（简化版）：

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_proj = nn.Linear(hidden_size, hidden_size) self.k_proj = nn.Linear(hidden_size, hidden_size) self.v_proj = nn.Linear(hidden_size, hidden_size) self.out_proj = nn.Linear(hidden_size, hidden_size) def forward(self, x, mask=None): # x: (batch, seq_len, hidden_size) batch, seq_len, _ = x.shape q = self.q_proj(x).view(batch, seq_len, self.num_heads, self.head_dim).transpose(1, 2) k = self.k_proj(x).view(batch, seq_len, self.num_heads, self.head_dim).transpose(1, 2) v = self.v_proj(x).view(batch, seq_len, self.num_heads, self.head_dim).transpose(1, 2) attn_scores = (q @ k.transpose(-2, -1)) / (self.head_dim ** 0.5) if mask is not None: attn_scores = attn_scores.masked_fill(mask == 0, float('-inf')) attn_weights = torch.softmax(attn_scores, dim=-1) out = attn_weights @ v # (batch, heads, seq_len, head_dim) out = out.transpose(1, 2).reshape(batch, seq_len, -1) return self.out_proj(out)

这里的mask参数很关键。GPT是自回归模型，生成第t个词时绝不能看到后面未来的词，所以注意力计算里要把未来位置的分数设成负无穷。这叫因果掩码（Causal Mask）。你去看GPT源码训练时，Attention部分一定有一个上三角掩码矩阵。

3.3 为什么自注意力能碾压循环神经网络

GPT没出现前，主流做语言模型的是循环神经网络（RNN/LSTM）。RNN的问题是每个时间步必须等前一步算完，既慢又难并行，而且长距离依赖容易在反向传播时被“稀释”。自注意力一次就能让任意两个token直接互动，路径长度恒定为1，还能高度并行计算。代价是计算量随序列长度平方增长，这也是为什么大模型的上下文窗口不能无限的直接原因。

所以你会看到很多优化工作都在试图降低注意力复杂度，比如稀疏注意力、线性注意力、滑动窗口注意力等。但凡是主流大模型，基础架构还是全注意力，只是应用层做各种近似。

4. 残差连接、LayerNorm与前馈网络

4.1 残差连接：防止网络太深练不动

多头注意力算完之后，GPT并不会直接输出。每个Transformer块里还有两样标配：残差连接和层归一化。残差连接的写法是：

[ h = x + \text{Sublayer}(x) ]

sublayer可以是注意力层，也可以是前馈网络层。这么做有什么好处？还记得反向传播里的链式法则吗？如果某一层的梯度在传播时，每层的雅可比矩阵都乘一次，网络深了就容易梯度消失或爆炸。有了残差连接，梯度多一条“短路”通道直接传回浅层，至少恒等映射的梯度为1，训练就稳得多。

在GPT里通常用的是“Pre-LN”结构，也就是先做LayerNorm再做注意力，原始Transformer里“Post-LN”的做法是注意力后再归一化。实践下来Pre-LN训练更稳定，更适合超深网络，这也是GPT系列选它的原因。

4.2 LayerNorm为什么取代BatchNorm

BatchNorm在一个batch里统计均值和方差，适合CNN那样喂大量小图片的任务。但NLP任务每个序列长度不同、batch通常很小（大模型可能只有几十甚至几个样本），BatchNorm统计出来很不稳定。而且序列里不同位置也应该有独立语义尺度，不该等于整个batch的统计量。

LayerNorm是针对每个token向量独立计算均值和方差再归一化。每个token有自己独立的分布统计，不用看同伴脸色，对变长序列天然友好。这也是GPT里每个Transformer块的标配。

4.3 前馈网络：被忽略的“记忆存储”环节

自注意力负责在不同token之间交换信息，而每个Transformer块后半部分还有个前馈网络（Feed-Forward Network，FFN），一般是两层线性层加一个激活函数：

[ \text{FFN}(x) = \text{GELU}(xW_1 + b_1)W_2 + b_2 ]

内部维度通常是hidden_size的4倍，GPT-3里hidden_size是12288，FFN中间层高达49152。前馈网络的作用可以粗略理解为“将注意力汇聚来的信息做非线性变换和加工”，让模型具备更复杂的特征表达和记忆能力。现在很多知识编辑和模型压缩研究都聚焦在FFN上，因为它像一个分布式的键值记忆库。

5. 从预训练到对齐：GPT是怎么被“教”出来的

5.1 预训练：疯狂地预测下一个词

GPT的训练分两个大阶段。第一阶段是预训练，目标就是前面说的“预测下一个token”。计算机会把互联网海量文本切成token序列，然后随机挖掉或掩盖部分？不对，GPT不挖掩盖，它是直接拿前文预测后面一位。训练语料的规模越大越好——你可能听过某模型的参数有上千亿，可训练数据也有上万亿token。模型就在这个纯粹的“猜字游戏”里学到语法、事实、推理乃至一些常识。

目标函数是交叉熵损失，也就是让模型给真实下一个token分配的概率尽量高：

[ L = -\frac{1}{N}\sum_{i=1}^{N}\log P(w_t^{(i)} | w_1^{(i)}, ..., w_{t-1}^{(i)}) ]

这个阶段需要超大规模算力。业内常用“困惑度”（Perplexity）作为指标，可以理解为模型在预测时的“惊讶程度”，困惑度越低说明模型对语料的拟合越好。

5.2 微调与指令跟随

预训练出来的模型已经会“续写”，但不一定听话。你问它问题，它可能给你编一段散文。所以需要第二阶段：指令微调（Supervised Fine-Tuning，SFT）。做法是收集大量“用户指令 + 理想回答”这样的配对数据，继续用同样的预测下一个词的方式训练模型，只不过数据从纯文本变成了问答对话形式。经过这一步，模型才学会“回答问题”。

但SFT还不够。因为“理想回答”有主观性，有的回答详细，有的简洁，标注员偏好不一致。而且模型可能学会迎合但不真实。于是有了更进阶的对齐技术。

5.3 RLHF和DPO：让模型学会“做人”

RLHF（基于人类反馈的强化学习）是GPT系列能“变聪明”的关键三步走：

• 第一步，用SFT训练一个基础模型。
• 第二步，让人对同一个问题的多个回答排序，训练一个奖励模型（Reward Model），用来打分预测人类偏好。
• 第三步，用强化学习（比如PPO算法）微调基础模型，让它的回答在奖励模型下得分更高。

这个过程很烧钱，也非常考验工程。实践中，PPO要同时维护策略模型、参考模型、奖励模型和值函数，显存开销大，训练不稳定。所以后来出现了更简单的DPO（Direct Preference Optimization）：它不需要训练奖励模型，直接基于偏好数据构造损失函数，让模型更偏好人类喜欢的回答。这两种方法现在都在工业界大量使用。

从预训练到SFT到RLHF/DPO，整体流程可以总结成一张路线图：

顺带一提，很多人问“为什么大模型会有幻觉”，根本原因就在预训练只追求“概率上合理”而不是“事实正确”，到了SFT和RLHF阶段才试图纠正，但纠不完。所以幻觉只能缓解，无法根除。

6. GPT家族进化史：参数变大的同时哪里变了

6.1 从GPT-1到GPT-4，发生了什么

GPT-1的参数规模只有约1.1亿，放在今天只是个小模型，但它在2018年证明了“生成式预训练 + 微调”这套路子的潜力。GPT-2把参数拉到15亿，核心发现是不需要为每个任务专门微调，模型在零样本情况下也能续写，只是质量一般。GPT-3直接跳到1750亿参数，靠海量数据和超大模型产生了“少样本学习”（In-Context Learning）能力：你只需要在提示词里给几个例子，它就能照猫画虎。

GPT-4没有公开参数规模，但明显在多模态、推理、对齐上做了更多工作。整个进化路线验证了一个非常粗暴的经验：模型规模大了，能力会出现不可预测的涌现。这也是“大力出奇迹”这条路线能压过其他路线的原因。

做一张表总结可能更清楚：

6.2 架构细节的变化

除了参数规模，GPT系列在架构上也有一些调整。比如GPT-2开始把LayerNorm前移，改进初始化方式；GPT-3用了交替的稠密与稀疏注意力层来省计算；GPT-4增加了视觉编码器来支持图像输入。但骨架始终是那个Transformer解码器，没有变。

当你读论文时看到“decoder-only架构”，这就是GPT的基本形态。它没有编码器，也没有attention的交叉层，只有因果解码器堆叠。相比BERT那类“encoder-only”模型，decoder-only在生成任务上天然顺手，而且以后来这套结构被证明在大规模下涌现能力更强。

7. 实操资源与硬件门槛：普通人如何跑通一个mini GPT

7.1 最小可复现版本怎么搭

说了这么多，不如动手做一个能跑的小GPT。代码框架直接写清楚，你用普通深度学习框架就能跑，只是规模小。例如用PyTorch搭一个两层Transformer解码器：

import torch import torch.nn as nn class MiniGPT(nn.Module): def __init__(self, vocab_size, hidden_size, num_heads, num_layers, max_seq_len): super().__init__() self.token_emb = nn.Embedding(vocab_size, hidden_size) self.pos_emb = nn.Embedding(max_seq_len, hidden_size) self.blocks = nn.ModuleList([ TransformerBlock(hidden_size, num_heads) for _ in range(num_layers) ]) self.ln_final = nn.LayerNorm(hidden_size) self.lm_head = nn.Linear(hidden_size, vocab_size) def forward(self, idx): B, T = idx.shape token_embeddings = self.token_emb(idx) position_ids = torch.arange(T, device=idx.device).unsqueeze(0) position_embeddings = self.pos_emb(position_ids) x = token_embeddings + position_embeddings for block in self.blocks: x = block(x) x = self.ln_final(x) logits = self.lm_head(x) return logits

上面的TransformerBlock会包含注意力、残差和前馈网络。这个模型在CPU上跑小数据集都没问题，只是别指望它讨论哲学，它只能学学“字符级文本规律”。

7.2 显存和算力怎么估算

很多人问我“这个模型得多少卡训练”，其实有个快速估算公式。模型参数量 N，每个参数用fp16占用2字节，训练时还涉及梯度（2字节）、优化器动量（4字节或更多）、激活值等，总显存大约是参数量的12到20倍。比如一个130亿参数模型用fp16训练，光参数和梯度加优化器状态：

• 参数：13B × 2字节 = 26GB
• 梯度：13B × 2字节 = 26GB
• 优化器状态（Adam）：13B × 4字节×2份 = 104GB

就这已经是156GB，还得加KV cache、激活值。所以单卡玩不动，必须多卡并行。要是还想微调大模型，显存不够就上LoRA——它只训练一小部分低秩矩阵，能省下90%以上显存。

# 一个LoRA模块的骨架 class LoRALinear(nn.Module): def __init__(self, in_features, out_features, rank=8): super().__init__() self.linear = nn.Linear(in_features, out_features) self.lora_A = nn.Parameter(torch.randn(in_features, rank) * 0.01) self.lora_B = nn.Parameter(torch.zeros(rank, out_features)) def forward(self, x): return self.linear(x) + x @ self.lora_A @ self.lora_B

训练时冻结linear部分，只更新lora_A和lora_B。多实践几次你会发现，用几千块钱的消费级显卡跑通7B模型的LoRA微调，在目前生态下确实能做到，前提是你有足够耐心调参。

7.3 推荐的学习路线

我强烈建议你按“逆向学习法”走。先跑代码，再回头看公式，这样比纯啃论文快得多。具体路线：先跑一个字符级GPT（网上有很多迷你实现），让模型学会生成莎士比亚风格的文本。这时候你对“预测下一个token”有了直观感受，再回头研究多头注意力代码。然后读原版Transformer论文中Attention部分，公式配合代码逐行对照。最后读GPT系列的技术报告，重点看训练设置和不同规模模型的对比，你会发现之前很多困惑都解开了。

8. 常见问题与避坑实录

8.1 训练时Loss不降怎么办

这是我被问过最多的问题，没有之一。先检查学习率：Transformer对学习率极其敏感，推荐用warmup + 余弦衰减，峰值学习率一般在1e-4到3e-4这个量级。再检查数据预处理：tokenizer有没有正确应用，是否存在大量重复样本。还有梯度裁剪，建议把clip值设在1.0左右，防止梯度爆炸毁掉整个训练曲线。

8.2 注意力矩阵太大导致显存溢出

序列长度一上去，注意力矩阵按平方膨胀。2千token没问题，2万直接塞爆显存。除了换更省显存的注意力变体，还有个技巧是开启梯度检查点（gradient checkpointing），用时间换空间。推理时可以用更底层的手段：KV Cache缓存历史键值，避免每个新token都重新计算整个历史。

8.3 生成质量很差：全是废话循环

检查一下采样策略。很多人直接取概率最高的token（贪心搜索），结果模型不断重复同一句话。建议使用top-p（核采样）+ temperature组合。temperature调高让概率分布更平缓，输出更多样；大于1会变混乱，低于0.5容易重复。我现在跑生成任务一般temperature=0.8，top_p=0.9起步，再根据具体场景微调。

8.4 别被“原理”吓住：几个让你心里有底的认知

很多初学者以为“懂了GPT”就是能把每一行反向传播代码手推出来。我做了这么久模型的体会是，工程实践中你99%时间在和数据处理、训练稳定性、性能优化打交道，真正推矩阵公式的时候并不多。所以不要怕数学，也不要神化数学。你有清晰的框架，能看懂代码，能复现实验，你已经超过90%只刷帖不实操的人。

另外，训练好的大模型权重下载后，做推理（inference）用普通GPU往往可以；但训练和全量微调门槛极高，这是正常的，不代表你学不会。

9. 一点个人经验，留给你

我自己的学习路径走了不少弯路。最早直接啃论文，被QKV公式砸晕，一个月没进展。第二次改成“边写代码边看原理”，用朋友推荐的一个千行量级的迷你GPT项目跑通英文文本生成，才真正通了。从那以后，我再也不把原理学习和实践分开看待了。

如果你现在也是一头雾水，我建议你从最小实验开始。找一段你感兴趣的文本，比如鲁迅的散文或者《三国演义》前几回，用字符级模型训练一个生成器。即使它只会输出“之乎者也”的乱序组合，你也会突然明白GPT是怎么工作的。之后每次看到“大模型原理”相关的讨论，你就不会再被术语吓倒。

这篇内容不是终点，只是你的起点。接下来可以往三个方向深入：动手微调一个轻量模型，研究某篇大模型论文的training细节，或者自己设计一个小规模的参数高效微调实验。无论选哪个，保持“边做边学”的节奏，你会进步得比想象中快。我自己现在回头看，当初那些卡壳的公式和概念，其实只需要一个合适的切入点而已。