网站栏目名,qq钓鱼网站制作,江门论坛网站建设,网站租用空间#x1f368; 本文为#x1f517;365天深度学习训练营中的学习记录博客#x1f356; 原作者#xff1a;K同学啊
文为「365天深度学习训练营」内部文章 参考本文所写记录性文章#xff0c;请在文章开头带上「#x1f449;声明」 #x1f37a;要求#xff1a; 保存训练过… 本文为365天深度学习训练营中的学习记录博客 原作者K同学啊
文为「365天深度学习训练营」内部文章 参考本文所写记录性文章请在文章开头带上「声明」 要求 保存训练过程中的最佳模型权重 已【达成√】调用官方的VGG-16网络框架【达成√】 拔高可选 测试集准确率达到60%难度有点大但是这个过程可以学到不少【达成√ 最终准确率为82%】手动搭建VGG-16网络框架【达成√】 我的环境
语言环境Python3.11.9编译器Jupyter Lab深度学习环境 torch2.3.1 torchvision0.18.1
数据集百度网盘、和鲸请不要对外公开数据集
目录
一、 前期准备
1. 设置GPU
2. 导入数据
3. 划分数据集
二、调用官方的VGG-16模型
三、 训练模型
1. 编写训练函数
3. 编写测试函数
3. 设置动态学习率
4. 正式训练
四、 结果可视化
1. Loss与Accuracy图
2. 指定图片进行预测
3. 模型评估
五、优化代码 1. 数据预处理部分优化
优化点
优化效果
2. 模型结构优化
优化点
优化效果
3. 损失函数与优化器优化
优化点
优化效果
4. 训练与测试循环优化
优化点
优化效果
5. 效果
六、手动搭建VGG-16模型
七、个人学习总结
1. 深度学习项目的系统化流程
2. 迁移学习的威力
3. 模型优化的重要性
4. 自主搭建模型的能力提升
5. 项目调试与性能分析
6. 数据可视化的价值 一、 前期准备
1. 设置GPU 如果设备上支持GPU就使用GPU,否则使用CPU import torch
import torch.nn as nn
import torchvision.transforms as transforms
import torchvision
from torchvision import transforms, datasets
import os,PIL,pathlib,warningswarnings.filterwarnings(ignore) #忽略警告信息device torch.device(cuda if torch.cuda.is_available() else cpu)
device 2. 导入数据 import os,PIL,random,pathlibdata_dir ./48-data/
data_dir pathlib.Path(data_dir)data_paths list(data_dir.glob(*))
classeNames [str(path).split(\\)[1] for path in data_paths]
classeNames # 关于transforms.Compose的更多介绍可以参考https://blog.csdn.net/qq_38251616/article/details/124878863
train_transforms transforms.Compose([transforms.Resize([224, 224]), # 将输入图片resize成统一尺寸# transforms.RandomHorizontalFlip(), # 随机水平翻转transforms.ToTensor(), # 将PIL Image或numpy.ndarray转换为tensor并归一化到[0,1]之间transforms.Normalize( # 标准化处理--转换为标准正太分布高斯分布使模型更容易收敛mean[0.485, 0.456, 0.406], std[0.229, 0.224, 0.225]) # 其中 mean[0.485,0.456,0.406]与std[0.229,0.224,0.225] 从数据集中随机抽样计算得到的。
])total_data datasets.ImageFolder(./48-data/,transformtrain_transforms)
total_data total_data.class_to_idx 3. 划分数据集
train_size int(0.8 * len(total_data))
test_size len(total_data) - train_size
train_dataset, test_dataset torch.utils.data.random_split(total_data, [train_size, test_size])
train_dataset, test_dataset batch_size 32train_dl torch.utils.data.DataLoader(train_dataset,batch_sizebatch_size,shuffleTrue,num_workers1)
test_dl torch.utils.data.DataLoader(test_dataset,batch_sizebatch_size,shuffleTrue,num_workers1)
for X, y in test_dl:print(Shape of X [N, C, H, W]: , X.shape)print(Shape of y: , y.shape, y.dtype)break 二、调用官方的VGG-16模型 VGG-16Visual Geometry Group-16是由牛津大学视觉几何组Visual Geometry Group提出的一种深度卷积神经网络架构用于图像分类和对象识别任务。VGG-16在2014年被提出是VGG系列中的一种。VGG-16之所以备受关注是因为它在ImageNet图像识别竞赛中取得了很好的成绩展示了其在大规模图像识别任务中的有效性。 以下是VGG-16的主要特点 深度VGG-16由16个卷积层和3个全连接层组成因此具有相对较深的网络结构。这种深度有助于网络学习到更加抽象和复杂的特征。卷积层的设计VGG-16的卷积层全部采用3x3的卷积核和步长为1的卷积操作同时在卷积层之后都接有ReLU激活函数。这种设计的好处在于通过堆叠多个较小的卷积核可以提高网络的非线性建模能力同时减少了参数数量从而降低了过拟合的风险。池化层在卷积层之后VGG-16使用最大池化层来减少特征图的空间尺寸帮助提取更加显著的特征并减少计算量。全连接层VGG-16在卷积层之后接有3个全连接层最后一个全连接层输出与类别数相对应的向量用于进行分类。 from torchvision.models import vgg16device cuda if torch.cuda.is_available() else cpu
print(Using {} device.format(device))# 加载预训练模型并且对模型进行微调
model vgg16(pretrained True).to(device) # 加载预训练的vgg16模型for param in model.parameters():param.requires_grad False # 冻结模型的参数这样子在训练的时候只训练最后一层的参数# 修改classifier模块的第6层即(6): Linear(in_features4096, out_features2, biasTrue)
# 注意查看我们下方打印出来的模型
model.classifier._modules[6] nn.Linear(4096,len(classeNames)) # 修改vgg16模型中最后一层全连接层输出目标类别个数
model.to(device)
model 三、 训练模型
1. 编写训练函数
# 训练循环
def train(dataloader, model, loss_fn, optimizer):size len(dataloader.dataset) # 训练集的大小num_batches len(dataloader) # 批次数目, (size/batch_size向上取整)train_loss, train_acc 0, 0 # 初始化训练损失和正确率for X, y in dataloader: # 获取图片及其标签X, y X.to(device), y.to(device)# 计算预测误差pred model(X) # 网络输出loss loss_fn(pred, y) # 计算网络输出和真实值之间的差距targets为真实值计算二者差值即为损失# 反向传播optimizer.zero_grad() # grad属性归零loss.backward() # 反向传播optimizer.step() # 每一步自动更新# 记录acc与losstrain_acc (pred.argmax(1) y).type(torch.float).sum().item()train_loss loss.item()train_acc / sizetrain_loss / num_batchesreturn train_acc, train_loss
3. 编写测试函数 测试函数和训练函数大致相同但是由于不进行梯度下降对网络权重进行更新所以不需要传入优化器 def test (dataloader, model, loss_fn):size len(dataloader.dataset) # 测试集的大小num_batches len(dataloader) # 批次数目, (size/batch_size向上取整)test_loss, test_acc 0, 0# 当不进行训练时停止梯度更新节省计算内存消耗with torch.no_grad():for imgs, target in dataloader:imgs, target imgs.to(device), target.to(device)# 计算losstarget_pred model(imgs)loss loss_fn(target_pred, target)test_loss loss.item()test_acc (target_pred.argmax(1) target).type(torch.float).sum().item()test_acc / sizetest_loss / num_batchesreturn test_acc, test_loss
3. 设置动态学习率
# def adjust_learning_rate(optimizer, epoch, start_lr):
# # 每 2 个epoch衰减到原来的 0.98
# lr start_lr * (0.92 ** (epoch // 2))
# for param_group in optimizer.param_groups:
# param_group[lr] lrlearn_rate 1e-4 # 初始学习率
# optimizer torch.optim.SGD(model.parameters(), lrlearn_rate)
# 调用官方动态学习率接口时使用
lambda1 lambda epoch: 0.92 ** (epoch // 4)
optimizer torch.optim.SGD(model.parameters(), lrlearn_rate)
scheduler torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambdalambda1) #选定调整方法
调用官方接口示例
该代码块仅为代码讲解示例不是整体程序的一部分
model [torch.nn.Parameter(torch.randn(2, 2, requires_gradTrue))]
optimizer SGD(model, 0.1)
scheduler ExponentialLR(optimizer, gamma0.9)for epoch in range(20):for input, target in dataset:optimizer.zero_grad()output model(input)loss loss_fn(output, target)loss.backward()optimizer.step()scheduler.step() 更多的官方动态学习率设置方式可参考torch.optim — PyTorch 2.5 documentation
4. 正式训练 model.train()、model.eval()训练营往期文章中有详细的介绍。请注意观察我是如何保存最佳模型与TensorFlow2的保存方式有何异同。 import copyloss_fn nn.CrossEntropyLoss() # 创建损失函数
epochs 40train_loss []
train_acc []
test_loss []
test_acc []best_acc 0 # 设置一个最佳准确率作为最佳模型的判别指标for epoch in range(epochs):# 更新学习率使用自定义学习率时使用# adjust_learning_rate(optimizer, epoch, learn_rate)model.train()epoch_train_acc, epoch_train_loss train(train_dl, model, loss_fn, optimizer)scheduler.step() # 更新学习率调用官方动态学习率接口时使用model.eval()epoch_test_acc, epoch_test_loss test(test_dl, model, loss_fn)# 保存最佳模型到 best_modelif epoch_test_acc best_acc:best_acc epoch_test_accbest_model copy.deepcopy(model)train_acc.append(epoch_train_acc)train_loss.append(epoch_train_loss)test_acc.append(epoch_test_acc)test_loss.append(epoch_test_loss)# 获取当前的学习率lr optimizer.state_dict()[param_groups][0][lr]template (Epoch:{:2d}, Train_acc:{:.1f}%, Train_loss:{:.3f}, Test_acc:{:.1f}%, Test_loss:{:.3f}, Lr:{:.2E})print(template.format(epoch1, epoch_train_acc*100, epoch_train_loss, epoch_test_acc*100, epoch_test_loss, lr))# 保存最佳模型到文件中
PATH ./best_model.pth # 保存的参数文件名
torch.save(model.state_dict(), PATH)print(Done) 四、 结果可视化
1. Loss与Accuracy图
import matplotlib.pyplot as plt
#隐藏警告
import warnings
warnings.filterwarnings(ignore) #忽略警告信息
plt.rcParams[font.sans-serif] [SimHei] # 用来正常显示中文标签
plt.rcParams[axes.unicode_minus] False # 用来正常显示负号
plt.rcParams[figure.dpi] 100 #分辨率epochs_range range(epochs)plt.figure(figsize(12, 3))
plt.subplot(1, 2, 1)plt.plot(epochs_range, train_acc, labelTraining Accuracy)
plt.plot(epochs_range, test_acc, labelTest Accuracy)
plt.legend(loclower right)
plt.title(Training and Validation Accuracy)plt.subplot(1, 2, 2)
plt.plot(epochs_range, train_loss, labelTraining Loss)
plt.plot(epochs_range, test_loss, labelTest Loss)
plt.legend(locupper right)
plt.title(Training and Validation Loss)
plt.show() 2. 指定图片进行预测 from PIL import Image classes list(total_data.class_to_idx)def predict_one_image(image_path, model, transform, classes):test_img Image.open(image_path).convert(RGB)plt.imshow(test_img) # 展示预测的图片test_img transform(test_img)img test_img.to(device).unsqueeze(0)model.eval()output model(img)_,pred torch.max(output,1)pred_class classes[pred]print(f预测结果是{pred_class})
# 预测训练集中的某张照片
predict_one_image(image_path./48-data/Angelina Jolie/001_fe3347c0.jpg, modelmodel, transformtrain_transforms, classesclasses) 3. 模型评估
best_model.eval()
epoch_test_acc, epoch_test_loss test(test_dl, best_model, loss_fn)
epoch_test_acc, epoch_test_loss # 查看是否与我们记录的最高准确率一致
epoch_test_acc 五、优化代码 1. 数据预处理部分优化
优化点
数据增强不足 仅使用了 Resize可能导致模型泛化能力较差。添加随机翻转、随机裁剪和颜色抖动等增强操作。目标类别个数 len(classNames) 未正确设置需检查类别数。
优化效果
增强数据多样性减少模型过拟合提高模型泛化性能。
from torchvision import transforms, datasets# 数据增强
train_transforms transforms.Compose([transforms.RandomResizedCrop(224), # 随机裁剪并调整到224x224transforms.RandomHorizontalFlip(), # 随机水平翻转transforms.ColorJitter(brightness0.2, contrast0.2, saturation0.2, hue0.1), # 颜色抖动transforms.ToTensor(), # 转为Tensortransforms.Normalize(mean[0.485, 0.456, 0.406], std[0.229, 0.224, 0.225]) # 标准化
])test_transforms transforms.Compose([transforms.Resize(256), # 调整大小transforms.CenterCrop(224), # 中心裁剪到224x224transforms.ToTensor(),transforms.Normalize(mean[0.485, 0.456, 0.406], std[0.229, 0.224, 0.225])
])total_data datasets.ImageFolder(./48-data/,transformtrain_transforms)
total_dataprint(total_data.class_to_idx)train_size int(0.8 * len(total_data))
test_size len(total_data) - train_size
train_dataset, test_dataset torch.utils.data.random_split(total_data, [train_size, test_size])
train_dataset, test_dataset# 数据加载器
batch_size 32
train_dl torch.utils.data.DataLoader(train_dataset, batch_sizebatch_size, shuffleTrue, num_workers1)
test_dl torch.utils.data.DataLoader(test_dataset, batch_sizebatch_size, shuffleFalse, num_workers1)2. 模型结构优化
优化点
VGG16的全连接层过多可能导致过拟合。 减少全连接层的神经元数量添加 Dropout 防止过拟合。冻结的特征层过多可能限制了特征学习能力。 解冻后几层卷积层让模型能够更好适配当前数据集。
优化效果
减轻过拟合风险提升模型对特定数据集的适应性。
from torchvision.models import vgg16
import torch.nn as nndevice cuda if torch.cuda.is_available() else cpu
print(fUsing {device} device)# 加载预训练模型
model vgg16(pretrainedTrue)# 解冻最后几层卷积层
for param in list(model.features.parameters())[-8:]:param.requires_grad True# 修改全连接层
model.classifier nn.Sequential(nn.Linear(25088, 4096), nn.ReLU(inplaceTrue),nn.Dropout(p0.5),nn.Linear(4096, 1024), nn.ReLU(inplaceTrue),nn.Dropout(p0.5),nn.Linear(1024, len(classeNames)) # 输出类别数
)model.to(device)
model 3. 损失函数与优化器优化
优化点
使用 AdamW 替代 SGD提高优化效率。增加权重衰减Weight Decay控制模型复杂度。调整学习率策略使用 CosineAnnealingLR。
优化效果
更快的收敛速度更平稳的优化过程减少过拟合风险。
import torch.optim as optimlearn_rate 1e-4
optimizer optim.AdamW(model.parameters(), lrlearn_rate, weight_decay1e-4)
scheduler torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max10)
loss_fn nn.CrossEntropyLoss()4. 训练与测试循环优化
优化点
记录每个 epoch 的学习率便于分析。添加梯度裁剪防止梯度爆炸。打印更多信息帮助调试如每轮训练时间。
优化效果
更稳定的训练过程便于调试与分析。
import time
import copyepochs 40
train_loss, train_acc [], []
test_loss, test_acc [], []
best_acc 0for epoch in range(epochs):start_time time.time()# 训练模式model.train()size len(train_dl.dataset)train_correct, train_epoch_loss 0, 0for X, y in train_dl:X, y X.to(device), y.to(device)optimizer.zero_grad()pred model(X)loss loss_fn(pred, y)loss.backward()# 梯度裁剪torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm1.0)optimizer.step()train_correct (pred.argmax(1) y).type(torch.float).sum().item()train_epoch_loss loss.item()# 测试模式model.eval()size len(test_dl.dataset)test_correct, test_epoch_loss 0, 0with torch.no_grad():for X, y in test_dl:X, y X.to(device), y.to(device)pred model(X)loss loss_fn(pred, y)test_correct (pred.argmax(1) y).type(torch.float).sum().item()test_epoch_loss loss.item()# 学习率更新scheduler.step()# 保存最佳模型test_accuracy test_correct / sizeif test_accuracy best_acc:best_acc test_accuracybest_model copy.deepcopy(model)train_loss.append(train_epoch_loss / len(train_dl))train_acc.append(train_correct / len(train_dl.dataset))test_loss.append(test_epoch_loss / len(test_dl))test_acc.append(test_accuracy)end_time time.time()print(fEpoch {epoch1:02d}, Train Acc: {train_acc[-1]*100:.2f}%, Test Acc: {test_acc[-1]*100:.2f}%, fTrain Loss: {train_loss[-1]:.4f}, Test Loss: {test_loss[-1]:.4f}, fLR: {scheduler.get_last_lr()[0]:.6f}, Time: {end_time - start_time:.2f}s)# 保存模型
torch.save(best_model.state_dict(), ./best_model.pth)
print(Training complete!)5. 效果 六、手动搭建VGG-16模型 VGG-16结构说明 13个卷积层Convolutional Layer分别用blockX_convX表示3个全连接层Fully connected Layer用classifier表示5个池化层Pool layer。 VGG-16包含了16个隐藏层13个卷积层和3个全连接层故称为VGG-16 import torch
import torch.nn as nn
import torch.nn.functional as Fclass VGG16(nn.Module):def __init__(self, num_classes1000):super(VGG16, self).__init__()# 定义卷积层和池化层self.features nn.Sequential(# Block 1nn.Conv2d(3, 64, kernel_size3, padding1),nn.ReLU(inplaceTrue),nn.Conv2d(64, 64, kernel_size3, padding1),nn.ReLU(inplaceTrue),nn.MaxPool2d(kernel_size2, stride2), # 112x112# Block 2nn.Conv2d(64, 128, kernel_size3, padding1),nn.ReLU(inplaceTrue),nn.Conv2d(128, 128, kernel_size3, padding1),nn.ReLU(inplaceTrue),nn.MaxPool2d(kernel_size2, stride2), # 56x56# Block 3nn.Conv2d(128, 256, kernel_size3, padding1),nn.ReLU(inplaceTrue),nn.Conv2d(256, 256, kernel_size3, padding1),nn.ReLU(inplaceTrue),nn.Conv2d(256, 256, kernel_size3, padding1),nn.ReLU(inplaceTrue),nn.MaxPool2d(kernel_size2, stride2), # 28x28# Block 4nn.Conv2d(256, 512, kernel_size3, padding1),nn.ReLU(inplaceTrue),nn.Conv2d(512, 512, kernel_size3, padding1),nn.ReLU(inplaceTrue),nn.Conv2d(512, 512, kernel_size3, padding1),nn.ReLU(inplaceTrue),nn.MaxPool2d(kernel_size2, stride2), # 14x14# Block 5nn.Conv2d(512, 512, kernel_size3, padding1),nn.ReLU(inplaceTrue),nn.Conv2d(512, 512, kernel_size3, padding1),nn.ReLU(inplaceTrue),nn.Conv2d(512, 512, kernel_size3, padding1),nn.ReLU(inplaceTrue),nn.MaxPool2d(kernel_size2, stride2), # 7x7)# 定义全连接层self.classifier nn.Sequential(nn.Linear(512 * 7 * 7, 4096),nn.ReLU(inplaceTrue),nn.Dropout(),nn.Linear(4096, 4096),nn.ReLU(inplaceTrue),nn.Dropout(),nn.Linear(4096, num_classes),)def forward(self, x):x self.features(x)x torch.flatten(x, 1) # 展平x self.classifier(x)return x# 测试网络是否能正常运行
if __name__ __main__:model VGG16(num_classes1000)print(model)# 测试输入input_tensor torch.randn(1, 3, 224, 224) # Batch size1, RGB图像, 224x224output model(input_tensor)print(输出形状:, output.shape) # torch.Size([1, 1000])七、个人学习总结
在这个项目中我完整体验了从数据预处理到模型训练再到结果优化的深度学习项目流程不仅巩固了理论知识也提升了实践能力。在完成VGG-16网络的调用与优化过程中我收获颇丰并从多个方面得到了深刻的经验和启发这些经验将极大地应用于后续的深度学习研究和实践。
1. 深度学习项目的系统化流程
本次实践让我认识到一个完整的深度学习项目离不开前期准备、模型构建、训练调试与后期优化等环节的有机结合。例如在数据预处理阶段我学习了如何利用torchvision.transforms进行数据增强包括随机裁剪、颜色抖动等操作这些方法有效提升了模型的泛化能力减少了过拟合现象。未来在处理其他数据集时这些增强技术能够让我快速应对数据样本不足的问题。
2. 迁移学习的威力
通过调用预训练的VGG-16网络我深刻理解了迁移学习在小样本数据集上的重要性。冻结部分卷积层参数仅微调全连接层大幅降低了训练难度并缩短了训练时间。最终测试集准确率达到82%这远超我的预期。未来在处理类似图像分类任务时迁移学习将是我优先选择的策略之一。
3. 模型优化的重要性
本次项目让我认识到不同的优化策略对模型性能提升有显著影响。通过引入动态学习率调节策略torch.optim.lr_scheduler模型在训练中保持了更平稳的收敛过程。尤其是在采用CosineAnnealingLR优化器时我看到了如何通过调节学习率在训练后期避免陷入局部最优。此外使用AdamW替代传统的SGD优化器也让我意识到针对不同模型和任务选择适合的优化方法的重要性。
4. 自主搭建模型的能力提升
尽管调用官方VGG-16框架已经完成了项目需求我仍尝试手动搭建了VGG-16模型这加深了我对其内部结构的理解。从卷积层到全连接层的逐步构建使我对参数设置和计算流程有了更直观的认识。举例来说VGG-16中使用3x3卷积核而非更大的卷积核这种设计在实际搭建时显得尤为高效因为它既保留了更细粒度的特征信息又显著减少了参数量。
5. 项目调试与性能分析
在项目实施过程中我多次遭遇训练不收敛、准确率波动较大的问题。通过引入梯度裁剪Gradient Clipping和记录每轮训练时间我学会了如何更好地监控训练过程并诊断问题。未来在复杂任务中这些调试手段可以帮助我快速定位问题所在从而更高效地改进模型。
6. 数据可视化的价值
通过绘制训练集和测试集的准确率与损失曲线我更加直观地了解了模型的收敛过程和潜在问题。例如在早期训练中测试集准确率上升缓慢而训练集准确率快速提升我可以据此判断是否存在过拟合问题。这让我深刻认识到可视化是深度学习项目中不可或缺的一部分。
