当前位置：首页 > article >正文

【Andrej Karpathy 神经网络从Zero到Hero】--2.语言模型的两种实现方式（Bigram 和神经网络）

article 2025/3/10 10:29:20

统计 Bigram 语言模型

首先给定一批数据，每个数据是一个英文名字，例如：

['emma',
 'olivia',
 'ava',
 'isabella',
 'sophia',
 'charlotte',
 'mia',
 'amelia',
 'harper',
 'evelyn']

Bigram语言模型的做法很简单，首先将数据中的英文名字都做成一个个bigram的数据

其中每个格子中是对应的二元组，eg: “rh” ，在所有数据中出现的次数。那么一个自然的想法是对于给定的字母，取其对应的行，将次数归一化转成概率值，然后根据概率分布抽取下一个可能的字母：

g = torch.Generator().manual_seed(2147483647)
P = N.float() # N 即为上述 counts 矩阵
P = P / P.sum(1, keepdims=True) # P是每行归一化后的概率值

for i in range(5):
  
  out = []
  ix = 0  ## start符和end符都用 id=0 表示，这里是start
  while True:
    p = P[ix] # 当前字符为 ix 时，预测下一个字符的概率分布，实质是一个多项分布（即可能抽到的值有多个，eg: 掷色子是六项分布）
    ix = torch.multinomial(p, num_samples=1, replacement=True, generator=g).item()
    out.append(itos[ix])
    if ix == 0: ## 当运行到end符，停止生成
      break
  print(''.join(out))

输出类似于：

mor.
axx.
minaymoryles.
kondlaisah.
anchshizarie.

质量评价方法

我们还需要方法来评估语言模型的质量，一个直观的想法是:
$P(s_1s_2...s_n) = P(s_1)P(s_2|s_1)\cdots P(s_n|s_{n-1})$
但上述计算方式有一个问题，概率值都是小于1的，当序列的长度比较长时，上述数值会趋于0，计算时容易下溢。因此实践中往往使用 $l o g (P)$ 来代替，为了可以对比不同长度的序列的预测效果，再进一步使用 $l o g (P) / n$ 表示一个序列平均的质量。

上述统计 Bigram 模型在训练数据上的平均质量为：

log_likelihood = 0.0
n = 0

for w in words: # 所有word里的二元组概率叠加
  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 # 所有word里的二元组数量之和

nll = -log_likelihood
print(f'{nll/n}') ## 值为 2.4764，表示前面做的bigram模型，对现有训练数据的置信度
                  ## 这个值越低表示当前模型越认可训练数据的质量，而由于训练数据是我们认为“好”的数据，因此反过来就说明这个模型好

但这里有一个问题是，例如：

log_likelihood = 0.0
n = 0

#for w in words:
for w in ["andrejz"]:
  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}')

输出是

.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
jz: 0.0000 -inf
z.: 0.0667 -2.7072
log_likelihood=tensor(-inf)
nll=tensor(inf)
inf

可以发现由于，jz 在计数矩阵 N 中为0，即数据中没有出现过，导致 log(loss) 变成了负无穷，这里为了避免这样的情况，需要做平滑处理，即 P = N.float() 改成 P = (N+1).float()，这样上述代码输出变成：

.a: 0.1376 -1.9835
an: 0.1604 -1.8302
nd: 0.0384 -3.2594
dr: 0.0770 -2.5646
re: 0.1334 -2.0143
ej: 0.0027 -5.9004
jz: 0.0003 -7.9817
z.: 0.0664 -2.7122
log_likelihood=tensor(-28.2463)
nll=tensor(28.2463)
3.5307815074920654

避免了出现 inf 这种数据溢出问题。

神经网络语言模型

接下来尝试用神经网络的方式构建上述bigram语言模型：

# 构建训练数据
xs, ys = [], [] # 分别是前一个字符和要预测的下一个字符的id
for w in words[:5]:
  chs = ['.'] + list(w) + ['.']
  for ch1, ch2 in zip(chs, chs[1:]):
    ix1 = stoi[ch1]
    ix2 = stoi[ch2]
    print(ch1, ch2)
    xs.append(ix1)
    ys.append(ix2)    
    
xs = torch.tensor(xs)
ys = torch.tensor(ys)
# 输出示例：. e
#          e m
#          m m
#          m a
#          a .
#       xs: tensor([ 0,  5, 13, 13,  1])
#       ys: tensor([ 5, 13, 13,  1,  0])

# 随机初始化一个 27*27 的参数矩阵
g = torch.Generator().manual_seed(2147483647)
W = torch.randn((27, 27), generator=g, requires_grad=True) # 基于正态分布随机初始化
# 前向传播
import torch.nn.functional as F
xenc = F.one_hot(xs, num_classes=27).float() # 将输入数据xs做成one-hot embedding
logits = xenc @ W # 用于模拟统计模型中的统计数值矩阵，由于 W 是基于正态分布采样，logits 并非直接是计数值，可以认为是 log(counts)
## tensor([[-0.5288, -0.5967, -0.7431,  ...,  0.5990, -1.5881,  1.1731],
##        [-0.3065, -0.1569, -0.8672,  ...,  0.0821,  0.0672, -0.3943],
##        [ 0.4942,  1.5439, -0.2300,  ..., -2.0636, -0.8923, -1.6962],
##        ...,
##        [-0.1936, -0.2342,  0.5450,  ..., -0.0578,  0.7762,  1.9665],
##        [-0.4965, -1.5579,  2.6435,  ...,  0.9274,  0.3591, -0.3198],
##        [ 1.5803, -1.1465, -1.2724,  ...,  0.8207,  0.0131,  0.4530]])
counts = logits.exp() # 将 log(counts) 还原成可以看作是 counts 的矩阵
## tensor([[ 0.5893,  0.5507,  0.4756,  ...,  1.8203,  0.2043,  3.2321],
##        [ 0.7360,  0.8548,  0.4201,  ...,  1.0856,  1.0695,  0.6741],
##        [ 1.6391,  4.6828,  0.7945,  ...,  0.1270,  0.4097,  0.1834],
##        ...,
##        [ 0.8240,  0.7912,  1.7245,  ...,  0.9438,  2.1732,  7.1459],
##        [ 0.6086,  0.2106, 14.0621,  ...,  2.5279,  1.4320,  0.7263],
##        [ 4.8566,  0.3177,  0.2802,  ...,  2.2722,  1.0132,  1.5730]])
probs = counts / counts.sum(1, keepdims=True) # 用于模拟统计模型中的概率矩阵，这其实即是 softmax 的实现
loss = -probs[torch.arange(5), ys].log().mean() # loss = log(P)/n， 这其实即是 cross-entropy 的实现

接下来可以通过loss.backward()来更新参数 W:

for k in range(100):
  
  # forward pass
  xenc = F.one_hot(xs, num_classes=27).float() 
  logits = xenc @ W # predict log-counts
  counts = logits.exp()
  probs = counts / counts.sum(1, keepdims=True) 
  loss = -probs[torch.arange(num), ys].log().mean() + 0.01*(W**2).mean() ## 这里加上了L2正则，防止过拟合
  print(loss.item())
  
  # backward pass
  W.grad = None # 每次反向传播前置为None
  loss.backward()
  
  # update
  W.data += -50 * W.grad

注意这里 logits = xenc @ W 由于 xenc 是 one-hot 向量，因此这里 logits 相当于是抽出了 W 中的某一行，而结合 bigram 模型中，loss 实际上是在计算实际的 log(P[x_i, y_i])，那么可以认为这里 W 其实是在拟合 bigram 中的计数矩阵 N（不过实际是 logW 在拟合 N）。

另外上述神经网络的 loss 最终也是达到差不多 2.47 的最低 loss。这是合理的，因为从上面的分析可知，这个神经网络是完全在拟合 bigram 计数矩阵的，没有使用更复杂的特征提取方法，因此效果最终也会差不多。

这里 loss 中还加了一个 L2 正则，主要目的是压缩 W，使得它向全 0 靠近，这里的效果非常类似于 bigram 中的平滑手段，想象给一个极大的平滑：P = (N+10000).float()`，那么 P 会趋于一个均匀分布，而 W 全为 0 会导致 counts = logits.exp() 全为 1，即也在拟合一个均匀分布。这里前面的参数 0.01 即是用来调整平滑强度的，如果这个给的太大，那么平滑太大了，就会学成一个均匀分布（当然实际不会希望这样，所以不会给很大）

查看全文

http://www.kler.cn/a/578442.html