1.03 Batch
上一节最后我们发现,时间大部分花在调用上,而不是计算上。现在每处理一个 token,过完整个流程需要几十次 PyTorch 的调用。而实际上每次调用的过程中,如果说我们能计算更多的 token,那处理相同 token,所需的总调用时间就省下来了。这就是 batch。
在 names 上,每秒能训练多少个 token。1.02 一个 token 一个 token 地算,每秒约 1.7k;一次算一整批,batch 64 时到了 198k,快了将近 120 倍。
batch 有两个方向:
- 一段文本里的所有位置一起算。原来每个位置都要单独调用一次模型,现在整段长度为 T 的文本一次送进去。
- 很多段文本一起算。一次送进去 B 段,输入的形状就从一个 token 变成了
(B, T)。
第一个方向会带来一个问题。所有位置一起算的时候,注意力能看到整段文本,前面的位置就能偷看到后面的答案。原来一个个算的时候不存在这个问题,因为后面的 token 还没送进来。所以要加一个因果 mask(causal mask):每个位置只能看自己和前面的位置。画出来是一个下三角,比如右图里,第二个 m 能看到 BOS、e、m 和它自己,看不到后面的 a。
这一节还换了一个数据集。names 里最长的名字才 15 个字母,用不上长的上下文,batch 在 T 这个方向上也展不开。所以我们加上了 TinyStories:微软在 2023 年发布的一个数据集,是用 GPT-3.5 和 GPT-4 写的英文小故事,只用三四岁小孩能懂的词。我们用的是它的验证集文件,一共 27629 篇故事、约 2200 万个字符,每篇的中位数是 719 个字符。上下文长度 T 设成 256。比如这样一篇:
下面是代码上的三处主要改动,左边是 1.02,右边是 1.03。完整文件在 GitHub。
1模型一次算整个 (B, T)
原来 gpt() 每次只吃一个 token,前面位置的 k、v 要存进列表里留给后面用。现在一次吃进整个 (B, T),所有位置的 q、k、v 一起算出来,形状是 (B, H, T, D):B 段文本、H 个头、T 个位置、每个头 D 维。
q @ k.transpose(-2, -1) 一次算出每个位置对每个位置的得分,形状 (B, H, T, T)。masked_fill 把不该看的位置(mask 里是 False 的)填成负无穷,经过 softmax 以后,e 的负无穷次方是 0,这些位置的权重就是 0。causal_mask 用 torch.tril 生成,就是上面那个下三角。
def gpt(token_id, pos_id, keys, values):
tok_emb = state_dict['wte'][token_id]
pos_emb = state_dict['wpe'][pos_id]
...
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'])
keys[li].append(k)
values[li].append(v)
q_h = q.view(n_head, 1, head_dim)
k_h = torch.stack(keys[li]).view(-1, n_head, head_dim).transpose(0, 1)
v_h = torch.stack(values[li]).view(-1, n_head, head_dim).transpose(0, 1)
attn_logits = q_h @ k_h.transpose(1, 2) / head_dim**0.5
attn_weights = softmax(attn_logits)
x_attn = (attn_weights @ v_h).view(n_embd)causal_mask = torch.tril(torch.ones(block_size, block_size, dtype=torch.bool))
def gpt(idx):
B, T = idx.shape
tok_emb = state_dict['wte'][idx] # (B, T, C)
pos_emb = state_dict['wpe'][:T] # (T, C)
...
q = linear(x, state_dict[f'layer{li}.attn_wq']).view(B, T, n_head, head_dim).transpose(1, 2) # (B, H, T, D)
k = linear(x, state_dict[f'layer{li}.attn_wk']).view(B, T, n_head, head_dim).transpose(1, 2) # (B, H, T, D)
v = linear(x, state_dict[f'layer{li}.attn_wv']).view(B, T, n_head, head_dim).transpose(1, 2) # (B, H, T, D)
attn_logits = q @ k.transpose(-2, -1) / head_dim**0.5 # (B, H, T, T)
attn_logits = attn_logits.masked_fill(~causal_mask[:T, :T], float('-inf'))
attn_weights = softmax(attn_logits)
x_attn = (attn_weights @ v).transpose(1, 2).reshape(B, T, n_embd) # (B, T, C)2loss去掉逐个位置的循环
原来要一个位置一个位置地调用模型,把每个位置的 loss 收集起来再平均。现在模型一次给出所有位置的概率,形状 (B, T, vocab),gather 按目标编号,从每个位置的概率里取出正确答案那一项,取 log 再平均就是 loss。
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()
losses.append(loss_t)
loss = torch.stack(losses).mean()def loss_fn(x, y):
probs = softmax(gpt(x)) # (B, T, vocab)
return -probs.gather(-1, y.unsqueeze(-1)).log().mean()
x, y = get_batch(train_data, batch_size)
loss = loss_fn(x, y)3取数据从一个名字,变成随机截 B 段
原来每一步取一个名字。现在先把所有文本首尾相接,中间用 BOS 隔开,拼成一条很长的序列,前 90% 训练,后 10% 验证。每一步随机挑 B 个起点,各截一段长度为 T 的窗口作为输入 x;把同一个窗口往后错一位,就是每个位置要猜的下一个 token,也就是 y。
doc = docs[step % len(docs)]
tokens = [BOS] + [uchars.index(ch) for ch in doc] + [BOS]
n = min(block_size, len(tokens) - 1)def encode(docs):
return torch.tensor([t for doc in docs for t in [BOS] + [stoi[ch] for ch in doc]] + [BOS])
n_train = int(0.9 * len(docs))
train_data, val_data = encode(docs[:n_train]), encode(docs[n_train:])
def get_batch(data, batch_size):
ix = torch.randint(len(data) - block_size, (batch_size,))
x = torch.stack([data[i:i + block_size] for i in ix])
y = torch.stack([data[i + 1:i + block_size + 1] for i in ix])
return x, y另外几处小改动:linear 写成了 x @ w.T,因为 batch 那几维现在放在最前面;rmsnorm 只在最后一维(每个 token 的 16 个数)上求平均。
实验怎么比:batch 取 1、4、16、64,两个数据集都跑一遍。batch 越大,每一步看到的 token 越多,所以为了公平,所有 batch 训练的总 token 数相同,names 是 218 ≈ 26 万,TinyStories 是 222 ≈ 420 万,batch 越大,步数越少(batch 1 是 16384 步,batch 64 只有 256 步)。学习率都固定是 0.01。比较的是验证集上的 loss。
运行结果
先看速度。在 names 上,batch 越大越快,batch 64 是 batch 1 的 15 倍:张量很小,时间主要花在调用上,batch 越大,同样的调用摊到的 token 越多。但在 TinyStories 上正好反过来,batch 1 每秒 44.9k 个 token,batch 64 只有 11.6k。原因放在最后补充。
再看 loss。同样的 token 数下,并不是 batch 越大越好。在 TinyStories 上,所有 batch 都很快降到 2.3 左右,然后停住;batch 1 和 4 后来突破了这个平台,降到 1.75 和 1.79;batch 16 到末尾才开始往下走;batch 64 一直停在平台上。
2.3 左右大致是"只靠前一两个字符猜下一个"的水平。突破它,意味着模型开始用注意力去看更远的上下文。batch 越大,更新的次数越少,batch 64 一共只更新了 256 次,还没来得及学会这一步,训练就结束了。
names 上差别小得多,batch 1 到 16 都在 2.24 到 2.26,只有 batch 64 差一些,是 2.31。
还有一点要注意:学习率对所有 batch 都固定是 0.01。通常 batch 越大,合适的学习率也越大,所以大 batch 吃亏,有一部分是学习率造成的。
batch 1 训练完,生成的故事是这样的。能看出一些常见的词,比如 the、and、said,但还连不成句子:
最后补充一点:为什么 TinyStories 上 batch 越大反而越慢?注意力要算每个位置对每个位置的权重,这是一个 B × 4 × 256 × 256 的矩阵,batch 16 时已经超过 32 MB。Linux 上的内存分配器(glibc 的 malloc)遇到这么大的一块,会直接向操作系统要新的内存页,用完马上还回去,下一次再重新要。每次拿到新页,都要先触发缺页中断、把整页清零,这部分开销比计算本身还大。在一个单独的测试里,把这个阈值调大以后,batch 64 每步从 1463 毫秒降到了 403 毫秒。但即便如此,CPU 上每个 token 还是要约 22 微秒,batch 再大也没有帮助:CPU 没有多少调用开销可以摊,它是真的算不过来了。