从零手搓大模型：Transformer、自注意力与预训练微调全流程实战

简介：这份资源面向希望系统掌握大语言模型构建的开发者与学习者，以GPT为主线，从零开始讲解模型构建全流程。内容覆盖Transformer架构与自注意力机制的核心原理，并延伸到预训练、微调、部署的完整生命周期，同时对比解析BERT、GPT等经典模型的实现思路，适合具备一定Python与深度学习基础、想深入理解LLM内部机制的中高级读者。压缩包共37个文件，约1.54MB，以22个ipynb交互式笔记为主体，辅以3个py脚本、3个txt语料、2个md说明及docx附赠资料，另含jpg与png图示，便于边运行边理解。目录按知识点递进组织，从N-Gram、Word2Vec、NPLM、Seq2Seq，到Attention、Transformer、GPT、ChatGPT与OpenAI API，涵盖QKV、多头自注意力、RLHF奖励模型等关键实现。已有181人学习，适合按模块复现实验、对照代码理解原理并积累工程排错经验。

1. 从零构建大模型：为什么说“手搓一遍”比读十篇论文都管用

很多人第一次接触大语言模型，都是从调用 API 开始的——几行代码就能让模型回答问题，确实爽。但爽完之后呢？一旦遇到显存爆了、loss 不降、微调后模型变傻这类问题，就彻底抓瞎了。原因很简单：你只看到了黑匣子的输入和输出，没看过里面长什么样。而“GPT图解大模型构建全流程”这件事，核心价值恰恰在于把黑匣子拆开——从 Transformer 架构、自注意力机制，到预训练、微调、部署，整条链路自己走一遍。哪怕你只是在一个小数据集上训一个几百万参数的小模型，只要跑通了全流程，你对 BERT、GPT 这类经典模型的理解会完全不一样。这篇笔记就是写给那些想动手、但不知道从哪下手的工程师，尤其是被“大模型”三个字吓住、觉得没有八卡 A100 就玩不转的人。实际上，构建大模型的最小可复现路径，一台带消费级显卡的机器就够。

2. 把 Transformer 和自注意力拆到能写出来：最小实现与张量形状推演

2.1 自注意力到底在算什么：从 QKV 到输出张量的形状变化

自注意力机制是 Transformer 的心脏，但很多教程一上来就甩公式，反而让人更晕。我一般会先问一个问题：给你一个形状为(batch_size, seq_len, d_model)的输入张量，经过自注意力后，形状变了吗？答案是没变。变的只是每个位置上的向量——它吸收了序列中其他位置的信息。

具体怎么吸收？先把输入分别乘三个权重矩阵，得到 Query、Key、Value，形状都是(batch_size, seq_len, d_model)。然后计算注意力分数：Q乘K的转置，形状变成(batch_size, seq_len, seq_len)。这个矩阵的每一行表示“当前位置对所有位置的关注程度”。除以sqrt(d_k)做缩放，再经过 softmax 归一化，最后乘V，形状回到(batch_size, seq_len, d_model)。

这里有个容易翻车的点：d_k是每个头的维度，不是d_model。如果你用多头注意力，d_model会被切成num_heads份，每个头独立算注意力，最后拼接再投影。形状推演错了，后面全错。

import torch import torch.nn as nn import math class SelfAttention(nn.Module): def __init__(self, d_model, num_heads): super().__init__() assert d_model % num_heads == 0, "d_model 必须能被 num_heads 整除" self.d_model = d_model self.num_heads = num_heads self.d_k = d_model // num_heads # 每个头的维度 # 一次性定义 Q、K、V 的线性层，输出维度都是 d_model 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_o = nn.Linear(d_model, d_model) # 输出投影 def forward(self, x, mask=None): batch_size, seq_len, _ = x.shape # 1. 线性变换并拆多头: (B, L, d_model) -> (B, L, H, d_k) -> (B, H, L, d_k) Q = self.W_q(x).view(batch_size, seq_len, self.num_heads, self.d_k).transpose(1, 2) K = self.W_k(x).view(batch_size, seq_len, self.num_heads, self.d_k).transpose(1, 2) V = self.W_v(x).view(batch_size, seq_len, self.num_heads, self.d_k).transpose(1, 2) # 2. 计算注意力分数: (B, H, L, d_k) @ (B, H, d_k, L) -> (B, H, L, L) scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.d_k) # 3. 掩码（解码器需要，编码器可忽略） if mask is not None: scores = scores.masked_fill(mask == 0, float('-inf')) # 4. softmax 归一化 attn_weights = torch.softmax(scores, dim=-1) # 5. 加权求和: (B, H, L, L) @ (B, H, L, d_k) -> (B, H, L, d_k) context = torch.matmul(attn_weights, V) # 6. 合并多头: (B, H, L, d_k) -> (B, L, H, d_k) -> (B, L, d_model) context = context.transpose(1, 2).contiguous().view(batch_size, seq_len, self.d_model) # 7. 输出投影 output = self.W_o(context) return output, attn_weights

这段代码里，d_model是模型的主维度，常见取值 512、768、1024；num_heads是头数，通常取 8 或 12。d_k必须能被整除，否则直接报错。mask在解码器里用来防止看到未来位置，是一个下三角矩阵。如果你发现训练时 loss 变成 NaN，优先检查sqrt(d_k)有没有漏掉，以及 mask 是不是把整行都遮成了-inf。

2.2 位置编码：为什么正弦波公式至今没被淘汰

自注意力本身没有位置概念——打乱输入顺序，输出不变。所以必须注入位置信息。常见做法有两种：可学习的位置嵌入和正弦波位置编码。前者简单，但序列长度超过训练长度就废了；后者是固定公式，能外推到更长序列，虽然效果会衰减，但至少不报错。

正弦波位置编码的公式是：

class PositionalEncoding(nn.Module): def __init__(self, d_model, max_len=5000): super().__init__() pe = torch.zeros(max_len, d_model) position = torch.arange(0, max_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) pe = pe.unsqueeze(0) # (1, max_len, d_model) self.register_buffer('pe', pe) def forward(self, x): # x: (B, L, d_model) return x + self.pe[:, :x.size(1), :]

max_len设成 5000 够用了，除非你做长文档。div_term里的10000.0是底数，改大改小会影响不同维度上的波长分布。我试过把它改成 1000，短序列上没区别，长序列上外推能力略差。所以除非有特殊需求，别动这个数。

2.3 编码器和解码器堆叠：BERT 和 GPT 的分岔路口

有了自注意力和位置编码，就可以搭 Transformer 块了。一个标准块包含：多头自注意力、前馈网络、残差连接和层归一化。但 BERT 和 GPT 在堆叠方式上分道扬镳：

• BERT 用编码器堆叠，双向注意力，每个位置能看到左右两边。适合理解任务，比如分类、抽取。
• GPT 用解码器堆叠，单向注意力（带 causal mask），每个位置只能看左边。适合生成任务。

如果你要复现 BERT，就把mask设成全 1（或者不传）；如果要复现 GPT，就传一个下三角矩阵。这个区别决定了模型能不能做生成。很多新手拿 BERT 去写文章，结果发现只能填空，就是这个原因。

class TransformerBlock(nn.Module): def __init__(self, d_model, num_heads, d_ff, dropout=0.1): super().__init__() self.attn = SelfAttention(d_model, num_heads) self.norm1 = nn.LayerNorm(d_model) self.norm2 = nn.LayerNorm(d_model) self.ffn = nn.Sequential( nn.Linear(d_model, d_ff), nn.ReLU(), nn.Linear(d_ff, d_model) ) self.dropout = nn.Dropout(dropout) def forward(self, x, mask=None): # 残差连接 + 层归一化（Post-LN，原始 Transformer 用法） attn_out, _ = self.attn(x, mask) x = self.norm1(x + self.dropout(attn_out)) ffn_out = self.ffn(x) x = self.norm2(x + self.dropout(ffn_out)) return x

d_ff通常是d_model的 4 倍，比如 512 对应 2048。dropout在训练时用 0.1，推理时关掉。注意层归一化的位置：原始论文是 Post-LN（先残差再 norm），后来很多模型改成 Pre-LN（先 norm 再残差），训练更稳定。如果你训到一半 loss 突然飙升，试试换成 Pre-LN。

3. 预训练和微调全流程：从数据管道到 loss 曲线监控

3.1 预训练数据准备：为什么你的 tokenizer 决定了模型上限

预训练的第一步不是搭模型，而是处理数据。很多人随便拿个 tokenizer 就开始训，结果模型学出来的东西乱七八糟。tokenizer 决定了文本怎么切、词表多大、特殊 token 怎么设。常见做法是用 BPE 或 WordPiece，词表大小在 3 万到 5 万之间。

我一般会先在小规模语料上训一个 tokenizer，或者直接用现成的。但要注意：如果你做的是中文任务，最好用中文语料训 tokenizer，否则一个汉字可能被切成多个 token，序列长度爆炸。

from tokenizers import Tokenizer, models, trainers, pre_tokenizers # 初始化 BPE tokenizer tokenizer = Tokenizer(models.BPE()) tokenizer.pre_tokenizer = pre_tokenizers.Whitespace() # 训练器配置 trainer = trainers.BpeTrainer( vocab_size=30000, special_tokens=["[PAD]", "[UNK]", "[CLS]", "[SEP]", "[MASK]"], min_frequency=2 ) # 假设 corpus.txt 是纯文本，每行一句 tokenizer.train(["corpus.txt"], trainer) tokenizer.save("tokenizer.json")

vocab_size设 30000 是平衡点：太小则一个词被切碎，太大则嵌入矩阵参数爆炸。min_frequency=2表示出现少于 2 次的字符不单独成 token，避免词表被低频噪声撑大。特殊 token 里[PAD]用于填充，[UNK]兜底，[CLS]和[SEP]是 BERT 风格，[MASK]用于掩码语言模型。

数据管道里还有一个坑：动态填充。如果每个 batch 都按最大长度填充，短句会浪费大量计算。常见做法是按长度分桶，或者用DataCollator动态填充到当前 batch 的最大长度。

3.2 预训练任务设计：MLM 和 CLM 的代码实现与参数选择

预训练任务决定了模型学什么。BERT 用掩码语言模型（MLM）：随机遮住 15% 的 token，让模型预测。GPT 用因果语言模型（CLM）：预测下一个 token。两者代码上只差一个 mask 和 loss 计算方式。

def create_mlm_mask(input_ids, tokenizer, mask_prob=0.15): """BERT 风格的 MLM 掩码""" labels = input_ids.clone() probability_matrix = torch.full(labels.shape, mask_prob) # 特殊 token 不掩码 special_tokens_mask = [ tokenizer.get_vocab()[tokenizer.special_tokens_map["cls_token"]] == id or tokenizer.get_vocab()[tokenizer.special_tokens_map["sep_token"]] == id for id in input_ids.flatten() ] probability_matrix.masked_fill_(torch.tensor(special_tokens_mask).reshape(labels.shape), 0.0) masked_indices = torch.bernoulli(probability_matrix).bool() labels[~masked_indices] = -100 # 不计算 loss 的位置设为 -100 # 80% 替换为 [MASK]，10% 随机替换，10% 保持不变 indices_replaced = torch.bernoulli(torch.full(labels.shape, 0.8)).bool() & masked_indices input_ids[indices_replaced] = tokenizer.get_vocab()["[MASK]"] indices_random = torch.bernoulli(torch.full(labels.shape, 0.5)).bool() & masked_indices & ~indices_replaced random_words = torch.randint(len(tokenizer.get_vocab()), labels.shape, dtype=torch.long) input_ids[indices_random] = random_words[indices_random] return input_ids, labels

mask_prob=0.15是 BERT 论文的默认值，改大改小都会影响收敛速度。-100是 PyTorch CrossEntropyLoss 的默认忽略索引，不计算 loss。80/10/10 的替换策略是为了缓解预训练和微调之间的不一致——微调时没有[MASK]，所以不能全用[MASK]。

CLM 就简单多了：输入和标签错开一位，loss 只计算非 padding 位置。

def create_clm_data(input_ids, pad_token_id=0): """GPT 风格的因果语言模型数据""" inputs = input_ids[:, :-1] labels = input_ids[:, 1:].clone() labels[labels == pad_token_id] = -100 return inputs, labels

3.3 微调策略：全量微调、LoRA 和冻结层的选择依据

预训练完（或者直接用现成权重），下一步是微调。全量微调最直接，但显存吃紧。LoRA 只训低秩矩阵，显存占用小，效果在多数任务上接近全量。冻结层则介于两者之间。

我一般这样选：数据量小于 1 万条，用 LoRA；数据量 1 万到 10 万，冻结底层、微调顶层；数据量大于 10 万，全量微调。当然还要看显存，LoRA 在 24G 卡上能微调 7B 模型，全量至少需要 4 张 40G。

from peft import LoraConfig, get_peft_model # LoRA 配置 lora_config = LoraConfig( r=8, # 低秩矩阵的秩 lora_alpha=32, # 缩放因子 target_modules=["q_proj", "v_proj"], # 只对注意力的 Q、V 做 LoRA lora_dropout=0.1, bias="none", task_type="CAUSAL_LM" ) model = get_peft_model(base_model, lora_config) model.print_trainable_parameters() # 输出类似: trainable params: 4,194,304 || all params: 6,738,415,616 || trainable%: 0.06%

r=8是秩，越大容量越强但参数越多。lora_alpha=32是缩放，通常设为r的 2 到 4 倍。target_modules选q_proj和v_proj是常见做法，也可以加上k_proj和o_proj，但参数会翻倍。lora_dropout=0.1防止过拟合。

微调时 loss 曲线要盯着：如果训练 loss 降但验证 loss 升，就是过拟合，减小r或增大 dropout；如果两个都不降，可能是学习率太小或数据有问题。

4. 部署与推理优化：模型从 checkpoint 到线上服务的最后一公里

4.1 模型导出与量化：ONNX 和 INT8 的取舍

训完模型，下一步是部署。直接拿 PyTorch checkpoint 上线不是不行，但推理速度慢、显存占用高。常见做法是导出 ONNX 或做量化。

ONNX 的好处是跨平台，能用 ONNX Runtime 加速。量化到 INT8 能减少一半显存，速度提升 1.5 到 2 倍，但精度会掉一点。我一般先导出 ONNX，测一下精度，如果掉得不多就直接用；掉得多就做动态量化，只量化权重不量化激活。

import torch.onnx # 导出 ONNX dummy_input = torch.randint(0, 30000, (1, 128)) torch.onnx.export( model, dummy_input, "model.onnx", input_names=["input_ids"], output_names=["logits"], dynamic_axes={ "input_ids": {0: "batch", 1: "sequence"}, "logits": {0: "batch", 1: "sequence"} }, opset_version=14 )

dynamic_axes让 batch 和序列长度可变，否则推理时只能跑固定形状。opset_version=14支持大多数 Transformer 算子，太低会报错。

量化用 PyTorch 的动态量化：

quantized_model = torch.quantization.quantize_dynamic( model, {nn.Linear}, dtype=torch.qint8 )

{nn.Linear}表示只量化线性层，这是 Transformer 里参数最多的地方。qint8是 8 位整数。量化后模型大小约为原来的四分之一，但注意：量化后的模型不能再训练，只能推理。

4.2 推理服务封装：用 FastAPI 搭一个最小可用接口

部署的最后一步是包成服务。FastAPI 轻量、异步、自带文档，适合做推理接口。

from fastapi import FastAPI from pydantic import BaseModel import torch app = FastAPI() class Request(BaseModel): text: str max_length: int = 50 class Response(BaseModel): generated_text: str @app.post("/generate", response_model=Response) async def generate(request: Request): inputs = tokenizer(request.text, return_tensors="pt").to(device) with torch.no_grad(): outputs = model.generate( **inputs, max_length=request.max_length, do_sample=True, temperature=0.7, top_p=0.9 ) text = tokenizer.decode(outputs[0], skip_special_tokens=True) return Response(generated_text=text)

max_length控制生成长度，temperature=0.7让输出有点随机性但不至于乱说，top_p=0.9是核采样，只从累积概率 90% 的 token 里选。这两个参数是玄学重灾区：温度太低输出重复，太高胡言乱语；top_p 太小多样性差，太大容易跑偏。我一般先用 0.7 和 0.9 跑一批，看效果再微调。

启动命令：

uvicorn main:app --host 0.0.0.0 --port 8000 --workers 2

--workers 2表示两个进程，适合多核 CPU。如果 GPU 推理，workers 设 1 就行，否则显存会爆。

5. 避坑与排查：构建大模型时最容易翻车的 5 个地方

5.1 loss 变成 NaN：从学习率到 mask 的排查顺序

现象：训练几个 step 后 loss 突然变成 NaN，之后再也降不下来。

原因：最常见的是学习率太大，导致梯度爆炸。其次是 mask 全遮成-inf，softmax 后出现 NaN。还有可能是数据里有空序列。

解决：先把学习率降到 1e-5 试跑 100 step。如果还 NaN，检查 mask 是不是有整行被遮。最后检查数据管道，过滤掉长度为 0 的样本。我习惯在训练循环里加torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)，梯度裁剪能挡掉大部分爆炸。

5.2 显存不够：batch size 和梯度累积的换算关系

现象：CUDA out of memory，但 batch size 已经设成 1 了。

原因：模型参数、优化器状态、激活值加起来超了。Adam 优化器会为每个参数存两份状态，显存占用是模型参数的三倍。

解决：用梯度累积模拟大 batch。比如目标 batch size 是 32，但显存只够 4，就设gradient_accumulation_steps=8，每 8 个 step 更新一次参数。另外可以开混合精度训练，torch.cuda.amp能省一半显存。

scaler = torch.cuda.amp.GradScaler() for i, batch in enumerate(dataloader): with torch.cuda.amp.autocast(): outputs = model(**batch) loss = outputs.loss / gradient_accumulation_steps scaler.scale(loss).backward() if (i + 1) % gradient_accumulation_steps == 0: scaler.step(optimizer) scaler.update() optimizer.zero_grad()

5.3 微调后模型变傻：灾难性遗忘的缓解手段

现象：微调后模型在目标任务上表现不错，但通用能力大幅下降，连简单问题都答错。

原因：灾难性遗忘。微调数据分布和预训练数据差异太大，模型把预训练学到的知识覆盖了。

解决：降低学习率（比预训练小一个数量级），用 LoRA 代替全量微调，或者在微调数据里混入 10% 的预训练数据。我一般用 LoRA，因为只更新低秩矩阵，原始权重不动，遗忘问题轻很多。

5.4 推理速度慢：KV Cache 和批处理的正确打开方式

现象：生成 100 个 token 要好几秒，线上 QPS 上不去。

原因：每次生成一个 token 都重新计算整个序列的注意力，大量重复计算。

解决：开 KV Cache。把之前算过的 Key 和 Value 缓存下来，新 token 只算自己的 Q，然后和缓存的 K、V 做注意力。PyTorch 的generate默认开 KV Cache，但如果你自己写推理循环，记得手动实现。

past_key_values = None for _ in range(max_new_tokens): outputs = model(input_ids=next_token, past_key_values=past_key_values, use_cache=True) past_key_values = outputs.past_key_values next_token = outputs.logits[:, -1, :].argmax(dim=-1, keepdim=True)

另外，批处理能显著提升吞吐。把多个请求拼成一个 batch，GPU 利用率上去了，QPS 自然高。但注意 padding 要动态，否则短请求等长请求，延迟反而增加。

5.5 tokenizer 与模型不匹配：一个隐蔽的精度杀手

现象：模型加载成功，推理不报错，但输出全是乱码或重复。

原因：tokenizer 的词表和模型嵌入层的词表大小不一致。比如模型是按 30000 词表训的，你加载的 tokenizer 是 50000 词表，嵌入层对不上。

解决：检查tokenizer.vocab_size和model.config.vocab_size是否相等。如果不相等，要么换 tokenizer，要么调整模型嵌入层。我习惯在加载后打印这两个值，确认一致再往下走。

6. 进阶技巧：用一个小模型验证全流程，再放大到 BERT/GPT

6.1 小模型快速验证：2 层 Transformer 跑通全链路

在投入大模型之前，我强烈建议先用一个 2 层、d_model=128、num_heads=4的小模型跑通全流程。数据用几百条句子，训 10 个 epoch，看 loss 能不能降到 1 以下。如果能，说明代码没问题，再放大到 BERT 或 GPT 的规模。

# 小模型配置 config = { "d_model": 128, "num_heads": 4, "num_layers": 2, "d_ff": 512, "vocab_size": 30000, "max_len": 128 } class SmallLM(nn.Module): def __init__(self, config): super().__init__() self.embedding = nn.Embedding(config["vocab_size"], config["d_model"]) self.pos_encoding = PositionalEncoding(config["d_model"], config["max_len"]) self.layers = nn.ModuleList([ TransformerBlock(config["d_model"], config["num_heads"], config["d_ff"]) for _ in range(config["num_layers"]) ]) self.lm_head = nn.Linear(config["d_model"], config["vocab_size"]) def forward(self, input_ids, mask=None): x = self.embedding(input_ids) x = self.pos_encoding(x) for layer in self.layers: x = layer(x, mask) logits = self.lm_head(x) return logits

这个模型参数量大约 400 万，单卡几秒一个 epoch。跑通之后，把num_layers改成 12，d_model改成 768，就是 BERT-base 的规模。改的时候注意学习率要跟着调，小模型用 1e-3，大模型用 1e-4 或更低。

6.2 从 BERT 到 GPT：改三处代码就能切换模型类型

BERT 和 GPT 的代码差异其实只有三处：

改的时候，把mask从全 1 换成下三角，把 MLM 数据换成 CLM 数据，把输出头换成lm_head，就完成了切换。其他部分——嵌入、位置编码、Transformer 块——完全一样。

def get_causal_mask(seq_len): """生成下三角掩码，1 表示可见，0 表示不可见""" mask = torch.tril(torch.ones(seq_len, seq_len)).unsqueeze(0).unsqueeze(0) return mask # (1, 1, L, L)

这个 mask 在SelfAttention里用masked_fill(mask == 0, -inf)应用。注意形状要能广播到(B, H, L, L)。

6.3 验证模型是否真的学到了：三个必做的检查

训完模型，别急着上线。先做三个检查：

第一，看注意力权重。拿一个句子，打印每一层的注意力矩阵。如果所有位置都均匀关注，说明没学到东西；如果某些位置明显高亮，说明学到了。

第二，做消融。把位置编码去掉，看效果掉多少。如果没变化，说明模型根本没用到位置信息。

第三，测困惑度。在验证集上算 perplexity，如果比随机猜还差，说明训练有问题。困惑度公式是exp(loss)，loss 是交叉熵。

def calculate_perplexity(model, dataloader): model.eval() total_loss = 0 total_tokens = 0 with torch.no_grad(): for batch in dataloader: outputs = model(**batch) loss = outputs.loss total_loss += loss.item() * batch["input_ids"].size(0) total_tokens += batch["input_ids"].numel() avg_loss = total_loss / total_tokens return math.exp(avg_loss)

困惑度越低越好，但别追求太低——在验证集上困惑度 10 以下就不错了，再低可能是过拟合。

我自己的习惯是：每次训完模型，先跑这三个检查，再决定要不要部署。有一次偷懒跳过，结果上线后模型只会重复“的的的的”，排查半天才发现是 mask 写反了。这个教训让我至今保持“先验证再上线”的习惯。希望帮到你。

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