基于PyTorch实现带Dropout的多层感知机(MLP)模型教程-优快云博客

本文链接：https://blog.youkuaiyun.com/gitblog_00224/article/details/148375597

基于PyTorch实现带Dropout的多层感知机(MLP)模型教程

deeplearning-models A collection of various deep learning architectures, models, and tips 项目地址: https://gitcode.com/gh_mirrors/de/deeplearning-models

前言

本教程将介绍如何使用PyTorch框架实现一个带有Dropout正则化的多层感知机(Multilayer Perceptron, MLP)模型。Dropout是一种常用的神经网络正则化技术，能有效防止模型过拟合。我们将使用经典的MNIST手写数字数据集作为示例，展示如何构建、训练和评估这样一个深度学习模型。

环境准备

首先确保已安装以下Python库：

PyTorch (1.0.0或更高版本)
torchvision
numpy

import torch
import torch.nn as nn
import torch.nn.functional as F
from torchvision import datasets, transforms
from torch.utils.data import DataLoader
import numpy as np
import time

数据集准备

我们使用MNIST数据集，它包含60,000张训练图像和10,000张测试图像，每张都是28×28像素的手写数字灰度图。

# 数据转换(将像素值归一化到0-1范围)
transform = transforms.ToTensor()

# 加载训练集和测试集
train_dataset = datasets.MNIST(root='data', 
                             train=True, 
                             transform=transform,
                             download=True)

test_dataset = datasets.MNIST(root='data', 
                            train=False, 
                            transform=transform)

# 创建数据加载器
batch_size = 64
train_loader = DataLoader(dataset=train_dataset, 
                         batch_size=batch_size, 
                         shuffle=True)

test_loader = DataLoader(dataset=test_dataset, 
                        batch_size=batch_size, 
                        shuffle=False)

模型架构设计

我们的MLP模型包含以下组件：

输入层：784个神经元(对应28×28像素)
第一个隐藏层：128个神经元，使用ReLU激活函数
Dropout层：丢弃概率设为0.5
第二个隐藏层：256个神经元，使用ReLU激活函数
Dropout层：丢弃概率设为0.5
输出层：10个神经元(对应10个数字类别)，使用softmax激活函数

class MLPWithDropout(nn.Module):
    def __init__(self, input_size, hidden1_size, hidden2_size, num_classes, dropout_prob):
        super(MLPWithDropout, self).__init__()
        self.fc1 = nn.Linear(input_size, hidden1_size)
        self.fc2 = nn.Linear(hidden1_size, hidden2_size)
        self.fc3 = nn.Linear(hidden2_size, num_classes)
        self.dropout_prob = dropout_prob
        
        # 初始化权重(使用正态分布)
        nn.init.normal_(self.fc1.weight, mean=0.0, std=0.1)
        nn.init.zeros_(self.fc1.bias)
        nn.init.normal_(self.fc2.weight, mean=0.0, std=0.1)
        nn.init.zeros_(self.fc2.bias)
        nn.init.normal_(self.fc3.weight, mean=0.0, std=0.1)
        nn.init.zeros_(self.fc3.bias)
    
    def forward(self, x):
        # 展平输入图像
        x = x.view(-1, 28*28)
        
        # 第一层
        x = self.fc1(x)
        x = F.relu(x)
        x = F.dropout(x, p=self.dropout_prob, training=self.training)
        
        # 第二层
        x = self.fc2(x)
        x = F.relu(x)
        x = F.dropout(x, p=self.dropout_prob, training=self.training)
        
        # 输出层
        logits = self.fc3(x)
        probas = F.softmax(logits, dim=1)
        return logits, probas

模型训练

超参数设置

# 模型参数
input_size = 784    # 28x28
hidden1_size = 128
hidden2_size = 256
num_classes = 10
dropout_prob = 0.5

# 训练参数
random_seed = 1
learning_rate = 0.1
num_epochs = 10

初始化模型和优化器

torch.manual_seed(random_seed)
model = MLPWithDropout(input_size, hidden1_size, hidden2_size, num_classes, dropout_prob)

# 使用GPU如果可用
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
model = model.to(device)

# 使用随机梯度下降优化器
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)

训练循环

def compute_accuracy(model, data_loader, device):
    correct_pred, num_examples = 0, 0
    for features, targets in data_loader:
        features = features.to(device)
        targets = targets.to(device)
        logits, probas = model(features)
        _, predicted_labels = torch.max(probas, 1)
        num_examples += targets.size(0)
        correct_pred += (predicted_labels == targets).sum()
    return correct_pred.float()/num_examples * 100

start_time = time.time()
for epoch in range(num_epochs):
    model.train()
    for batch_idx, (features, targets) in enumerate(train_loader):
        features = features.to(device)
        targets = targets.to(device)
        
        # 前向传播
        logits, probas = model(features)
        cost = F.cross_entropy(logits, targets)
        
        # 反向传播和优化
        optimizer.zero_grad()
        cost.backward()
        optimizer.step()
        
        # 每50个batch打印一次日志
        if not batch_idx % 50:
            print ('Epoch: %03d/%03d | Batch %03d/%03d | Cost: %.4f' 
                   %(epoch+1, num_epochs, batch_idx, len(train_loader), cost))
    
    model.eval()
    with torch.set_grad_enabled(False):
        train_acc = compute_accuracy(model, train_loader, device)
        print('Epoch: %03d/%03d training accuracy: %.2f%%' % (
              epoch+1, num_epochs, train_acc))
    
    print('Time elapsed: %.2f min' % ((time.time() - start_time)/60))

print('Total Training Time: %.2f min' % ((time.time() - start_time)/60))

模型评估

训练完成后，我们可以在测试集上评估模型性能：

model.eval()
with torch.set_grad_enabled(False):
    test_acc = compute_accuracy(model, test_loader, device)
    print('Test accuracy: %.2f%%' % (test_acc))