devbox
从前慢现在也慢
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【Pytorch深度学习框架入门】_pytorch框架

作者：从前慢现在也慢 | 2024-04-04 17:27:34

赞

踩

pytorch框架

1.pytorch加载数据

两个有用的工具箱：

help(torch.cuda.is_available) # 对函数进行操作

唤醒指定的python运行环境的命令：

conda activate 环境的名称

Dataset 和 Dataloader 

Dataset：提供一种方式去获取数据及其label

  • 如何获取每一个数据及其label
  • 告诉我们总共有多少数据

Dataloader ：为后面的网络提供不同的数据形式

  1. from torch.utils.data import Dataset #Dataset数据处理的包
  2. from PIL import Image
  3. import os
  4.  
  5. #定义数据处理的类
  6. class MyData(Dataset):
  7.     
  8.     #数据地址处理方法
  9.     def __init__(self,root_dir,label_dir):
  10.         self.root_dir = root_dir #读取数据文件的根地址
  11.         self.label_dir = label_dir #读取数据文件的字地址
  12.         self.path = os.path.join(self.root_dir,self.label_dir)# 将根地址和子地址进行拼接
  13.         self.img_path = os.listdir(self.path) #将图片的地址提取出来，并一个个存入到列表中去
  14.  
  15.     
  16.     #提取每一个图片的信息
  17.     def __getitem__(self, idx):
  18.         img_name = self.img_path[idx] #根据序号从列表中找到相应的图片地址
  19.         img_item_path = os.path.join(self.root_dir,self.label_dir,img_name)# 将根地址与图片地址进行拼接
  20.         img = Image.open(img_item_path) #将地址转换为图片的形式
  21.         label = self.label_dir# 读取标签的地址
  22.         return img,label #返回图片和标签
  23.  
  24.     #计算数据集的长度
  25.     def __len__(self):
  26.         return len(self.img_path)
  27.  
  28. root_dir = "dataset/train"
  29. ants_label_dir = "ants"
  30. bees_label_dir = "bees"
  31. ants_dataset = MyData(root_dir,ants_label_dir)
  32. bees_dataset = MyData(root_dir,bees_label_dir)
  33. train_dataset = ants_dataset + bees_dataset

2.TensorBoard的使用

  1. from torch.utils.tensorboard import SummaryWriter
  2. from PIL import  Image
  3. import numpy as np
  4.  
  5. writer = SummaryWriter("logs")
  6. image_path = "dataset/train/ants/0013035.jpg"
  7. img_PIL = Image.open(image_path)
  8. img_array = np.array(img_PIL)
  9. print(type(img_array))
  10. print(img_array.shape)
  11. # writer.add_image("test",img_array,1,dataformats='HWC')# 其中1的作用主要是为了进行步数的设置
  12. # y = x
  13. for i in range(100):
  14.     writer.add_scalar("y=2x",3*i,i)
  15. writer.close()

启动日志的相关命令

tensorboard --logdir=logs --port=6007

3. transfrom的使用

下面图片是transform的图解：

  1. """
  2. transform的讲解
  3. """
  4. from PIL import Image
  5. from torch.utils.tensorboard import SummaryWriter
  6. from torchvision import transforms
  7.  
  8.  
  9. #python的用法 -》 tensor数据类型
  10. #通过 transform.Totensor去看两个问题
  11. # 1、transform该如何去使用（python）
  12. # 2、为什么我们需要tensor数据类型
  13.  
  14. # 绝对路径："F:\learn_pytorch\p9_transform.py"
  15. # 相对路径："dataset/train/ants/0013035.jpg"
  16. #为什么不选择使用绝对路径，因为在window系统下，\会被认为是转移字符
  17.  
  18. img_path = "dataset/train/ants/0013035.jpg"# 读取图片的相对地址
  19. img_path_abs = "F:\learn_pytorch\p9_transform.py"# 读取图片的绝对地址
  20. img = Image.open(img_path)# 打开图片
  21. #print(img)
  22.  
  23. writer = SummaryWriter("logs") # 创建TensorBoard对象
  24.  
  25. # 1、transform该如何去使用（python）
  26. tensor_trans = transforms.ToTensor()# 创建一个tensor_trans的图片类型转换工具的对象
  27. tensor_img = tensor_trans(img)# 将img转化成tensor的形式
  28. #print(tensor_img)
  29.  
  30. writer.add_image("Tensor_img",tensor_img)# 利用TensorBoard展示数据

4.常见的transform

 Python中__call__的用法

  1. class Person:
  2.     def __call__(self,name):
  3.         print("__call__"+"Hello"+name)
  4.     def hello(self,name):
  5.         print("hello"+name)
  6.  
  7. person = Person()
  8.  
  9. person("张三")
  10.  
  11. person.hello("lisi")

Totensor()的使用

  1. #Totensor()的使用
  2. trans_Totensor = transforms.ToTensor()
  3. img_tensor = trans_Totensor(img)
  4. writer.add_image('ToTensor',img_tensor)

Normalize()的使用

  1. print(img_tensor[0][0][0])
  2. trans_norm = transforms.Normalize([0.5,0.5,0.5],[0.5,0.5,0.5])
  3. img_norm = trans_norm(img_tensor)
  4. print(img_norm[0][0][0])

Resize()的使用

  1. #Resize()
  2. print(img.size)
  3. trans_size = transforms.Resize((512,512))
  4. # img PIL -> resize ->img_resize PIL
  5. img_resize = trans_size(img)
  6. # img_resize PIL -> totensor ->img_resize tensor
  7. img_resize = trans_Totensor(img_resize)
  8. writer.add_image('Resize',img_resize,0)
  9. print(img_resize)

Compose()的使用

  1. #Compose() -resize -2
  2. trans_resize_2 = transforms.Resize(512)
  3. # PIL -> PIL -> tensor
  4. trans_compose = transforms.Compose([trans_resize_2,trans_Totensor])
  5. img_resize_2 = trans_compose(img)
  6. writer.add_image('Compose',img_resize_2)
RandomCrop()的使用

  1. #RandomCrop()
  2. trans_random = transforms.RandomCrop((500,20))
  3.  
  4. trans_compose_2 = transforms.Compose([trans_random,trans_Totensor])
  5.  
  6. for i in range(10):
  7.     img_crop = trans_compose_2(img)
  8.     writer.add_image('RandomCrop',img_crop,i)

 4.torchvision中数据集的使用

进入pytorch的官网

依次进入到Docs->torchvision->dataset

 相关代码：

  1. import torchvision
  2. from torch.utils.tensorboard import SummaryWriter
  3.  
  4. dataset_transform = torchvision.transforms.Compose([
  5.     torchvision.transforms.ToTensor()
  6. ])
  7. train_set = torchvision.datasets.(root="./dataset1",train=True,download=True,transform=dataset_transform)#构建训练集
  8. test_set = torchvision.datasets.CIFAR10(root="./dataset1",train=False,download=True,transform=dataset_transform)#构建测试集
  9.  
  10. '''
  11. print(test_set[0])
  12. print(test_set.classes)
  13. img,target = test_set[0]
  14. print(img)
  15. print(target)
  16. img.show()
  17. '''
  18. # print(test_set[0])
  19. writer = SummaryWriter('p10')
  20. # writer.add_image()
  21. for i in range(10):
  22.     img,target = test_set[i]
  23.     writer.add_image('test_set',img,i)
  24. writer.close()

5.dataloader的使用

 

  1.  
  2. import torchvision
  3. from torch.utils.data import DataLoader
  4. from torch.utils.tensorboard import SummaryWriter
  5.  
  6. test_data = torchvision.datasets.CIFAR10(root="./dataset1",train=True,transform=torchvision.transforms.ToTensor(),download=True)
  7.  
  8. test_loader = DataLoader(dataset=test_data,batch_size=64,shuffle=False,num_workers=0,drop_last=False)
  9.  
  10. #测试数据集里面的第一章图片及target
  11. img,target = test_data[0]
  12. print(img.shape)
  13. print(target)
  14.  
  15. writer = SummaryWriter('dataloader')
  16. for epoch in range(2):#进行两轮
  17.     step = 0
  18.     for data in test_loader:
  19.         imgs,targets = data
  20.         writer.add_images(f"Epoch{epoch}",imgs,step)
  21.         step = step + 1
  22.         # print(imgs.shape)
  23.         # print(target)
  24. print("读取结束")
  25. writer.close()
  26.

 6.神经网络的基本骨架-nn.Mouble的使用

 

  1. import torch
  2. from torch import nn
  3.  
  4.  
  5. class Tudui(nn.Module):
  6.  
  7.     def __init__(self) -> None:
  8.         super().__init__()
  9.  
  10.     def forward(self,input):
  11.         output = input + 1
  12.         return output
  13.  
  14. tutui = Tudui()
  15. x = torch.tensor(1.0)
  16. output = tutui(x)
  17. print(output)

 7.卷积操作


需要重点学会的是：Conv2d

对应位置相乘，然后加在一起

 

 注意padding填充的全部为0。

 需要注意以上的参数的要求：

  1. import torch
  2. import torch.nn.functional as F
  3. #输入
  4. input = torch.tensor([[1,2,0,3,1],
  5.                       [0,1,2,3,1],
  6.                       [1,2,1,0,0],
  7.                       [5,2,3,1,1],
  8.                       [2,1,0,1,1]])
  9. #卷积核
  10. kernel = torch.tensor([[1,2,1],
  11.                        [0,1,0],
  12.                        [2,1,0]])
  13.  
  14. input = torch.reshape(input,(1,1,5,5))
  15. kernel = torch.reshape(kernel,(1,1,3,3))
  16.  
  17. print(input.shape)
  18. print(kernel.shape)
  19.  
  20. output1= F.conv2d(input,kernel,stride=1)
  21. print(output1)
  22. output2 = F.conv2d(input,kernel,stride=2)
  23. print(output2)
  24. output3 = F.conv2d(input,kernel,stride=1,padding=1)
  25. print(output3)

 8.神经网络-卷积层

 

 当out_channel = 2的时候，此时会设置2个卷积核

  1.  
  2. import torch
  3. import torchvision
  4.  
  5. #加载测试集
  6. from torch import nn
  7. from torch.nn import Conv2d
  8. from torch.utils.data import DataLoader
  9. from torch.utils.tensorboard import SummaryWriter
  10.  
  11. dataset = torchvision.datasets.CIFAR10(root="./dataset",train=False,transform=torchvision.transforms.ToTensor(),download=True)
  12.  
  13. dataloader = DataLoader(dataset,batch_size=64,num_workers=0)
  14.  
  15. class Tudui(nn.Module):
  16.     def __init__(self):
  17.         super(Tudui, self).__init__()
  18.         self.conv1 = Conv2d(in_channels=3,out_channels=6,kernel_size=3,stride=1,padding=0)
  19.  
  20.     def forward(self,x):
  21.         x = self.conv1(x)
  22.         return x
  23. tudui = Tudui()
  24. print(tudui)
  25.  
  26. writer = SummaryWriter('./logs')
  27. step = 0
  28. for data in dataloader:
  29.     imgs,targets = data
  30.     ouput = tudui(imgs)
  31.     print(imgs.shape)
  32.     print(ouput.shape)
  33.     writer.add_images("input",imgs,step)
  34.     ouput = torch.reshape(ouput, (-1, 3, 30, 30))  # ->[xxx,3,30,30],3是通道数减少，使得xxx的batchsize变大
  35.     writer.add_images("ouput",ouput,step)
  36.     step = step + 1
  37. print("over")
  38.

  9.神经网络-最大池化的使用

 

 

 

 

  1. import torch
  2. from torch import nn
  3. from torch.nn import MaxPool2d
  4.  
  5. input = torch.tensor([[1,2,0,3,1],
  6.                       [0,1,2,3,1],
  7.                       [1,2,1,0,0],
  8.                       [5,2,3,1,1],
  9.                       [2,1,0,1,1]],dtype=torch.float)
  10.  
  11. input = torch.reshape(input,(-1,1,5,5))
  12.  
  13. class Tudui(nn.Module) :
  14.     def __init__(self):
  15.         super(Tudui, self).__init__()
  16.         self.maxpool = MaxPool2d(kernel_size=3,ceil_mode=False)
  17.  
  18.  
  19.  
  20.     def forward(self,input):
  21.         output = self.maxpool(input)
  22.         return output
  23. tudui = Tudui()
  24. output = tudui(input)
  25. print(output)
  26.

 最大池化的作用：就是压缩。

  1. import torch
  2. import torchvision
  3. from torch import nn
  4. from torch.nn import MaxPool2d
  5. from torch.utils.data import DataLoader
  6. from torch.utils.tensorboard import SummaryWriter
  7.  
  8. dataset = torchvision.datasets.CIFAR10(root="./dataset",train=False,transform=torchvision.transforms.ToTensor(),download=True)
  9.  
  10. dataloader = DataLoader(dataset,batch_size=64,shuffle=True)
  11. '''
  12. input = torch.tensor([[1,2,0,3,1],
  13.                       [0,1,2,3,1],
  14.                       [1,2,1,0,0],
  15.                       [5,2,3,1,1],
  16.                       [2,1,0,1,1]],dtype=torch.float)
  18. input = torch.reshape(input,(-1,1,5,5))
  19. '''
  20. class Tudui(nn.Module) :
  21.     def __init__(self):
  22.         super(Tudui, self).__init__()
  23.         self.maxpool = MaxPool2d(kernel_size=3,ceil_mode=False)
  24.  
  25.  
  26.  
  27.     def forward(self,input):
  28.         output = self.maxpool(input)
  29.         return output
  30.  
  31. tudui = Tudui()
  32. writer = SummaryWriter("logs")
  33. step = 0
  34. for data in dataloader:
  35.     imgs,target = data
  36.     writer.add_images("imgs",imgs,step)
  37.     print(imgs.shape)
  38.     output = tudui(imgs)
  39.     writer.add_images("maxpool",output,step)
  40.     print(output.shape)
  41.     step = step + 1
  42.  
  43. writer.close()
  44. print("over")
  45.  
  46. # tudui = Tudui()
  47. # output = tudui(input)
  48. # print(output)
  49.

10.神经网络-非线性激活

inplace参数的讲解

  1. '''
  2. ReLU
  3. '''
  4. import torch
  5. from torch import nn
  6. from torch.nn import ReLU
  7.  
  8. input = torch.tensor([[1,-0.5],
  9.                      [-1,3]])
  10.  
  11. input = torch.reshape(input,(-1,1,2,2))
  12.  
  13. print(input.shape)
  14.  
  15.  
  16. class Tudui(nn.Module):
  17.     def __init__(self):
  18.         super(Tudui, self).__init__()
  19.         self.relu1 = ReLU()
  20.  
  21.     def forward(self,input):
  22.         output = self.relu1(input)
  23.  
  24.         return output
  25.  
  26. tudui = Tudui()
  27. output = tudui(input)
  28. print(output)
  29.  
  30.  
  31.  

  1. '''
  2. Sigmoid
  3. '''
  4. import torch
  5. import torchvision.datasets
  6. from torch import nn
  7. from torch.nn import ReLU, Sigmoid
  8. from torch.utils.data import DataLoader
  9. from torch.utils.tensorboard import SummaryWriter
  10.  
  11. input = torch.tensor([[1,-0.5],
  12.                      [-1,3]])
  13.  
  14. input = torch.reshape(input,(-1,1,2,2))
  15.  
  16. print(input.shape)
  17.  
  18. dataset = torchvision.datasets.CIFAR10(root="./dataset",train=False,download=True,
  19.                                        transform=torchvision.transforms.ToTensor())
  20. dataloader = DataLoader(dataset,batch_size=64)
  21. class Tudui(nn.Module):
  22.     def __init__(self):
  23.         super(Tudui, self).__init__()
  24.         self.relu1 = ReLU()
  25.         self.sigmoid1 = Sigmoid()
  26.  
  27.     def forward(self,input):
  28.         output = self.sigmoid1(input)
  29.  
  30.         return output
  31.  
  32. tudui = Tudui()
  33.  
  34. writer = SummaryWriter("logs")
  35. step = 0
  36. for data in dataloader:
  37.     imgs,targets = data
  38.     print(imgs.shape)
  39.     writer.add_images("imgs",imgs,step)
  40.     output = tudui(imgs)
  41.     print(output.shape)
  42.     writer.add_images("Sigmod",output,step)
  43.  
  44. writer.close()
  45.  
  46.  
  47.

11.神经网络-线性层及其它层的介绍 

 线性层

  1. """
  2. vgg16
  3. """
  4. import torch
  5. import torchvision.datasets
  6. from torch import nn
  7. from torch.nn import Linear
  8. from torch.utils.data import DataLoader
  9. from torch.utils.tensorboard import SummaryWriter
  10.  
  11. dataset = torchvision.datasets.CIFAR10("./dataset",train=False,transform=torchvision.transforms.ToTensor(),
  12.                                        download=True)
  13.  
  14. dataloader = DataLoader(dataset,batch_size=64)
  15.  
  16. class Tudui(nn.Module):
  17.     def __init__(self):
  18.         super(Tudui, self).__init__()
  19.         self.linear1 = Linear(196608,10)
  20.  
  21.     def forward(self,input):
  22.         output = self.linear1(input)
  23.         return output
  24.  
  25. tudui = Tudui()
  26.  
  27. #writer = SummaryWriter("logs")
  28. #step = 0
  29.  
  30. for data in dataloader:
  31.     imgs,tragets = data
  32.     print(imgs.shape)
  33.     #writer.add_images("imgs",imgs,step)
  34.     #output = torch.reshape(imgs,(1,1,1,-1))
  35.     output = torch.flatten(imgs)
  36.     print(output.shape)
  37.     output = tudui(output)
  38.     print(output.shape)
  39.     #writer.add_images("linear",output,step)
  40.     #step += 1
  41.  
  42. #writer.close()
  43.  
  44.

12.神经网络-搭建小实战和Sequential的使用

 CIFAR 10 model结构

 

  1. import torch
  2. from torch import nn
  3. from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential
  4. from torch.utils.tensorboard import SummaryWriter
  5.  
  6.  
  7. class Tudui(nn.Module):
  8.     def __init__(self):
  9.         super(Tudui, self).__init__()
  10.         self.conv1 = Conv2d(3,32,5,padding=2)
  11.         self.maxpool1 = MaxPool2d(2)
  12.         self.conv2 = Conv2d(32,32,5,padding=2)
  13.         self.maxpool2 = MaxPool2d(2)
  14.         self.conv3 = Conv2d(32,64,5,padding=2)
  15.         self.maxpool3 = MaxPool2d(2)
  16.         self.flatten = Flatten()
  17.         self.Linear1 = Linear(1024,64)
  18.         self.Linear2 = Linear(64,10)
  19.  
  20.         self.model1 = Sequential(
  21.             Conv2d(3,32,5,padding=2),
  22.             MaxPool2d(2),
  23.             Conv2d(32, 32, 5, padding=2),
  24.             MaxPool2d(2),
  25.             Conv2d(32, 64, 5, padding=2),
  26.             MaxPool2d(2),
  27.             Flatten(),
  28.             Linear(1024, 64),
  29.             Linear(64, 10)
  30.         )
  31.     def forward(self,x):
  32.         # x = self.conv1(x)
  33.         # x = self.maxpool1(x)
  34.         # x = self.conv2(x)
  35.         # x = self.maxpool2(x)
  36.         # x = self.conv3(x)
  37.         # x = self.maxpool3(x)
  38.         # x = self.flatten(x)
  39.         # x = self.Linear1(x)
  40.         # x = self.Linear2(x)
  41.         x = self.model1(x)
  42.         return x
  43.  
  44. tudui = Tudui()
  45. input = torch.ones((64,3,32,32))
  46. output = tudui(input)
  47. print(output)
  48.  
  49.  
  50. writer = SummaryWriter("logs_seq")
  51. writer.add_graph(tudui,input)
  52. writer.close()

13.损失函数

 

  1. '''
  2. nn.loss
  3. '''
  4.  
  5. import torch
  6. from torch.nn import L1Loss
  7.  
  8. inputs = torch.tensor([1,2,3],dtype=torch.float32)
  9. targets = torch.tensor([1,2,5],dtype=torch.float32)
  10.  
  11. inputs = torch.reshape(inputs,(1,1,1,3))
  12. targets = torch.reshape(targets,(1,1,1,3))
  13.  
  14. loss =L1Loss(reduction='sum')
  15. result = loss(inputs,targets)
  16.  
  17. print(result)

  1. '''
  2. nn.MSEloss
  3. '''
  4.  
  5. import torch
  6. from torch.nn import L1Loss
  7. from torch import nn
  8.  
  9. inputs = torch.tensor([1,2,3],dtype=torch.float32)
  10. targets = torch.tensor([1,2,5],dtype=torch.float32)
  11.  
  12. inputs = torch.reshape(inputs,(1,1,1,3))
  13. targets = torch.reshape(targets,(1,1,1,3))
  14.  
  15. loss =L1Loss(reduction='sum')
  16. result = loss(inputs,targets)
  17.  
  18. loss_mse = nn.MSELoss()
  19. result_mse = loss_mse(inputs,targets)
  20.  
  21. print(result)
  22. print(result_mse)

  1. '''
  2. nn.CrossEntropyLoss
  3. '''
  4.  
  5. import torch
  6. from torch.nn import L1Loss
  7. from torch import nn
  8.  
  9. inputs = torch.tensor([1,2,3],dtype=torch.float32)
  10. targets = torch.tensor([1,2,5],dtype=torch.float32)
  11.  
  12. inputs = torch.reshape(inputs,(1,1,1,3))
  13. targets = torch.reshape(targets,(1,1,1,3))
  14.  
  15. loss =L1Loss(reduction='sum')
  16. result = loss(inputs,targets)
  17.  
  18. loss_mse = nn.MSELoss()
  19. result_mse = loss_mse(inputs,targets)
  20.  
  21. print(result)
  22. print(result_mse)
  23.  
  24. x = torch.tensor([0.1,0.2,0.3])
  25. y = torch.tensor([1])
  26. x = torch.reshape(x,(1,3))
  27. loss_cross = nn.CrossEntropyLoss()
  28. result_cross = loss_cross(x,y)
  29. print(result_cross)

  1. import torchvision
  2. from torch import nn
  3. from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential
  4. from torch.utils.data import DataLoader
  5.  
  6. dataset = torchvision.datasets.CIFAR10("./data",train=False,transform=torchvision.transforms.ToTensor(),
  7.                                        download=True)
  8. dataloader = DataLoader(dataset,batch_size = 1)
  9.  
  10. class Tudui(nn.Module):
  11.     def __init__(self):
  12.         super(Tudui, self).__init__()
  13.         self.conv1 = Conv2d(3,32,5,padding=2)
  14.         self.maxpool1 = MaxPool2d(2)
  15.         self.conv2 = Conv2d(32,32,5,padding=2)
  16.         self.maxpool2 = MaxPool2d(2)
  17.         self.conv3 = Conv2d(32,64,5,padding=2)
  18.         self.maxpool3 = MaxPool2d(2)
  19.         self.flatten = Flatten()
  20.         self.Linear1 = Linear(1024,64)
  21.         self.Linear2 = Linear(64,10)
  22.  
  23.         self.model1 = Sequential(
  24.             Conv2d(3,32,5,padding=2),
  25.             MaxPool2d(2),
  26.             Conv2d(32, 32, 5, padding=2),
  27.             MaxPool2d(2),
  28.             Conv2d(32, 64, 5, padding=2),
  29.             MaxPool2d(2),
  30.             Flatten(),
  31.             Linear(1024, 64),
  32.             Linear(64, 10)
  33.         )
  34.     def forward(self,x):
  35.         # x = self.conv1(x)
  36.         # x = self.maxpool1(x)
  37.         # x = self.conv2(x)
  38.         # x = self.maxpool2(x)
  39.         # x = self.conv3(x)
  40.         # x = self.maxpool3(x)
  41.         # x = self.flatten(x)
  42.         # x = self.Linear1(x)
  43.         # x = self.Linear2(x)
  44.         x = self.model1(x)
  45.         return x
  46. loss = nn.CrossEntropyLoss()
  47. tudui = Tudui()
  48. for data in dataloader:
  49.     imgs,targets = data
  50.     outputs = tudui(imgs)
  51.     result_loss = loss(outputs,targets)
  52.     result_loss.backward()
  53.     print("ok")
  54.     print(result_loss)
  55.     print(outputs)
  56.     print(targets)

14.优化器

  1. import torch
  2. import torchvision
  3. from torch import nn
  4. from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential
  5. from torch.utils.data import DataLoader
  6.  
  7. dataset = torchvision.datasets.CIFAR10("./data",train=False,transform=torchvision.transforms.ToTensor(),
  8.                                        download=True)
  9. dataloader = DataLoader(dataset,batch_size = 1)
  10.  
  11. class Tudui(nn.Module):
  12.     def __init__(self):
  13.         super(Tudui, self).__init__()
  14.         self.conv1 = Conv2d(3,32,5,padding=2)
  15.         self.maxpool1 = MaxPool2d(2)
  16.         self.conv2 = Conv2d(32,32,5,padding=2)
  17.         self.maxpool2 = MaxPool2d(2)
  18.         self.conv3 = Conv2d(32,64,5,padding=2)
  19.         self.maxpool3 = MaxPool2d(2)
  20.         self.flatten = Flatten()
  21.         self.Linear1 = Linear(1024,64)
  22.         self.Linear2 = Linear(64,10)
  23.  
  24.         self.model1 = Sequential(
  25.             Conv2d(3,32,5,padding=2),
  26.             MaxPool2d(2),
  27.             Conv2d(32, 32, 5, padding=2),
  28.             MaxPool2d(2),
  29.             Conv2d(32, 64, 5, padding=2),
  30.             MaxPool2d(2),
  31.             Flatten(),
  32.             Linear(1024, 64),
  33.             Linear(64, 10)
  34.         )
  35.     def forward(self,x):
  36.         # x = self.conv1(x)
  37.         # x = self.maxpool1(x)
  38.         # x = self.conv2(x)
  39.         # x = self.maxpool2(x)
  40.         # x = self.conv3(x)
  41.         # x = self.maxpool3(x)
  42.         # x = self.flatten(x)
  43.         # x = self.Linear1(x)
  44.         # x = self.Linear2(x)
  45.         x = self.model1(x)
  46.         return x
  47. loss = nn.CrossEntropyLoss()
  48. tudui = Tudui()
  49. optim = torch.optim.SGD(tudui.parameters(),lr = 0.01,)
  50. for epoch in range(20):
  51.     running_loss = 0.0
  52.     for data in dataloader:
  53.         imgs,targets = data
  54.         outputs = tudui(imgs)
  55.         result_loss = loss(outputs,targets)# 计算损失
  56.         optim.zero_grad()# 梯度清零
  57.         result_loss.backward()# 反向传播，求出每个参数的梯度
  58.         optim.step() #对权重进行更新
  59.         running_loss = running_loss + result_loss
  60.     print(running_loss)

15.现有模型的使用和修改

  1. import torchvision
  2.  
  3. # train_data = torchvision.datasets.ImageNet("./dataset",split='train',download=True,
  4. #                                            transform=torchvision.transforms.ToTensor())
  5. from torch import nn
  6.  
  7. vgg16_false = torchvision.models.vgg16(pretrained=False)
  8. vgg16_true = torchvision.models.vgg16(pretrained=True)
  9. print("ok")
  10. print(vgg16_true)
  11.  
  12.  
  13. train_data = torchvision.datasets.CIFAR10('./data',train=True,transform=torchvision.transforms.ToTensor(),
  14.                                           download=True)
  15. # 修改vgg16网络模型的结构
  16. vgg16_true.classifier.add_module('add_liner',nn.Linear(1000,10))
  17. print(vgg16_true)
  18. print(vgg16_false)
  19. vgg16_false.classifier[6] = nn.Linear(4096,10)
  20. print(vgg16_false)

16.网络模型的保存与读取

 

自己定义模型

  1. from torch import nn
  2.  
  3.  
  4. class Tudui(nn.Module):
  5.     def __init__(self):
  6.         super(Tudui, self).__init__()
  7.         self.conv1 = nn.Conv2d(3,64,kernel_size=3)
  8.  
  9.     def forward(self,x):
  10.         x = self.conv1(x)
  11.         return x

保存模型

  1. import torch
  2. import torchvision
  3.  
  4. vgg16 = torchvision.models.vgg16(pretrained=False) #加载vgg16初始的模型
  5.  
  6. #保存方式1
  7. torch.save(vgg16,"vgg16_method1.pth")
  1. import torch
  2. import torchvision
  3. from torch import nn
  4. from Tudui import Tudui
  5. # vgg16 = torchvision.models.vgg16(pretrained=False) #加载vgg16初始的模型
  6. #
  7. # #保存方式1 模型的结构+模型的参数
  8. # torch.save(vgg16,"vgg16_method1.pth")
  9. #
  10. # #保存方式2 模型的参数（官方的推荐）保存为字典的形式
  11. # torch.save(vgg16.state_dict(),"vgg16_method2.pth")
  12.  
  13. #陷阱
  14.  
  15. # class Tudui(nn.Module):
  16. #     def __init__(self):
  17. #         super(Tudui, self).__init__()
  18. #         self.conv1 = nn.Conv2d(3,64,kernel_size=3)
  19. #
  20. #     def forward(self,x):
  21. #         x = self.conv1(x)
  22. #         return x
  23. tudui = Tudui()
  24.  
  25. torch.save(tudui,"tudui_method1.pth")
  26. print("over")

加载模型

  1. import torch
  2. import torchvision
  3.  
  4. vgg16 = torchvision.models.vgg16(pretrained=False) #加载vgg16初始的模型
  5.  
  6. #保存方式1
  7. torch.save(vgg16,"vgg16_method1.pth")
  1. """
  2. 加载模型
  3. """
  4. import torch
  5. #保存方式1的加载模型的方法
  6. import torchvision
  7.  
  8. # model = torch.load("vgg16_method1.pth")
  9. #print(model)
  10.  
  11. #方式2的加载模型的方法
  12. # # model = torch.load("vgg16_method2.pth")
  13. # print(model)
  14.  
  15.  
  16.  
  17. vgg16 = torchvision.models.vgg16(pretrained=False)
  18. vgg16.load_state_dict((torch.load("vgg16_method2.pth")))
  19. # print(vgg16)
  20. #陷阱
  21. model = torch.load("tudui_method1.pth")
  22. print(model)

17.完整的模型训练的套路

 定义网络模型Model.py

  1. #搭建神经网络
  2. from torch import nn
  3.  
  4.  
  5. class Tudui(nn.Module):
  6.     def __init__(self):
  7.         super(Tudui, self).__init__()
  8.         #使用序列化的方法更新神经网络的各个层
  9.         self.model = nn.Sequential(
  10.             nn.Conv2d(3,32,kernel_size=5,stride=1,padding=2),
  11.             nn.MaxPool2d(kernel_size=2),
  12.             nn.Conv2d(32,32,kernel_size=5,stride=1,padding=2),
  13.             nn.MaxPool2d(2),
  14.             nn.Conv2d(32,64,kernel_size=5,stride=1,padding=2),
  15.             nn.MaxPool2d(2),
  16.             nn.Flatten(),
  17.             nn. Linear(64*4*4,64),
  18.             nn.Linear(64,10)
  19.         )
  20.  
  21. #定义前向传播
  22.     def forward(self,x):
  23.         x = self.model(x)
  24.         return x

完整的模型训练套路train.py

  1. """
  2. 完整的模型训练的套路
  3. """
  4.  
  5. #准备数据集
  6. import torch
  7. import torchvision
  8. from torch import nn
  9. from torch.utils.data import DataLoader
  10. from torch.utils.tensorboard import SummaryWriter
  11.  
  12. from Model import Tudui
  13.  
  14. train_data = torchvision.datasets.CIFAR10("./data",
  15.                                           train=True,
  16.                                           transform=torchvision.transforms.ToTensor(),
  17.                                           download=True)
  18. test_data = torchvision.datasets.CIFAR10("./data",
  19.                                           train=False,
  20.                                           transform=torchvision.transforms.ToTensor(),
  21.                                           download=True)
  22.  
  23. #查看训练集和测试集有多少张
  24. #length 长度
  25. train_data_size = len(train_data) #训练集的长度
  26. test_data_size = len(test_data) #测试集的长度
  27. print(f"训练集的长度为{train_data_size}\n")
  28. print(f"测试集的长度为{test_data_size}\n")
  29.  
  30. # 利用DataLoader 来加载数据集
  31. train_dataloader = DataLoader(train_data,batch_size=64)
  32. test_dataloader = DataLoader(test_data,batch_size=64)
  33.  
  34. #主函数
  35. if __name__ == '__main__':
  36.     # 创建网络模型
  37.     tudui = Tudui()
  38.  
  39.     #小测试
  40.     input = torch.ones((64,3,32,32))
  41.     output = tudui(input)
  42.     print(output.shape)
  43.     """
  44.     torch.Size([64, 10])
  45.     64是代表64张照片
  46.     10是代表10个类别，每张图片10各类别上分别的概率
  47.     """
  48.  
  49.     # 损失函数
  50.     loss_fn = nn.CrossEntropyLoss()
  51.  
  52.     #学习速率
  53.     #1e-2=1x10^(-2)
  54.     learning_rate = 1e-2
  55.  
  56.     # 优化器
  57.     optimizer = torch.optim.SGD(tudui.parameters(),lr = learning_rate,)
  58.  
  59.     #设置训练网络的一些参数
  60.     total_train_step = 0 #记录训练的次数
  61.     total_test_step = 0 #记录测试的次数
  62.     #训练的次数
  63.     epoch = 10
  64.     #添加tensorboard
  65.     writer = SummaryWriter("logs_train")
  66.  
  67.     for i  in range(epoch):
  68.         print(f"------第{i+1}轮训练开始------")
  69.  
  70.         # 训练步骤开始
  71.         tudui.train()
  72.         for data in train_dataloader:
  73.             imgs,targets = data
  74.             outputs = tudui(imgs)
  75.             loss = loss_fn(outputs,targets)
  76.  
  77.             #优化器的调优
  78.             optimizer.zero_grad()# 梯度清零
  79.             loss.backward()# 反向传播
  80.             optimizer.step()# 更新优化参数
  81.  
  82.             total_train_step = total_train_step + 1 #训练次数加1
  83.             if total_train_step % 100 == 0:# 每个一百次输出一次训练的结果
  84.                 print(f"训练次数：{total_train_step},Loss：{loss.item()}") #记录每次训练的损失结果,item()主要就是把loss转化为真实的数，其实转化不转化都行的
  85.                 writer.add_scalar("train_loss",loss.item(),total_train_step)
  86.  
  87.         #测试步骤开始
  88.         tudui.eval()
  89.         total_test_loss = 0
  90.         total_accuracy = 0
  91.         with torch.no_grad():#防止调优，测试时不需要进行调优
  92.             for data in test_dataloader:
  93.                 imgs , targets = data
  94.                 outputs = tudui(imgs)
  95.                 loss = loss_fn(outputs,targets)
  96.                 total_test_loss = total_test_loss + loss
  97.  
  98.                 #计算整体的正确率
  99.                 accuracy = (outputs.argmax(1) == targets).sum()
  100.                 total_accuracy = total_accuracy + accuracy
  101.             print(f"整体测试集上的正确率{total_accuracy/test_data_size}")
  102.             print(f"整体测试集上的Loss：{total_test_loss}")
  103.             writer.add_scalar("test_loss",total_test_loss,total_test_step)
  104.             writer.add_scalar("test_accuracy",total_accuracy/test_data_size,total_test_step)
  105.             total_test_step = total_test_step + 1
  106.  
  107.         #保存模型
  108.         torch.save(tudui,f"tudui_{i}.ph")
  109.         #torch.save(tudui.state_dict(),f"tudui_{i}.ph")
  110.         print("模型已保存")
  111.  
  112.     writer.close()

18.利用GPU进行训练

  1. """
  2. 完整的模型训练的套路
  3. """
  4.  
  5. #准备数据集
  6. import torch
  7. import torchvision
  8. from torch import nn
  9. from torch.utils.data import DataLoader
  10. from torch.utils.tensorboard import SummaryWriter
  11. import time
  12.  
  13. from Model import Tudui
  14.  
  15. train_data = torchvision.datasets.CIFAR10("./data",
  16.                                           train=True,
  17.                                           transform=torchvision.transforms.ToTensor(),
  18.                                           download=True)
  19. test_data = torchvision.datasets.CIFAR10("./data",
  20.                                           train=False,
  21.                                           transform=torchvision.transforms.ToTensor(),
  22.                                           download=True)
  23.  
  24. #查看训练集和测试集有多少张
  25. #length 长度
  26. train_data_size = len(train_data) #训练集的长度
  27. test_data_size = len(test_data) #测试集的长度
  28. print(f"训练集的长度为{train_data_size}\n")
  29. print(f"测试集的长度为{test_data_size}\n")
  30.  
  31. # 利用DataLoader 来加载数据集
  32. train_dataloader = DataLoader(train_data,batch_size=64)
  33. test_dataloader = DataLoader(test_data,batch_size=64)
  34.  
  35. #主函数
  36. if __name__ == '__main__':
  37.     # 创建网络模型
  38.     tudui = Tudui()
  39.     if torch.cuda.is_available():
  40.         tudui = tudui.cuda()
  41.  
  42.     #小测试
  43.  
  44.     input = torch.ones((64,3,32,32))
  45.     device = torch.device('cuda:0') #将tensor.cpu类型的数据转化为tensor.gpu类型的数据
  46.     input = input.to(device)
  47.     output = tudui(input)
  48.     print(output.shape)
  49.     """
  50.     torch.Size([64, 10])
  51.     64是代表64张照片
  52.     10是代表10个类别，每张图片10各类别上分别的概率
  53.     """
  54.  
  55.     # 损失函数
  56.     loss_fn = nn.CrossEntropyLoss()
  57.     if torch.cuda.is_available():
  58.         loss_fn = loss_fn.cuda()
  59.  
  60.     #学习速率
  61.     #1e-2=1x10^(-2)
  62.     learning_rate = 1e-2
  63.  
  64.     # 优化器
  65.     optimizer = torch.optim.SGD(tudui.parameters(),lr = learning_rate,)
  66.  
  67.     #设置训练网络的一些参数
  68.     total_train_step = 0 #记录训练的次数
  69.     total_test_step = 0 #记录测试的次数
  70.     #训练的次数
  71.     epoch = 10
  72.     #添加tensorboard
  73.     writer = SummaryWriter("logs_train")
  74.  
  75.     start_time = time.time() #开始训练的时间
  76.     for i  in range(epoch):
  77.         print(f"------第{i+1}轮训练开始------")
  78.  
  79.         # 训练步骤开始
  80.         tudui.train()
  81.         for data in train_dataloader:
  82.             imgs,targets = data
  83.             if torch.cuda.is_available():
  84.                 imgs = imgs.cuda()
  85.                 targets = targets.cuda()
  86.             outputs = tudui(imgs)
  87.             loss = loss_fn(outputs,targets)
  88.  
  89.             #优化器的调优
  90.             optimizer.zero_grad()# 梯度清零
  91.             loss.backward()# 反向传播
  92.             optimizer.step()# 更新优化参数
  93.  
  94.             total_train_step = total_train_step + 1 #训练次数加1
  95.             if total_train_step % 100 == 0:# 每个一百次输出一次训练的结果
  96.                 end_time = time.time() #结束时间
  97.                 print(end_time - start_time) #计算100次训练的间隔的时间
  98.                 print(f"训练次数：{total_train_step},Loss：{loss.item()}") #记录每次训练的损失结果,item()主要就是把loss转化为真实的数，其实转化不转化都行的
  99.                 writer.add_scalar("train_loss",loss.item(),total_train_step)
  100.  
  101.         #测试步骤开始
  102.         tudui.eval()
  103.         total_test_loss = 0
  104.         total_accuracy = 0
  105.         with torch.no_grad():#防止调优，测试时不需要进行调优
  106.             for data in test_dataloader:
  107.                 imgs , targets = data
  108.                 if torch.cuda.is_available():
  109.                     imgs = imgs.cuda()
  110.                     targets = targets.cuda()
  111.                 outputs = tudui(imgs)
  112.                 loss = loss_fn(outputs,targets)
  113.                 total_test_loss = total_test_loss + loss
  114.  
  115.                 #计算整体的正确率
  116.                 accuracy = (outputs.argmax(1) == targets).sum()
  117.                 total_accuracy = total_accuracy + accuracy
  118.             print(f"整体测试集上的正确率{total_accuracy/test_data_size}")
  119.             print(f"整体测试集上的Loss：{total_test_loss}")
  120.             writer.add_scalar("test_loss",total_test_loss,total_test_step)
  121.             writer.add_scalar("test_accuracy",total_accuracy/test_data_size,total_test_step)
  122.             total_test_step = total_test_step + 1
  123.  
  124.         #保存模型
  125.         torch.save(tudui,f"tudui_{i}.ph")
  126.         #torch.save(tudui.state_dict(),f"tudui_{i}.ph")
  127.         print("模型已保存")
  128.  
  129.     writer.close()

  1. """
  2. 完整的模型训练的套路
  3. """
  4.  
  5. #准备数据集
  6. import torch
  7. import torchvision
  8. from torch import nn
  9. from torch.utils.data import DataLoader
  10. from torch.utils.tensorboard import SummaryWriter
  11. import time
  12.  
  13. from Model import Tudui
  14.  
  15. #定义训练的设备
  16. # device = torch.device("cuda:0")
  17. device =  torch.device("cuda" if torch.cuda.is_available() else "cpu")
  18.  
  19. train_data = torchvision.datasets.CIFAR10("./data",
  20.                                           train=True,
  21.                                           transform=torchvision.transforms.ToTensor(),
  22.                                           download=True)
  23. test_data = torchvision.datasets.CIFAR10("./data",
  24.                                           train=False,
  25.                                           transform=torchvision.transforms.ToTensor(),
  26.                                           download=True)
  27.  
  28. #查看训练集和测试集有多少张
  29. #length 长度
  30. train_data_size = len(train_data) #训练集的长度
  31. test_data_size = len(test_data) #测试集的长度
  32. print(f"训练集的长度为{train_data_size}\n")
  33. print(f"测试集的长度为{test_data_size}\n")
  34.  
  35. # 利用DataLoader 来加载数据集
  36. train_dataloader = DataLoader(train_data,batch_size=64)
  37. test_dataloader = DataLoader(test_data,batch_size=64)
  38.  
  39. #主函数
  40. if __name__ == '__main__':
  41.     # 创建网络模型
  42.     tudui = Tudui()
  43.     tudui = tudui.to(device)
  44.  
  45.  
  46.     #小测试
  47.  
  48.     input = torch.ones((64,3,32,32))
  49.     input = input.to(device)
  50.     output = tudui(input)
  51.     print(output.shape)
  52.     """
  53.     torch.Size([64, 10])
  54.     64是代表64张照片
  55.     10是代表10个类别，每张图片10各类别上分别的概率
  56.     """
  57.  
  58.     # 损失函数
  59.     loss_fn = nn.CrossEntropyLoss()
  60.     loss_fn = loss_fn.to(device)
  61.  
  62.     #学习速率
  63.     #1e-2=1x10^(-2)
  64.     learning_rate = 1e-2
  65.  
  66.     # 优化器
  67.     optimizer = torch.optim.SGD(tudui.parameters(),lr = learning_rate,)
  68.  
  69.     #设置训练网络的一些参数
  70.     total_train_step = 0 #记录训练的次数
  71.     total_test_step = 0 #记录测试的次数
  72.     #训练的次数
  73.     epoch = 10
  74.     #添加tensorboard
  75.     writer = SummaryWriter("logs_train")
  76.  
  77.     start_time = time.time() #开始训练的时间
  78.     for i  in range(epoch):
  79.         print(f"------第{i+1}轮训练开始------")
  80.  
  81.         # 训练步骤开始
  82.         tudui.train()
  83.         for data in train_dataloader:
  84.             imgs,targets = data
  85.             imgs = imgs.to(device)
  86.             targets = targets.to(device)
  87.             outputs = tudui(imgs)
  88.             loss = loss_fn(outputs,targets)
  89.  
  90.             #优化器的调优
  91.             optimizer.zero_grad()# 梯度清零
  92.             loss.backward()# 反向传播
  93.             optimizer.step()# 更新优化参数
  94.  
  95.             total_train_step = total_train_step + 1 #训练次数加1
  96.             if total_train_step % 100 == 0:# 每个一百次输出一次训练的结果
  97.                 end_time = time.time() #结束时间
  98.                 print(end_time - start_time) #计算100次训练的间隔的时间
  99.                 print(f"训练次数：{total_train_step},Loss：{loss.item()}") #记录每次训练的损失结果,item()主要就是把loss转化为真实的数，其实转化不转化都行的
  100.                 writer.add_scalar("train_loss",loss.item(),total_train_step)
  101.  
  102.         #测试步骤开始
  103.         tudui.eval()
  104.         total_test_loss = 0
  105.         total_accuracy = 0
  106.         with torch.no_grad():#防止调优，测试时不需要进行调优
  107.             for data in test_dataloader:
  108.                 imgs , targets = data
  109.                 imgs = imgs.to(device)
  110.                 targets = targets.to(device)
  111.                 outputs = tudui(imgs)
  112.                 loss = loss_fn(outputs,targets)
  113.                 total_test_loss = total_test_loss + loss
  114.  
  115.                 #计算整体的正确率
  116.                 accuracy = (outputs.argmax(1) == targets).sum()
  117.                 total_accuracy = total_accuracy + accuracy
  118.             print(f"整体测试集上的正确率{total_accuracy/test_data_size}")
  119.             print(f"整体测试集上的Loss：{total_test_loss}")
  120.             writer.add_scalar("test_loss",total_test_loss,total_test_step)
  121.             writer.add_scalar("test_accuracy",total_accuracy/test_data_size,total_test_step)
  122.             total_test_step = total_test_step + 1
  123.  
  124.         #保存模型
  125.         torch.save(tudui,f"tudui_{i}.ph")
  126.         #torch.save(tudui.state_dict(),f"tudui_{i}.ph")
  127.         print("模型已保存")
  128.  
  129.     writer.close()

如果没有GPU怎么办呢？

没有GPU的话，我们可以使用谷歌提供colab，可能访问这个网站的话需要进行科学上网

 19.完整的模型验证套路

利用已经训练好的模型，然后给它提供测试

  1. # -*- coding: utf-8 -*-
  2. # 作者：小土堆
  3. # 公众号：土堆碎念
  4. import torch
  5. import torchvision
  6. from PIL import Image
  7. from torch import nn
  8.  
  9. image_path = "../imgs/airplane.png"
  10. image = Image.open(image_path)
  11. print(image)
  12. image = image.convert('RGB')
  13. transform = torchvision.transforms.Compose([torchvision.transforms.Resize((32, 32)),
  14.                                             torchvision.transforms.ToTensor()])
  15.  
  16. image = transform(image)
  17. print(image.shape)
  18.  
  19. class Tudui(nn.Module):
  20.     def __init__(self):
  21.         super(Tudui, self).__init__()
  22.         self.model = nn.Sequential(
  23.             nn.Conv2d(3, 32, 5, 1, 2),
  24.             nn.MaxPool2d(2),
  25.             nn.Conv2d(32, 32, 5, 1, 2),
  26.             nn.MaxPool2d(2),
  27.             nn.Conv2d(32, 64, 5, 1, 2),
  28.             nn.MaxPool2d(2),
  29.             nn.Flatten(),
  30.             nn.Linear(64*4*4, 64),
  31.             nn.Linear(64, 10)
  32.         )
  33.  
  34.     def forward(self, x):
  35.         x = self.model(x)
  36.         return x
  37.  
  38. model = torch.load("tudui_29_gpu.pth", map_location=torch.device('cpu'))
  39. print(model)
  40. image = torch.reshape(image, (1, 3, 32, 32))
  41. model.eval()
  42. with torch.no_grad():
  43.     output = model(image)
  44. print(output)
  45.  
  46. print(output.argmax(1))

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/360138
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号