17 KiB
17 KiB
深度学习的实现
在Pytorch中实现
import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import transforms
from torchvision import datasets
from torch.utils.data import DataLoader
import warnings
# 数据加载与预处理
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081,))
])
train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
test_dataset = datasets.MNIST(root='./data', train=False, transform=transform)
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True, num_workers=4, pin_memory=True)
test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False, num_workers=4, pin_memory=True)
class MNISTCNN(nn.Module):
def __init__(self):
super().__init__()
self.conv_layers = nn.Sequential(
nn.Conv2d(1, 32, 3, padding=1),
nn.ReLU(inplace=True),
nn.MaxPool2d(2),
nn.Conv2d(32, 64, 3, padding=1),
nn.ReLU(inplace=True),
nn.MaxPool2d(2),
)
self.fc_layers = nn.Sequential(
nn.Linear(64 * 7 * 7, 128),
nn.ReLU(inplace=True),
nn.Dropout(0.5),
nn.Linear(128, 10)
)
def forward(self, x):
x = self.conv_layers(x)
x = x.view(x.size(0), -1)
return self.fc_layers(x)
model = MNISTCNN().to('cuda')
optimizer = optim.AdamW(model.parameters(), lr=0.001, weight_decay=0.0001)
loss_fn = nn.CrossEntropyLoss(reduction='mean')
num_epochs = 10
for epoch in range(num_epochs):
model.train()
train_loss = 0.0
for images, labels in train_loader:
images, labels = images.to('cuda'), labels.to('cuda')
optimizer.zero_grad()
outputs = model(images)
loss = loss_fn(outputs, labels)
loss.backward()
optimizer.step()
train_loss += loss.item() * images.size(0)
avg_train_loss = train_loss / len(train_dataset)
# 验证
model.eval()
correct = 0
total = 0
with torch.no_grad():
for images, labels in test_loader:
images, labels = images.to('cuda'), labels.to('cuda')
outputs = model(images)
_, predicted = torch.max(outputs, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
test_acc = 100 * correct / total
print(f'Epoch {epoch+1}/{num_epochs} | Train Loss: {avg_train_loss:.4f} | Test Acc: {test_acc:.2f}%')
torch.save(model.state_dict(), 'mnist_cnn_model.pth')
print("Saved CNN model state!")
在Pytorch中实现深度学习需要以下步骤：
数据准备->模型定义->定义优化器 & 损失函数->模型训练（自动/自定义）->模型评估->保存 & 部署
模型定义
基础定义模板
import torch
import torch.nn as nn
class MyModel(nn.Module):
def __init__(self):
super(MyModel, self).__init__() # 必须调用父类构造函数
# 在这里定义网络层
self.layer1 = nn.Linear(in_features=784, out_features=256)
self.layer2 = nn.Linear(256, 10)
self.relu = nn.ReLU()
def forward(self, x):
# 定义前向传播逻辑
x = self.relu(self.layer1(x))
x = self.layer2(x)
return x
- 他需要手动定义向前传播逻辑，即
forward函数，并且需要手动调用父类的构造函数super(MyModel, self).__init__() nn.Module是所有神经网络模块的基类，我们自己的模型需要继承这个类，并且实现forward函数nn.Linear是全连接层，in_features是输入特征数，out_features是输出特征数nn.ReLU是激活函数self.layer1 = nn.Linear(in_features=784, out_features=256)表示定义一个全连接层，输入特征数为784，输出特征数为256self.layer2 = nn.Linear(256, 10)表示定义一个全连接层，输入特征数为256，输出特征数为10self.relu = nn.ReLU()表示定义一个激活函数x = self.relu(self.layer1(x))表示先通过layer1层，再通过relu激活函数x = self.layer2(x)表示通过layer2层return x表示返回输出
使用 nn.Sequential 简化模型定义
import torch
import torch.nn as nn
class MyModel(nn.Module):
def __init__(self):
super(MyModel, self).__init__()
self.model = nn.Sequential(
nn.Linear(in_features=784, out_features=256),
nn.ReLU(),
nn.Linear(256, 10)
)
def forward(self, x):
return self.model(x)
nn.Sequential是一个容器，可以将多个层按顺序组合在一起，与tensorflow的tf.keras.Sequential类似self.model = nn.Sequential(nn.Linear(in_features=784, out_features=256), nn.ReLU(), nn.Linear(256, 10))表示定义一个包含两个全连接层和一个激活函数的模型return self.model(x)表示通过self.model模型进行前向传播
在torch中有超过50种类型的层，可以参考官方文档，使用方式都一样，不断的在nn.Module中添加层即可
| 层类型 | 定义参数 | 作用 | 示例代码 | 典型用途 |
|---|---|---|---|---|
| nn.Linear | in_features (输入维度), out_features (输出维度) | 全连接层：对输入数据进行线性变换。 | self.fc = nn.Linear(784, 256) | MLP、全连接网络 |
| nn.Conv2d | in_channels, out_channels, kernel_size, stride=1, padding=0 | 二维卷积层：提取局部特征（图像处理）。 | self.conv1 = nn.Conv2d(3, 64, 3, padding=1) | CNN、图像分类 |
| nn.ReLU | inplace=False (默认) | 非线性激活函数：缓解梯度消失，引入非线性。 | self.relu = nn.ReLU(inplace=True) | 所有神经网络层后 |
| nn.BatchNorm2d | num_features (输出通道数) | 批量归一化：加速训练，稳定梯度。 | self.bn1 = nn.BatchNorm2d(64) | CNN、ResNet |
| nn.MaxPool2d | kernel_size, stride=1, padding=0 | 最大池化：下采样，减少计算量，增加平移不变性。 | self.pool = nn.MaxPool2d(2, 2) | 图像特征提取 |
| nn.Dropout | p=0.5 (丢弃概率，默认0.5) | 随机失活：防止过拟合。 | self.dropout = nn.Dropout(0.5) | MLP、RNN、CNN |
| nn.Embedding | num_embeddings (嵌入维度), input_dim (词汇表大小) | 嵌入层：将离散类别映射为稠密向量。 | self.embedding = nn.Embedding(10000, 128) | NLP、词嵌入 |
| nn.LSTM | input_size, hidden_size, num_layers, batch_first=True | 长短期记忆网络：处理序列数据，捕捉长期依赖。 | self.lstm = nn.LSTM(100, 64, 2, batch_first=True) | 文本分类、时间序列预测 |
| nn.GRU | input_size, hidden_size, num_layers, batch_first=True | 门控循环单元：简化版 LSTM，计算更高效。 | self.gru = nn.GRU(100, 64, 2, batch_first=True) | 类似 LSTM 的应用场景 |
| nn.TransformerEncoderLayer | d_model, nhead, dim_k, dim_v | Transformer 编码器层：自注意力机制，处理序列数据。 | self.encoder_layer = nn.TransformerEncoderLayer(512, 8) | NLP、机器翻译 |
| nn.Upsample | scale_factor (上采样倍数), mode='nearest' | 上采样：图像超分辨率，扩大特征图尺寸。 | self.up = nn.Upsample(scale_factor=2, mode='nearest') | 图像分割、生成模型 |
| nn.ConvTranspose2d | in_channels, out_channels, kernel_size, stride=1, padding=0 | 转置卷积：反卷积操作，用于生成对抗网络（GAN）的输出。 | self.deconv = nn.ConvTranspose2d(64, 3, 3, padding=1) | GAN、图像修复 |
| nn.Softmax | dim=-1 (默认) | 概率分布：将输出转换为分类概率。 | self.softmax = nn.Softmax(dim=1) | 分类任务最终层 |
| nn.CrossEntropyLoss | ignore_index=-1 (可选) | 结合 Softmax 和 Cross-Entropy 的损失函数，用于分类任务。 | criterion = nn.CrossEntropyLoss() | 分类任务（无需手动加 Softmax） |
| nn.MSELoss | 均方误差损失：回归任务。 | criterion = nn.MSELoss() | 回归、坐标预测 |
定义优化器和损失函数
一、定义优化器 (Optimizer) 优化器用于更新模型的参数，常见的算法包括SGD、Adam、RMSProp等。PyTorch的torch.optim模块提供了多种优化器。
- 常用优化器示例
import torch.optim as optim
# 定义优化器
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)
optimizer = optim.Adam(model.parameters(), lr=0.001, betas=(0.9, 0.999))
optimizer = optim.RMSprop(model.parameters(), lr=0.01, alpha=0.99)
- 常用参数说明
| 参数名 | 含义 | 默认值 |
|---|---|---|
| params | 需要优化的参数（通常是model.parameters()） | 必须参数 |
| lr | 学习率（Learning Rate） | 1e-3 |
| momentum | 动量项（仅SGD系列有效） | 0 |
| weight_decay | 权重衰减（L2正则化） | 0 |
| betas | Adam的β1和β2超参数（平衡梯度指数衰减率） | (0.9, 0.99) |
| eps | Adam的极小值防止除零错误 | 1e-8（默认为1e-7） |
二、定义损失函数 (Loss Function) 损失函数用于衡量模型的预测结果与真实标签之间的差异，常见的损失函数包括均方误差损失、交叉熵损失等。PyTorch的torch.nn模块提供了多种损失函数。
- 常用损失函数示例
import torch.nn as nn
# 分类任务（如图像分类）
criterion = nn.CrossEntropyLoss(
reduction='mean' # 可选'mean'或'sum'
)
# 回归任务（如房价预测）
criterion = nn.MSELoss(
reduction='mse' # 可选'mse', 'mae', 'sum', 'mean'
)
- 常用参数说明
- reduction：指定损失函数的归约方式，可选值包括none（不聚合）、sum（求和）、mean（均值）、mse（均方误差）。默认为'mean'。
- weight：指定每个类别的权重，用于加权交叉熵损失。
- ignore_index：指定忽略的类别索引，用于多分类任务。
模型训练
一、自动训练（标准流程）
这是最常见的模式，基于 DataLoader 和 torch.nn 模块的高层抽象实现。
- 核心 API
| API | 作用 | 参数说明 |
|---|---|---|
| torch.utils.data.DataLoader | 数据加载器，封装 Dataset 并分批次加载数据 | dataset: 自定义数据集对象, batch_size: 每次迭代的数据量 |
| model.train() | 将模型切换为训练模式（启用 Dropout/BatchNorm 等训练时行为） | 无参数 |
| optimizer.step() | 执行参数更新（基于梯度） | 无参数 |
| optimizer.zero_grad() | 清空梯度缓存，为下一次反向传播准备 | 无参数 |
| loss.backward() | 反向传播，计算梯度 | retain_graph=True 可保留梯度用于多次反向传播 |
| 2. 代码示例 |
# 定义模型、优化器、损失函数
model = MyModel().to(device)
optimizer = torch.optim.Adam(
params=model.parameters(),
lr=0.001, # 学习率（核心超参数）
betas=(0.9, 0.999), # 动量参数
eps=1e-8, # 数值稳定性保护
weight_decay=0.01 # 权重衰减（正则化）
)
criterion = nn.CrossEntropyLoss()
# 训练循环
for epoch in range(num_epochs):
model.train() # 设置训练模式
for inputs, labels in dataloader: ## 注意dataloader是迭代器，每次迭代返回一个batch的数据
inputs, labels = inputs.to(device), labels.to(device)
# 前向传播
outputs = model(inputs)
loss = criterion(outputs, labels)
# 反向传播 + 参数更新
optimizer.zero_grad() # 清空梯度
loss.backward() # 计算梯度
optimizer.step() # 更新参数
# 打印日志
print(f"Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}")
二、自定义训练（灵活控制）
- 适用于需要特殊逻辑的场景（如动态修改学习率、梯度裁剪、多任务学习等）。
- 扩展功能 API
| API | 作用 | 参数说明 |
|---|---|---|
| torch.optim.lr_scheduler | 学习率调度器（如 StepLR、ReduceLROnPlateau） | optimizer: 优化器对象，step_size调度步长 |
| torch.nn.utils.clip_grad_norm_ | 梯度裁剪，防止爆炸 | parameters: 模型参数,max_norm 最大梯度范数 |
| with torch.no_grad(): | 禁用梯度计算，节省内存（常用于推理或评估） | 无参数 |
| 2. 代码示例 |
# 添加学习率调度器和梯度裁剪
scheduler = torch.optim.StepLR(optimizer, step_size=30, gamma=0.1)
gradient_clip = 5.0
for epoch in range(num_epochs):
model.train()
for inputs, labels in dataloader:
inputs, labels = inputs.to(device), labels.to(device)
# 前向传播
outputs = model(inputs)
loss = criterion(outputs, labels)
# 反向传播 + 梯度裁剪 + 参数更新
optimizer.zero_grad()
loss.backward()
torch.nn.utils.clip_grad_norm_(model.parameters(), gradient_clip)
optimizer.step()
# 动态调整学习率
scheduler.step()
# 验证集评估（自定义逻辑）
if batch_idx % 100 == 0:
validate(model, val_dataloader, criterion)
关键的参数
- DataLoader 参数
DataLoader(
dataset=MyDataset(),
batch_size=64, # 批量大小
shuffle=True, # 训练时打乱数据顺序
num_workers=4, # 多线程加载数据
pin_memory=True # GPU 数据传输加速
)
高级技巧
- 混合精度训练（Mixed Precision Training）
# 混合精度训练
scaler = torch.cuda.amp.GradScaler()
model, optimizer = amp.initialize(model, optimizer, opt_level="O1")
for epoch in range(num_epochs):
model.train()
for inputs, labels in dataloader:
inputs, labels = inputs.to(device), labels.to(device)
# 前向传播
with torch.cuda.amp.autocast():
outputs = model(inputs)
loss = criterion(outputs, labels)
# 反向传播和优化
optimizer.zero_grad()
scaler.scale(loss).backward()
scaler.step(optimizer)
scaler.update()
- 分布式训练（Distributed Training）
# 分布式训练
torch.distributed.init_process_group(backend='nccl')
model = model.to(device)
model = torch.nn.parallel.DistributedDataParallel(model, device_ids=[device])
for epoch in range(num_epochs):
model.train()
for inputs, labels in dataloader:
inputs, labels = inputs.to(device), labels.to(device)
# 前向传播
outputs = model(inputs)
loss = criterion(outputs, labels)
# 反向传播和优化
optimizer.zero_grad()
loss.backward()
optimizer.step()
- 梯度检查点（Gradient Checkpointing）
# 梯度检查点
from torch.utils.checkpoint import checkpoint
for epoch in range(num_epochs):
model.train()
for inputs, labels in dataloader:
inputs, labels = inputs.to(device), labels.to(device)
# 前向传播
def forward(inputs):
return model(inputs)
outputs = checkpoint(forward, inputs)
# 反向传播和优化
optimizer.zero_grad()
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
模型评估
import torch
from sklearn.metrics import classification_report
def run_evaluation(model, test_loader, class_names):
model.eval()
all_preds = []
all_labels = []
with torch.no_grad():
for inputs, labels in test_loader:
outputs = model(inputs)
preds = torch.argmax(outputs, dim=1)
all_preds.extend(preds.cpu().numpy())
all_labels.extend(labels.cpu().numpy())
# 打印报告
print(classification_report(all_labels, all_preds, target_names=class_names))
# 返回字典格式结果
return {
'accuracy': sum(p == l for p, l in zip(all_preds, all_labels)) / len(all_labels),
'classification_report': classification_report(all_labels, all_preds, target_names=class_names)
}
模型保存与加载
# 保存模型
torch.save(model.state_dict(), 'model.pth')
# 加载模型
model = YourModelClass()
model.load_state_dict(torch.load('model.pth'))
model.eval()