最大似然估计

最大似然估计（Maximum Likelihood Estimation, MLE）是机器学习中最核心的参数估计方法——几乎所有损失函数都是 MLE 的变体。二元交叉熵 BCE = 伯努利分布的负对数似然，用于逻辑回归和二分类 Sigmoid 输出层；多分类交叉熵 CE = Categorical 分布的负对数似然，GPT/BERT 的预训练目标都是最大化下一个 token 的对数似然（即最小化 CE）；MSE 损失 = 假设高斯噪声下的负对数似然，线性回归、图像回归模型的默认选择。MAP（最大后验）= MLE + 正则化：L2 正则对应高斯先验 → 岭回归，L1 正则对应拉普拉斯先验 → Lasso。更进一步，EM 算法在高斯混合模型（GMM）中交替执行 E 步和 M 步来最大化不完全数据的似然；VAE 最大化证据下界 ELBO，本质也是似然估计的推广。理解 MLE 就掌握了“为什么用这个损失函数”以及“正则化项从哪来”的本质原因。

一、核心思想

二、伯努利分布的 MLE → 推导出交叉熵

三、高斯分布的 MLE → 推导出 MSE 损失

四、多分类的 MLE → 推导出多分类交叉熵

五、MAP 估计——加入先验 → 正则化

六、EM 算法与 MLE

七、MLE 总结对照表

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

C#（.NET 10）

// dotnet run 即可执行
// ===== 伯努利 MLE =====
int[] data = { 1, 1, 1, 1, 1, 1, 1, 0, 0, 0 };
double pMle = data.Average();
Console.WriteLine($"伯努利 MLE: p̂ = {pMle}");

foreach (double p in new[] { 0.5, 0.6, 0.7, 0.8 })
{
    double L = Math.Pow(p, 7) * Math.Pow(1 - p, 3);
    Console.WriteLine($"  L(p={p}) = {L:F6}");
}

// ===== 二元交叉熵 = 负对数似然 =====
double[] y = { 1, 0, 1 };
double[] pHat = { 0.9, 0.2, 0.7 };
double bce = 0;
for (int i = 0; i < 3; i++)
    bce -= y[i] * Math.Log(pHat[i]) + (1 - y[i]) * Math.Log(1 - pHat[i]);
Console.WriteLine($"\n总 BCE = {bce:F4}, 平均 = {bce / 3:F4}");

// ===== 线性回归 MLE (正规方程) =====
double[] X = { 50, 60, 80, 100, 120 };
double[] Y = { 150, 180, 230, 290, 350 };
int N = 5;
double sumX = 0, sumY = 0, sumXX = 0, sumXY = 0;
for (int i = 0; i < N; i++)
{ sumX += X[i]; sumY += Y[i]; sumXX += X[i] * X[i]; sumXY += X[i] * Y[i]; }

double w = (N * sumXY - sumX * sumY) / (N * sumXX - sumX * sumX);
double b = (sumY - w * sumX) / N;
Console.WriteLine($"\n线性回归 MLE: w={w:F3}, b={b:F2}");
Console.Write("预测: ");
foreach (double xi in X) Console.Write($"{w * xi + b:F1} ");
Console.WriteLine();

// ===== 高斯 MLE 的 σ² =====
double sigma2 = 0;
for (int i = 0; i < N; i++) sigma2 += Math.Pow(Y[i] - (w * X[i] + b), 2);
sigma2 /= N;
Console.WriteLine($"噪声方差 σ̂² = {sigma2:F2}");

// ===== MAP = MLE + L2 (岭回归) =====
double lam = 10;
double a11 = sumXX + lam, a12 = sumX, a22 = N + lam;
double det = a11 * a22 - a12 * a12;
double wR = (a22 * sumXY - a12 * sumY) / det;
double bR = (-a12 * sumXY + a11 * sumY) / det;
Console.WriteLine($"\n岭回归(λ={lam}): w={wR:F3}, b={bR:F2}");

// ===== 多分类交叉熵 =====
double[] pSoftmax = { 0.01, 0.02, 0.05, 0.72, 0.04, 0.03, 0.02, 0.06, 0.03, 0.02 };
double ce = -Math.Log(pSoftmax[3]);
Console.WriteLine($"\n多分类 CE = {ce:F4}");

Rust

fn main() {
    // ===== 伯努利 MLE =====
    let data = [1, 1, 1, 1, 1, 1, 1, 0, 0, 0_i32];
    let p_mle = data.iter().sum::<i32>() as f64 / data.len() as f64;
    println!("伯努利 MLE: p̂ = {p_mle}");

    for p in [0.5_f64, 0.6, 0.7, 0.8] {
        let l = p.powi(7) * (1.0 - p).powi(3);
        println!("  L(p={p}) = {l:.6}");
    }

    // ===== 二元交叉熵 =====
    let y = [1.0, 0.0, 1.0_f64];
    let p_hat = [0.9, 0.2, 0.7_f64];
    let bce: f64 = (0..3)
        .map(|i| -(y[i] * p_hat[i].ln() + (1.0 - y[i]) * (1.0 - p_hat[i]).ln()))
        .sum();
    println!("\n总 BCE = {bce:.4}, 平均 = {:.4}", bce / 3.0);

    // ===== 线性回归 MLE =====
    let xd = [50.0, 60.0, 80.0, 100.0, 120.0_f64];
    let yd = [150.0, 180.0, 230.0, 290.0, 350.0_f64];
    let n = 5.0_f64;
    let (sx, sy, sxx, sxy) = xd.iter().zip(&yd)
        .fold((0.0, 0.0, 0.0, 0.0), |(sx, sy, sxx, sxy), (&xi, &yi)|
            (sx + xi, sy + yi, sxx + xi * xi, sxy + xi * yi));

    let w = (n.mul_add(sxy, -(sx * sy))) / (n.mul_add(sxx, -(sx * sx)));
    let b = (sy - w * sx) / n;
    println!("\n线性回归 MLE: w={w:.3}, b={b:.2}");
    print!("预测: ");
    for xi in &xd { print!("{:.1} ", w.mul_add(*xi, b)); }
    println!();

    // 高斯 MLE σ²
    let sigma2: f64 = xd.iter().zip(&yd)
        .map(|(&xi, &yi)| (yi - w.mul_add(xi, b)).powi(2))
        .sum::<f64>() / n;
    println!("噪声方差 σ̂² = {sigma2:.2}");

    // ===== Ridge 回归 =====
    let lam = 10.0_f64;
    let (a11, a12, a22) = (sxx + lam, sx, n + lam);
    let det = a11 * a22 - a12 * a12;
    let w_r = (a22 * sxy - a12 * sy) / det;
    let b_r = (-a12 * sxy + a11 * sy) / det;
    println!("\n岭回归(λ={lam}): w={w_r:.3}, b={b_r:.2}");

    // ===== 多分类交叉熵 =====
    let p_sm = [0.01, 0.02, 0.05, 0.72, 0.04, 0.03, 0.02, 0.06, 0.03, 0.02_f64];
    let ce = -p_sm[3].ln();
    println!("\n多分类 CE = {ce:.4}");
}