机器学习数学推导（二十）正则化与模型选择

正则化(Regularization)是机器学习中控制模型复杂度、防止过拟合的核心技术——当训练数据有限时，模型容易记住噪声而非真实规律。从 L1/L2 正则的数学形式到其贝叶斯先验解释，从 Dropout 的随机失活到早停的隐式正则化，从交叉验证的模型选择到 VC 维的泛化界，正则化理论为平衡欠拟合与过拟合提供了数学保证。本章将深入推导正则化的优化形式、贝叶斯解释、偏差方差分解与学习理论基础。

过拟合与泛化能力

过拟合的数学刻画

训练误差（经验风险）：

R_{}() = _{i=1}^N L(f(_i; ), y_i) $$

泛化误差（期望风险）：

R() = {(, y) P{}} [L(f(; ), y)] $$

泛化差距：

过拟合：很小但很大，泛化差距大

欠拟合：很大

偏差方差权衡

回归问题的期望泛化误差分解：

假设真实模型，[] = 0 $，$ 学习算法在训练集 $上得到模型$

期望泛化误差（对所有可能的 $和噪声$ ）：

分解推导：

第三项：_{}[] = 0$，故为 0

进一步分解第一项：

定义 {f}() = _{}[_{}()]$（平均预测）

第三项：_{} [{f}() - _{} ()] = 0$

最终分解：

物理解释：

偏差（ Bias）：模型平均预测与真实值的差距，衡量欠拟合
方差（ Variance）：不同训练集导致的预测波动，衡量过拟合
不可约误差：数据本身的噪声

模型复杂度与泛化的权衡

简单模型（低复杂度）：

高偏差（欠拟合）
低方差（稳定）

复杂模型（高复杂度）：

低偏差（拟合训练数据）
高方差（对训练数据敏感，过拟合）

最优复杂度：平衡偏差与方差，最小化总误差

L2 正则化：岭回归

优化形式

目标函数：

J() = _{i=1}^N L(f(_i; ), y_i) + ||_2^2 $$

其中 > 0$ 是正则化强度

线性回归的岭回归：

J() = | - |^2 + ||^2 $$

求解：

闭式解：

$^{*} = (^T + N )^{-1} ^T $

正则化的作用：

防止$^T 奇异（不可逆）
收缩权重向 0（权重衰减）

贝叶斯解释

最大后验估计(MAP)：

取对数：

等价于：

假设：

似然： - 先验：（高斯先验）

推导：

组合：

结论： L2 正则化等价于高斯先验下的 MAP 估计，= ^2 / ^2$

权重衰减的梯度下降

梯度更新：

改写为：

物理意义：每次更新前，权重先衰减到倍

SVD 视角的岭回归

线性回归的 SVD 分解：

无正则化的解：

$^{*} = ^{-1} ^T $

岭回归的解：

$_{} = (^2 + N )^{-1} ^T $

收缩因子：

大奇异值_i $：收缩因子$ （保留）
小奇异值_i $：收缩因子$ （抑制）

直觉：岭回归抑制了对应小奇异值的方向（噪声方向）

L1 正则化： Lasso

优化形式

目标函数：

J() = _{i=1}^N L(f(_i; ), y_i) + ||_1 $$

其中||_1 = _j |_j|$

线性回归的 Lasso：

J() = | - |^2 + ||_1 $$

特点：不可微（在 0 点），需要特殊优化算法

稀疏性诱导

L1 vs L2 的几何直觉：

考虑约束优化形式：

L2 约束：||_2 C$（球形）
L1 约束：||_1 C$（菱形，在坐标轴上有尖角）

等高线与约束的切点：

L2：切点通常不在坐标轴上，$非稀疏
L1：切点倾向于在坐标轴上（尖角处），$部分为 0，稀疏！

数学分析：

L1 的次梯度：

软阈值算子（ Soft-thresholding）：

w_j^{} = (w_j^{} ) (|w_j^{} | - , 0) $$

结论： L1 正则化会将小权重直接置为 0，实现特征选择

贝叶斯解释

Laplace 先验：

P() = _j (-) $$

负对数先验：

结论： L1 正则化等价于 Laplace 先验下的 MAP 估计

LASSO 求解算法

坐标下降法（ Coordinate Descent）：

对每个坐标$ j $，固定其他坐标，优化$ w_j$：

w_j (r_j) (|r_j| - , 0) $$

其中$ r_j = j^T ( - {-j} _{-j}) / |_j|^2$

近端梯度下降（ Proximal Gradient Descent）：

其中近端算子：

Elastic Net： L1 + L2

组合正则化：

J() = | - |^2 + _1 ||_1 + ||^2 $$

优势：

保留 L1 的稀疏性
避免 L1 在高相关特征时不稳定的问题
L2 的群组效应：相关特征倾向于同时选择或丢弃

Dropout：随机失活正则化

Dropout 机制

训练时：

每个神经元以概率$ p $（通常$ p=0.5$）被随机"关闭"

或等价地，引入二值掩码：

除以保证期望不变：[_j] = h_j$

测试时：

使用所有神经元，不进行 Dropout（或等价地使用期望）

集成学习视角

想法： Dropout 训练了指数级多个子网络

假设网络有个隐藏神经元，每个可以被 Dropout，共有个可能的子网络

训练：每次 mini-batch 采样一个子网络

测试：近似为所有子网络的平均（权重共享）

类比 Bagging：训练多个模型并平均

正则化效果的数学分析

近似 L2 正则：

考虑线性模型$ y = ^T ， Dropout 相当于添加噪声：

其中

期望与方差：

$[] = (1-p) ^T $ $

最小化方差相当于惩罚_j w_j^2 x_j^2$，类似于自适应 L2 正则

深层网络： Dropout 防止神经元共适应（ co-adaptation），强制学习鲁棒特征

Dropout 变体

DropConnect：随机失活权重而非神经元

$ = ( )^T $

Spatial Dropout（ CNN 专用）：对整个特征图 Dropout

Variational Dropout：在 RNN 中对时间步共享掩码

早停与隐式正则化

早停策略

算法：

在训练过程中监控验证集误差
当验证集误差连续个 epoch 不下降时停止
返回验证集误差最小的模型

效果：防止过拟合，类似于正则化

早停的数学解释

梯度下降的轨迹：

初始化_0 $，经过$ T $ 次迭代：

早停 = 限制迭代次数

对于凸二次损失（如线性回归），可以证明早停与 L2 正则化等价

直觉：

训练初期：学习主要模式（低频分量）
训练后期：拟合噪声（高频分量）

早停在学到主要模式后停止，避免拟合噪声

早停与 L2 正则的关系

线性回归例子：

损失函数：梯度下降更新：

可以证明（通过 SVD 分解）：

$^{(T)} (^T + (T) )^{-1} ^T $

其中(T) /T$

结论：早停相当于自适应的岭回归，$随迭代次数递减

数据增强

数据增强策略

图像：

随机裁剪、翻转、旋转
颜色抖动、亮度/对比度调整
Mixup：线性插值两张图片

文本：

同义词替换
回译（翻译成其他语言再翻译回来）
随机插入/删除/交换

数学原理：

数据增强等价于在损失函数中添加关于变换的不变性约束

L_{} = {, y} {T } [L(f(T()), y)] $$

其中$ 是变换分布（如旋转、翻译）

Mixup 数学分析

Mixup：

$ $

其中(, )$

正则化效果：

鼓励模型在训练样本之间进行线性插值，平滑决策边界

理论分析： Mixup 等价于在特征空间中添加平滑正则项

模型选择与交叉验证

交叉验证策略

K-fold 交叉验证：

将数据分为折（通常或 10）
对每一折$ k $：用其余$ K -1$ 折训练
- 在第折验证
平均次验证误差

估计泛化误差：

留一交叉验证(LOO-CV)： - 无偏估计 - 计算量大次训练

时间序列交叉验证：

保持时间顺序，只用过去数据训练，未来数据验证

信息准则

AIC(Akaike Information Criterion)：

其中是参数数量

BIC(Bayesian Information Criterion)：

原理：平衡拟合度与复杂度

第一项：负对数似然（越小越好）
第二项：复杂度惩罚（越简单越好）

AIC vs BIC：

BIC 对复杂度惩罚更重（N > 2$ 当）
BIC 倾向于选择更简单的模型
AIC 渐近最优（预测视角）
BIC 一致性（时恢复真实模型）

学习曲线与验证曲线

学习曲线：误差 vs 训练样本数

训练误差：单调上升
验证误差：单调下降
两者收敛：欠拟合
两者差距大：过拟合

验证曲线：误差 vs 超参数（如$）

左侧（$ 小）：过拟合
右侧（$ 大）：欠拟合
U 型曲线最低点：最优超参数

泛化理论： VC 维与 PAC 学习

VC 维定义

打散(Shatter)：假设空间 $能对数据集$ 的所有种标签组合给出正确分类

VC 维：$ 能打散的最大样本数

$Extra close brace or missing open brace\text{VC}(\mathcal{H}) = \max \{m: \mathcal{H} \text{ can shatter some set of size } m}$ $

例子：

1D 线性分类器： VC 维 = 2
2D 线性分类器： VC 维 = 3
维线性分类器： VC 维 =

VC 维与泛化界

定理（ Vapnik-Chervonenkis）：

以概率至少，对所有：

R(h) R_{} (h) + $$

含义：

VC 维越大，泛化界越松（需要更多数据）
样本数越大，泛化界越紧

权衡：

复杂模型（高 VC 维）：训练误差小，泛化界松
简单模型（低 VC 维）：训练误差大，泛化界紧

PAC 学习框架

PAC(Probably Approximately Correct)：

给定：

误差阈值> 0 $置信度$ 如果存在算法，以概率至少，输出假设满足：

R(h) R(h^{*}) + $$

其中是最优假设，则$ 是 PAC 可学习的

样本复杂度：

要达到- PAC 学习，需要的样本数：

N = O( (() + (1/))) $$

结论：有限 VC 维$P AC 可学习

Rademacher 复杂度

定义：衡量假设空间在随机标签上的拟合能力

其中_i {-1, +1} $

泛化界：

R(h) R_{} (h) + 2_N() + O( ) $$

优势：

比 VC 维更精细
对数据分布敏感
便于分析深度学习（通过范数界）

深度学习的泛化之谜

现象：深度神经网络参数数量$ 训练样本数，按传统理论应该严重过拟合，但实际泛化很好

经典理论失效：

VC 维10^{10}$（巨大）
Rademacher 复杂度也很高
但测试误差仍然很小！

现代解释：

隐式正则化： SGD 倾向于收敛到平坦最小值（低 Hessian 特征值）
范数约束：实际学到的权重范数远小于理论上界
压缩界：基于 PAC-Bayes 、信息论的新界
双下降曲线：现代过参数化 regime 的新现象

代码实现：正则化技术

L1/L2 正则化实现

import numpy as np

class RegularizedLinearRegression:
    """带正则化的线性回归"""
    
    def __init__(self, reg_type='l2', lambda_reg=0.1):
        """
        参数:
            reg_type: 'l1', 'l2', 或 'elastic_net'
            lambda_reg: 正则化强度（或 L1 强度，对于 elastic_net）
        """
        self.reg_type = reg_type
        self.lambda_reg = lambda_reg
        self.w = None
    
    def fit(self, X, y, learning_rate=0.01, n_iterations=1000, lambda_l2=0.0):
        """
        训练模型（梯度下降）
        
        参数:
            X: (N, D)
            y: (N, 1)
            learning_rate: 学习率
            n_iterations: 迭代次数
            lambda_l2: L2 强度（仅用于 elastic_net）
        """
        N, D = X.shape
        self.w = np.zeros((D, 1))
        
        for _ in range(n_iterations):
            # 预测
            y_pred = X @ self.w
            
            # 梯度
            grad = (2 / N) * X.T @ (y_pred - y)
            
            # 添加正则化梯度
            if self.reg_type == 'l2':
                grad += self.lambda_reg * self.w
            elif self.reg_type == 'l1':
                grad += self.lambda_reg * np.sign(self.w)
            elif self.reg_type == 'elastic_net':
                grad += self.lambda_reg * np.sign(self.w) + lambda_l2 * self.w
            
            # 更新
            self.w -= learning_rate * grad
        
        return self
    
    def fit_closed_form(self, X, y):
        """
        闭式解（仅 L2 正则化）
        
        参数:
            X: (N, D)
            y: (N, 1)
        """
        if self.reg_type != 'l2':
            raise ValueError("Closed form only available for L2 regularization")
        
        N, D = X.shape
        self.w = np.linalg.inv(X.T @ X + self.lambda_reg * N * np.eye(D)) @ X.T @ y
        return self
    
    def predict(self, X):
        """预测"""
        return X @ self.w

Dropout 实现

class DropoutLayer:
    """Dropout 层"""
    
    def __init__(self, dropout_rate=0.5):
        """
        参数:
            dropout_rate: Dropout 概率（关闭神经元的概率）
        """
        self.dropout_rate = dropout_rate
        self.mask = None
        self.training = True
    
    def forward(self, X):
        """
        前向传播
        
        参数:
            X: (batch_size, D)
        
        返回:
            output: (batch_size, D)
        """
        if self.training:
            # 生成二值掩码
            self.mask = np.random.binomial(1, 1 - self.dropout_rate, X.shape)
            # 缩放保持期望不变
            output = X * self.mask / (1 - self.dropout_rate)
        else:
            # 测试时不 Dropout
            output = X
        
        return output
    
    def backward(self, dout):
        """
        反向传播
        
        参数:
            dout: 来自上层的梯度
        
        返回:
            dx: 传递给下层的梯度
        """
        if self.training:
            return dout * self.mask / (1 - self.dropout_rate)
        else:
            return dout
    
    def set_training(self, training):
        """设置训练/测试模式"""
        self.training = training

早停实现

class EarlyStopping:
    """早停策略"""
    
    def __init__(self, patience=5, min_delta=0.0):
        """
        参数:
            patience: 容忍的 epoch 数
            min_delta: 最小改进量
        """
        self.patience = patience
        self.min_delta = min_delta
        self.counter = 0
        self.best_loss = None
        self.early_stop = False
        self.best_model = None
    
    def __call__(self, val_loss, model):
        """
        检查是否应该早停
        
        参数:
            val_loss: 当前验证损失
            model: 当前模型（需要有 copy 方法）
        
        返回:
            是否应该早停
        """
        if self.best_loss is None:
            self.best_loss = val_loss
            self.best_model = model.copy() if hasattr(model, 'copy') else model
        elif val_loss < self.best_loss - self.min_delta:
            self.best_loss = val_loss
            self.counter = 0
            self.best_model = model.copy() if hasattr(model, 'copy') else model
        else:
            self.counter += 1
            if self.counter >= self.patience:
                self.early_stop = True
        
        return self.early_stop

交叉验证实现

from sklearn.model_selection import KFold

class CrossValidator:
    """K-fold 交叉验证"""
    
    def __init__(self, n_splits=5, shuffle=True, random_state=42):
        """
        参数:
            n_splits: 折数
            shuffle: 是否打乱
            random_state: 随机种子
        """
        self.kfold = KFold(n_splits=n_splits, shuffle=shuffle, random_state=random_state)
    
    def evaluate(self, model_class, X, y, **model_params):
        """
        执行交叉验证
        
        参数:
            model_class: 模型类
            X: 特征 (N, D)
            y: 标签 (N, 1)
            **model_params: 模型参数
        
        返回:
            scores: 每折的评分
            avg_score: 平均评分
        """
        scores = []
        
        for train_idx, val_idx in self.kfold.split(X):
            # 分割数据
            X_train, X_val = X[train_idx], X[val_idx]
            y_train, y_val = y[train_idx], y[val_idx]
            
            # 训练模型
            model = model_class(**model_params)
            model.fit(X_train, y_train)
            
            # 评估
            y_pred = model.predict(X_val)
            mse = np.mean((y_val - y_pred)**2)
            scores.append(mse)
        
        return scores, np.mean(scores)
    
    def grid_search(self, model_class, X, y, param_grid):
        """
        网格搜索最佳超参数
        
        参数:
            model_class: 模型类
            X: 特征
            y: 标签
            param_grid: 参数网格（字典）
        
        返回:
            best_params: 最佳参数
            best_score: 最佳评分
        """
        from itertools import product
        
        # 生成所有参数组合
        keys = param_grid.keys()
        values = param_grid.values()
        param_combinations = [dict(zip(keys, v)) for v in product(*values)]
        
        best_score = float('inf')
        best_params = None
        
        for params in param_combinations:
            _, avg_score = self.evaluate(model_class, X, y, **params)
            
            if avg_score < best_score:
                best_score = avg_score
                best_params = params
            
            print(f"Params: {params}, Score: {avg_score:.6f}")
        
        print(f"\nBest params: {best_params}, Best score: {best_score:.6f}")
        return best_params, best_score

综合示例

def regularization_comparison():
    """对比不同正则化方法"""
    # 生成数据
    np.random.seed(42)
    N = 100
    D = 20
    
    X_train = np.random.randn(N, D)
    true_w = np.random.randn(D, 1)
    true_w[10:] = 0  # 稀疏真实权重
    y_train = X_train @ true_w + np.random.randn(N, 1) * 0.1
    
    # 测试集
    X_test = np.random.randn(50, D)
    y_test = X_test @ true_w + np.random.randn(50, 1) * 0.1
    
    # 不同正则化方法
    methods = [
        ('No Regularization', RegularizedLinearRegression(reg_type='l2', lambda_reg=0.0)),
        ('L2 (λ=0.1)', RegularizedLinearRegression(reg_type='l2', lambda_reg=0.1)),
        ('L2 (λ=1.0)', RegularizedLinearRegression(reg_type='l2', lambda_reg=1.0)),
        ('L1 (λ=0.1)', RegularizedLinearRegression(reg_type='l1', lambda_reg=0.1)),
    ]
    
    import matplotlib.pyplot as plt
    fig, axes = plt.subplots(2, 2, figsize=(12, 10))
    axes = axes.flatten()
    
    for idx, (name, model) in enumerate(methods):
        # 训练
        model.fit(X_train, y_train, learning_rate=0.01, n_iterations=1000)
        
        # 预测
        y_pred_train = model.predict(X_train)
        y_pred_test = model.predict(X_test)
        
        # 误差
        train_mse = np.mean((y_train - y_pred_train)**2)
        test_mse = np.mean((y_test - y_pred_test)**2)
        
        # 绘制权重
        ax = axes[idx]
        ax.plot(true_w.flatten(), 'g-', label='True weights', linewidth=2)
        ax.plot(model.w.flatten(), 'r--', label='Learned weights', linewidth=2)
        ax.set_title(f'{name}\nTrain MSE: {train_mse:.4f}, Test MSE: {test_mse:.4f}')
        ax.legend()
        ax.grid(True, alpha=0.3)
        ax.set_xlabel('Weight index')
        ax.set_ylabel('Weight value')
    
    plt.tight_layout()
    plt.savefig('regularization_comparison.png', dpi=300)
    plt.show()

深入问答

Q1： L1 正则为什么产生稀疏解，而 L2 不会？

A：几何和优化两个角度：

几何：约束优化的可行域 - L1：菱形（有尖角），等高线倾向于在尖角处相切 - L2：圆形（光滑），等高线在光滑边界相切

优化：次梯度 - L1 在 0 点次梯度为，可以精确到达 0 - L2 在 0 点梯度为 0，只能无限逼近 0

Q2：为什么 Dropout 在训练时需要除以(1-p)？

A：保持期望不变！

训练时：[] = (1-p) = h $测试时：$ 如果不缩放，测试时激活值是训练时的倍，导致输出不一致。

另一种做法（ Inverted Dropout）：训练时缩放，测试时不变（ PyTorch 采用）

Q3：为什么早停类似 L2 正则化？

A：对于凸二次损失，梯度下降的轨迹可用 SVD 分解：

当小时，这正是岭回归的收缩因子形式，/t$

Q4： Batch Normalization 算正则化吗？

A： BN 主要是加速训练（稳定梯度），但有副作用的正则化效果：

噪声注入： mini-batch 统计量有噪声，类似 Dropout
缩放不变性：权重范数不影响输出，隐式正则化

但 BN 的正则化效果比 Dropout 弱，通常需要结合其他正则化方法。

Q5：如何选择正则化强度λ？

A：三种方法：

交叉验证：网格搜索$（对数尺度）
学习曲线：绘制训练/验证误差 vs $，选择 U 型曲线最低点
贝叶斯优化：高效搜索超参数空间

实践中，从$ 开始，上下调整 1-2 个数量级。

Q6：数据增强为什么有效？

A：两个角度：

增加有效样本数：（是增强倍数）
引入先验知识：如图像旋转不变性、翻译不变性

数学上，数据增强等价于在损失函数中添加对称性约束（群不变性）。

Q7： VC 维能预测深度学习的泛化吗？

A：不能！深度神经网络的 VC 维巨大（10^{10}$），按 VC 理论需要天文数字级别的样本，但实际泛化很好。

现代理论： - PAC-Bayes 界：基于权重范数 - 压缩界：基于信息论 - 隐式正则化： SGD 偏好平坦最小值

VC 维对经典机器学习（ SVM 、决策树）仍有指导意义。

Q8：过参数化为什么有助于泛化？

A：反直觉的"双下降"现象：

欠参数化区域：增加参数降低测试误差
插值阈值：参数数 = 样本数，最差泛化
过参数化区域：继续增加参数，测试误差再次下降！

解释：过参数化使得优化景观更平滑， SGD 找到的解更鲁棒（最小范数插值）。

Q9：如何诊断模型是否需要正则化？

A：检查学习曲线：

1 2	plt.plot(train_loss, label='Train') plt.plot(val_loss, label='Validation')

训练 loss ≪ 验证 loss：过拟合，增加正则化
训练 loss ≈ 验证 loss，但都很高：欠拟合，减少正则化
训练 loss 和验证 loss 都低：良好拟合

Q10： Dropout 、 L2 正则、数据增强能同时使用吗？

A：可以！它们作用于不同方面：

L2 正则：限制权重大小
Dropout：防止神经元共适应
数据增强：引入不变性先验

实践中常见组合： - CNN：数据增强 + L2 正则 + Dropout - Transformer： Dropout + 梯度裁剪 + 标签平滑

注意：过度正则化会导致欠拟合，需要交叉验证调优。

Q11：为什么 ImageNet 预训练模型泛化这么好？

A：三个因素：

数据规模：百万级样本学到通用特征（边缘、纹理、物体部件）
隐式正则化： SGD + BN + 数据增强
迁移学习：低层特征通用，高层特征任务特定

预训练模型相当于强先验，大幅减少目标任务所需样本数。

Q12：学习理论对实践有什么指导？

A：三点启示：

样本复杂度：复杂模型需要更多数据，否则过拟合
正则化必要性：有限样本下，正则化必不可少
模型选择：平衡偏差与方差，选择适当复杂度

但注意：现代深度学习超出传统理论框架，实践中需要经验和实验。

参考文献

[1] Tikhonov, A. N. (1963). Solution of incorrectly formulated problems and the regularization method. Soviet Mathematics Doklady, 5, 1035-1038.

[2] Tibshirani, R. (1996). Regression shrinkage and selection via the lasso. Journal of the Royal Statistical Society: Series B, 58(1), 267-288.

[3] Zou, H., & Hastie, T. (2005). Regularization and variable selection via the elastic net. Journal of the Royal Statistical Society: Series B, 67(2), 301-320.

[4] Srivastava, N., Hinton, G., Krizhevsky, A., Sutskever, I., & Salakhutdinov, R. (2014). Dropout: A simple way to prevent neural networks from overfitting. Journal of Machine Learning Research, 15(1), 1929-1958.

[5] Vapnik, V. N., & Chervonenkis, A. Y. (1971). On the uniform convergence of relative frequencies of events to their probabilities. Theory of Probability & Its Applications, 16(2), 264-280.

[6] Valiant, L. G. (1984). A theory of the learnable. Communications of the ACM, 27(11), 1134-1142.

[7] Bartlett, P. L., & Mendelson, S. (2002). Rademacher and Gaussian complexities: Risk bounds and structural results. Journal of Machine Learning Research, 3, 463-482.

[8] Zhang, C., Bengio, S., Hardt, M., Recht, B., & Vinyals, O. (2017). Understanding deep learning requires rethinking generalization. ICLR.

[9] Neyshabur, B., Bhojanapalli, S., McAllester, D., & Srebro, N. (2017). Exploring generalization in deep learning. NeurIPS, 5947-5956.

[10] Nakkiran, P., Kaplun, G., Bansal, Y., Yang, T., Barak, B., & Sutskever, I. (2020). Deep double descent: Where bigger models and more data hurt. ICLR.