零基础-动手学深度学习-4.6暂退法（Dropout）

鄙人生医转码，道行浅薄请多谅解~仅作笔记学习交流

常用于多层感知机的隐藏层输出上，丢弃概率是控制模型参数复杂度的超参数

一、重新审视过拟合

书上说的很好：当面对更多的特征而样本不足时，线性模型往往会过拟合。 相反，当给出更多样本而不是特征，通常线性模型不会过拟合。 不幸的是，线性模型泛化的可靠性是有代价的。 简单地说，线性模型没有考虑到特征之间的交互作用。 对于每个特征，线性模型必须指定正的或负的权重，而忽略其他特征。

泛化性和灵活性之间的这种基本权衡被描述为偏差-方差权衡，深度神经网络位于偏差-方差谱的另一端，与线性模型不同，神经网络并不局限于单独查看每个特征，而是学习特征之间的交互。

二、扰动的稳健性

一个好的模型要对输入数据的扰动鲁棒，我们期待的好的预测模型能在未知的数据上有很好的表现，经典的泛化理论认为，我们应该以简单的模型作为目标，简单的另一个角度是平滑性，不应该对输入的微小变化敏感，于是乎就有一帮人在每一内部层的同时注入噪声，也称之为drop out，淡然还有Tikhonov正则直接使用有噪音的数据进行输入

重点也在于我们要如何注入这种噪声，一种想法是以一种无偏向的方式注入噪声，就是加入噪音但是不改变我们的期望，我们通过未丢弃的节点的分数进行规范化来消除每一层的偏差，即每个中间活性值h以暂退概率p由随机变量h`替换：

三、实践中的暂退法

通常将drop out作用在隐藏全连接层的输出上：

通常，我们在测试时不用暂退法。 给定一个训练好的模型和一个新的样本，我们不会丢弃任何节点，因此不需要标准化，正则项只在训练中使用，推理中我们不需要drop out

四、从0开始实现

导入库：

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

实现dropout_layer函数：

def dropout_layer(X, dropout):
    assert 0 <= dropout <= 1
    #断言语句确保 dropout 参数的取值范围在 0 和 1 之间
    # 在本情况中，所有元素都被丢弃
    if dropout == 1:
        return torch.zeros_like(X)
    # 在本情况中，所有元素都被保留
    if dropout == 0:
        return X
    mask = (torch.rand(X.shape) > dropout).float()
    #torch.rand(X.shape) 生成一个与输入 X 形状相同的随机张量，每个元素都在 [0, 1) 范围内
    #(torch.rand(X.shape) > dropout) 会生成一个布尔掩码（mask），每个元素根据随机数是否大于 dropout 来决定是否保留该元素。
    #如果随机数大于 dropout，则保留该元素（标记为 True），否则丢弃（标记为 False）
    #.float() 将布尔掩码转换为浮点数张量，True 转为 1.0，False 转为 0.0
    return mask * X / (1.0 - dropout)
    #这一行有两个操作：
    #1.mask * X：使用掩码 mask 来按元素相乘输入张量 X，丢弃部分神经元的输出（对应掩码为 0 的位置），保留其余神经元的输出
    #2./ (1.0 - dropout)：为了在训练过程中保持输出的期望值不变，对剩余神经元的输出进行缩放。
    #丢弃率为 dropout 的神经元有 (1.0 - dropout) 的比例会被保留，因此输出需要按 1.0 - dropout 进行缩放，确保训练时和测试时的激活值的期望值一致

1.定义模型参数

导入MINST数据集，定义具有两个隐藏层的多层感知机，每个隐藏层包含256个单元：

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

2.定义模型

我们可以将暂退法应用于每个隐藏层的输出（在激活函数之后）， 并且可以为每一层分别设置暂退概率： 常见的技巧是在靠近输入层的地方设置较低的暂退概率。 下面的模型将第一个和第二个隐藏层的暂退概率分别设置为0.2和0.5， 并且暂退法只在训练期间有效：

dropout1, dropout2 = 0.2, 0.5

class Net(nn.Module):
    def __init__(self, num_inputs, num_outputs, num_hiddens1, num_hiddens2,
                 is_training = True):
        # num_inputs: 输入特征的数量
        # num_outputs: 输出的数量，通常与任务有关，比如分类任务中的类别数量
        # num_hiddens1: 第一个隐藏层的神经元数量
        # num_hiddens2: 第二个隐藏层的神经元数量
        #is_training: 一个布尔变量，指示模型是否处于训练模式。这个参数用于决定是否应用 dropout（因为 dropout 只在训练时使用，测试时不使用）
        super(Net, self).__init__()
        self.num_inputs = num_inputs
        self.training = is_training
        self.lin1 = nn.Linear(num_inputs, num_hiddens1)#self.lin1: 第一个全连接层，输入大小为 num_inputs，输出大小为 num_hiddens1
        self.lin2 = nn.Linear(num_hiddens1, num_hiddens2)#self.lin2: 第二个全连接层，输入大小为 num_hiddens1，输出大小为 num_hiddens2
        self.lin3 = nn.Linear(num_hiddens2, num_outputs)#self.lin3: 输出层，输入大小为 num_hiddens2，输出大小为 num_outputs
        self.relu = nn.ReLU()#self.relu: 激活函数 ReLU，添加非线性激活以增强模型的表达能力

    def forward(self, X):
        H1 = self.relu(self.lin1(X.reshape((-1, self.num_inputs))))
        # 只有在训练模型时才使用dropout
        # self.lin1(X.reshape(...)): 通过第一个全连接层（线性变换），输入维度为 num_inputs，输出维度为 num_hiddens1
        if self.training == True:
            # 在第一个全连接层之后添加一个dropout层
            H1 = dropout_layer(H1, dropout1)
            #如果 self.training == True，即网络处于训练模式，那么会调用 dropout_layer(H1, dropout1)
            #对第一个隐藏层的输出 H1 应用 dropout，使用的 dropout 比率为 dropout1（比如 0.2，即有 20% 的神经元将被随机丢弃）
        H2 = self.relu(self.lin2(H1))
        #self.lin2(H1): 第二个全连接层的输入是 H1，输出维度为 num_hiddens2
        if self.training == True:
            # 在第二个全连接层之后添加一个dropout层
            H2 = dropout_layer(H2, dropout2)
        out = self.lin3(H2)
        #最后通过第三个全连接层 self.lin3(H2)，将网络的输出传递给输出层，输出大小为 num_outputs
        return out


net = Net(num_inputs, num_outputs, num_hiddens1, num_hiddens2)
#创建一个网络对象 net，并传入模型的超参数：num_inputs、num_outputs、num_hiddens1 和 num_hiddens2。这些参数将决定模型的层次结构，包括输入大小、输出大小以及两个隐藏层的大小

3.训练和测试

类似于前面描述的多层感知机训练和测试：

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，我们只需在每个全连接层之后添加一个层， 将暂退概率作为唯一的参数传递给它的构造函数：

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)