一个神经元在算什么

这一章要讲什么

机器学习讲的是一个神经元:加权和、加偏置、过激活。

这一章讲多个神经元怎么组成网络:

课

讲什么

这一课

一个神经元内部到底做几步运算

21.2

多个神经元并排 = 一次矩阵乘法

21.3

输入层 / 隐藏层 / 输出层,每层的形状怎么变

21.4

一张小网络,每个数手算一遍

学完这四课,你看到 nn.Linear(784, 128) 时, 应该能立刻说出"它把 784 个数变成 128 个数,中间做了 784×128 次乘法和 128 次加法"。

一个神经元有四个零件

看这个最小的东西:

三个输入各乘一个权重,加完偏置再过激活函数。右边那个 1.3 就是这一层的输出

它做四件事,顺序固定:

#

零件

做什么

1

权重 w

每个输入乘上一个数

2

求和 Σ

把所有乘积加起来

3

偏置 b

加上一个常数

4

激活 f

过一个非线性函数

逐数字算一遍

给一组具体的数:

输入 x = [2, 3, 1] 权重 w = [0.5, -0.2, 0.8] 偏置 b = 0.1 激活 f = ReLU

第 1 步:每个输入乘权重

2 × 0.5 = 1.0 3 × (-0.2) = -0.6 1 × 0.8 = 0.8

第 2 步:加起来

1.0 + (-0.6) + 0.8 = 1.2

第 3 步:加偏置

1.2 + 0.1 = 1.3

第 4 步:过激活

ReLU(1.3) = 1.3 因为 1.3 > 0,原样通过

输出是 1.3。

这个数意味着什么

输入 [2, 3, 1] 经过这个神经元,变成一个数 1.3。

三个数进,一个数出——记住这句话,下一课会用到。

用代码验证

import torch x = torch.tensor([2.0, 3.0, 1.0]) w = torch.tensor([0.5, -0.2, 0.8]) b = 0.1 # 手写四步 prod = x * w # tensor([ 1.0000, -0.6000, 0.8000]) s = prod.sum() # 1.2 z = s + b # 1.3 out = torch.relu(z) # 1.3 print(out.item()) # 1.3

用 PyTorch 的一行写法:

out = torch.relu(x @ w + b) # x @ w 就是"乘完求和",结果是一个标量 # 1.3

x @ w 把前两步合成了一步——这就是点积。

换个输入看看

同样的 w 和 b,输入改成 [-1, 0, 2]:

(-1) × 0.5 = -0.5 0 × (-0.2) = 0.0 2 × 0.8 = 1.6 ------- 1.1 + 0.1 = 1.2 ReLU(1.2) = 1.2

再换成 [-5, 0, 0]:

(-5) × 0.5 = -2.5 0 × ... = 0.0 0 × ... = 0.0 ------ -2.5 + 0.1 = -2.4 ReLU(-2.4) = 0.0 ← 负数被截成 0

ReLU 会把负数直接变 0

第三个例子输出 0。这个神经元对那组输入完全没有反应。

如果一组输入长期让某个神经元输出 0,它的权重就永远得不到有效的梯度更新, 这叫"死亡 ReLU",第 24 课会细讲。

权重控制什么

改一个权重看看影响:

w₁

x = [2,3,1] 时的输出

0.5

1.3

1.0

1.0×2 + (−0.6) + 0.8 + 0.1 = 2.3

−0.5

(−1.0) + (−0.6) + 0.8 + 0.1 = −0.7 → ReLU 后 0

权重决定"这个输入有多重要": 正权重是赞成票,负权重是反对票,绝对值是票的分量。

偏置决定"什么都不输入时的倾向":b 很大,神经元容易兴奋; b 很负,神经元容易被压住。

没有激活会怎样

把 ReLU 去掉,两个神经元串起来:

第一层:y₁ = w₁·x + b₁ 第二层:y₂ = w₂·y₁ + b₂ 代入:y₂ = w₂(w₁x + b₁) + b₂ = (w₂w₁)x + (w₂b₁ + b₂) = Wx + B ← 还是一个线性函数!

这就是必须有激活函数的原因

没有非线性,叠多少层都等于一层。

加了 ReLU 之后,第二层看到的不再是原始输入的线性组合, 才有了"组合特征"的能力。

第 16 章讲过这件事,这里是从运算上再确认一遍。

小结

概念

一句话

一个神经元

把任意多个输入压成一个数

它做的运算

f(x·w + b)

权重

每个输入的重要性,可正可负

偏置

整体偏移,控制"多容易兴奋"

激活

提供非线性,没有它叠层无意义

下一课

一个神经元把 3 个数变成 1 个数。那3 个神经元并排呢?

下一课算给你看——那正好是一次矩阵乘法。