使用PyTorch实现L1, L2和Elastic Net正则化

最新推荐文章于 2024-05-24 00:07:19 发布
最新推荐文章于 2024-05-24 00:07:19 发布
阅读量3.9k 收藏 12
点赞数 5
文章标签： pytorch 人工智能 python 深度学习 机器学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/deephub/article/details/138652748
版权

在机器学习中，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

 importos
 importtorch
 fromtorchimportnn
 fromtorchvision.datasetsimportMNIST
 fromtorch.utils.dataimportDataLoader
 fromtorchvisionimporttransforms
 
 classMLP(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)
     )
 
 
   defforward(self, x):
     '''Forward pass'''
     returnself.layers(x)
   
   defcompute_l1_loss(self, w):
       returntorch.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
   forepochinrange(0, 5): # 5 epochs at maximum
     
     # Print epoch
     print(f'Starting epoch {epoch+1}')
     
     # Iterate over the DataLoader for training data
     fori, datainenumerate(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= []
       forparameterinmlp.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()
       ifi%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正则化也很容易。我们不取权重值的绝对值，而是取它们的平方。

 importos
 importtorch
 fromtorchimportnn
 fromtorchvision.datasetsimportMNIST
 fromtorch.utils.dataimportDataLoader
 fromtorchvisionimporttransforms
 
 classMLP(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)
     )
 
 
   defforward(self, x):
     '''Forward pass'''
     returnself.layers(x)
   
   defcompute_l2_loss(self, w):
       returntorch.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
   forepochinrange(0, 5): # 5 epochs at maximum
     
     # Print epoch
     print(f'Starting epoch {epoch+1}')
     
     # Iterate over the DataLoader for training data
     fori, datainenumerate(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= []
       forparameterinmlp.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()
       ifi%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)

 classMLP(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)
     )
 
 
   defforward(self, x):
     '''Forward pass'''
     returnself.layers(x)
   
   defcompute_l1_loss(self, w):
       returntorch.abs(w).sum()
   
   defcompute_l2_loss(self, w):
       returntorch.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
   forepochinrange(0, 5): # 5 epochs at maximum
     
     # Print epoch
     print(f'Starting epoch {epoch+1}')
     
     # Iterate over the DataLoader for training data
     fori, datainenumerate(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= []
       forparameterinmlp.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()
       ifi%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)正则化。这三种正则化方法在不同的情况和数据集上有不同的效果，选择哪种正则化方法取决于具体的应用场景和数据特性。

https://avoid.overfit.cn/post/c99ec105e41c4a71a0a1a29735245944

deephub
关注
  • 5
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
pytorch-lasso:使用PyTorch的L1正则化最小二乘
04-19
用于L1正则化最小二乘（套索）问题的PyTorch库。 该库正在进行中。 欢迎和赞赏的贡献！ 作者：Reuben Feinman（纽约大学） 乍看上去： import torch from lasso . linear import dict_learning , sparse_encode #...
PyTorch程序实现L1和L2正则项
qq_44949041的博客
07-05 4159
正则化是机器学习中的一个重要概念，它可以帮助我们防止模型过拟合。在这篇文章中，我将详细介绍两种常见的正则化技术：L1和L2正则项。然后会基于PyTorch平台讲解如何向自己的网络模型中添加上述两种技术，将正则化真正为己所用！！！
Pytorch L1,L2正则化
Victor_Li_的博客
10-30 711
偏置的作用：偏置（bias）是模型中的一个常数项，它的作用是调整模型预测值与实际值之间的偏差。权值在模型中起到了控制特征的重要作用，对权值进行正则化可以有效地减少模型的复杂度，提高泛化能力。数据中的偏移：在实际的数据中，通常会存在一些偏移（bias），即使我们对权值不进行正则化，模型也可以通过调整偏置来适应这种偏移。因此，对偏置进行正则化可能会导致对数据中的偏移进行过度拟合，而忽略了模型对其他特征的学习能力。L1正则化和L2正则化是常用的正则化技术，用于在机器学习模型中控制过拟合。
PyTorch入门精简资料（五）PyTorch实现L1，L2正则化以及Dropout
Courageux_J的博客
08-16 751
Datawhale_Task5PyTorch实现L1，L2正则化以及Dropout 了解知道Dropout原理 用代码实现正则化(L1、L2、Dropout） Dropout的numpy实现 PyTorch中实现dropout 参考资料：PyTorch 中文文档 1.Dropout原理 （1）Dropout 实际是在前向传播的时候，让某个神经元的激活值以一定...
pytorch实现L2和L1正则化regularization的方法
Elvirangel的博客
09-03 724
pytorch实现L2和L1正则化regularization的方法 https://github.com/PanJinquan/pytorch-learning-notes 深度学习中，使用REGULARIZATION正则化(WEIGHT_DECAY)的好处，LOSS=NAN
在PyTorch中使用标签平滑正则化的问题
09-17
主要介绍了如何在PyTorch中使用标签平滑正则化的问题，本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
用于注视估计和跟踪的L2CS-Net的官方PyTorch实现
01-19
用于注视估计和跟踪的L2CS-Net的官方PyTorch实现,，代码和预训练模型 https://github.com/Ahmednull/L2CS-Net/tree/main?tab=readme-ov-fi
使用pytorch实现可视化中间层的结果
09-18
今天小编就为大家分享一篇使用pytorch实现可视化中间层的结果，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
从 0 手撸一个 pytorch
易迟的专栏
05-19 800
最近抽空看了下 Andrej Karpathy 的视频教程，教程的质量很高。教程不需要任何前置机器学习基础，只需要有高中水平的数学基础即可。整个教程从 0 到 1 手撸了一个类 pytorch 的机器学习库micrograd，核心代码不到 100 行。虽然为了简化没有实现复杂的矩阵运算，但是对于理解 pytorch 的设计思想有很大帮助。通过上面的流程可以很容易理解机器学习模型训练框架的设计方案，这一套流程也完全适用于 pytorch，可以帮助更好地理解 pytorch 的训练流程。
【Pytorch】13.搭建完整的CIFAR10模型
Elephant_King的博客
05-18 1056
我们可以在网上搜到CIFAR10的网络模型，通过网络模型来搭建网络，具体可以看【Pytorch】10.CIFAR10模型搭建return x这里我们新创建了一个model.py用于专门存储网络结构，这样在我们的训练文件中，可以通过# 3.创建神经网络来导入我们自定义的神经网络。
【图神经网络——GATv2】
weixin_46348136的博客
05-21 667
仅记录个人学习。
解析pytorch3D中的坐标变换问题
qq_26239785的博客
05-18 656
借用pytorch3d官网对于坐标系的解释来讲，pytorch3d中使用了一个NDC坐标系，这个坐标系最终将所有3d点的坐标归一化到-1到1之间。熟悉pytorch的朋友应该知道这是为了方便梯度的反向传播。与常规的图形和视觉系统一致，我们分别定义了1、模型坐标系（可选，图中未显示）2、世界坐标系3、相机坐标系4、NDC坐标系5、屏幕坐标系其坐标轴的朝向如图所示。
每天五分钟深度学习框架PyTorch：创建具有特殊值的tensor张量
最新发布
huanfeng_AI的博客
05-24 112
tensor张量是一个多维数组，本节课程我们将学习一些pytorch中已经封装好的方法，使用这些方法我们可以快速创建出具有特殊意义的tensor张量。
cv函数的pytorch实现
m0_65621281的博客
05-17 626
未完待续…
RANSAC算法概述
点云侠的博客
05-20 1257
RANSAC算法概述
让动物世界触手可及——好用的动物识别API合集
youqingy的博客
05-21 1322
用户只需要上传一张包含动物的图像或视频，API就能够自动识别出其中的动物种类，并给出相应的分类结果。通过API接口，用户可以上传动物的照片，API会自动识别动物的种类和特征，并提供相关的标签和描述，帮助用户在社交媒体上更好地展示和分享自己的宠物。通过API接口，犬只安全管理部门可以上传犬只的鼻纹图像，API会自动识别和匹配犬只的身份信息和安全等级，帮助监测和保护公共区域和设施的安全。通过API接口，用户可以上传犬只的鼻纹图像，API会自动识别和记录犬只的身份信息和来源，帮助监控和管理犬只的流通和交易过程。
四非、双非计算机保研夏令营入营情况
小蒋的博客
05-19 947
厦大 信息学院，电影学院，CS，人工智能浙软（海营，预推免入场券）、工程师华东科技大学网安中国科学技术大学 先进技术研究院，空间应用工程与技术中心，信工所，软件所，计算与网络中心，计算技术研究所北京师范大学 认知神经科学与学习国家重点实验室山东大学 网络空间与安全学院，SE天津大学 智能与计算机学部华中师范大学 计算机学院、大数据北航计算机南开计算机，SE吉大计算机、SE、人工智能湖南信息山大计院（不发offer），网安成电计算机，网安。
PX4使用yolo仿真环境搭建
超维空间科技的博客
05-21 167
PX4 1.13.3已配置好PX4 ROS gazebo环境。
pytorch实现l1和l2正则化
09-01
要使用PyTorch实现L1和L2正则化，可以通过在损失函数中添加相应的正则化项来实现。下面是一个简单的示例： ```python import torch import torch.nn as nn import torch.optim as optim # 定义模型 class MyModel(nn.Module): def __init__(self): super(MyModel, self).__init__() self.linear = nn.Linear(10, 1) def forward(self, x): return self.linear(x) model = MyModel() # 定义损失函数和优化器 criterion = nn.MSELoss() optimizer = optim.SGD(model.parameters(), lr=0.01) # 定义正则化权重 l1_lambda = 0.01 l2_lambda = 0.01 # 训练循环 for epoch in range(num_epochs): for inputs, targets in data_loader: optimizer.zero_grad() outputs = model(inputs) loss = criterion(outputs, targets) # 添加L1正则化 l1_reg = torch.tensor(0.) for param in model.parameters(): l1_reg += torch.norm(param, 1) loss += l1_lambda * l1_reg # 添加L2正则化 l2_reg = torch.tensor(0.) for param in model.parameters(): l2_reg += torch.norm(param, 2) loss += l2_lambda * l2_reg loss.backward() optimizer.step() ``` 在上述代码中，我们定义了一个`MyModel`类来表示我们的模型。然后，我们使用`nn.MSELoss()`作为损失函数，并使用`optim.SGD`作为优化器。在训练循环中，我们通过遍历模型的参数并计算其L1和L2范数来计算正则化项。然后将正则化项加到损失函数中，通过调整`l1_lambda`和`l2_lambda`参数来控制正则化的强度。最后，我们进行反向传播和参数更新以完成训练。 请注意，这只是一个简单的示例，实际应用中可能还会有其他细节需要考虑，如权重衰减（weight decay）等。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值