大模型原理与训练 / 系统课时

完成一轮小型 GPT 预训练

完成一轮小型 GPT 预训练

这一节把已经准备好的 token 数据真正送进一个小型 GPT,串起取批次、前向计算、AdamW、学习率调度、验证集评估与检查点保存。完成后,你将得到一条可重复运行、能用验证损失判断是否继续训练的最小预训练闭环。

学习目标

  • 把训练数据、GPT、优化器和学习率调度器接成完整训练循环
  • 定期计算训练与验证损失,并保存验证集最优检查点
  • 根据验证损失趋势判断继续训练、提前停止或调整配置

先锁定训练输入与验收指标

下面示例假设数据预处理已经产出 data/shakespeare_char/train.bin、val.bin 和 meta.pkl。两个二进制文件保存 uint16 token ID,meta.pkl 至少包含 vocab_size。如果你使用 GPT-2 BPE 数据,只需把目录改成对应预处理结果,训练循环本身不变。

这轮训练先只验收三件事:训练损失能够下降;验证损失在若干评估点上至少出现一次改善;out/ckpt.pt 能保存最优模型、优化器状态和迭代位置。不要只看训练损失,它持续下降而验证损失回升,通常说明已经开始过拟合。

看清一次迭代如何闭环

小型 GPT 预训练闭环

训练时每个 batch 都会执行“取样本 → 前向 → 计算 loss → 反向 → 更新参数”。验证路径不做反向传播,只周期性抽取多个 batch 求平均 loss。只有验证 loss 创下新低时才覆盖检查点,因此磁盘中的文件始终代表当前最好版本,而不是最后一次迭代。

跑通一轮可恢复训练

将下面程序保存为 train_small.py,并在项目根目录执行 python train_small.py。示例使用一个最小因果 Transformer,重点是把训练闭环完整跑通;如果你已经有自己的 GPT 类,可保持训练循环不变,只替换 TinyGPT。

python
from pathlib import Path
import math
import pickle

import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F

torch.manual_seed(1337)
device = "cuda" if torch.cuda.is_available() else "cpu"

data_dir = Path("data/shakespeare_char")
out_dir = Path("out")
out_dir.mkdir(exist_ok=True)
ckpt_path = out_dir / "ckpt.pt"

block_size = 128
batch_size = 32
n_layer, n_head, n_embd = 4, 4, 128
max_iters = 600
eval_interval, eval_iters = 100, 20
learning_rate, min_lr = 3e-4, 3e-5
warmup_iters = 50
patience = 3

with open(data_dir / "meta.pkl", "rb") as f:
    vocab_size = pickle.load(f)["vocab_size"]

train_data = np.memmap(data_dir / "train.bin", dtype=np.uint16, mode="r")
val_data = np.memmap(data_dir / "val.bin", dtype=np.uint16, mode="r")

def get_batch(split):
    data = train_data if split == "train" else val_data
    ix = torch.randint(len(data) - block_size - 1, (batch_size,))
    x = torch.stack([
        torch.from_numpy(np.array(data[i:i + block_size], dtype=np.int64))
        for i in ix
    ])
    y = torch.stack([
        torch.from_numpy(np.array(data[i + 1:i + 1 + block_size], dtype=np.int64))
        for i in ix
    ])
    return x.to(device), y.to(device)

class Block(nn.Module):
    def __init__(self):
        super().__init__()
        self.ln1 = nn.LayerNorm(n_embd)
        self.attn = nn.MultiheadAttention(
            n_embd, n_head, dropout=0.0, batch_first=True
        )
        self.ln2 = nn.LayerNorm(n_embd)
        self.mlp = nn.Sequential(
            nn.Linear(n_embd, 4 * n_embd),
            nn.GELU(),
            nn.Linear(4 * n_embd, n_embd),
        )

    def forward(self, x):
        t = x.size(1)
        mask = torch.full((t, t), float("-inf"), device=x.device)
        mask = torch.triu(mask, diagonal=1)
        h = self.ln1(x)
        a, _ = self.attn(h, h, h, attn_mask=mask, need_weights=False)
        x = x + a
        return x + self.mlp(self.ln2(x))

class TinyGPT(nn.Module):
    def __init__(self):
        super().__init__()
        self.tok_emb = nn.Embedding(vocab_size, n_embd)
        self.pos_emb = nn.Embedding(block_size, n_embd)
        self.blocks = nn.ModuleList([Block() for _ in range(n_layer)])
        self.ln_f = nn.LayerNorm(n_embd)
        self.lm_head = nn.Linear(n_embd, vocab_size, bias=False)
        self.lm_head.weight = self.tok_emb.weight

    def forward(self, idx, targets=None):
        _, t = idx.shape
        pos = torch.arange(t, device=idx.device)
        x = self.tok_emb(idx) + self.pos_emb(pos)
        for block in self.blocks:
            x = block(x)
        logits = self.lm_head(self.ln_f(x))
        loss = None
        if targets is not None:
            loss = F.cross_entropy(
                logits.view(-1, vocab_size), targets.view(-1)
            )
        return logits, loss

model = TinyGPT().to(device)
optimizer = torch.optim.AdamW(
    model.parameters(), lr=learning_rate, weight_decay=0.1
)

def get_lr(it):
    if it < warmup_iters:
        return learning_rate * (it + 1) / warmup_iters
    ratio = min(1.0, (it - warmup_iters) / (max_iters - warmup_iters))
    coeff = 0.5 * (1.0 + math.cos(math.pi * ratio))
    return min_lr + coeff * (learning_rate - min_lr)

@torch.no_grad()
def estimate_loss():
    model.eval()
    result = {}
    for split in ("train", "val"):
        values = torch.zeros(eval_iters)
        for k in range(eval_iters):
            x, y = get_batch(split)
            _, loss = model(x, y)
            values[k] = loss.item()
        result[split] = values.mean().item()
    model.train()
    return result

start_iter, best_val, stale = 0, float("inf"), 0
if ckpt_path.exists():
    state = torch.load(ckpt_path, map_location=device)
    model.load_state_dict(state["model"])
    optimizer.load_state_dict(state["optimizer"])
    start_iter = state["iter"] + 1
    best_val = state["best_val"]
    print(f"resumed from iter={start_iter}")

print(f"device={device} vocab_size={vocab_size}")

for it in range(start_iter, max_iters):
    lr = get_lr(it)
    for group in optimizer.param_groups:
        group["lr"] = lr

    if it % eval_interval == 0:
        losses = estimate_loss()
        print(
            f"iter={it:04d} train_loss={losses['train']:.4f} "
            f"val_loss={losses['val']:.4f} lr={lr:.2e}"
        )
        if losses["val"] < best_val:
            best_val, stale = losses["val"], 0
            torch.save(
                {
                    "model": model.state_dict(),
                    "optimizer": optimizer.state_dict(),
                    "iter": it,
                    "best_val": best_val,
                },
                ckpt_path,
            )
            print(f"checkpoint saved: {ckpt_path}")
        else:
            stale += 1
            if stale >= patience:
                print("early stop: validation loss stopped improving")
                break

    x, y = get_batch("train")
    _, loss = model(x, y)
    optimizer.zero_grad(set_to_none=True)
    loss.backward()
    torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
    optimizer.step()

print(f"training finished: best_val={best_val:.4f}")

预期输出

text
device=<DEVICE> vocab_size=<VOCAB_SIZE>
iter=0000 train_loss=<TRAIN_LOSS> val_loss=<VAL_LOSS> lr=<LEARNING_RATE>
checkpoint saved: out/ckpt.pt
iter=0100 train_loss=<TRAIN_LOSS> val_loss=<VAL_LOSS> lr=<LEARNING_RATE>
...
training finished: best_val=<BEST_VAL>

<DEVICE>、<VOCAB_SIZE> 和各项 loss 会随环境、数据与随机采样变化。第一次评估必然会保存检查点,因为初始 best_val 为正无穷;后续只有验证损失继续降低才会覆盖该文件。如果连续三个评估点都没有改善,程序会提前停止。

用验证损失决定下一步

观察验证曲线时,先比较趋势而不是单个点。训练损失与验证损失都下降,说明还在有效学习;训练损失下降但验证损失连续上升,优先考虑提前停止、增大数据量或减小模型容量;两者都几乎不动,则检查学习率是否过小、数据是否重复或梯度是否异常。

如果 loss 明显震荡甚至变成 nan,先把学习率降低到原来的三分之一到十分之一,再检查输入 token 是否越界和梯度范数是否爆炸。若训练稳定但很慢,可在显存允许时增大 batch_size,或使用梯度累积获得更大的有效 batch,而不要直接把学习率同时放大。

验收检查点而不是只看日志

训练结束后至少确认 out/ckpt.pt 存在,并且保存的是验证集最优版本。重新执行脚本时,如果看到 resumed from iter=<ITER>,说明模型、优化器和迭代位置都能恢复;若只恢复模型参数而丢失优化器状态,学习率与 AdamW 的动量会重新开始,继续训练的轨迹会发生明显变化。

完成这一轮后,是否继续扩大模型或训练步数应由验证损失决定:验证损失仍稳定下降时继续训练;长期平台期先调学习率或数据;持续恶化则保留最佳检查点并停止,而不是机械地跑满最大迭代数。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

完成一轮小型 GPT 预训练

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通