24.Dropout代码实现

在深度学习中，过拟合是一个常见的问题。为了解决这个问题，研究者们提出了许多技术，其中Dropout是一种非常有效的方法。Dropout通过在训练过程中随机将网络中的神经元“关闭”或“丢弃”，来防止模型对训练数据的过度拟合。本文将通过一个简单的PyTorch代码示例，演示如何使用Dropout来防止过拟合。

import torch  
import torch.nn as nn  
import torch.optim as optim  
import matplotlib.pyplot as plt  
  
# 设置随机种子以确保结果可复现  
torch.manual_seed(0)  
  
# 超参数  
num_samples = 20  
num_features = 1  
num_hidden = 200  
num_epochs = 500  
dropout_p = 0.5  
  
# 生成数据  
X_train = torch.linspace(-1, 1, num_samples).view(-1, num_features)  
Y_train = X_train + 0.2 * torch.randn(X_train.size())  
  
# 准备测试集（这里为了简单起见，我们使用训练集作为测试集）  
X_test = X_train  
Y_test = Y_train  
  
# 绘制数据点  
plt.scatter(X_train.numpy(), Y_train.numpy(), c='red', label='Training Data')  
plt.legend()  
plt.show()  
  
# 定义不带Dropout的模型  
class NetWithoutDropout(nn.Module):  
    def __init__(self):  
        super(NetWithoutDropout, self).__init__()  
        self.fc1 = nn.Linear(num_features, num_hidden)  
        self.fc2 = nn.Linear(num_hidden, num_hidden)  
        self.fc3 = nn.Linear(num_hidden, 1)  
  
    def forward(self, x):  
        x = torch.relu(self.fc1(x))  
        x = torch.relu(self.fc2(x))  
        x = self.fc3(x)  
        return x  
  
model_without_dropout = NetWithoutDropout()  
  
# 定义带Dropout的模型  
class NetWithDropout(nn.Module):  
    def __init__(self, dropout_p):  
        super(NetWithDropout, self).__init__()  
        self.fc1 = nn.Linear(num_features, num_hidden)  
        self.dropout = nn.Dropout(dropout_p)  
        self.fc2 = nn.Linear(num_hidden, num_hidden)  
        self.fc3 = nn.Linear(num_hidden, 1)  
  
    def forward(self, x):  
        x = torch.relu(self.fc1(x))  
        x = self.dropout(x)  # 在第一层ReLU后应用Dropout  
        x = torch.relu(self.fc2(x))  
        x = self.dropout(x)  # 在第二层ReLU后应用Dropout  
        x = self.fc3(x)  
        return x  
  
model_with_dropout = NetWithDropout(dropout_p)  
  
# 损失函数和优化器  
criterion = nn.MSELoss()  
optimizer_without_dropout = optim.Adam(model_without_dropout.parameters(), lr=0.01)  
optimizer_with_dropout = optim.Adam(model_with_dropout.parameters(), lr=0.01)  
  
# 训练函数  
def train_model(model, optimizer, X_train, Y_train, num_epochs):  
    for epoch in range(num_epochs):  
        # 前向传播  
        outputs = model(X_train)  
        loss = criterion(outputs, Y_train)  
          
        # 反向传播和优化  
        optimizer.zero_grad()  
        loss.backward()  
        optimizer.step()  
          
        if (epoch+1) % 100 == 0:  
            print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item()}')  
  
# 训练不带Dropout的模型  
train_model(model_without_dropout, optimizer_without_dropout, X_train, Y_train, num_epochs)  
  
# 训练带Dropout的模型  
train_model(model_with_dropout, optimizer_with_dropout, X_train, Y_train, num_epochs)  
  
# 预测函数  
def predict(model, X_test):  
    with torch.no_grad():  
        outputs = model(X_test)  
    return outputs.numpy()  
  
# 预测不带Dropout的模型  
predictions_without_dropout = predict(model_without_dropout, X_test)  
  
# 预测带Dropout的模型  
model_with_dropout.eval()  
predictions_with_dropout = predict(model_with_dropout, X_test)  
  

# 绘制预测结果  
plt.scatter(X_train.numpy(), Y_train.numpy(), c='red', label='Training Data')  
plt.plot(X_test.numpy(), predictions_without_dropout.flatten(), color='blue', label='Without Dropout')  
plt.plot(X_test.numpy(), predictions_with_dropout.flatten(), color='green', label='With Dropout')  
plt.legend()  
plt.show()  
  
# 清理资源（如果需要在Jupyter Notebook等环境中）  
# torch.cuda.empty_cache()  # 如果你使用了GPU并且想要释放GPU内存

在这个例子中，我们使用了简单的线性数据来模拟回归问题，并且使用了MSE（均方误差）作为损失函数。在训练过程中，我们分别训练了两个模型，一个没有使用Dropout，另一个在每个隐藏层后使用了Dropout。最后，我们通过绘制训练数据和模型预测的结果来可视化两个模型的性能。