导数与梯度："学习"的数学定义

回到 L1-02 末尾的问题：矩阵 $W$ 里的数是从哪儿来的？

答案：训练。

更细一点：通过”梯度下降”调出来的。

这一篇我们把”梯度”彻底讲明白。读完你会发现，它只是”哪边是下坡”的数学说法。

第一站：什么是导数

让我们用一个例子。你在开车，速度仪表盘显示当前 60 km/h。

这个数字 60 是什么？它是**“距离对时间的导数”**——

“再过 1 秒，我会前进 60/3600 km”

导数就是变化率。它回答的问题是：

“自变量增加一点点，因变量增加多少？”

数学上写作：

$$f'(x) = \frac{df}{dx} = \lim_{\Delta x \to 0} \frac{f(x + \Delta x) - f(x)}{\Delta x}$$

别被这个公式吓住，它就是说”$x$ 增加 $\Delta x$ 时，$f$ 增加了多少，再除以 $\Delta x$“——一个比值。

一些直觉

• 函数 $f(x) = x^2$，在 $x = 3$ 处的导数 = 6（因为 $f' = 2x$）。意思：$x$ 从 3 增加一点点，$f$ 大约增加 6 倍那么多。
• 函数 $f(x) = 5$（常数），导数 = 0。意思：$x$ 怎么动，$f$ 都不变。
• 函数 $f(x) = 3x + 7$，导数 = 3。意思：$x$ 增加 1，$f$ 增加 3。

几何意义

导数 = 函数图像在该点的”切线斜率”

向上的切线 → 正导数（值在增加） 向下的切线 → 负导数（值在减少） 水平的切线 → 零导数（局部极大或极小）

第二站：什么是梯度

如果一个函数只有一个输入（比如 $f(x)$），它的”导数”就是一个数。

但 AI 里的函数，往往有几百万、几十亿个输入。比如一个神经网络的损失函数：

$$L(W) = L(w_1, w_2, w_3, \ldots, w_{175000000000})$$

——GPT-3 的 1750 亿参数都是它的”输入”。

对这种函数，我们怎么定义”导数”？

答：对每一个参数分别求导，得到的一组数叫梯度（gradient）。

$$\nabla L = \left[ \frac{\partial L}{\partial w_1}, \frac{\partial L}{\partial w_2}, \ldots, \frac{\partial L}{\partial w_n} \right]$$

梯度的每个分量告诉你：“如果只调这一个参数，损失会怎么变。”

梯度本身是一个向量。

一个图形化的直觉

想象你站在一片山地里。你脚下的高度 = 损失函数的值。你身处的位置（经纬度）= 模型参数。

梯度 = “山的最陡上坡方向”。

如果你想找最低点（损失最小），你应该沿着梯度反方向走——这就叫”梯度下降”。

每一步：

$$W_{new} = W_{old} - \alpha \cdot \nabla L(W_{old})$$

• $\alpha$ 是步长（也叫”学习率”）
• $\nabla L$ 是当前位置的梯度
• 负号表示”反方向”——朝下坡走

这就是几乎所有 AI 训练的核心算法。

第三站：链式法则

但神经网络不是 $f(x)$ 这么简单。它是层层嵌套的——

$$y = f_3(f_2(f_1(x)))$$

输入 $x$ 经过第一层 $f_1$，再经过 $f_2$，再经过 $f_3$——这就是”3 层神经网络”。

现在问题来了：怎么对这个嵌套函数求导？

答案：链式法则。这是高中数学就教过的概念，但绝大多数人没意识到它有多重要。

$$\frac{dy}{dx} = \frac{dy}{df_2} \cdot \frac{df_2}{df_1} \cdot \frac{df_1}{dx}$$

翻译过来：每一层”对输入的影响” = 每一层自己导数的连乘。

反向传播（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) = \sum_i (w \cdot x_i - y_i)^2$$

意思：用我们的 $w$ 预测，和实际值差多少的平方和。越小说明拟合越好。

代入数据：

$$L(w) = (w \cdot 1 - 3)^2 + (w \cdot 2 - 5)^2 + (w \cdot 3 - 7)^2$$

2. 求导

$$\frac{dL}{dw} = 2(w-3) + 2 \cdot 2(2w-5) + 2 \cdot 3(3w-7) = 2w - 6 + 8w - 20 + 18w - 42 = 28w - 68$$

3. 梯度下降

随便初始化 $w = 0$，学习率 $\alpha = 0.05$：

步数	$w$	梯度	新 $w$
0	0.00	$28(0)-68 = -68$	$0 - 0.05 \times (-68) = 3.40$
1	3.40	$28(3.4)-68 = 27.2$	$3.40 - 0.05 \times 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 优化器深度解析）

但核心思路完全一样：

1. 前向：用当前参数算预测
2. 算损失
3. 反向：用链式法则算梯度
4. 用梯度更新参数
5. 重复几百万次

想”看见”它

👀 打开梯度下降登山者可视化 —— 点击地图任意位置设起点，看 SGD / Momentum / Adam 三条轨迹同时下山。

一句话总结

导数告诉你”哪个方向能更好”，梯度下降让你”朝那个方向走一步”。

重复几百万次，机器就学会了。

下一篇：《概率与最大似然：为什么机器学习是个概率问题》