神经网络-Chap.2
本系列神经网络课程根据Youtube上Andrej Karpathy的系列视频: Neural Networks: Zero to Hero整理而来.
应当可以作为对于LLM进行内部原理理解的入门视频之一.
这一节我们开始真正试着捣鼓出一些比较简单的模型. 依旧基于作者提供的一个GitHub库: https://github.com/karpathy/makemore
2.1 引子
我们的目的是捣鼓出来一个能生成一些很像名字的字符串的模型.
这个仓库的基本结构围绕着这个目的, 其结构非常简单:
makemore/
├── names.txt # 【数据文件】约 32,000 个真实英文人名,每行一个名字
├── makemore.py # 【源码】单文件包含了 Bigram / MLP / RNN / BoW / Transformer 5 种架构
├── README.md # 项目说明与命令行运行指南
└── LICENSE # MIT 开源协议需要指出的是, 如果我们给了一个名字, 例如: adam. 我们其实能从这个名字里面获得的信息很多, like:
- a有可能作为一个名字的起始字母
- d有可能跟在a后面
- a可能跟在ad后面
- …
- m有可能是名字的最后一个字母
为了更好地开始, 我们暂且不考虑过于复杂的信息, 如第二讲视频中所提及的, 我们这一节只是想做一个 ‘Bigram’ 模型. 即只根据前面一个字母来生成下一个字母.
2.2 探索相邻字符的关联
我们考虑从这段代码开始:
words = open('names.txt', 'r').read().splitlines()
for w in words:
for ch1, ch2 in zip(w, w[1:]):
print(ch1, ch2)但就像我们上面所说的那样. 这样提取出的前后关联, 少了一步.
也就是开头的字母以及结尾的字母该怎么表示, 所以我们在字符串前后都加一个特殊字符.
words = open('names.txt', 'r').read().splitlines()
for w in words:
chs = ['<S>'] + list(w) + ['<E>']
for ch1, ch2 in zip(chs, chs[1:]):
print(ch1, ch2)Output<S> e e m m m m a a <E> <S> o o l l i i v v i i a a <E> <S> a a v v a a <E> ...
So, 我们现在要找到这一对二元组的数据之间的关联, 最简单的方式是什么?
直接数, 对吧:
b = {}
words = open('names.txt', 'r').read().splitlines()
for w in words:
chs = ['<S>'] + list(w) + ['<E>']
for ch1, ch2 in zip(chs, chs[1:]):
bigram = (ch1, ch2)
b[bigram] = b.get(bigram, 0) + 1
# And we sorted the result(with backward order)
sorted(b.items(), key = lambda kv: -kv[1])output[ (('n', '<E>'), 6763), # 最常见的组合:以字母 'n' 结尾的名字(出现了 6763 次) (('a', '<E>'), 6640), # 第二常见:以字母 'a' 结尾的名字(出现了 6640 次) (('a', 'n'), 5438), # 第三常见:字母 'a' 后面紧接 'n'(出现了 5438 次) (('<S>', 'a'), 4410), # 第四常见:以字母 'a' 开头的名字(出现了 4410 次) (('e', '<E>'), 3983), (('a', 'r'), 3264), (('e', 'l'), 3248), (('r', 'i'), 3033), (('n', 'a'), 2977), # ... (省略中间项) ... (('q', 'r'), 1), (('z', 'x'), 1), ]
现在我们用的是dictionary这个数据结构. 虽然这不算低效, 但确实不适合计算. 有没有更合适的方式来存储这种数据结构?
矩阵.
我们用矩阵的行作为第一个字母, 列作为第二个字母, 行列对应位置的数字作为计数值.
所以我们应该需要一个 28 * 28 的矩阵, 即26个字母 + 两个特殊字符.
我们直接用Pytorch来进行矩阵的创建, 存储更新:
import torch
N = torch.zeros((28, 28), dtype = torch.int32) # 存储计数, 所以只需要int类型即可
words = open('names.txt', 'r').read().splitlines()
chars = sorted(list(set(''.join(words))))
stoi = {s:i for i, s in enumerate(chars)} # a dictionary to convert letters to number
stoi['<S>'] = 26
stoi['<E>'] = 27
for w in words:
chs = ['<S>'] + list(w) + ['<E>']
for ch1, ch2 in zip(chs, chs[1:]):
ix1 = stoi[ch1]
ix2 = stoi[ch2]
N[ix1, ix2] += 1Expected Output:
ix1 \ ix2 | 0 (a) | 1 (b) | 2 (c) | … | 25 (z) | 26 (<S>) | 27 (<E>) |
|---|---|---|---|---|---|---|---|
0 (a) | 556 | 541 | 470 | … | 435 | 0 | 6640 |
1 (b) | 321 | 38 | 1 | … | 0 | 0 | 114 |
2 (c) | 815 | 0 | 42 | … | 4 | 0 | 97 |
| … | … | … | … | … | … | … | … |
25 (z) | 860 | 4 | 2 | … | 45 | 0 | 160 |
26 (<S>) | 4410 | 1306 | 1542 | … | 929 | 0 | 0 |
27 (<E>) | 0 | 0 | 0 | … | 0 | 0 | 0 |
显然, 这样的储存方式有点呆呆的, 我们浪费了一些空间, 因为结尾符号是不可能在起始符号之前的. 同时, 起始符号紧跟着结尾符号的情况也几乎不可能出现(我们一般管它叫无效数据)
优化一下:
import torch
N = torch.zeros((28, 28), dtype = torch.int32) # 存储计数, 所以只需要int类型即可
words = open('names.txt', 'r').read().splitlines()
chars = sorted(list(set(''.join(words))))
stoi = {s:i for i, s in enumerate(chars)} # a dictionary to convert letters to number
itos = [i:s for s, i in stoi.items()]
stoi['.'] = 0
for w in words:
chs = ['.'] + list(w) + ['.']
for ch1, ch2 in zip(chs, chs[1:]):
ix1 = stoi[ch1]
ix2 = stoi[ch2]
N[ix1, ix2] += 1Expected output:
ix1 \ ix2 | 0 (.) | 1 (a) | 2 (b) | 3 (c) | … | 26 (z) |
|---|---|---|---|---|---|---|
0 (.) | 0 | 4410 | 1306 | 1542 | … | 929 |
1 (a) | 6640 | 556 | 541 | 470 | … | 435 |
2 (b) | 114 | 321 | 38 | 1 | … | 0 |
3 (c) | 97 | 815 | 0 | 42 | … | 4 |
| … | … | … | … | … | … | … |
26 (z) | 160 | 860 | 4 | 2 | … | 45 |
这样好多了.
2.3 根据概率获得几个名字
所以我们现在需要开始算概率, 以计算开头字母的方式为例:
p = N[0].float()
p = p / p.sum()output# N[0] tensor([ 0, 4410, 1306, 1542, 1690, 1531, 417, 669, 874, 591, 2422, 2963, 1572, 2538, 1146, 394, 515, 92, 1639, 2055, 1308, 78, 376, 307, 134, 535, 929], dtype=torch.int32) # p tensor([0.0000, 0.1377, 0.0408, 0.0481, 0.0528, 0.0478, 0.0130, 0.0209, 0.0273, 0.0184, 0.0756, 0.0925, 0.0491, 0.0792, 0.0358, 0.0123, 0.0161, 0.0029, 0.0512, 0.0642, 0.0408, 0.0024, 0.0117, 0.0096, 0.0042, 0.0167, 0.0290])
通过这种方式, 我们拿到了开头字母的概率.
下一步是要通过这个概率来拿到具体的字母.(或者说拿到字母的下标也没问题)
这就得介绍Pytorch的另一个常用函数:
g = torch.Generator().manual_seed(2147483647) # Generator
p = torch.rand(3, generator = g) # generate 3 numbers in [0, 1]
p = p / p.sum() # probability
torch.multinomial(p, num_samples = 20, replacement = True, generator = g)output# p tensor([0.6064, 0.3033, 0.0903]) # multinomial output tensor([1, 1, 2, 0, 0, 2, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1])
multinomial 这个函数能根据一个概率数组对应每次选择一个数值取出(返回的是该数值在数组中的下标).
num_samples代表取样数量
replacement代表是否能够重复取样(默认值是False)
现在用这个函数来取具体的字母:
g = torch.Generator().manual_seed(2147483647) # Generator
ix = torch.multinomial(p, num_samples = 1, replacement = True, generator = g).item() # if without .item(), then it'll be a tensor item
itos[ix]output# ix 13 # itos[ix] 'm'
所以, 我们可以写个循环了:
for i in range(20):
ix = 0
out = []
while True:
p = N[ix].float()
p = p / p.sum()
ix = torch.multinomial(p, num_samples = 1, replacement = True, generator = g).item()
out.append(itos[ix])
if ix == 0:
break
print(''.join(out))outputcexze. momasurailezitynn. konimittain. llayn. ka. da. staiyaubrtthrigotai. moliellavo. ke. teda. ka. emimmsade. enkaviyny. ftlspihinivenvorhlasu. dsdr. dviel. ...
看起来效果并不好. 但事实上, 这是Bigram训练方式本身带来的局限.
正如我们在前面所说的, Bigram只看前后两个字母的关联. 它实际上忽视了很多很多的信息.
2.4 修复一个效率问题
上面的代码仅仅限制于 能跑 , 但是它的效率着实比较感人.
它的循环内部每一次都要算一遍概率, 这是很低效的做法.
更正常的做法, 是先把这个概率算出来, 再在循环内直接取用.
我们希望实现的步骤是: 每一行的数, 除以该行的总和.
为了更好的过渡到后面的模型类别, 我们更应该使用Pytorch相关的方法. 这里再介绍一个函数: torch.sum()
P = N.float()
P /= P.sum(1, keepdim = True)这段代码得好好说说, 它挺复杂的.
第一行很简单, 我们把上面记录频次的这个27 * 27的数组完全赋值给了P.
第二行:
P.sum(1, keepdim = True): 在P这个 torch 类型对象上进行求和操作.- 第一个参数: 代表 消除 哪一维的结构.
0代表行,1代表列. 这里消除了列的结构, 意味着把每一行的元素均加和. - 第二个参数
keepdim: 是否保留原维度结构. 本处原先是一个二维数组,keepdim为True时, 会给出一个 27 * 1 的二维数组; 若该参数为False, 则给出一个长度为 27 的一维数组.
- 第一个参数: 代表 消除 哪一维的结构.
P /= P.sum(1, keepdim = True): 用一个 27 * 27 的数组除以一个 27 * 1 的数组. 对于 torch 类型对象而言, 会将后者 以复制的形式 转化为一个 27 * 27 的数组, 并对应相除. (该机制称为广播机制 Broadcasting, 当两个数组其中一个维度相同, 而另一维度长度为 1 或缺失时会自动朝向缺失维度进行复制扩展)
所以我们通过这么简单的两行代码, 就获得了整个二维数组在整行上的概率分布.
这个Broadcasting, 请读者务必重视, 这玩意很容易写出bug来.
现在我们上面的循环写法可以变成:
for i in range(20):
ix = 0
out = []
while True:
p = P[ix]
ix = torch.multinomial(p, num_samples = 1, replacement = True, generator = g).item()
out.append(itos[ix])
if ix == 0:
break
print(''.join(out))2.5 评估我们刚刚的模型
通过刚刚的编写, 实际上我们已经成功训练出了一个模型, 尽管它十分简陋, 但确实, 它能够产生有效的输出了.
现在下一个问题是, 我们练出一个模型, 自然而然的, 就需要一个建模方案去 评估它 .
这件事, 在我们这个比较小的模型中, 是比较简单的:
for w in words:
chs = ['.'] + list(w) + ['.']
for ch1, ch2 in zip(chs, chs[1:]):
ix1 = stoi[ch1]
ix2 = stoi[ch2]
prob = P[ch1, ch2]
print(f'{ch1}{ch2}: {prob:.4f}')output.e: 0.0478 em: 0.0377 mm: 0.0253 ma: 0.3899 a.: 0.1960 .o: 0.0123 ...
现在的问题是, 怎么把这一堆来自”训练数据集”的概率, 转化成一个能够作为评估模型好坏的数字?
从理论上来说, 对于 这一个训练数据组成的数据集 , 它的概率应当越接近100%越好. 所以我们如果希望结合上全部这一堆数据, 一个简单的方案是直接把它们全部相乘.
如果我们联系一下第一节中的内容, 应该能想到这个玩意: loss, 怎么把这一堆概率转变成loss?
我们想想上一节中loss的特征:
- 永远是正数.
- 越小(越接近0)越好.
那么现在这些概率值就存在问题: 它们的绝对值太小了, 离0太近. 直接相乘的话, 会直接超出计算机能够存储的最小值, 完蛋, 直接变成0了.(这里涉及到一些计算机组成原理中的知识, 对这方面没有了解的读者, 只需要了解到, 计算机能存储的小数是有最低下限的, 当超出这个限制, 就下溢直接存成0了)
在现有的主要解决方案中, 取log是一个比较常见的方案.
for w in words:
chs = ['.'] + list(w) + ['.']
for ch1, ch2 in zip(chs, chs[1:]):
ix1 = stoi[ch1]
ix2 = stoi[ch2]
prob = P[ix1, ix2]
logprob = torch.log(prob)
print(f'{ch1}{ch2}: {prob:.4f} {logprob:.4f}')output.e: 0.0478 -3.0408 em: 0.0377 -3.2793 mm: 0.0253 -3.6772 ma: 0.3899 -0.9418 a.: 0.1960 -1.6299 .o: 0.0123 -4.3982 ol: 0.0780 -2.5508 ...
现在数值够大了, 但是它们是负的. 这个简单, 取个负号.
而如果我们还记得高中关于对数的知识:
$$log(abc) = log(a) + log(b) + log(c)$$
所以我们只需要将这几个数字加在一块, 对总数据集数量取个平均就行了:
log_likelihood = 0.0
n = 0
for w in words:
chs = ['.'] + list(w) + ['.']
for ch1, ch2 in zip(chs, chs[1:]):
ix1 = stoi[ch1]
ix2 = stoi[ch2]
prob = P[ix1, ix2]
logprob = torch.log(prob)
log_likelihood += logprob
n += 1
print(f'{ch1}{ch2}: {prob:.4f} {logprob:.4f}')
print(f'{log_likelihood=}')
nll = -log_likelihood
print(f'{nll=}')
print(f'{nll/n}')outputlog_likelihood=tensor(-559891.7500) nll=tensor(559891.7500) 2.424102306365967
上面这个评估方式在现实中非常常用, 它叫做: 负似然对数(negative log likelihood)
但目前的代码还有一个小虫. 比如我们让这个评估方案凭据这个词语: andrejq
log_likelihood = 0.0
n = 0
for w in ["andrejq"]:
chs = ['.'] + list(w) + ['.']
for ch1, ch2 in zip(chs, chs[1:]):
ix1 = stoi[ch1]
ix2 = stoi[ch2]
prob = P[ix1, ix2]
logprob = torch.log(prob)
log_likelihood += logprob
n += 1
print(f'{ch1}{ch2}: {prob:.4f} {logprob:.4f}')
print(f'{log_likelihood=}')
nll = -log_likelihood
print(f'{nll=}')
print(f'{nll/n}')output.a: 0.1377 -1.9829 an: 0.1605 -1.8296 nd: 0.0384 -3.2594 dr: 0.0771 -2.5620 re: 0.1336 -2.0127 ej: 0.0027 -5.9171 jq: 0.0000 -inf q.: 0.1029 -2.2736 log_likelihood=tensor(-inf) nll=tensor(inf) inf
这种情况是因为在我们的训练集合中, jq这种数据一次都没有出现. 所以在碰到jq之后, 结果直接变成 infinity 了.
这确实有些不符合直觉, 因为一个错误生成并不应当完全否定掉整个模型的可用性, 对吧.
所以, 有一种方案叫做: 模型平滑(Model Smoothing), 也就是在每种数据集的可能上都加上一定的 假样本数 :
P = (N+1).float()
...output.a: 0.1376 -1.9835 an: 0.1604 -1.8302 nd: 0.0384 -3.2594 dr: 0.0770 -2.5646 re: 0.1334 -2.0142 ej: 0.0027 -5.9004 jq: 0.0003 -7.9817 q.: 0.0970 -2.3331 log_likelihood=tensor(-27.8672) nll=tensor(27.8672) 3.4834020137786865
这样就不会碰到 -inf 的情况了.
2.6 使用神经网络的思路去训练Bigram模型
2.6.1 张量(tensor)
以上, 我们做了很多工作, 写了很多代码. 但是实质上我们的模型是基于我们最开始的计数程序而来的, 即这个counting program.
这实际上在训练更加大型的模型时, 是几乎无法复刻的. 因为更大的模型需要考虑的信息过多, 而我们刚刚在干的事情, 与我们第一节中手算导数的行为几乎无异.
所以我们现在要达到的目标是: 利用自动化程序, 让模型能够自动根据我们提供的数据集, 调整参数, 达到我们刚刚的模型效果.
第一步, 还是创造数据集, 只不过这一次, 我们不计数了:
# creare the training set of bigrams (x, y)
xs, ys = [], []
for w in words[:1]:
chs = ['.'] + list(w) + ['.']
for ch1, ch2 in zip(chs, chs[1:]):
ix1 = stoi[ch1]
ix2 = stoi[ch2]
xs.append(ix1)
ys.append(ix2)
xs = torch.tensor(xs)
ys = torch.tensor(ys)output# xs(-emma) tensor([0, 5, 13, 13, 1]) # ys(emma-) tensor([5, 13, 13, 1, 0])
tensor , 中文译作 张量 , 其实可以直接当作编程中的多维数组来看. 上述代码中的xs, ys都是一维张量.
之所以要做这样一步转换, 是因为正常情况下, python本身的list放置数据的位置不够集中, 效率不够高. 而Pytorch提供的数据结构能够更高效的进行机器学习相关的计算.
这里额外提一嘴: 实际使用中尽可能使用 torch.tensor() , 而不要使用大写的版本( torch.Tensor() ), 二者区别在于小写的方法能够自动识别数据类型, 而大写的方法会默认采用float32类型.
2.6.2 转化张量, 并放入神经网络中进行计算
现在我们拿到了一维张量, 但正常来说, 我们不应该把这一维张量直接喂给模型.
正常而言, 每个字母的权重应该是一样的, 而这种一维张量, 显然, 字母越靠后, 数字越大.
这就得提到一个叫 one_hot 的函数. 它负责把一个一维张量转化为一个二维张量, 其中的每个一维张量的长度由参数决定, 其作用是让一维张量中对应的那个位置置值为1, 其余位置保持全0.
import torch.nn.functional as F
xenc = F.one_hot(xs, num_classes = 27).float()outputtensor([[1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], [0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], [0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]])
之所以这里额外转成
float, 是因为我们塞到神经网络里的数据格式显然不应该是一个整数.
之所以不用dtype = float转化, 是因为至今为止,one_hot仍然不支持dtype参数.
如果读者还记得第一节中micrograd的内容, 应该记得我们每一层神经网络其实做的计算很简单: $ F = wx + b $ .
g = torch.Generator().manual_seed(2147483647)
W = torch.randn((27, 27), generator = g, requires_grad = true)
xenc @ Woutputtensor([[ 1.5674, -0.2373, -0.0274, ..., -0.0707, 2.4968, 2.4448], [ 0.4724, 1.4830, 0.3175, ..., -0.4275, -2.1259, 0.9604], [ 0.1936, 1.0532, 0.0397, ..., 0.8032, -0.5015, -1.0383], [ 0.1936, 1.0532, 0.0397, ..., 0.8032, -0.5015, -1.0383], [-0.6701, -1.2199, 0.3031, ..., 0.8019, -0.7131, -1.2704]])
这里解释一下俩比较让人疑惑的点:
torch.randn(): 按照标准正态分布来进行初始化权重. 可以在括弧内增加一个具体的张量维度.@: 标准矩阵乘法.
这其中的每一行是啥意思呢?
它意味着在这种初始化参数可能性下, 从我们某一组数据(比如e->m)算出来的, 后面取对应字母的可能性.
2.6.3 Softmax
所以, 现在我们得到了一个, emm, 输出张量矩阵?
该怎么把它转化成一个我们熟悉的玩意? 或者说, 频次?
比较常用的是这个函数: $ e^x $ . 以防各位读者忘记, 它长这样:
它能把所有实数, 映射到一个 非负 的值上. 并且它非常符合直觉, 原值越小, 映射值越接近0; 反之则越大.
在人工智能领域中, 常用 logit 代表初始值矩阵, 转为一个频次表, 则需要额外套一层 exp() 函数.
logits = xenc @ W # log-counts
counts = logits.exp() # equivalent Noutput# counts tensor([[0.8185, 0.0934, 0.3881, 1.7107, 0.9095, 0.1674, 0.4050, 2.2690, 1.9988, 1.0114, 0.2165, 1.8363, 0.2995, 6.4269, 0.2722, 0.9704, 0.1152, 0.9476, 0.9868, 0.6956, 1.6911, 0.9921, 3.1905, 7.2798, 1.6447, 2.0857, 0.5287], [0.6426, 1.6526, 3.8628, 0.6646, 0.4559, 0.2846, 0.6339, 1.1579, 0.6402, 3.5782, 0.5291, 1.8971, 0.5702, 0.7364, 5.3499, 0.2273, 0.0646, 1.4734, 1.4874, 4.7479, 0.8191, 0.8696, 0.2713, 1.5363, 3.5104, 2.2271, 1.7246], [0.7649, 0.7680, 1.5826, 1.0344, 2.1124, 3.5812, 0.3738, 1.1972, 1.0858, 0.5686, 0.6937, 0.4335, 0.1711, 1.6501, 0.1746, 0.4422, 0.1031, 2.6413, 0.3419, 1.3655, 0.7783, 1.0787, 2.5426, 5.2256, 3.4233, 1.1310, 0.7764], [0.7649, 0.7680, 1.5826, 1.0344, 2.1124, 3.5812, 0.3738, 1.1972, 1.0858, 0.5686, 0.6937, 0.4335, 0.1711, 1.6501, 0.1746, 0.4422, 0.1031, 2.6413, 0.3419, 1.3655, 0.7783, 1.0787, 2.5426, 5.2256, 3.4233, 1.1310, 0.7764], [1.2152, 0.3225, 2.5802, 0.5283, 0.6426, 0.5226, 1.9301, 0.1495, 7.5789, 3.5313, 0.1784, 3.6588, 0.5003, 0.6789, 2.1977, 0.4454, 1.7763, 0.5908, 0.5528, 1.1524, 2.9104, 0.8386, 0.7042, 0.5852, 1.1584, 4.7982, 0.3537]])
这玩意, 实际上跟我们之前手动计数出来的那个频次矩阵(N), 是等价的.(详见: 2.2 节) 当然, 它取出来的这个数值肯定是跟我们实际算出来的这个N非常不一致. 一方面是我们只考虑了第一个词emma. 另一方面是, 我们的这个权重 weight, W 还没优化呢, 它是完全随机取出来的.
随后再算个概率:
logits = xenc @ W # log-counts
counts = logits.exp() # equivalent N
probs = counts / counts.sum(1, keepdims = True)output# probs tensor([[0.0205, 0.0023, 0.0097, 0.0428, 0.0228, 0.0042, 0.0101, 0.0568, 0.0500, 0.0253, 0.0054, 0.0460, 0.0075, 0.1609, 0.0068, 0.0243, 0.0029, 0.0237, 0.0247, 0.0174, 0.0423, 0.0248, 0.0799, 0.1822, 0.0412, 0.0522, 0.0132], [0.0154, 0.0397, 0.0928, 0.0160, 0.0110, 0.0068, 0.0152, 0.0278, 0.0154, 0.0860, 0.0127, 0.0456, 0.0137, 0.0177, 0.1286, 0.0055, 0.0016, 0.0354, 0.0357, 0.1141, 0.0197, 0.0209, 0.0065, 0.0369, 0.0844, 0.0535, 0.0414], [0.0212, 0.0213, 0.0439, 0.0287, 0.0586, 0.0994, 0.0104, 0.0332, 0.0301, 0.0158, 0.0192, 0.0120, 0.0047, 0.0458, 0.0048, 0.0123, 0.0029, 0.0733, 0.0095, 0.0379, 0.0216, 0.0299, 0.0705, 0.1450, 0.0950, 0.0314, 0.0215], [0.0212, 0.0213, 0.0439, 0.0287, 0.0586, 0.0994, 0.0104, 0.0332, 0.0301, 0.0158, 0.0192, 0.0120, 0.0047, 0.0458, 0.0048, 0.0123, 0.0029, 0.0733, 0.0095, 0.0379, 0.0216, 0.0299, 0.0705, 0.1450, 0.0950, 0.0314, 0.0215], [0.0289, 0.0077, 0.0613, 0.0126, 0.0153, 0.0124, 0.0459, 0.0036, 0.1801, 0.0839, 0.0042, 0.0869, 0.0119, 0.0161, 0.0522, 0.0106, 0.0422, 0.0140, 0.0131, 0.0274, 0.0692, 0.0199, 0.0167, 0.0139, 0.0275, 0.1140, 0.0084]])
我们在上面捣鼓了半天的这个过程, 在人工智能的领域中被叫做 Softmax .
如果用数学公式来表达它的话, 它长这样:
$$ \text{Softmax}(z_i) = \frac{e^{z_i}}{\sum_{j=1}^{K} e^{z_j}} $$
希望我们上面的一系列样例, 能够让读者明白这一步的意义. Softmax至今仍然是人工智能训练过程中, 输出结果时必经的一步.
2.6.4 loss
好, 现在问题就回到了我们熟悉的(?)地方.
我们应该计算出一个loss, 通过调整我们的W, 让这个loss尽可能归零.
我们首先得明确我们要的正确的概率在哪里, 事实上, 这一点在前面其实已经存起来了, 就在我们的 ys 里面(见2.6.1).
所以我们实际上关心的概率是:
probs[0, ys[0]], probs[1, ys[1]], probs[2, ys[2]], probs[3, ys[3]], probs[4, ys[4]]但是显然, 我们要找到更加有效率能够访问这种正确概率的方式. 幸运的是, torch已经考虑到了这一点:
probs[torch.arange(5), ys]outputtensor([0.0123, 0.0181, 0.0267, 0.0737, 0.0150])
如果读者还记得上一节我们怎么算的loss, 应该就能明白下面这个负似然对数了:
loss = -probs[torch.arange(5), ys].log().mean()outputtensor(3.7693)
总结一下, 我们的forward pass:
xenc = F.one_hot(xs, num_classes = 27).float()
logits = xenc @ W # log-counts
counts = logits.exp() # equivalent N
probs = counts / counts.sum(1, keepdims = True) # probablities for next character
loss = -probs[torch.arange(5), ys].log().mean()2.6.5 backward pass
首先明确, 我们要对谁算导数? 之前说过多次, weight, W 对吧.
再明确, 我们之前一直用的是pytorch给出的torch数据结构. 所以这回非常方便, 我们不用再自己去造轮子了(笑
W.grad = None # init the gradient
loss.backword()outputtensor([[ 0.0121, 0.0020, 0.0025, 0.0008, 0.0034, -0.1975, 0.0005, 0.0046, 0.0027, 0.0063, 0.0016, 0.0056, 0.0018, 0.0016, 0.0100, 0.0476, 0.0121, 0.0005, 0.0050, 0.0011, 0.0068, 0.0022, 0.0006, 0.0040, 0.0024, 0.0307, 0.0292], [-0.1970, 0.0017, 0.0079, 0.0020, 0.0121, 0.0062, 0.0217, 0.0026, ...], ...])
随后我们可以:
W.data += -0.1 * W.grad这理论上就能让我们的loss尽可能的小了.
2.6.6 合在一块
# create the dataset
xs, ys = [], []
for w in words:
chs = ['.'] + list(w) + ['.']
for ch1, ch2 in zip(chs, chs[1:]):
ix1 = stoi[ch1]
ix2 = stoi[ch2]
xs.append(ix1)
ys.append(ix2)
xs = torch.tensor(xs)
ys = torch.tensor(ys)
num = xs.nelement()
print('number of examples: ', num)
# initialize the 'network'
g = torch.Generator().manual_seed(2147483647)
W = torch.randn((27, 27), generator=g, requires_grad=True)
# 3. 梯度下降主循环 (迭代 100 轮)
for k in range(100):
# 前向传播 (Forward pass)
xenc = F.one_hot(xs, num_classes=27).float() # 将输入转为独热编码 [num, 27]
logits = xenc @ W # 矩阵相乘预测对数频次 (log-counts)
counts = logits.exp() # 取指数还原为正数频次 (等价于计数矩阵 N)
probs = counts / counts.sum(1, keepdims=True) # 归一化得到下一字符的概率分布 (Softmax)
loss = -probs[torch.arange(num), ys].log().mean() # 计算平均负对数似然损失 (NLL Loss)
print(loss.item())
# 反向传播 (Backward pass)
W.grad = None # 梯度清零 (设为 None 比填 0 更高效)
loss.backward()
# 更新参数 (Update)
W.data += -50 * W.gradoutput3.758953809738159 3.371100902557373 3.154043197631836 3.020373821258545 2.927711248397827 ... 2.4728763103485107 2.4727530479431152 2.4726319313049316
2.6.7 Regularization
我们在前面提到了一个叫做Model Smoothing的事情(见2.5节). 在这里我们怎么实现它?
我们可以做这种修改:
# original
loss = -probs[torch.arange(num), ys].log().mean() # 计算平均负对数似然损失 (NLL Loss)
# to
loss = -probs[torch.arange(num), ys].log().mean() + 0.01*(W**2).mean()我们在loss上加了个小尾巴, 理解一下这个式子, 我们会发现这个小尾巴只有当W这个张量全为0的时候, 才能不增加loss.
W这个张量全0意味着什么?
后面乘法乘出来的概率矩阵全是相同的数, 对吧. 其实就是完全平均分布(每个字母取的概率均等)
所以, 我们后面加这么个小尾巴, 本质上就在尝试把模型权重往平均拉平. (W**2) 前面那个参数越大, 模型越平滑.
这个事情, 在人工智能领域有个名字, 叫 Regularization .
2.6.8 用我们的模型生成几个名字
# 使用训练好的神经网络权重 W 抽样生成 5 个名字
g = torch.Generator().manual_seed(2147483647)
for i in range(5):
out = []
ix = 0 # 从起始符 '.' (编号 0) 开始
while True:
# 1. 将当前字符编号 ix 转为 [1, 27] 的独热向量,通过神经网络前向传播算出概率 p
xenc = F.one_hot(torch.tensor([ix]), num_classes=27).float()
logits = xenc @ W
counts = logits.exp()
p = counts / counts.sum(1, keepdims=True)
# 2. 按预测概率分布 p 抽样下一个字符编号
ix = torch.multinomial(
p, num_samples=1, replacement=True, generator=g
).item()
out.append(itos[ix])
# 3. 如果抽到了结束符 '.' (编号 0),则当前名字生成完毕
if ix == 0:
break
print(''.join(out))好. 我们这篇博文到这里就结束了.
目前为止, 我们捣鼓出了一个bigram的模型, 尽管它其中的参数只是一个相乘, 只有一层.
但是至少, 它能够产出具体结果了. 并且我们搞明白了最后这个Softmax的过程.
这篇博文就到这里~
