逐数字走一遍

前两课分开讲了神经元和层。这一课把它们串成一个完整的两层网络, 从输入一路算到损失。

网络很小,手工能算完:

输入 2 个数 → 隐藏层 3 个神经元 → 输出层 2 个神经元

全部参数

W1 = [[ 0.3, -0.5], b1 = [ 0.1, [ 0.8, 0.2], 0.0, [-0.4, 0.6]] -0.2] 形状 (3, 2) 形状 (3,) W2 = [[ 0.7, -0.3, 0.5], b2 = [ 0.0, [-0.2, 0.9, -0.1]] 0.1] 形状 (2, 3) 形状 (2,)

输入和标签:

x = [1.0, 2.0] 正确类别 = 1(第二个类)

第 1 层:2 个数 → 3 个数

先算隐藏层。三个神经元,每个接收 2 个输入。

z1 = x @ W1ᵀ + b1,逐个算:

第 0 个隐藏神经元

1.0 × 0.3 + 2.0 × (-0.5) = 0.3 - 1.0 = -0.7 -0.7 + 0.1 = -0.6 ReLU(-0.6) = 0.0 ← 被截断

第 1 个隐藏神经元

1.0 × 0.8 + 2.0 × 0.2 = 0.8 + 0.4 = 1.2 1.2 + 0.0 = 1.2 ReLU(1.2) = 1.2

第 2 个隐藏神经元

1.0 × (-0.4) + 2.0 × 0.6 = -0.4 + 1.2 = 0.8 0.8 + (-0.2) = 0.6 ReLU(0.6) = 0.6

隐藏层输出 a1 = [0.0, 1.2, 0.6]

第 2 层:3 个数 → 2 个数

隐藏层出来 3 个数,现在它们成了第 2 层的输入。

z2 = a1 @ W2ᵀ + b2:

第 0 个输出

0.0 × 0.7 + 1.2 × (-0.3) + 0.6 × 0.5 = 0.0 - 0.36 + 0.30 = -0.06 -0.06 + 0.0 = -0.06

第 1 个输出

0.0 × (-0.2) + 1.2 × 0.9 + 0.6 × (-0.1) = 0.0 + 1.08 - 0.06 = 1.02 1.02 + 0.1 = 1.12

logits = [-0.06, 1.12]

第 1 个位置更大,所以模型猜类别 1。正确类别也是 1——这次猜对了。

算损失

前向走完了,模型给了两个分数。现在把它和正确答案比一比。

用交叉熵。先 softmax 把两个数变成概率:

e^(-0.06) = 0.9418 e^(1.12) = 3.0649 ------- 总和 = 4.0067 p₀ = 0.9418 / 4.0067 = 0.2351 p₁ = 3.0649 / 4.0067 = 0.7649

正确类别是 1,取 p₁ = 0.7649,损失:

loss = -ln(0.7649) = 0.2679

这一轮的损失是 0.268。

这个损失算好还是不好

两个类别,随机猜的损失是 -ln(0.5) = 0.693。

0.268 比它低,说明模型猜得比随机好,但还没到满分(满分是 0)。

用代码验证全部数字

import torch, torch.nn as nn W1 = torch.tensor([[ 0.3, -0.5], [ 0.8, 0.2], [-0.4, 0.6]]) b1 = torch.tensor([0.1, 0.0, -0.2]) W2 = torch.tensor([[ 0.7, -0.3, 0.5], [-0.2, 0.9, -0.1]]) b2 = torch.tensor([0.0, 0.1]) x = torch.tensor([[1.0, 2.0]]) y = torch.tensor([1]) # 逐层算 z1 = x @ W1.T + b1 a1 = torch.relu(z1) z2 = a1 @ W2.T + b2 print("z1 ", z1) # tensor([[-0.6000, 1.2000, 0.6000]]) print("a1 ", a1) # tensor([[0.0000, 1.2000, 0.6000]]) print("logits", z2) # tensor([[-0.0600, 1.1200]]) print("probs", torch.softmax(z2, dim=1)) # tensor([[0.2351, 0.7649]]) print("pred ", z2.argmax(1)) # tensor([1]) print("loss ", nn.CrossEntropyLoss()(z2, y)) # tensor(0.2679)

全部对上了。

一次前向做了多少次运算

数字都对上了。最后看一眼这个小网络到底算了多少东西。

层

乘法

加法

第 1 层

3×2 = 6

3×2 = 6(每次点积 2 次加)

第 2 层

2×3 = 6

6

偏置

—

3 + 2 = 5

合计

12

17

换成真实网络 784 → 128 → 10:

第 1 层:784 × 128 = 100352 次乘法 第 2 层:128 × 10 = 1280 次乘法 合计 :101632 次乘法,每个样本

一批 64 个样本就是 650 万次乘法。一次前向。

这解释了为什么需要 GPU——不是它单次运算快,是它能同时算几千个。

从这一课记住的三件事

整个第 21 章压缩成三句话。

#

记住

1

每层就是一次 输入 @ 权重ᵀ + 偏置

2

激活函数在层与层之间,形状不变

3

最后一层输出的是 logits,不是概率

你现在应该能回答

· nn.Linear(128, 10) 有多少个参数?

· 输入 (64, 128) 经过它之后形状是什么?

· 输出层为什么是 10 而不是 1?

· 为什么模型最后一层不需要加 softmax?

下一章

现在你知道网络在算什么了。下一章把它写成 nn.Module, 接上损失和优化器,跑通 MNIST。