从五开始的深度学习——暂退法/丢弃法（一种神奇的方法）

参考来源：

动手深度学习（第二版）

一、丢弃法基本原理

丢弃法（Dropout）是一种常用的正则化方法，可以防止神经网络在训练时产生过拟合现象。其基本思想是在每次训练迭代中随机丢弃一部分神经元的输出，使得模型对输入数据有更好的鲁棒性。

在神经网络中，每个神经元通常都会与前一层或后一层的所有神经元相连。在传统的神经网络中，这些连接和激活函数都是固定的，在每次迭代中都会被使用。而丢弃法通过随机删除一些连接以及对应的激活函数来实现正则化，从而减少了每个神经元之间的依赖关系，增加了模型的泛化能力。

具体地说，丢弃法在隐藏层中随机选择一部分神经元，并将它们的输出值设为零。这样做的结果是，每个神经元不再能够总是依赖于特定的一组神经元进行正确分类，而是必须自己学习不同组合的相关特征。因此，丢弃法可以促使模型具有更高的鲁棒性和泛化能力，有效防止过拟合的发生。同时，丢弃法通过突出模型中最强大的特征，还可以提高神经网络性能，增加训练速度。

在实际应用中，丢弃法可以被视为一种随机从神经网络中删除部分神经元的过程，减少了因网络复杂度过高而导致的计算和存储成本。其常用于卷积神经网络、循环神经网络以及全连接神经网络等不同类型的架构，并已被成功地应用于语音识别、自然语言处理和图像分类等任务上。

 丢弃法在前向传播过程中，计算每一内部层的同时注入噪声，这已经成为训练神经网络的常用技术。 这种方法之所以被称为暂退法，因为我们从表面上看是在训练过程中丢弃（drop out）一些神经元。 在整个训练过程的每一次迭代中，标准丢弃法包括在计算下一层之前将当前层中的一些节点置零。

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

                                           

根据此模型的设计，其期望值保持不变，即E[h′]=h：

二、丢弃法原理图

如图示，就是在隐藏层处理中利用丢弃法丢弃了h2与h5

三、从零开始实现丢弃法

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

#将比dropout小的设为0
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)

X= torch.arange(16, dtype = torch.float32).reshape((2, 8))
print(X)
print(dropout_layer(X, 0.))
print(dropout_layer(X, 0.5))
print(dropout_layer(X, 1.))

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)

简洁版：

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)