深度学习之抛弃法

抛弃法

动机

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

无偏差的加入噪音

• 对                                         x                                  \mathbf{x}                     x 加入噪音得到                                                    x                               ′                                            \mathbf{x}'                     x′，我们盼望
                                                E                               [                                           x                                  ′                                          ]                               =                               x                                      \mathbf{E}[\mathbf{x}'] = \mathbf{x}                        E[x′]=x
  
• 抛弃法对每个元素进行如下扰动
                                                            x                                  i                                  ′                                          =                                           {                                                                                            0                                                                                                                     with probability                                                  p                                                                                                                                                                               x                                                    i                                                                                    1                                                    −                                                    p                                                                                                                                     otherwise                                                                                                       x_i' = \begin{cases} 0 & \text{with probability } p \\ \frac{x_i}{1 - p} & \text{otherwise} \end{cases}                        xi′​={01−pxi​​​with probability potherwise​
  

实际上，上述 Dropout 后期望是没有发生变革的，具体期望计算如下：                                        E                            [                                       x                               i                               ′                                      ]                            =                            p                            ⋅                            0                            +                            (                            1                            −                            p                            )                            ⋅                                                   x                                  i                                                      1                                  −                                  p                                                 =                                       x                               i                                            \mathbf{E}[x_i'] = p \cdot 0 + (1 - p) \cdot \frac{x_i}{1 - p} = x_i                     E[xi′​]=p⋅0+(1−p)⋅1−pxi​​=xi​

# 推理中的抛弃法

• 正则项只在训练中使用：他们影响模子参数的更新
  
• 在推理过程中，抛弃法直接返回输入，无需做任何操纵                                             h                               =                               dropout                               (                               h                               )                                      \mathbf{h} = \text{dropout}(\mathbf{h})                        h=dropout(h)
  
• 如许也能保证确定性的输出
  

总结

• 抛弃法将一些输出项随机置 0 来控制模子复杂度
  
• 常作用在多层感知机的隐藏层输出上，很少用在 CNN 之类的模子上
  
• 抛弃概率是控制模子复杂度的超参数
  

代码实现

从零开始实现

首先导入须要的库，同时实现一个 dropout_layer 函数，该函数以dropout的概率抛弃张量输入X中的元素：

1. import torch
2. from torch import nn
3. from d2l import torch as d2l
6. def dropout_layer(X, dropout): # X是张量，dropout是丢弃率
7.     assert 0 <= dropout <= 1
8.     # 在本情况中，所有元素都被丢弃
9.     if dropout == 1: # 为1表示所有元素都丢弃，返回一个与X形状相同的全0张量
10.         return torch.zeros_like(X)
11.     # 在本情况中，所有元素都被保留
12.     if dropout == 0: # 所有元素都保留
13.         return X
14.     # 生成一个与X形状相同的随机张量，值在[0, 1)之间，然后与dropout进行比较，大于的赋值为1.0，小于的赋值为0.0
15.     mask = (torch.rand(X.shape) > dropout).float()
16.     # 得到一个二值掩码张量 mask，用于指示哪些元素应该保留（值为1）
17.     return mask * X / (1.0 - dropout)

复制代码

接下来来测试一下该函数：

1. X= torch.arange(16, dtype = torch.float32).reshape((2, 8))
2. print(X)
3. print(dropout_layer(X, 0.))
4. print(dropout_layer(X, 0.5)) # 有一半的概率将其中的元素变为0
5. print(dropout_layer(X, 0.7))
6. print(dropout_layer(X, 1.))

复制代码

下面定义模子参数（定义具有两个隐藏层的多层感知机，每个隐藏层包罗256个单位）：
输入还是 28*28，输出是 10 个类别

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

复制代码

下面定义模子：

1. dropout1, dropout2= 0.2, 0.5
3. class Net(nn.Module):
4.     def __init__(self, num_inputs, num_outputs, num_hiddens1, num_hiddens2,
5.                  is_training = True): # 要区别是在训练，还是在测试
6.         super(Net, self).__init__()
7.         self.num_inputs = num_inputs
8.         self.training = is_training
9.         self.lin1 = nn.Linear(num_inputs, num_hiddens1) # 定义第一个全连接层，输入为 num_inputs，输出为 num_hiddens1
10.         self.lin2 = nn.Linear(num_hiddens1, num_hiddens2)
11.         self.lin3 = nn.Linear(num_hiddens2, num_outputs)
12.         self.relu = nn.ReLU()# 定义激活函数
14.     def forward(self, X):
15.         H1 = self.relu(self.lin1(X.reshape((-1, self.num_inputs)))) # 第一个隐藏层的输出
16.         # 只有在训练模型时才使用dropout
17.         if self.training == True:
18.             # 在第一个全连接层之后添加一个dropout层
19.             H1 = dropout_layer(H1, dropout1)
20.         H2 = self.relu(self.lin2(H1))
21.         if self.training == True:
22.             # 在第二个全连接层之后添加一个dropout层
23.             H2 = dropout_layer(H2, dropout2)
24.         out = self.lin3(H2)
25.         return out
27. net = Net(num_inputs, num_outputs, num_hiddens1, num_hiddens2)

复制代码

下面训练和测试：

1. num_epochs, lr, batch_size = 10, 0.5, 256
2. loss = nn.CrossEntropyLoss(reduction='none') # 不对每个样本的损失进行平均或求和，而是返回每个样本的损失值
3. train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)
4. trainer = torch.optim.SGD(net.parameters(), lr=lr)
5. d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, trainer)

复制代码

简便实现

1. net = nn.Sequential(nn.Flatten(),# 将输入张量展平为一维向量
2.         nn.Linear(784, 256), # 定义一个全连接层
3.         nn.ReLU(),
4.         # 在第一个全连接层之后添加一个dropout层
5.         nn.Dropout(dropout1),
6.         nn.Linear(256, 256),
7.         nn.ReLU(),
8.         # 在第二个全连接层之后添加一个dropout层
9.         nn.Dropout(dropout2),
10.         nn.Linear(256, 10))
12. def init_weights(m):
13.     if type(m) == nn.Linear: # 检查是否为全连接层
14.         nn.init.normal_(m.weight, std=0.01)
16. net.apply(init_weights);
18. trainer = torch.optim.SGD(net.parameters(), lr=lr)
19. d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, trainer)

复制代码

QA 思索

Q1：Dropout 随机抛弃，怎样保证效果的精确性和可重复性？
A1：实际上，机器学习是没有精确性这一说的，只有效果好不好。没须要可重复，只需要精度差不多就可以。
概念1：抛弃法是在训练中把神经元抛弃后训练，在预测时网络中的神经元没有抛弃。
概念2：抛弃法是每次迭代一次，随机抛弃一次。也就是每一个层在调用前向运算的时候，随机抛弃一次。
Q2：训练时使用dropout，推理时不用。那会不会导致推理时输出效果翻倍了？比如dropout=0.5，推理时输出效果是训练时2个子神经网络的叠加而翻倍?
A2：这就是为啥需要除以一个 （1 - p），保证期望不会发生变革，避免我的输出效果是我的训练时的 N 倍。
Q3：在同样的Ir下，dropout的到场会不会造成参数收敛更慢，需要比没有dropout的环境下适当调大Ir吗?
A3：由于Dropout的加入，导致梯度值减小，因此参数收敛汇编慢，但是并没有研究表明一定需要适当增大 lr 的。
Q4：为什么推理中的 Dropout 是直接返回输入？
A4：预测，也就是不对权重做更新的时候，Dropout 是不需要的，因为 Dropout 是一个正则项，正则项唯一的作用就是在更新权重的时候让模子复杂度变低一点，在做推理的时候是不会更新模子的，因此是不需要 Dropout 的，当然也可以用，但是用的话就会出现随机性了。因此为了避免这些随机性，如许需要多算几次推理来将这个方差降下来，但是训练的时候是没有题目的，因为我训练的时候需要跑许多轮，如许对整个体系的稳定性来说是没有题目的，但是在推理的时候，就关心某一个样本效果的话，可能就需要做平均了。
对于这个的明白是，训练集的分布与真实分布可能并不完全雷同，因此引用dropout来对训练集加入一些噪音，使得训练数据的分布更加普适，从而保证模子的鲁棒性。所以预测的时候就没须要再加入噪声了。
后记

明白了之后写的一段代码：

1. import torch
2. import torchvision
3. from torchvision import transforms
4. from torch.utils import data
5. import matplotlib.pyplot as plt
6. from tqdm import tqdm  # 导入 tqdm 库
9. # 定义 Dropout 层
10. def dropout_layer(X, dropout):
11.     assert 0 <= dropout <= 1
12.     if dropout == 1:
13.         return torch.zeros_like(X)
14.     if dropout == 0:
15.         return X
16.     mask = (torch.rand(X.shape) > dropout).float()
17.     return mask * X / (1.0 - dropout)
20. # 定义神经网络
21. class Net(torch.nn.Module):
22.     def __init__(self, num_inputs, num_outputs, num_hiddens1, num_hiddens2, is_training=True):
23.         super(Net, self).__init__()
24.         self.num_inputs = num_inputs
25.         self.training = is_training
26.         self.lin1 = torch.nn.Linear(num_inputs, num_hiddens1)
27.         self.lin2 = torch.nn.Linear(num_hiddens1, num_hiddens2)
28.         self.lin3 = torch.nn.Linear(num_hiddens2, num_outputs)
29.         self.relu = torch.nn.ReLU()
31.     def forward(self, X):
32.         H1 = self.relu(self.lin1(X.reshape((-1, self.num_inputs))))
33.         if self.training:
34.             H1 = dropout_layer(H1, dropout=0.2)
35.         H2 = self.relu(self.lin2(H1))
36.         if self.training:
37.             H2 = dropout_layer(H2, dropout=0.5)
38.         return self.lin3(H2)  # 输出层不需要激活函数
41. # 加载 Fashion-MNIST 数据集
42. def load_data_fashion_mnist(batch_size, resize=None):
43.     trans = [transforms.ToTensor()]
44.     if resize:
45.         trans.insert(0, transforms.Resize(resize))
46.     trans = transforms.Compose(trans)
47.     mnist_train = torchvision.datasets.FashionMNIST("../data", train=True, transform=trans, download=True)
48.     mnist_test = torchvision.datasets.FashionMNIST("../data", train=False, transform=trans, download=True)
49.     return (
50.         data.DataLoader(mnist_train, batch_size, shuffle=True),
51.         data.DataLoader(mnist_test, batch_size, shuffle=False)
52.     )
55. # 累积器类
56. class Accumulator:
57.     def __init__(self, n):
58.         self.data = [0.0] * n
60.     def add(self, *args):
61.         self.data = [a + float(b) for a, b in zip(self.data, args)]
63.     def reset(self):
64.         self.data = [0.0] * len(self.data)
66.     def __getitem__(self, idx):
67.         return self.data[idx]
70. # 计算准确率
71. def accuracy(y_hat, y):
72.     if len(y_hat.shape) > 1 and y_hat.shape[1] > 1:
73.         y_hat = y_hat.argmax(axis=1)
74.     cmp = y_hat.type(y.dtype) == y
75.     return float(cmp.type(y.dtype).sum())
78. # 评估模型在数据集上的准确率
79. def evaluate_accuracy(net, data_iter):
80.     if isinstance(net, torch.nn.Module):
81.         net.eval()
82.     metric = Accumulator(2)
83.     with torch.no_grad():
84.         for X, y in data_iter:
85.             metric.add(accuracy(net(X), y), y.numel())
86.     return metric[0] / metric[1]
89. # 单个 epoch 的训练
90. def train_epoch_ch3(net, train_iter, loss, updater):
91.     if isinstance(net, torch.nn.Module):
92.         net.train()
93.     metric = Accumulator(3)
94.     # 使用 tqdm 添加进度条
95.     for X, y in tqdm(train_iter, desc="Training"):
96.         y_hat = net(X)
97.         l = loss(y_hat, y)
98.         if isinstance(updater, torch.optim.Optimizer):
99.             updater.zero_grad()
100.             l.mean().backward()
101.             updater.step()
102.         else:
103.             l.sum().backward()
104.             updater(X.shape[0])
105.         metric.add(float(l.sum()), accuracy(y_hat, y), y.numel())
106.     return metric[0] / metric[2], metric[1] / metric[2]
109. # 绘制动画的类
110. class Animator:
111.     def __init__(self, xlabel=None, ylabel=None, legend=None, xlim=None,
112.                  ylim=None, xscale='linear', yscale='linear',
113.                  fmts=('-', 'm--', 'g-.', 'r:'), figsize=(3.5, 2.5)):
114.         if legend is None:
115.             legend = []
116.         self.xlabel = xlabel
117.         self.ylabel = ylabel
118.         self.legend = legend
119.         self.xlim = xlim
120.         self.ylim = ylim
121.         self.xscale = xscale
122.         self.yscale = yscale
123.         self.fmts = fmts
124.         self.figsize = figsize
125.         self.X, self.Y = [], []
127.     def add(self, x, y):
128.         if not hasattr(y, "__len__"):
129.             y = [y]
130.         n = len(y)
131.         if not hasattr(x, "__len__"):
132.             x = [x] * n
133.         if not self.X:
134.             self.X = [[] for _ in range(n)]
135.         if not self.Y:
136.             self.Y = [[] for _ in range(n)]
137.         for i, (a, b) in enumerate(zip(x, y)):
138.             if a is not None and b is not None:
139.                 self.X[i].append(a)
140.                 self.Y[i].append(b)
142.     def show(self):
143.         plt.figure(figsize=self.figsize)
144.         for x_data, y_data, fmt in zip(self.X, self.Y, self.fmts):
145.             plt.plot(x_data, y_data, fmt)
146.         plt.xlabel(self.xlabel)
147.         plt.ylabel(self.ylabel)
148.         if self.legend:
149.             plt.legend(self.legend)
150.         if self.xlim:
151.             plt.xlim(self.xlim)
152.         if self.ylim:
153.             plt.ylim(self.ylim)
154.         plt.xscale(self.xscale)
155.         plt.yscale(self.yscale)
156.         plt.grid()
157.         plt.show()
160. # 主训练函数
161. def train_ch3(net, train_iter, test_iter, loss, num_epochs, updater):
162.     animator = Animator(xlabel='epoch', xlim=[1, num_epochs], ylim=[0.3, 0.9],
163.                         legend=['train loss', 'train acc', 'test acc'])
164.     for epoch in range(num_epochs):
165.         train_metrics = train_epoch_ch3(net, train_iter, loss, updater)
166.         test_acc = evaluate_accuracy(net, test_iter)
167.         animator.add(epoch + 1, train_metrics + (test_acc,))
168.         print(f"Epoch {epoch + 1}: Train Metrics = {train_metrics}, Test Acc = {test_acc}")
169.     train_loss, train_acc = train_metrics
171.     animator.show()  # 展示最终结果图
174. # 主程序
175. if __name__ == "__main__":
176.     # 参数设置
177.     num_epochs, lr, batch_size = 10, 0.5, 256
178.     num_inputs, num_outputs, num_hiddens1, num_hiddens2 = 784, 10, 256, 256
180.     # 加载数据
181.     train_iter, test_iter = load_data_fashion_mnist(batch_size)
183.     # 定义模型、损失函数和优化器
184.     net = Net(num_inputs, num_outputs, num_hiddens1, num_hiddens2)
185.     loss = torch.nn.CrossEntropyLoss(reduction='none')
186.     trainer = torch.optim.SGD(net.parameters(), lr=lr)
188.     # 开始训练
189.     train_ch3(net, train_iter, test_iter, loss, num_epochs, trainer)

复制代码

扔一个简化版：

1. import torch
2. from torch import nn
3. from package import load_data_fashion_mnist, train_ch3
6. # 定义 Dropout 层
7. def dropout_layer(X, dropout):
8.     assert 0 <= dropout <= 1
9.     if dropout == 1:
10.         return torch.zeros_like(X)
11.     if dropout == 0:
12.         return X
13.     mask = (torch.rand(X.shape) > dropout).float()
14.     return mask * X / (1.0 - dropout)
17. # 定义神经网络（复杂版）
18. class Net(torch.nn.Module):
19.     def __init__(self, num_inputs, num_outputs, num_hiddens1, num_hiddens2, is_training=True):
20.         super(Net, self).__init__()
21.         self.num_inputs = num_inputs
22.         self.training = is_training
23.         self.lin1 = torch.nn.Linear(num_inputs, num_hiddens1)
24.         self.lin2 = torch.nn.Linear(num_hiddens1, num_hiddens2)
25.         self.lin3 = torch.nn.Linear(num_hiddens2, num_outputs)
26.         self.relu = torch.nn.ReLU()
28.     def forward(self, X):
29.         H1 = self.relu(self.lin1(X.reshape((-1, self.num_inputs))))
30.         if self.training:
31.             H1 = dropout_layer(H1, dropout=0.2)
32.         H2 = self.relu(self.lin2(H1))
33.         if self.training:
34.             H2 = dropout_layer(H2, dropout=0.5)
35.         return self.lin3(H2)  # 输出层不需要激活函数
38. # 定义神经网络（简化版）
39. class Net_Simple(nn.Module):
40.     def __init__(self, num_inputs, num_outputs, num_hiddens1, num_hiddens2):
41.         super(Net_Simple, self).__init__()
42.         self.net = nn.Sequential(
43.             nn.Flatten(),
44.             nn.Linear(num_inputs, num_hiddens1),
45.             nn.ReLU(),
46.             nn.Dropout(0.2),
47.             nn.Linear(num_hiddens1, num_hiddens2),
48.             nn.ReLU(),
49.             nn.Dropout(0.5),
50.             nn.Linear(num_hiddens2, num_outputs)
51.         )
53.     def forward(self, X):
54.         return self.net(X)
57. # 权重初始化函数
58. def init_weights(m):
59.     if type(m) == nn.Linear:
60.         nn.init.normal_(m.weight, std=0.01)
63. # 主程序
64. if __name__ == "__main__":
65.     # 参数设置
66.     num_epochs, lr, batch_size = 10, 0.5, 256
67.     num_inputs, num_outputs, num_hiddens1, num_hiddens2 = 784, 10, 256, 256
69.     # 加载数据
70.     train_iter, test_iter = load_data_fashion_mnist(batch_size)
72.     # 定义复杂模型、损失函数和优化器
73.     net = Net(num_inputs, num_outputs, num_hiddens1, num_hiddens2)
74.     loss = nn.CrossEntropyLoss(reduction='none')
75.     trainer = torch.optim.SGD(net.parameters(), lr=lr)
77.     # 开始训练复杂模型
78.     print("Training complex model...")
79.     train_ch3(net, train_iter, test_iter, loss, num_epochs, trainer)
81.     print("===========================================================")
83.     # 定义简化模型、损失函数和优化器
84.     net_simple = Net_Simple(num_inputs, num_outputs, num_hiddens1, num_hiddens2)
85.     net_simple.apply(init_weights)  # 初始化权重
86.     loss = nn.CrossEntropyLoss(reduction='none')
87.     trainer = torch.optim.SGD(net_simple.parameters(), lr=lr)
89.     # 开始训练简化模型
90.     print("Training simple model...")
91.     train_ch3(net_simple, train_iter, test_iter, loss, num_epochs, trainer)

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

继续阅读请点击广告