深度学习------权重衰退

news2024/11/14 14:24:06

目录

  • 使用均方范数作为硬性限制
  • 使用均方范数作为柔性限制
  • 演示最优解的影响
  • 参数更新法则
  • 总结
  • 高纬线性回归
  • 多项式的权重衰退从零开始实现
    • 初始化模型参数
    • 定义L2范数惩罚
    • 定义训练代码实现
    • 忽略正则化直接训练
    • 使用权重衰减
    • 从零开始代码实现
  • 多项式的权重衰退的简洁实现
    • 简洁函数代码
    • 简洁代码实现
  • 问题

在这里插入图片描述


使用均方范数作为硬性限制

  使用限制参数值的选择范围来控制模型容量
在这里插入图片描述
  通常不限制偏移b(限不限制都差不多)
  小的θ意味着更强的正则项

在这里插入图片描述



使用均方范数作为柔性限制

对每个θ,都可以找到λ使得之前的目标函数等价于下面。

在这里插入图片描述
可以通过拉格朗日乘子来证明
超参数λ控制了正则项的重要程度
    λ=0:无作用
    λ→∞, w ∗ w^* w→0



演示最优解的影响

在这里插入图片描述
①绿色的线就是原始损失函数l的等高线,优化原始损失l的最优解(波浪号即最优解)在中心位置。
在这里插入图片描述

②当原始损失加入二分之λ的项后,这个项是一个二次项,假如w就两个值,x1(横轴)、x2(纵轴),那么在图上这个二次项的损失以原点为中心的等高线为橙色的图所示。所以合并后的损失为绿色的和黄色的线加一起的损失。

在这里插入图片描述

③当加上损失项后,可以知道原来最优解对应的二次项的损失特别大,因此原来的最优解不是加上二次项后的公式的最优解了。若沿着橙色的方向走,原有l损失值会大一些,但是二次项罚(penalty→惩罚)的损失会变小,当拉到平衡点以内时,惩罚项减少的值不足以原有l损失增大的值,这样w * 就是加惩罚项后的最优解。

④ 损失函数加上正则项成为目标函数,目标函数最优解不是损失函数最优解。正则项就是防止达到损失函数最优导致过拟合,把损失函数最优点往外拉一拉。鼓励权重分散,将所有额特征运用起来,而不是依赖其中的少数特征,并且权重分散的话它的内积就小一些。

⑤ l2正则项会对大数值的权值进行惩罚。




参数更新法则

计算梯度:

在这里插入图片描述
时间t更新参数:
让损失函数减低就往梯度的反方向走,所以需要减去梯度。

在这里插入图片描述

所以

在这里插入图片描述
通常ηλ<1在深度学习中通常叫做权重衰退
w t + 1 w_{t+1} wt+1= w t w_t wt-η梯度看成向量-η梯度表示的是沿着梯度这个向量反方向变化。



总结

权重衰退通过L2正则项使得模型参数不会过大,从而控制模型复杂度。
正则项权重是控制模型复杂度的超参数。




高纬线性回归

演示一下权重衰减,为了使过拟合的效果更加明显,我们可以将问题的维数增加到 𝑑=200 , 并使用一个只包含20个样本的小训练集。

在这里插入图片描述

import torch
from torch import nn
from d2l import torch as d2l
n_train, n_test, num_inputs, batch_size = 20, 100, 200, 5
true_w, true_b = torch.ones((num_inputs, 1)) * 0.01, 0.05
# 生成合成数据,每个样本生成一个随机的输入特征向量x以及对应的标签y
train_data = d2l.synthetic_data(true_w, true_b, n_train)
train_iter = d2l.load_array(train_data, batch_size)
# 生成数据迭代器,将train_data划分为大小为batch_size的多个批次
# 每次迭代时产生一个批次的样本,直到所有的样本都被遍历完为止
test_data = d2l.synthetic_data(true_w, true_b, n_test)
test_iter = d2l.load_array(test_data, batch_size, is_train=False)



多项式的权重衰退从零开始实现

初始化模型参数

def init_params():
    w = torch.normal(0, 1, size=(num_inputs, 1), requires_grad=True)
    b = torch.zeros(1, requires_grad=True)
    return [w, b]

定义L2范数惩罚

实现这一惩罚最方便的方法是对所有项求平方后并将它们求和。

def l2_penalty(w):
    return torch.sum(w.pow(2)) / 2

定义训练代码实现

下面的代码将模型拟合训练数据集并在测试数据集上进行评估。线性网络和平方损失没有变化, 所以我们通过d2l.linregd2l.squared_loss导入它们。 唯一的变化是损失现在包括了惩罚项

def train(lambd):
    w, b = init_params()
    # 用lambda匿名函数定义net,输入为X,输出为d2l.linreg(X, w, b)
    net, loss = lambda X: d2l.linreg(X, w, b), d2l.squared_loss

    num_epochs, lr = 100, 0.003
    animator = d2l.Animator(xlabel='epochs', ylabel='loss', yscale='log',
                            xlim=[5, num_epochs], legend=['train', 'test'])
    for epoch in range(num_epochs):
        for X, y in train_iter:
        	# lambd是L2正则化项系数,是为了调整正则化的强度
            # 增加了L2范数惩罚项,
            # 广播机制使l2_penalty(w)成为一个长度为batch_size的向量
            l = loss(net(X), y) + lambd * l2_penalty(w)
            l.sum().backward() # 对参数进行反向传播,以计算权重和偏置的梯度。
            d2l.sgd([w, b], lr, batch_size) # 使用SGD更新权重和偏置
        if (epoch + 1) % 5 == 0:
        	# 每5轮将训练集和测试集上的损失添加到animator中
            animator.add(epoch + 1, (d2l.evaluate_loss(net, train_iter, loss),
                                     d2l.evaluate_loss(net, test_iter, loss)))
    # .item() 方法用于将包含单个元素的张量转换为 Python 标量(普通的整数或浮点数)
    print('w的L2范数是:', torch.norm(w).item())


忽略正则化直接训练

使用lambd = 0禁用权重衰减后运行这个代码。 注意,这里训练误差有了减少,但测试误差没有减少, 这意味着出现了严重的过拟合

train(lambd=0)

输出:

在这里插入图片描述
在这里插入图片描述

使用权重衰减

使用权重衰减来运行代码。 注意,在这里训练误差增大,但测试误差减小。 这正是我们期望从正则化中得到的效果。

train(lambd=3)

输出:

在这里插入图片描述
在这里插入图片描述
之间还是有一定的过拟合,大约在50轮后,就开始缓和了。

从零开始代码实现

import torch
from d2l import torch as d2l


def init_params():
    w = torch.normal(0, 1, size=(num_inputs, 1), requires_grad=True)
    b = torch.zeros(1, requires_grad=True)
    return [w, b]


def l2_penalty(w):
    return torch.sum(w.pow(2)) / 2


def train(lambd):
    w, b = init_params()
    # 用lambda匿名函数定义net,输入为X,输出为d2l.linreg(X, w, b)
    net, loss = lambda X: d2l.linreg(X, w, b), d2l.squared_loss

    num_epochs, lr = 100, 0.003
    animator = d2l.Animator(xlabel='epochs', ylabel='loss', yscale='log',
                            xlim=[5, num_epochs], legend=['train', 'test'])
    for epoch in range(num_epochs):
        for X, y in train_iter:
            # lambd是L2正则化项系数,是为了调整正则化的强度
            # 增加了L2范数惩罚项,
            # 广播机制使l2_penalty(w)成为一个长度为batch_size的向量
            l = loss(net(X), y) + lambd * l2_penalty(w)
            l.sum().backward()  # 对参数进行反向传播,以计算权重和偏置的梯度。
            d2l.sgd([w, b], lr, batch_size)  # 使用SGD更新权重和偏置
        if (epoch + 1) % 5 == 0:
            # 每5轮将训练集和测试集上的损失添加到animator中
            animator.add(epoch + 1, (d2l.evaluate_loss(net, train_iter, loss),
                                     d2l.evaluate_loss(net, test_iter, loss)))
    # .item() 方法用于将包含单个元素的张量转换为 Python 标量(普通的整数或浮点数)
    print('w的L2范数是:', torch.norm(w).item())


n_train, n_test, num_inputs, batch_size = 20, 100, 200, 5
true_w, true_b = torch.ones((num_inputs, 1)) * 0.01, 0.05
# 生成合成数据,每个样本生成一个随机的输入特征向量x以及对应的标签y
train_data = d2l.synthetic_data(true_w, true_b, n_train)
train_iter = d2l.load_array(train_data, batch_size)
# 生成数据迭代器,将train_data划分为大小为batch_size的多个批次
# 每次迭代时产生一个批次的样本,直到所有的样本都被遍历完为止
test_data = d2l.synthetic_data(true_w, true_b, n_test)
test_iter = d2l.load_array(test_data, batch_size, is_train=False)
train(lambd=3)
d2l.plt.show()




多项式的权重衰退的简洁实现

    由于权重衰减在神经网络优化中很常用, 深度学习框架为了便于我们使用权重衰减, 将权重衰减集成到优化算法中,以便与任何损失函数结合使用。 此外,这种集成还有计算上的好处, 允许在不增加任何额外的计算开销的情况下向算法中添加权重衰减。 由于更新的权重衰减部分仅依赖于每个参数的当前值, 因此优化器必须至少接触每个参数一次
    在下面的代码中,我们在实例化优化器时直接通过weight_decay指定weight decay超参数
默认情况下,PyTorch同时衰减权重和偏移。 这里我们只为权重设置了weight_decay,所以偏置参数b不会衰减。

def train_concise(wd):
    net = nn.Sequential(nn.Linear(num_inputs, 1))
    for param in net.parameters():
    #将原来的数据替换为从标准正态分布中抽取的随机样本返回一个与输入大小相同的张量。
        param.data.normal_()
    loss = nn.MSELoss(reduction='none')
    num_epochs, lr = 100, 0.003
    # 偏置参数没有衰减
    trainer = torch.optim.SGD([
    	# net[0].weight是权重衰退的强度,wd是正则化项的系数
        {"params":net[0].weight,'weight_decay': wd},
        {"params":net[0].bias}], lr=lr)
    animator = d2l.Animator(xlabel='epochs', ylabel='loss', yscale='log',
                            xlim=[5, num_epochs], legend=['train', 'test'])
    for epoch in range(num_epochs):
        for X, y in train_iter:
            trainer.zero_grad()
            #通过net(X)前向传播,然后进行损失计算
            l = loss(net(X), y)
            # 反向传播,计算平均损失的梯度
            l.mean().backward()
            trainer.step()
        if (epoch + 1) % 5 == 0:
            animator.add(epoch + 1,
                         (d2l.evaluate_loss(net, train_iter, loss),
                          d2l.evaluate_loss(net, test_iter, loss)))
    print('w的L2范数:', net[0].weight.norm().item())



简洁函数代码

def train_concise(wd):
    net = nn.Sequential(nn.Linear(num_inputs, 1))
    for param in net.parameters():
    #将原来的数据替换为从标准正态分布中抽取的随机样本返回一个与输入大小相同的张量。
        param.data.normal_()
    loss = nn.MSELoss(reduction='none')
    num_epochs, lr = 100, 0.003
    # 偏置参数没有衰减
    trainer = torch.optim.SGD([
    	# net[0].weight是权重衰退的强度,wd是正则化项的系数
        {"params":net[0].weight,'weight_decay': wd},
        {"params":net[0].bias}], lr=lr)
    animator = d2l.Animator(xlabel='epochs', ylabel='loss', yscale='log',
                            xlim=[5, num_epochs], legend=['train', 'test'])
    for epoch in range(num_epochs):
        for X, y in train_iter:
            trainer.zero_grad()
            #通过net(X)前向传播,然后进行损失计算
            l = loss(net(X), y)
            # 反向传播,计算平均损失的梯度
            l.mean().backward()
            trainer.step()
        if (epoch + 1) % 5 == 0:
            animator.add(epoch + 1,
                         (d2l.evaluate_loss(net, train_iter, loss),
                          d2l.evaluate_loss(net, test_iter, loss)))
    print('w的L2范数:', net[0].weight.norm().item())
train_concise(0)

输出:

在这里插入图片描述
在这里插入图片描述

train_concise(3)

输出:
在这里插入图片描述
在这里插入图片描述

这些图看起来和我们从零开始实现权重衰减时的图相同。 然而,它们运行得更快更容易实现。 对于更复杂的问题,这一好处将变得更加明显。
当wd(即:λ)为0时

在这里插入图片描述

在这里插入图片描述



当wd(即:λ)为3时
在这里插入图片描述
在这里插入图片描述

简洁代码实现

import torch
from torch import nn
from d2l import torch as d2l


def train_concise(wd):
    net = nn.Sequential(nn.Linear(num_inputs, 1))
    for param in net.parameters():
        # 将原来的数据替换为从标准正态分布中抽取的随机样本返回一个与输入大小相同的张量。
        param.data.normal_()
    loss = nn.MSELoss(reduction='none')
    num_epochs, lr = 100, 0.003
    # 偏置参数没有衰减
    trainer = torch.optim.SGD([
        # net[0].weight是权重衰退的强度,wd是正则化项的系数
        {"params": net[0].weight, 'weight_decay': wd},
        {"params": net[0].bias}], lr=lr)
    animator = d2l.Animator(xlabel='epochs', ylabel='loss', yscale='log',
                            xlim=[5, num_epochs], legend=['train', 'test'])
    for epoch in range(num_epochs):
        for X, y in train_iter:
            trainer.zero_grad()
            # 通过net(X)前向传播,然后进行损失计算
            l = loss(net(X), y)
            # 反向传播,计算平均损失的梯度
            l.mean().backward()
            trainer.step()
        if (epoch + 1) % 5 == 0:
            animator.add(epoch + 1,
                         (d2l.evaluate_loss(net, train_iter, loss),
                          d2l.evaluate_loss(net, test_iter, loss)))
    print('w的L2范数:', net[0].weight.norm().item())


n_train, n_test, num_inputs, batch_size = 20, 100, 200, 5
true_w, true_b = torch.ones((num_inputs, 1)) * 0.01, 0.05
# 生成合成数据,每个样本生成一个随机的输入特征向量x以及对应的标签y
train_data = d2l.synthetic_data(true_w, true_b, n_train)
train_iter = d2l.load_array(train_data, batch_size)
# 生成数据迭代器,将train_data划分为大小为batch_size的多个批次
# 每次迭代时产生一个批次的样本,直到所有的样本都被遍历完为止
test_data = d2l.synthetic_data(true_w, true_b, n_test)
test_iter = d2l.load_array(test_data, batch_size, is_train=False)
train_concise(3)
d2l.plt.show()




问题

①为什么参数不大,复杂度就低呢?
其实不是参数不大,复杂度就低,是说限制整个模型在优化的时候只在一个很小的范围里面取参数。如果在很小的范围里取参数那么整个模型就会变小。

②如果是用L1范数的话如何更新权重?
其实是差不多的,但是这个L1好像更好一点
在这里插入图片描述
输出:
在这里插入图片描述
L1:

在这里插入图片描述
L2:
在这里插入图片描述

③实践中权重衰减的值一般设置多少为好呢?之前在跑代码的时候总感觉权重衰减的效果并不是那么好。
一般是取1e-3,1e-4。
其实权重衰退就是一点点效果,之后还有处理权重衰退的方法。


④⭐为什么要把w往小了拉?如果最优解的w就是比较大的数,那权重衰减是不是会有反作用?
在这里插入图片描述

假设图中的这个点为最优解,但是实际上数据是有噪音的,实际上学不到这个点。真正学到的如下图所示:
在这里插入图片描述

通过控制λ的大小来决定将往回拉多少

拉到这个地方,不够,还是太大了,λ太小。

在这里插入图片描述



λ太大可能会拉到这个地方。
在这里插入图片描述



数学的最优解就是假设的那个点(图中绿色中心),实际上求解求不到最优解,因为数据有噪音,所以用λ来处理噪音。


⑤L2 norm是让w变得更平均吗?没有突出的值为什么这种调整可以使得拟合更好呢?
不是,它不会让变得平均,而是往里拉。


⑥噪音越大,w就比较,这个是经验所得还是可以证明的?
是可以证明的。

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/1973389.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

案例分享|Alluxio在自动驾驶数据闭环中的应用

分享嘉宾&#xff1a; 孙涛 - 中汽创智智驾工具链数据平台开发专家 关于中汽创智&#xff1a; 中汽创智科技有限公司&#xff08;以下简称“中汽创智”&#xff09;由中国一汽、东风公司、南方工业集团、长安汽车和南京江宁经开科技共同出资设立。聚焦智能底盘、新能动力、智…

学习硬件测试04:触摸按键+PWM 驱动蜂鸣器+数码管(P62~P67、P71、P72)

一、触摸按键 1.1理论讲解 1.1.1实验现象 触摸按键 1 单击与长按&#xff0c;控制 LED1&#xff1b;触摸按键 2 单击与长按&#xff0c;控制 LED2;触摸按键 3 单击与长按&#xff0c;控制 LED3;触摸按键 4 单击与长按&#xff0c;控制继电器; 1.1.2硬件电路 是原理图上触摸…

vue3+element-plus实现table表格整列的拖拽

参考文章&#xff1a;https://blog.csdn.net/candy0521/article/details/136470284 一、为防止原文章不见了将参考文章代码拷过来了&#xff08;不好意思&#xff09;&#xff1a;这是参考文章的代码 可直接复制粘贴运行 <template><div class"draggable-table&…

uniapp 多渠道打包实现方案

首先一个基础分包方案&#xff1a; 包不用区分渠道&#xff0c;只是通过文件名进行区分&#xff0c;公共代码逻辑可以通过mixins进行混入。 这样分包后就需要在打包时只针对编译的渠道包文件进行替换打包&#xff0c;其他渠道包的文件不打包进去&#xff0c;通过工具类实现…

商业策划案怎么写?附商场230个策划案例

商业策划案的撰写是一个系统性工程&#xff0c;旨在详细阐述项目的背景、目标、实施策略、财务预测及风险评估等内容&#xff0c;以吸引投资者或合作伙伴的关注。 以下是一个详细的撰写步骤和要点&#xff0c;码字不易&#xff0c;如果回答对你有所帮助&#xff0c;请不吝给一…

GraphRAG如何使用ollama提供的llm model 和Embedding model服务构建本地知识库

使用GraphRAG踩坑无数 在GraphRAG的使用过程中将需要踩的坑都踩了一遍&#xff08;不得不吐槽下&#xff0c;官方代码有很多遗留问题&#xff0c;他们自己也承认工作重心在算法的优化而不是各种模型和框架的兼容性适配性上&#xff09;&#xff0c;经过了大量的查阅各种资料以…

【目标和】python刷题记录

R3-dp篇. 目录 思路&#xff1a; 增加记忆化搜索&#xff1a; 优化空间复杂度&#xff1a; 思路&#xff1a; class Solution:def findTargetSumWays(self, nums: List[int], target: int) -> int:#设正数之和为p,总元素之和为s&#xff0c;带符号总元素之和为t&…

AWS开发人工智能:如何基于云进行开发人工智能AI

随着人工智能技术的飞速发展&#xff0c;企业对高效、易用的AI服务需求日益增长。Amazon Bedrock是AWS推出的一项创新服务&#xff0c;旨在为企业提供一个简单、安全的平台&#xff0c;以访问和集成先进的基础模型。本文中九河云将详细介绍Amazon Bedrock的功能特点以及其收费方…

安卓常用控件(上)

文章目录 TextViewButtonEditText TextView textview主要用于在界面上显示一段文本信息。 属性名描述id给当前控件定义一个唯一的标识符。layout_width给控件指定一个宽度。match_parent&#xff1a;控件大小与父布局一样&#xff1b;wrap_content&#xff1a;控件大小刚好够包…

WinUI vs WPF vs WinForms: 三大Windows UI框架对比

1.前言 在Windows平台上开发桌面应用程序时&#xff0c;WinUI、WPF和WinForms是三种主要的用户界面框架。每种框架都有其独特的特点和适用场景。本文将通过示例代码&#xff0c;详细介绍这些框架的优缺点及其适用场景&#xff0c;帮助dotnet桌面开发者更好地选择适合自己项目的…

【Spring】SSM框架整合Spring和SpringMVC

目录 1.项目结构 2.项目的pom.xml文件 3.spring.xml和springMVC配置文件 4.database.properties和mybatis.xml配置文件 5. 代码编写 6.测试整合结果 1.项目结构 首先创建一个名为ssm_pro的Mavew项目&#xff0c;然后再在主目录和资源目录下&#xff0c;创建如下所示的结…

5.2-软件工程基础知识-软件过程模型

软件过程模型 瀑布模型瀑布模型变种-V模型演化模型-原型模型增量模型演化模型-螺旋模型喷泉模型基于构件的开发模型形式化方法模型统一过程模型敏捷方法极限编程其他方法 软件过程模型概述练习题 瀑布模型 瀑布模型(SDLC):瀑布模型是一个经典的生命周期模型&#xff0c;一般将软…

SpringBoot中如何正确使用Redis(详细介绍,原理讲解,企业版)

1.引入Redis依赖 <dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId></dependency> 2.配置Redis的连接信息(application.yml) 实际开发中有两个一个是开发环境applicati…

VBA字典与数组第十七讲:工作表数组大小的扩展及意义

《VBA数组与字典方案》教程&#xff08;10144533&#xff09;是我推出的第三套教程&#xff0c;目前已经是第二版修订了。这套教程定位于中级&#xff0c;字典是VBA的精华&#xff0c;我要求学员必学。7.1.3.9教程和手册掌握后&#xff0c;可以解决大多数工作中遇到的实际问题。…

JAVA(IO流)7.31

ok了家人们今天还是学习IO流&#xff0c; 一.打印流【了解】 1.1 打印流的概述 我们平时使用的System语句就是调用了print()方法和println()方法。 这两个方法都来自于 java.io.PrintStream 类。 作用&#xff1a; 该类能够方便地打印各种数据类型的值&#xff0c;写入数据后…

谷粒商城实战笔记-115-全文检索-ElasticSearch-进阶-bool复合查询

文章目录 1&#xff0c;must2&#xff0c;must not3&#xff0c;should 1&#xff0c;must {"query": {"bool": {"must": [{"match": {"gender": "M"}},{"match": {"address": "mill&q…

java代码审计-SQL的注入

0x01 前言 Java里面常见的数据库连接方式有三种&#xff0c;分别是JDBC&#xff0c;Mybatis&#xff0c;和Hibernate。 0x02 JDBC注入场景 很早之前的Javaweb都是用JDBC的方式连接数据库然后去实现dao接口再调service业务层去实现功能代码JDBC连接代码 WebServlet("/d…

科技云报道:大模型引领技术浪潮,AI安全治理面临“大考”

科技云报道原创。 从文生文到文生图&#xff0c;再到文生视频&#xff0c;近年来&#xff0c;以ChatGPT、Sora等为代表的大模型引领了全球人工智能技术与产业的新一轮浪潮。2024年更是被业内称为大模型应用爆发元年。 年初&#xff0c;Sora横空出世验证了Scalling Law在视频生…

计算机的错误计算(五十)

摘要 扩展了计算机的错误计算&#xff08;四十九&#xff09;中的代码。同时发现&#xff0c;误差也“扩展”了。 下面是代码&#xff1a; import torch# 设置随机种子 torch.manual_seed(0)# 创建张量并移动到GPU W1 torch.randn(5, 3) * 10 W1 W1.to(cuda) X1 torch.ran…