项目任务：运用残差网络模型来识别手写数字
代码实现：
import torch
print(torch.__version__)
from torch import nn
from torch.utils.data import DataLoader
from torchvision import datasets
from torchvision.transforms import ToTensor
training_data = datasets.MNIST(root='data',train=True,download=True,transform=ToTensor())
test_data = datasets.MNIST(root='data',train=False,download=True,transform=ToTensor())
train_dataloader = DataLoader(training_data,batch_size=64)
test_dataloader = DataLoader(test_data,batch_size=64)
for X,y in test_dataloader:
print(f"Shape of X[N,C,H,W]:{X.shape}")
print(f"Shape of y: {y.shape} {y.dtype}")
break
device = 'cuda' if torch.cuda.is_available() else 'mps' if torch.backends.mps.is_available() else 'cpu'
print(f"Using {device} device")
import torch
import torch.nn as nn
import torch.nn.functional as F
# 残差块定义
class ResBlock(nn.Module):
def __init__(self, channels_in):
super().__init__()
self.conv1 = torch.nn.Conv2d(channels_in,30, kernel_size=5, padding=2)
self.conv2 = torch.nn.Conv2d(30, channels_in, kernel_size=3, padding=1)
def forward(self, x):
out = self.conv1(x)
out = self.conv2(out)
return F.relu(out + x) # 残差连接（out + 输入x）
# ResNet网络定义
class ResNet(nn.Module):
def __init__(self):
super().__init__()
self.conv1 = torch.nn.Conv2d(1,20,5)
self.conv2 = torch.nn.Conv2d(20,15,3)
self.maxpool = torch.nn.MaxPool2d(2)
self.resblock1 = ResBlock(channels_in=20) # 第一个残差块
self.resblock2 = ResBlock(channels_in=15) # 第二个残差块
self.full_c = torch.nn.Linear(375, 10) # 全连接层（输出维度10，对应10分类）
def forward(self, x):
size = x.shape[0] # 获取批次大小
# 第一段卷积+池化+残差块
x = F.relu(self.maxpool(self.conv1(x)))
x = self.resblock1(x)
# 第二段卷积+池化+残差块
x = F.relu(self.maxpool(self.conv2(x)))
x = self.resblock2(x)
# 展平后送入全连接层
x = x.view(size, -1)
x = self.full_c(x)
return x
model = ResNet().to(device)
def train(dataloader,model,loss_fn,optimizer):
model.train()
batch_size_num = 1
for 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()
loss_value = loss.item()
if batch_size_num % 100 ==0:
print(f"loss:{loss_value:>7f} [number:{batch_size_num}]")
batch_size_num +=1
best_acc=0
def test(dataloader,model,loss_fn):
global best_acc
size = len(dataloader.dataset)
num_batches= len(dataloader)
model.eval()
test_loss = 0
correct = 0
with 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_pj_loss = test_loss / num_batches
test_acy = correct / size * 100
print(f"Avg loss: {test_pj_loss:>7f} \n Accuray: {test_acy:>5.2f}%")
if correct > best_acc:
best_acc = correct
# 保存模型的状态字典，而非整个模型
torch.save(model.state_dict(), 'best.pth') # 重点修改这里
print(f"保存最佳模型，准确率: {test_acy:>5.2f}%")
else:
print(f"保存最佳模型，准确率: {test_acy:>5.2f}%")
loss_fn = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(),lr=0.001)
# train(train_dataloader,model,loss_fn,optimizer)
# test(test_dataloader,model,loss_fn)
i=10
for j in range(i):
print(f"Epoch {j+1}\n----------")
train(train_dataloader, model,loss_fn,optimizer)
test(test_dataloader,model,loss_fn)这段代码是一个基于 PyTorch 实现的残差网络（ResNet），用于训练和测试 MNIST 手写数字识别任务。下面对代码进行解析：
1. 库导入与数据集准备
import torch
print(torch.__version__) # 打印PyTorch版本
from torch import nn # 神经网络模块
from torch.utils.data import DataLoader # 数据加载工具
from torchvision import datasets # 计算机视觉数据集
from torchvision.transforms import ToTensor # 图像转张量的转换工具
导入了 PyTorch 核心库、神经网络模块、数据加载工具，以及处理 MNIST 数据集的相关工具。
ToTensor()用于将图像（PIL 格式）转换为 PyTorch 张量，并自动将像素值归一化到[0, 1]范围。
# 加载MNIST训练集和测试集
training_data = datasets.MNIST(
root='data', # 数据保存路径
train=True, # 训练集
download=True, # 若本地无数据则自动下载
transform=ToTensor() # 应用转换
)
test_data = datasets.MNIST(
root='data',
train=False, # 测试集
download=True,
transform=ToTensor()
)
MNIST 是经典的手写数字数据集，包含 60000 张训练图和 10000 张测试图，每张图是 28x28 的灰度图（单通道），标签为 0-9 的数字。
# 数据加载器（按批次加载数据，方便批量训练）
train_dataloader = DataLoader(training_data, batch_size=64) # 训练集批次大小64
test_dataloader = DataLoader(test_data, batch_size=64) # 测试集批次大小64
DataLoader将数据集按batch_size分批，支持自动打乱数据、多线程加载等功能，是训练中高效读取数据的工具。
# 打印数据形状，验证数据格式
for X, y in test_dataloader:
print(f"Shape of X[N,C,H,W]: {X.shape}") # 输入图像形状
print(f"Shape of y: {y.shape} {y.dtype}") # 标签形状和类型
break
输出示例：X[N,C,H,W]中，N=64（批次大小）、C=1（单通道灰度图）、H=28、W=28（图像尺寸）；y是长度为 64 的标签（类型为long，适合分类任务）。
2. 设备配置
# 自动选择训练设备（优先GPU，其次苹果芯片，最后CPU）
device = 'cuda' if torch.cuda.is_available() else 'mps' if torch.backends.mps.is_available() else 'cpu'
print(f"Using {device} device")
深度学习训练通常需要 GPU 加速，这里自动检测并选择可用的加速设备，最大化训练效率。
3. 残差网络（ResNet）定义
残差网络的核心是残差块（Residual Block），通过 “跳跃连接”（将输入直接加到输出）缓解深层网络的梯度消失问题。
3.1 残差块（ResBlock）
class ResBlock(nn.Module):
def __init__(self, channels_in):
super().__init__()
# 第一个卷积层：输入通道数→30，5x5卷积核，padding=2（保持尺寸）
self.conv1 = torch.nn.Conv2d(channels_in, 30, kernel_size=5, padding=2)
# 第二个卷积层：30→输入通道数，3x3卷积核，padding=1（保持尺寸）
self.conv2 = torch.nn.Conv2d(30, channels_in, kernel_size=3, padding=1)
def forward(self, x):
out = self.conv1(x) # 第一次卷积
out = self.conv2(out) # 第二次卷积
return F.relu(out + x) # 残差连接（输出+输入）+ ReLU激活
残差块的关键是out + x：将输入x直接加到卷积后的输出out上，实现 “跳跃连接”，确保梯度能有效回传。
卷积层的padding设置保证了输入和输出的尺寸一致，才能进行加法操作。
3.2 完整 ResNet 网络
class ResNet(nn.Module):
def __init__(self):
super().__init__()
# 第一层卷积：输入1通道（灰度图）→20通道，5x5卷积核
self.conv1 = torch.nn.Conv2d(1, 20, 5)
# 第二层卷积：20通道→15通道，3x3卷积核
self.conv2 = torch.nn.Conv2d(20, 15, 3)
self.maxpool = torch.nn.MaxPool2d(2) # 2x2最大池化（尺寸减半）
self.resblock1 = ResBlock(channels_in=20) # 第一个残差块（输入20通道）
self.resblock2 = ResBlock(channels_in=15) # 第二个残差块（输入15通道）
self.full_c = torch.nn.Linear(375, 10) # 全连接层（输出10类，对应0-9）
def forward(self, x):
size = x.shape[0] # 获取批次大小（用于后续展平操作）
# 第一段：卷积→池化→激活→残差块
x = F.relu(self.maxpool(self.conv1(x))) # conv1→池化（尺寸减半）→ReLU
x = self.resblock1(x) # 经过第一个残差块
# 第二段：卷积→池化→激活→残差块
x = F.relu(self.maxpool(self.conv2(x))) # conv2→池化（尺寸减半）→ReLU
x = self.resblock2(x) # 经过第二个残差块
# 展平特征图→全连接层输出
x = x.view(size, -1) # 展平为(batch_size, 特征数)，这里特征数为375
x = self.full_c(x) # 输出10类的预测概率（未经过softmax）
return x
网络整体流程：输入图像→卷积层提取特征→池化层降维→残差块增强特征→全连接层输出分类结果。
x.view(size, -1)将卷积后的三维特征图（batch, channel, height, width）展平为二维张量（batch, 特征数），才能输入全连接层。
全连接层输入维度375是根据前面的特征图尺寸计算的（具体为：经过多次卷积和池化后，特征图尺寸为 5x5，通道数 15，5×5×15=375）。
4. 模型初始化
model = ResNet().to(device) # 实例化模型，并移动到之前选择的设备（GPU/CPU）
5. 训练与测试函数
5.1 训练函数（train）
def train(dataloader, model, loss_fn, optimizer):
model.train() # 设置模型为训练模式（启用dropout、批归一化更新等）
batch_size_num = 1 # 批次计数器
for 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() # 更新参数
# 每100个批次打印一次损失
loss_value = loss.item()
if batch_size_num % 100 == 0:
print(f"loss: {loss_value:>7f} [number: {batch_size_num}]")
batch_size_num += 1
核心流程：前向传播计算预测→计算损失→反向传播求梯度→优化器更新参数。
model.train()：启用训练模式（例如，若有 dropout 层会随机丢弃神经元）。
5.2 测试函数（test）
best_acc = 0 # 记录最佳准确率
def test(dataloader, model, loss_fn):
global best_acc # 引用全局变量
size = len(dataloader.dataset) # 测试集总样本数
num_batches = len(dataloader) # 测试集批次数
model.eval() # 设置模型为评估模式（关闭dropout等）
test_loss = 0 # 总测试损失
correct = 0 # 正确分类的样本数
with 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_pj_loss = test_loss / num_batches
test_acy = correct / size * 100
print(f"Avg loss: {test_pj_loss:>7f} \n Accuracy: {test_acy:>5.2f}%")
# 保存准确率最高的模型
if correct > best_acc:
best_acc = correct
torch.save(model.state_dict(), 'best.pth') # 保存模型参数（而非整个模型）
print(f"保存最佳模型，准确率: {test_acy:>5.2f}%")
else:
print(f"当前准确率未超过最佳，最佳准确率: {best_acc/size*100:>5.2f}%")
核心作用：评估模型在测试集上的性能（损失和准确率），并保存表现最好的模型。
model.eval()：切换到评估模式（例如，关闭 dropout，固定批归一化参数）。
with torch.no_grad()：关闭梯度计算，减少内存占用，加速测试过程。
模型保存用model.state_dict()：仅保存参数（权重和偏置），而非整个模型结构，更轻量且灵活。
6. 训练配置与执行
loss_fn = nn.CrossEntropyLoss() # 交叉熵损失（适合分类任务，内置softmax）
optimizer = torch.optim.Adam(model.parameters(), lr=0.001) # Adam优化器，学习率0.001
# 训练10个epoch
epochs = 10
for j in range(epochs):
print(f"Epoch {j+1}\n----------")
train(train_dataloader, model, loss_fn, optimizer) # 训练一轮
test(test_dataloader, model, loss_fn) # 测试一轮
CrossEntropyLoss：适用于多分类任务，自动对输出进行 softmax 处理，并计算与标签的交叉熵。
Adam：一种常用的优化器，结合了动量和自适应学习率，收敛速度快且稳定。
epoch：完整遍历一次训练集的次数，这里设置为 10 次，每次训练后测试模型性能。
总结
这段代码实现了一个简化版的残差网络，用于 MNIST 手写数字识别。核心亮点包括：
使用残差块解决深层网络梯度消失问题；
完整的训练 - 测试流程（含设备自动选择、损失计算、参数更新、模型保存）；
符合 PyTorch 最佳实践（如train()/eval()模式切换、torch.no_grad()关闭梯度等）。
通过训练，模型通常能达到 98% 以上的准确率，残差结构相比普通卷积网络能更高效地学习特征。