深入解析：如何在 PyTorch 中高效实现 L1 与 L2 正则化

2026-02-04 18:42:15 0条评论 4次阅读 0人点赞

欢迎来到我们关于深度学习模型优化的深度探索系列。在构建和训练神经网络时，我们经常会遇到一个令人头疼的问题：模型在训练集上表现完美，但在测试集或新数据上却表现糟糕。这就是我们常说的“过拟合”。为了解决这个难题，正则化技术成为了我们手中的得力武器。

在这篇文章中，我们将深入探讨两种最基础且强大的正则化技术——L1 和 L2 正则化。我们将不仅理解它们背后的数学直觉，还将亲手编写代码，看看如何在 PyTorch 框架中灵活地应用它们。无论你是刚入门的深度学习爱好者，还是希望优化模型性能的资深开发者，这篇文章都将为你提供实用的见解和最佳实践。

理解深度学习中的正则化

什么是正则化？

简单来说，正则化是一种防止模型“死记硬背”训练数据的技术。在机器学习中，我们的目标是让模型学习数据中的通用规律，而不是噪声。如果不加约束，一个复杂的神经网络可能会拼命调整参数以适应每一个训练样本，包括那些随机出现的噪声。这就像学生为了考试死记硬背，虽然模拟考（训练集）分数很高，但高考（测试集）一旦题型稍微变化，就会束手无策。

正则化的工作原理

正则化的核心思想是在损失函数中增加一个“惩罚项”。这个惩罚项与模型参数的大小相关。这意味着，模型如果想要获得很低的损失，不仅要拟合数据好，还要保持参数尽可能小。这种限制迫使模型关注最显著的特征，忽略细微的噪声，从而提高了模型的泛化能力和鲁棒性。

正则化的主要类型

在深度学习中，最常用的两种正则化方法是 L1 和 L2 正则化。它们对模型参数的惩罚方式截然不同，因此产生的效果也各不相同。

  • L1 正则化：在损失函数中增加一个与参数绝对值成比例的惩罚项。它倾向于让许多权重变为完全的零，从而产生“稀疏”模型。
  • L2 正则化：在损失函数中增加一个与参数平方值成比例的惩罚项。它倾向于让权重普遍变小，但不会完全变成零。

通常，我们将两者结合使用，这种方法被称为“弹性网络”，它兼具了二者的优点。

L1 正则化：特征选择的利器

数学原理

L1 正则化通过在原始损失函数基础上增加一个与权重绝对值之和相关的项来实现。数学公式如下：

$$L{\text{total}} = L{\text{original}} + \lambda \sum{i=1}^{n}

wi

$$

其中：

  • $L_{\text{total}}$ 是我们最终要优化的总损失。
  • $L_{\text{original}}$ 是原始的任务损失（如交叉熵或均方误差）。
  • $\lambda$（lambda）是超参数，控制正则化的强度。
  • $w_i$ 是模型的权重参数。

为什么 L1 如此独特？

L1 正则化最迷人的特性在于它的稀疏性。在几何上，L1 范数的等值线是菱形的，这种形状更容易与原始损失的等值线在坐标轴上相切。这意味着，为了最小化总损失，许多权重 $w_i$ 会被优化器强制变为 0。

这对我们意味着什么？

  • 自动特征选择：那些变为 0 的权重对应的特征，实际上是被模型认为“无用”的。这使得 L1 正则化成为一种内置的特征选择工具。
  • 模型轻量化：由于大部分权重为 0，我们可以直接移除对应的神经元或连接，从而得到一个更小、更快的模型。

L2 正则化：稳健的权重衰减

数学原理

L2 正则化（通常称为权重衰减，Weight Decay）在损失函数中增加一个与权重平方和相关的项。公式如下：

$$L{\text{total}} = L{\text{original}} + \frac{\lambda}{2} \sum{i=1}^{n} wi^2$$

(注：通常在公式中加入 1/2 是为了求导时能消去系数，方便计算，但本质上和平方成比例是一样的)。

L2 的独特优势

与 L1 不同，L2 正则化很难将权重完全压缩为 0，而是让所有权重都变得很小。这具有以下好处：

  • 抑制共线性：当输入特征之间存在高度相关性时，L2 会将相关的特征权重平均化，而不是只依赖其中一个。
  • 数值稳定性：限制权重的大小可以防止梯度爆炸，让训练过程更加平滑。
  • 防止过拟合：通过限制权重的范数，模型对输入数据的微小扰动不那么敏感，从而增强了鲁棒性。

在 PyTorch 中实现正则化

PyTorch 为我们提供了极大的灵活性。实现正则化主要有两种方式：一种是手动实现，这有助于我们理解其工作原理；另一种是利用 PyTorch 优化器内置的 weight_decay 参数。

场景一：手动实现 L1 正则化

PyTorch 的优化器（如 SGD 或 Adam）原生支持 weight_decay（即 L2 正则化），但并没有直接提供 L1 的参数。因此，我们需要手动在反向传播之前计算 L1 惩罚项并将其加到损失中。

下面这个例子展示了如何实现一个带有 L1 正则化的线性回归模型。

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

# 1. 准备一些合成数据
# 我们生成一个稍微带点噪声的线性关系
torch.manual_seed(42) # 设置随机种子以保证结果可复现
X = torch.randn(100, 1) * 10
Y = 2 * X + 3 + torch.randn(100, 1) * 2 # y = 2x + 3 + noise

# 2. 定义一个简单的线性模型
class LinearRegressionModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(1, 1)
    
    def forward(self, x):
        return self.linear(x)

model = LinearRegressionModel()

# 3. 设置超参数
learning_rate = 0.01
epochs = 100
l1_lambda = 0.01 # L1 正则化系数

# 4. 定义优化器（这里我们只使用基础的 SGD，不加 weight_decay）
optimizer = optim.SGD(model.parameters(), lr=learning_rate)
criterion = nn.MSELoss()

# 5. 训练循环
losses = []
for epoch in range(epochs):
    # 前向传播
    y_pred = model(X)
    
    # 计算原始损失 (MSE)
    original_loss = criterion(y_pred, Y)
    
    # === 关键步骤：计算 L1 正则化惩罚项 ===
    # 我们遍历所有参数，计算它们的绝对值之和
    l1_penalty = 0
    for param in model.parameters():
        l1_penalty += torch.sum(torch.abs(param))
    
    # 总损失 = 原始损失 + lambda * L1 惩罚
    total_loss = original_loss + l1_lambda * l1_penalty
    
    # 反向传播和优化
    optimizer.zero_grad()
    total_loss.backward()
    optimizer.step()
    
    losses.append(total_loss.item())
    
    if (epoch+1) % 20 == 0:
        print(f‘Epoch [{epoch+1}/{epochs}], Total Loss: {total_loss.item():.4f}‘)

# 查看训练后的权重
print("
训练后的权重:", model.linear.weight.item())
print("训练后的偏置:", model.linear.bias.item())

代码解析：

请注意代码中的“关键步骤”。我们在 INLINECODEe385c952 基础上，手动计算了所有参数的绝对值之和 INLINECODE93d89cce，然后加到总损失中。在反向传播时，PyTorch 会自动计算这个增加项的梯度，从而在更新参数时起到“惩罚”大权重的作用。

场景二：使用内置的 L2 正则化 (Weight Decay)

与 L1 不同，L2 正则化在 PyTorch 中非常简单，因为几乎所有优化器（INLINECODEcc89862f, INLINECODEca446023, INLINECODE97af97cd 等）都有一个名为 INLINECODE30340caf 的参数。

重要提示：在优化器中设置 weight_decay=0.01 等价于在损失函数中加入 $\frac{\lambda}{2} |

w

^2$。

让我们看一个更复杂的多层感知机（MLP）例子，我们在分类任务中使用 L2 正则化。

import torch
import torch.nn as nn
import torch.optim as optim
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split

# 1. 准备二分类数据集
X, Y = make_classification(n_samples=1000, n_features=20, n_informative=15, random_state=42)
X = torch.tensor(X, dtype=torch.float32)
Y = torch.tensor(Y, dtype=torch.float32).unsqueeze(1)

# 划分训练集和测试集以监控过拟合
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.2, random_state=42)

# 2. 定义一个更宽的神经网络（容易过拟合）
class DeepNet(nn.Module):
    def __init__(self):
        super().__init__()
        # 我们故意设计一个参数较多的网络，以便演示正则化的效果
        self.net = nn.Sequential(
            nn.Linear(20, 64),
            nn.ReLU(),
            nn.Linear(64, 32),
            nn.ReLU(),
            nn.Linear(32, 1),
            nn.Sigmoid()
        )
        
    def forward(self, x):
        return self.net(x)

model = DeepNet()

# 3. 定义优化器和损失函数
# 注意这里的 weight_decay 参数！这就是我们应用 L2 正则化的地方
l2_lambda = 0.01
optimizer = optim.Adam(model.parameters(), lr=0.001, weight_decay=l2_lambda)
criterion = nn.BCELoss() # 二元交叉熵损失

# 4. 训练过程
num_epochs = 100
batch_size = 32

# 简单的批量训练循环
for epoch in range(num_epochs):
    # 这里为了演示简化了数据加载，实际建议使用 DataLoader
    permutation = torch.randperm(X_train.size()[0])
    
    epoch_loss = 0
    for i in range(0, X_train.size()[0], batch_size):
        indices = permutation[i:i+batch_size]
        batch_x, batch_y = X_train[indices], Y_train[indices]
        
        # 前向传播
        y_pred = model(batch_x)
        loss = criterion(y_pred, batch_y)
        
        # 反向传播
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        
        epoch_loss += loss.item()
    
    if (epoch+1) % 20 == 0:
        # 评估测试集损失
        with torch.no_grad():
            test_pred = model(X_test)
            test_loss = criterion(test_pred, Y_test)
            print(f‘Epoch [{epoch+1}/{epochs}], Train Loss: {epoch_loss:.4f}, Test Loss: {test_loss.item():.4f}‘)

实战见解：

在这个例子中，如果你去掉 weight_decay=0.01，你可能会发现训练集损失降得很快，但测试集损失在某个点之后开始上升（过拟合的迹象）。加入 L2 正则化后，你会发现测试集的表现更加稳定，模型不会过度依赖某几个特定的权重。

场景三：弹性网络

如果你想要鱼和熊掌兼得——既想要 L1 的稀疏性（特征选择），又想要 L2 的稳定性——你可以手动结合它们。

# 假设我们在训练循环中
l1_lambda = 0.001
l2_lambda = 0.001

# ... 在计算损失的部分 ...
original_loss = criterion(y_pred, batch_y)

l1_penalty = 0
l2_penalty = 0

for param in model.parameters():
    l1_penalty += torch.sum(torch.abs(param))
    l2_penalty += torch.sum(param ** 2)

# 组合总损失
# 注意：PyTorch 的优化器 weight_decay 实际上也包含了 L2，
# 但为了演示显式计算，这里我们手动把 L2 加到 loss 里。
# 如果同时使用 optimizer 的 weight_decay 和这里的 l2_penalty，
# 实际上你的 L2 强度是两者的叠加。
total_loss = original_loss + l1_lambda * l1_penalty + l2_lambda * l2_penalty

常见错误与性能优化建议

在应用这些技术时，作为开发者，我们需要注意以下几个坑点：

  • 不要重复计算 L2：如果你已经在 INLINECODE7e362cd1 中设置了 INLINECODE168ea569，千万不要再手动计算 L2 惩罚加到 loss 里。这会导致你的正则化强度加倍，模型可能会欠拟合（因为权重被压得太小了）。
  • 关于 INLINECODE960c8545：以前很多人使用 INLINECODE51d555c9 优化器配合 INLINECODE27b7dbb7，但后来发现 Adam 的自适应学习率和 L2 正则化在数学上其实是有冲突的（Adam 衰减权重的力度不如预期）。因此，现在的最佳实践是使用 INLINECODE1873257f 优化器（W 代表 Weight Decay修正），它是专门设计来正确解耦权重衰减和自适应学习率的。强烈建议在复杂模型中使用 AdamW。
  • 如何选择 $\lambda$：这通常是一个超参数搜索的问题。

* 如果 $\lambda$ 太大，模型会欠拟合，权重都被压成了 0（L1）或非常小的常数（L2），模型根本学不到东西。

* 如果 $\lambda$ 太小，正则化起不到作用，依然会过拟合。

* 建议：从 1e-4 或 1e-3 这样的数量级开始尝试，使用验证集来调整这个值。

  • 偏置项：通常我们只需要对权重 $W$ 进行正则化，而不需要对偏置 $b$ 进行正则化。虽然 PyTorch 的 weight_decay 默认对所有参数（包括偏置）生效，但在实践中，对偏置进行正则化往往影响不大。如果你追求极致，可以手动过滤参数列表，只对 weight 参数应用正则化。
# 高级技巧：只对权重应用 weight_decay，而不对偏置项应用
# 1. 定义两个参数组
optimizer = optim.AdamW([
    {‘params‘: model.net[0].weight, ‘weight_decay‘: 0.01},
    {‘params‘: model.net[0].bias,   ‘weight_decay‘: 0},  # 偏置不衰减
    # ... 其他层 ...
], lr=0.001)

结论

在这篇文章中，我们一起剖析了 L1 和 L2 正则化的数学原理及其在 PyTorch 中的实现。我们了解到：

  • L1 正则化是实现稀疏模型和进行特征选择的绝佳工具，虽然 PyTorch 没有内置接口，但手动实现非常简单。
  • L2 正则化 是防止过拟合的稳健手段，可以直接通过优化器的 weight_decay 参数轻松实现。
  • AdamW 是结合了权重衰减的现代优化器，建议作为默认选择。

掌握正则化技术，是每一位从入门进阶到高级深度学习工程师的必经之路。希望你在下一次遇到模型过拟合问题时，能够自信地运用这些工具，构建出更加强大和鲁棒的 AI 模型。

继续尝试修改我们提供的代码，观察不同的 $\lambda$ 值如何影响模型权重的分布，这将会是你深入理解这一概念的最好方式。

声明：本站所有文章，如无特殊说明或标注，均为本站原创发布。任何个人或组织，在未征得本站同意时，禁止复制、盗用、采集、发布本站内容到任何网站、书籍等各类媒体平台。如若本站内容侵犯了原著者的合法权益，可联系我们进行处理。如需转载，请注明文章出处豆丁博客和来源网址。https://shluqu.cn/25930.html
点赞
0.00 平均评分 (0% 分数) - 0 票

相关文章美国1G带宽/1T流量高速vps $17.99/年