pytorch学习(b站小土堆学习)

1 环境配置

参考链接

2. dir 和 help函数

dir()：用于查看某一模块函数的方法
help()：用于查看某方法的使用方法
在这里插入图片描述

3. dataset类实战

利用Image对象打开图片，利用os模块的地址拼接组成图片路径
当我们用方括号访问元素对象时，实际上是调用了这个对象的__getitem__方法

from torch.utils.data import Dataset
from PIL import Image
import osclass MyData(Dataset):# 初始化，根目录的相对地址和标签labeldef __init__(self,root_dir,label_dir):self.root_dir = root_dirself.label_dir = label_dirself.path = os.path.join(self.root_dir,self.label_dir) # 拼接获得路径self.img_path = os.listdir(self.path) # 将对应路径下的元素名转换为列表# 当我们用方括号访问元素对象时，实际上是调用了这个对象的__getitem__方法def __getitem__(self, index): # 传入下标，获取对应图片img_name = self.img_path[index] # 从元素名的列表获取需要的元素名# 拼接所需图片的路径img_item_path = os.path.join(self.root_dir,self.label_dir,img_name)img = Image.open(img_item_path) # 根据路径获得图片对象label = self.label_dirreturn img,labeldef __len__(self): # 获取类中元素的数量return len(self.img_path)root_dir = "E:\\pythonProject\\dataset\\hymenoptera_data\\train"
ants_label_dir = "ants"
bees_label_dir = "bees"
ants_dataset = MyData(root_dir,ants_label_dir)
bees_dataset = MyData(root_dir,bees_label_dir)# 整体数据集可以使用两个数据集相加
train_dataset = ants_dataset + bees_dataset

然后可以数据集图片对象进行操作
在这里插入图片描述

4.TensorBoard的使用(一)

创建SummaryWriter实例，并生成一个图像，保存与当前路径下的 ”logs”文件夹中
SummaryWriter是PyTorch中的一个工具，用于将模型训练过程中的日志保存到TensorBoard中。可以通过使用SummaryWriter的add_scalar()方法来保存损失函数、准确率等标量信息，使用add_histogram()方法来保存权重、梯度等张量信息，使用add_image()方法来保存图像信息等。

from torch.utils.tensorboard import SummaryWriter# 传入某一文件夹的路径，默认为当前路径下的文件夹
writer = SummaryWriter("logs")
for i in range(10000):# 参数1：tag（图表的名称/label） ， 参数2：y轴的数值，参数3：x轴的数值writer.add_scalar("y = x", i ,i)
writer.close()

在对应虚拟环境的终端启动TensorBoard: logdir = 保存对应图像的文件夹名；port为打开的端口号
在这里插入图片描述
结果：

5. Tensorboard的使用(二)

使用numpy格式，添加文件图片。
numpy格式有两种：opencv打开文件和使用numpy直接格式转换

from torch.utils.tensorboard import SummaryWriter
import numpy as np
from PIL import  Image# 传入某一文件夹的路径，默认为当前路径下的文件夹
writer = SummaryWriter("logs")
img_path = "dataset/hymenoptera_data/train/bees/16838648_415acd9e3f.jpg"
img = Image.open(img_path)  # img 为PIL的jpeg类型
img_array = np.array(img)  # 将img转换为numpy类型
# numpy的类型的方法二 是用opencv打开# global—step 为步骤顺序，dataformats 为 数据格式
writer.add_image("test",img_array,1,dataformats='HWC')for i in range(100):# 参数1：tag（图表的名称/label） ， 参数2：y轴的数值，参数3：x轴的数值writer.add_scalar("y = x", i ,i)
writer.close()

在这里插入图片描述

6. Transfroms的使用(一)

![(https://i-blog.csdnimg.cn/direct/17e2ec49e97347349eba5e1d2b429e3c.png)

from torchvision import transforms
from PIL import Image# transforms如何使用(python)
img_path = "dataset/hymenoptera_data/train/ants/0013035.jpg"
img = Image.open(img_path) # 打开文件,得到一个图片类的实例# 获取一个ToTensor实例
tensor_trans = transforms.ToTensor()
# 由于存在__call__方法，调用该实例，调用该方法
# 由图片实例转换为 tensor类型
tensor_img = tensor_trans(img)print(tensor_img)

结果：
在这里插入图片描述

注： call 是 Python 中一个魔术方法（magic method），它用于定义对象的函数调用行为。换句话说，当你尝试调用一个具有 call 方法的对象时，Python 会自动调用该方法。

ToTensor类的__call__方法：
在这里插入图片描述

7. Transforms的使用（二）

将图片转换为tensor对象，再将该对象利用tensorboard的SummaryWriter打开。

from torch.utils.tensorboard import SummaryWriter
from torchvision import transforms
from PIL import Image# transforms如何使用(python)
img_path = "dataset/hymenoptera_data/train/ants/0013035.jpg"
img = Image.open(img_path) # 打开文件,得到一个图片类的实例# 获取一个ToTensor实例
tensor_trans = transforms.ToTensor()
# 由于存在__call__方法，调用该实例，调用该方法
# 由图片实例转换为 tensor类型
tensor_img = tensor_trans(img)writer = SummaryWriter("logs")
# 参数 ：  self, tag, img_tensor, global_step=None, walltime=None, dataformats="CHW"
writer.add_image("Tensor_img",tensor_img) # 保存图像信息writer.close()

启动tensorboard：
在这里插入图片描述
结果：

8.常见的Transform（一）

from PIL import Image
from torch.utils.tensorboard import SummaryWriter
from torchvision import transformswriter = SummaryWriter("logs")
img = Image.open("images/123.jpg")# ToTensor，转换后张量的范围均为0-1
trans_totensor = transforms.ToTensor()  # 创建ToTensor实例
img_tensor = trans_totensor(img) #调用内置__call__方法
writer.add_image("ToTensor",img_tensor)# normalize 归一化
# 创建Normalize实例 ,输入分别为 均值 和 标准差
trans_norm = transforms.Normalize([0.5,0.5,0.5],[0.5,0.5,0.5])
img_norm = trans_norm(img_tensor)  # 其父类具有__call__方法,img_norm为tensor类型
writer.add_image("normalize", img_norm)
writer.close()

归一化会改变tensor的数据的范围，img_tensor中的值为[0,1] ,而使用标准差与均值均为0.5的归一化后，其值的范围变为[-1,1]。若标准差与均值改变，则范围也会改变

在这里插入图片描述
运行结果：

9. 常见的Transform（二）

（1）Resize

from PIL import Image
from torch.utils.tensorboard import SummaryWriter
from torchvision import transformswriter = SummaryWriter("logs")
img = Image.open("images/321.jpg")# ToTensor，转换后张量的范围均为0-1
trans_totensor = transforms.ToTensor()  # 创建ToTensor实例
img_tensor = trans_totensor(img) #调用内置__call__方法
writer.add_image("ToTensor",img_tensor)# normalize 归一化
# 创建Normalize实例 ,输入分别为 均值 和 标准差
trans_norm = transforms.Normalize([0.5,0.5,0.5],[0.5,0.5,0.5])
img_norm = trans_norm(img_tensor)  # 其父类具有__call__方法,img_norm为tensor类型
writer.add_image("normalize", img_norm)
writer.close()# Resize
trans_resize = transforms.Resize([256,256]) # 传入要缩放的长和宽的列表
img_resize = trans_resize(img) # 传入一个PIL数据类型，返回值也为PIL类型
img_resize_tensor = trans_totensor(img_resize)  # 转换为tensor类型
writer.add_image("Resize",img_resize_tensor,0)# Resize 写法2,使用compose,传入transform的列表，表示要进行的transform的操作
trans_resize2 = transforms.Resize(256)  # 等比缩放
trans_compose = transforms.Compose([trans_resize2,trans_totensor]) # 先改变大小，再转换为tensor
img_resize_tensor2 = trans_compose(img)
writer.add_image("Resize",img_resize_tensor2,1)

运行结果：
在这里插入图片描述

（2） RandomCrop：随即裁剪

# RandomCrop 随机裁剪,如果输入一个值n，则会减为x*x；若输入两个值，则裁剪为x*y
trans_randowcrop = transforms.RandomCrop(256)
trans_compose2 = transforms.Compose([trans_randowcrop,trans_totensor])
for i in range(10): # 随机裁剪十次img_randomcrop = trans_compose2(img)writer.add_image("RandomCrop",img_randomcrop,i)writer.close()

运行结果：
在这里插入图片描述

10. torchvision中的数据集使用

数据集常用的参数：
在这里插入图片描述

import torchvision
from torchvision import transforms
from torch.utils.tensorboard import SummaryWriter# 自定义使用的transform
dataset_transforms = transforms.Compose([transforms.ToTensor() # 转化为tensor
])# 数据集的路径，是否为训练数据集，使用的transform ,是否需要下载
train_set = torchvision.datasets.CIFAR10("./dataset1",train=True,transform=dataset_transforms,download=True)
test_set = torchvision.datasets.CIFAR10("./dataset1",train=False,transform=dataset_transforms,download=True)writer = SummaryWriter("logs")
for i in range(10):img, target = test_set[i] # img为图片的tensor类型writer.add_image("test_set",img, i)
writer.close()

运行结果：
在这里插入图片描述

11. DataLoader的使用

在这里插入图片描述

import torchvision
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
from torchvision import transformstest_set = torchvision.datasets.CIFAR10("./dataset1",train=False,transform=transforms.ToTensor(),download=True)# batch_size: 批大小， shuffle表示是否打乱（一个epoch打乱一次），num_workers表示多进程数（0表示主进程进行）
# drop_last表示当数据总数与批大小不成比例，剩余不够一批的数据是否舍弃
test_loader = DataLoader(test_set,batch_size=64,shuffle=True,num_workers=0,drop_last=False)writer = SummaryWriter("dataload")for epoch in range(2):  # epoch的数量设置为2step = 0for data in test_loader:imgs, targets = data  # imgs 是batch(一批)的图片张量# 注意是add_images 不是 add_imagewriter.add_images(f"Epoch:{epoch}",imgs, step)step += 1writer.close()

运行结果：
在这里插入图片描述

12. nn.Module的基本使用

import torch
from torch import nn
class Test(nn.Module):def __init__(self):super().__init__()# 正向传播def forward(self, x):out = x + 1return outtest = Test()
x = torch.tensor(2.0)
# 使用实例传参会调用__call__函数，在nn.Module下会自动调用forward方法
print(test(x)) # 输出3

13. 神经网路-卷积层

卷积层stride默认为1.而后面池化层的stride默认为窗口长/宽。而卷积层的滤波器的初始值是随机值（在一定初始化方法下的随机，例如：Kaiming初始化和Xavier初始化）

卷积层作用： 从输入数据中提取特征，形成特征图
池化层作用： 对特征图进行降维处理
在这里插入图片描述

import torch
import torchvision
from torch import nn
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriterclass MyConv(nn.Module):def __init__(self):super().__init__()self.conv2 = nn.Conv2d(3,6,3)def forward(self, x):# 使用一个2d卷积，输入通道数为3，输出通道数为6，滤波器为3*3x = self.conv2(x)return xtest_data = torchvision.datasets.CIFAR10("./dataset1",train=False,transform=torchvision.transforms.ToTensor(),download=True)
dataLoader1 = DataLoader(test_data,batch_size=64)
writer = SummaryWriter("logs")myconv = MyConv()step = 0
for data in dataLoader1:imgs, targets = data  # img.shape = 64,3,32,32writer.add_images("imgs",imgs,step)out = myconv(imgs)  # out.shape = 64,6,30,30,不能直接被识别为图像# 因此化为两个三通道图片out = torch.reshape(out,(-1,3,30,30))writer.add_images("out",out,step)step += 1writer.close()

结果：
在这里插入图片描述

14. 最大池化层的使用

在这里插入图片描述

import torchvision.datasets
from torch import nn
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriterclass MyMaxpool(nn.Module):def __init__(self):super().__init__()# ceil_mode表示是否保存 当池化窗口不满时，窗口中的最大值self.maxpool = nn.MaxPool2d(3,ceil_mode=True)def forward(self, x):x = self.maxpool(x)return xtest_data = torchvision.datasets.CIFAR10("./dataset1",train=False,transform=torchvision.transforms.ToTensor(), download=True)
dataloader = DataLoader(test_data, batch_size=64)
writer = SummaryWriter("logs_maxpool")mymaxpool = MyMaxpool()step = 0
for data in dataloader:imgs, targets = datawriter.add_images("imgs",imgs, step)out = mymaxpool(imgs)writer.add_images("out",out,step)step += 1writer.close()

执行结果：
在这里插入图片描述

15. 非线性激活

非线性变换的目的： 为网络引入非线性特征

激活函数作用： 将神经网络的线性模型变为非线性的

ReLU中，inplace的用法
在这里插入图片描述

ReLU与Sigmold的简单使用

import torchvision.datasets
from torch import nn
from torch.nn import ReLU, Sigmoid
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriterclass MyRelu(nn.Module):def __init__(self):super().__init__()# inplace 表示是否用输入的变量接收输出；若为false，则input不变，存在返回值outputself.relu = ReLU(inplace=False)self.sigmoid = Sigmoid()def forward(self, x):x = self.sigmoid(x)return x;writer = SummaryWriter("logs_relu")
test_data = torchvision.datasets.CIFAR10("./dataset1",train=False,transform=torchvision.transforms.ToTensor(),download=True)
dataLoader1 = DataLoader(test_data,batch_size=64)myrelu = MyRelu()step = 0
for data in dataLoader1:imgs, targets = datawriter.add_images("imgs",imgs,step)out = myrelu(imgs)writer.add_images("out",out,step)writer.close()

运行结果：
在这里插入图片描述

16. 线性层及其他层的介绍

线性层，也就等同于全连接层，将一个多维数据拉伸映射为一维

在这里插入图片描述

17. 搭建小实战Sequential的使用

在这里插入图片描述
需要分别计算每个卷积核的padding和stride（卷积后H,W不变，一般padding=（5卷积核宽度-1）的一半），利用公式计算，dilation默认为1。

import torch
from torch import nn
from torch.nn import Sequential, Conv2d, MaxPool2d, Flatten, Linearclass MySeq(nn.Module):def __init__(self):super().__init__()self.module = Sequential(# 卷积过后尺寸不变， padding = (kernel_size - 1) / 2Conv2d(3,32,5,padding=2),MaxPool2d(2),Conv2d(32,32,5,padding=2),MaxPool2d(2),Conv2d(32,64,5,padding=2),MaxPool2d(2),  # 目前为64*4*4，需flatten成线性的Flatten(), # => 1024Linear(1024,64), # 1024=>64Linear(64,10),# 64=> 10)def forward(self, x):x = self.module(x)return xmyseq = MySeq()
x = torch.ones((64,3,32,32)) # 训练后 batch_size 不变
print(myseq(x).shape)

在这里插入图片描述

18. 损失函数和反向传播

交叉熵：
在这里插入图片描述

在这里插入图片描述

import torch
import torchvision.datasets
from torch import nn
from torch.nn import Sequential, Conv2d, MaxPool2d, Flatten, Linear
from torch.utils.data import DataLoaderdataset = torchvision.datasets.CIFAR10("dataset1",False,torchvision.transforms.ToTensor(),download=True)class MySeq(nn.Module):def __init__(self):super().__init__()self.module = Sequential(# 卷积过后尺寸不变， padding = (kernel_size - 1) / 2Conv2d(3,32,5,padding=2),MaxPool2d(2),Conv2d(32,32,5,padding=2),MaxPool2d(2),Conv2d(32,64,5,padding=2),MaxPool2d(2),  # 目前为64*4*4，需flatten成线性的Flatten(), # => 1024Linear(1024,64), # 1024=>64Linear(64,10),# 64=> 10)def forward(self, x):x = self.module(x)return xdataloader = DataLoader(dataset,batch_size=1)loss = nn.CrossEntropyLoss()  # 交叉熵损失函数
myseq = MySeq()for data in dataloader:imgs, targets = dataoutputs = myseq(imgs)result_loss = loss(outputs,targets)result_loss.backward() # 反向传播# loss样例
x = torch.tensor([0.1,0.2,0.3])
x = torch.reshape(x,(1,3))
target = torch.tensor([1])
print(loss(x,target))

运行结果： 与预想一致
在这里插入图片描述

19. 优化器

优化器的作用：
PyTorch的优化器在深度学习模型的训练过程中起着至关重要的作用。它们的主要功能是根据计算得到的梯度信息来更新模型的参数，以最小化损失函数。以下是PyTorch优化器的主要作用：

参数更新：优化器负责根据计算得到的梯度信息更新模型的参数（包括权值）。梯度表示了损失函数关于每个参数的变化率，通过将梯度与学习率相乘，优化器可以决定参数在每个训练步骤中的更新幅度。
学习率调整：优化器还可以控制学习率的调整。学习率决定了参数更新的步长，过大或过小的学习率都可能导致训练不稳定或收敛速度缓慢。一些优化器提供了自适应调整学习率的功能，根据训练进程或其他因素自动调整学习率的大小。
参数优化算法：优化器实现了不同的参数优化算法，如随机梯度下降（SGD）、Adam、Adagrad、RMSprop等。这些算法在计算参数更新时使用不同的策略和规则，以提高训练效果和收敛速度。
动量：一些优化器支持动量的概念，通过引入动量项来加速参数更新。动量可以帮助优化器在参数空间中更快地搜索，并有助于克服局部最小值的困境。

总而言之，PyTorch的优化器在深度学习模型的训练中起着关键的作用，负责根据梯度信息更新模型参数、调整学习率，并利用不同的优化算法和技术来提高训练效果和收敛速度。选择合适的优化器要根据具体的问题和模型特性进行调整和实验

在这里插入图片描述

import torch
import torchvision.datasets
from torch import nn
from torch.nn import Sequential, Conv2d, MaxPool2d, Flatten, Linear
from torch.optim import SGD
from torch.utils.data import DataLoaderdataset = torchvision.datasets.CIFAR10("dataset1",False,torchvision.transforms.ToTensor(),download=True)class MySeq(nn.Module):def __init__(self):super().__init__()self.module = Sequential(# 卷积过后尺寸不变， padding = (kernel_size - 1) / 2Conv2d(3,32,5,padding=2),MaxPool2d(2),Conv2d(32,32,5,padding=2),MaxPool2d(2),Conv2d(32,64,5,padding=2),MaxPool2d(2),  # 目前为64*4*4，需flatten成线性的Flatten(), # => 1024Linear(1024,64), # 1024=>64Linear(64,10),# 64=> 10)def forward(self, x):x = self.module(x)return xdataloader = DataLoader(dataset,batch_size=1)loss = nn.CrossEntropyLoss()  # 交叉熵损失函数
myseq = MySeq()optim = SGD(myseq.parameters(), lr=0.01)for epoch in range(20):epoch_loss = 0.0for data in dataloader:imgs, targets = dataoutputs = myseq(imgs)result_loss = loss(outputs,targets)optim.zero_grad() # 将梯度清零result_loss.backward() # 反向传播,获取梯度optim.step() # 利用优化器优化参数epoch_loss = epoch_loss + result_lossprint(epoch_loss) # 输出一个epoch总的损失率

在这里插入图片描述

20. 现用模型的使用及修改

在这里插入图片描述

from torch import nn
from torchvision.models import vgg16vgg16_false = vgg16()
# 迁移学习
# 1. 在最后添加一个线性层，将1024=》10
# vgg16_false.classifier.add_module('add_linear',nn.Linear(1000,10))
print(vgg16_false)
# 2. 修改最后一个线性层
vgg16_false.classifier[6] = nn.Linear(4096,10)
print(vgg16_false)

21. 模型保存和模型加载

模型保存

import torch
import torchvision.modelsvgg16 = torchvision.models.vgg16()# 保存方式1：保存整个模型（不推荐）
torch.save(vgg16,"vgg16_method1.pth")# 保存方式2：仅保存参数（官方推荐）
torch.save(vgg16.state_dict(), "vgg16_method2.pth")

模型加载

import torch
import torchvision# 加载保存方式1，整个模型
model = torch.load("vgg16_method1.pth")
# print(model)# 加载保存方式2，导入参数
# torch.load("vgg16_method2.pth") 导入模型的参数
vgg16_2 = torchvision.models.vgg16()
vgg16_2.load_state_dict(torch.load("vgg16_method2.pth"))
print(vgg16_2)

运行结果：
在这里插入图片描述

22. 完整的模型训练套路（一）

训练的代码：

import torchvision.datasets
from torch.nn import CrossEntropyLoss
from torch.optim import SGD
from torch.utils.data import DataLoader
from torchvision import transformsfrom model import MyModeldataset_train = torchvision.datasets.CIFAR10("dataset1",True,transforms.ToTensor(),download=True)
dataset_test = torchvision.datasets.CIFAR10("dataset1",False,transforms.ToTensor(),download=True)
train_dataloader = DataLoader(dataset_train,batch_size=64)
test_dataloader = DataLoader(dataset_test,batch_size=64)# length长度
train_length = len(dataset_train)
test_length = len(dataset_test)
print(f"训练集的长度：{train_length}")
print(f"测试集的长度：{test_length}")# 创建网络模型
myModel = MyModel()# 损失函数
loss_func = CrossEntropyLoss()# 优化器
learning_rate = 1e-2
optimizer = SGD(myModel.parameters(), lr=learning_rate)# 设置训练网络的一些参数
# 记录训练的总次数（训练一个batch算一次）
total_train_num = 0
# 记录测试的总次数
total_test_num = 0
# 训练的轮次
epoch = 10for i in range(10):print(f"-----第{i+1}轮训练开始-----")for data in train_dataloader:imgs, targets = dataoutputs = myModel(imgs)loss = loss_func(outputs, targets)  # 输入预测结果和真实结果，得到损失率# 优化器优化模型optimizer.zero_grad() # 将梯度清零loss.backward()  # 反向传播计算梯度optimizer.step() # 利用优化器优化参数total_train_num = total_train_num + 1print(f"训练次数:{total_train_num}, ；loss:{loss.item()}")

model.py

from torch import nn
from torch.nn import Sequential, Conv2d, MaxPool2d, Flatten, Linearclass MyModel(nn.Module):def __init__(self):super().__init__()self.module = Sequential(# 卷积过后尺寸不变， padding = (kernel_size - 1) / 2Conv2d(3,32,5,padding=2),MaxPool2d(2),Conv2d(32,32,5,padding=2),MaxPool2d(2),Conv2d(32,64,5,padding=2),MaxPool2d(2),  # 目前为64*4*4，需flatten成线性的Flatten(), # => 1024Linear(1024,64), # 1024=>64Linear(64,10),# 64=> 10)def forward(self, x):x = self.module(x)return x

运行结果：
在这里插入图片描述

23.完整的模型训练套路（二）

with：上下文管理器，with语句可以自动管理上下文资源，不论是什么原因跳出with块都能确保文件可以正确的关闭，以此来达到释放资源的目的。

with torch.no_grad() ：是一个用于临时禁用梯度计算的上下文管理器。

add_scalar: add_scalar() 用于展示标量，数

train()和eval() ：只针对某些层有用，例如drop_out层
在这里插入图片描述

代码：

import torch
import torchvision.datasets
from torch.nn import CrossEntropyLoss
from torch.optim import SGD
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
from torchvision import transformsfrom model import MyModeldataset_train = torchvision.datasets.CIFAR10("dataset1",True,transforms.ToTensor(),download=True)
dataset_test = torchvision.datasets.CIFAR10("dataset1",False,transforms.ToTensor(),download=True)
train_dataloader = DataLoader(dataset_train,batch_size=64)
test_dataloader = DataLoader(dataset_test,batch_size=64)# length长度
train_length = len(dataset_train)
test_length = len(dataset_test)
print(f"训练集的长度：{train_length}")
print(f"测试集的长度：{test_length}")# 创建网络模型
myModel = MyModel()# 损失函数
loss_func = CrossEntropyLoss()# 优化器
learning_rate = 1e-2
optimizer = SGD(myModel.parameters(), lr=learning_rate)# 设置tensorboard可视化
writer = SummaryWriter("logs")# 设置训练网络的一些参数
# 记录训练的总次数（训练一个batch算一次）
total_train_num = 0
# 记录测试的总次数
total_test_num = 0
# 训练的轮次
epoch = 10for i in range(10):print(f"-----第{i+1}轮训练开始-----")# 训练步骤开始myModel.train()for data in train_dataloader:imgs, targets = dataoutputs = myModel(imgs)loss = loss_func(outputs, targets)  # 输入预测结果和真实结果，得到损失率# 优化器优化模型optimizer.zero_grad() # 将梯度清零loss.backward()  # 反向传播计算梯度optimizer.step() # 利用优化器优化参数total_train_num = total_train_num + 1if total_train_num % 100 == 0:print(f"训练次数:{total_train_num}, ；loss:{loss.item()}")# 测试步骤开始myModel.eval()total_test_loss = 0total_accuracy = 0with torch.no_grad():for data in test_dataloader:imgs, targets = dataoutputs = myModel(imgs)loss = loss_func(outputs, targets)total_test_loss = total_test_loss + loss.item() # 计算一epoch中的总损失# argmax中 0 表示列比较  1 表示行比较  => 最后得到一行accuracy = (outputs.argmax(1) == targets).sum() # 准确个数 为 输出与目标相等数量的总和total_accuracy = total_accuracy + accuracy # 计算本轮总命中数print(f"整体测试集上的loss:{total_test_loss}")print(f"整体测试集上的准确率:{total_accuracy/test_length}")writer.add_scalar("test_loss",total_test_loss,i+1)writer.add_scalar("test_accuracy", total_accuracy/test_length, i+1)# 保存模型torch.save(myModel,f"MyModel_{i+1}.pth")print("模型已保存")writer.close()

运行结果：
在这里插入图片描述

24. 利用GPU训练（一）

使用方法1：
在这里插入图片描述

# 创建网络模型
myModel = MyModel()
if torch.cuda.is_available():myModel = myModel.cuda()# 损失函数
loss_func = CrossEntropyLoss()
if torch.cuda.is_available():loss_func = loss_func.cuda()

imgs, targets = data
if torch.cuda.is_available():imgs = imgs.cuda()targets = targets.cuda()

不使用GUP的时间：
在这里插入图片描述
使用GPU的时间：

使用GPU的方法二：
在这里插入图片描述

# 单显卡中cuda:0 == cuda
# device = torch.device("cuda")  写法1
device = torch.device("cuda" if torch.cuda.is_available() else "cpu") # 常用写法

# 创建网络模型
myModel = MyModel()
myModel = myModel.to(device)# 损失函数
loss_func = CrossEntropyLoss()
loss_func.to(device)

imgs, targets = data
imgs = imgs.to(device)
targets = targets.to(device)

运行结果：
在这里插入图片描述

25. 完整的模型验证套路

测试的图片：
在这里插入图片描述

import torch
import torchvision.transforms
from PIL import Image
from torch import nn
from torch.nn import Sequential, Conv2d, MaxPool2d, Flatten, Linearclass MyModel(nn.Module):def __init__(self):super().__init__()self.module = Sequential(# 卷积过后尺寸不变， padding = (kernel_size - 1) / 2Conv2d(3,32,5,padding=2),MaxPool2d(2),Conv2d(32,32,5,padding=2),MaxPool2d(2),Conv2d(32,64,5,padding=2),MaxPool2d(2),  # 目前为64*4*4，需flatten成线性的Flatten(), # => 1024Linear(1024,64), # 1024=>64Linear(64,10),# 64=> 10)def forward(self, x):x = self.module(x)return ximage = Image.open("images/img_1.png")
print(image)
image = image.convert('RGB')  # 将图片转为三通道
# 裁剪为32*32,再转换为Tensor类型
transform = torchvision.transforms.Compose([torchvision.transforms.Resize((32,32)),torchvision.transforms.ToTensor()])
image = transform(image)
print(image.shape) # 3,32,32# 加载训练好的模型
# 当在cpu上运行gpu上训练的模型时，需添加map_location参数
model = torch.load("MyModel_30_gpu.pth",map_location="cpu")
print(model)# 输入应为 B C H W 四维
image = torch.reshape(image,(1,3,32,32))
model.eval()
with torch.no_grad():output = model(image)
print(output)
print(output.argmax(1))