《李沐：动手学深度学习v2 pytorch版》第4章：4.5 权重衰减 - 4.6 暂退法

最新推荐文章于 2024-05-06 21:35:54 发布

视觉猫_VisionCat

最新推荐文章于 2024-05-06 21:35:54 发布

阅读量804

点赞数 7

分类专栏：动手学深度学习文章标签：深度学习 pytorch 人工智能

本文链接：https://blog.csdn.net/weixin_44219441/article/details/137795313

版权

动手学深度学习专栏收录该内容

6 篇文章 2 订阅

订阅专栏

4.5 权重衰减

我们总是可以通过去收集更多的训练数据来缓解过拟合。但这可能成本很高，耗时颇多，或者完全超出我们的控制，因而在短期内不可能做到。假设我们已经拥有尽可能多的高质量数据，我们便可以将重点放在正则化技术上。

在训练参数化机器学习模型时，权重衰减（weight decay）是最广泛使用的正则化的技术之一，它通常也被称为L2正则化。这项技术通过函数与零的距离来衡量函数的复杂度，因为在所有函数f中，函数f=0（所有输入都得到值0）在某种意义上是最简单的。
在这里插入图片描述
为什么首先使用L2范数而不是L1范数呢？

事实上，这个选择在整个统计领域中都是有效的和受欢迎的。 L2正则化线性模型构成经典的岭回归（ridge regression）算法， L1正则化线性回归是统计学中类似的基本模型，通常被称为套索回归（lasso regression）。

使用L2范数的一个原因是它对权重向量的大分量施加了巨大的惩罚。这使得我们的学习算法偏向于在大量特征上均匀分布权重的模型。

在实践中，这可能使它们对单个变量中的观测误差更为稳定。相比之下，L1惩罚会导致模型将权重集中在一小部分特征上，而将其他权重清除为零。 这称为特征选择（feature selection），这可能是其他场景下需要的。

L2正则化回归的小批量随机梯度下降更新如下式：
在这里插入图片描述
根据之前章节所讲的，我们根据估计值与观测值之间的差异来更新W。然而，我们同时也在试图将W的大小缩小到零。这就是为什么这种方法有时被称为权重衰减。我们仅考虑惩罚项，优化算法在训练的每一步衰减权重。与特征选择相比，权重衰减为我们提供了一种连续的机制来调整函数的复杂度。较小的lamda值对应较少约束的W，而较大的lamda值对W的约束更大。

4.5.1 高维线性回归

我们通过一个简单的例子来演示权重衰减。

%matplotlib inline
import torch
from torch import nn
from d2l import torch as d2l

首先，我们像以前一样生成一些数据，生成公式如下：
在这里插入图片描述
我们选择标签是关于输入的线性函数。标签同时被均值为0，标准差为0.01高斯噪声破坏。为了使过拟合的效果更加明显，我们可以将问题的维数增加到d=200，并使用一个只包含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)

4.5.2 从零开始实现

下面我们将从头开始实现权重衰减，只需将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范数惩罚

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

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

定义训练代码实现

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

def train(lambd):
    w, b = init_params()
    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)

在这里插入图片描述

使用权重衰减

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

train(lambd=3)

在这里插入图片描述

4.5.3 简洁实现

由于权重衰减在神经网络优化中很常用，深度学习框架为了便于我们使用权重衰减，将权重衰减集成到优化算法中，以便与任何损失函数结合使用。此外，这种集成还有计算上的好处，允许在不增加任何额外的计算开销的情况下向算法中添加权重衰减。由于更新的权重衰减部分仅依赖于每个参数的当前值，因此优化器必须至少接触每个参数一次。

在下面的代码中，我们在实例化优化器时直接通过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([
        {"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())

本章小结

1.正则化是处理过拟合的常用方法：在训练集的损失函数中加入惩罚项，以降低学习到的模型的复杂度。

2.保持模型简单的一个特别的选择是使用L2惩罚的权重衰减。这会导致学习算法更新步骤中的权重衰减。

3.权重衰减功能在深度学习框架的优化器中提供。

4.在同一训练代码实现中，不同的参数集可以有不同的更新行为。

5.L2正则化的lambda也属于超参数。

4.6 暂退法Dropout

暂退法Dropout在前向传播过程中，计算每一内部层的同时注入噪声。

这种方法之所以被称为暂退法，因为我们从表面上看是在训练过程中丢弃（drop out）一些神经元。

在整个训练过程的每一次迭代中，标准暂退法包括在计算下一层之前将当前层中的一些节点置零，即Dropout一些神经元。

“就好像一个活有二十个人干，资本家觉得工资开的太多了，然后就尝试裁员，发现即使裁掉一小部分，效率可能不变甚至会更好”

那么关键的挑战就是如何注入这种噪声。一种想法是以一种无偏向（unbiased）的方式注入噪声。这样在固定住其他层时，每一层的期望值等于没有噪音时的值。

在标准暂退法正则化中，通过按保留（未丢弃）的节点的分数进行规范化来消除每一层的偏差。换言之，每个中间活性值
以暂退概率h由随机变量h’替换，如下所示：
在这里插入图片描述

实践中的Dropout

当我们将暂退法应用到隐藏层，以p的概率将一个或多个隐藏单元置为零时，结果可以看作一个只包含原始神经元子集的网络。（事实上这也是dropout被Hinton发明时的初始版本：神经元并没有被真正的删除掉，只是按照p概率选择一部分神经元进行梯度计算）。
比如在下图中，删除了h2和h5，因此输出的计算不再依赖于h2或后h5，并且它们各自的梯度在执行反向传播时也会消失。这样，输出层的计算不能过度依赖于h1…,h5的任何一个元素。
在这里插入图片描述
通常，我们在测试时不用暂退法。给定一个训练好的模型和一个新的样本，我们不会丢弃任何节点，因此不需要标准化。

然而也有一些例外：一些研究人员在测试时使用暂退法，用于估计神经网络预测的“不确定性”：如果通过许多不同的暂退法遮盖后得到的预测结果都是一致的，那么我们可以说网络发挥更稳定。

从零开始实现

# Dropout暂退法
import torch
from torch import nn
from d2l import torch as d2l


# 定义Dropout函数
def dropout_layer(X, dropout):
    assert 0 <= dropout <= 1
    # 在本情况中，所有元素都被丢弃
    if dropout == 1:
        return torch.zeros_like(X)
    # 在本情况中，所有元素都被保留
    if dropout == 0:
        return X

    mask = (torch.randn(X.shape) > dropout).float()
    return mask * X / (1.0 - dropout)


num_inputs, num_outputs, num_hiddens1, num_hiddens2 = 784, 10, 256, 256
dropout1, dropout2 = 0.2, 0.5


class Net(nn.Module):
    def __init__(self, num_inputs, num_outputs, num_hiddens1, num_hiddens2,
                 is_training=True):
        super(Net, self).__init__()
        self.num_inputs = num_inputs
        self.training = is_training
        self.lin1 = nn.Linear(num_inputs, num_hiddens1)
        self.lin2 = nn.Linear(num_hiddens1, num_hiddens2)
        self.lin3 = nn.Linear(num_hiddens2, num_outputs)
        self.relu = nn.ReLU()

    def forward(self, X):
        H1 = self.relu(self.lin1(X.reshape((-1, self.num_inputs))))
        # 只有在训练模型时才使用dropout
        if self.training == True:
            # 在第一个全连接层之后添加一个dropout层
            H1 = dropout_layer(H1, dropout1)
        H2 = self.relu(self.lin2(H1))
        if self.training == True:
            # 在第二个全连接层之后添加一个dropout层
            H2 = dropout_layer(H2, dropout2)

        out = self.lin3(H2)  # 输出层不做Dropout
        return out


net = Net(num_inputs, num_outputs, num_hiddens1, num_hiddens2)
num_epochs, lr, batch_size = 10, 0.5, 256
loss = nn.CrossEntropyLoss(reduction='none')
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)
trainer = torch.optim.SGD(net.parameters(), lr=lr)
d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, trainer)

本章小节

1.暂退法在前向传播过程中，计算每一内部层的同时丢弃一些神经元。

2.暂退法可以避免过拟合，它通常与控制权重向量的维数和大小结合使用的。

3.暂退法将活性值h替换为具有期望值h的随机变量。

4.暂退法仅在训练期间使用。

5.Dropout的概率也属于超参数。

视觉猫_VisionCat

关注

7
点赞
踩
20

收藏

觉得还不错? 一键收藏
0
评论
《李沐：动手学深度学习v2 pytorch版》第4章：4.5 权重衰减 - 4.6 暂退法

实现这一惩罚最方便的方法是对所有项求平方后并将它们求和。下面的代码将模型拟合训练数据集，并在测试数据集上进行评估。从 3节以来，线性网络和平方损失没有变化，所以我们通过d2l.linreg和d2l.squared_loss导入它们。唯一的变化是损失现在包括了惩罚项。# 增加了L2范数惩罚项，# 广播机制使l2_penalty(w)成为一个长度为batch_size的向量print('w的L2范数是：', torch.norm(w).item())
复制链接

扫一扫