一、神经网络构建
1.nn.Module：网络构建的基石
概念 ：
nn.Module是所有神经网络模块的基类，我们自定义的网络都需要继承这个类。
DNN代码实现：
class DNN(nn.Module):
def init(self):
super(DNN, self).init() #继承初始化
# 定义网络层
self.net = nn.Sequential( #按顺序搭建各层
nn.Linear(5,3), nn.ReLU(),
nn.Linear(3,9), nn.ReLU()
)
def forward(self, x):
# 定义前向传播
self.net (x)
return x
CNN代码实现：
class CNN(nn.Module):
def init(self, num_classes=10):
super(CNN, self).init()
# 卷积层序列self.net = nn.Sequential(
# 第一个卷积块
nn.Conv2d(1, 32, 3, padding=1), # 输入1通道，输出32通道，3x3卷积
nn.ReLU(),
nn.MaxPool2d(2),
# 第二个卷积块
nn.Conv2d(32, 64, 3, padding=1),
nn.ReLU(),
nn.MaxPool2d(2),
# 第三个卷积块nn.Conv2d(64, 128, 3, padding=1),
nn.ReLU(),
nn.MaxPool2d(2)
)
def forward(self, x):
# 定义前向传播
x = self.net(x)
return x
二、损失函数与优化器
1.损失函数
分类任务：
import torch.nn as nn
# 交叉熵损失（多分类）
criterion_ce = nn.CrossEntropyLoss()
# 二元交叉熵（二分类）
criterion_bce = nn.BCEWithLogitsLoss()
# 多标签分类
criterion_multilabel = nn.MultiLabelSoftMarginLoss()
回归任务：
# 均方误差
criterion_mse = nn.MSELoss()
# 平均绝对误差
criterion_mae = nn.L1Loss()
# 平滑L1损失
criterion_smoothl1 = nn.SmoothL1Loss()
2.优化器选择
常用优化器：
import torch.optim as optim
# SGD with Momentum
optimizer_sgd = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)
# Adam优化器
optimizer_adam = optim.Adam(model.parameters(), lr=0.001, betas=(0.9, 0.999))
# RMSprop
optimizer_rms = optim.RMSprop(model.parameters(), lr=0.01, alpha=0.99)
# Adagrad
optimizer_ada = optim.Adagrad(model.parameters(), lr=0.01)
三、完整训练流程
1.模型训练
def train_model(model, train_loader, val_loader, criterion, optimizer, epochs=10):
# 记录训练过程train_losses = \[\]
val_accuracies = \[\]
# 设备选择(CPU / GPU)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model.to(device)
for epoch in range(epochs):
# 训练阶段
model.train()
running_loss = 0.0**#记录损失变化的列表**
correct = 0
total = 0
for batch_idx, (data, target) in enumerate(train_loader):
data, target = data.to(device), target.to(device)
# 前向传播
output = model(data)
loss = criterion(output, target)
# 反向传播
optimizer.zero_grad()
loss.backward()
optimizer.step()
# 统计信息running_loss += loss.item()
_, predicted = output.max(1)
total += target.size(0)
correct += predicted.eq(target).sum().item()
# 每100个batch打印一次
if batch_idx % 100 == 99:
print(f'Epoch: {epoch+1}, Batch: {batch_idx+1}, '
f'Loss: {loss/100:.4f}, '
f'Acc: {100.*correct/total:.2f}%')
running_loss = 0.0
# 验证阶段val_acc = evaluate_model(model, val_loader, device)
val_accuracies.append(val_acc)
print(f'Epoch {epoch+1}/{epochs} completed. Validation Accuracy: {val_acc:.2f}%')
return train_losses, val_accuracies
2.模型评估
def evaluate_model(model, test_loader, device=None):
if device is None:
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model.eval() # 设置评估模式（关闭dropout等）
correct = 0
total = 0
with torch.no_grad(): # 暂时禁用梯度计算，节省内存
for data, target in test_loader:
data, target = data.to(device), target.to(device)
output = model(data)
_, predicted = output.max(1) #获得预测类别
total += target.size(0)
correct += predicted.eq(target).sum().item()
accuracy = 100. * correct / total
return accuracy
四、模型保存与加载
1.保存模型
# 保存整个模型
torch.save(model, 'mymodel.pth')
# 只保存模型参数（推荐）
torch.save(model.state_dict(), 'mymodel_weights.pth')
# 保存训练状态（用于恢复训练）
checkpoint = {
'epoch': epoch,
'model_state_dict': model.state_dict(),
'optimizer_state_dict': optimizer.state_dict(),
'loss': loss,
'accuracy': accuracy
}
torch.save(checkpoint, 'checkpoint.pth')
2.加载模型
# 加载整个模型
model = torch.load('mymodel.pth ')
model.eval()
# 加载模型参数
model = CIFAR10_CNN()
model.load_state_dict(torch.load('mymodel_weights.pth '))
model.eval()
# 恢复训练
checkpoint = torch.load('checkpoint.pth ')
model.load_state_dict(checkpoint'model_state_dict')
optimizer.load_state_dict(checkpoint'optimizer_state_dict')
epoch = checkpoint'epoch'
loss = checkpoint'loss'
总结
本文介绍了PyTorch神经网络构建与训练的核心流程。首先阐述了如何通过继承nn.Module基类构建DNN和CNN网络，包括网络结构定义和前向传播实现。其次详细说明了不同任务（分类/回归）适用的损失函数，以及SGD、Adam等优化器的选择。然后展示了完整的训练流程，涵盖设备选择、训练循环、验证评估等关键步骤。最后讲解了模型保存与加载的多种方式，包括完整模型保存、参数保存和训练状态恢复。全文提供了可复用的代码模板，涵盖了PyTorch模型开发的核心技术要点。