L1, L2和Elastic Net正则化的实现及使用（采用PyTorch框架）

于 2024-05-19 14:55:01 发布
阅读量694 收藏 20
点赞数 15
文章标签： pytorch 人工智能 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/abackcab/article/details/139042894
版权

在机器学习中，L1正则化、L2正则化和Elastic Net正则化是用来避免过拟合的技术，它们通过在损失函数中添加一个惩罚项来实现。

正则化介绍
L1 正则化（Lasso回归）：
L1 正则化通过向损失函数添加参数的绝对值的和来实施惩罚，公式可以表示为：

在这里插入图片描述

其中 L0 是原始的损失函数，λ 是正则化强度，wi是模型参数。

L1 正则化的特点是它可以产生稀疏模型，即许多模型参数会被设置为零。这种特性使得L1正则化不仅可以防止过拟合，还可以进行特征选择。

L2 正则化（Ridge回归）：
L2 正则化通过添加参数的平方和来施加惩罚，公式为：

图片

λ 控制着正则化的强度。

L2 正则化倾向于让参数值趋近于零但不会完全为零，这有助于处理参数值过大的问题，从而减少模型在训练数据上的过拟合。

Elastic Net 正则化：
Elastic Net 正则化是L1和L2正则化的组合，它在损失函数中同时添加了L1和L2惩罚项，公式为：

图片

这种方法结合了L1和L2的优点，既可以产生稀疏模型，也可以平滑模型参数。

在实际应用中，Elastic Net特别适合于那些特征数量多于样本数量，或者特征之间高度相关的情况。

在sklearn中，我们可以使用内置的回归函数来实现

Lasso回归是应用L1正则化的典型模型。它可以通过Lasso类实现；Ridge回归使用L2正则化。它可以通过Ridge类来实现；Elastic Net回归结合了L1和L2正则化。它通过ElasticNet类实现

Pytorch代码实现
但是这些都是最简单的线性回归的扩展，通过上面的介绍，我们看到这些正则化的方式都是通过修改模型本身的权重来实现的，所以我们可以在MLP上也使用这些正则化的方法，下面我们将使用Pytorch来演示这个步骤

首先我们看下L1

 import os
 import torch
 from torch import nn
 from torchvision.datasets import MNIST
 from torch.utils.data import DataLoader
 from torchvision import transforms
 
 class MLP(nn.Module):
   '''
    Multilayer Perceptron.
  '''
   def __init__(self):
     super().__init__()
     self.layers = nn.Sequential(
       nn.Flatten(),
       nn.Linear(28 * 28 * 1, 64),
       nn.ReLU(),
       nn.Linear(64, 32),
       nn.ReLU(),
       nn.Linear(32, 10)
    )
 
 
   def forward(self, x):
     '''Forward pass'''
     return self.layers(x)
   
   def compute_l1_loss(self, w):
       return torch.abs(w).sum()
   
   
 if __name__ == '__main__':
   
   # Set fixed random number seed
   torch.manual_seed(42)
   
   # Prepare CIFAR-10 dataset
   dataset = MNIST(os.getcwd(), download=True, transform=transforms.ToTensor())
   trainloader = torch.utils.data.DataLoader(dataset, batch_size=10, shuffle=True, num_workers=1)
   
   # Initialize the MLP
   mlp = MLP()
   
   # Define the loss function and optimizer
   loss_function = nn.CrossEntropyLoss()
   optimizer = torch.optim.Adam(mlp.parameters(), lr=1e-4)
   
   # Run the training loop
   for epoch in range(0, 5): # 5 epochs at maximum
     
     # Print epoch
     print(f'Starting epoch {epoch+1}')
     
     # Iterate over the DataLoader for training data
     for i, data in enumerate(trainloader, 0):
       
       # Get inputs
       inputs, targets = data
       
       # Zero the gradients
       optimizer.zero_grad()
       
       # Perform forward pass
       outputs = mlp(inputs)
       
       # Compute loss
       loss = loss_function(outputs, targets)
       
       # Compute L1 loss component
       l1_weight = 1.0
       l1_parameters = []
       for parameter in mlp.parameters():
           l1_parameters.append(parameter.view(-1))
       l1 = l1_weight * mlp.compute_l1_loss(torch.cat(l1_parameters))
       
       # Add L1 loss component
       loss += l1
       
       # Perform backward pass
       loss.backward()
       
       # Perform optimization
       optimizer.step()
       
       # Print statistics
       minibatch_loss = loss.item()
       if i % 500 == 499:
           print('Loss after mini-batch %5d: %.5f (of which %.5f L1 loss)' %
                (i + 1, minibatch_loss, l1))
           current_loss = 0.0
 
   # Process is complete.
   print('Training process has finished.')

我们在本身的一个简单的MLP中增加了一个compute_l1_loss方法，在我们计算完基本的损失后，还会计算模型参数的L1 损失，然后与基本损失相加，最后使用这个最终损失来进行反向传播。

L2正则化也很容易。我们不取权重值的绝对值，而是取它们的平方。

 import os
 import torch
 from torch import nn
 from torchvision.datasets import MNIST
 from torch.utils.data import DataLoader
 from torchvision import transforms
 
 class MLP(nn.Module):
   '''
    Multilayer Perceptron.
  '''
   def __init__(self):
     super().__init__()
     self.layers = nn.Sequential(
       nn.Flatten(),
       nn.Linear(28 * 28 * 1, 64),
       nn.ReLU(),
       nn.Linear(64, 32),
       nn.ReLU(),
       nn.Linear(32, 10)
    )
 
 
   def forward(self, x):
     '''Forward pass'''
     return self.layers(x)
   
   def compute_l2_loss(self, w):
       return torch.square(w).sum()
   
   
 if __name__ == '__main__':
   
   # Set fixed random number seed
   torch.manual_seed(42)
   
   # Prepare CIFAR-10 dataset
   dataset = MNIST(os.getcwd(), download=True, transform=transforms.ToTensor())
   trainloader = torch.utils.data.DataLoader(dataset, batch_size=10, shuffle=True, num_workers=1)
   
   # Initialize the MLP
   mlp = MLP()
   
   # Define the loss function and optimizer
   loss_function = nn.CrossEntropyLoss()
   optimizer = torch.optim.Adam(mlp.parameters(), lr=1e-4)
   
   # Run the training loop
   for epoch in range(0, 5): # 5 epochs at maximum
     
     # Print epoch
     print(f'Starting epoch {epoch+1}')
     
     # Iterate over the DataLoader for training data
     for i, data in enumerate(trainloader, 0):
       
       # Get inputs
       inputs, targets = data
       
       # Zero the gradients
       optimizer.zero_grad()
       
       # Perform forward pass
       outputs = mlp(inputs)
       
       # Compute loss
       loss = loss_function(outputs, targets)
       
       # Compute l2 loss component
       l2_weight = 1.0
       l2_parameters = []
       for parameter in mlp.parameters():
           l2_parameters.append(parameter.view(-1))
       l2 = l2_weight * mlp.compute_l2_loss(torch.cat(l2_parameters))
       
       # Add l2 loss component
       loss += l2
       
       # Perform backward pass
       loss.backward()
       
       # Perform optimization
       optimizer.step()
       
       # Print statistics
       minibatch_loss = loss.item()
       if i % 500 == 499:
           print('Loss after mini-batch %5d: %.5f (of which %.5f l2 loss)' %
                (i + 1, minibatch_loss, l2))
           current_loss = 0.0
 
   # Process is complete.
   print('Training process has finished.')

最终的计算过程和L1正则化一样，只不过是计算附加损失的方法不同。

对于L2的正则化Pytorch的Adam优化器有一个官方的参数，叫做权重衰减 weight_decay

 optimizer = torch.optim.Adam(mlp.parameters(), lr=1e-4, weight_decay=1.0)

你可能不知道他和L2的关系，但是你一定用到过，所以我们这样一解释就非常明白了对吧

最后就是Elastic Net (L1 + L2)

 class MLP(nn.Module):
   '''
    Multilayer Perceptron.
  '''
   def __init__(self):
     super().__init__()
     self.layers = nn.Sequential(
       nn.Flatten(),
       nn.Linear(28 * 28 * 1, 64),
       nn.ReLU(),
       nn.Linear(64, 32),
       nn.ReLU(),
       nn.Linear(32, 10)
    )
 
 
   def forward(self, x):
     '''Forward pass'''
     return self.layers(x)
   
   def compute_l1_loss(self, w):
       return torch.abs(w).sum()
   
   def compute_l2_loss(self, w):
       return torch.square(w).sum()
   
   
 if __name__ == '__main__':
   
   # Set fixed random number seed
   torch.manual_seed(42)
   
   # Prepare CIFAR-10 dataset
   dataset = MNIST(os.getcwd(), download=True, transform=transforms.ToTensor())
   trainloader = torch.utils.data.DataLoader(dataset, batch_size=10, shuffle=True, num_workers=1)
   
   # Initialize the MLP
   mlp = MLP()
   
   # Define the loss function and optimizer
   loss_function = nn.CrossEntropyLoss()
   optimizer = torch.optim.Adam(mlp.parameters(), lr=1e-4)
   
   # Run the training loop
   for epoch in range(0, 5): # 5 epochs at maximum
     
     # Print epoch
     print(f'Starting epoch {epoch+1}')
     
     # Iterate over the DataLoader for training data
     for i, data in enumerate(trainloader, 0):
       
       # Get inputs
       inputs, targets = data
       
       # Zero the gradients
       optimizer.zero_grad()
       
       # Perform forward pass
       outputs = mlp(inputs)
       
       # Compute loss
       loss = loss_function(outputs, targets)
       
       # Specify L1 and L2 weights
       l1_weight = 0.3
       l2_weight = 0.7
       
       # Compute L1 and L2 loss component
       parameters = []
       for parameter in mlp.parameters():
           parameters.append(parameter.view(-1))
       l1 = l1_weight * mlp.compute_l1_loss(torch.cat(parameters))
       l2 = l2_weight * mlp.compute_l2_loss(torch.cat(parameters))
       
       # Add L1 and L2 loss components
       loss += l1
       loss += l2
       
       # Perform backward pass
       loss.backward()
       
       # Perform optimization
       optimizer.step()
       
       # Print statistics
       minibatch_loss = loss.item()
       if i % 500 == 499:
           print('Loss after mini-batch %5d: %.5f (of which %.5f L1 loss; %0.5f L2 loss)' %
                (i + 1, minibatch_loss, l1, l2))
           current_loss = 0.0
 
   # Process is complete.
   print('Training process has finished.')

也非常的简单，并且我们可以设置两个权重，就是L1和L2的占比，使用不同的加权，可以获得更好的结果。

总结
这篇文章是要是为了介绍L1, L2和Elastic Net (L1+L2)正则化在理论上是如何工作的。并且我们也在PyTorch中使用了L1, L2和Elastic Net (L1+L2)正则化。这三种正则化方法在不同的情况和数据集上有不同的效果，选择哪种正则化方法取决于具体的应用场景和数据特性。

毕业小助手
关注
  • 15
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
脉络梳理，正则化和L范数直观理解
qq_37177765的博客
10-28 263
正则化和L范数
正则化Regularization
07-22
正则化Regularization正则化Regularization正则化Regularization
正则化
fu6543210的博客
09-28 1124
在编写处理字符串的程序或网页时，经常会有查找符合某些复杂规则的字符串的需要。正则表达式就是用于描述这些规则的工具。换句话说，正则表达式就是记录文本规则的代码。 很可能你使用过Windows/Dos下用于文件查找的通配符(wildcard)，也就是*和?。如果你想查找某个目录下的所有的Word文档的话，你会搜索*.doc。在这里，*会被解释成任意的字符串。和通配符类似，正则表达式也是用来进行文本匹...
机器学习中正则化项L1和L2的直观理解（转）
上帝是个娘们的博客
09-18 183
机器学习中正则化项L1和L2的直观理解
正则化L1 L2
qq_44817900的博客
08-23 1815
正则化通常有两种方式，分别是L1，L2正则化，对应L1范数，和L2范数。有0值出现，确实也该如此，当对一组数据求绝对值的和时，想要其值很小，必须有足够多0值。上图中是二维的情况，若是多维情况，有多个顶点，并且顶点都在坐标轴上，且离等值线更近，也意味着有参数的值为0，也就是产生了稀疏矩阵。是一个超参数（取 0-1），主要是调和cost和正则项的比列，二分之一，是为了求导后，消除2。例如，相交顶点为w1=0，w2=w，若是其他点落在红色等高线上，可以发现。上图中，彩色的曲线圆圈，就是cost的等高线。
波士顿房价预测正则化代码实现
02-26
本项目"波士顿房价预测正则化代码实现"主要关注的是如何通过正则化来防止线性回归模型过拟合，具体涉及L1正则化、L2正则化以及ElasticNet回归。 首先，线性回归是最基础的预测模型之一，它通过找到最佳拟合直线来...
【一看就懂】机器学习之L1和L2正则化1
08-03
在实际应用中，通常会根据任务需求和数据特性来选择L1或L2，或者采用两者的结合，如 Elastic Net 正则化。 正则化不仅仅是为了防止过拟合，它还帮助我们在有限的计算资源下找到一个平衡点，既能够拟合数据，又能...
PyTorch中的正则化：提升模型性能的秘诀
最新发布
07-19
弹性网正则化综合了L1和L2两种正则化的优势，通过设置两个不同的正则化系数（L1和L2），可以在控制模型复杂度的同时保持模型的稳定性。 **代码示例**: ```python # 定义 L1 和 L2 正则化系数 l1_coef = 0.1 l2_...
tikhonov.zip_L曲线正则化_Tikhonov 正则化_Tikhonov正则化_tikhonov_正则化
07-15
6. **比较与其他正则化**：可能讨论Tikhonov正则化与其他正则化方法的区别，如LASSO回归（L1正则化）、Elastic Net（L1和L2正则化结合）等。 7. **误差分析**：探讨正则化对模型误差的影响，包括预测误差和模型偏差...
MATLAB实现elastic net回归
02-09
Elastic Net 回归是一种融合了 L1（Lasso）和 L2（Ridge）正则化的线性回归模型。它在模型拟合的过程中同时考虑到 L1 和 L2 正则项，这有助于处理具有高度共线性的特征以及高维数据集。
L1正则化和L2正则化的详细直观解释
Miracle.Zhao的博客
08-09 3万+
正则化（Regularization） 转自：此处 机器学习中几乎都可以看到损失函数后面会添加一个额外项，常用的额外项一般有两种，一般英文称作ℓ1ℓ1-norm和ℓ2ℓ2-norm，中文称作L1正则化和L2正则化，或者L1范数和L2范数。 L1正则化和L2正则化可以看做是损失函数的惩罚项。所谓『惩罚』是指对损失函数中的某些参数做一些限制。对于线性回归模型，使用L1正则化的模型建叫做Lasso...
L1正则化和L2正则化讲解
Joker的博客
10-16 1万+
L1正则化和L2正则化讲解   在机器学习实践过程中，训练模型的时候往往会出现过拟合现象，为了减小或者避免在训练中出现过拟合现象，通常在原始的损失函数之后附加上正则项，通常使用的正则项有两种：L1正则化和L2正则化。   L1正则化和L2正则化都可以看做是损失函数的惩罚项，所谓惩罚项是指对损失函数中的一些参数进行限制，让参数在某一范围内进行取值。L1正则化的模型叫做LASSO回归，L2正则化的模型叫做岭回归。 LASSO回归公式 min12mΣi=1m(f(x)−y(i))2+λ∣∣w∣∣1min\fr
机器学习中正则化项L1和L2的直观理解
mingyuli的博客
07-22 997
正则化（Regularization） 机器学习中几乎都可以看到损失函数后面会添加一个额外项，常用的额外项一般有两种，一般英文称作ℓ1-norm和ℓ2-norm，中文称作L1正则化 和L2正则化，或者L1范数 和L2范数。 L1正则化和L2正则化可以看做是损失函数的惩罚项。所谓『惩罚』是指对损失函数中的某些参数做一些限制。对于线性回归模型，使用L1正则化的模型建叫做Lasso回归，使用L2正则...
机器学习教程之4-正则化(Regularization)
把你挖出来的博客
05-23 5008
1.过拟合的问题模型的分类：欠拟合、完全符合、过拟合 目前已经学习的线性回归和逻辑回归可以解决很多问题，在实际应用中可能会产生过度拟合(over-fitting)的问题，可能导致它们的效果很差。 这里利用正则化(regularization，有译者翻译为：规范化)技术减少过度拟合的问题。 减少过拟合的方法： 1. 丢弃一些不能帮助我们正确预测的特征。可以是手工选择保留哪些特征， 或者使用一些
L1和L2正则化原理及分析
William Zhao's notes
08-25 1万+
正则化 是指在优化目标函数或代价函数是，在目标函数后面加上一个正则项。正则项通常有L1正则项和L2正则项。 1. L1正则  L1正则是基于L1范数和项，即参数的绝对值和参数的积项，即：  C=C0+λn∑w|w|C=C0+λn∑w|w| 其中C0代表原始的代价函数，n是样本的个数，λ就是正则项系数，权衡正则项与C0项的比重。后面那一项即为L1正则项。  在计算梯度时，w的梯度变为：  ...
机器学习笔记05：正则化(Regularization)、过拟合(Overfitting)
请叫我AXin
04-30 1万+
说明：文章中的所有图片均属于Stanford机器学习课程 （一）过拟合问题(The Problem of Overfitting) 不管是在线性回归还是在逻辑回归中，我们都会遇到过拟合的问题。先从例子来看看什么是过拟合。 i.线性回归中的过拟合 还是以房价预测为例，来看几张张图片： 1.欠拟合（Underfitting） 上图中，我们用一条直线 hθ(x)=θ0+θ1xh_
正则化方法：L1和L2 regularization、数据集扩增、dropout
热门推荐
wepon的专栏
03-14 12万+
本文是《Neural networks and deep learning》概览 中第三章的一部分，讲机器学习/深度学习算法中常用的正则化方法。（本文会不断补充）正则化方法：防止过拟合，提高泛化能力在训练数据不够多时，或者overtraining时，常常会导致overfitting（过拟合）。其直观的表现如下图所示，随着训练过程，网络在training data上的error渐渐减小，但是在验证集上
L2正则化方法
步步拾遗
09-20 1万+
在机器学习中，无论是分类还是回归，都可能存在由于特征过多而导致的过拟合问题。当然解决的办法有 （1）减少特征，留取最重要的特征。 （2）惩罚不重要的特征的权重。 但是通常情况下，我们不知道应该惩罚哪些特征的权重取值。通过正则化方法可以防止过拟合，提高泛化能力。 先来看看L2正则化方法。对于之前梯度下降讲到的损失函数来说，在代价函数后面加上一个正则化项，得到 https://www.cnblogs....
L1正则化和L2正则化参数的区别
03-28
L1正则化和L2正则化是机器学习中常用的正则化方法，它们的主要区别在于正则化的方式和效果。 L1正则化将权重向量中的绝对值相加作为正则化项，即：$||w||_1=\sum_{i=1}^n{|w_i|}$，它的效果是将一些特征的权重降为0，从而达到特征选择的目的，同时也可以防止过拟合。 L2正则化将权重向量中的平方和开根号作为正则化项，即：$||w||_2=\sqrt{\sum_{i=1}^n{w_i^2}}$，它的效果是强制权重分布在整个权重向量上，使得权重向量的每个元素都尽可能小，从而使模型更加平滑。 因此，L1正则化更适用于特征选择问题，而L2正则化更适用于防止过拟合问题。在实际应用中，可以根据具体问题选择使用哪一种正则化方法，也可以将两种正则化方法结合起来使用，即Elastic Net正则化。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

毕业小助手

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值