动手学PyTorch | (10) Dropout(丢弃法)

最新推荐文章于 2023-08-01 09:54:48 发布

CoreJT

最新推荐文章于 2023-08-01 09:54:48 发布

阅读量3.4k

点赞数 2

分类专栏：动手学PyTorch 文章标签：动手学PyTorch Dropout

本文链接：https://blog.csdn.net/sdu_hao/article/details/103105918

版权

动手学PyTorch 专栏收录该内容

20 篇文章 21 订阅

订阅专栏

除了前⼀节介绍的权􏰀重衰减以外，深度学习模型常常使用丢弃法(dropout)来应对过拟合问题。丢弃法有⼀些不同的变体。本节中提到的丢弃法特指倒置丢弃法(inverted dropout)。

1. 方法

回忆⼀下，(多层感知机)的图示描述了一个单隐藏层的多层感知机。其中输⼊个数为4，隐藏单元个数为5，且隐藏单元 $h_i(i=1,...,5)$ 的计算表达式为：

这里 $\phi$ 是激活函数， $x_1,...,x_4$ 是输入，隐藏单元i的权重参数为 $w_{1i},...,w_{4i}$ ,偏差参数为 $b_i$ .当对该隐藏层使⽤丢弃法时，该层的隐藏单元将有一定概率被丢弃掉。设丢弃概率为p,那么有p的概率 $h_i(i=1,...,5)$ 会被清零，有1-p的概率 $h_i(i=1,...,5)$ 会除以1-p做拉伸。丢弃概率是丢弃法的超参数。具体来说，设随机变量 $\xi _i$ 为 0和1的概率分别为p和1-p。使⽤丢弃法时我们计算新的隐藏单元 $h_i'$ :

由于 $E(\xi_i)=1-p$ （2项分布）,因此：

即丢弃法不改变其输⼊的期望值。让我们对下图中的隐藏层使⽤丢弃法，⼀种可能的结果如下所示，其中 $h_2,h_5$ 被清零。这时输出值的计算不再依赖 $h_2,h_5$ ，在反向传播时，与这两个隐藏单元相关的权􏰀重的梯度均为0.由于在训练中隐藏层神经元的丢弃是随机的，即 $h_1,...,h_5$ 都有可能被清零，输出层的计算⽆无法过度依赖 $h_1,...,h_5$ 中的任一个，从⽽在训练模型时起到正则化的作⽤用，并可以用来应对过拟合。在测试模型时，我们为了拿到更加确定性的结果，⼀般不使用丢弃法。

2. 从0开始实现

根据丢弃法的定义，我们可以很容易地实现它。下面的dropout函数将以drop_prob的概率丢弃X中的元素。

%matplotlib inline
import torch
import torch.nn as nn
import numpy as np
import sys
sys.path.append(".") 
import d2lzh_pytorch as d2l

def dropout(X, drop_prob):
    X = X.float()
    assert 0 <= drop_prob <= 1
    keep_prob = 1 - drop_prob
    # 这种情况下把全部元素都丢弃
    if keep_prob == 0:
        return torch.zeros_like(X)
    mask = (torch.rand(X.shape) < keep_prob).float()
    
    return mask * X / keep_prob

我们运行⼏个例子来测试一下dropout函数。其中丢弃概率分别为0、0.5和1.

X = torch.arange(16).view(2, 8)
dropout(X, 0)

dropout(X, 0.5)

dropout(X, 1.0)

定义模型参数

实验中，我们依然使(softmax回归的从零开始实现)中介绍的Fashion-MNIST数据集。我们将定义⼀个包含两个隐藏层的多层感知机，其中两个隐藏层的输出个数都是256。

num_inputs, num_outputs, num_hiddens1, num_hiddens2 = 784, 10, 256, 256

W1 = torch.tensor(np.random.normal(0, 0.01, size=(num_inputs, num_hiddens1)), dtype=torch.float, requires_grad=True)
b1 = torch.zeros(num_hiddens1, requires_grad=True)
W2 = torch.tensor(np.random.normal(0, 0.01, size=(num_hiddens1, num_hiddens2)), dtype=torch.float, requires_grad=True)
b2 = torch.zeros(num_hiddens2, requires_grad=True)
W3 = torch.tensor(np.random.normal(0, 0.01, size=(num_hiddens2, num_outputs)), dtype=torch.float, requires_grad=True)
b3 = torch.zeros(num_outputs, requires_grad=True)

params = [W1, b1, W2, b2, W3, b3]

定义模型

下面定义的模型将全连接层和激活函数ReLU串起来，并对每个激活函数的输出使用丢弃法。我们可以分别设置各个层的丢弃概率。通常的建议是把靠近输⼊层的丢弃概率设得⼩一点。在这个实验中，我们把第⼀个隐藏层的丢弃概率设为0.2，把第⼆二个隐藏层的丢弃概率设为0.5。我们可以通过参数is_training函数来判断运行模式为训练还是测试，并只需在训练模式下使用丢弃法。

drop_prob1, drop_prob2 = 0.2, 0.5

def net(X, is_training=True):
    X = X.view(-1, num_inputs)
    H1 = (torch.matmul(X, W1) + b1).relu()
    if is_training:  # 只在训练模型时使用丢弃法
        H1 = dropout(H1, drop_prob1)  # 在第一层全连接后添加丢弃层
    H2 = (torch.matmul(H1, W2) + b2).relu()
    if is_training:
        H2 = dropout(H2, drop_prob2)  # 在第二层全连接后添加丢弃层
    return torch.matmul(H2, W3) + b3

我们在对模型评估的时候不应该进行丢弃，所以我们修改一下d2lzh_pytorch中的evaluate_accuracy函数：

# 可以把本函数保存在d2lzh_pytorch
def evaluate_accuracy(data_iter, net):
    acc_sum, n = 0.0, 0
    for X, y in data_iter:
        if isinstance(net, torch.nn.Module):
            net.eval() # 评估模式, 这会关闭dropout
            acc_sum += (net(X).argmax(dim=1) == y).float().sum().item()
            net.train() # 改回训练模式
        else: # 自定义的模型
            if('is_training' in net.__code__.co_varnames): # 如果有is_training这个参数
                # 将is_training设置成False
                acc_sum += (net(X, is_training=False).argmax(dim=1) == y).float().sum().item() 
            else:
                acc_sum += (net(X).argmax(dim=1) == y).float().sum().item() 
        n += y.shape[0]
    return acc_sum / n

将上述evaluate_accuracy写回d2lzh_pytorch后要重启一下jupyter kernel才会生效。

训练和测试模型

这部分与之前多层感知机的训练和测试类似。

num_epochs, lr, batch_size = 5, 100.0, 256
loss = torch.nn.CrossEntropyLoss()
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)
d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, batch_size, params, lr)

3. 简洁实现

在PyTorch中，我们只需要在全连接层后添加Dropout层并指定丢弃概率。在训练模型时，Dropout 层将以指定的丢弃概率随机丢弃上⼀层的输出元素;在测试模型时(即 model.eval()后)， Dropout层并不发挥作用。

net = nn.Sequential(
        d2l.FlattenLayer(),
        nn.Linear(num_inputs, num_hiddens1),
        nn.ReLU(),
        nn.Dropout(drop_prob1),
        nn.Linear(num_hiddens1, num_hiddens2), 
        nn.ReLU(),
        nn.Dropout(drop_prob2),
        nn.Linear(num_hiddens2, 10)
        )
#手动初始化参数
for param in net.parameters():
    nn.init.normal_(param, mean=0, std=0.01)

下⾯训练并测试模型。

optimizer = torch.optim.SGD(net.parameters(), lr=0.5)
d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, batch_size, None, None, optimizer)

由于这⾥使⽤的是PyTorch的SGD⽽不是d2lzh_pytorch⾥面手写的sgd，所以就不存在学习率看起来很⼤的问题了。

4. 小结

1）我们可以通过使⽤用丢弃法应对过拟合。

2）丢弃法只在训练模型时使⽤用。

CoreJT

关注

2
点赞
踩
7

收藏

觉得还不错? 一键收藏
1
评论
动手学PyTorch | (10) Dropout(丢弃法)

除了前⼀节介绍的权????重衰减以外，深度学习模型常常使用丢弃法(dropout)来应对过拟合问题。丢弃法有⼀些不同的变体。本节中提到的丢弃法特指倒置丢弃法(inverted dropout)。目录1. 方法2. 从0开始实现3. 简洁实现4. 小结1. 方法回忆⼀下，(多层感知机)的图示描述了一个单隐藏层的多层感知机。其中输⼊个数为4，隐藏单元个数为5，且隐藏单元的计算表达...
复制链接

扫一扫