deep_learning_6.过拟合-暂退法(Dropout)

暂退法（Dropout）

模型的泛化性越强，要求模型对其输入的微小变化越不敏感，也就是对噪声的适应能力越强。

那么关键是如何加入这种噪声，一种想法是无偏差（unbiased）的方式注入噪声。这样在固定住其他层时，每一层的期望值等于没有噪声时的值。我们把这种方法叫做暂退法。

暂退法其实就是在训练过程中丢弃（drop out）一些神经元。 在整个训练过程的每一次迭代中，标准暂退法包括在计算下一层之前将当前层中的一些节点置零。

无偏差的加入噪音

• 对X加入噪音得到X‘，我们希望

  $E[x’] = x$

• 丢弃法对每个元素进行如下的扰动
  $$
  x_i’ = \begin{cases} 0 \ , with\ probablity\ p \
  \frac {x_i}{1-p} \ , otherwise
  \end{cases}
  $$

$E[x_i’] = p0 + (1-p) \frac {x_i’}{(1-p)} = x_i’$

代码实现

要实现单层的暂退法函数， 我们从均匀分布U[0,1]中抽取样本，样本数与这层神经网络的维度一致。 然后我们保留那些对应样本大于p的节点，把剩下的丢弃。

在下面的代码中，我们实现 dropout_layer 函数， 该函数以dropout的概率丢弃张量输入X中的元素， 如上所述重新缩放剩余部分：将剩余部分除以1.0-dropout。

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


def dropout_layer(X, dropout):
    assert 0 <= dropout <= 1
    # 在本情况中，所有元素都被丢弃
    if dropout == 1:
        return torch.zeros_like(X)
    # 在本情况中，所有元素都被保留
    if dropout == 0:
        return X
    mask = (torch.rand(X.shape) > dropout).float()
    return mask * X / (1.0 - dropout)

我们可以通过下面几个例子来测试dropout_layer函数。 我们将输入X通过暂退法操作，暂退概率分别为0、0.5和1。

X = torch.arange(16,dtype=torch.float32).reshape((2,8))
print(X)
print(drop_out_layer(X,0.))
print(drop_out_layer(X,0.5))
print(drop_out_layer(X,1.))
print(torch.rand(X.shape) > 0.5)
print((torch.rand(X.shape) > 0.5).float())

tensor([[ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.],
        [ 8.,  9., 10., 11., 12., 13., 14., 15.]])
tensor([[ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.],
        [ 8.,  9., 10., 11., 12., 13., 14., 15.]])
tensor([[ 0.,  0.,  4.,  0.,  8., 10.,  0.,  0.],
        [ 0., 18., 20., 22.,  0., 26.,  0., 30.]])
tensor([[0., 0., 0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0.]])
tensor([[ True, False,  True, False,  True, False, False,  True],
        [False,  True, False,  True, False,  True, False, False]])
tensor([[0., 0., 1., 1., 1., 0., 0., 0.],
        [0., 0., 1., 0., 1., 0., 1., 0.]])

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)
        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)

简介代码实现

对于深度学习框架的高级API，我们只需在每个全连接层之后添加一个Dropout层， 将暂退概率作为唯一的参数传递给它的构造函数。 在训练时，Dropout层将根据指定的暂退概率随机丢弃上一层的输出（相当于下一层的输入）。 在测试时，Dropout层仅传递数据。

net = nn.Sequential(nn.Flatten(),
        nn.Linear(784, 256),
        nn.ReLU(),
        # 在第一个全连接层之后添加一个dropout层
        nn.Dropout(dropout1),
        nn.Linear(256, 256),
        nn.ReLU(),
        # 在第二个全连接层之后添加一个dropout层
        nn.Dropout(dropout2),
        nn.Linear(256, 10))

def init_weights(m):
    if type(m) == nn.Linear:
        nn.init.normal_(m.weight, std=0.01)

net.apply(init_weights);

trainer = torch.optim.SGD(net.parameters(), lr=lr)
d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, trainer)

Q&A

1.丢弃法的丢弃依据是什么？如果丢弃不合理对输出的结果影响会很大？

所谓丢弃不合理，其实就是过大或过小，过小就还是过拟合，太大那么就是欠拟合，慢慢调超参数就好了

2.dropout随机置0对求梯度和反向传播的影响是什么？

dropout掉的对应的梯度不会更新

3.丢弃法是在训练中把神经元丢弃后训练，在预测时网络中的神经元没有丢弃吗？

是的，dropout其实是正则项，正则项唯一的作用是你在训练模型的时候，让你的模型复杂度变低一点，当你在做推理的时候你不会更新你的模型，这就是为什么在预测的时候不用dropout。

4.丢弃法是每次迭代一次，随机丢弃一次吗？

每一个层在调用前项运算的时候，随机丢一次，假如你3个隐藏层就是套3个dropout

5.dropout会不会让训练的loss曲线方差变大，不够平滑？

李沐说不care这件事情，没有具体去看过

6.在解决过拟合问题上，dropout和regularization的主要区别是什么？

可以认为dropout就是正则regularization

7.dropout层丢弃的是前一层还是后一层？

丢弃前一层的输出，后一层的输入

8.dropout和权重衰减都属于正则，为何dropout效果更好更常用呢？

dropout其实没有权重衰减常用，dropout是在全连接层使用，权重衰减对于卷积层啊之后的transformer都可以用。至于为什么效果更好，其实是dropout更好调参一点，权重衰减的weight没那么好调。

9.在同样的学习率lr上，dropout的介入会不会造成参数手链更慢，需要比没有dropout的情况下适当调大lr？

lr主要是对期望和方差敏感一点，dropout不改变期望，没有说dropout的情况下一定要调大lr，但你也可以试试。但会收敛变慢是可能的，等于是说你每次你更小的数量在更新梯度