动手学深度学习之丢弃法(Dropout)

丢弃法

动机

• 一个好的模型需要对输入数据的扰动鲁棒
  • 使用有噪音的数据等价于Tikhonov正则
  • 丢弃法：在层之间加入噪音

无偏差的加入噪音

• 对x加入噪音得到$x^{{}^{\prime }}$，我们希望
  $E[x^{{}^{\prime }}]=x$
• 丢弃法对每个元素进行如下扰动。
  $x_i^{{}^{\prime }}=\{\begin{array}{cc}0& withprobablityp\\ \frac{x_i}{1?p}& otherise\end{array}$

使用dropout

• 通常将丢弃法作用在隐藏全连接层的输出上

推理中的dropout

• 正则项只在训练中使用：他们影响模型参数的更新
• 在推理过程中，丢弃法直接返回输入 h=dropout(h)
  • 这样也能保证确定性的输出

总结

• dropout将一些输出项随机置0来控制模型复杂度
• 常作用在多层感知机的隐藏层输出上
• 丢弃概率是控制模型复杂度的超参数

Dropout

我们实现dropout_layer函数，该函数以dropout的概率丢弃张量输入X中的元素

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

测试dropout_layer函数

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., 12.,  0.],[16., 18., 20.,  0.,  0.,  0., 28.,  0.]])
tensor([[0., 0., 0., 0., 0., 0., 0., 0.],[0., 0., 0., 0., 0., 0., 0., 0.]])

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

定义具有两个隐藏层的多层感知机，每个隐藏层包含256个单元

dropout1, dropout2 = 0.2, 0.5class 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_inputsself.training = is_trainingself.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))))# 只有在训练模型时才使用dropoutif 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 outnet = Net(num_inputs, num_outputs, num_hiddens1, num_hiddens2)

训练

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)

?

简洁实现

dropout1, dropout2 = 0.2, 0.5
net = nn.Sequential(nn.Flatten(), nn.Linear(784, 256), nn.ReLU(),nn.Dropout(dropout1), 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)

Sequential((0): Flatten(start_dim=1, end_dim=-1)(1): Linear(in_features=784, out_features=256, bias=True)(2): ReLU()(3): Dropout(p=0.2, inplace=False)(4): Linear(in_features=256, out_features=256, bias=True)(5): ReLU()(6): Dropout(p=0.5, inplace=False)(7): Linear(in_features=256, out_features=10, bias=True)
)

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