scratch2modern
第一章 · 训练

1.01 microgpt

这一节起点:Karpathy 的 microgpt,200 行纯 Python 的 GPT
结果在 names 上训练 1000 步,CPU 上 109 秒,loss 2.65
$ python train.py
num docs: 32033
vocab size: 27
num params: 4192
step 1000 / 1000 | loss 2.6497
--- inference (new, hallucinated names) ---
sample  1: kamonsample  2: annsample  3: karaisample  4: jairesample  5: vialansample  6: kariasample  7: yeransample  8: annasample  9: arelisample 10: kainasample 11: konnasample 12: keylensample 13: liolesample 14: alerinsample 15: earansample 16: lennesample 17: kanasample 18: larasample 19: alelasample 20: anton

这是 Andrej Karpathy 的 microgpt 训练完的输出:4192 个参数,在 CPU 上训练 109 秒,编出了 20 个名字。标色的 9 个在训练数据里没有出现过。

首先,语言模型在做什么。最简单地来说,就是给它一段文字,让它猜下一个字是什么。

计算机只能对数字进行计算,所以要先把文字编码成数字,我们叫做 tokenize。相当于构建了一本字典,每个字对应字典里的一个编号(token)。microgpt 的字典很小,就是 26 个字母,再加一个 BOS 表示名字的开头和结尾,一共 27 项。比如 emma 就变成了 BOS e m m a BOS 这 6 个编号。

而接下来的一系列计算,就是模型干的事。模型算出来的并不是某一个字,而是字典里每一项的概率。比如看到 BOS e m,下一个是 m 的可能性大一些,i 也有可能,q 就几乎不可能。生成的时候,按这个概率抽一个字接到后面,再拿去猜下一个,直到抽到 BOS,一个名字就生成完了。开头那 20 个名字,就是这样一个字母一个字母抽出来的。

模型一开始是乱猜的。训练就是拿真实的名字去教它:每一步看它给正确的下一个字分了多少概率,然后调整模型的参数,让这个概率变大一点。重复很多次,模型就越猜越准。

那这一系列计算具体长什么样?现在主流的语言模型几乎都是 Transformer,而 microgpt 用的是其中最经典的 GPT-2 结构,只是做了简化。GPT-2 是 OpenAI 在 2019 年发布的,到今天的大模型,基本都还是这个骨架,只是换了一些部件。

对着右边的图,从上往下看,模型每次处理一个位置:

  1. 输入当前 token 的编号和它所在的位置,各查一张表,得到两个向量,相加。从这里开始,每个 token 都用一串数来表示,microgpt 里是 16 个。
  2. 注意力(attention):当前位置去看前面所有的位置,挑出和自己相关的,把它们的信息取回来。猜下一个字母时,模型就是靠这一步知道前面已经写了什么。
  3. MLP:在当前位置上,把取回来的信息再加工一遍。
  4. 注意力加 MLP 合起来叫一个 block。最小的 GPT-2 叠了 12 层,microgpt 只有 1 层。
  5. 最后乘一个矩阵,把 16 个数变成 27 个得分,再经过 softmax 变成 27 个概率。

图里还有两样东西:每一块前面都先做一次归一化(RMSNorm),把这串数的大小拉回到差不多的范围;每一块的输出都加回到输入上(残差,图里的 +),这样每一块只需要学"在原来基础上改多少"。这两样都是为了让层数叠多了以后,模型还训得动。

和原版 GPT-2 比,microgpt 把 LayerNorm 换成了更简单的 RMSNorm,把 GELU 换成了 ReLU,去掉了所有偏置项(bias)。这些都不影响我们理解它是怎么工作的。

token(如 m) 位置(如 3) token 向量 位置向量 + 每个 token 变成 16 个数 RMSNorm × n_layer(GPT-2 12 层,microgpt 1 层) RMSNorm 注意力 attention 看前面的位置, 把有用的信息取回来 + 残差 RMSNorm MLP 16 → 64 → 16 在当前位置上, 把信息再加工一遍 + lm_head 16 → 27 27 个得分 softmax 下一个 token 的 27 个概率

microgpt 把上面这些,连同训练用的自动求导和优化器,全部写进了一个两百行的 Python 文件,不依赖任何库。文件开头写着 “This file is the complete algorithm. Everything else is just efficiency.”(原文)

我们拿它当起点,原因有三个:

  1. 它是完整的。从读数据到生成文本,训练和使用一个 GPT 需要的东西都在,结构就是 GPT-2 的简化版。
  2. 它是透明的。没有一行藏在库里,每个数、每一次运算都看得见。
  3. 它只有算法。没有为了速度或效果额外加的东西,之后我们每加一样,都能单独看出它的作用。

下面按文件的顺序把代码分成 9 块贴出来。原来的英文注释换成了中文,记日志的几行去掉了,完整文件在 GitHub。强烈建议打开编辑器,跟着手敲一遍。敲的时候你会停下来想“这一行为什么这样写”,而这些地方读的时候很容易一眼滑过去。

1数据读入 32033 个英文名字
import os
import math
import random
random.seed(42)  # 固定随机种子:初始化、打乱、采样每次都一样,结果可以复现

# 每行一个名字,每个名字就是一篇"文档"
data_path = 'names.txt'
if not os.path.exists(data_path):
    import urllib.request
    names_url = 'https://raw.githubusercontent.com/karpathy/makemore/988aa59/names.txt'
    urllib.request.urlretrieve(names_url, data_path)
docs = [line.strip() for line in open(data_path) if line.strip()]
random.shuffle(docs)  # 打乱顺序,训练时按顺序往下取
print(f"num docs: {len(docs)}")
2Tokenizer把文字变成编号
# 字符级:数据里出现过的每个字符就是一个 token,a..z 编号 0..25
uchars = sorted(set(''.join(docs)))
# 特殊 token BOS,编号 26,加在每个名字的两头:
# 开头的告诉模型"开始了",结尾的让模型学会"什么时候停"
BOS = len(uchars)
vocab_size = len(uchars) + 1  # 词表一共 27 个
print(f"vocab size: {vocab_size}")
3自动求导每个数记住自己从哪来,反向时按链式法则求梯度
# 每个标量都是一个 Value。做运算时,结果记住自己由哪几个数算来、对它们的局部导数是多少。
# 算完 loss 以后从它往回走,就能得到 loss 对每个参数的导数(梯度)。
class Value:
    __slots__ = ('data', 'grad', '_children', '_local_grads')  # 省内存

    def __init__(self, data, children=(), local_grads=()):
        self.data = data                 # 前向算出的值
        self.grad = 0                    # loss 对它的导数,反向时填入
        self._children = children        # 它由哪几个 Value 算来
        self._local_grads = local_grads  # 它对每个 child 的局部导数

    def __add__(self, other):
        other = other if isinstance(other, Value) else Value(other)
        # c = a + b:c 对 a、b 的局部导数都是 1
        return Value(self.data + other.data, (self, other), (1, 1))

    def __mul__(self, other):
        other = other if isinstance(other, Value) else Value(other)
        # c = a * b:c 对 a 的局部导数是 b,对 b 的是 a
        return Value(self.data * other.data, (self, other), (other.data, self.data))

    # 幂、log、exp、relu 同理,各自写好局部导数
    def __pow__(self, other): return Value(self.data**other, (self,), (other * self.data**(other-1),))
    def log(self): return Value(math.log(self.data), (self,), (1/self.data,))
    def exp(self): return Value(math.exp(self.data), (self,), (math.exp(self.data),))
    def relu(self): return Value(max(0, self.data), (self,), (float(self.data > 0),))
    # 减法、除法等都化成上面几种运算
    def __neg__(self): return self * -1
    def __radd__(self, other): return self + other
    def __sub__(self, other): return self + (-other)
    def __rsub__(self, other): return other + (-self)
    def __rmul__(self, other): return self * other
    def __truediv__(self, other): return self * other**-1
    def __rtruediv__(self, other): return other * self**-1

    def backward(self):
        # 拓扑排序:保证处理一个节点时,所有用到它的节点都已经处理完
        topo = []
        visited = set()
        def build_topo(v):
            if v not in visited:
                visited.add(v)
                for child in v._children:
                    build_topo(child)
                topo.append(v)
        build_topo(self)
        self.grad = 1  # loss 对自己的导数是 1
        # 从 loss 往回走:child 的梯度 += 局部导数 × 上游梯度,这就是链式法则
        # 用 += 是因为同一个数可能被多处用到,各处传回的梯度要加起来
        for v in reversed(topo):
            for child, local_grad in zip(v._children, v._local_grads):
                child.grad += local_grad * v.grad
4参数4192 个随机初始化的数
n_layer = 1      # 层数
n_embd = 16      # 宽度:每个 token 用 16 个数表示
block_size = 16  # 最长上下文:最长的名字 15 个字母,再加一个 BOS
n_head = 4       # 注意力头数
head_dim = n_embd // n_head  # 每个头 4 维
# 所有参数从 N(0, 0.08²) 随机取值
matrix = lambda nout, nin, std=0.08: [[Value(random.gauss(0, std)) for _ in range(nin)] for _ in range(nout)]
# wte:token 嵌入,每个 token 一行;wpe:位置嵌入,每个位置一行;lm_head:输出层,16 维 → 27 个得分
state_dict = {'wte': matrix(vocab_size, n_embd), 'wpe': matrix(block_size, n_embd), 'lm_head': matrix(vocab_size, n_embd)}
for i in range(n_layer):
    # 注意力:q、k、v 三个投影,加一个输出投影
    state_dict[f'layer{i}.attn_wq'] = matrix(n_embd, n_embd)
    state_dict[f'layer{i}.attn_wk'] = matrix(n_embd, n_embd)
    state_dict[f'layer{i}.attn_wv'] = matrix(n_embd, n_embd)
    state_dict[f'layer{i}.attn_wo'] = matrix(n_embd, n_embd)
    # MLP:16 → 64 → 16
    state_dict[f'layer{i}.mlp_fc1'] = matrix(4 * n_embd, n_embd)
    state_dict[f'layer{i}.mlp_fc2'] = matrix(n_embd, 4 * n_embd)
params = [p for mat in state_dict.values() for row in mat for p in row]  # 摊平成一个列表,方便逐个更新
print(f"num params: {len(params)}")  # 4192
5基本运算linear、softmax、rmsnorm
# 结构照 GPT-2,做了三处简化:LayerNorm 换成 RMSNorm,去掉所有 bias,GeLU 换成 ReLU

# 矩阵乘向量:w 的每一行和 x 做点积,没有 bias
def linear(x, w):
    return [sum(wi * xi for wi, xi in zip(wo, x)) for wo in w]

# 把一组数变成和为 1 的概率:取指数变成正数,再除以总和
# 先减去最大值:结果不变,但 exp 不会因为数太大而溢出
def softmax(logits):
    max_val = max(val.data for val in logits)
    exps = [(val - max_val).exp() for val in logits]
    total = sum(exps)
    return [e / total for e in exps]

# 把向量缩放到均方根为 1,数值不会随着层层累加而失控
# 和 LayerNorm 相比,不减均值,也没有可学习的缩放和偏置
def rmsnorm(x):
    ms = sum(xi * xi for xi in x) / len(x)
    scale = (ms + 1e-5) ** -0.5
    return [xi * scale for xi in x]
6模型嵌入 → 注意力 → MLP → 输出
# 一次处理一个位置:输入当前 token 和它的位置,输出 27 个得分(logits),表示下一个 token 是谁
# keys、values 里存着之前每个位置算出的 k、v,供当前位置的注意力使用
def gpt(token_id, pos_id, keys, values):
    tok_emb = state_dict['wte'][token_id]  # 查表得到 token 向量
    pos_emb = state_dict['wpe'][pos_id]    # 查表得到位置向量
    x = [t + p for t, p in zip(tok_emb, pos_emb)]  # 两者相加
    x = rmsnorm(x)  # 后面的残差会把这个 x 原样加回去,所以这一次归一化不是多余的

    for li in range(n_layer):
        # 1) 注意力:从前文里取回有用的信息
        x_residual = x
        x = rmsnorm(x)  # pre-norm:先归一化,再进入这一块
        q = linear(x, state_dict[f'layer{li}.attn_wq'])  # 我要找什么
        k = linear(x, state_dict[f'layer{li}.attn_wk'])  # 我这里有什么
        v = linear(x, state_dict[f'layer{li}.attn_wv'])  # 我能提供什么
        # 存下来给后面的位置用。位置是一个个往后算的,当前位置只看得到自己和之前的位置,不需要 mask
        keys[li].append(k)
        values[li].append(v)
        x_attn = []
        for h in range(n_head):  # 4 个头各自独立算一遍
            hs = h * head_dim
            q_h = q[hs:hs+head_dim]
            k_h = [ki[hs:hs+head_dim] for ki in keys[li]]
            v_h = [vi[hs:hs+head_dim] for vi in values[li]]
            # q 和每个位置的 k 做点积,越大说明那个位置越相关
            # 除以 √head_dim:维度越大点积越大,不除的话 softmax 会几乎只选中一个位置
            attn_logits = [sum(q_h[j] * k_h[t][j] for j in range(head_dim)) / head_dim**0.5 for t in range(len(k_h))]
            attn_weights = softmax(attn_logits)  # 变成和为 1 的权重
            head_out = [sum(attn_weights[t] * v_h[t][j] for t in range(len(v_h))) for j in range(head_dim)]  # 按权重对 v 求和
            x_attn.extend(head_out)  # 4 个头拼回 16 维
        x = linear(x_attn, state_dict[f'layer{li}.attn_wo'])
        x = [a + b for a, b in zip(x, x_residual)]  # 残差:结果加回输入,这一块只需学"改动多少"
        # 2) MLP:在当前位置上加工信息
        x_residual = x
        x = rmsnorm(x)
        x = linear(x, state_dict[f'layer{li}.mlp_fc1'])  # 16 → 64
        x = [xi.relu() for xi in x]  # 负数变 0。没有这个非线性,两次矩阵乘法合起来还是一次
        x = linear(x, state_dict[f'layer{li}.mlp_fc2'])  # 64 → 16
        x = [a + b for a, b in zip(x, x_residual)]  # 残差

    logits = linear(x, state_dict['lm_head'])  # 16 → 27
    return logits
7Adam优化器的状态
# 每个参数记两个滑动平均:m 是梯度的平均,让方向更稳;v 是梯度平方的平均,用来把步长归一化
# β1、β2 决定平均的窗口长短,这里比常见的 0.9 / 0.999 小,窗口更短
learning_rate, beta1, beta2, eps_adam = 0.01, 0.85, 0.99, 1e-8
m = [0.0] * len(params)
v = [0.0] * len(params)
8训练循环前向、反向、更新,重复 1000 步
num_steps = 1000
for step in range(num_steps):

    # 每步取一个名字,两头加上 BOS:emma → [BOS, e, m, m, a, BOS]
    doc = docs[step % len(docs)]
    tokens = [BOS] + [uchars.index(ch) for ch in doc] + [BOS]
    n = min(block_size, len(tokens) - 1)  # 要预测的位置数

    # 前向:从左往右,每个位置预测下一个 token
    keys, values = [[] for _ in range(n_layer)], [[] for _ in range(n_layer)]
    losses = []
    for pos_id in range(n):
        token_id, target_id = tokens[pos_id], tokens[pos_id + 1]
        logits = gpt(token_id, pos_id, keys, values)
        probs = softmax(logits)
        loss_t = -probs[target_id].log()  # 给正确答案的概率越高,loss 越小
        losses.append(loss_t)
    loss = (1 / n) * sum(losses)  # 对所有位置取平均

    # 反向:一次调用,4192 个参数的梯度全部算好
    loss.backward()

    # 更新
    lr_t = learning_rate * (1 - step / num_steps)  # 学习率从 0.01 线性降到 0
    for i, p in enumerate(params):
        m[i] = beta1 * m[i] + (1 - beta1) * p.grad
        v[i] = beta2 * v[i] + (1 - beta2) * p.grad ** 2
        # m、v 从 0 开始累积,前几步偏小,除以 1 - β^t 补回来
        m_hat = m[i] / (1 - beta1 ** (step + 1))
        v_hat = v[i] / (1 - beta2 ** (step + 1))
        p.data -= lr_t * m_hat / (v_hat ** 0.5 + eps_adam)  # 沿 m/√v 的反方向走一步
        p.grad = 0  # 梯度清零,下一步重新累加

    print(f"step {step+1:4d} / {num_steps:4d} | loss {loss.data:.4f}", end='\r')
9生成从 BOS 开始一个个往后抽
temperature = 0.5  # 先把 logits 除以它再 softmax。小于 1 让分布更尖:名字更像样,变化也更少
print("\n--- inference (new, hallucinated names) ---")
for sample_idx in range(20):
    keys, values = [[] for _ in range(n_layer)], [[] for _ in range(n_layer)]
    token_id = BOS  # 从 BOS 开始
    sample = []
    for pos_id in range(block_size):
        logits = gpt(token_id, pos_id, keys, values)
        probs = softmax([l / temperature for l in logits])
        token_id = random.choices(range(vocab_size), weights=[p.data for p in probs])[0]  # 按概率抽一个
        if token_id == BOS:  # 抽到 BOS,名字结束
            break
        sample.append(uchars[token_id])
    print(f"sample {sample_idx+1:2d}: {''.join(sample)}")

运行结果

原样跑 1000 步,单线程 CPU 上用了 109 秒。每步一个名字,一共读了 7170 个 token。

2.0 3.0 4.0 0 250 500 750 1000 训练步数 随机猜:ln 27 ≈ 3.30
每一步的训练 loss。灰线是单步的值,粗线是最近 50 步的平均,虚线是瞎猜的水平 ln 27 ≈ 3.30。

loss 从 3.4 左右降到 2.3 左右。对 27 个 token 均匀瞎猜,loss 是 ln 27 ≈ 3.30;刚开始的模型比瞎猜还差一点,因为随机初始化的模型不是均匀地猜,而是带着偏好猜错。

前 200 步降得很快,之后在 2.4 到 2.5 之间徘徊,最后 200 步学习率接近 0,又降了一点。灰线抖得厉害,因为每步只看一个名字,名字之间难度差别很大。

学到的东西就是开头那 20 个名字,没见过的也像英文名字。代价是慢:每秒只能处理 66 个 token。每一次加法、乘法都要创建一个 Python 对象、记下它的来历,真正的算术只占很小一部分。