梯度与偏导数

偏导数是多元函数对单个变量的导数，梯度 ∇f = (∂f/∂x₁, ..., ∂f/∂xₙ) 则是所有偏导数组成的向量。梯度指向函数增长最快的方向，它的反方向就是函数下降最快的方向——深度学习的参数更新公式 w ← w - η·∇L(w) 正是沿梯度反方向迈一步。在 ResNet-50 中，一次反向传播要计算约 2500 万个参数的偏导数；GPT-3 要对 1750 亿个参数分别求偏导。方向导数告诉我们沿任意方向的变化率，梯度方向的方向导数最大——这正是梯度下降比随机搜索高效的数学原因。Jacobian 矩阵将梯度推广到向量值函数（如 Softmax 的 Jacobian），Hessian 矩阵（二阶偏导）用于 Newton 法和判断鞍点。工程中的偏导数计算由自动微分（autograd）引擎在计算图上自动完成，不需要手写公式。

一、为什么需要偏导数

高中学的导数只针对一元函数 f(x)。但神经网络的损失函数有成千上万个参数：L(w₁, w₂, ..., wₙ)。我们需要知道"调整每个参数 wᵢ 对损失的影响有多大"——这就是偏导数。

二、偏导数的逐步计算

三、梯度的定义与性质

四、方向导数——在任意方向上的变化率

五、AI 真实场景中的梯度计算

六、梯度的几何直觉

七、代码验证（C# / Rust）

C#（.NET 10）

// dotnet run 即可执行
// ===== 偏导数的数值验证 =====
double F(double x, double y) => 3*x*x*y + 2*x*y*y - 5*x + 7;
double DfDx(double x, double y) => 6*x*y + 2*y*y - 5;
double DfDy(double x, double y) => 3*x*x + 4*x*y;

double x0 = 2.0, y0 = 3.0, eps = 1e-7;
double numDx = (F(x0+eps, y0) - F(x0-eps, y0)) / (2*eps);
double numDy = (F(x0, y0+eps) - F(x0, y0-eps)) / (2*eps);
Console.WriteLine($"解析 ∂f/∂x = {DfDx(x0,y0)}, 数值 = {numDx:F6}");
Console.WriteLine($"解析 ∂f/∂y = {DfDy(x0,y0)}, 数值 = {numDy:F6}");

// ===== 线性回归梯度下降 =====
double[,] X = { {25,60}, {30,45}, {20,80}, {28,55} };
double[] y = { 27, 32, 22, 30 };
double[] w = { 0.8, 0.05 };
double b = 2.0, lr = 0.0001;
int rows = 4, cols = 2;

for (int epoch = 0; epoch < 5; epoch++)
{
    double[] yp = new double[rows];
    for (int i = 0; i < rows; i++)
    { yp[i] = b; for (int j = 0; j < cols; j++) yp[i] += X[i,j] * w[j]; }

    double loss = 0;
    for (int i = 0; i < rows; i++) loss += Math.Pow(y[i] - yp[i], 2);
    loss /= rows;

    double[] dw = new double[cols]; double db = 0;
    for (int i = 0; i < rows; i++)
    {
        double d = y[i] - yp[i];
        for (int j = 0; j < cols; j++) dw[j] += X[i,j] * d;
        db += d;
    }
    for (int j = 0; j < cols; j++) { dw[j] *= -2.0/rows; w[j] -= lr*dw[j]; }
    db *= -2.0/rows; b -= lr*db;
    Console.WriteLine($"Epoch {epoch+1}: Loss={loss:F4}, w=[{w[0]:F4}, {w[1]:F4}], b={b:F4}");
}

// ===== 方向导数验证 =====
double[] pt = {1.0, 1.0};
double[] grad = {2*pt[0], 4*pt[1]};  // f=x²+2y², ∇f=(2x,4y)
double norm = Math.Sqrt(grad[0]*grad[0] + grad[1]*grad[1]);
Console.WriteLine($"\n梯度: [{grad[0]}, {grad[1]}], 模: {norm:F4}");

double dirD = grad[0]*(grad[0]/norm) + grad[1]*(grad[1]/norm);
Console.WriteLine($"梯度方向导数 = {dirD:F4} (应等于模)");
Console.WriteLine($"x方向导数 = {grad[0]}");
Console.WriteLine($"y方向导数 = {grad[1]}");

Rust

fn main() {
    // ===== 偏导数的数值验证 =====
    let f = |x: f64, y: f64| 3.0*x*x*y + 2.0*x*y*y - 5.0*x + 7.0;
    let df_dx = |x: f64, y: f64| 6.0*x*y + 2.0*y*y - 5.0;
    let df_dy = |x: f64, y: f64| 3.0*x*x + 4.0*x*y;

    let (x0, y0, eps) = (2.0_f64, 3.0, 1e-7);
    let nd_x = (f(x0+eps, y0) - f(x0-eps, y0)) / (2.0*eps);
    let nd_y = (f(x0, y0+eps) - f(x0, y0-eps)) / (2.0*eps);
    println!("解析 ∂f/∂x = {}, 数值 = {nd_x:.6}", df_dx(x0, y0));
    println!("解析 ∂f/∂y = {}, 数值 = {nd_y:.6}", df_dy(x0, y0));

    // ===== 线性回归梯度下降 =====
    let xd = [[25.0,60.0],[30.0,45.0],[20.0,80.0],[28.0,55.0]];
    let yd = [27.0, 32.0, 22.0, 30.0_f64];
    let (mut w, mut b, lr, n) = ([0.8, 0.05_f64], 2.0_f64, 0.0001_f64, 4);

    for epoch in 0..5 {
        let mut yp = [0.0_f64; 4];
        for i in 0..n { yp[i] = xd[i][0].mul_add(w[0], xd[i][1].mul_add(w[1], b)); }

        let mut loss = 0.0_f64;
        for i in 0..n { loss += (yd[i] - yp[i]).powi(2); }
        loss /= n as f64;

        let (mut dw, mut db) = ([0.0_f64; 2], 0.0_f64);
        for i in 0..n {
            let d = yd[i] - yp[i];
            dw[0] += xd[i][0]*d; dw[1] += xd[i][1]*d; db += d;
        }
        dw[0] *= -2.0/n as f64; dw[1] *= -2.0/n as f64; db *= -2.0/n as f64;
        w[0] -= lr*dw[0]; w[1] -= lr*dw[1]; b -= lr*db;
        println!("Epoch {}: Loss={loss:.4}, w=[{:.4}, {:.4}], b={b:.4}",
                 epoch+1, w[0], w[1]);
    }

    // ===== 方向导数 =====
    let pt = [1.0, 1.0_f64];
    let grad = [2.0*pt[0], 4.0*pt[1]];
    let norm = (grad[0]*grad[0] + grad[1]*grad[1]).sqrt();
    println!("\n梯度: [{}, {}], 模: {norm:.4}", grad[0], grad[1]);

    let dir_d = (grad[0]/norm).mul_add(grad[0], (grad[1]/norm) * grad[1]);
    println!("梯度方向导数 = {dir_d:.4} (应等于模)");
    println!("x方向导数 = {}", grad[0]);
    println!("y方向导数 = {}", grad[1]);
}