1.02 PyTorch
把 microgpt 搬到 PyTorch 上:1000 步里每一步的 loss 都和原来一模一样,两条线完全重合,生成的 20 个名字也一字不差。训练时间从 108.8 秒降到了 4.3 秒。
上一节我们用的完全是最朴素的 Python 代码,没有任何特殊的库,就连矩阵乘法都是一个数一个数手动算的。但实际上,有一些库能让我们写得更省事,矩阵运算也执行得更高效。当下最流行的就是 PyTorch。
它主要提供两样东西。一是张量(tensor),也就是多维数组,一次运算处理一整块数,同一份代码可以在 CPU 上跑,也可以搬到 GPU 上跑。二是自动求导,和 microgpt 里的 Value 做的是同一件事。有了它,我们只需要写清楚模型算什么,怎么算得快交给它。之后训练上的各种加速,基本都是建立在这一层上面的。
那为什么 microgpt 慢?不是因为算术多,而是每一个数都是一个 Python 对象。一次 16×16 的矩阵乘向量,要做 256 次乘法和差不多同样多次加法,每做一次都要新建一个 Value,记下它是从哪两个数算来的。我们数了一下,训练第一个名字 yuheng 时,计算图里一共有 59647 个节点;换成 PyTorch 以后,一次矩阵运算只是一个节点,同样这一步只有 452 个。
下面挑出原来写起来最费劲的几处,左边是 microgpt,右边是 PyTorch。没列出来的部分(数据、tokenizer、模型的其余部分、生成)基本只是把列表换成了张量,完整文件在 GitHub,和 1.01 diff 一下就能看到全部改动。
1自动求导整个 Value 类,变成两处改动
整个 Value 类都不需要了。参数创建的时候加上 requires_grad=True,PyTorch 就会记下它参与的每一次运算。loss.backward() 还是那一行,做的事也一样:从 loss 往回走,按链式法则把梯度填进每个参数的 .grad 里。
区别在于记录的粒度。Value 记的是每一个数,PyTorch 记的是每一次张量运算。
class Value:
__slots__ = ('data', 'grad', '_children', '_local_grads')
def __init__(self, data, children=(), local_grads=()):
self.data = data
self.grad = 0
self._children = children
self._local_grads = local_grads
def __add__(self, other):
other = other if isinstance(other, Value) else Value(other)
return Value(self.data + other.data, (self, other), (1, 1))
def __mul__(self, other):
other = other if isinstance(other, Value) else Value(other)
return Value(self.data * other.data, (self, other), (other.data, self.data))
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
for v in reversed(topo):
for child, local_grad in zip(v._children, v._local_grads):
child.grad += local_grad * v.grad
# 每个参数都是一个 Value
matrix = lambda nout, nin, std=0.08: [[Value(random.gauss(0, std)) for _ in range(nin)] for _ in range(nout)]
loss.backward()# 参数是一整个张量,打上 requires_grad=True,
# PyTorch 就会记下它参与的每一次运算
matrix = lambda nout, nin, std=0.08: torch.tensor(
[[random.gauss(0, std) for _ in range(nin)] for _ in range(nout)],
requires_grad=True)
# 和原来一样,一行算完所有梯度
loss.backward()2基本运算linear、softmax、rmsnorm
原来这几个函数都是在列表上一个数一个数地算,现在直接对整个张量做运算。linear 里的两重循环变成了一个 @(矩阵乘法)。
softmax 里的 max(dim=-1, keepdim=True):沿最后一维取最大值,并且保留这一维,结果的形状和原张量对得上,就能直接相减。.values 是因为 PyTorch 的 max 会同时返回最大值和它的位置,这里只要值。
def linear(x, w):
return [sum(wi * xi for wi, xi in zip(wo, x)) for wo in w]
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]
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]def linear(x, w):
return w @ x
def softmax(logits):
exps = (logits - logits.max(dim=-1, keepdim=True).values).exp()
return exps / exps.sum(dim=-1, keepdim=True)
def rmsnorm(x):
return x * (x.pow(2).mean() + 1e-5) ** -0.53多头注意力4 个头一次算完
原来 4 个头是用 for 循环一个一个算的,每个头从 16 维里切出自己的 4 维。
现在换一种切法:torch.stack 先把存下来的 k、v 叠成一个矩阵;view 把 16 维重新看成 4 个头 × 4 维(数据不动,只是换个形状来看);transpose 再把"头"这一维换到最前面。这样 4 个头的点积就成了一次批量的矩阵乘法。注释里的 H、T、D 分别是头数、前文长度和每个头的维度。
x_attn = []
for h in range(n_head):
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]]
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)
head_out = [sum(attn_weights[t] * v_h[t][j] for t in range(len(v_h)))
for j in range(head_dim)]
x_attn.extend(head_out)q_h = q.view(n_head, 1, head_dim) # (H, 1, D)
k_h = torch.stack(keys[li]).view(-1, n_head, head_dim).transpose(0, 1) # (H, T, D)
v_h = torch.stack(values[li]).view(-1, n_head, head_dim).transpose(0, 1) # (H, T, D)
attn_logits = q_h @ k_h.transpose(1, 2) / head_dim**0.5 # (H, 1, T)
attn_weights = softmax(attn_logits)
x_attn = (attn_weights @ v_h).view(n_embd) # (H, 1, D) → (16,)4Adam 更新公式不变,从 4192 个数变成 9 个张量
公式一个字没改。原来这个循环要对 4192 个数各跑一遍,现在只对 9 个参数张量各跑一遍,每一行都是整块的运算。
外面多套了一层 torch.no_grad():更新参数这一步本身不需要求导,告诉 PyTorch 这几行不用记进计算图。梯度清零写成 p.grad = None,下一次 backward 会重新生成。
m = [0.0] * len(params)
v = [0.0] * len(params)
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_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)
p.grad = 0m = [torch.zeros_like(p) for p in params]
v = [torch.zeros_like(p) for p in params]
with torch.no_grad():
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_hat = m[i] / (1 - beta1 ** (step + 1))
v_hat = v[i] / (1 - beta2 ** (step + 1))
p -= lr_t * m_hat / (v_hat ** 0.5 + eps_adam)
p.grad = None另外,文件开头多了三行:
import torch
torch.set_default_dtype(torch.float64)
torch.set_num_threads(1)
第二行是为了能和 1.01 逐数对照。Python 的 float 是 64 位的,而 PyTorch 默认用 32 位,精度不同,算出来的数会有微小的差别,一步步累积下去,两边就对不上了。初始权重也同样还是用 random.gauss 一个个生成,这样两边从同一组数出发。第三行的原因,在下面的结果里。
运行结果
1000 步里,每一步的 loss 和 1.01 的差值都是 0,最后 50 步的平均 loss 都是 2.3233,生成的名字也完全一样。说明两边算的确实是同一件事,只是换了算的方式。每步耗时从 108.8 毫秒降到了 4.3 毫秒,快了 25 倍。
PyTorch 默认会用上机器所有的 CPU 核,我们这台机器是 48 个。但这里每次运算的张量都很小,16 维的向量乘 16×16 的矩阵,拆给多个线程去算,线程之间协调的时间比计算本身还长。
1 到 16 个线程都在 4 到 5 秒之间,用满 48 个反而要 80 到 140 秒,和纯 Python 的 microgpt 差不多,甚至更慢。这台机器上同时还有别人在跑任务,所以 48 线程的数字波动很大,但慢了一个数量级是确定的。所以开头固定只用 1 个线程。
最后补充一点:PyTorch 到底快在哪?要注意,两边做的乘法和加法一样多,算术本身一次都没有省,省下的是"调用"的次数。在 microgpt 里,每一次加法、乘法都是一次 Python 调用:新建一个对象,检查类型,记下它从哪来,这些开销比算术本身大得多。训练第一个名字时,前向就要建将近六万个 Value,反向还要再挨个走一遍。PyTorch 把一整个矩阵运算打包成一次调用,里面的几百次乘加在 C++ 里一口气算完,同样这一步,前向加反向一共只有一千六百次左右的调用。调用少了几十倍,时间也就少了 25 倍。
不过,即使在 PyTorch 里,每次调用也有两三微秒的固定开销,而一个 16×16 的矩阵乘向量,真正算起来只要几十纳秒。所以现在的时间,大部分仍然花在调用上,而不是计算上。