PyTorch深度学习快速入门学习总结（三）

现有网络模型的使用与调整

VGG — Torchvision 0.22 documentation

VGG 模型是由牛津大学牛津大学（Oxford University）的 Visual Geometry Group 于 2014 年提出的卷积神经网络模型，在 ImageNet 图像分类挑战赛中表现优异，以其简洁统一的网络结构设计而闻名。

优点：结构简洁统一，易于理解和实现；小卷积核设计提升了特征提取能力，泛化性能较好。
缺点：参数量巨大（主要来自全连接层），计算成本高，训练和推理速度较慢，对硬件资源要求较高。

ImageNet — Torchvision 0.22 documentation

在 PyTorch 的torchvision库中，ImageNet相关功能主要用于加载和预处理 ImageNet 数据集，方便用户在该数据集上训练或评估模型。

import torch
import torchvision
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential
from torch.utils.data import DataLoader# train_data = torchvision.datasets.ImageNet('./data_image_net', split='train', download=True,
#                                        transform=torchvision.transforms.ToTensor())
# 指定要加载的数据集子集。这里设置为'train'，表示加载的是 ImageNet 的训练集（包含约 120 万张图像）。
# 若要加载验证集，可将该参数改为'val'（验证集包含约 5 万张图像）。vgg16_false = torchvision.models.vgg16(pretrained=False)
vgg16_true = torchvision.models.vgg16(pretrained=True)print(vgg16_true)# 利用现有网络修改结构
train_data = torchvision.datasets.CIFAR10('./dataset', train=True, download=True,transform=torchvision.transforms.ToTensor())vgg16_true.add_module('add_linear', nn.Linear(1000, 10))
print(vgg16_true)
# (add_linear): Linear(in_features=1000, out_features=10, bias=True)# 修改位置不同
vgg16_true.classifier.add_module('add_linear', nn.Linear(1000, 10))# 直接修改某层
print(vgg16_false)
vgg16_false.classifier[6] = nn.Linear(4096, 10)
print(vgg16_false)

vgg16_false：适合用于训练全新的任务，vgg16_true：常用于迁移学习场景

vgg16_false：pretrained=False表示不加载在大型数据集上（如 ImageNet）预训练好的权重参数。此时，模型的权重参数会按照默认的随机初始化方式进行初始化，比如卷积层和全连接层的权重会从一定范围内的随机值开始，偏置项通常初始化为 0 或一个较小的值。这种初始化方式下，模型需要从头开始学习训练数据中的特征表示。
vgg16_true：pretrained=True表示加载在 ImageNet 数据集上预训练好的权重参数。VGG16 在 ImageNet 上经过大量图像的训练，已经学习到了通用的图像特征，比如边缘、纹理、形状等。加载这些预训练权重后，模型在新的任务上可以利用已学习到的特征，减少训练所需的样本数量和训练时间，在很多情况下能更快地收敛到较好的性能。

模型的保存与加载

模型保存

import torch
import torchvision
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential
from torch.utils.data import DataLoadervgg16 = torchvision.models.vgg16(pretrained=False)# 方式一保存 模型结构+模型参数
torch.save(vgg16, 'vgg16_method1.pth')# 方式二保存 模型参数 (推荐）
torch.save(vgg16.state_dict(), 'vgg16_method2.pth')# 陷阱
class Chenxi(nn.Module):def __init__(self, *args, **kwargs) -> None:super().__init__(*args, **kwargs)self.conv1 = nn.Conv2d(3, 64, kernel_size=3)def forward(self, x):x = self.conv1(x)return xchenxi = Chenxi()
torch.save(chenxi, 'chenxi_method1.pth')

相应模型加载方法

import torch
import torchvision
from module_save import * # 注意from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential
from torch.utils.data import DataLoader# 方式一, 加载模型
model = torch.load('vgg16_method1.pth')
# print(model)# 方式二, 加载模型
vgg16 = torchvision.models.vgg16(pretrained=False) # 新建网络模型结构
vgg16.load_state_dict(torch.load('vgg16_method2.pth'))
# print(vgg16)
# model = torch.load('vgg16_method2.pth')
# print(model)# 陷阱1
# 方法一必须要有模型# class Chenxi(nn.Module):
#     def __init__(self, *args, **kwargs) -> None:
#         super().__init__(*args, **kwargs)
#         self.conv1 = nn.Conv2d(3, 64, kernel_size=3)
#     def forward(self, x):
#         x = self.conv1(x)
#         return x# chenxi = Chenxi() 不需要model = torch.load('chenxi_method1.pth')
print(model)

完整的模型训练套路

CIFAR10为例

model文件

import torch
from torch import nn
from torch.nn import Sequential, Conv2d, MaxPool2d, Flatten, Linear# 搭建神经网络
class Chenxi(nn.Module):def __init__(self, *args, **kwargs) -> None:super().__init__(*args, **kwargs)self.model1 = Sequential(Conv2d(3, 32, 5, padding=2),MaxPool2d(2),Conv2d(32, 32, 5, padding=2),MaxPool2d(2),Conv2d(32, 64, 5, padding=2),MaxPool2d(2),Flatten(),Linear(1024, 64),Linear(64, 10),)def forward(self, x):x = self.model1(x)return xif __name__ == '__main__':chenxi = Chenxi()input = torch.ones((64, 3, 32, 32))output = chenxi(input)print(output.shape)# torch.Size([64, 10])

train文件

import torch
import torchvision.datasets
from torch import nn
from torch.nn import MaxPool2d, Sequential, Conv2d, Flatten, Linear
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriterfrom model import *# 准备数据集
train_data = torchvision.datasets.CIFAR10('./dataset', train=True, download=True,transform=torchvision.transforms.ToTensor())
test_data = torchvision.datasets.CIFAR10('./dataset', train=False, download=True,transform=torchvision.transforms.ToTensor())train_data_size = len(train_data)
test_data_size = len(test_data)print("训练数据集的长度为:{}".format(train_data_size))
print("测试数据集的长度为:{}".format(test_data_size))
# 训练数据集的长度为:50000
# 测试数据集的长度为:10000train_dataloader = DataLoader(train_data, batch_size=64)
test_dataloader = DataLoader(test_data, batch_size=64)# 创建网络模型
chenxi = Chenxi()# 损失函数
loss_fn = nn.CrossEntropyLoss()# 优化器
learning_rate = 1e-2
optimizer = torch.optim.SGD(chenxi.parameters(),lr=learning_rate)# 设置训练网络的参数
# 记录训练次数
total_train_step = 0
# 记录测试次数
total_test_step = 0
# 训练的轮数
epoch = 10# 添加Tensorboard
writer = SummaryWriter('./logs_train')for i in range(epoch):print('---------第{}轮训练开始-----------'.format(i + 1))# 训练开始chenxi.train()for data in train_dataloader:imgs, target = dataoutputs = chenxi(imgs)loss = loss_fn(outputs, target)# 优化器优化模型optimizer.zero_grad()loss.backward()optimizer.step()total_train_step = total_train_step + 1if total_train_step % 100 == 0:print("训练次数:{}, loss:{}".format(total_train_step, loss.item()))writer.add_scalar('train_loss', loss.item(), total_train_step)# 测试步骤开始chenxi.eval()total_test_loss = 0total_accuracy = 0with torch.no_grad():# 禁用梯度计算for data in test_dataloader:imgs, targets = dataoutputs = chenxi(imgs)loss = loss_fn(outputs, targets)total_test_loss = total_test_loss + loss.item()accuracy = (outputs.argmax(1) == targets).sum()total_accuracy = total_accuracy + accuracyprint("整体测试集上的Loss:{}".format(total_test_loss))print("整体测试集上的正确率:{}".format(total_accuracy/test_data_size))writer.add_scalar('test_loss', loss.item(), total_test_step)writer.add_scalar('test_accuracy', loss.item(), total_test_step)total_test_step += 1torch.save(chenxi, "chenxi_{}.pth".format(i))# torch.save(chenxi.state_dict(), "chenxi_{}.pth".format(i))print("模型已保存")writer.close()

train优化部分

import torch
outputs = torch.tensor([[0.1, 0.2],[0.05, 0.4]])
# print(outputs.argmax(0)) # 纵向
# print(outputs.argmax(1)) # 横向preds = outputs.argmax(0)
targets = torch.tensor([0, 1])
print((preds == targets).sum())

使用GPU进行训练

方法一：使用.cuda()

对网络模型、数据及标注、损失函数，进行 .cuda()操作

如果电脑不支持GPU，可以使用谷歌浏览器：

https://colab.research.google.com/drive/1HKuF0FtulVXkHaiWV8VzT-VXZmbq4kK4#scrollTo=861yC3qEpi3F

方法二：使用.to(device)

device = torch.device('cpu')
# device = torch.device('cuda')
x = x.to(device)
# 代替.cuda()

import torch
import torchvision.datasets
from torch import nn
from torch.nn import MaxPool2d, Sequential, Conv2d, Flatten, Linear
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter# from model import *# 准备数据集
train_data = torchvision.datasets.CIFAR10('./dataset', train=True, download=True,transform=torchvision.transforms.ToTensor())
test_data = torchvision.datasets.CIFAR10('./dataset', train=False, download=True,transform=torchvision.transforms.ToTensor())train_data_size = len(train_data)
test_data_size = len(test_data)print("训练数据集的长度为:{}".format(train_data_size))
print("测试数据集的长度为:{}".format(test_data_size))
# 训练数据集的长度为:50000
# 测试数据集的长度为:10000train_dataloader = DataLoader(train_data, batch_size=64)
test_dataloader = DataLoader(test_data, batch_size=64)# 创建网络模型
class Chenxi(nn.Module):def __init__(self, *args, **kwargs) -> None:super().__init__(*args, **kwargs)self.model1 = Sequential(Conv2d(3, 32, 5, padding=2),MaxPool2d(2),Conv2d(32, 32, 5, padding=2),MaxPool2d(2),Conv2d(32, 64, 5, padding=2),MaxPool2d(2),Flatten(),Linear(1024, 64),Linear(64, 10),)def forward(self, x):x = self.model1(x)return xchenxi = Chenxi()
if torch.cuda.is_available():chenxi = chenxi.cuda()
# 损失函数
loss_fn = nn.CrossEntropyLoss()
if torch.cuda.is_available():loss_fn = loss_fn.cuda()# 优化器
learning_rate = 1e-2
optimizer = torch.optim.SGD(chenxi.parameters(),lr=learning_rate)# 设置训练网络的参数
# 记录训练次数
total_train_step = 0
# 记录测试次数
total_test_step = 0
# 训练的轮数
epoch = 10# 添加Tensorboard
writer = SummaryWriter('./logs_train')for i in range(epoch):print('---------第{}轮训练开始-----------'.format(i + 1))# 训练开始chenxi.train()for data in train_dataloader:imgs, targets = dataif torch.cuda.is_available():imgs = imgs.cuda()targets = targets.cuda()outputs = chenxi(imgs)loss = loss_fn(outputs, targets)# 优化器优化模型optimizer.zero_grad()loss.backward()optimizer.step()total_train_step = total_train_step + 1if total_train_step % 100 == 0:print("训练次数:{}, loss:{}".format(total_train_step, loss.item()))writer.add_scalar('train_loss', loss.item(), total_train_step)# 测试步骤开始chenxi.eval()total_test_loss = 0total_accuracy = 0with torch.no_grad():# 禁用梯度计算for data in test_dataloader:imgs, targets = dataif torch.cuda.is_available():imgs = imgs.cuda()targets = targets.cuda()outputs = chenxi(imgs)loss = loss_fn(outputs, targets)total_test_loss = total_test_loss + loss.item()accuracy = (outputs.argmax(1) == targets).sum()total_accuracy = total_accuracy + accuracyprint("整体测试集上的Loss:{}".format(total_test_loss))print("整体测试集上的正确率:{}".format(total_accuracy/test_data_size))writer.add_scalar('test_loss', loss.item(), total_test_step)writer.add_scalar('test_accuracy', loss.item(), total_test_step)total_test_step += 1torch.save(chenxi, "chenxi_{}.pth".format(i))# torch.save(chenxi.state_dict(), "chenxi_{}.pth".format(i))print("模型已保存")writer.close()

完整的模型验证套路