暂退法及代码

一、暂退法与过拟合

1、好的模型需要对输入的数据的扰动具有鲁棒性（抗干扰能力）

2、使用有噪音的数据等价于Tikhonov正则，丢弃法其实是一个正则，正则都是为了使权重不要过大，使训练过拟合

3、有噪音训练会出现过拟合，但加入随机扰动可以防止过拟合。数据自带的噪音可能存在偏好，加入随机噪音后，能把这种偏好抵消一些。

4、丢弃法（暂退法）就是在层之间加入噪音

二、无偏差加入噪音

要保持前后期望E不变

三、使用丢弃法

1、通常将丢弃法作用在隐藏层

2、超参数与作用式

3、正则式只在训练中使用，用于控制w超参数范围来限制模型的复杂度，防止过拟合。

在预测中，不进行训练时，直接返回不做丢弃：即一旦模型训练完成，并且在测试集上验证模型的性能后，我们希望使用模型进行实际的预测或应用。在这个阶段，不再需要使用正则化来限制模型的复杂度，因为我们关心的是模型在新数据上的预测能力。

四、总结

• 暂退法在前向传播过程中，计算每一内部层的同时丢弃一些神经元。

• 暂退法可以避免过拟合，它通常与控制权重向量的维数和大小结合使用的。

• 暂退法将活性值ℎ替换为具有期望值ℎ的随机变量。

五、代码

def dropout_layer(X, dropout):
    assert 0 <= dropout <= 1
    # 在本情况中，所有元素都被丢弃
    if dropout == 1:
        return torch.zeros_like(X)
    # 在本情况中，所有元素都被保留
    if dropout == 0:
        return X
    #bool类型的矩阵0、1，再转化为float类型，这样就能随机使一些元素置为0
    mask = (torch.rand(X.shape) > dropout).float()
    return mask * X / (1.0 - dropout)

1、测试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.))

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

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

3、定义模型

dropout1, dropout2 = 0.2, 0.5

class 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_inputs
        self.training = is_training
        self.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))))
        # 只有在训练模型时才使用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)

4、训练和测试

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)

六、简洁实现

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);