现在，让我们打造属于你自己的人工智能吧。

训练目标——错开一格的答案

把训练资料转成词元编号，就成了一长串编号。从中切出 13 个词元的片段，前 12 个作为输入，错开一格的后 12 个作为答案。

• 词元是 [a, b, c, d] 时，输入 [a, b, c] 的答案是 [b, c, d]。
• 位置 1 只看 a 预测 b，位置 2 看 a、b 预测 c，位置 3 看 a、b、c 预测 d。
• 多亏因果注意力，一次 forward 同时解 12 道题。

不需要人来标注答案，文字本身就成了题目和答案。所以网上的文字可以直接作为训练资料(自监督学习)。要准确预测下一个词元，必须懂语法、上下文、格式和事实，所以这个简单的目标能引出整个语言能力。

损失——交叉熵(正确概率的负对数)

设每个位置上模型给正确词元的概率为 p，该位置的损失就是 −log(p)。片段的损失是 12 个位置损失的平均。

• p = 1 时损失为 0：对答案很确定。
• p = 0.5 时是 0.693，p = 0.1 时是 2.303，p = 0.01 时是 4.605：给正确答案的概率越小，损失增长得越陡。
• 给错误答案大概率不会直接受罚。概率总和为 1，错误答案拿走得多，正确答案的 p 就变小，损失变大。

初始损失可以事先知道。训练前的模型给词表 40 个词元几乎相同的概率(1/40)，所以损失是 −log(1/40) = ln 40 ≈ 3.689。train.py 最先输出的 validation 3.7568 和这个值几乎相同，就说明模型正确初始化了。词表有 50,257 个的 GPT-2，初始损失约 10.8。对损失取 exp 的值叫困惑度(perplexity)，像 exp(3.689) = 40 这样，可以理解为"正在多少个选项中犹豫"。

词表有几万个的模型，损失大致这样解读：10 以上是随机水平，5~7 在学语法，3~5 在学格式，2~3 在学含义，降到 2 以下就要怀疑在死记(过拟合)。出发点随词表大小不同，所以在 XSLM 中看从出发点 3.69 下降了多少。

import math

for p in [1.0, 0.9, 0.5, 0.1, 0.01]:
    print('p =', p, ' loss =', round(0.0 - math.log(p), 4))
for vocab in [40, 50257]:
    print('guess evenly among', vocab, '->', round(math.log(vocab), 4))

cd ~/xslm
mkdir -p lab
micro lab/loss.py
python3 -m lab.loss

p = 1.0  loss = 0.0
p = 0.9  loss = 0.1054
p = 0.5  loss = 0.6931
p = 0.1  loss = 2.3026
p = 0.01  loss = 4.6052
guess evenly among 40 -> 3.6889
guess evenly among 50257 -> 10.8249

梯度下降与学习率——朝梯度反方向一点点走

梯度是"把这个数字稍微调大，损失会增加多少"。要减少损失，就把数字朝梯度的反方向移动。

• 新值 = 旧值 − 学习率 × 梯度

学习率(learning_rate)是一次移动多少。下面的实验从 0 出发，走 20 步寻找 f(w) = (w − 3)² 的最低点 w = 3。

• 0.01：太谨慎，只走到 1.0 附近。训练很慢。
• 0.1：走到 2.97，几乎到达。
• 0.5：对这个函数，一步就正好到 3。
• 1.1：跳得太大，反复越过谷底到对面，最后飞到 −112(发散)。

真实模型有几千到几十亿个数字，无法知道谷底的形状，所以学习率靠实验决定。XSLM 的 0.03 是让小模型不乱跳的谨慎值。改学习率会改变 settings.json，所以要用新检查点开始。

# f(w) = (w - 3) ** 2 is smallest at w = 3. Its gradient is 2 * (w - 3).
for lr in [0.01, 0.1, 0.5, 1.1]:
    w = 0.0
    for step in range(20):
        w -= lr * 2 * (w - 3)
    print('lr', lr, '-> w =', round(w, 4))

cd ~/xslm
mkdir -p lab
micro lab/descent.py
python3 -m lab.descent

lr 0.01 -> w = 0.9972
lr 0.1 -> w = 2.9654
lr 0.5 -> w = 3.0
lr 1.1 -> w = -112.0128

训练循环一圈——六步

train.py 的一次循环是这个顺序。

• 选片段：在训练词元序列中随机选起点，切出 13 个词元。
• 清梯度：把所有参数的 grad 设为 0。梯度用 += 累加，上一次循环的值留下就会混进来。本次片段中没出现的词元的嵌入行不在计算图中，backward 不会碰它们，所以不在这里清掉，旧梯度会一直留着。
• 前向传播：model.loss 完成 forward 和损失计算。
• 反向传播：用 loss.backward() 求出全部 1,248 个的梯度。
• 更新：限制梯度大小后，用 p.data −= 学习率 × 梯度 × 倍率 移动所有数字。
• 保存与记录：保存检查点，输出 step 和 loss。

训练按设定次数转这一圈。开始前和结束后，用验证资料的第一个片段测损失，看在没用于训练的文字上是否也有进步。

XSLM 不按资料过了几遍(epoch)计数，而是按步数(step)计数。片段是随机抽的，有些部分被抽到多次，有些少一些。大模型通常也按 step 计数。

梯度裁剪——一次别走太远

有时某个片段的梯度会突然变得非常大。直接更新，数字会一下子飞得很远，毁掉之前的训练(梯度爆炸)。所以 train.py 在更新前测量整个梯度的长度。

• 长度 = √(所有梯度平方之和)
• 倍率 = min(1, 1 ÷ 长度)
• 长度在 1 以下时倍率为 1，原样使用；大于 1 时，把所有梯度按同一比例缩小，使长度正好为 1。

关键是方向不变，只缩小大小。在 PyTorch 中由 clip_grad_norm_ 做同样的事(通常最大长度 1.0)。分母中的 1e-8 是为了在梯度全为 0 时不除以 0 而加的小数。

优化器——SGD 与 AdamW

用梯度修改数字的规则叫优化器。

• SGD(XSLM)：新值 = 旧值 − 学习率 × 梯度。只看当前梯度，不记忆任何东西。所以不需要在检查点里保存优化器状态。
• 动量：记住过去梯度的走势(速度)，方向一致就走得更快，摇摆时就少动。
• Adam、AdamW：为每个数字记住梯度的平均和大小的平均，自动为每个数字定出合适的步长。AdamW 再加上一点点缩小数字、防止过大的权重衰减(weight decay)。这是大语言模型训练的标准，学习率通常在 0.0003 左右。

Adam 每个参数要多记两个数字，所以要继续训练，检查点里也要保存这个状态(optimizer state)。因此 PyTorch 检查点里通常除了模型权重还有优化器状态。训练中的内存也是只放权重时的好几倍。

批——多个片段的平均梯度

XSLM 一次用一个片段(批大小 1)求梯度。每个片段内容不同，梯度波动大，所以损失也忽高忽低。

大模型一次计算多个片段，使用平均梯度。例如 16 个长 256 词元的片段(批大小 16)，一次更新就看 4,096 个词元。

• 取平均能减少波动，更新方向更稳定。
• GPU 同时计算多个片段，所以批变大，时间几乎不增加。
• 但内存也相应增加。内存不够(OOM)时就减小批或片段长度。

内存不足时，用梯度累积(gradient accumulation)：用小批多次 backward 收集梯度，再更新一次。XSLM 的 backward 开始时会把图中的梯度清为 0，所以不能直接用这个方法。

过拟合与欠拟合——同时看训练损失和验证损失

同时看两个损失，就能知道模型的状态。

• 两个都下降：学得很好。
• 只有训练损失下降，验证损失上升：过拟合。背下了训练资料，对没见过的文字反而更差。
• 两个都降不下来：欠拟合。模型太小、训练不足，或学习率不合适。

我们用 XSLM 实际测了一下(桌面 Python，默认资料)。默认学习率 0.03 训练 1,500 次，验证损失从 3.76 降到 3.23。学习率 0.1 训练 3,000 次，训练损失在某些片段降到 1.3，但验证损失升到 4.42；0.3 时升到 5.28。背下 12 对训练句子很容易，但资料不够多，学不到能用于没见过的 3 对的规则。

减少过拟合最可靠的方法是增加资料，也会用缩小模型、dropout、提前停止训练(使用验证损失最低的检查点)。欠拟合就把模型调大或多训练。

检查点——保存什么，为什么

checkpoints/model.json 包含停下后能准确继续训练所需的一切。

• weights：9 个矩阵的 1,248 个数字。
• step：到目前为止的更新次数。
• random：随机数生成器的状态。继续训练时，片段顺序无缝衔接。
• settings、tokenizer：模型的大小和编号规则。generate.py 和 runner.py 只读这些就能重建模型。
• data_hash：训练和验证资料的 SHA-256 指纹。用来判断资料是否变化。

所以分两次各训练 3 次的结果，和一次训练 6 次的结果，每个数字都一样。可以亲自验证：把运行两次 --steps 3 得到的 model.json 改名保存，再和重新运行一次 --steps 6 的结果比较。

保存是安全的。先完整写到 model.tmp，再用 os.replace 改名。改名是一瞬间完成的，所以写到一半按 Ctrl+C 或断电，model.json 也只会是之前的完整版或新的完整版之一。不会留下写了一半的坏文件。

PyTorch 用 torch.save 把权重、优化器状态、step 和设置保存为二进制文件(.pt)。XSLM 每一步都保存，但大模型保存也要花时间，所以每几百步评估并保存一次。

可复现性——用 seed 再次得到相同结果

计算机的随机数是从 seed(种子编号)按固定规则生成的数列。seed 相同，总会得到相同的数列。XSLM 用 seed 7 决定两处。

• 权重的初始值(model.py 的 random.Random(seed))。
• 训练片段的顺序(train.py 的 rng)。

所以资料和设置相同，谁在哪里运行都会走相同的训练过程。只改一个学习率来比较，其余的随机性必须相同，所以可复现性是实验的基础。改了 seed，就从不同的初始值出发，结果也会不同。依赖一个幸运 seed 得出的结论难以相信，所以重要的比较要换几个 seed 重复。

不过 Python 或操作系统的数学库不同，小数点末位可能不同，很长的训练中数字可能会逐渐拉开差距。

读训练记录——数字告诉你什么

train.py 会输出这样的行。

• parameters: 1248 resume: 0 —— 参数数量和继续开始的步数。第一次是 0。
• validation: 3.7568 —— 训练前的验证损失。应该接近 ln(词表数)。
• step: 1 loss: 3.6875 —— 每一步该片段的训练损失。
• validation: … —— 训练后的验证损失。
• saved: checkpoints/model.json —— 保存的位置。

每一步的 loss 因片段不同而起伏。不要只看一个数字，要看多步的走势。默认 20 次只是在 3.7 附近略有变动，几百到几千次才会明显下降。

flush=True 表示立刻把输出送到屏幕。没有它，Python 会把输出攒起来一次显示，看起来像训练卡住了，用 nohup 写入文件时也会记录得晚。

训练不顺时——按症状检查

用症状缩小原因范围。

• 损失在 3.7 附近几乎不动：训练次数少。增加 --steps，或者用新检查点稍微调大学习率试试。
• 损失大幅跳动或只升不降：学习率太大。调小后重新开始。
• ValueError: math domain error 或 nan：概率变成 0 而计算了 log(0)，或者数字发散了。降低学习率，检查是否有梯度裁剪。
• AssertionError: changed settings/tokenizer 或 changed data：检查点和当前设置、资料不同。把旧检查点移走，重新开始。
• AssertionError: add more text：训练或验证词元少于 13 个。在 raw.txt 中加行。
• 太慢：减小 width、context 会变快，但需要新检查点。先把 --steps 分小段运行。
• 训练好了但 Runner 的回答没变：Runner 只在启动时读一次。关掉再启动。