dropout丢弃法python

丢弃法(dropout)

动机

一个好的模型需要对输入数据的扰动鲁棒。
1、使用有噪音的数据等价于Tikhonov正则。（权重的范围不要太大，防止过拟合，在数据里面加入噪音等价于正则。正则都是为了避免过拟合？？随机噪音）
2、丢弃法：在层之间加噪音。

无偏差的加入噪音

丢弃法对每个元素进行如下扰动：概率p为0，其他情况变大。p就是dropout rate
$$x_i^{{}^{\prime }}=\{\begin{array}{ll}0& \text{with probablity p}\\ \frac{x^{\prime }}{1-p}& \text{otherise}\end{array}$$

使用丢弃法

通常将丢弃法作用在隐藏全连接层的输出上。（昨天汇报的那篇论文Deep learn FHE就是最后是全连接层加dropout层）
$$\begin{gathered} h=\sigma (W_{1}x+b_1)第一个隐藏层，激活函数 \\ {h}^{\prime }=dropout(h)在概率p丢弃 \\ o=W_2{h}^{\prime }+b_2输出层 \\ y=softmax(o) \end{gathered}$$

假设原先一共3层，分别有输入层4，隐藏层5，输出层3.
变为输入层4，隐藏层剩下3个，输出不变还是3。下一次可能是另外一些。随机化。

推理中的丢弃法：
正则项只在训练中使用：他们会影响参数的更新。
在推理过程中，丢弃法直接返回输入。
预测时：h=dropout（h）
这样也能保证确定性的输出。

总结：

丢弃法将一些输出项随机置0来控制模型的复杂度。（增加单元，减少复杂度）
常作用于多层感知机MLP的隐藏层输出上。
丢弃概率式控制模型复杂度的超参数。

import torch
import timer
from torch import nn
from d2l import torch as d2l
import matplotlib.pyplot as plt
def dropout_layer(X, dropout):#简洁实现时，这个函数已经封装好了
    assert 0 <= dropout <= 1
    # 在本情况中，所有元素都被丢弃。
    if dropout == 1:
        return torch.zeros_like(X)
    # 在本情况中，所有元素都被保留。不变
    if dropout == 0:
        return X
    mask = (torch.randn(X.shape) > dropout).float()
    return mask * X / (1.0 - dropout)#此时mask只取两个值，0和1，相当于取一些位置置0

'''
实例
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.))
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.,  0.,  0.,  8.,  0.,  0., 14.],保持期望不变，值会变大
        [ 0., 18.,  0.,  0.,  0., 26., 28.,  0.]])
tensor([[0., 0., 0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0.]])
'''
#定义具有两个隐藏层的多层感知机，每个隐藏层包含256个单元，注意是否是在训练

num_inputs, num_outputs, num_hidden1, num_hidden2 = 784, 10, 256, 256
dropout1, dropout2 = 0.2, 0.5


class Net(nn.Module):
    def __init__(self, num_inputs, num_outputs, num_hidden1, num_hidden2, is_training=True):
        super(Net, self).__init__()
        self.num_inputs = num_inputs
        self.training = is_training
        self.lin1 = nn.Linear(num_inputs, num_hidden1)
        self.lin2 = nn.Linear(num_hidden1, num_hidden2)
        self.lin3 = nn.Linear(num_hidden2, 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:
            # 在第一个全连接层之后添加一个dropout层，先激活relu
            H1 = dropout_layer(H1, dropout1)
        H2 = self.relu(self.lin2(H1))
        if self.training:
            # 在第二个全连接层之后添加一个dropout层
            H2 = dropout_layer(H2, dropout2)
        out = self.lin3(H2)
        return out

net = Net(num_inputs, num_outputs, num_hidden1, num_hidden2)
num_epochs, lr, batch_size = 10, 0.5, 256
loss = nn.CrossEntropyLoss()#交叉熵
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)
print(len(train_iter))
trainer = torch.optim.SGD(net.parameters(), lr=lr)
d2l.train_ch3(net,train_iter,test_iter,loss,num_epochs,trainer)
plt.show()

#有dropout结果会比之前好许多

import torch
import timer
from torch import nn
from d2l import torch as d2l
import matplotlib.pyplot as plt

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


num_inputs, num_outputs, num_hidden1, num_hidden2 = 784, 10, 256, 256
dropout1, dropout2 = 0.2, 0.5
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))
net.apply(init_weights)
num_epochs, lr, batch_size = 10, 0.5, 256
loss = nn.CrossEntropyLoss()
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)
plt.show()

QA

1. dropout随机置0，梯度和权重也会为0.
2. dropout超参数设置要合适， 不合理输出结果影响不同。
   随机丢弃保证不了正确性，，看精度，可以重复。
3. 丢弃法是在训练中吧神经元丢弃后训练，在预测网络中的神经元没有丢弃。
4. 每epoch迭代一次，随机丢弃一次。
5. BN是卷积层，dropout是全连接层使用。
6. dropout没有被丢弃的输入部分的值会改变（变大），保持期望（方差，均值不变），训练数据的标签还是原来的值。
7. 解决过拟合的问题上，两种方法，可以一起用，dropout减少复杂度，L2限制权重范围。