李沐深度学习-04.04暂退法

1.暂退法定义

有人建议在计算后续层之前向网络的每一层注入噪声。 因为当训练一个有多层的深层网络时，注入噪声只会在输入-输出映射上增强平滑性。这个想法被称为暂退法（dropout）。

这种方法之所以被称为暂退法，因为我们从表面上看是在训练过程中丢弃（drop out）一些神经元。在整个训练过程的每一次迭代中，标准暂退法包括在计算下一层之前将当前层中的一些节点置零。

那么关键的挑战就是如何注入这种噪声。在标准暂退法正则化中，通过按保留（未丢弃）的节点的分数进行规范化来消除每一层的偏差。 换言之，每个中间活性值 h 以暂退概率 p 由随机变量 h`替换，如下所示：
根据此模型的设计，其期望值保持不变，即

实践中如下图所示

2.代码从零开始实现

注意：
（1）一般把网络中具有可学习参数的层（如全连接层、卷积层等）放在构造函数__init__()中，当然我也可以吧不具有参数的层也放在里面；

（2）一般把不具有可学习参数的层(如ReLU、dropout、BatchNormanation层)可放在构造函数中，也可不放在构造函数中，如果不放在构造函数__init__里面，则在forward方法里面可以使用nn.functional来代替

（3）forward方法是必须要重写的，它是实现模型的功能，实现各个层之间的连接关系的核心。
执行y = model(x)时，由于LeNet类继承了Module类，而Module这个基类中定义了__call__方法，所以会执行__call__方法，而__call__方法中调用了forward()方法

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

def dropout_layer(X, dropout):
    assert 0 <= dropout <= 1
    if dropout ==1: # 全部丢弃，返回0即可
        return torch.zeros_like(X)
    if dropout == 0:#不丢弃，则全部返回
        return X
    mask = (torch.rand(X.shape) > dropout).float() # 大于概率得值保留
    return mask * X /(1.0 - dropout) #保留得值反向扩大

num_inputs, num_outputs, num_hiddens1, num_hiddens2 = 784, 10, 256, 256  #fashiuon输入784*1，输出为10个分类
dropout1,dropout2 = 0.2,0.5

class Net(nn.Module):#定义神经网络,并且重写init与forwarad前向传播这两个方法，而且必须重写
    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)#第一层网络 784*256
        self.lin2 = nn.Linear(num_hiddens1,num_hiddens2)#第二层 256*256
        self.lin3 = nn.Linear(num_hiddens2,num_outputs)#第三层 256*10
        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)#加载fashion_mnist数据
trainer = torch.optim.SGD(net.parameters(),lr=lr)#优化函数
d2l.train_ch3(net,train_iter,test_iter,loss,num_epochs,trainer)#训练

3.简洁实现

# 简洁实现
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)

num_inputs, num_outputs, num_hiddens1, num_hiddens2 = 784, 10, 256, 256
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)

dropout1, dropout2 = 0.2, 0.5

#对于深度学习框架的高级API，我们只需在每个全连接层之后添加一个Dropout层， 将暂退概率作为唯一的参数传递给它的构造函数。 
#在训练时，Dropout层将根据指定的暂退概率随机丢弃上一层的输出（相当于下一层的输入）。 在测试时，Dropout层仅传递数据。
net = nn.Sequential(nn.Flatten(),
                     # 在第一个全连接层之后添加一个dropout层
                    nn.Linear(784,256),nn.ReLU(),nn.Dropout(dropout1),
                    # 在第二个全连接层之后添加一个dropout层
                    nn.Linear(256,256),nn.ReLU(),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)

4.课后习题的一些想法

1.交换暂退法概率不会有大的变化，当lambda过大时，test_acc会下降，当过小时，不会有明显变化。
2.只是单纯的增加训练轮数，一定轮数，如15层左右，train_acc会即为接近1而train_loss在10附近就接近0,但是test_acc并没有明显变化
3.同时使用暂退法和权重衰减，会使精度下降