冲冲冲😊
here😊

PyTorch多层感知机模型构建与MNIST分类训练笔记

🎯 1. 任务概述

解决MNIST手写数字分类问题，创建一个简单的多层感知机（MLP）模型

• 使用torch.nn.Linear层构建模型
• 使用ReLU作为激活函数
• 包含两个全连接隐藏层（120和84个神经元）和输出层（10个神经元对应10个数字类别）
• 模型输入为展平后的28×28=784像素图像

⚙️ 2. 环境设置

2.1 导入必要库

import torch
from torch import nn
import os

2.2 GPU配置

# os.environ["CUDA_VISIBLE_DEVICES"] = "3,4,6"  # 只使用空闲的GPU

🧠 3. 模型构建

3.1 模型定义关键点

class Model(nn.Module):def __init__(self):super().__init__()# 第一层输入展平后的特征长度28乘28,创建120个神经元self.liner_1 = nn.Linear(28*28, 120)# 第二层输入的是前一层的输出,创建84个神经元self.liner_2 = nn.Linear(120, 84)# 输出层接受第二层的输入84,输出分类个数10self.liner_3 = nn.Linear(84, 10)def forward(self, input):x = input.view(-1, 28*28)  # 将输入展平为二维(1,28,28)->(28*28)x = torch.relu(self.liner_1(x))x = torch.relu(self.liner_2(x))x = self.liner_3(x)return x

📝 模型结构说明：

1. 输入层：将28×28图像展平为784维向量
2. 隐藏层1：120个神经元，使用ReLU激活
3. 隐藏层2：84个神经元，使用ReLU激活
4. 输出层：10个神经元对应10个数字类别

3.2 损失函数选择

loss_fn = nn.CrossEntropyLoss()  # 交叉熵损失函数
'''
注意两个参数
1. weight: 各类别的权重（处理不平衡数据集）
2. ignore_index: 忽略特定类别的索引
另外,它要求实际类别为数值编码,而不是独热编码
'''

🔍 为什么选择交叉熵损失？

• 适用于多分类问题
• 内部集成了Softmax计算，简化实现流程
• 对错误分类有较强的惩罚

3.3 模型初始化与设备选择

device = "cuda" if torch.cuda.is_available() else "cpu"
model = Model().to(device)
# print(device)  # 可选：打印使用的设备

💡 GPU加速提示：
使用.to(device)将模型移动到GPU可显著加快训练速度，特别是对于大模型和大数据集

🔧 4. 优化器配置

4.1 随机梯度下降优化器

optimizer = torch.optim.SGD(model.parameters(), lr=0.005)

🔧 关键参数解析：

• params: 需要优化的模型参数（通常为model.parameters()）
• lr=0.005: 学习率，控制参数更新步长的超参数
• 其他可选参数：momentum（动量），weight_decay（L2正则化）

🔄 5. 训练循环实现

5.1 训练函数设计

def train(dataloader, model, loss_fn, optimizer):size = len(dataloader.dataset)  # 获取当前数据集样本总数量num_batches = len(dataloader)   # 获取当前data loader总批次数# train_loss用于累计所有批次的损失之和, correct用于累计预测正确的样本总数train_loss, correct = 0, 0for X, y in dataloader:X, y = X.to(device), y.to(device)# 进行预测,并计算当前批次的损失pred = model(X)loss = loss_fn(pred, y)# 利用反向传播算法,根据损失优化模型参数optimizer.zero_grad()   # 先将梯度清零loss.backward()          # 损失反向传播,计算模型参数梯度optimizer.step()         # 根据梯度优化参数with torch.no_grad():# correct用于累计预测正确的样本总数correct += (pred.argmax(1) == y).type(torch.float).sum().item()# train_loss用于累计所有批次的损失之和train_loss += loss.item()# train_loss 是所有批次的损失之和,所以计算全部样本的平均损失时需要除以总的批次数train_loss /= num_batches# correct 是预测正确的样本总数,若计算整个epoch总体正确率,需要除以样本总数量correct /= sizereturn train_loss, correct

5.2 测试函数设计

def test(dataloader, model):size = len(dataloader.dataset)num_batches = len(dataloader)test_loss, correct = 0, 0with torch.no_grad():for X, y in dataloader:X, y = X.to(device), y.to(device)pred = model(X)test_loss += loss_fn(pred, y).item()correct += (pred.argmax(1) == y).type(torch.float).sum().item()test_loss /= num_batchescorrect /= sizereturn test_loss, correct

📊 数据加载器相关方法区别：

方法	返回内容	适用场景
len(dataset)	数据集总样本数（如100）	数据统计、划分
len(dataloader)	总批次数（如4）	训练循环控制
len(dataloader.dataset)	等同于 len(dataset)	需要访问原始数据时

📦 6. 数据准备

6.1 加载MNIST数据集

import torchvision
from torchvision.transforms import ToTensortrain_ds = torchvision.datasets.MNIST("data/", train=True, transform=ToTensor(), download=True)
test_ds = torchvision.datasets.MNIST("data/", train=False, transform=ToTensor(), download=True)train_dl = torch.utils.data.DataLoader(train_ds, batch_size=64, shuffle=True)
test_dl = torch.utils.data.DataLoader(test_ds, batch_size=64)

🚀 7. 训练执行

7.1 训练循环主体

# 对全部的数据集训练50个epoch(一个epoch表示对全部数据训练一遍)
epochs = 50 
train_loss, train_acc = [], []
test_loss, test_acc = [], []for epoch in range(epochs):# 调用train()函数训练epoch_loss, epoch_acc = train(train_dl, model, loss_fn, optimizer)# 调用test()函数测试epoch_test_loss, epoch_test_acc = test(test_dl, model)train_loss.append(epoch_loss)train_acc.append(epoch_acc)test_loss.append(epoch_test_loss)test_acc.append(epoch_test_acc)# 定义一个打印模板template = ("epoch:{:2d},train_loss:{:.6f},train_acc:{:.1f}%,""test_loss:{:.5f},test_acc:{:.1f}%")print(template.format(epoch, epoch_loss, epoch_acc*100, epoch_test_loss, epoch_test_acc*100))print("Done")

7.2 训练过程输出（部分）

epoch: 0,train_loss:2.157364,train_acc:46.7%,test_loss:1.83506,test_acc:63.7%
epoch: 1,train_loss:1.222660,train_acc:74.3%,test_loss:0.74291,test_acc:81.8%
epoch: 2,train_loss:0.612381,train_acc:84.0%,test_loss:0.49773,test_acc:86.3%
...
epoch:48,train_loss:0.110716,train_acc:96.9%,test_loss:0.12003,test_acc:96.4%
epoch:49,train_loss:0.108877,train_acc:97.0%,test_loss:0.11783,test_acc:96.5%
Done

📈 训练趋势分析：

• 初始准确率：46.7%（训练集），63.7%（测试集）
• 最终准确率：97.0%（训练集），96.5%（测试集）
• 过拟合现象轻微：训练集和测试集性能差距仅0.5%

📊 8. 结果可视化

8.1 损失曲线绘制

import matplotlib.pyplot as pltplt.plot(range(1, epochs+1), train_loss, label="train_loss")
plt.plot(range(1, epochs+1), test_loss, label="test_loss", ls="--")
plt.xlabel("epoch")
plt.legend()
plt.show()

注释：损失曲线显示训练初期损失快速下降，后期趋于平稳

8.2 准确率曲线绘制

plt.plot(range(1, epochs+1), train_acc, label="train_acc")
plt.plot(range(1, epochs+1), test_acc, label="test_acc")
plt.xlabel("epoch")
plt.legend()
plt.show()

注释：准确率曲线稳步上升，最终达到96.5%的测试准确率