# Python实战：用SymPy搞定一元函数微分学（附梯度下降可视化） 数学与编程的交叉点总是充满魅力。当高等数学遇上Python，枯燥的公式瞬间变得生动起来。SymPy这个符号计算库，让微积分不再是纸上谈兵，而是可以亲手操作、直观感受的活知识。本文将带你用代码重新认识导数、微分这些基础概念，并最终将它们应用于机器学习中的梯度下降算法。 ## 1. 符号计算基础：SymPy快速入门 在传统数学课上，我们用手工计算导数。现在，SymPy可以帮我们自动完成这些机械工作。首先安装这个库： ```bash pip install sympy numpy matplotlib ``` 定义符号变量是SymPy的第一步。与普通Python变量不同，符号变量代表数学表达式中的未知数： ```python import sympy as sp x = sp.symbols('x') # 定义符号变量x f = x**3 - 2*x + 1 # 定义函数f(x) ``` 计算导数只需一行代码： ```python f_prime = sp.diff(f, x) # 计算f(x)的一阶导数 print(f"导数结果: {f_prime}") ``` SymPy的强大之处在于它能保持表达式的符号形式。比如计算sin(x)的导数： ```python f_trig = sp.sin(x**2) print(sp.diff(f_trig, x)) # 输出: 2*x*cos(x**2) ``` 常见导数计算对照表： | 函数类型 | SymPy表达式 | 导数结果 | |---------|------------|---------| | 多项式 | x**3 + 2*x | 3*x**2 + 2 | | 三角函数 | sp.sin(x) | sp.cos(x) | | 指数函数 | sp.exp(x) | sp.exp(x) | | 对数函数 | sp.log(x) | 1/x | > 提示：使用`sp.init_printing()`可以让SymPy以更美观的数学格式输出结果，适合Jupyter notebook环境。 ## 2. 微分学的核心概念解析 导数描述的是变化率，而微分则是这个变化率的线性近似。让我们用代码来揭示它们的关系。 计算函数在某点的导数值： ```python f = x**2 f_prime = sp.diff(f, x) # 在x=2处的导数值 print(f_prime.subs(x, 2)) # 输出: 4 ``` 微分计算示例： ```python dx = sp.symbols('dx') # 定义微分变量 # 计算f在x=1处的微分 linear_approx = f.subs(x, 1) + f_prime.subs(x, 1)*dx print(f"在x=1处的线性近似: {linear_approx}") ``` 可视化对比函数值与其线性近似： ```python import numpy as np import matplotlib.pyplot as plt x_vals = np.linspace(0.5, 1.5, 100) y_original = [f.subs(x, val) for val in x_vals] y_approx = [linear_approx.subs(dx, val-1) for val in x_vals] plt.figure(figsize=(10,6)) plt.plot(x_vals, y_original, label='原函数 $f(x)=x^2$') plt.plot(x_vals, y_approx, '--', label='线性近似') plt.scatter([1], [f.subs(x, 1)], color='red') plt.legend() plt.grid(True) plt.title('函数与其线性近似的对比') plt.show() ``` 复合函数求导法则的应用： ```python # 链式法则示例 g = sp.sin(x**2) g_prime = sp.diff(g, x) print(f"复合函数导数: {g_prime}") # 输出: 2*x*cos(x**2) ``` ## 3. 高级求导技巧实战 隐函数求导是SymPy的拿手好戏。以圆的方程为例： ```python x, y = sp.symbols('x y') circle = x**2 + y**2 - 1 # 单位圆方程 # 计算dy/dx dy_dx = sp.idiff(circle, y, x) print(f"隐函数导数结果: {dy_dx}") # 输出: -x/y ``` 参数方程求导示例： ```python t = sp.symbols('t') x_t = t - sp.sin(t) y_t = 1 - sp.cos(t) # 摆线方程 # 计算dy/dx dy_dx_param = sp.diff(y_t, t) / sp.diff(x_t, t) print(f"参数方程导数: {dy_dx_param.simplify()}") ``` 泰勒展开是函数局部近似的强大工具。SymPy可以轻松生成泰勒多项式： ```python # 在x=0处展开e^x，到5阶 taylor_exp = sp.series(sp.exp(x), x, 0, 6).removeO() print(f"e^x的泰勒展开: {taylor_exp}") ``` 比较不同阶数的泰勒近似效果： ```python orders = [1, 3, 5] x_vals = np.linspace(-2, 2, 100) plt.figure(figsize=(10,6)) plt.plot(x_vals, np.exp(x_vals), 'k', label='真实值') for n in orders: approx = sp.series(sp.exp(x), x, 0, n+1).removeO() y_approx = [approx.subs(x, val) for val in x_vals] plt.plot(x_vals, y_approx, '--', label=f'{n}阶近似') plt.legend() plt.title('不同阶数泰勒近似的比较') plt.grid(True) plt.show() ``` ## 4. 微分学在梯度下降中的应用 梯度下降是优化算法的核心，其本质就是导数的应用。让我们实现一个完整的例子。 定义损失函数及其导数： ```python w = sp.symbols('w') loss = w**2 - 4*w + 5 # 简单的二次损失函数 loss_prime = sp.diff(loss, w) # 解析解 # 转换为数值函数 loss_func = sp.lambdify(w, loss, 'numpy') grad_func = sp.lambdify(w, loss_prime, 'numpy') ``` 梯度下降实现： ```python def gradient_descent(start, lr, iterations): history = [] current = start for _ in range(iterations): grad = grad_func(current) current = current - lr * grad history.append(current) return history ``` 可视化梯度下降过程： ```python w_history = gradient_descent(start=10, lr=0.1, iterations=20) w_vals = np.linspace(-1, 11, 100) plt.figure(figsize=(10,7)) plt.plot(w_vals, loss_func(w_vals), label='损失函数') plt.scatter(w_history, loss_func(w_history), c='red', s=100, alpha=0.3) plt.plot(w_history, loss_func(w_history), 'r--', alpha=0.3) plt.scatter([2], [loss_func(2)], c='green', s=200, marker='*', label='最小值') plt.xlabel('参数w') plt.ylabel('损失值') plt.title('梯度下降过程可视化') plt.legend() plt.grid(True) plt.show() ``` 学习率对收敛的影响对比： ```python lrs = [0.01, 0.1, 0.5] # 不同学习率 plt.figure(figsize=(12,8)) for lr in lrs: history = gradient_descent(10, lr, 20) plt.plot(loss_func(history), 'o-', label=f'lr={lr}') plt.xlabel('迭代次数') plt.ylabel('损失值') plt.title('不同学习率下的收敛情况') plt.legend() plt.grid(True) plt.show() ``` 在实际项目中，我们可能遇到更复杂的函数。比如添加正则化项后的损失函数： ```python # 带L2正则化的损失函数 lambda_ = 0.1 loss_reg = w**2 - 4*w + 5 + lambda_*w**2 loss_reg_prime = sp.diff(loss_reg, w) # 新的最小值点 solution = sp.solve(loss_reg_prime, w) print(f"带正则化的最优解: {solution[0]:.4f}") ```