织梦文章类网站模板,做视频网站要什么软件有哪些,教育网站建站需求,厂字型网页网站小土堆PyTorch入门教程笔记 最近在观看PyTorch深度学习快速入门教程#xff08;绝对通俗易懂#xff01;#xff09;【小土堆】顺便做点笔记#xff0c;方便回看#xff0c;同时也希望记录的笔记能够帮助到更多在入门的小伙伴~ 【注】仅记录个人觉得重要的知识#xff0c…小土堆PyTorch入门教程笔记 最近在观看PyTorch深度学习快速入门教程绝对通俗易懂【小土堆】顺便做点笔记方便回看同时也希望记录的笔记能够帮助到更多在入门的小伙伴~ 【注】仅记录个人觉得重要的知识部分内容可能有遗漏
判断pytorch是否安装好GPU是否可供pytorch使用无报错即成功
import torch
torch.cuda.is_available()2. 添加环境变量的作用告诉系统在执行程序或者其他操作时应该如何工作 在命令行使用该命令时无需切换到程序所在路径 3. nb_conda是jupyter notebook的扩展可在jupyter notebook中直接使用conda环境允许在notebook的界面中创建、管理、切换conda环境而无需通过命令行
#安装命令如下
conda install nb_conda使用本地已下载好的包进行安装
conda install --use-local 包名.tar.bz2Python的内置函数dir() dir()函数打开工具箱。用于列出一个对象的所有属性和方法。它返回一个包含对象所有属性和方法名称的列表。如果不传入参数则返回当前作用域中所有可用的名称
#示例 查看pytorch
dir(torch)可以更加具体详细的查看
dir(torch.cuda)dir(torch.cuda.is_available) #注意torch.cuda.is_available后没有括号返回的结果是一个函数对象的属性列表 python 里 前后各有双下划线 __函数名__是什么 在 Python 中魔术属性Magic Attributes也称为特殊属性Special Attributes也称为魔法方法、双下划线方法Double Underscore Methods是以双下划线 __ 开头和结尾的特殊命名方式用于实现对象的特殊行为和操作不允许被修改 Python的内置函数help()查看官方解释文档 help()函数查看说明书。用于获取对象、模块、函数、关键字等的帮助信息。当传入对象时它会显示该对象的帮助文档。如果没有传入任何参数则会进入交互式帮助模式。
help(torch.cuda.is_available)在 IPython 中当输入 object?? 时它会尝试显示该对象的源代码 Pycharm 按shift 回车 会跳转至下一行的行首 在Pycharm的Python Console中也可 以任意行为块 输入多行时 按shift 回车 Pytorch读取数据的两个类 Dataset和DataLoader
from torch.utils.data import Dataset
help(Dataset)
Dataset??Dataset将数据和label进行组织编号0 1 2 3……使得可以根据编号读取数据需获取每一个数据及其label以及数据总数 要实现 len() 方法和 getitem() 方法。 len() 方法返回数据集的样本数量 getitem() 方法根据给定的索引返回对应的数据样本
DataLoader对数据进行打包将数据集划分为小批量按batchsize送入网络模型可以接收一个 Dataset 对象作为输入并根据指定的批量大小、是否打乱数据、是否使用多线程等参数来构建一个用于数据加载的迭代器
Jupter Notebook从星号*变为数字代表运行结束
Dataset类代码实战 通过继承Dataset类class MyData(Dataset)实现__len__和__getitem__方法可以自定义自己的数据集类以适应不同的数据源和格式 蚂蚁蜜蜂/练手数据集链接: https://pan.baidu.com/s/1jZoTmoFzaTLWh4lKBHVbEA 密码: 5suq
from torch.utils.data import Dataset
from PIL import Image
import osclass MyData(Dataset):def __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)def __getitem__(self, idx):img_name self.img_path[idx]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 蚂蚁蜜蜂数据集\\dataset\\train
ants_label_dir ants
ants_dataset MyData(root_dir, ants_label_dir)
print(ants_dataset)
print(ants_dataset[0] ) # 根据重写的getitem返回 img与 label
img, label ants_dataset[0]
img.show()
bees_label_dir bees
bees_dataset MyData(root_dir, bees_label_dir)
img, label bees_dataset[0]
img.show()train_dataset ants_dataset bees_dataset #两个数据集的拼接 未改变顺序ants在前 bees在后
print(len(ants_dataset))
print(len(bees_dataset))
print(len(train_dataset))Tensorboard的使用 add_saclar用于在TensorBoard中添加标量数据。该方法可以用来添加训练过程中的损失值、准确率等指标以便于在TensorBoard中进行可视化和比较 tag字符串用于标识添加的标量数据的名称或标签。在TensorBoard中这个标签将用作图表的标题。 scalar_value数值要记录的标量数据的值。这可以是损失值、准确率等。 global_step整数可选表示记录的步数或迭代次数。这个参数对于在TensorBoard中显示随时间变化的数据非常有用。例如在训练神经网络时您可以将当前的迭代次数传递给global_step以便在TensorBoard中可视化损失值、准确率等随着训练步数的变化而变化的曲线。 walltime时间戳可选表示记录的时间。如果不指定则默认使用当前时间 使用tensorboard绘制 y x 的函数
from torch.utils.tensorboard import SummaryWriterwriter SummaryWriter(logs) # 日志文件存储位置
for i in range(100):writer.add_scalar(y x, i, i) #前一个i是y 后一个i是横坐标
writer.close()在对应位置已生成事件文件
打开日志文件 在anaconda激活已安装tensorboard的环境并进入日志文件所在位置使用如下命令
tensorboard --logdirlogs #logs是上面指定在writer SummaryWriter(logs)中指定的文件夹名日志文件存储在此文件中出现如下的情况即为成功在浏览器中打开显示的url http://localhost:6006/ 另一种方式直接输入完整的日志文件所在路径 可通过tensorboard --logdirlogs --portXXXX 指定端口号当未改变图像标题重复修改y值 如writer.add_scalar(“y x”, i, i)writer.add_scalar(“y x”, 2i, i)writer.add_scalar(“y x”, 3i, i)会导致新绘制会包含之前绘制的图像 解决方法删除所有log文件重新执行程序再在tensorboard中查看 add_image()的使用 老方法先使用help看一下方法说明
from torch.utils.tensorboard import SummaryWriter
help(SummaryWriter.add_image)注意add_image的参数img_tensor类型需为torch.Tensor, numpy.array, or string/blobname 而通过PIL中的Image读取图像其对应的类型是class ‘PIL.JpegImagePlugin.JpegImageFile’
利用numpy.array()对PIL的图像进行转换
from torch.utils.tensorboard import SummaryWriter
from PIL import Image
img_path C:\\Users\\Sen\\Desktop\\pytorch\\Pytorch教程\\data\\train\\ants_image\\0013035.jpg
img Image.open(img_path)
print(type(img))
import numpy as np
img_array np.array(img)
print(type(img_array))使用numpy.array()转图像并进行writer.add_image()
from torch.utils.tensorboard import SummaryWriter
from PIL import Image
import numpy as npwriter SummaryWriter(logs) # 日志文件存储位置
img_path C:\\Users\\Sen\\Desktop\\pytorch\\Pytorch教程\\data\\train\\ants_image\\0013035.jpg
img Image.open(img_path)
print(type(img))
img_array np.array(img)
print(type(img_array))
print(img_array.shape)
writer.add_image(Img Test, img_array, 1)
writer.close()
会发现有如下报错 问题原因图像形状默认为 :math:(3, H, W)而上面通过打印发现形状为(512, 768, 3)需对通道参数进行转换 使用 dataformats‘HWC’
from torch.utils.tensorboard import SummaryWriter
from PIL import Image
import numpy as npwriter SummaryWriter(logs) # 日志文件存储位置
img_path C:\\Users\\Sen\\Desktop\\pytorch\\Pytorch教程\\data\\train\\ants_image\\0013035.jpg
img Image.open(img_path)
print(type(img))
img_array np.array(img)
print(type(img_array))
print(img_array.shape)
writer.add_image(Img Test, img_array, 1, dataformatsHWC)
writer.close() 无报错运行tensorboard进行查看
Pytorch中的Transforms 用于对图像进行预处理和数据增强操作如调整图像大小、中心裁剪、随机裁剪、随机水平翻转、归一化、将 PIL 图像转换为 Tensor 等等
from torchvision import transforms使用transforms的ToTensor()进行图片类型的转化
from torchvision import transforms
from PIL import Image
img_path C:\\Users\\Sen\\Desktop\\pytorch\\Pytorch教程\\data\\train\\bees_image\\16838648_415acd9e3f.jpg
img Image.open(img_path)
print(type(img))
tensor_trans transforms.ToTensor() # transforms.ToTensor() 这一步相当于实例化 返回totensor的对象
tensor_img tensor_trans(img)
print(type(tensor_img))Pycharm中查看包的结构 快捷键Alt 7 Pycharm 查看需传入的参数ctrlP Python的__call__ 方法 在 Python 中__call__ 是一个特殊方法也称为魔术方法或双下划线方法用于使对象可以像函数一样被调用。当你在一个对象上调用 obj() 时Python 解释器会查找该对象的__call__ 方法并调用它
class MyClass:def __init__(self, value):self.value valuedef __call__(self, x):return self.value xobj MyClass(10)
result obj(5) # 调用了 __call__ 方法
print(result) # 输出: 15
在 Python 中__call__ 是一个特殊方法也称为魔术方法或双下划线方法用于使对象可以像函数一样被调用。当你在一个对象上调用 obj() 时Python 解释器会查找该对象的 __call__ 方法并调用它。
class MyClass:def __init__(self, value):self.value valuedef __call__(self, x):return self.value xobj MyClass(10)
result obj(5) # 调用了 __call__ 方法
print(result) # 输出: 15在上面的示例中MyClass 类实现了__call__方法因此创建的 obj 实例可以像函数一样被调用。在调用 obj(5) 时实际上会调用 obj.__call__(5)返回的结果是 self.value x 的计算结果即 10 5 15。
__call__方法的灵活性使得对象可以像函数一样被使用这在某些情况下非常有用例如实现可调用的对象或者定制对象的行为。 查看transforms的源代码发现其实现了__call__方法 所以tensor_trans transforms.ToTensor() tensor_img tensor_trans(img)直接传入img调用了其中的__call__方法 tensor数据类型 神经网络专用的数据类型包含了许多神经网络需要的参数使用Python Console查看tensor_img的参数 opencv 使用cv2.imread()读取的图像数据类型是numpy.ndarray 使用add_image()添加tensor类型的图像到日志文件中 通过tensorboard展示
from torch.utils.tensorboard import SummaryWriter
from PIL import Image
from torchvision import transformswriter SummaryWriter(logs) # 日志文件存储位置
img_path C:\\Users\\Sen\\Desktop\\pytorch\\Pytorch教程\\data\\train\\bees_image\\16838648_415acd9e3f.jpg
img Image.open(img_path)
tensor_trans transforms.ToTensor()
tensor_img tensor_trans(img)
writer.add_image(Tensor_img,tensor_img)
writer.close()常见的transforms 使用Normalize对图像进行归一化对每个通道进行归一化输入值–均值/ 标准差 假设三个通道的均值和标准差都为0.5
from torch.utils.tensorboard import SummaryWriter
from PIL import Image
from torchvision import transformswriter SummaryWriter(logs) # 日志文件存储位置
img_path C:\\Users\\Sen\\Desktop\\pytorch\\Pytorch教程\\data\\train\\bees_image\\16838648_415acd9e3f.jpg
img Image.open(img_path)
tensor_trans transforms.ToTensor()
tensor_img tensor_trans(img)
trans_norm transforms.Normalize([0.5,0.5,0.5],[0.5,0.5,0.5])
img_norm trans_norm(tensor_img)
print(tensor_img[0][0][0])
print(img_norm[0][0][0])
writer.add_image(Normalize,img_norm)
writer.close()transform.Resize()的使用 注意图片数据类型通过Image.open读取的是PIL类型的 transform.Resize() 可以处理 PIL 图像对象也可以处理张量类型的数据
from PIL import Image
from torchvision import transforms
img_path C:\\Users\\Sen\\Desktop\\pytorch\\Pytorch教程\\data\\train\\bees_image\\16838648_415acd9e3f.jpg
img Image.open(img_path)
print(图片原始大小读取为PIL类型,img.size)
trans_resize transforms.Resize((512,512))
img_resize trans_resize(img)
print(对PIL类型进行Resize,img_resize)
tensor_trans transforms.ToTensor()
img_resize tensor_trans(img_resize)
print(将PIL Reszie的图片转换为Tensor,img_resize)
trans_resize2 transforms.Resize((256,256))
img_resize trans_resize(img_resize)
print(对tensor类型的数据进行Resize,img_resize)利用Compose进行resize Compose用于组合多个图像转换transform操作。通过 Compose可以创建一个转换流程这个流程可以按顺序执行多个图像处理操作这些操作可以包括缩放、裁剪、归一化等其需要的参数是一个列表其元素类型是transforms类型。 格式Compose([transforms参数1,transforms参数2,…])
from PIL import Image
from torchvision import transforms
img_path C:\\Users\\Sen\\Desktop\\pytorch\\Pytorch教程\\data\\train\\bees_image\\16838648_415acd9e3f.jpg
img Image.open(img_path)
print(img)
trans_resize2 transforms.Resize(512)
trans_totensor transforms.ToTensor()
trans_compose transforms.Compose([trans_resize2,trans_totensor])
img_resize_2 trans_compose(img)
print(img_resize_2)随机裁剪RandomCrop
RandomCrop 是 PyTorch 中用于图像数据增强data augmentation的函数之一它可以在图像或张量的随机位置裁剪出指定大小的区域 transforms.RandomCrop((128, 128))会随机在输入图像中裁剪出大小为 128x128 的区域并返回裁剪后的图像对象
from PIL import Image
from torchvision import transforms
help(transforms.RandomCrop)from torch.utils.tensorboard import SummaryWriter
from PIL import Image
from torchvision import transformswriter SummaryWriter(logs) # 日志文件存储位置
img_path C:\\Users\\Sen\\Desktop\\pytorch\\Pytorch教程\\data\\train\\bees_image\\16838648_415acd9e3f.jpg
img Image.open(img_path)
print(img)
trans_random transforms.RandomCrop(30)
trans_totensor transforms.ToTensor()
trans_compose_2 transforms.Compose([trans_random,trans_totensor])
for i in range(10):img_crop trans_compose_2(img)writer.add_image(RandomCrop,img_crop,i)writer.close()裁剪的结果如下
当随机裁剪的大小大于图像输入时会报类似这种错误
torchvision.datasets的使用
import torchvision
from torchvision import transforms
from torch.utils.tensorboard import SummaryWriterwriter SummaryWriter(logs) # 日志文件存储位置
dataset_transform transforms.Compose([transforms.ToTensor()
])
train_set torchvision.datasets.CIFAR10(root./dataset, trainTrue,transformdataset_transform, downloadTrue)
test_set torchvision.datasets.CIFAR10(root./dataset, trainFalse,transformdataset_transform, downloadTrue)
print(test_set[0])
img, target test_set[0] # target对应类的编号 对应cat
print(img)
print(target)
print(test_set.classes[target])for i in range(10):img, target test_set[i]writer.add_image(torchvision,img,i)DataLoader的使用 drop_lastTrue 表示如果最后一个批次的样本数量小于批次大小则丢弃该批次而 drop_lastFalse 则表示保留最后一个不完整的批次
import torchvision
from torchvision import transforms
from torch.utils.data import DataLoader
dataset_transform transforms.Compose([transforms.ToTensor()
])
test_set torchvision.datasets.CIFAR10(root./dataset, trainFalse,transformdataset_transform, downloadTrue)
test_loader DataLoader(datasettest_set, batch_size4, shuffleTrue, num_workers0, drop_lastFalse)
img, target test_set[0]
print(单个img:,img.shape)
print(单个target:,target)for data in test_loader:imgs,targets dataprint(imgs.shape)print(targets)import torchvision
from torchvision import transforms
from torch.utils.tensorboard import SummaryWriter
from torch.utils.data import DataLoader
dataset_transform transforms.Compose([transforms.ToTensor()
])
test_set torchvision.datasets.CIFAR10(root./dataset, trainFalse,transformdataset_transform, downloadTrue)
test_loader DataLoader(datasettest_set, batch_size64, shuffleTrue, num_workers0, drop_lastFalse)
img, target test_set[0]
print(单个img:,img.shape)
print(单个target:,target)writer SummaryWriter(logs) # 日志文件存储位置
step 0
for data in test_loader:imgs,targets datawriter.add_images(test_data,imgs,step)step step 1writer.close()使用shuffle参数进行打乱
import torchvision
from torchvision import transforms
from torch.utils.tensorboard import SummaryWriter
from torch.utils.data import DataLoader
dataset_transform transforms.Compose([transforms.ToTensor()
])
test_set torchvision.datasets.CIFAR10(root./dataset, trainFalse,transformdataset_transform, downloadTrue)
test_loader DataLoader(datasettest_set, batch_size64, shuffleTrue, num_workers0, drop_lastFalse)
img, target test_set[0]
print(单个img:,img.shape)
print(单个target:,target)writer SummaryWriter(logs) # 日志文件存储位置
for epoch in range(2):step 0for data in test_loader:imgs,targets datawriter.add_images(Epoch:{}.format(epoch),imgs,step)step step 1writer.close()神经网络的基本骨架nn.Module的使用 常用的的包torch.nn 神经网络的基类Module定义的模型都需要集成该类nn.Module 自己定义的模型需要实现__init__和forward函数
import torch
from torch import nn
class Tudui(nn.Module):def __init__(self):super().__init__()def forward(self, input):output input 1return output
tudui Tudui()
x torch.tensor(1.0)
myout tudui(x)
print(myout)代码的执行流程可通过Pycharm进行debug 使用Step into My Code进行查看 tudui Tudui()进行类的实例化首先会调用__init__函数然后执行 super().__init__() 当调用一个 nn.Module 的实例时例如 tudui(x)PyTorch 会自动触发该实例的 forward 方法。这是因为 nn.Module 类在 Python 中被视为一个可调用对象这是通过在 nn.Module 类中实现特殊方法__call__()来实现的。
__call__ 方法在 nn.Module 中被定义为调用 forward 方法的包装器像函数一样调用一个 nn.Module 实例时实际上是在执行 forward 方法并将传入的参数在这个例子中是 x作为输入传递给 forward 方法
卷积操作 理论讲解请看P17 讲的很清晰 以上是torch.nn.functional.conv2d的参数要求
import torch
import torch.nn.functional as F
input torch.tensor([[1,2,0,3,1],[0,1,2,3,1],[1,2,1,0,0],[5,2,3,1,1],[2,1,0,1,1]])
kernel torch.tensor([[1,2,1],[0,1,0],[2,1,0]])
input torch.reshape(input,(1,1,5,5)) # 变换input维度使其满足torch.nn.functional.conv2d的参数要求
kernel torch.reshape(kernel,(1,1,3,3))
print(input.shape)
print(kernel.shape)output F.conv2d(input,kernel,stride1)
print(output)卷积层的使用 卷积操作可视化链接 dilation是空洞卷积默认值是1 out_channels是指经过卷积核之后输出的特征图的通道数 个人补充内容请理解以下两个式子 输入特征图的通道数 卷积核的通道数 输出特征图的通道数 卷积核的个数 解释卷积核的通道数一定和输入的通道数相等输入对应的每个通道与卷积核对应的每个通道进行计算再求和得到 一个通道的卷积输出而输出特征图的通道数与卷积核的个数相关有多少个卷积核最终就有多少个输出通道 如果理解不够清晰请看下图
卷积练习代码
import torch
import torchvision
from torch.utils.data import DataLoader
from torch import nn
from torch.nn import Conv2d
from torch.utils.tensorboard import SummaryWriter dataset torchvision.datasets.CIFAR10(./dataset,train False, transform torchvision.transforms.ToTensor(), downloadTrue)
dataloader DataLoader(dataset, batch_size64)#搭建网络
class Tudui(nn.Module):def __init__(self):super(Tudui, self).__init__()self.conv1 Conv2d(in_channels3, out_channels6, kernel_size3, stride1, padding0)def forward(self, x):x self.conv1(x)return xwriter SummaryWriter(logs) # 日志文件存储位置
tudui Tudui()
print(tudui)step 0
for data in dataloader:imgs, targets dataoutput tudui(imgs)print(原图像的形状,imgs.shape)print(卷积之后图像的形状,output.shape)writer.add_images(input,imgs,step)# 卷积之后图像的形状 torch.Size([64, 6, 30, 30])是6个通道的 而add_images只能接收3通道的输入 output torch.reshape(output, (-1, 3, 30, 30))#不严谨操作 ---对output进行reshape 增大batchsize的数量 减少通道数writer.add_images(Conv_output,output,step) step step 1
writer.close()卷积之后图像的形状 torch.Size([64, 6, 30, 30])是6个通道的 而add_images只能接收3通道的输入 如果不对output进行reshape 增大batchsize的数量 减少通道数会报以下错误 tensorboard的输出结果
最大池化层 保留输入的特征同时减少数据量 加快训练速度 最大池化层的步长默认大小为kernel_size ceil_mode ceil向上取整floor向下取整 ceil 允许有出界部分floor 不允许 ceil_mode True时 为ceil 池化层有三个特点1.没有需要学习的参数2.通道数保持不变3.对微小位置的变化具有鲁棒性
import torch
from torch import nn
from torch.nn import MaxPool2d
input torch.tensor([[1,2,0,3,1],[0,1,2,3,1],[1,2,1,0,0],[5,2,3,1,1],[2,1,0,1,1]],dtypetorch.float32)
input torch.reshape(input,(-1,1,5,5))
print(input.shape)class Tudui(nn.Module):def __init__(self):super(Tudui,self).__init__()self.maxpool1 MaxPool2d(kernel_size3,ceil_modeTrue)def forward(self,input):output self.maxpool1(input)return outputtudui Tudui()
output tudui(input)
print(output)import torch
from torch import nn
from torch.nn import MaxPool2d
input torch.tensor([[1,2,0,3,1],[0,1,2,3,1],[1,2,1,0,0],[5,2,3,1,1],[2,1,0,1,1]],dtypetorch.float32)
input torch.reshape(input,(-1,1,5,5))
print(input.shape)class Tudui(nn.Module):def __init__(self):super(Tudui,self).__init__()self.maxpool1 MaxPool2d(kernel_size3,ceil_modeFalse)def forward(self,input):output self.maxpool1(input)return outputtudui Tudui()
output tudui(input)
print(output)与手动计算的最大池化一致
import torch
import torchvision
from torch.utils.data import DataLoader
from torch import nn
from torch.utils.tensorboard import SummaryWriter
from torch.nn import MaxPool2d
dataset torchvision.datasets.CIFAR10(./dataset,train False, transform torchvision.transforms.ToTensor(), downloadTrue)
dataloader DataLoader(dataset, batch_size64)#搭建网络
class Tudui(nn.Module):def __init__(self):super(Tudui,self).__init__()self.maxpool1 MaxPool2d(kernel_size3,ceil_modeFalse)def forward(self,input):output self.maxpool1(input)return outputwriter SummaryWriter(logs) # 日志文件存储位置
tudui Tudui()
print(tudui)step 0
for data in dataloader:imgs, targets dataoutput tudui(imgs)print(原图像的形状,imgs.shape)print(池化之后图像的形状,output.shape)writer.add_images(maxpool_input,imgs,step)writer.add_images(maxpool_output,output,step) step step 1
writer.close()非线性激活层引入非线性的特性使得神经网络具有更强的表达能力和适应能力 inplace参数的含义为True时对原输入进行激活函数的计算计算结果赋给原输入为False时返回对原输入进行激活函数的计算的结果原输入不发生改变保留原始数据默认为False ReLU的使用
import torch
from torch import nn
from torch.nn import ReLU
input torch.tensor([[1, -0.5],[-1, 3]])
input torch.reshape(input,(-1, 1, 2, 2)) #增加一个batchsize维
print(input.shape)class Tudui(nn.Module):def __init__(self):super(Tudui,self).__init__()self.relu1 ReLU()def forward(self, input):output self.relu1(input)return outputtudui Tudui()
output tudui(input)
print(output) Sigmoid的使用
import torch
import torchvision
from torch.utils.data import DataLoader
from torch import nn
from torch.utils.tensorboard import SummaryWriter
from torch.nn import Sigmoid
dataset torchvision.datasets.CIFAR10(./dataset,train False, transform torchvision.transforms.ToTensor(), downloadTrue)
dataloader DataLoader(dataset, batch_size64)#搭建网络
class Tudui(nn.Module):def __init__(self):super(Tudui,self).__init__()self.sigmoid1 Sigmoid()def forward(self,input):output self.sigmoid1(input)return outputwriter SummaryWriter(logs) # 日志文件存储位置
tudui Tudui()
print(tudui)step 0
for data in dataloader:imgs, targets dataoutput tudui(imgs)writer.add_images(before_activate,imgs,step)writer.add_images(after_activate,output,step) step step 1
writer.close()线性层全连接层及其他层介绍
import torch
import torchvision
from torch.utils.data import DataLoader
from torch import nn
from torch.utils.tensorboard import SummaryWriter
from torch.nn import Linear
dataset torchvision.datasets.CIFAR10(./dataset,train False, transform torchvision.transforms.ToTensor(), downloadTrue)
dataloader DataLoader(dataset, batch_size64, drop_lastTrue)#搭建网络
class Tudui(nn.Module):def __init__(self):super(Tudui,self).__init__()self.linear1 Linear(196608,10)def forward(self,input):output self.linear1(input)return outputtudui Tudui()
print(tudui)for data in dataloader:imgs, targets dataprint(原尺寸, imgs.shape) #【64,3,32,32】output torch.reshape(imgs,(1, 1, 1, -1)) # reshape后 变为【11,1,196608】print(reshape后尺寸,output.shape)output tudui(output)print(全连接层输出尺寸,output.shape) flatten层将输入张量扁平化flatten的函数。它将输入张量沿着指定的维度范围进行扁平化处理并返回一个一维张量作为结果 input: 输入张量即要进行扁平化操作的张量。 start_dim: 指定开始扁平化的维度。默认为0即从第0维开始扁平化。 end_dim: 指定结束扁平化的维度包含在内。默认为-1即扁平化至最后一维。
t torch.tensor([[[1, 2],[3, 4]],[[5, 6],[7, 8]]])
torch.flatten(t)
torch.flatten(t, start_dim1)import torch
import torchvision
from torch.utils.data import DataLoader
from torch import nn
from torch import flatten
from torch.utils.tensorboard import SummaryWriter
from torch.nn import Linear
dataset torchvision.datasets.CIFAR10(./dataset,train False, transform torchvision.transforms.ToTensor(), downloadTrue)
dataloader DataLoader(dataset, batch_size64, drop_lastTrue)#搭建网络
class Tudui(nn.Module):def __init__(self):super(Tudui,self).__init__()self.linear1 Linear(196608,10)def forward(self,input):output self.linear1(input)return outputtudui Tudui()
print(tudui)for data in dataloader:imgs, targets dataprint(原尺寸, imgs.shape) #【64,3,32,32】output flatten(imgs)print(flatten后尺寸,output.shape)output tudui(output)print(全连接层输出尺寸,output.shape) 网络搭建以及Sequential的使用 顺序容器可以按照添加的顺序依次执行包含的各个模块torch.nn.Sequential提供了一种简单的方式来构建神经网络模型代码十分简洁。 各层输入输出顺序如下图所示
搭建上图中的网络各层的padding和stride需要手动计算一下 最后两步的线性层中略有省略在此补充
#未使用sequential
from torch import nn
from torch.nn import Module
from torch.nn import Conv2d
from torch.nn import MaxPool2d,Flatten,Linear
import torchclass Tudui(nn.Module):def __init__(self):super(Tudui,self).__init__()self.conv1 Conv2d(3, 32, 5, padding2)self.maxpool1 MaxPool2d(2)self.conv2 Conv2d(32, 32, 5, padding2)self.maxpool2 MaxPool2d(2)self.conv3 Conv2d(32,64,5, padding2)self.maxpool3 MaxPool2d(2)self.flatten Flatten()self.linear1 Linear(1024,64)self.linear2 Linear(64, 10)def forward(self, x):x self.conv1(x)x self.maxpool1(x)x self.conv2(x)x self.maxpool2(x)x self.conv3(x)x self.maxpool3(x)x self.flatten(x)x self.linear1(x)x self.linear2(x)return xtudui Tudui()
print(tudui)input torch.ones((64, 3, 32, 32))
output tudui(input)
print(output.shape)搭建网络并构造3*32*32的数据输入网络检验网络各层输入输出的正确性 使用Sequential并使用tensorboard添加计算图
from torch import nn
from torch.nn import Module
from torch.nn import Conv2d
from torch.nn import MaxPool2d,Flatten,Linear, Sequential
import torch
from torch.utils.tensorboard import SummaryWriter #使用sequential
class Tudui(nn.Module):def __init__(self):super(Tudui,self).__init__()self.model1 Sequential(Conv2d(3, 32, 5, padding2),MaxPool2d(2),Conv2d(32, 32, 5, padding2),MaxPool2d(2),Conv2d(32,64,5, padding2),MaxPool2d(2),Flatten(),Linear(1024,64),Linear(64, 10))def forward(self, x):x self.model1(x)return xwriter SummaryWriter(logs) # 日志文件存储位置
writer.add_graph(tudui, input)
tudui Tudui()
print(tudui)input torch.ones((64, 3, 32, 32))
output tudui(input)
print(output.shape)
writer.close()在tensorboard中打开点击GRAPHS writer.add_graph(模型, 可选参数–模型的输入数据)是 TensorBoardX 库中用于将模型结构添加到 TensorBoard 中的函数。它可以将 PyTorch 模型的计算图可视化方便查看模型的层次结构和数据流动 点击Tudui可查看详细结构
torch.nn中的损失函数 损失函数Loss Function用于衡量模型的预测输出与实际标签之间的差异或者误差损失越小越好根据loss调整参数反向传播更新输出减小损失
import torch
from torch.nn import L1Lossinputs torch.tensor([1,2,3],dtypetorch.float32)
targets torch.tensor([1,2,5],dtypetorch.float32)inputs torch.reshape(inputs, (1,1,1,3))
targets torch.reshape(targets, (1,1,1,3))
loss L1Loss()
result loss(inputs,targets)
print(result)loss2 L1Loss(reductionsum)
result2 loss2(inputs,targets)
print(result2)均方损失
import torch
from torch.nn import L1Loss,MSELossinputs torch.tensor([1,2,3],dtypetorch.float32)
targets torch.tensor([1,2,5],dtypetorch.float32)inputs torch.reshape(inputs, (1,1,1,3))
targets torch.reshape(targets, (1,1,1,3))
loss L1Loss()
result loss(inputs,targets)
print(result)loss2 L1Loss(reductionsum)
result2 loss2(inputs,targets)
print(result2)mse_loss MSELoss()
mse_result mse_loss(inputs,targets)
print(mse_result)分类问题常用损失torch.nn.CrossEntropyLoss交叉熵损失函数 交叉熵损失函数Cross-Entropy Loss Function是在分类问题中经常使用的一种损失函数特别是在多分类问题中。它衡量了模型输出的概率分布与真实标签之间的差异通过最小化交叉熵损失来调整模型参数使得模型更好地适应分类任务。 当分类预测正确时损失要比较小上式两项左边的项相比右边的项应较大
import torch
from torch.nn import CrossEntropyLossx torch.tensor([0.1, 0.2, 0.3])
y torch.tensor([1])
x torch.reshape(x,(1,3))
loss_cross CrossEntropyLoss()
result_cross loss_cross(x, y )
print(result_cross)loss function的使用应根据需求选定好损失函数后按损失函数要求的维度形状输入
使用前面搭建的网络结合CrossEntropyLoss计算损失
from torch import nn
from torch.nn import Module
from torch.nn import Conv2d
from torch.nn import MaxPool2d,Flatten,Linear, Sequential
import torch
import torchvision
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter dataset torchvision.datasets.CIFAR10(./dataset,train False, transform torchvision.transforms.ToTensor(), downloadTrue)
dataloader DataLoader(dataset, batch_size1, drop_lastTrue)#使用sequential
class Tudui(nn.Module):def __init__(self):super(Tudui,self).__init__()self.model1 Sequential(Conv2d(3, 32, 5, padding2),MaxPool2d(2),Conv2d(32, 32, 5, padding2),MaxPool2d(2),Conv2d(32,64,5, padding2),MaxPool2d(2),Flatten(),Linear(1024,64),Linear(64, 10) )def forward(self, x):x self.model1(x)return xloss nn.CrossEntropyLoss()
tudui Tudui()
for data in dataloader:imgs, targets dataoutputs tudui(imgs)
# print(outputs)
# print(targets)result_loss loss(outputs, targets)print(result_loss) 关于outputs和targets的维度匹配的问题 在你提供的代码中outputs 和 targets 的维度能够匹配上这是因为在构建 Tudui 类时你没有对输入图片进行展平Flatten因此输入的图片在经过 Sequential 中的各个层时维度会保持在图片数据的维度上例如 [batch_size, channels, height, width]并且在经过最后一个线性层时会自动展平为 [batch_size, num_classes] 的形状其中 num_classes 是输出的类别数量。 让我们具体分析一下 输入的图片 imgs 的维度为 [batch_size, channels, height, width]例如 [1, 3, 32, 32]假设 batch size 为 1图像大小为 32x32并且有 3 个通道。 在 Tudui 类中通过 Sequential 定义了模型结构但没有对输入图片进行展平操作因此保持了输入图片的维度。 经过 Sequential 中的各个层之后最后一个线性层的输出会自动展平为 [batch_size, num_classes] 的形状其中 num_classes 是输出的类别数量这里是 10因为 CIFAR-10 数据集有 10 个类别。 因此在计算损失时outputs 的维度为 [batch_size, num_classes]与 targets 的维度 [batch_size] 是匹配的因为交叉熵损失函数 nn.CrossEntropyLoss() 会自动处理这种情况它期望 outputs 的形状是 [batch_size, num_classes]并且 targets 的形状是 [batch_size]它会自动将 targets 进行 one-hot 编码并计算交叉熵损失。 反向传播 张量梯度的属性grad 自动求导Autograd 在张量上进行操作时PyTorch 会自动跟踪操作并构建计算图可以使用 .backward() 方法反向传播计算梯度然后通过 .grad 属性获取梯度值。 在pycharm中对该行打断点可以看到具体的梯度值
from torch import nn
from torch.nn import Module
from torch.nn import Conv2d
from torch.nn import MaxPool2d,Flatten,Linear, Sequential
import torch
import torchvision
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter dataset torchvision.datasets.CIFAR10(./dataset,train False, transform torchvision.transforms.ToTensor(), downloadTrue)
dataloader DataLoader(dataset, batch_size1, drop_lastTrue)#使用sequential
class Tudui(nn.Module):def __init__(self):super(Tudui,self).__init__()self.model1 Sequential(Conv2d(3, 32, 5, padding2),MaxPool2d(2),Conv2d(32, 32, 5, padding2),MaxPool2d(2),Conv2d(32,64,5, padding2),MaxPool2d(2),Flatten(),Linear(1024,64),Linear(64, 10) )def forward(self, x):x self.model1(x)return xloss nn.CrossEntropyLoss()
tudui Tudui()
for data in dataloader:imgs, targets dataoutputs tudui(imgs)result_loss loss(outputs, targets)result_loss.backward()print(result_loss)
当未使用.backward()时grad属性会一直为None 这里还未使用优化器结合优化器可以对参数进行优化降低loss
优化器的使用torch.optim 在深度学习中optimizer.zero_grad()是一个非常重要的操作它的含义是将模型参数的梯度清零。 在训练神经网络时通常采用反向传播算法Backpropagation来计算损失函数关于模型参数的梯度并利用优化器optimizer来更新模型参数以最小化损失函数。在每次反向传播计算梯度后梯度信息会被累积在对应的参数张量tensor中。如果不清零梯度在下一次计算梯度时这些梯度将会被新计算的梯度累加导致梯度信息错误。 optimizer.zero_grad()的作用如下
先进行optimizer.zero_grad()再进行计算loss进行反向传播loss.backward()之后再进行optim.step() optim.step()是优化器对象如SGD、Adam等的一个方法用于根据计算得到的梯度更新模型的参数
for data in dataloader循环完相当于对数据进行了一轮的学习看了一遍在这个for循环中用这次看到的数据更新网络参数对下一次看到的数据影响不大因为只对整个数据看了一遍这时的loss变化不大
from torch import nn
from torch.nn import Module
from torch.nn import Conv2d
from torch.nn import MaxPool2d,Flatten,Linear, Sequential
import torch
import torchvision
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter dataset torchvision.datasets.CIFAR10(./dataset,train False, transform torchvision.transforms.ToTensor(), downloadTrue)
dataloader DataLoader(dataset, batch_size1, drop_lastTrue)#使用sequential
class Tudui(nn.Module):def __init__(self):super(Tudui,self).__init__()self.model1 Sequential(Conv2d(3, 32, 5, padding2),MaxPool2d(2),Conv2d(32, 32, 5, padding2),MaxPool2d(2),Conv2d(32,64,5, padding2),MaxPool2d(2),Flatten(),Linear(1024,64),Linear(64, 10) )def forward(self, x):x self.model1(x)return xloss nn.CrossEntropyLoss()
tudui Tudui()
optim torch.optim.SGD(tudui.parameters(), lr0.01, )for data in dataloader:imgs, targets dataoutputs tudui(imgs)result_loss loss(outputs, targets)optim.zero_grad()result_loss.backward()optim.step()print(result_loss)因此需要引入epoch对数据多扫几遍 for data in dataloader循环 这个循环通常用于遍历数据集中的每个批次batch数据。 dataloader是一个用于批次化处理数据的工具它会将数据集按照指定的批次大小分割并提供数据加载的迭代器。 在每次迭代中for data in dataloader会从数据加载器中获取一个批次的数据然后你可以对这个批次的数据进行前向传播、计算损失、反向传播和参数更新等操作。 这个循环通常嵌套在训练循环中用于处理每个训练批次的数据。 for epoch in range(X)循环 这个循环用于控制整个训练过程的迭代次数其中X代表训练的总轮数epochs。 一个epoch表示将数据集中的所有样本都用于训练一次通常情况下训练过程会重复多个epoch以便模型能够更好地学习数据的特征。 在每个epoch循环中你会执行多次for data in dataloader循环每次处理一个批次的数据并进行前向传播、损失计算、反向传播和参数更新等训练步骤。 一般来说训练过程会在每个epoch结束时进行模型评估例如计算验证集上的准确率或损失以便监控模型的训练情况和避免过拟合。 综上所述for data in dataloader循环用于处理单个批次的数据而for epoch in range(X)循环用于控制整个训练过程的迭代次数确保模型能够在整个数据集上进行多次学习和优化。在实际的训练过程中这两个循环通常会结合使用以完成模型的训练任务。
from torch import nn
from torch.nn import Module
from torch.nn import Conv2d
from torch.nn import MaxPool2d,Flatten,Linear, Sequential
import torch
import torchvision
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter dataset torchvision.datasets.CIFAR10(./dataset,train False, transform torchvision.transforms.ToTensor(), downloadTrue)
dataloader DataLoader(dataset, batch_size1, drop_lastTrue)#使用sequential
class Tudui(nn.Module):def __init__(self):super(Tudui,self).__init__()self.model1 Sequential(Conv2d(3, 32, 5, padding2),MaxPool2d(2),Conv2d(32, 32, 5, padding2),MaxPool2d(2),Conv2d(32,64,5, padding2),MaxPool2d(2),Flatten(),Linear(1024,64),Linear(64, 10) )def forward(self, x):x self.model1(x)return xloss nn.CrossEntropyLoss()
tudui Tudui()
optim torch.optim.SGD(tudui.parameters(), lr0.01, )
for epoch in range(20):running_loss 0.0for data in dataloader:imgs, targets dataoutputs tudui(imgs)result_loss loss(outputs, targets)optim.zero_grad()result_loss.backward()optim.step()running_loss running_loss result_loss # running_loss相当于扫一遍全部数据的loss总和print(running_loss)
【注】运行会比较慢执行几个epoch看下loss的变化情况即可
使用pytorch提供的网络模型VGG16 以上是博主2024年3月官网截图vgg16的调用方法已经发生改变与小土堆视频中的调用方法发生改变不再有参数pretrained而是变成了参数weights 我使用的是torch 1.11.0版本支持参数pretrained
import torchvisionvgg16_false torchvision.models.vgg16(pretrainedFalse) #pretrainedFalse仅加载网络模型无参数vgg16_true torchvision.models.vgg16(pretrainedTrue) #pretrainedTrue加载网络模型并从网络中下载在数据集上训练好的参数
print(vgg16_true)权重会被下载到这个文件夹中C:\Users\用户名.cache\torch\hub\checkpoints 有下载问题的可以使用我下载好的文件放置在对应文件路径下即可 链接https://pan.baidu.com/s/1DqR9GK1VJBJgWUqTCUQXWA 提取码cfjx 可通过以下命令torch.hub.set_dir(新路径)来设置自定义的缓存文件夹路径
import torchvision.models as models# 设置自定义缓存文件夹路径
torch.hub.set_dir(/path/to/custom/cache/dir/)
# 加载预训练的VGG16模型
vgg16 models.vgg16(pretrainedTrue)修改VGG网络对1000类进行分类 在网络最后添加一个线性层 在CIFAR10上对10类进行分类 使用add_module()方法
import torchvision
import torch.nn as nn
vgg16_true torchvision.models.vgg16(pretrainedTrue) #pretrainedTrue加载网络模型并从网络中下载在数据集上训练好的参数
dataset torchvision.datasets.CIFAR10(./dataset,train False, transform torchvision.transforms.ToTensor(), downloadTrue)
vgg16_true.add_module(add_linear, nn.Linear(1000,10))
print(vgg16_true)将添加的线性层加在classifier中
import torchvision
import torch.nn as nn
vgg16_true torchvision.models.vgg16(pretrainedTrue) #pretrainedTrue加载网络模型并从网络中下载在数据集上训练好的参数
dataset torchvision.datasets.CIFAR10(./dataset,train False, transform torchvision.transforms.ToTensor(), downloadTrue)
vgg16_true.classifier.add_module(add_linear, nn.Linear(1000,10))
print(vgg16_true)不添加层仅修改vgg原有网络
import torchvision
import torch.nn as nn
vgg16_true torchvision.models.vgg16(pretrainedTrue) #pretrainedTrue加载网络模型并从网络中下载在数据集上训练好的参数
print(修改前,vgg16_true)
dataset torchvision.datasets.CIFAR10(./dataset,train False, transform torchvision.transforms.ToTensor(), downloadTrue)
vgg16_true.classifier[6] nn.Linear(4096,10)
print(修改后,vgg16_true)模型的保存与读取 两种保存方式 ①torch.save(vgg16,vgg16_method1.pth)保存模型结构及模型参数 ②torch.save(vgg16.state_dict(),vgg16_method2.pth)仅保存模型参数存为字典不保存模型结构官方推荐
import torchvision
import torch
vgg16 torchvision.models.vgg16(pretrainedFalse)
# 保存方式1--保存模型结构及模型参数
torch.save(vgg16,vgg16_method1.pth)# 保存方式2--仅保存模型参数存为字典不保存模型结构官方推荐
torch.save(vgg16.state_dict(),vgg16_method2.pth)两种读取方式 ①model torch.load(vgg16_method1.pth) 加载模型结构 参数方式 ②vgg16 torchvision.models.vgg16(pretrainedFalse) vgg16.load_state_dict(torch.load(vgg16_method2.pth)) 为方式2创建模型结构并加载参数的完整写法
import torch
import torchvision
# 保存方式1对应的加载模型结构 参数方式
model torch.load(vgg16_method1.pth)
print(model)# 保存方式2对应的加载模型参数方式
model2 torch.load(vgg16_method2.pth) #加载的是字典
print(model2)vgg16 torchvision.models.vgg16(pretrainedFalse) #为方式2创建模型结构并加载参数的完整写法
vgg16.load_state_dict(torch.load(vgg16_method2.pth))
print(vgg16)方式1 torch.load(“vgg16_method1.pth”)存在的问题 保存模型参数
import torch
from torch import nn
class Tudui(nn.Module):def __init__(self):super(Tudui, self).__init__()self.conv1 nn.Conv2d(3, 64, kernel_size 3)def forward(self, x):x self.conv1(x)return xtudui Tudui()
torch.save(tudui,tudui_method1.pth)读取模型及参数
import torchmodel torch.load(tudui_method1.pth)
print(model)亲测在jupyter notebook中不会报错 而在pycharm中会报AttributeError: Cant get attribute Tudui on module __main__ from D:/DongShouRL/pytorch/nn_load.py 个人猜测原因应该是在一个jupyter notebook是能够找到Tudui这个类的而在Pycharm中上述读取和保存在两个文件中导致找不到Tudui这个类故报上述错误
解决方法①要么在读取的文件中把模型的定义复制过来
import torch
import torch.nn as nn
class Tudui(nn.Module):def __init__(self):super(Tudui, self).__init__()self.conv1 nn.Conv2d(3, 64, kernel_size3)def forward(self, x):x self.conv1(x)return xmodel torch.load(tudui_method1.pth)
print(model)②导入对应的类使用from nn_save import Tudui
import torch
import torch.nn as nn
from nn_save import Tudui# class Tudui(nn.Module):
# def __init__(self):
# super(Tudui, self).__init__()
# self.conv1 nn.Conv2d(3, 64, kernel_size3)
#
# def forward(self, x):
# x self.conv1(x)
# return xmodel torch.load(tudui_method1.pth)
print(model)print格式化输出字符串 print函数的format是一种格式化输出字符串的方法用来插入变量值或格式化输出字符串的样式 将{}的地方替换为变量值
name Alice
age 30
print(My name is {} and I am {} years old..format(name, age))搭建后面要用的神经网络
# model.py
from torch import nn
import torch
# 搭建神经网络
class Tudui(nn.Module):def __init__(self):super(Tudui, self).__init__()self.model nn.Sequential(nn.Conv2d(3, 32, 5, 1, padding2),nn.MaxPool2d(2),nn.Conv2d(32, 32, 5, 1, padding2),nn.MaxPool2d(2),nn.Conv2d(32, 64, 5, 1, padding2),nn.MaxPool2d(2),nn.Flatten(), # 展平后的序列长度为 64*4*41024nn.Linear(1024, 64),nn.Linear(64, 10))def forward(self, x):x self.model(x)return xif __name__ __main__:tudui Tudui()input torch.ones((64, 3, 32, 32))output tudui(input)print(output.shape)
构造输入测试网络搭建是否正确
如果在其他文件中import报错 将文件所在目录Mark Directory as Sources Root
item()函数 item()函数用于从只包含单个元素的张量中提取Python数值将张量转换为标量值
import torch# 创建一个只包含一个元素的张量
tensor torch.tensor([3.14])# 使用item()函数获取张量的数值
value tensor.item()print(Value extracted using item():, value)
print(Type of extracted value:, type(value)) torch.no_grad() 在推理或评估模型时使用torch.no_grad()表明当前计算不需要反向传播使用之后强制后边的内容不进行计算图的构建 with 语句是 Python 中的一个语法结构用于包裹代码块的执行并确保在代码块执行完毕后能够自动执行一些清理工作。 完整的模型训练与测试套路
from torch.utils.tensorboard import SummaryWriterfrom model import *
import torchvision
import torch.nn as nn
from torch.utils.data import DataLoader
# 准备数据集
train_data torchvision.datasets.CIFAR10(../dataset,trainTrue, transformtorchvision.transforms.ToTensor(),downloadTrue)
test_data torchvision.datasets.CIFAR10(../dataset,trainFalse, transformtorchvision.transforms.ToTensor(),downloadTrue)
# len()获取数据集长度
train_data_size len(train_data)
test_data_size len(test_data)
print(训练数据集的长度为{}.format(train_data_size))
print(测试数据集的长度为{}.format(test_data_size))# 利用dataloader加载数据集
train_dataloader DataLoader(train_data, batch_size64, drop_lastTrue)
test_dataloader DataLoader(test_data, batch_size64, drop_lastTrue)#创建网络模型
tudui Tudui()# 损失函数
loss_fn nn.CrossEntropyLoss()# 优化器
learning_rate 1e-2
optimizer torch.optim.SGD(tudui.parameters(), lrlearning_rate)# 设置训练网络的一些参数
# 记录训练的次数
total_train_step 0# 记录测试的次数
total_test_step 0# 训练的轮数
epoch 10# 添加tensorboard
writer SummaryWriter(../logs_train)for i in range(epoch):print(-------------第 {} 轮训练开始------------.format(i1))#训练步骤开始for data in train_dataloader:imgs, targets dataoutput tudui(imgs)loss loss_fn(output, 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)# 测试步骤开始total_test_loss 0with torch.no_grad():for data in test_dataloader:imgs, targets dataoutputs tudui(imgs)loss loss_fn(outputs, targets)total_test_loss total_test_loss loss.item()print(整体测试集上的Loss{}.format(total_test_loss))writer.add_scalar(test_loss,total_test_loss, total_test_step)total_test_step total_test_step 1torch.save(tudui, tudui_{}.pth.format(i))print(模型已保存)
writer.close() 分类问题计算正确率的方法 argmax 是一个数学和编程中常用的术语它表示找到一个函数或数组中最大值的索引或位置。在 PyTorch 中torch.argmax 是一个函数用于返回输入张量Tensor中最大值的索引。
import torchoutputs torch.tensor([[0.1, 0.2],[0.3, 0.4]])
print(outputs.argmax(1))
preds outputs.argmax(1)
targets torch.tensor([0,1])
print(preds targets)
print((preds targets).sum())补充正确率代码
from torch.utils.tensorboard import SummaryWriterfrom model import *
import torchvision
import torch.nn as nn
from torch.utils.data import DataLoader
# 准备数据集
train_data torchvision.datasets.CIFAR10(../dataset,trainTrue, transformtorchvision.transforms.ToTensor(),downloadTrue)
test_data torchvision.datasets.CIFAR10(../dataset,trainFalse, transformtorchvision.transforms.ToTensor(),downloadTrue)
# len()获取数据集长度
train_data_size len(train_data)
test_data_size len(test_data)
print(训练数据集的长度为{}.format(train_data_size))
print(测试数据集的长度为{}.format(test_data_size))# 利用dataloader加载数据集
train_dataloader DataLoader(train_data, batch_size64, drop_lastTrue)
test_dataloader DataLoader(test_data, batch_size64, drop_lastTrue)#创建网络模型
tudui Tudui()# 损失函数
loss_fn nn.CrossEntropyLoss()# 优化器
learning_rate 1e-2
optimizer torch.optim.SGD(tudui.parameters(), lrlearning_rate)# 设置训练网络的一些参数
# 记录训练的次数
total_train_step 0# 记录测试的次数
total_test_step 0# 训练的轮数
epoch 10# 添加tensorboard
writer SummaryWriter(../logs_train)for i in range(epoch):print(-------------第 {} 轮训练开始------------.format(i1))#训练步骤开始tudui.train()for data in train_dataloader:imgs, targets dataoutput tudui(imgs)loss loss_fn(output, 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)# 测试步骤开始tudui.eval()total_test_loss 0total_accuracy 0with torch.no_grad():for data in test_dataloader:imgs, targets dataoutputs tudui(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,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 1torch.save(tudui, tudui_{}.pth.format(i))print(模型已保存)
writer.close()model.train()和model.eval() model.train()开启训练模式模型会跟踪所有层的梯度以便在优化器如 torch.optim.SGD 或 torch.optim.Adam进行梯度下降时更新模型的权重。此外train() 方法还会将模型中的某些层如 BatchNorm 和 Dropout设置为训练行为。
BatchNorm 层对于包含 BatchNorm批量归一化层的模型model.train() 确保在训练过程中使用每一批数据来计算层的运行均值和方差。这些运行统计量用于归一化网络的激活值有助于提高训练的稳定性和性能。
Dropout 层对于包含 Dropout 层的模型model.train() 在训练过程中随机选择一部分网络连接进行训练即“丢弃”一部分神经元的输出。这样做可以防止网络过拟合因为每次训练时只有一部分神经元被激活从而增加了模型的泛化能力。 model.eval()开启评估模式在评估模式下模型不会跟踪梯度这有助于减少内存消耗并提高计算效率。此外eval() 方法还会将模型中的某些层如 BatchNorm 和 Dropout设置为评估行为这意味着它们的行为会根据固定的参数进行调整而不是根据训练数据。 在评估模式model.eval()下BatchNorm 层会使用在训练过程中学习到的均值和方差而不是使用当前批次的数据。 在评估模式下Dropout 层会被禁用所有的神经元都会保留其输出确保评估时的确定性。 当网络中有这些Dropout、BatchNorm 层时一定要调用model.train()和model.eval()当网络不含这些层时不进行调用也可以
使用GPU进行训练方式1 xx xx.cuda() 训练数据和测试数据都要.cuda()
from torch.utils.tensorboard import SummaryWriterimport torch
import torchvision
import torch.nn as nn
from torch.utils.data import DataLoader
# 准备数据集
train_data torchvision.datasets.CIFAR10(../dataset,trainTrue, transformtorchvision.transforms.ToTensor(),downloadTrue)
test_data torchvision.datasets.CIFAR10(../dataset,trainFalse, transformtorchvision.transforms.ToTensor(),downloadTrue)
# len()获取数据集长度
train_data_size len(train_data)
test_data_size len(test_data)
print(训练数据集的长度为{}.format(train_data_size))
print(测试数据集的长度为{}.format(test_data_size))# 利用dataloader加载数据集
train_dataloader DataLoader(train_data, batch_size64, drop_lastTrue)
test_dataloader DataLoader(test_data, batch_size64, drop_lastTrue)#创建网络模型
class Tudui(nn.Module):def __init__(self):super(Tudui, self).__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(), # 展平后的序列长度为 64*4*41024nn.Linear(1024, 64),nn.Linear(64, 10))def forward(self, x):x self.model(x)return xtudui Tudui()
if torch.cuda.is_available():tudui tudui.cuda()# 损失函数
loss_fn nn.CrossEntropyLoss()
if torch.cuda.is_available():loss_fn loss_fn.cuda()
# 优化器
learning_rate 1e-2
optimizer torch.optim.SGD(tudui.parameters(), lrlearning_rate)# 设置训练网络的一些参数
# 记录训练的次数
total_train_step 0# 记录测试的次数
total_test_step 0# 训练的轮数
epoch 10# 添加tensorboard
writer SummaryWriter(../logs_train)for i in range(epoch):print(-------------第 {} 轮训练开始------------.format(i1))#训练步骤开始tudui.train()for data in train_dataloader:imgs, targets dataif torch.cuda.is_available():imgs imgs.cuda()targets targets.cuda()output tudui(imgs)loss loss_fn(output, 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)# 测试步骤开始tudui.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 tudui(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,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 1torch.save(tudui, tudui_{}.pth.format(i))print(模型已保存)
writer.close()
在jupyter notebook中运行shell命令
!命令使用GPU进行训练方式2更常用 xx xx.to(device)
from torch.utils.tensorboard import SummaryWriterimport torch
import torchvision
import torch.nn as nn
from torch.utils.data import DataLoader# 定义训练的设备
device torch.device(cuda)
# 准备数据集
train_data torchvision.datasets.CIFAR10(./dataset,trainTrue, transformtorchvision.transforms.ToTensor(),downloadTrue)
test_data torchvision.datasets.CIFAR10(./dataset,trainFalse, transformtorchvision.transforms.ToTensor(),downloadTrue)
# len()获取数据集长度
train_data_size len(train_data)
test_data_size len(test_data)
print(训练数据集的长度为{}.format(train_data_size))
print(测试数据集的长度为{}.format(test_data_size))# 利用dataloader加载数据集
train_dataloader DataLoader(train_data, batch_size64, drop_lastTrue)
test_dataloader DataLoader(test_data, batch_size64, drop_lastTrue)#创建网络模型
class Tudui(nn.Module):def __init__(self):super(Tudui, self).__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(), # 展平后的序列长度为 64*4*41024nn.Linear(1024, 64),nn.Linear(64, 10))def forward(self, x):x self.model(x)return xtudui Tudui()
tudui tudui.to(device)# 损失函数
loss_fn nn.CrossEntropyLoss()
loss_fn loss_fn.to(device)# 优化器
learning_rate 1e-2
optimizer torch.optim.SGD(tudui.parameters(), lrlearning_rate)# 设置训练网络的一些参数
# 记录训练的次数
total_train_step 0# 记录测试的次数
total_test_step 0# 训练的轮数
epoch 10# 添加tensorboard
writer SummaryWriter(../logs_train)for i in range(epoch):print(-------------第 {} 轮训练开始------------.format(i1))#训练步骤开始tudui.train()for data in train_dataloader:imgs, targets dataimgs imgs.to(device)targets targets.to(device)output tudui(imgs)loss loss_fn(output, 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)# 测试步骤开始tudui.eval()total_test_loss 0total_accuracy 0with torch.no_grad():for data in test_dataloader:imgs, targets dataimgs imgs.to(device)targets targets.to(device)outputs tudui(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,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 1torch.save(tudui, tudui_{}.pth.format(i))print(模型已保存)
writer.close()
更便捷的写法
device torch.device(cuda if torch.cuda.is_available() else cpu)【注】前面讲的两种在GPU训练方法其实只有数据和标签(imgs和targets)需要进行 数据 数据.cuda() 或者 数据 数据.to(device) 模型和损失函数可以直接model.to() ,model.cuda() ,loss.to(),loss.cuda()而无需赋值 利用已经训练好的模型 提供输入进行验证
import torchvision
from PIL import Imageimage_path ./dog.png
image Image.open(image_path)
print(image)
image image.convert(RGB)
transform torchvision.transforms.Compose([torchvision.transforms.Resize((32,32)),torchvision.transforms.ToTensor()])
image transform(image)
print(image)class Tudui(nn.Module):def __init__(self):super(Tudui, self).__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(), # 展平后的序列长度为 64*4*41024nn.Linear(1024, 64),nn.Linear(64, 10))def forward(self, x):x self.model(x)return xmodel torch.load(tudui_0.pth,map_locationtorch.device(cuda))
print(model)
image torch.reshape(image,(1,3,32,32))
model.eval()
with torch.no_grad():image image.to(cuda)output model(image)
print(output)
print(output.argmax(1))使用gpu训练保存的模型在cpu上使用
model torch.load(XXXX.pth,map_location torch.device(cpu))map_locationtorch.device(cpu) 是在使用 PyTorch 的 torch.load 函数加载模型或张量时的一个参数它用于指定加载数据的目标设备。当你使用这个参数时你告诉 PyTorch 将加载的数据映射到 CPU 上而不是默认的 CUDA 设备如果你的系统上有 GPU。
运行python文件传入参数
python XXX.py --参数名 值练习代码文件 链接https://pan.baidu.com/s/1323fpWQiv0UrMS4vHGbN8g 提取码m0c4 完结撒花在此感谢小土堆制作的视频教程与阅读这篇博客的你~
