PyTorch深度学习快速入门（下）
- 一、现有网络模型的使用及修改
- 二、网络模型的保存与加载
- 三、完整的模型训练套路
- [四、GPU 训练](#四、GPU 训练)
-
- [（一）训练方式1 --- 调用 .cuda( ) 来改](#（一）训练方式1 — 调用 .cuda( ) 来改)
- [（二）训练方式2 --- 调用 .to( device ) 来改](#（二）训练方式2 — 调用 .to( device ) 来改)
- [五、完整的模型验证套路（测试 / demo）](#五、完整的模型验证套路（测试 / demo）)
- 六、看看GitHub上的开源项目
-
- （一）看一个项目，先看README
- [（二）再看 train.py 文件中的整体架构](#（二）再看 train.py 文件中的整体架构)
- [（三）将函数中 required=True 的地方用 default= ......替换](#（三）将函数中 required=True 的地方用 default= ……替换)
一、现有网络模型的使用及修改
（一）背景知识
（1）本质 ：迁移学习，即利用现有的网络，去改变它的结构(微调)
（2）所用模型与数据集的解介绍
（3）pretrained设置为True或False的区别
- False：只是加载了网络架构，参数都是初始化的默认参数
- True ：从网络中下载每个卷积层在数据集上训练好的参数
（二）修改网络模型的三种方法
python
import torchvision
from torch import nn
# traindata = torchvision.datasets.ImageNet("./data_image_net",split='train',download=True,
# transform=torchvision.transforms.ToTensor())
# The dataset is no longer publicly accessible. You need to download the archives externally and place them in the root directory.
# False：只是加载了网络架构，参数都是初始化的默认参数
# True：从网络中下载每个卷积层在数据集上训练好的参数
vgg16_false = torchvision.models.vgg16(pretrained=False)
vgg16_true = torchvision.models.vgg16(pretrained=True)
train_data = torchvision.datasets.CIFAR10("./dataset",train=True,
transform=torchvision.transforms.ToTensor(),download=True)
print(vgg16_true)
# CIFAR10 只把数据分成了 10 类，而加载的 vgg16 这个模型把数据分成了 1000 个类，需要修改
# vgg16_true.add_module('add_linear',nn.Linear(1000,10)) # 加在 VGG 大类中加
vgg16_true.classifier.add_module('add_linear',nn.Linear(1000,10)) #在 classifier 最后加
print(vgg16_true)
print(vgg16_false)
vgg16_false.classifier[6] = nn.Linear(4096,10) # 修改网络模型
print(vgg16_false)
二、网络模型的保存与加载
（一）保存网络模型的两种方法
- 保存方式一：保存了 模型结构 + 模型参数
- 保存方式二：将网络模型中的参数保存成字典，没有了结构，只保存了模型参数（官方推荐，文件小）
model_save.py文件
python
import torch
import torchvision
from torch import nn
vgg16 = torchvision.models.vgg16(pretrained=False)
# 保存方式一：保存了 模型结构 + 模型参数
# pth文件是 PyTorch 中常用的一种文件格式，主要用于 保存和加载 模型的参数
torch.save(vgg16,"vgg16_method1.pth")
# 保存方式二：将网络模型中的参数保存成字典，没有了结构，只保存了模型参数（官方推荐，文件小）
torch.save(vgg16.state_dict(),"vgg16_method2.pth")
# 陷阱
class Li(nn.Module):
def __init__(self):
super().__init__()
self.conv = nn.Conv2d(3,64,3)
def forward(self,x):
x = self.conv(x)
return x
li = Li()
torch.save(li,"li_method1.pth")运行完程序后，在终端中输入 dir即可查看到文件相关信息
mac 里面的 ls(list) == windows 里面的 dir(directory)
（二）加载网络模型的两种方法
- 加载模型方式一 对应 保存方式一
- 加载模型方式二 对应 保存方式二：字典形式，无结构
另：如果要恢复网络模型结构Step1：新建网络模型结构（默认没有参数）
Step2：通过字典形式加载参数（别人训练好的参数）
model_load.py文件
python
# import torch
# import torchvision
from model_save import * # *代表导入当前目录下的所有函数 （陷阱的解决方法）
# 加载模型方式一：--> 保存方式一
model = torch.load("vgg16_method1.pth")
print(model)
# 加载模型方式二：--> 保存方式二：字典形式，无结构
# model = torch.load("vgg16_method2.pth")
# 如果要恢复网络模型结构
# Step1：新建网络模型结构，但是没有参数
vgg16 = torchvision.models.vgg16(pretrained=False)
# Step2：通过字典形式加载参数（别人训练好的参数）
vgg16.load_state_dict(torch.load("vgg16_method2.pth"))
print(vgg16)
# 此方式在自己的数据集上训练达到理想的效果了之后
# 陷阱
model = torch.load("li_method1.pth")
print(model)
# Can't get attribute 'Li' on <module '__main__' from 'D:\\Python\\pythonProject3\\model_load.py'>
# 要把 model_save 中的网络架构复制过来才行，或者直接 import 过来注：
加载模型的时候，要把 model_save 中的网络架构复制过来 才行，或者直接 import 过来
三、完整的模型训练套路
（一）背景知识
（1）有 Dropout，BatchNorm 层才需要在 训练/测试前 把网络设置成 训练/测试模式
（2）分类问题中，正确率指标的计算方法
python
outputs = torch.tensor([0.1,0.2],
[0.3,0.4])
# print(outputs.argmax(1)) # 填 1 的时候横向看，填 0 的时候纵向看（填标号的方向）
# 输出 tensor([1,1]) --> 横向来看：第一行预测在 1 位置，第二行也预测在 1 位置
preds = outputs.argmax(1)
targets = torch.tensor([0,1])
# print(preds == targets) # 输出 tensor([False,True])
print((preds == targets).sum()) # 输出 tensor(1) 计算出对应位置相等的个数，这里正确的个数为1（3）tensor 类型加不加 .item( ) 的区别
python
a = torch.tensor(5)
print(a) # 打印 tensor(5)
print(a.item()) # 打印 5（4）验证集 != 测试集
数据集分3部分：
1）训练集：训练神经网络（平时练习）
2）验证集：看网络效果、修改参数，防止模型过拟合（模拟考）
3）测试集：是最后一步，看网络怎么样（高考）
（5）训练网络的大体流程
准备数据集、dataloader加载数据集，搭建网络模型，创建网络模型实例，定义损失函数，定义优化器，设置网络训练的参数，开始训练，验证模型，最后保存模型。可以将训练结果展示
（二）代码实战
python
import torch
from torch import nn
class Li(nn.Module):
def __init__(self):
super().__init__()
self.model = nn.Sequential(
nn.Conv2d(3,32,5,1,2),
nn.MaxPool2d(2),
nn.Conv2d(32,32,5,1,2),
nn.MaxPool2d(2),
nn.Conv2d(32,64,5,1,2),
nn.MaxPool2d(2),
nn.Flatten(),
nn.Linear(64*4*4,64),
nn.Linear(64,10)
)
def forward(self,x):
x = self.model(x)
return x
# 可测试网络的正确性
if __name__ == '__main__': # 相当于 main
li = Li()
input = torch.ones((64,3,32,32)) # batch_size = 64，代表有 64 张图片
output = li(input)
print(output.shape)
# 输出 torch.Size([64, 10])
# 含义：返回 64 行数据，每一行数据上面有 10 个数据（代表每一张图片在 10 个类别当中的概率）
# 另：__name__ == '__main__':下的代码只有在文件作为脚本直接执行时，才会被执行
# 而该.py脚本被 import 到其他脚本中去时，其下的代码就不会被执行
python
import torch
import torchvision
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
from model import * # 1、被引用的 python 文件首字母不能为数字符号 2、两个文件必须在一个文件夹底下
# 准备数据集 (下载数据集，并加载到内存中)
train_data = torchvision.datasets.CIFAR10(root="../dataset",train=True,
transform=torchvision.transforms.ToTensor(),download=True)
test_data = torchvision.datasets.CIFAR10(root="../dataset",train=False,
transform=torchvision.transforms.ToTensor(),download=True)
# 数据集的长度 (批量处理数据，提供一个迭代访问的接口)
train_data_size = len(train_data) # ctr + D 复制此行内容到下一行
test_data_size = len(test_data)
print(f"训练数据集的长度为：{train_data_size}")
print(f"测试数据集的长度为：{test_data_size}")
# 利用DataLoader加载数据集
train_dataloader = DataLoader(train_data,batch_size=64) # DataLoader 是类，Dataloader 是库
test_dataloader = DataLoader(test_data,batch_size=64)
# 搭建神经网络
# 创建网络模型
li = Li()
# 创建损失函数 mse用于回归，crossentropy 用于分类
loss_fn = nn.CrossEntropyLoss() # 参数为 optional 即为可选的
# 优化器 SGD(随机梯度下降) parameter：参数
# learning_rate = 0.01
learning_rate = 1e-2
optimizer = torch.optim.SGD(li.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(f"-----------第{i+1}轮训练开始-----------")
# Step1：训练步骤开始
li.train() # 有 Dropout, BatchNorm 层才需要调用
for data in train_dataloader:
imgs,targets = data
outputs = li(imgs) # 是 10 个类别中的某一个，也就是训练的标准
loss = loss_fn(outputs,targets)
# 优化器优化模型 --> 梯度清零、反向传播、参数优化、变量加一
optimizer.zero_grad()
loss.backward()
optimizer.step()
total_train_step = total_train_step + 1
if total_train_step % 100 == 0:
print(f"训练次数：{total_train_step}，Loss：{loss.item()}")
writer.add_scalar("train_loss",loss.item(),total_train_step)
# Step2：测试步骤开始（不需要调优，在现有的模型上测试），看看模型有没有训练好，是否达到需求
li.eval() # 有 Dropout，BatchNorm 层才需要调用
total_test_loss = 0 # 想求整个数据集上的 loss
total_accuracy = 0 # 想知道整体正确的个数，正确率：分类问题中特有的衡量指标
with torch.no_grad(): # 不调优了
for data in test_dataloader:
imgs,targets = data
outputs = li(imgs)
loss = loss_fn(outputs,targets)
total_test_loss = total_test_loss + loss.item()
accuracy = (outputs.argmax(1) == targets).sum() # outputs.argmax(1) 横向比较单张图片的各种类别概率，求最大
total_accuracy = total_accuracy + accuracy # 整个测试集上正确的个数
total_test_step = total_test_step + 1
print(f"整体测试集上的Loss：{total_test_loss}")
print(f"整体测试集上的正确率：{total_accuracy/test_data_size}")
writer.add_scalar("test_loss",total_test_loss,total_test_step) # 深色线：平滑处理，浅色线：真实曲线
writer.add_scalar("test_accuracy",total_accuracy/test_data_size,total_test_step)
# Step3：保存每一轮训练的模型结果
torch.save(li,f"li_{i}.pth")
# torch.save(li.state_dict(),f"li_{}.pth")
print("模型已保存")
writer.close()
四、GPU 训练
用GPU训练，只需要改动代码中网络模型、数据（输入图片&标注）、损失函数这三个部分即可
（一）训练方式1 --- 调用 .cuda( ) 来改
python
import torch
import torchvision
from torch import nn
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
import time # 用来计时
# 准备数据集
train_data = torchvision.datasets.CIFAR10(root="../dataset",train=True,
transform=torchvision.transforms.ToTensor(),download=True)
test_data = torchvision.datasets.CIFAR10(root="../dataset",train=False,
transform=torchvision.transforms.ToTensor(),download=True)
# 数据集的长度
train_data_size = len(train_data)
test_data_size = len(test_data)
print(f"训练数据集的长度为：{train_data_size}")
print(f"测试数据集的长度为：{test_data_size}")
# 加载数据集
train_dataloader = DataLoader(train_data,batch_size=64) # DataLoader是类，Dataloader是库
test_dataloader = DataLoader(test_data,batch_size=64)
# 搭建神经网络
class Li(nn.Module):
def __init__(self):
super().__init__()
self.model = nn.Sequential(
nn.Conv2d(3,32,5,1,2),
nn.MaxPool2d(2),
nn.Conv2d(32,32,5,1,2),
nn.MaxPool2d(2),
nn.Conv2d(32,64,5,1,2),
nn.MaxPool2d(2),
nn.Flatten(),
nn.Linear(64*4*4,64),
nn.Linear(64,10)
)
def forward(self,x):
x = self.model(x)
return x
# <<<<<<<<<<<网络模型>>>>>>>>>>>>>
li = Li()
#################################################################
if torch.cuda.is_available():
li = li.cuda() # Moves all model parameters and buffers to the GPU
#################################################################
# <<<<<<<<<<<损失函数>>>>>>>>>>>>>
loss_fn = nn.CrossEntropyLoss()
#################################################################
if torch.cuda.is_available():
loss_fn = loss_fn.cuda()
#################################################################
# 优化器
learning_rate = 1e-2
optimizer = torch.optim.SGD(li.parameters(),lr=learning_rate)
total_train_step = 0
total_test_step = 0
epoch = 10
writer = SummaryWriter("../logs_train")
start_time = time.time() # 用 time 库中的 .time() 记录当前时间
for i in range(epoch):
print(f"-----------第{i+1}轮训练开始-----------")
# 训练步骤开始
li.train()
for data in train_dataloader:
# <<<<<<<<<<<数据>>>>>>>>>>>>>
imgs,targets = data
########################################
if torch.cuda.is_available():
imgs = imgs.cuda()
targets = targets.cuda()
########################################
outputs = li(imgs)
loss = loss_fn(outputs,targets)
optimizer.zero_grad()
loss.backward()
optimizer.step()
total_train_step = total_train_step + 1
if total_train_step % 100 == 0:
end_time = time.time() # 用 time 库中的 .time() 记录当前时间
print(end_time - start_time)
print(f"训练次数：{total_train_step}，Loss：{loss.item()}")
writer.add_scalar("train_loss",loss.item(),total_train_step)
# 测试步骤开始
li.eval()
total_test_loss = 0
total_accuracy = 0
with torch.no_grad():
for data in test_dataloader:
# <<<<<<<<<<<数据>>>>>>>>>>>>>
imgs,targets = data
########################################
if torch.cuda.is_available():
imgs = imgs.cuda()
targets = targets.cuda()
########################################
outputs = li(imgs)
loss = loss_fn(outputs,targets)
total_test_loss = total_test_loss + loss.item()
accuracy = (outputs.argmax(1) == targets).sum()
total_accuracy = total_accuracy + accuracy
print(f"整体测试集上的Loss：{total_test_loss}")
print(f"整体测试集上的正确率：{total_accuracy/test_data_size}")
writer.add_scalar("test_loss",total_test_loss,total_test_step)
writer.add_scalar("test_accuracy",total_accuracy/test_data_size,total_test_step)
total_test_step = total_test_step + 1
# 保存每一轮训练的结果
torch.save(li,f"li_{i}.pth")
# torch.save(li.state_dict(),f"li_{}.pth")
print("模型已保存")
writer.close()查看云端GPU的配置
运行程序
（二）训练方式2 --- 调用 .to( device ) 来改
可以用 device = torch.device("cuda:序号") 来指定用电脑中那一张显卡
device = torch.device("cuda") 和 device = torch.device("cuda:0") 两者无差别
python
import torch
import torchvision
from torch import nn
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
import time
##########################################################
# <<<<<<<<<<<<<定义训练的设备>>>>>>>>>>>>>>>
# device = torch.device("cuda" if torch.cuda.is_available() else "cpu") # 语法糖
device = torch.device("cuda") # 更常用
##########################################################
# 准备数据集
train_data = torchvision.datasets.CIFAR10(root="../dataset",train=True,
transform=torchvision.transforms.ToTensor(),download=True)
test_data = torchvision.datasets.CIFAR10(root="../dataset",train=False,
transform=torchvision.transforms.ToTensor(),download=True)
# 数据集的长度
train_data_size = len(train_data)
test_data_size = len(test_data)
print(f"训练数据集的长度为：{train_data_size}")
print(f"测试数据集的长度为：{test_data_size}")
# 加载数据集
train_dataloader = DataLoader(train_data,batch_size=64)
test_dataloader = DataLoader(test_data,batch_size=64)
# 搭建神经网络
class Li(nn.Module):
def __init__(self):
super().__init__()
self.model = nn.Sequential(
nn.Conv2d(3,32,5,1,2),
nn.MaxPool2d(2),
nn.Conv2d(32,32,5,1,2),
nn.MaxPool2d(2),
nn.Conv2d(32,64,5,1,2),
nn.MaxPool2d(2),
nn.Flatten(),
nn.Linear(64*4*4,64),
nn.Linear(64,10)
)
def forward(self,x):
x = self.model(x)
return x
# <<<<<<<<<<<<<网络模型>>>>>>>>>>>>>>>
li = Li()
##########################################################
# li = li.to(device) # 将网络转移到设备上去
li.to(device)
##########################################################
# <<<<<<<<<<<<<损失函数>>>>>>>>>>>>>>>
loss_fn = nn.CrossEntropyLoss()
##########################################################
# loss_fn = loss_fn.to(device)
loss_fn.to(device)
##########################################################
# 优化器
learning_rate = 1e-2
optimizer = torch.optim.SGD(li.parameters(),lr=learning_rate)
total_train_step = 0
total_test_step = 0
epoch = 10
writer = SummaryWriter("../logs_train")
start_time = time.time()
for i in range(epoch):
print(f"-----------第{i+1}轮训练开始-----------")
# 训练步骤开始
li.train()
for data in train_dataloader:
imgs,targets = data
#################################################
imgs = imgs.to(device)
targets = targets.to(device)
#################################################
outputs = li(imgs)
loss = loss_fn(outputs,targets)
optimizer.zero_grad()
loss.backward()
optimizer.step()
total_train_step = total_train_step + 1
if total_train_step % 100 == 0:
end_time = time.time()
print(end_time - start_time)
print(f"训练次数：{total_train_step}，Loss：{loss.item()}")
writer.add_scalar("train_loss",loss.item(),total_train_step)
# 测试步骤开始
li.eval()
total_test_loss = 0
total_accuracy = 0
with torch.no_grad():
for data in test_dataloader:
imgs,targets = data
##########################################
imgs = imgs.to(device)
targets = targets.to(device)
##########################################
outputs = li(imgs)
loss = loss_fn(outputs,targets)
total_test_loss = total_test_loss + loss.item()
accuracy = (outputs.argmax(1) == targets).sum()
total_accuracy = total_accuracy + accuracy
print(f"整体测试集上的Loss：{total_test_loss}")
print(f"整体测试集上的正确率：{total_accuracy/test_data_size}")
writer.add_scalar("test_loss",total_test_loss,total_test_step)
writer.add_scalar("test_accuracy",total_accuracy/test_data_size,total_test_step)
total_test_step = total_test_step + 1
# 保存每一轮训练的结果
torch.save(li,f"li_{i}.pth")
# torch.save(li.state_dict(),f"li_{}.pth")
print("模型已保存")
writer.close()五、完整的模型验证套路（测试 / demo）
利用已经训练好的模型，给它提供输入（应用到实际的环境当中，下面随便找到物体图片就是应用）
python
import torch
import torchvision
from PIL import Image
from torch import nn
image_path = "../imgs/dog.png" # ../ 到上一层级文件夹里找
image = Image.open(image_path)
print(image)
# <PIL.PngImagePlugin.PngImageFile image mode=RGBA size=348x238 at 0x135148BC6A0>
# png格式是 4 通道(RGBA)：除 RGB 三通道外，还有一个透明度通道。但我们只想保留其颜色通道
image = image.convert('RGB')
# 要将图片调整成符合要调用的网络模型的大小，才可正常输入
transform = torchvision.transforms.Compose([torchvision.transforms.Resize((32,32)),
torchvision.transforms.ToTensor()])
image = transform(image)
print(image.shape)
class Li(nn.Module):
def __init__(self):
super().__init__()
self.model = nn.Sequential(
nn.Conv2d(3,32,5,1,2),
nn.MaxPool2d(2),
nn.Conv2d(32,32,5,1,2),
nn.MaxPool2d(2),
nn.Conv2d(32,64,5,1,2),
nn.MaxPool2d(2),
nn.Flatten(),
nn.Linear(64*4*4,64),
nn.Linear(64,10)
)
def forward(self,x):
x = self.model(x)
return x
# 加载网络模型
# 注：在CPU上加载GPU上训练的模型，要加映射 map_location
model = torch.load("../complete_model_training/li_29_gpu.pth",map_location=torch.device('cpu'))
print(model)
image = torch.reshape(image,(1,3,32,32)) # 网络训练往往需要bach_sizes
model.eval() # 将模型转化为测试类型
with torch.no_grad(): # with 自动处理对文件的关闭操作
output = model(image)
print(output)
print(output.argmax(1))
六、看看GitHub上的开源项目
（一）看一个项目，先看README
里面有安装、训练、测试模型的方法，需要环境配置的版本，还需要注意什么 等
（二）再看 train.py 文件中的整体架构
（三）将函数中 required=True 的地方用 default= ......替换
完