文章目录
六、数据加载与预处理
在 PyTorch 中，数据加载与预处理是深度学习注中非常重要的一部分，它涉及到将原始数据加载到模型中并进行适当的预处理，以便用于训练和测试。PyTorch 提供了 torch.utils.data 模块来实现数据加载和预处理，同时可以使用 trochvision 提供的一些工具进行常见的图像处理。
数据加载与预处理：
① 数据集的定义
② 数据加载器
③ 预处理与转换
④ 使用预训练模型
⑤ 数据加载与迭代
⑥ 使用预训练模型
1. 数据集的定义
在 PyTorch 中，通常通过创建一个自定义的数据集类来加载数据。自定义数据集需要继承自 torch.utils.data.Dataset，并实现 __len__ 和 __getitem__ 方法。
from torch.utils.data import Dataset
class CustomDataset(Dataset):
def __init__(self, data, labels, transform=None):
self.data = data
self.labels = labels
self.transform = transform
def __len__(self):
return len(self.data)
def __getitem__(self, idx):
sample = {'data': self.data[idx], 'label': self.labels[idx]}
if self.transform:
sample = self.transform(sample)
return sample2. 数据在加载器
数据加载器是 PyTorch 中用于批量加载数据的工具。通过创建一个数据加载器，可以方便地在模型训练中迭代地获取批量数据。
from torch.utils.data import DataLoader
# 创建数据集
dataset = CustomDataset(data, labels, transform=...)
# 创建数据加载器
dataloader = DataLoader(dataset, batch_size=64, shuffle=True)3. 预处理与转换
可以使用 torchvision.transforms 中的预处理函数对数据进行常见的预处理，例如缩放、裁剪、旋转等。
from torchvision import transforms
# 定义转换
transform = transforms.Compose([
transforms.Resize((256, 256)),
transforms.RandomCrop((224, 224)),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
])
# 将转换应用于数据集
dataset = CustomDataset(data, labels, transform=transform)4. 使用预训练模型
如果使用了预训练的模型，可能需要采用与训练时相同的预处理方式。 torchvision.transforms 中也提供了用于预训练模型的一些标准预处理方法。
from torchvision import transforms
# 使用 ImageNet 预训练模型的标准化参数
preprocess = transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])5. 数据加载与迭代
通过数据加载器，可以在训练循环中方便地迭代加载批量的数据。
for batch in dataloader:
inputs, labels = batch['data'], batch['label']
# 进行模型训练七、模型保存与加载
在PyTorch 中，模型的保存与加载是训练深度学习模型中重要的一部分。模型的保存使得可以在训练过程中保存中间结果或在训练结束后保存最终模型，而模型的加载则允许在其他地方或其他时间使用已经训练好的模型。
模型保存与加载：
① 模型的保存
② 模型的加载
③ 跨设备加载模型
④ 保存与加载模型的结构和参数
⑤ 保存与加载模型的结构
⑥ 只保存和加载模型参数
1. 模型的保存
在 PyTorch 中，可以使用 torch.save 函数保存模型的状态字典（state_dict）或整个模型。状态字典包含了模型的参数和其他相关信息。
import torch
import torch.nn as nn
# 定义模型
class SimpleModel(nn.Module):
def __init__(self):
super(SimpleModel, self).__init__()
self.fc = nn.Linear(10, 1)
model = SimpleModel()
# 保存模型的状态字典
torch.save(model.state_dict(), 'model_state.pth')
# 保存整个模型（包括结构和参数）
torch.save(model, 'model.pth')2. 模型的加载
使用 torch.load 函数加载模型的状态字典或整个模型。
# 加载模型的状态字典
loaded_state_dict = torch.load('model_state.pth')
model.load_state_dict(loaded_state_dict)
# 加载整个模型
loaded_model = torch.load('model.pth')3. 跨设备加载模型
如果在训练时使用了GPU，而在加载时想切换到GPU，可以使用 map_location 参数。
# 在 CPU 上加载 GPU 上保存的模型
loaded_model = torch.load('model.pth', map_location=torch.device('cpu'))4. 保存与加载模型的结构和参数
在保存整个模型时，模型的结构和参数都会被保存。
# 保存整个模型（包括结构和参数）
torch.save(model, 'model.pth')
# 加载整个模型
loaded_model = torch.load('model.pth')5. 保存与加载模型的结构
如果只想保存与加载模型的结构而不包含参数，可以使用 torch.save 时设置 save_model_obj = False。
# 保存模型结构
torch.save(model, 'model_structure.pth', save_model_obj=False)
# 加载模型结构
loaded_model_structure = torch.load('model_structure.pth')6. 只保存和加载模型参数
如果只想保存和加载模型参数而不包含模型结构，可以使用 torch.save 时设置 save_model_obj = False。
# 保存模型参数
torch.save(model.state_dict(), 'model_parameters.pth')
# 加载模型参数
loaded_parameters = torch.load('model_parameters.pth')
model.load_state_dict(loaded_parameters)以上是在 PyTorch 中保存与加载模型的基本方法。在实际应用中，还可以结合其他工具，如 torch.optim 优化器状态字典的保存与加载，以便在恢复训练时继续优化过程。
八、学习率调整
在深度学习中，学习率调整是优化算法的关键部分之一。PyTorch 提供了 torch.optim.lr_scheduler 模块来实现各种学习率调整策略。
学习率调整：
① StepLR 学习率调整
② MultiStepLR 学习率调整
③ ExponentialLR 学习率调整
④ CosineAnnealingLR 学习率调整
⑤ LambdaLR 学习率调整
⑥ ReduceLROnPlateau 学习率调整
⑦ 使用学习率调整器
⑧ 学习率调整的参数
1. StepLR 学习率调整
StepLR 是一种简单的学习率调整策略，每经过一定的步数，将学习率按照给定的因子进行衰减。
import torch.optim as optim
from torch.optim import lr_scheduler
# 定义优化器
optimizer = optim.SGD(model.parameters(), lr=0.01)
# 定义学习率调整策略
scheduler = lr_scheduler.StepLR(optimizer, step_size=5, gamma=0.1)
# 在训练循环中使用
for epoch in range(num_epochs):
# 训练模型
...
# 更新学习率
scheduler.step()2. MultiStepLR 学习率调整
MultiStepLR 是在预定义的多个时间点降低学习率的策略。
scheduler = lr_scheduler.MultiStepLR(optimizer, milestones=[10, 20, 30], gamma=0.1)3. ExponentialLR 学习率调整
ExponentialLR 对学习率进行指数衰减。
scheduler = lr_scheduler.ExponentialLR(optimizer, gamma=0.9)4. CosineAnnealingLR 学习率调整
CosineAnnealingLR 使用余弦退火函数来调整学习率。
scheduler = lr_scheduler.CosineAnnealingLR(optimizer, T_max=10)5. LambdaLR 学习率调整
LambdaLR 允许使用任意的学习率调整函数。
scheduler = lr_scheduler.LambdaLR(optimizer, lr_lambda=lambda epoch: 0.95 ** epoch)6. ReduceLROnPlateau 学习率调整
ReduceLROnPlateau 在验证集上监测指标，当指标不再提升时降低学习率。
scheduler = lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=0.1, patience=5, verbose=True)7. 使用学习率调整器
在训练循环中使用学习率调整器。
for epoch in range(num_epochs):
# 训练模型
...
# 更新学习率
scheduler.step(validation_loss) # 如果使用 ReduceLROnPlateau8. 学习率调整的参数
在学习率调整中，有一些参数是常用的：
- optimizer：优化器，可以通过 optim.SGD、optim.Adam 等创建。
- step_size（对于 StepLR 和 MultiStepLR）：学习率衰减的步数。
- gama：学习率衰减的因子。
- milestones（对于 MultiStepLR）：多步学习率衰减的时间点。
- T_max（对于 CosineAnneaLingLR）：一个周期的迭代次数。
- lr_lambda（对于 LambdaLR）：自定义学习率衰减函数。
- mode（对于 ReduceLROnPlateau）：监测指标的模式，可以是‘min’、‘max’ 或 ‘auto’。
选择适当的学习率调整策略对于模型的性能非常关键。在实践中，通常需要进行一些实验以确定最佳的学习率调整策略和参数。
九、模型评估
模型评估是在训练之后对模型性能进行定量评估的过程。评估模型涉及到使用验证集或测试集上的数据进行推理，并计算模型在这些数据上的性能指标，如准确率、精确度、召回率等。
模型评估：
① 设置模型为评估模式
② 使用验证集或测试集进行推理
③ 计算性能指标
④ 混淆矩阵（Confusion Matrix）
⑤ 模型性能可视化
⑥ 完整的评估过程示例
⑦ 注意事项
1. 设置模型为评估模式
在进行模型评估之前，需要将模型切换到评估模式，即使用 eval( ) 方法。这会关闭 Dropout 等训练时使用的一些特定行为。
model.eval()2. 使用验证集或测试集进行推理
通过遍历验证集或测试集，使用模型进行推理。
model.eval()
with torch.no_grad():
for inputs, labels in dataloader:
outputs = model(inputs)
# 进行后续处理...3. 计算性能指标
根据任务类型和需求，选择合适的性能指标进行计算。以下是一些常见的性能指标：
- 准确率（Accuracy）
correct = (predicted == labels).sum().item()
total = labels.size(0)
accuracy = correct / total- 精确度（Precision）
from sklearn.metrics import precision_score
precision = precision_score(labels, predicted, average='weighted')
- 召回率（Recall）
from sklearn.metrics import recall_score
recall = recall_score(labels, predicted, average='weighted')
- F1分数（F1 Score）
from sklearn.metrics import f1_score
f1 = f1_score(labels, predicted, average='weighted')4. 混淆矩阵（Confusion Matrix）
混淆矩阵是一个很有用的工具，可以展示模型在每个类别上的性能。
from sklearn.metrics import confusion_matrix
conf_matrix = confusion_matrix(labels, predicted)5. 模型性能可视化
通过绘制ROC曲线、学习曲线等图表，可以更直观地了解模型的性能。
import matplotlib.pyplot as plt
# 绘制 ROC 曲线等6. 完整的评估过程示例
model.eval()
total_correct = 0
total_samples = 0
with torch.no_grad():
for inputs, labels in dataloader:
outputs = model(inputs)
_, predicted = torch.max(outputs, 1)
total_correct += (predicted == labels).sum().item()
total_samples += labels.size(0)
accuracy = total_correct / total_samples
print(f'Accuracy: {accuracy}')7. 注意事项
- 在评估过程中，确保使用 torch.no_grad( ) 来关闭梯度计算，以减少内存使用和加速推理过程。
- 对于分类问题，使用 Softmax 函数获得类别概率，并选择概率最大的类别作为预测结果。
- 对于不同的任务（分类、回归、目标检测等），选择合适的性能指标进行评估。
以上是在PyTorch 中进行模型评估的基本步骤。具体的评估过程会根据任务的性质和需求而有所不同。
十、GPU加速
在 PyTorch 中，利用 GPU 加速是训练深度学习模型的关键步骤之一。PyTorch 提供了简单而灵活的方式，使用户能够方便地将模型和数据移动到GPU 上进行加速。
GPU 加速：
① 检查 GPU 是否可用
② 将模型移动到 GPU
③ 将张量移动到 GPU
④ 在 GPU 上执行前向传播和反向传播
⑤ 多 GPU 加速
⑥ 在 GPU 上保存和加载模型
⑦ GPU 上的数据并行
⑧ 注意事项
1. 检查 GPU 是否可用
在使用 GPU 加速之前，首先需要检查系统上是否有可用的 GPU 设备。
import torch
# 检查 GPU 是否可用
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print('Using device:', device)2. 将模型移动到 GPU
使用 .to( ) 方法将模型移动到 GPU 上。
model = MyModel() # 自定义模型
model.to(device)3. 将张量移动到 GPU
同样地，使用 .to( ) 方法将张量移动到 GPU 上。
inputs, labels = data # 假设 data 是从数据加载器中获取的一批数据
inputs, labels = inputs.to(device), labels.to(device)4. GPU 上执行前向传播和反向传播
使用 GPU 上的模型进行前向传播和反向传播。
outputs = model(inputs)
loss = criterion(outputs, labels)
optimizer.zero_grad()
loss.backward()
optimizer.step()5. 多 GPU 加速
PyTorch 支持多 GPU 加速，可以使用 torch.nn.DataParallel 封装模型，使其能够并行在多个 GPU 上执行。
model = MyModel()
model = nn.DataParallel(model)
model.to(device)6. 在 GPU 上保存和加载模型
保存和加载模型时，可以选择将模型参数保存到或加载自 GPU。
# 保存模型到 GPU
torch.save(model.state_dict(), 'model.pth')
# 加载模型到 GPU
model.load_state_dict(torch.load('model.pth'))
model.to(device)7. GPU 上的数据并行
在使用多 GPU 进行数据并行训练时，可以使用 torch.nn.parallel.DistributeDataParallel。
model = MyModel()
model = nn.parallel.DistributedDataParallel(model)
model.to(device)8. 注意事项
- 确保你的 PyTorch 版本支持 CUDA，并安装了与你的 GPU 驱动版本相匹配的 CUDA 版本。
- 模型和数据移动到 GPU 时，确保 GPU 上有足够的显存可用。
- 使用 torch.cuda.empty_cache( ) 可以释放一部分被 PyTorch 占用的 GPU 内存。
GPU 加速能够显著提高深度学习模型的训练速度，特别是对于复杂的模型和大规模的数据集。在实践中，GPU 的使用通常是深度学习项目中的标配。
参考资料：深夜努力写Python 作者：cos大壮