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

engine.py Value——一个数字和它的来历

class Value:
    def __init__(self, data, parents=()):
        self.data = float(data)
        self.grad = 0.0
        self.parents = parents

Value 包装一个数字。data 是值，grad 是损失对这个值的导数(初始为 0)，parents 是生成这个值的输入以及对这些输入的局部导数的列表。像权重这样一开始就存在的值，parents 是空的。用 float(data) 转换，所以放入整数也按浮点数计算。

engine.py 运算符——一边计算一边记下导数

    def __add__(self, other):
        other = other if isinstance(other, Value) else Value(other)
        return Value(self.data + other.data, ((self, 1), (other, 1)))

    def __mul__(self, other):
        other = other if isinstance(other, Value) else Value(other)
        return Value(self.data * other.data,
                     ((self, other.data), (other, self.data)))

    def __pow__(self, power):
        return Value(self.data ** power,
                     ((self, power * self.data ** (power - 1)),))

    def __neg__(self):
        return self * -1

    def __sub__(self, other):
        return self + (-other)

    def __truediv__(self, other):
        return self * (other ** -1)

    __radd__ = __add__
    __rmul__ = __mul__

Python 把 a + b 换成 a.__add__(b) 来调用。定义了这些特殊方法，Value 之间就能像普通算式一样计算。

• __add__：结果 = a + b。局部导数 a 侧为 1，b 侧为 1。
• __mul__：结果 = a × b。局部导数 a 侧为 b 的值，b 侧为 a 的值。
• __pow__：a 的 n 次方。局部导数为 n × a 的 (n − 1) 次方。
• __neg__、__sub__、__truediv__：减法换成乘 −1 再相加，除法换成乘以 −1 次方，复用上面三种。不需要新的求导规则。
• other 不是 Value 时(像 2 这样的普通数)，就包装成 Value。
• __radd__、__rmul__：像 2 * x 这样左边是普通数时调用。sum() 从 0 + 第一个值开始，所以有 __radd__ 才能对 Value 列表求 sum。

engine.py exp、log、relu——函数的导数

    def exp(self):
        result = math.exp(self.data)
        return Value(result, ((self, result),))

    def log(self):
        return Value(math.log(self.data), ((self, 1 / self.data),))

    def relu(self):
        return Value(max(0, self.data), ((self, float(self.data > 0)),))

exp 的导数是它自身，所以直接记下结果值 result。log x 的导数是 1/x。relu 正数时记梯度 1，0 以下记 0。float(self.data > 0) 为真时是 1.0，为假时是 0.0。只要有这三种和四则运算，就能求出整个模型的导数。

engine.py backward——倒着走图收集梯度

    def backward(self):
        order, seen, stack = [], set(), [(self, False)]
        while stack:
            node, expanded = stack.pop()
            if expanded:
                order.append(node)
            elif node not in seen:
                seen.add(node)
                stack.append((node, True))
                stack.extend((parent, False) for parent, _ in node.parents)
        for node in order:
            node.grad = 0.0
        self.grad = 1.0
        for node in reversed(order):
            for parent, derivative in node.parents:
                parent.grad += derivative * node.grad

分两步。

• 建立顺序(第46~54行)：用 stack 深度优先遍历图，生成 order。节点以 (节点, False) 第一次被取出时，在 seen 中标记，重新压入 (节点, True)，再压入各父节点。所有父节点处理完后，(节点, True) 被取出时才放进 order，所以在 order 中输入总是排在结果前面(拓扑排序)。
• 传播梯度(第55~60行)：把图中所有节点的 grad 清为 0，损失自身设为 1.0(dL/dL = 1)。倒着走 order(从结果到输入)，给每个父节点加上"局部导数 × 我的 grad"。因为倒着走，一个节点的 grad 从所有用处收集完毕之后，才会传给它的父节点。

engine.py softmax——不会溢出的概率

def softmax(values):
    peak = max(v.data for v in values)
    exps = [(v - peak).exp() for v in values]
    total = sum(exps)
    return [v / total for v in exps]

peak 是分数中最大的值(用 .data 取出的普通数)。所有分数减去 peak 再取 exp，最大值变成 1，不会溢出。除以总和 total，就得到总和为 1 的概率。peak 作为普通数相减，不会记录在图中，但所有分数减去同一个数概率不变，所以导数也仍然正确。

engine.py linear、norm——矩阵乘法与归一化

def linear(x, weights):
    return [sum(a * b for a, b in zip(x, row)) for row in weights]


def norm(x):
    mean = sum(x) / len(x)
    variance = sum((v - mean) ** 2 for v in x) / len(x)
    return [(v - mean) * (variance + 1e-5) ** -0.5 for v in x]

linear 对 weights 的每一行(row)，与 x 同一格相乘再相加，输出结果。所以 weights 是(输出格数)行 × (输入格数)格，结果的格数等于行数。PyTorch 的 nn.Linear 也按(输出, 输入)的形状保存权重。norm 求出平均 mean 和方差 variance 后，换成(值 − 平均) ÷ √(方差 + 0.00001)。取 -0.5 次方等于除以平方根。

engine.py 自我检查

if __name__ == '__main__':
    x = Value(3)
    y = x * x + 2 * x
    y.backward()
    print('y =', y.data, 'dy/dx =', x.grad)
    assert y.data == 15 and x.grad == 8

直接运行 engine.py，会在 x = 3 处计算 y = x² + 2x 并求导。y = 9 + 6 = 15，dy/dx = 2·3 + 2 = 8 才对，assert 会确认这一点。如果改过引擎，先重新运行这个检查。

model.py 建立 9 种权重

class GPT:
    def __init__(self, vocab_size, width, context, seed=7):
        self.width, self.context = width, context
        rng = random.Random(seed)
        shapes = {
            'token': (vocab_size, width), 'position': (context, width),
            'query': (width, width), 'key': (width, width),
            'value': (width, width), 'project': (width, width),
            'expand': (2 * width, width), 'contract': (width, 2 * width),
            'head': (vocab_size, width),
        }
        self.weights = {
            name: [[Value(rng.gauss(0, 0.1)) for _ in range(cols)]
                   for _ in range(rows)] for name, (rows, cols) in shapes.items()
        }
        self.parameters = [v for matrix in self.weights.values()
                           for row in matrix for v in row]

shapes 字典为每个矩阵定好(行数, 格数)。字典推导式为每个名称生成 行数 × 格数 个 Value(rng.gauss(0, 0.1))。这是从平均 0、标准差 0.1 的正态分布中抽出的小数。如果全部填 0，所有格都会一样地变化，学不到不同的特征，所以从随机开始。rng 用 seed 创建，所以初始值总是相同。parameters 是把 9 个矩阵的 Value 展开成的一个列表，是训练要修改的全部数字。

model.py forward 开始——词元加位置

    def forward(self, ids):
        assert 0 < len(ids) <= self.context
        w, keys, values, output = self.weights, [], [], []
        for position, token in enumerate(ids):
            x = [a + b for a, b in zip(w['token'][token], w['position'][position])]
            h = norm(x)

assert 把输入长度限制在 1 以上、context 以下。位置表的行数是 context，更长就没有位置向量。keys、values 是用来积累前面各位置 key、value 的列表。每次循环接收 position(从 0 开始)和 token 编号，把词元向量和位置向量按格相加得到 x。h = norm(x) 是要放进注意力的归一化值(Pre-LN)。

model.py 一个头的因果注意力

            q = linear(h, w['query'])
            keys.append(linear(h, w['key']))
            values.append(linear(h, w['value']))
            scores = [sum(a * b for a, b in zip(q, k)) / self.width ** 0.5
                      for k in keys]
            attention = softmax(scores)
            mixed = [sum(p * v[i] for p, v in zip(attention, values))
                     for i in range(self.width)]
            x = [a + b for a, b in zip(x, linear(mixed, w['project']))]

q 是当前位置的 query，当前位置的 key、value 加到列表末尾。列表中只有到目前为止的位置，所以看不到未来。scores 是 q 和各 key 的内积 ÷ √width，attention 是它的 softmax，mixed 是把各 value 按 attention 权重逐格相加得到的向量。最后一行用 project 变换 mixed，加到 x 上(残差)。

model.py 两层 MLP

            hidden = [v.relu() for v in linear(norm(x), w['expand'])]
            x = [a + b for a, b in zip(x, linear(hidden, w['contract']))]

把 x 归一化，用 expand 扩到 16 格，每格套上 relu 得到 hidden。用 contract 缩回 8 格，加到 x 上(残差)。和注意力不同，它不看其他位置，只加工当前位置的向量。

model.py 输出层分数

            output.append(linear(norm(x), w['head']))
        return output

把 x 最后归一化，与 head 相乘，得到词表数量的分数，按位置积累到 output。循环结束后，output 是(输入长度) × (词表数)的分数表。

model.py loss——每个位置 −log 概率的平均

    def loss(self, inputs, targets):
        logits = self.forward(inputs)
        losses = [-softmax(row)[target].log()
                  for row, target in zip(logits, targets)]
        return sum(losses) / len(losses)

用 forward 得到每个位置的分数，在该位置的 softmax 概率中，对正确答案 target 的概率取 log 再改变符号。把所有位置的损失相加，除以位置数，返回平均值。结果也是 Value，所以可以调用 loss.backward()。

model.py state、load——保存与读取权重

    def state(self):
        return {name: [[v.data for v in row] for row in matrix]
                for name, matrix in self.weights.items()}

    def load(self, state):
        assert set(state) == set(self.weights), 'checkpoint keys'
        for name, matrix in self.weights.items():
            assert len(state[name]) == len(matrix), 'checkpoint rows'
            for row, saved in zip(matrix, state[name]):
                assert len(saved) == len(row), 'checkpoint columns'
                for value, number in zip(row, saved):
                    value.data = float(number)

state 返回一个形状相同、只取出普通数(.data)而不是 Value 的字典。因为 Value 对象带有计算图的连接，无法存成 JSON。load 反过来，把保存的数字放进 Value 的 data。在此之前用 assert 确认矩阵名称、行数、格数与当前模型相同，避免悄悄读错不同大小的检查点。