回到 L1-02 末尾的问题:矩阵 W 里的数是从哪儿来的?
答案:训练。
更细一点:通过”梯度下降”调出来的。
这一篇我们把”梯度”彻底讲明白。读完你会发现,它只是”哪边是下坡”的数学说法。
第一站:什么是导数
让我们用一个例子。你在开车,速度仪表盘显示当前 60 km/h。
这个数字 60 是什么?它是**“距离对时间的导数”**——
“再过 1 秒,我会前进 60/3600 km”
导数就是变化率。它回答的问题是:
“自变量增加一点点,因变量增加多少?”
数学上写作:
f′(x)=dxdf=Δx→0limΔxf(x+Δx)−f(x)
别被这个公式吓住,它就是说”x 增加 Δx 时,f 增加了多少,再除以 Δx“——一个比值。
一些直觉
- 函数 f(x)=x2,在 x=3 处的导数 = 6(因为 f′=2x)。意思:x 从 3 增加一点点,f 大约增加 6 倍那么多。
- 函数 f(x)=5(常数),导数 = 0。意思:x 怎么动,f 都不变。
- 函数 f(x)=3x+7,导数 = 3。意思:x 增加 1,f 增加 3。
几何意义
导数 = 函数图像在该点的”切线斜率”
向上的切线 → 正导数(值在增加)
向下的切线 → 负导数(值在减少)
水平的切线 → 零导数(局部极大或极小)
💡 一个关键直觉
导数 = 0 是最优点。
我们要找一个函数的最小值,等价于找让”导数 = 0”的点。
这是接下来”梯度下降”的核心思路。
第二站:什么是梯度
如果一个函数只有一个输入(比如 f(x)),它的”导数”就是一个数。
但 AI 里的函数,往往有几百万、几十亿个输入。比如一个神经网络的损失函数:
L(W)=L(w1,w2,w3,…,w175000000000)
——GPT-3 的 1750 亿参数都是它的”输入”。
对这种函数,我们怎么定义”导数”?
答:对每一个参数分别求导,得到的一组数叫梯度(gradient)。
∇L=[∂w1∂L,∂w2∂L,…,∂wn∂L]
梯度的每个分量告诉你:“如果只调这一个参数,损失会怎么变。”
梯度本身是一个向量。
一个图形化的直觉
想象你站在一片山地里。你脚下的高度 = 损失函数的值。你身处的位置(经纬度)= 模型参数。
梯度 = “山的最陡上坡方向”。
如果你想找最低点(损失最小),你应该沿着梯度反方向走——这就叫”梯度下降”。
每一步:
Wnew=Wold−α⋅∇L(Wold)
- α 是步长(也叫”学习率”)
- ∇L 是当前位置的梯度
- 负号表示”反方向”——朝下坡走
这就是几乎所有 AI 训练的核心算法。
第三站:链式法则
但神经网络不是 f(x) 这么简单。它是层层嵌套的——
y=f3(f2(f1(x)))
输入 x 经过第一层 f1,再经过 f2,再经过 f3——这就是”3 层神经网络”。
现在问题来了:怎么对这个嵌套函数求导?
答案:链式法则。这是高中数学就教过的概念,但绝大多数人没意识到它有多重要。
dxdy=df2dy⋅df1df2⋅dxdf1
翻译过来:每一层”对输入的影响” = 每一层自己导数的连乘。
反向传播(Backprop)
如果你从最后一层开始,一层一层往回算导数——这个过程就叫反向传播。
它是神经网络训练的核心算法。1986 年由 Hinton 等人推广(详见 L0-02 AI 简史)。
关键洞察:链式法则让我们不需要”硬刚”整个网络的导数——可以一层一层、机械地、便宜地算出来。
这就是为什么 100 层、1000 层的网络仍然能训——靠链式法则。
一个完整的例子
让我们用最简单的例子走完整个流程。
任务:给定数据点 (1,3),(2,5),(3,7),找一条直线 y=wx 拟合它们。
我们要找的就是参数 w。
直觉答案:w=2.something(数据看起来 y ≈ 2x + 1,简化后大概)。
机器怎么学:
1. 定义损失函数
L(w)=i∑(w⋅xi−yi)2
意思:用我们的 w 预测,和实际值差多少的平方和。越小说明拟合越好。
代入数据:
L(w)=(w⋅1−3)2+(w⋅2−5)2+(w⋅3−7)2
2. 求导
dwdL=2(w−3)+2⋅2(2w−5)+2⋅3(3w−7)=2w−6+8w−20+18w−42=28w−68
3. 梯度下降
随便初始化 w=0,学习率 α=0.05:
| 步数 | w | 梯度 | 新 w |
|---|
| 0 | 0.00 | 28(0)−68=−68 | 0−0.05×(−68)=3.40 |
| 1 | 3.40 | 28(3.4)−68=27.2 | 3.40−0.05×27.2=2.04 |
| 2 | 2.04 | 28(2.04)−68=−10.88 | 2.04+0.54=2.58 |
| 3 | 2.58 | 28(2.58)−68=4.24 | 2.58−0.21=2.37 |
| 4 | 2.37 | … 越来越接近 0 | ≈ 2.43 |
| ⋯ | | | |
| 收敛 | w≈2.43 | 梯度 ≈ 0 | 找到最优 |
这就是梯度下降的全过程——从一个随机起点出发,不断沿梯度反方向走,直到梯度 = 0。
用 NumPy 跑一遍
import numpy as np
# 数据
X = np.array([1, 2, 3])
y = np.array([3, 5, 7])
# 初始化参数和学习率
w = 0.0
lr = 0.05
# 训练循环
for step in range(50):
# 1. 前向:预测
y_pred = w * X
# 2. 算损失(仅用于打印观察)
loss = np.mean((y_pred - y) ** 2)
# 3. 算梯度(dL/dw)
grad = 2 * np.mean((y_pred - y) * X)
# 4. 梯度下降更新
w = w - lr * grad
if step % 10 == 0:
print(f"step {step}: w={w:.4f}, loss={loss:.4f}, grad={grad:.4f}")
print(f"\n最终 w = {w:.4f}")
跑一下,你会看到 w 从 0 一路逼近 2.43。这就是机器”学”出来的。
真正神经网络的训练
真实神经网络比这个例子复杂得多:
- 参数不是 1 个,是几千亿个
- 损失函数不是平方误差,是交叉熵(下一篇讲)
- 不是用全部数据算梯度,是用 mini-batch
- 不只是简单梯度下降,是 Adam / Momentum 等(详见 L2-09 优化器深度解析)
但核心思路完全一样:
- 前向:用当前参数算预测
- 算损失
- 反向:用链式法则算梯度
- 用梯度更新参数
- 重复几百万次
🔬 一个突然的领悟
“训练”听起来很玄——但本质就是重复做四件事直到收敛。
机器学到的不是”知识”,是一组让损失最小的数。
想”看见”它
👀 打开梯度下降登山者可视化 —— 点击地图任意位置设起点,看 SGD / Momentum / Adam 三条轨迹同时下山。
一句话总结
导数告诉你”哪个方向能更好”,梯度下降让你”朝那个方向走一步”。
重复几百万次,机器就学会了。
下一篇:《概率与最大似然:为什么机器学习是个概率问题》
📐 完整推导(可点开)
📐 推导:链式法则 d/dx f(g(x)) = f'(g(x)) · g'(x) 点击展开 点击折叠
用 Δ 增量法证明
- 设 u=g(x), y=f(u)=f(g(x))。
- x 增加 Δx,u 增加 Δu=g(x+Δx)−g(x),y 增加 Δy。
- 把比率拆开:
ΔxΔy=ΔuΔy⋅ΔxΔu
- 当 Δx→0:Δu→0(连续性);左右两项各自取极限:
dxdy=dudy⋅dxdu=f′(g(x))⋅g′(x)□
深度学习的意义:神经网络是函数嵌套 f3(f2(f1(x)))——反向传播 = 链式法则的工程化。
📐 推导:sigmoid 的导数 σ'(x) = σ(x)(1 - σ(x)) 点击展开 点击折叠
σ(x)=1+e−x1。
- 用商法则 (u1)′=−u2u′:
σ′(x)=−(1+e−x)2−e−x=(1+e−x)2e−x
- 重新整理:
=1+e−x1⋅1+e−xe−x=σ(x)⋅1+e−xe−x
- 注意 1+e−xe−x=1−σ(x):
σ′(x)=σ(x)(1−σ(x))□
为什么这个形式有用:反向传播时算 σ′ 不需要重新算 e−x——只用前向时存的 σ(x) 值即可。