详解 L2 正则化：解决神经网络过拟合的实用技巧

原创于 2025-07-17 18:42:43 发布 · 847 阅读

8 ·

CC 4.0 BY-SA版权

文章标签：

#神经网络 #人工智能 #深度学习

在深度学习模型训练中，过拟合是一个常见的挑战。当模型在训练数据上表现优异但在新数据上泛化能力差时，很可能就是出现了过拟合。本文将通过具体代码实例，详细讲解 L2 正则化如何有效缓解过拟合问题，并结合理论知识帮助你理解其工作原理。

一、什么是过拟合？

过拟合指的是模型过度 "记住" 了训练数据中的细节和噪声，而不是学习数据中普遍存在的规律。表现为：

训练损失持续下降，测试损失先降后升
模型在训练集上准确率很高，在测试集上表现糟糕
模型参数值过大，对输入数据的微小变化过于敏感

二、L2 正则化的原理

L2 正则化（也称为权重衰减）通过在损失函数中添加权重参数的平方和来惩罚过大的参数值，从而限制模型复杂度，防止过拟合。

数学原理

添加 L2 正则化后的损失函数为：

$L_{total}(\theta) = L(\theta) + \lambda \cdot \frac{1}{2} \sum_{i} \theta_{i}^{2}$

其中：

$L(\theta)$ 是原始损失函数（如均方误差）
$\lambda$ 是正则化强度，控制惩罚力度
$\theta_i$ 是模型的权重参数

在参数更新时，L2 正则化会让权重朝着 0 的方向进行衰减，更新公式变为：

$\theta_{t+1} = \theta_{t} - \eta \left( \nabla L(\theta_{t}) + \lambda \theta_{t} \right)$

这意味着参数越大，受到的惩罚越大，从而有效限制了参数的增长。

三、代码实现：L2 正则化对比实验

下面通过一个简单的全连接神经网络实验，展示 L2 正则化的效果：

import torch
import torch.nn as nn
import torch.optim as optim
import matplotlib.pyplot as plt

# 设置随机种子以保证可重复性
torch.manual_seed(42)

# 生成随机数据
n_samples = 100  # 样本数量
n_features = 20  # 特征数量
X = torch.randn(n_samples, n_features)  # 输入数据
y = torch.randn(n_samples, 1)  # 目标值

# 定义一个简单的全连接神经网络
class SimpleNet(nn.Module):
    def __init__(self):
        super(SimpleNet, self).__init__()
        self.fc1 = nn.Linear(n_features, 50)  # 第一层：输入层到隐藏层
        self.fc2 = nn.Linear(50, 1)  # 第二层：隐藏层到输出层
        
    def forward(self, x):
        x = torch.relu(self.fc1(x))  # 隐藏层使用ReLU激活函数
        return self.fc2(x)

# 训练函数
def train_model(use_l2=False, weight_decay=0.01, n_epochs=100):
    # 初始化模型
    model = SimpleNet()
    criterion = nn.MSELoss()  # 损失函数（均方误差）
    
    # 选择优化器，weight_decay参数实现L2正则化
    if use_l2:
        # 使用L2正则化，通过weight_decay参数设置正则化强度
        optimizer = optim.SGD(model.parameters(), lr=0.01, weight_decay=weight_decay)
    else:
        # 不使用L2正则化
        optimizer = optim.SGD(model.parameters(), lr=0.01)
    
    # 记录训练损失
    train_losses = []
    
    # 训练过程
    for epoch in range(n_epochs):
        optimizer.zero_grad()  # 清空梯度
        outputs = model(X)  # 前向传播
        loss = criterion(outputs, y)  # 计算损失
        loss.backward()  # 反向传播
        optimizer.step()  # 更新参数
        
        train_losses.append(loss.item())  # 记录损失
        
        # 每10个epoch打印一次损失
        if (epoch + 1) % 10 == 0:
            print(f'Epoch [{epoch + 1}/{n_epochs}], Loss: {loss.item():.4f}')
    
    return train_losses

# 训练并比较两种模型
train_losses_no_l2 = train_model(use_l2=False)  # 不使用L2正则化
train_losses_with_l2 = train_model(use_l2=True, weight_decay=0.01)  # 使用L2正则化

# 绘制训练损失曲线
plt.plot(train_losses_no_l2, label='Without L2 Regularization')
plt.plot(train_losses_with_l2, label='With L2 Regularization')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.title('Training Loss: L2 Regularization vs No Regularization')
plt.legend()
plt.show()