机器学习&&深度学习——权重衰减

最新推荐文章于 2024-09-06 23:56:13 发布

布布要成为最负责的男人

最新推荐文章于 2024-09-06 23:56:13 发布

阅读量1.5k

点赞数 3

分类专栏：机器学习&&深度学习文章标签：机器学习深度学习人工智能

本文链接：https://blog.csdn.net/m0_52380556/article/details/131989732

版权

机器学习&&深度学习专栏收录该内容

49 篇文章 8 订阅

订阅专栏

👨‍🎓作者简介：一位即将上大四，正专攻机器学习的保研er
🌌上期文章：机器学习&&深度学习——模型选择、欠拟合和过拟合
📚订阅专栏：机器学习&&深度学习
希望文章对你们有所帮助

讨论（思维过一下，后面会总结）

前一节已经描述了过拟合的问题，本节将会介绍一些正则化模型的技术。
之前用了多项式回归的例子，我们可以通过调整拟合多项式的阶数来限制模型容量。而限制特征数量是缓解过拟合的一种常用技术。然而，我们还需要考虑高维输入可能发生的情况。多项式对多变量的自然扩展称为单项式，也可以说是变量幂的成绩。单项式的阶数是幂的和。例如，x1²x2和x3x5²都是3次单项式。
随着阶数d的增长，带有阶数d的项数迅速增加。给定k个变量，阶数为d的项的个数为：
$C_{k-1+d}^{k-1}=\frac{(k-1+d)!}{(d)!(k-1)!}$
因此即使是阶数上的微小变化,也会显著增加我们模型的复杂性。仅仅通过简单的限制特征数量，可能仍然使模型在过简单和过复杂中徘徊。我们需要一个更细粒度的工具来调整函数的复杂性，使其达到一个合适的平衡位置。
在之前已经描述了L2范数和L1范数。
在训练参数化机器学习模型时，权重衰减是最广泛使用的正则化的技术之一，它通常被称为L2正则化。这项技术通过函数与0的距离来衡量函数的复杂度，因为所有的函数f中，f=0在某种意义上是最简单的。但是衡量函数f与0的距离并不简单，这也没有一个正确的答案。
一种简单的方法是通过线性函数f(x)=w^Tx中的某个向量的范数来度量其复杂性，例如||w||²。要保证权重向量比较小，最常用方法是将其范数作为惩罚项加到最小化损失的问题中。将原来的训练目标最小化训练标签上的预测损失，调整为最小化预测损失和惩罚项之和。如果我们的权重向量增长的太大，我们的学习算法可能更集中于最小化权重范数||w||²。回归线性回归，我们的损失由下式给出：
$L(w,b)=\frac{1}{n}\sum_{i=1}^n\frac{1}{2}(w^Tx^{(i)}+b-y^{(i)})^2$
其中，x⁽ⁱ⁾是样本i的特征，y⁽ⁱ⁾是样本i的标签，(w,b)是权重和偏置参数。
为了乘法权重向量的大小，我们现在在损失函数添加||w||²，模型如何平衡这个新的额外乘法的损失？我们通过正则化常数λ来描述这种权衡（这是一个非负超参数，我们使用验证数据拟合）：
$L(w,b)+\frac{\lambda}{2}||w||^2$
对于λ=0，我们恢复了原来的损失函数。对于λ＞0，我们限制||w||的大小。这里我们仍然除以2（当我们取一个二次函数的导数时， 2和1/2会抵消）。
对于范数的选择，可以提出两个问题：
1、为什么不选择欧几里得距离？
2、为什么不用L1范数？
对于第1个问题：这样做就是为了通过平方去掉L2范数的平方根，留下权重向量每个分量的平方和，这样就很好进行求导了（此时导数的和就等于和的导数）
对于第2个问题：L2范数比起L1范数，对权重向量的大分量施加了巨大的惩罚，在这里还是L2更适合。
那么L2正则化回归的小批量随机梯度下降更新如下式：
$w←(1-ηλ)w-\frac{η}{|B|}\sum_{i∈B}x^{(i)}(w^Tx^{(i)}+b-y^{(i)})$
为啥是这个结果可以看后面的推导，这个结论说明：我们根据估计值和观测值之间的差距来更新w，同时也在试图缩小w的大小，这就叫权重衰减（或权重衰退）。
权重衰减为我们提供了一种连续的机制来调整函数复杂度，较小的λ值对应较少约束的w，较大的λ值对w的约束会更大。

权重衰减

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

1、通过限制参数值的选择范围来控制模型容量：
$min l(w,b)其中||w||^2≤θ$
2、通常不限制偏移b（其实限制不限制都差不多）
3、更小的θ意味着更强的正则项

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

1、对每个θ，都可以找到λ使得之前的目标函数等价于
$l(w,b)+\frac{\lambda}{2}||w||^2$
2、上式通过拉格朗日乘子就能证明
3、超参数λ控制了正则项的重要程度
$\lambda=0：无作用\\ \lambda→∞：w^*→0$

对最优解的影响

一张图片就能看出来：
在这里插入图片描述

参数更新法则

计算梯度：
$\frac{\partial}{\partial w}(l(w,b)+\frac{\lambda}{2}||w||^2)=\frac{\partial l(w,b)}{\partial w}+\lambda w$
时间t更新参数：
$w_{t+1}=w_t-η\frac{\partial}{\partial w}\\把\frac{\partial}{\partial w}用上式带入，得：\\w_{t+1}=(1-η\lambda)w_t-η\frac{\partial l(w_t,b_t)}{\partial w_t}$
通常ηλ＜1，在深度学习中叫作权重衰退。
（可以和之前的梯度做比较，会发现也就是在w之前加了个(1-ηλ)的系数，这样就可以做到权重衰退）

总结

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

高维线性回归

我们通过简单例子来演示权重衰减

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

生成一些人工数据集，生成公式如下：
$y=0.05+\sum_{i=1}^d0.01x_i+\sigma\\ 其中\sigma符合正态分布N(0,0.01^2)$
为了把过拟合体现的更明显，我们的训练集就只有20个（数据越简单越容易过拟合）

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
train_data = d2l.synthetic_data(true_w, true_b, n_train)
train_iter = d2l.load_array(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)

从零开始实现

下面从头开始实现权重衰减，只需将L2的平方惩罚添加到原始目标函数值。

初始化模型参数

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范数乘法

我们这边是在原来的L2基础上加上了平方，从而去除了他的根号。

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

定义训练代码实现

下面将模型与训练数据集进行拟合，并在测试数据集上进行评估。其中线性网络与平方损失是没有变化的，唯一的变化只是现在增加了惩罚项。

def train(lambd):
    w, b = init_params()
    # lambda X相当于定义了一个net()函数，不好理解少用
    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:
            # 增加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)
        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范数是：', torch.norm(w).item())

忽略正则化直接训练

此时，我们使用lambd=0来禁止权重衰减，运行代码以后，训练误差会减少，但是测试误差却没有减少，说明出现了严重的过拟合。

train(lambd=0)
d2l.plt.show()

运行结果：

w的L2范数是： 13.375638008117676

运行图片：
在这里插入图片描述

使用权重衰减

这里的训练误差增大，但测试误差减小，这正是期望从正则化中得到的效果。

train(lambd=3)
d2l.plt.show()

运行结果：

w的L2范数是： 0.35898885130882263

运行图片：
在这里插入图片描述

简洁实现

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

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
train_data = d2l.synthetic_data(true_w, true_b, n_train)
train_iter = d2l.load_array(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 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([
        {"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()
            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())