导数详解

目录

1. 引言：导数就在我们身边
2. 一阶导数：变化的快慢
3. 二阶导数：变化的变化
4. 偏导数：多变量的变化
5. 梯度：多变量的方向
6. 链式法则：复合函数的导数
7. 导数的应用场景
8. 导数在人工智能中的应用
9. 可视化代码示例

引言：导数就在我们身边

生活中的导数

想象你正在开车：

• 速度：你每小时行驶多少公里（比如 60 km/h）
• 加速度：你的速度变化有多快（比如每秒增加 2 km/h）

速度就是位置的导数，加速度就是速度的导数！

导数描述的是变化率——某个量变化得有多快。

导数的本质

导数 = 瞬时变化率 = 斜率

就像爬山时，导数告诉你：

• 在某个点，山坡有多陡？
• 向上走还是向下走？
• 走多快会改变高度？

一阶导数：变化的快慢

类比1：汽车的速度

假设你开车从 A 点到 B 点：

位置函数：s(t) = t²（t 是时间，s 是位置）

t = 0 秒：位置 = 0 米
t = 1 秒：位置 = 1 米
t = 2 秒：位置 = 4 米
t = 3 秒：位置 = 9 米

导数（速度）：v(t) = 2t

• t = 1 秒时，速度 = 2 m/s
• t = 2 秒时，速度 = 4 m/s
• t = 3 秒时，速度 = 6 m/s

导数告诉我们：位置变化得越来越快！

类比2：温度的变化

想象一天中温度的变化：

早上 6 点：10°C
中午 12 点：25°C
下午 6 点：20°C
晚上 12 点：15°C

导数（温度变化率）：

• 早上到中午：温度上升，导数为正（+2.5°C/小时）
• 中午到下午：温度下降，导数为负（-0.83°C/小时）

导数告诉我们：温度是上升还是下降，变化有多快！

数学定义

对于函数 f(x)，在点 x 处的导数定义为：

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

直观理解：

• 取两个非常接近的点
• 计算函数值的变化
• 除以距离
• 得到瞬时变化率

几何意义：切线的斜率

导数就是函数图像上某点处切线的斜率！

想象一条曲线：
- 在点 A，画一条切线
- 这条切线的斜率 = 导数
- 斜率大 = 曲线陡峭
- 斜率小 = 曲线平缓
- 斜率为正 = 上升
- 斜率为负 = 下降

常见函数的导数

导数的运算法则

1. 常数倍法则：
$$(cf(x))' = cf'(x)$$

2. 和差法则：
$$(f(x) \pm g(x))' = f'(x) \pm g'(x)$$

3. 乘积法则：
$$(f(x) \cdot g(x))' = f'(x)g(x) + f(x)g'(x)$$

4. 商法则：
$$\left(\frac{f(x)}{g(x)}\right)' = \frac{f'(x)g(x) - f(x)g'(x)}{g(x)^2}$$

5. 链式法则（后面详细讲解）：
$$(f(g(x)))' = f'(g(x)) \cdot g'(x)$$

二阶导数：变化的变化

类比：汽车的加速度

回到开车的例子：

位置：s(t) = t²
速度：v(t) = s'(t) = 2t（一阶导数）
加速度：a(t) = v'(t) = 2（二阶导数）

二阶导数告诉我们：速度的变化率是恒定的（加速度恒定）！

类比：股票价格

想象股票价格的变化：

第一天：价格上升 5%（一阶导数 > 0）
第二天：价格上升 3%（一阶导数 > 0，但变小了）
第三天：价格上升 1%（一阶导数 > 0，更小了）

二阶导数 < 0：虽然价格还在上升，但上升的速度在减慢（上升趋势减弱）

第一天：价格下降 2%（一阶导数 < 0）
第二天：价格下降 1%（一阶导数 < 0，但绝对值变小）
第三天：价格上升 1%（一阶导数 > 0）

二阶导数 > 0：下降速度在减慢，可能触底反弹

数学定义

二阶导数是导数的导数：

$$f''(x) = \frac{d}{dx}(f'(x)) = \frac{d^2}{dx^2}f(x)$$

几何意义：曲线的弯曲程度

二阶导数描述曲线的凹凸性：

• $f''(x) > 0$：曲线向上弯曲（凹函数，像碗）
• $f''(x) < 0$：曲线向下弯曲（凸函数，像拱桥）
• $f''(x) = 0$：拐点（弯曲方向改变的点）

实际应用：最优化

在寻找函数的最小值或最大值时：

1. 一阶导数 = 0：找到极值点（可能是最大值或最小值）
2. 二阶导数 > 0：这是最小值点（局部最低点）
3. 二阶导数 < 0：这是最大值点（局部最高点）

类比：爬山时

• 一阶导数 = 0：你站在山顶或谷底（水平）
• 二阶导数 > 0：你在谷底（周围都比这里高）
• 二阶导数 < 0：你在山顶（周围都比这里低）

偏导数：多变量的变化

类比：房间的温度分布

想象一个房间，温度随位置变化：

温度函数：T(x, y) = x² + y²

x = 水平位置
y = 垂直位置
T = 温度

问题：如果你只向东移动（x 增加），温度变化多快？

答案：对 x 的偏导数 = 2x

问题：如果你只向北移动（y 增加），温度变化多快？

答案：对 y 的偏导数 = 2y

数学定义

对于多变量函数 $f(x, y, z, ...)$：

对 x 的偏导数：把其他变量当作常数，只对 x 求导

$$\frac{\partial f}{\partial x} = \lim_{h \to 0} \frac{f(x+h, y, z, ...) - f(x, y, z, ...)}{h}$$

记号：$\frac{\partial f}{\partial x}$ 或 $f_x$

实际例子

函数：$f(x, y) = x^2y + 3xy^2$

对 x 的偏导数（把 y 当常数）：
$$\frac{\partial f}{\partial x} = 2xy + 3y^2$$

对 y 的偏导数（把 x 当常数）：
$$\frac{\partial f}{\partial y} = x^2 + 6xy$$

几何意义

偏导数 = 沿着某个坐标轴方向的斜率

想象一个三维曲面：

• $\frac{\partial f}{\partial x}$：沿着 x 方向切一刀，看切线的斜率
• $\frac{\partial f}{\partial y}$：沿着 y 方向切一刀，看切线的斜率

梯度：多变量的方向

类比：最陡的上坡方向

想象你在一个山坡上：

高度函数：h(x, y) = x² + y²

你在点 (1, 1)，高度 = 2

问题：朝哪个方向走，高度增加最快？

答案：梯度方向！

梯度：所有偏导数组成的向量

$$\nabla f = \left(\frac{\partial f}{\partial x}, \frac{\partial f}{\partial y}\right) = (2x, 2y)$$

在点 (1, 1)：$\nabla f = (2, 2)$

这意味着：

• 朝 (2, 2) 方向走，高度增加最快
• 朝 -(2, 2) 方向走，高度下降最快

数学定义

对于函数 $f(x_1, x_2, ..., x_n)$，梯度是：

$$\nabla f = \left(\frac{\partial f}{\partial x_1}, \frac{\partial f}{\partial x_2}, ..., \frac{\partial f}{\partial x_n}\right)$$

梯度是一个向量，指向函数值增加最快的方向。

梯度的性质

1. 梯度指向最陡上升方向
2. 梯度的大小 = 变化率
3. 负梯度指向最陡下降方向

链式法则：复合函数的导数

类比：连锁反应

想象一个工厂的生产链：

原材料 → 半成品 → 成品

如果：
- 原材料增加 10%，半成品增加 5%
- 半成品增加 10%，成品增加 8%

那么：
- 原材料增加 10%，成品增加多少？
- 答案：5% × 8% = 0.4%（近似）

数学定义

如果 $y = f(u)$ 且 $u = g(x)$，那么：

$$\frac{dy}{dx} = \frac{dy}{du} \cdot \frac{du}{dx}$$

直观理解：变化率相乘

例子

函数：$y = (x^2 + 1)^3$

设：$u = x^2 + 1$，则 $y = u^3$

链式法则：
$$\frac{dy}{dx} = \frac{dy}{du} \cdot \frac{du}{dx} = 3u^2 \cdot 2x = 3(x^2 + 1)^2 \cdot 2x = 6x(x^2 + 1)^2$$

多变量链式法则

如果 $z = f(x, y)$，且 $x = g(t)$，$y = h(t)$，那么：

$$\frac{dz}{dt} = \frac{\partial z}{\partial x} \cdot \frac{dx}{dt} + \frac{\partial z}{\partial y} \cdot \frac{dy}{dt}$$

这就像：z 的变化 = x 方向的变化 + y 方向的变化

导数的应用场景

1. 物理学：运动学

位置、速度、加速度的关系：

位置：s(t)
速度：v(t) = s'(t)（位置的导数）
加速度：a(t) = v'(t) = s''(t)（速度的导数，位置的二阶导数）

应用：

• 计算物体在任意时刻的速度
• 预测物体的未来位置
• 分析运动轨迹

2. 经济学：边际分析

成本函数：C(q) = 生产 q 件产品的总成本

边际成本：C'(q) = 多生产一件产品的额外成本

收益函数：R(q) = 销售 q 件产品的总收益

边际收益：R'(q) = 多销售一件产品的额外收益

利润最大化：当边际成本 = 边际收益时，利润最大

3. 工程学：最优化设计

问题：设计一个容器，在给定体积下，表面积最小

方法：

1. 建立目标函数（表面积）
2. 建立约束条件（体积固定）
3. 求导数，找极值点
4. 验证二阶导数，确认是最小值

4. 生物学：种群增长模型

逻辑增长模型：$P(t) = \frac{K}{1 + Ae^{-rt}}$

• P(t)：t 时刻的种群数量
• K：环境容量
• r：增长率

导数：$P'(t)$ 表示种群增长的速度

应用：预测种群数量变化，制定保护策略

5. 医学：药物浓度

药物在血液中的浓度：$C(t) = C_0 e^{-kt}$

• C₀：初始浓度
• k：清除率常数

导数：$C'(t) = -kC_0 e^{-kt}$ 表示浓度下降的速度

应用：确定给药频率，保证有效浓度

导数在人工智能中的应用

1. 梯度下降：机器学习的核心

问题：如何找到函数的最小值？

类比：你在一个黑暗的山谷中，想找到最低点

方法：

1. 感受脚下的坡度（计算梯度）
2. 朝最陡的下坡方向走一步（沿负梯度方向）
3. 重复，直到到达谷底

数学表达

目标：最小化损失函数 $L(\theta)$

梯度下降更新规则：

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

其中：

• $\theta$：模型参数（权重）
• $\alpha$：学习率（步长）
• $\nabla L$：损失函数的梯度

例子：线性回归

模型：$y = wx + b$

损失函数：$L(w, b) = \frac{1}{n}\sum_{i=1}^{n}(y_i - (wx_i + b))^2$

梯度：
$$\frac{\partial L}{\partial w} = -\frac{2}{n}\sum_{i=1}^{n}(y_i - (wx_i + b))x_i$$
$$\frac{\partial L}{\partial b} = -\frac{2}{n}\sum_{i=1}^{n}(y_i - (wx_i + b))$$

更新：
$$w_{new} = w_{old} - \alpha \frac{\partial L}{\partial w}$$
$$b_{new} = b_{old} - \alpha \frac{\partial L}{\partial b}$$

重复这个过程，直到损失函数收敛！

2. 反向传播：神经网络的训练

问题：多层神经网络如何更新权重？

前向传播：输入 → 隐藏层1 → 隐藏层2 → 输出

反向传播：输出 → 隐藏层2 → 隐藏层1 → 输入

核心：链式法则！

简单例子

网络结构：

输入 x → 权重 w1 → 隐藏层 h → 权重 w2 → 输出 y

前向传播：
$$h = f(w_1 x)$$
$$y = g(w_2 h)$$

损失：$L = (y_{true} - y)^2$

反向传播（使用链式法则）：

$$\frac{\partial L}{\partial w_2} = \frac{\partial L}{\partial y} \cdot \frac{\partial y}{\partial w_2}$$

$$\frac{\partial L}{\partial w_1} = \frac{\partial L}{\partial y} \cdot \frac{\partial y}{\partial h} \cdot \frac{\partial h}{\partial w_1}$$

这就是链式法则的应用！

3. 优化算法：Adam、RMSprop 等

问题：如何加速梯度下降？

基本梯度下降的问题：

• 学习率固定，可能太慢或太快
• 在狭窄的山谷中震荡

解决方案：自适应学习率

Adam 算法（使用一阶和二阶矩估计）：

1. 计算梯度的一阶矩（平均值）
2. 计算梯度的二阶矩（方差）
3. 自适应调整学习率

数学表达：

$$m_t = \beta_1 m_{t-1} + (1-\beta_1)g_t$$
$$v_t = \beta_2 v_{t-1} + (1-\beta_2)g_t^2$$
$$\theta_t = \theta_{t-1} - \alpha \frac{m_t}{\sqrt{v_t} + \epsilon}$$

其中：

• $g_t$：当前梯度
• $m_t$：一阶矩估计
• $v_t$：二阶矩估计
• $\alpha$：学习率

4. 正则化：防止过拟合

L2 正则化

损失函数：$L_{total} = L_{data} + \lambda \sum \theta_i^2$

梯度：$\frac{\partial L_{total}}{\partial \theta_i} = \frac{\partial L_{data}}{\partial \theta_i} + 2\lambda \theta_i$

效果：大的权重会被惩罚，防止模型过拟合

L1 正则化

损失函数：$L_{total} = L_{data} + \lambda \sum |\theta_i|$

梯度：$\frac{\partial L_{total}}{\partial \theta_i} = \frac{\partial L_{data}}{\partial \theta_i} + \lambda \text{sign}(\theta_i)$

效果：可以产生稀疏权重（很多权重变为 0）

5. 激活函数的导数

问题：为什么需要激活函数？

激活函数：$f(x)$，如 ReLU、Sigmoid、Tanh

导数的重要性：

• 在反向传播中，需要计算激活函数的导数
• 导数影响梯度的大小
• 梯度消失/爆炸问题

常见激活函数及其导数

1. Sigmoid：$\sigma(x) = \frac{1}{1+e^{-x}}$

导数：$\sigma'(x) = \sigma(x)(1-\sigma(x))$

问题：导数最大值为 0.25，容易导致梯度消失

2. ReLU：$f(x) = \max(0, x)$

导数：
$$f'(x) = \begin{cases}
1 & \text{if } x > 0 \
0 & \text{if } x \leq 0
\end{cases}$$

优点：计算简单，缓解梯度消失

3. Tanh：$\tanh(x) = \frac{e^x - e^{-x}}{e^x + e^{-x}}$

导数：$\tanh'(x) = 1 - \tanh^2(x)$

6. 卷积神经网络的梯度

卷积操作的导数

前向传播：卷积操作

反向传播：需要计算卷积的梯度

关键：卷积的梯度 = 转置卷积（Transposed Convolution）

应用：图像生成、语义分割

7. 生成对抗网络（GAN）

问题：如何训练生成器？

目标：生成器 G 和判别器 D 的对抗训练

损失函数：
$$L_D = -\mathbb{E}[\log D(x_{real})] - \mathbb{E}[\log(1-D(G(z)))]$$
$$L_G = -\mathbb{E}[\log D(G(z))]$$

训练过程：

1. 固定 G，更新 D（最大化 $L_D$）
2. 固定 D，更新 G（最小化 $L_G$）

核心：交替使用梯度下降和梯度上升

可视化代码示例

以下 Python 代码可以帮助你可视化导数的概念：

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.patches import FancyArrowPatch
from mpl_toolkits.mplot3d import Axes3D

# 设置中文字体
plt.rcParams['font.sans-serif'] = ['SimHei', 'Microsoft YaHei']
plt.rcParams['axes.unicode_minus'] = False

# ==================== 1. 一阶导数可视化 ====================
def visualize_first_derivative():
    """可视化一阶导数：切线的斜率"""
    x = np.linspace(0, 10, 100)
    y = x**2  # 函数 y = x²
    dy = 2*x  # 导数 y' = 2x
    
    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 5))
    
    # 左图：函数和切线
    ax1.plot(x, y, 'b-', linewidth=2, label='y = x²')
    
    # 在几个点画切线
    points = [2, 4, 6]
    for p in points:
        x_tangent = np.linspace(p-1, p+1, 10)
        y_tangent = dy[points.index(p)*10] * (x_tangent - p) + p**2
        ax1.plot(x_tangent, y_tangent, 'r--', linewidth=2, alpha=0.7)
        ax1.plot(p, p**2, 'ro', markersize=8)
        ax1.text(p, p**2 + 5, f'斜率={2*p}', fontsize=10)
    
    ax1.set_xlabel('x', fontsize=12)
    ax1.set_ylabel('y', fontsize=12)
    ax1.set_title('函数和切线（导数 = 切线斜率）', fontsize=14)
    ax1.legend()
    ax1.grid(True, alpha=0.3)
    
    # 右图：导数函数
    ax2.plot(x, dy, 'g-', linewidth=2, label="y' = 2x")
    ax2.set_xlabel('x', fontsize=12)
    ax2.set_ylabel("y'", fontsize=12)
    ax2.set_title('导数函数', fontsize=14)
    ax2.legend()
    ax2.grid(True, alpha=0.3)
    
    plt.tight_layout()
    plt.savefig('first_derivative.png', dpi=300, bbox_inches='tight')
    plt.show()

# ==================== 2. 二阶导数可视化 ====================
def visualize_second_derivative():
    """可视化二阶导数：曲线的凹凸性"""
    x = np.linspace(-5, 5, 100)
    y = x**3 - 3*x  # 函数 y = x³ - 3x
    dy = 3*x**2 - 3  # 一阶导数
    d2y = 6*x  # 二阶导数
    
    fig, axes = plt.subplots(3, 1, figsize=(10, 12))
    
    # 原函数
    axes[0].plot(x, y, 'b-', linewidth=2, label='y = x³ - 3x')
    axes[0].axhline(y=0, color='k', linestyle='--', alpha=0.3)
    axes[0].axvline(x=0, color='k', linestyle='--', alpha=0.3)
    axes[0].set_xlabel('x', fontsize=12)
    axes[0].set_ylabel('y', fontsize=12)
    axes[0].set_title('原函数', fontsize=14)
    axes[0].legend()
    axes[0].grid(True, alpha=0.3)
    
    # 一阶导数
    axes[1].plot(x, dy, 'g-', linewidth=2, label="y' = 3x² - 3")
    axes[1].axhline(y=0, color='k', linestyle='--', alpha=0.3)
    axes[1].axvline(x=0, color='k', linestyle='--', alpha=0.3)
    axes[1].set_xlabel('x', fontsize=12)
    axes[1].set_ylabel("y'", fontsize=12)
    axes[1].set_title('一阶导数（变化率）', fontsize=14)
    axes[1].legend()
    axes[1].grid(True, alpha=0.3)
    
    # 二阶导数
    axes[2].plot(x, d2y, 'r-', linewidth=2, label="y'' = 6x")
    axes[2].axhline(y=0, color='k', linestyle='--', alpha=0.3)
    axes[2].axvline(x=0, color='k', linestyle='--', alpha=0.3)
    axes[2].fill_between(x, 0, d2y, where=(d2y > 0), alpha=0.3, color='green', label='凹函数')
    axes[2].fill_between(x, 0, d2y, where=(d2y < 0), alpha=0.3, color='red', label='凸函数')
    axes[2].set_xlabel('x', fontsize=12)
    axes[2].set_ylabel("y''", fontsize=12)
    axes[2].set_title('二阶导数（凹凸性：>0 凹，<0 凸）', fontsize=14)
    axes[2].legend()
    axes[2].grid(True, alpha=0.3)
    
    plt.tight_layout()
    plt.savefig('second_derivative.png', dpi=300, bbox_inches='tight')
    plt.show()

# ==================== 3. 偏导数可视化 ====================
def visualize_partial_derivative():
    """可视化偏导数：多变量函数"""
    x = np.linspace(-3, 3, 50)
    y = np.linspace(-3, 3, 50)
    X, Y = np.meshgrid(x, y)
    Z = X**2 + Y**2  # 函数 z = x² + y²
    
    fig = plt.figure(figsize=(14, 5))
    
    # 3D 曲面
    ax1 = fig.add_subplot(121, projection='3d')
    surf = ax1.plot_surface(X, Y, Z, cmap='viridis', alpha=0.8)
    ax1.set_xlabel('x', fontsize=12)
    ax1.set_ylabel('y', fontsize=12)
    ax1.set_zlabel('z', fontsize=12)
    ax1.set_title('函数 z = x² + y²', fontsize=14)
    fig.colorbar(surf, ax=ax1)
    
    # 等高线图
    ax2 = fig.add_subplot(122)
    contour = ax2.contour(X, Y, Z, levels=10)
    ax2.clabel(contour, inline=True, fontsize=8)
    
    # 在点 (1, 1) 处画梯度
    point_x, point_y = 1, 1
    grad_x = 2 * point_x  # ∂z/∂x = 2x
    grad_y = 2 * point_y  # ∂z/∂y = 2y
    
    ax2.plot(point_x, point_y, 'ro', markersize=10, label='点 (1, 1)')
    ax2.arrow(point_x, point_y, grad_x * 0.3, grad_y * 0.3, 
             head_width=0.2, head_length=0.15, fc='red', ec='red', 
             linewidth=2, label='梯度方向')
    ax2.set_xlabel('x', fontsize=12)
    ax2.set_ylabel('y', fontsize=12)
    ax2.set_title('等高线图和梯度（最陡上升方向）', fontsize=14)
    ax2.legend()
    ax2.grid(True, alpha=0.3)
    ax2.set_aspect('equal')
    
    plt.tight_layout()
    plt.savefig('partial_derivative.png', dpi=300, bbox_inches='tight')
    plt.show()
    
    print(f"在点 (1, 1) 处：")
    print(f"∂z/∂x = {grad_x}")
    print(f"∂z/∂y = {grad_y}")
    print(f"梯度向量 = ({grad_x}, {grad_y})")

# ==================== 4. 梯度下降可视化 ====================
def visualize_gradient_descent():
    """可视化梯度下降过程"""
    # 定义损失函数（简单的二次函数）
    x = np.linspace(-5, 5, 100)
    y = (x - 2)**2 + 1  # 最小值在 x = 2
    
    # 梯度下降
    x_start = -3
    learning_rate = 0.3
    n_iterations = 10
    
    x_path = [x_start]
    y_path = [(x_start - 2)**2 + 1]
    
    x_current = x_start
    for i in range(n_iterations):
        gradient = 2 * (x_current - 2)  # 导数
        x_current = x_current - learning_rate * gradient
        x_path.append(x_current)
        y_path.append((x_current - 2)**2 + 1)
    
    fig, ax = plt.subplots(figsize=(10, 6))
    ax.plot(x, y, 'b-', linewidth=2, label='损失函数 L(x) = (x-2)² + 1')
    ax.plot(x_path, y_path, 'ro-', linewidth=2, markersize=8, label='梯度下降路径')
    
    # 标注每个点
    for i, (xp, yp) in enumerate(zip(x_path, y_path)):
        ax.annotate(f'步骤 {i}', (xp, yp), xytext=(5, 5), 
                   textcoords='offset points', fontsize=9)
    
    ax.axvline(x=2, color='g', linestyle='--', alpha=0.5, label='最小值点 x=2')
    ax.set_xlabel('x (参数)', fontsize=12)
    ax.set_ylabel('L(x) (损失)', fontsize=12)
    ax.set_title('梯度下降：寻找损失函数的最小值', fontsize=14)
    ax.legend()
    ax.grid(True, alpha=0.3)
    
    plt.tight_layout()
    plt.savefig('gradient_descent.png', dpi=300, bbox_inches='tight')
    plt.show()

# ==================== 5. 链式法则可视化 ====================
def visualize_chain_rule():
    """可视化链式法则"""
    x = np.linspace(0, 5, 100)
    u = x**2  # u = g(x) = x²
    y = np.sin(u)  # y = f(u) = sin(u)，所以 y = sin(x²)
    
    # 直接求导：y = sin(x²)
    dy_direct = 2*x * np.cos(x**2)
    
    # 链式法则：dy/dx = (dy/du) * (du/dx)
    du_dx = 2*x  # du/dx
    dy_du = np.cos(u)  # dy/du
    dy_chain = dy_du * du_dx
    
    fig, axes = plt.subplots(2, 2, figsize=(12, 10))
    
    # u = x²
    axes[0, 0].plot(x, u, 'b-', linewidth=2, label='u = x²')
    axes[0, 0].set_xlabel('x', fontsize=12)
    axes[0, 0].set_ylabel('u', fontsize=12)
    axes[0, 0].set_title('u = g(x) = x²', fontsize=14)
    axes[0, 0].legend()
    axes[0, 0].grid(True, alpha=0.3)
    
    # y = sin(u)
    u_range = np.linspace(0, 25, 100)
    axes[0, 1].plot(u_range, np.sin(u_range), 'g-', linewidth=2, label='y = sin(u)')
    axes[0, 1].set_xlabel('u', fontsize=12)
    axes[0, 1].set_ylabel('y', fontsize=12)
    axes[0, 1].set_title('y = f(u) = sin(u)', fontsize=14)
    axes[0, 1].legend()
    axes[0, 1].grid(True, alpha=0.3)
    
    # y = sin(x²)
    axes[1, 0].plot(x, y, 'r-', linewidth=2, label='y = sin(x²)')
    axes[1, 0].set_xlabel('x', fontsize=12)
    axes[1, 0].set_ylabel('y', fontsize=12)
    axes[1, 0].set_title('复合函数 y = sin(x²)', fontsize=14)
    axes[1, 0].legend()
    axes[1, 0].grid(True, alpha=0.3)
    
    # 导数对比
    axes[1, 1].plot(x, dy_direct, 'b-', linewidth=2, label="直接求导: 2x·cos(x²)")
    axes[1, 1].plot(x, dy_chain, 'r--', linewidth=2, label="链式法则: cos(x²)·2x")
    axes[1, 1].set_xlabel('x', fontsize=12)
    axes[1, 1].set_ylabel("dy/dx", fontsize=12)
    axes[1, 1].set_title('导数（两种方法结果相同）', fontsize=14)
    axes[1, 1].legend()
    axes[1, 1].grid(True, alpha=0.3)
    
    plt.tight_layout()
    plt.savefig('chain_rule.png', dpi=300, bbox_inches='tight')
    plt.show()

# ==================== 主程序 ====================
if __name__ == '__main__':
    print("=" * 60)
    print("导数可视化示例")
    print("=" * 60)
    
    print("\n1. 一阶导数可视化（切线斜率）")
    visualize_first_derivative()
    
    print("\n2. 二阶导数可视化（凹凸性）")
    visualize_second_derivative()
    
    print("\n3. 偏导数可视化（多变量函数）")
    visualize_partial_derivative()
    
    print("\n4. 梯度下降可视化")
    visualize_gradient_descent()
    
    print("\n5. 链式法则可视化")
    visualize_chain_rule()
    
    print("\n所有可视化完成！")

总结

本文详细介绍了导数的各种概念：

核心概念

1. 一阶导数：变化率，切线的斜率
2. 二阶导数：变化的变化率，曲线的凹凸性
3. 偏导数：多变量函数沿某个方向的变化率
4. 梯度：多变量函数的导数向量，指向最陡上升方向
5. 链式法则：复合函数求导的规则

关键应用

1. 物理学：运动学、动力学
2. 经济学：边际分析、最优化
3. 工程学：设计优化
4. 人工智能：
   • 梯度下降（优化算法）
   • 反向传播（神经网络训练）
   • 正则化（防止过拟合）
   • 激活函数设计

在 AI 中的重要性

导数是人工智能的基础：

• 没有导数，就没有梯度下降
• 没有梯度下降，就无法训练神经网络
• 没有神经网络，就没有深度学习