第七章 完整的模型训练

模型框架与测试

建一个名为model的py文件用于保存模型框架

import torch
from torch import nnclass Myx(nn.Module):def __init__(self):super().__init__()self.model=nn.Sequential(nn.Conv2d(3,32,5,padding=2),nn.MaxPool2d(2),nn.Conv2d(32,32,5,padding=2),nn.MaxPool2d(2),nn.Conv2d(32,64,5,padding=2),nn.MaxPool2d(2),nn.Flatten(),nn.Linear(1024,64),nn.Linear(64,10))def forward(self, x):x=self.model(x)return x
#写个测试试一下代码是否成功
if __name__ == '__main__':myx=Myx()input=torch.ones((64,3,32,32))output=myx(input)print(output.shape)

使用if __name__ == "__main__":可以让你的Python文件既可以作为脚本直接运行，也可以作为模块被其他文件导入而不执行特定代码块。

完整模型训练套路

argmax函数

作用

argmax()可以按照一定方向得到最大值的索引,在分类的时候将输出由概率值转为概率最大值的下标

实例

import torch
output=torch.tensor([[0.2,0.4],[0.3,0.5]])
preds=output.argmax(1)#参数为1一行为一组，参数为0一列为一组
targets=torch.tensor([0,1])#真实标签的下标
print(preds==targets)#转换为bool值，true为预测正确

tensor([False,  True])

预测正确的数量：

preds_true_amount=(preds==targets).sum()
print(preds_true_amount)

tensor(1)

实例

import torch
import torchvision
from torch import nn
from torch.utils.data import DataLoader
from torchvision import transforms
from torch.utils.data import DataLoader
from model import *#准备数据集
train_data=torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transforms.ToTensor())
test_data=torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transforms.ToTensor())#查看数据集长度（照片数量）
train_data_size=len(train_data)
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)
test_dataloader=DataLoader(test_data, batch_size=64)#搭建神经网络
#将搭建好的网络单独存放在mode.py下并测试
#创建网络模型
myx=Myx()
#损失函数
loss_function=nn.CrossEntropyLoss()
#优化器
learning_rate=0.001
optimizer=torch.optim.SGD(myx.parameters(), lr=learning_rate)
#设置训练网络的参数
total_train_step=0#训练次数
total_test_step=0#测试次数
epoch=10#训练轮数
#训练开始
myx.train()#将网络设置为训练状态
for i in range(epoch):print(f"--------------------第{i+1}轮训练开始-----------------------")for data in train_dataloader:#imgs,targets=datares=myx(imgs)#得到预测值loss=loss_function(res,targets)#预测值与真实值比较得到loss#优化器优化模型optimizer.zero_grad()#梯度清零loss.backward()#通过loss反向传播得到梯度optimizer.step()#优化器通过梯度优化参数total_train_step+=1print(f"-----------------训练为第{total_train_step}次，loss为{loss.item()}-----------------")#使用.item()可以获得数据中的内容忽视其格式#测试步骤myx.eval()#将网络设置为测试状态total_test_loss=0total_accuarcy=0with torch.no_grad():#测试的时候不需要对梯度进行调整for data in test_dataloader:imgs,targets=datares=myx(imgs)loss=loss_function(res,targets)total_test_loss+=loss.item()accuarcy=(res.argmax(1)==targets).sum()#预测正确的个数total_accuarcy+=accuarcyprint(f"整体测试集上的loss：{total_test_loss}")print(f"整体测试集上的正确率：{total_accuarcy}/{test_data_size}")#保存每一轮训练结果torch.save(myx,f"myx_model_{i}.pth")print("模型已保存")

利用GPU训练

方法一——.cuda()

用gpu训练的第一种方法，就是把之前的模型、损失函数和数据通过调用.cuda()全都转移到cuda上进行

import torch
import torchvision
from torch import nn
from torch.utils.data import DataLoader
from torchvision import transforms
from torch.utils.data import DataLoader
from model import *
train_data=torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transforms.ToTensor())
test_data=torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transforms.ToTensor())
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)
myx=Myx()#模型转移到cuda上
myx=myx.cuda()loss_function=nn.CrossEntropyLoss()
#损失函数转移到cuda上
loss_function=loss_function.cuda()learning_rate=0.001
optimizer=torch.optim.SGD(myx.parameters(), lr=learning_rate)
total_train_step=0
total_test_step=0
epoch=10
myx.train()
for i in range(epoch):print(f"--------------------第{i+1}轮训练开始-----------------------")for data in train_dataloader:imgs,targets=data#将训练数据转移到cuda上imgs=imgs.cuda()targets=targets.cuda()res=myx(imgs)loss=loss_function(res,targets)optimizer.zero_grad()loss.backward()optimizer.step()total_train_step+=1print(f"-----------------训练为第{total_train_step}次，loss为{loss.item()}-----------------")myx.eval()total_test_loss=0total_accuarcy=0with torch.no_grad():for data in test_dataloader:imgs,targets=data# 将测试数据转移到cuda上imgs = imgs.cuda()targets = targets.cuda()res=myx(imgs)loss=loss_function(res,targets)total_test_loss+=loss.item()accuarcy=(res.argmax(1)==targets).sum()total_accuarcy+=accuarcyprint(f"整体测试集上的loss：{total_test_loss}")print(f"整体测试集上的正确率：{total_accuarcy}/{test_data_size}")

主要有四步，模型-损失函数-训练数据-测试数据，全部转移到cuda上

方法二——torch.device()

用gpu训练的第二种方法,使用.to(device)转移到torch.device()上，这样只需在前面修改device()中的内容就可以更改用cpu还是gpu进行训练，更常用

import torch
import torchvision
from torch import nn
from torch.utils.data import DataLoader
from torchvision import transforms
from torch.utils.data import DataLoader
from model import *#定义训练用的设备
device=torch.device("cpu")train_data=torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transforms.ToTensor())
test_data=torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transforms.ToTensor())
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)
myx=Myx()#将模型转移到device上
myx=myx.to(device)loss_function=nn.CrossEntropyLoss()#将损失函数转移到device上
loss_function=loss_function.to(device)learning_rate=0.001
optimizer=torch.optim.SGD(myx.parameters(), lr=learning_rate)
total_train_step=0
total_test_step=0
epoch=10
myx.train()
for i in range(epoch):print(f"--------------------第{i+1}轮训练开始-----------------------")for data in train_dataloader:imgs,targets=data#将训练数据转移到device上imgs=imgs.to(device)targets=targets.to(device)res=myx(imgs)loss=loss_function(res,targets)optimizer.zero_grad()loss.backward()optimizer.step()total_train_step+=1print(f"-----------------训练为第{total_train_step}次，loss为{loss.item()}-----------------")myx.eval()total_test_loss=0total_accuarcy=0with torch.no_grad():for data in test_dataloader:imgs,targets=data# 将测试数据转移到device上imgs = imgs.to(device)targets = targets.to(device)res=myx(imgs)loss=loss_function(res,targets)total_test_loss+=loss.item()accuarcy=(res.argmax(1)==targets).sum()total_accuarcy+=accuarcyprint(f"整体测试集上的loss：{total_test_loss}")print(f"整体测试集上的正确率：{total_accuarcy}/{test_data_size}")

也要分四步，模型-损失函数-训练数据-测试数据

相比与第一种方法，第二种方法在修改时更加方便

使用demo进行测试

#得到训练后的模型后对模型进行测试也叫demo
import torch
import torchvision
from PIL import Imageimage_path= "/image/img.png"
image=Image.open(image_path)
image=image.convert('RGB')#将png图片转换为rgb三通道
transform=torchvision.transforms.Compose([torchvision.transforms.Resize((32,32)),torchvision.transforms.ToTensor()])#Resize参数元组(高，宽),compose中需要用列表[]
image=transform(image)
model=torch.load("/myx_model_0.pth", map_location=torch.device('cpu'))#如果是在gpu上运行得到的模型需要加上这句话
image=torch.reshape(image,(1,3,32,32))#加上batch_size为1model.eval()#将模型改为测试状态
with torch.no_grad():#不改变gradres=model(image)
print(res.argmax(1))#输出可能性最大的标签索引

将保存好的模型随便找几张图输出，看一下结果与预期是否相符