devbox
煮酒与君饮
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

从零开始教你用Pytorch搭建CNN模型_pytorch cnn

作者：煮酒与君饮 | 2024-07-12 23:58:46

赞

踩

pytorch cnn

目录

CNN搭建（PyTorch）

一、前期准备

1、PyTorch环境配置

1、创建虚拟环境

2、配置GitHub上下载的项目

3、jupyter的使用

2、加载数据初认识

1、Dataset

2、Dataloader

3、使用Python Console查看类的属性

4、Tensorboard

5、Transforms

6、torchvision中数据集的使用

二、模型搭建

7、nn.Module

7.1模型size

7.2模型conv

7.2.1卷积过程

7.2.2卷积效果：

7.3模型pooling

7.4模型非线性激活

7.5模型全连接

三、搭建小实战

8、CIFAR10模型

9、Lose Function

9.1基本使用

9.2实际作用

四、现有网络模型的使用及修改

10、vgg16

10.1模型的保存与读取

五、完整的模型训练套路

11、模型训练

11.1train

11.2model

12、模型测试

12.1test

pytorch官网：torchvision — Torchvision master documentation (pytorch.org)

一、前期准备

1、PyTorch环境配置

1、创建虚拟环境

1、conda create -n pycyy python=3.7 -c 镜像地址

以下是一些常见的conda镜像地址：

  • 清华大学：https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main/
  • 阿里云：https://mirrors.aliyun.com/anaconda/pkgs/main/
  • 北京外国语大学：https://mirrors.bfsu.edu.cn/anaconda/pkgs/main/

2、conda activate pycyy

3、在pytorch官网复制上述python版本对应的pytorch配置代码，如：conda install pytorch torchvision torchaudio cpuonly -c pytorch

[i]

2、配置GitHub上下载的项目

1、利用PyCharm打开项目：File->Open

2、配置相应的虚拟环境：File->Setting->Project->Python解释器。然后选择对应的虚拟环境

3、直接运行代码，右键->run

4、如果提示某些包没有发现，可以用

  1. conda activate pycyy

  2. conda install 包名

  3. pip insatll 包名

利用搜索引擎找原因 - 包名不对、通道不对，或者其他原因

5、可选 - 最好把requirements.txt文件内容当做参考，有选择性使用

3、jupyter的使用

  1. conda activate pycyy

  2. jupyter notebook D:

[i]

Jupyter Notebook(pycyy)属性：

[i]

目标：D:\software\anaconda\Ana\python.exe D:\software\anaconda\Ana\cwp.py D:\software\anaconda\Ana\envs\pycyy D:\software\anaconda\Ana\envs\pycyy\python.exe D:\software\anaconda\Ana\envs\pycyy\Scripts\jupyter-notebook-script.py "%USERPROFILE%/"

将"%USERPROFILE%/"改为"D:\"即打开Jupyter Notebook(pycyy)直接进入D盘，不用在每次都执行jupyter notebook D:命令

2、加载数据初认识

1、Dataset

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

  1. 如何获取每一个数据及其label

  2. 告诉我们总共有多少个数据

2、Dataloader

为网络提供不同的数据形式（如压缩形式）

3、使用Python Console查看类的属性

可以看到图片的宽、高等相关属性信息

4、Tensorboard

  1. from torch.utils.tensorboard import SummaryWriter
  2. writer = SummaryWriter("logs")
  3. # writer.add_image()
  4. for i in range(100):
  5.     writer.add_scalar("y=x",i,i)
  6. writer.close()

tensorboard --logdir=logs --port=6007，指定端口打开tensorboard 页面

tensorboard 页面如下：

绘制了一个y=x的函数

5、Transforms

  1. from PIL import Image
  2. ​
  3. from torchvision import transforms
  4. image_path = "data/train/ants_image/6743948_2b8c096dda.jpg"
  5. img = Image.open(image_path)
  6. tensor_trans = transforms.ToTensor()
  7. tensor_img = tensor_trans(img)
  8. print(tensor_img)
  9. ​
D:\software\anaconda\Ana\envs\pycyy\python.exe D:\code\Python\pycyy\Transforms.py 
tensor([[[0.6549, 0.5451, 0.5765,  ..., 0.7451, 0.7451, 0.7647],
         [0.4078, 0.4471, 0.5373,  ..., 0.8118, 0.8431, 0.8627],
         [0.3529, 0.5804, 0.7490,  ..., 0.6824, 0.8314, 0.8824],
         ...,
         [0.5490, 0.5412, 0.4353,  ..., 0.6510, 0.6706, 0.6275],
         [0.8824, 0.5020, 0.8353,  ..., 0.6745, 0.6706, 0.5608],
         [0.6235, 0.3961, 0.7765,  ..., 0.7765, 0.6784, 0.6196]],

        [[0.6235, 0.5020, 0.5294,  ..., 0.6706, 0.6353, 0.6353],
         [0.3529, 0.3922, 0.4824,  ..., 0.7451, 0.7608, 0.7569],
         [0.2863, 0.5098, 0.6863,  ..., 0.6196, 0.7725, 0.8157],
         ...,
         [0.4824, 0.4667, 0.3529,  ..., 0.5569, 0.5843, 0.5529],
         [0.8314, 0.4392, 0.7608,  ..., 0.5843, 0.5882, 0.4863],
         [0.5922, 0.3490, 0.7059,  ..., 0.6902, 0.5961, 0.5490]],

        [[0.5412, 0.4157, 0.4353,  ..., 0.6118, 0.5804, 0.5686],
         [0.3529, 0.3804, 0.4471,  ..., 0.6431, 0.6471, 0.6392],
         [0.3569, 0.5569, 0.6902,  ..., 0.4784, 0.6118, 0.6431],
         ...,
         [0.4039, 0.4000, 0.2863,  ..., 0.5098, 0.5294, 0.4941],
         [0.7569, 0.3765, 0.7059,  ..., 0.5216, 0.5216, 0.4196],
         [0.5176, 0.2863, 0.6588,  ..., 0.6078, 0.5137, 0.4627]]])

Process finished with exit code 0

6、torchvision中数据集的使用

  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.CIFAR10(root="./dataset", train=True, transform=dataset_transform, download=True)
  8. test_set = torchvision.datasets.CIFAR10(root="./dataset", train=True, transform=dataset_transform, download=True)
  9. # img, target = test_set[0]
  10. # print(img)
  11. # print(target)
  12. # img.show()
  13. ​
  14. writer = SummaryWriter("p10")
  15. for i in range(10):
  16.     img,target = test_set[i]
  17.     writer.add_image("test_set", img, i)
  18.     writer.close()
  19.

[i]

二、模型搭建

7、nn.Module

Neural network简称nn，nn.Module为神经网络的基本骨架的搭建

  1. import torch
  2. from torch import nn
  3. ​
  4. class Jzh(nn.Module):
  5.     # 初始化
  6.     def __int__(self):
  7.         super(Jzh, self).__int__()
  8. ​
  9.     # 功能函数
  10.     def forward(self, input):
  11.         output = input + 1
  12.         return output
  13. ​
  14. jzh = Jzh()
  15. x = torch.tensor(1.0)
  16. output = jzh(x)
  17. print(output)
  18.
7.1模型size
  1. import torch
  2. ​
  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. # 换一种数据的输入方式，这样打印出来的数据会有所不同
  15. input = torch.reshape(input, (1, 1, 5, 5))
  16. kernel = torch.reshape(kernel, (1, 1, 3, 3))
  17. ​
  18. print(input.shape)
  19. print(kernel.shape)
  20.

如下是不做torch.reshape()操作输出的数据尺寸：

D:\software\anaconda\Ana\envs\pycyy\python.exe D:\code\Python\pycyy\nn_conv.py 
torch.Size([5, 5])
torch.Size([3, 3])

Process finished with exit code 0

如下是经过orch.reshape()操作输出的数据尺寸：

D:\software\anaconda\Ana\envs\pycyy\python.exe D:\code\Python\pycyy\nn_conv.py 
torch.Size([1, 1, 5, 5])
torch.Size([1, 1, 3, 3])

Process finished with exit code 0

7.2模型conv
7.2.1卷积过程
  1. import torch
  2. import torch.nn.functional as F
  3. ​
  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]])
  10. # 卷积核
  11. kernel = torch.tensor([[1, 2, 1],
  12.                        [0, 1, 0],
  13.                        [2, 1, 0]])
  14. ​
  15. # 换一种数据的输入方式，这样打印出来的数据会有所不同
  16. input = torch.reshape(input, (1, 1, 5, 5))
  17. kernel = torch.reshape(kernel, (1, 1, 3, 3))
  18. ​
  19. print(input.shape)
  20. print(kernel.shape)
  21. ​
  22. output = F.conv2d(input, kernel, stride=1)
  23. print(output)
  24.

D:\software\anaconda\Ana\envs\pycyy\python.exe D:\code\Python\pycyy\nn_conv.py 
torch.Size([1, 1, 5, 5])
torch.Size([1, 1, 3, 3])
tensor([[[[10, 12, 12],
          [18, 16, 16],
          [13,  9,  3]]]])

Process finished with exit code 0

若再补充如下代码：

  1. output2 = F.conv2d(input, kernel, stride=1, padding=1)
  2. print(output2)

则输出为：

D:\software\anaconda\Ana\envs\pycyy\python.exe D:\code\Python\pycyy\nn_conv.py 
torch.Size([1, 1, 5, 5])
torch.Size([1, 1, 3, 3])
tensor([[[[10, 12, 12],
          [18, 16, 16],
          [13,  9,  3]]]])
tensor([[[[ 1,  3,  4, 10,  8],
          [ 5, 10, 12, 12,  6],
          [ 7, 18, 16, 16,  8],
          [11, 13,  9,  3,  4],
          [14, 13,  9,  7,  4]]]])

Process finished with exit code 0

7.2.2卷积效果：
  1. import torch
  2. import torchvision
  3. from torch import nn
  4. from torch.nn import Conv2d
  5. from torch.utils.data import DataLoader
  6. from torch.utils.tensorboard import SummaryWriter
  7. ​
  8. dataset = torchvision.datasets.CIFAR10("./data_conv2d", train=False, transform=torchvision.transforms.ToTensor(),
  9.                                        download=True)
  10. dataloader = DataLoader(dataset, batch_size=64)
  11. ​
  12. class Jzh(nn.Module):
  13.     def __init__(self):
  14.         super(Jzh, self).__init__()
  15.         # out_channels实际上就是卷积核的数量，有多少个卷积之后就输出几幅图像
  16.         self.conv1 = Conv2d(in_channels=3, out_channels=6, kernel_size=3, stride=1, padding=0)
  17. ​
  18.     def forward(self, x):
  19.         x = self.conv1(x)
  20.         return x
  21. ​
  22. jzh = Jzh()
  23. print(jzh)
  24. ​
  25. writer = SummaryWriter("./logs")
  26. step = 0
  27. for data in dataloader:
  28.     imgs, targets = data
  29.     output = jzh(imgs)
  30.     print(imgs.shape)
  31.     print(output.shape)
  32.     # 输入时的大小：torch.Size([64, 3, 32, 32])
  33.     writer.add_images("input", imgs, step)
  34. ​
  35.     # torch.Size([64, 6, 30, 30]) -> [xxx, 3, 30, 30]
  36.     # 3保证输出的仍是三维的数据与输入时一致，这样就能正常显示输出图像
  37.     output = torch.reshape(output, (-1, 3, 30, 30))
  38.     # 输出时的大小：
  39.     writer.add_images("output", output, step)
  40.     step = step + 1
  41. writer.close()
  42.

[i]

7.3模型pooling
  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.float32)
  10. ​
  11. # -1表示自动计算batch_size;1表示一个channel;5、5表示5*5的输入图像
  12. # batch size（批量大小）是一个超参数，它指的是在进行模型训练或评估时，每次迭代所使用的数据样本的数量。
  13. input = torch.reshape(input, (-1, 1, 5, 5))
  14. print(input.shape)
  15. ​
  16. class Jzh(nn.Module):
  17.     def __init__(self):
  18.         super(Jzh, self).__init__()
  19.         # ceil_mode表示不足三列或者三行的按照三行然后去池中的最大值
  20.         self.maxpool1 = MaxPool2d(kernel_size=3, ceil_mode=True)
  21. ​
  22.     def forward(self, input):
  23.         output = self.maxpool1(input)
  24.         return output
  25. ​
  26. jzh = Jzh()
  27. output = jzh(input)
  28. print(output)
  29.

经池化后输出为：

D:\software\anaconda\Ana\envs\pycyy\python.exe D:\code\Python\pycyy\nn_maxpool.py 
torch.Size([1, 1, 5, 5])
tensor([[[[2., 3.],
          [5., 1.]]]])

Process finished with exit code 0

加载CIRF10数据集进行池化操作：

  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("./data_pool", train=False, download=True,
  9.                                        transform=torchvision.transforms.ToTensor())
  10. ​
  11. dataloader = DataLoader(dataset, batch_size=64)
  12. # 用于创建一个数据加载器（DataLoader），它将数据集（dataset）分成大小为64的批次。
  13. ​
  14. class Jzh(nn.Module):
  15.     def __init__(self):
  16.         super(Jzh, self).__init__()
  17.         # ceil_mode表示不足三列或者三行的按照三行然后去池中的最大值
  18.         self.maxpool1 = MaxPool2d(kernel_size=3, ceil_mode=True)
  19. ​
  20.     def forward(self, input):
  21.         output = self.maxpool1(input)
  22.         return output
  23. ​
  24. jzh = Jzh()
  25. ​
  26. writer = SummaryWriter("logs_maxpool")
  27. step = 0
  28. for data in dataloader:
  29.     imgs, targets = data
  30.     writer.add_images("input", imgs, step)
  31.     output = jzh(imgs)
  32.     writer.add_images("output", output, step)
  33.     step = step+1
  34. ​
  35. writer.close()
  36.

[i]

7.4模型非线性激活
  1. import torch
  2. import torchvision
  3. from torch import nn
  4. from torch.nn import ReLU, Sigmoid
  5. from torch.utils.data import DataLoader
  6. from torch.utils.tensorboard import SummaryWriter
  7. ​
  8. input = torch.tensor([[1, -0.5],
  9.                       [-1, 3]])
  10. input = torch.reshape(input, (-1, 1, 2, 2))
  11. print(input.shape)
  12. ​
  13. dataset = torchvision.datasets.CIFAR10("./data_pool", train=False, download=True,
  14.                                        transform=torchvision.transforms.ToTensor())
  15. dataloader = DataLoader(dataset, batch_size=64)
  16. class Jzh(nn.Module):
  17.     def __init__(self):
  18.         super().__init__()
  19.         self.relu1 = ReLU()
  20.         self.sigmoid1 = Sigmoid()
  21. ​
  22. ​
  23.     def forward(self, input):
  24.         # 将输入的实数值映射到介于0和1之间的输出
  25.         output = self.sigmoid1(input)
  26.         return output
  27. ​
  28. jzh=Jzh()
  29. writer = SummaryWriter("logs_sigmoid1")
  30. step = 0
  31. for data in dataloader:
  32.     imgs, targets = data
  33.     writer.add_images("input", imgs, global_step=step)
  34.     output = jzh(imgs)
  35.     writer.add_images("output", output, step)
  36.     step = step+1
  37. ​
  38. writer.close()
  39.

激活函数向图像引入非线性特征：

[i]

7.5模型全连接
  1. import torch
  2. import torchvision
  3. from torch import nn
  4. from torch.nn import Linear
  5. from torch.utils.data import DataLoader
  6. ​
  7. dataset = torchvision.datasets.CIFAR10("./data_linear", train=False, transform=torchvision.transforms.ToTensor(),
  8.                                        download=True)
  9. dataloader = DataLoader(dataset, batch_size=64, drop_last=True)
  10. ​
  11. class Jzh(nn.Module):
  12.     def __init__(self):
  13.         super().__init__()
  14.         # 将图片展平成torch.Size([1, 1, 1, 196608])格式
  15.         self.linear1 = Linear(196608, 10)
  16. ​
  17.     def forward(self, input):
  18.         output = self.linear1(input)
  19.         return output
  20. ​
  21. jzh = Jzh()
  22. ​
  23. for data in dataloader:
  24.     imgs, target = data
  25.     print(imgs.shape)
  26.     # output = torch.reshape(imgs, (1, 1, 1, -1))
  27.     # 上述代码可以由下一行代码替换,并直接输出成torch.Size([196608])
  28.     output =torch.flatten(imgs)
  29.     print(output.shape)
  30.     output = jzh(output)
  31.     print(output.shape)
  32.

三、搭建小实战

8、CIFAR10模型

Inputs -> 第一层Feature maps 层的计算可由如下公式得出：

[i]

计算过程为：

[ 32 + 2padding - 1(5-1) - 1 ] / stride + 1 = 32 ， 得出padding=2，stride=1

对应代码为：self.conv1 = Conv2d(3, 32, 5, padding=2)

  1. import torch
  2. from torch import nn
  3. from torch.nn import MaxPool2d, Flatten, Linear, Conv2d, Sequential
  4. from torch.utils.tensorboard import SummaryWriter
  5. ​
  6. ​
  7. class Jzh(nn.Module):
  8.     def __init__(self):
  9.         super().__init__()
  10.         # 第一种写法
  11.         # self.conv1 = Conv2d(3, 32, 5, padding=2)
  12.         # self.maxpool1 = MaxPool2d(2)
  13.         # self.conv2 = Conv2d(32, 32, 5, padding=2)
  14.         # self.maxpool2 = MaxPool2d(2)
  15.         # self.conv3 = Conv2d(32, 64, 5, padding=2)
  16.         # self.maxpool3 = MaxPool2d(2)
  17.         # self.flatten = Flatten()
  18.         # self.linear1 = Linear(1024, 64)
  19.         # self.linear2 = Linear(64, 10)
  20. ​
  21.         # 第二种写法
  22.         self.model1 = Sequential(
  23.             Conv2d(3, 32, 5, padding=2),
  24.             MaxPool2d(2),
  25.             Conv2d(32, 32, 5, padding=2),
  26.             MaxPool2d(2),
  27.             Conv2d(32, 64, 5, padding=2),
  28.             MaxPool2d(2),
  29.             Flatten(),
  30.             Linear(1024, 64),
  31.             Linear(64, 10)
  32.         )
  33. ​
  34.     def forward(self, x):
  35.         # 第一种写法
  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. ​
  46.         # 第二种写法
  47.         x = self.model1(x)
  48. ​
  49.         return x
  50. ​
  51. jzh = Jzh()
  52. print(jzh)
  53. # torch.ones((64, 3, 32, 32))里的参数注意和Conv2d(32, 32, 5, padding=2)作区分,这里的64指batch_size
  54. input = torch.ones((64, 3, 32, 32))
  55. output = jzh(input)
  56. # 检验输出结果是否为torch.Size([64, 10]),因为这是一个是分类的模型,若是则证明self.linear2 = Linear(64, 10)正常执行
  57. print(output.shape)
  58. ​
  59. ​
  60. writer = SummaryWriter("./logs_seq")
  61. # jzh 是一个 PyTorch 模型，input 是输入数据，这个函数会将模型的计算图添加到 TensorBoard，以便在可视化时查看模型的结构
  62. writer.add_graph(jzh, input)
  63. writer.close()
  64. ​
​

D:\software\anaconda\Ana\envs\pycyy\python.exe D:\code\Python\pycyy\nn_CIFAR10.py 
Jzh(
  (model1): Sequential(
    (0): Conv2d(3, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
    (1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (2): Conv2d(32, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
    (3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (4): Conv2d(32, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
    (5): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (6): Flatten(start_dim=1, end_dim=-1)
    (7): Linear(in_features=1024, out_features=64, bias=True)
    (8): Linear(in_features=64, out_features=10, bias=True)
  )
)
torch.Size([64, 10])

Process finished with exit code 0

模型结构图：

[i]

9、Lose Function

9.1基本使用

LogSoftmax用于计算log-softmax激活。它的作用是将输入张量中的每个元素进行指数运算后归一化，然后取对数。这样可以将原始输出转换为概率分布，便于在分类任务中使用

计算公式如下：

注意，深度学习中的log默认是以e为底的即ln

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

D:\software\anaconda\Ana\envs\pycyy\python.exe D:\code\Python\pycyy\nn_loss.py 
tensor(0.6667)
tensor(1.3333)
tensor(1.1019)

Process finished with exit code 0

9.2实际作用

  1. 计算实际输出和目标之间的差距

    1. import torch
    2. import torchvision
    3. from torch import nn
    4. from torch.nn import MaxPool2d, Flatten, Linear, Conv2d, Sequential
    5. from torch.utils.data import DataLoader
    6. from torch.utils.tensorboard import SummaryWriter
    7. ​
    8. dataset = torchvision.datasets.CIFAR10("./data_linear", train=False, transform=torchvision.transforms.ToTensor(),
    9.                                        download=True)
    10. dataloader = DataLoader(dataset, batch_size=1)
    11. ​
    12. ​
    13. class Jzh(nn.Module):
    14.     def __init__(self):
    15.         super().__init__()
    16. ​
    17.         # 第二种写法
    18.         self.model1 = Sequential(
    19.             Conv2d(3, 32, 5, padding=2),
    20.             MaxPool2d(2),
    21.             Conv2d(32, 32, 5, padding=2),
    22.             MaxPool2d(2),
    23.             Conv2d(32, 64, 5, padding=2),
    24.             MaxPool2d(2),
    25.             Flatten(),
    26.             Linear(1024, 64),
    27.             Linear(64, 10)
    28.         )
    29. ​
    30.     def forward(self, x):
    31. ​
    32.         # 第二种写法
    33.         x = self.model1(x)
    34.         return x
    35. ​
    36. loss = nn.CrossEntropyLoss()
    37. jzh = Jzh()
    38. for data in dataloader:
    39.     imgs, targets = data
    40.     outputs = jzh(imgs)
    41.     result_loss = loss(outputs, targets)
    42.     print(result_loss)
    43.

    部分输出结果：

    D:\software\anaconda\Ana\envs\pycyy\python.exe D:\code\Python\pycyy\nn_loss_network.py 
    Files already downloaded and verified
    tensor(2.3428, grad_fn=<NllLossBackward0>)
    tensor(2.3684, grad_fn=<NllLossBackward0>)
    tensor(2.3722, grad_fn=<NllLossBackward0>)
    tensor(2.3924, grad_fn=<NllLossBackward0>)
    tensor(2.3649, grad_fn=<NllLossBackward0>)
    tensor(2.3878, grad_fn=<NllLossBackward0>)
    tensor(2.1113, grad_fn=<NllLossBackward0>)

  2. 为我们更新输出提供一定的依据：反向传播and优化器

    主体部分不变，在上述代码中增加如下sgd优化器代码：

    1. loss = nn.CrossEntropyLoss()
    2. jzh = Jzh()
    3. # lr为学习速率,一般模型训练开始时设置较大,模型训练后期设置较小
    4. optim = torch.optim.SGD(jzh.parameters(), 0.01)
    5. for epoch in range(20):
    6.     running_loss = 0.0
    7.     # 下面这个for仅代表循环一次
    8.     for data in dataloader:
    9.         imgs, targets = data
    10.         outputs = jzh(imgs)
    11.         result_loss = loss(outputs, targets)
    12.         # 清零梯度
    13.         optim.zero_grad()
    14.         # 计算每个节点参数的梯度，方便后续用优化器对其优化
    15.         result_loss.backward()
    16.         optim.step()
    17.         # 这一轮整体误差总和
    18.         running_loss = running_loss + result_loss
    19.     print(running_loss)
    20. ​

    部分运行结果：

D:\software\anaconda\Ana\envs\pycyy\python.exe D:\code\Python\pycyy\nn_optim.py 
Files already downloaded and verified
tensor(18591.2637, grad_fn=<AddBackward0>)
tensor(16061.7539, grad_fn=<AddBackward0>)
tensor(15454.4775, grad_fn=<AddBackward0>)
tensor(15985.7441, grad_fn=<AddBackward0>)
tensor(18142.6211, grad_fn=<AddBackward0>)
tensor(20303.0449, grad_fn=<AddBackward0>)
tensor(22268.1523, grad_fn=<AddBackward0>)
tensor(23856.8047, grad_fn=<AddBackward0>)
tensor(25047.0723, grad_fn=<AddBackward0>)

四、现有网络模型的使用及修改

10、vgg16

  1. import torchvision
  2. from torchvision.models import VGG16_Weights
  3. from torch import nn
  4. ​
  5. # train_data = torchvision.datasets.ImageNet("./data_imagenet", split='train', download=True,
  6. #                                            transform=torchvision.transforms.ToTensor())
  7. ​
  8. # vgg16_false = torchvision.models.vgg16(pretrained=False)
  9. # 设置成true则下载的是一个已经预训练过的模型
  10. # vgg16_true = torchvision.models.vgg16(pretrained=True)
  11. # 下列语句为新版本模型加载代码，新版本默认没有预训练，如需预训练则需加上weights=VGG16_Weights.DEFAULT
  12. vgg16_true = torchvision.models.vgg16(weights=VGG16_Weights.DEFAULT)
  13. print(vgg16_true)
  14. ​
  15. train_data = torchvision.datasets.CIFAR10("./dataset", train=True, transform=torchvision.transforms.ToTensor(),
  16.                                        download=True)
  17. # 对模型进行修改，从1000分类修改成10分类
  18. vgg16_true.classifier.add_module('add_linear', nn.Linear(1000, 10))
  19. print(vgg16_true)
  20.

VGG1000分类和10分类输出对比：

VGG(
  (features): Sequential(
    (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): ReLU(inplace=True)
    (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (3): ReLU(inplace=True)
    (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (6): ReLU(inplace=True)
    (7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (8): ReLU(inplace=True)
    (9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (11): ReLU(inplace=True)
    (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (13): ReLU(inplace=True)
    (14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (15): ReLU(inplace=True)
    (16): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (17): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (18): ReLU(inplace=True)
    (19): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (20): ReLU(inplace=True)
    (21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (22): ReLU(inplace=True)
    (23): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (24): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (25): ReLU(inplace=True)
    (26): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (27): ReLU(inplace=True)
    (28): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (29): ReLU(inplace=True)
    (30): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (avgpool): AdaptiveAvgPool2d(output_size=(7, 7))
  (classifier): Sequential(
    (0): Linear(in_features=25088, out_features=4096, bias=True)
    (1): ReLU(inplace=True)
    (2): Dropout(p=0.5, inplace=False)
    (3): Linear(in_features=4096, out_features=4096, bias=True)
    (4): ReLU(inplace=True)
    (5): Dropout(p=0.5, inplace=False)
    (6): Linear(in_features=4096, out_features=1000, bias=True)
  )
)
改成10分类则在(6): Linear(in_features=4096, out_features=1000, bias=True)之后多添加了一层线性层：
 (add_linear): Linear(in_features=1000, out_features=10, bias=True)

10.1模型的保存与读取

model_save

  1. import torch
  2. import torchvision
  3. from torch import nn
  4. ​
  5. vgg16 = torchvision.models.vgg16(weights=None)
  6. # 第一种保存方式,模型结构+模型参数
  7. torch.save(vgg16, "vgg16_method1.pth")
  8. ​
  9. # 第二种保存方式,模型参数（保存成字典形式）,官方推荐,但这样输出的就不再是一个网络模型了,需要使用还要进行相关操作
  10. torch.save(vgg16.state_dict(), "vgg16_method2.pth")
  11. ​
  12. # 方式一有陷阱（如果自己搭建模型的话）
  13. class Jzh(nn.Module):
  14.     def __init__(self):
  15.         super(Jzh, self).__init__()
  16.         self.conv1 = nn.Conv2d(3, 64, kernel_size=3)
  17. ​
  18.     def forward(self, x):
  19.         x = self.conv1(x)
  20.         return x
  21. ​
  22. jzh = Jzh()
  23. torch.save(jzh, "jzh_method1.pth")
  24.

model_load

  1. import torch
  2. import torchvision
  3. from model_save import *
  4. from torch import nn
  5.  
  6. # 对应方式1，加载模型
  7. model = torch.load("vgg16_method1.pth")
  8. # print(model)
  9.  
  10. # 对应方式2，加载模型
  11. vgg16 = torchvision.models.vgg16(weights=None)
  12. vgg16.load_state_dict(torch.load("vgg16_method2.pth"))
  13. # model = torch.load("vgg16_method2.pth")
  14. print(vgg16)
  15.  
  16. # 方式一陷阱,自己创建的模型需要在这里定义一下,但是from model_save import *下面代码就可以不要了,
  17. # model_save文件定义过了,直接加载模型打印
  18. # class Jzh(nn.Module):
  19. #     def __init__(self):
  20. #         super(Jzh, self).__init__()
  21. #         self.conv1 = nn.Conv2d(3, 64, kernel_size=3)
  22. #
  23. #     def forward(self, x):
  24. #         x = self.conv1(x)
  25. #         return x
  26.  
  27. model = torch.load('jzh_method1.pth')
  28. print(model)

五、完整的模型训练套路

11、模型训练

11.1train
  1. import torch
  2. ​
  3. import torchvision
  4. from torch.utils.data import DataLoader
  5. from torch.utils.tensorboard import SummaryWriter
  6. ​
  7. from model import *
  8. ​
  9. # 准备数据集
  10. train_data = torchvision.datasets.CIFAR10(root="./data_taolu", train=True, transform=torchvision.transforms.ToTensor(),
  11.                                           download=True)
  12. test_data = torchvision.datasets.CIFAR10(root="./data_taolu", train=False, transform=torchvision.transforms.ToTensor(),
  13.                                           download=True)
  14. ​
  15. train_data_size = len(train_data)
  16. test_data_size = len(test_data)
  17. print("训练数据集的长度为：{}".format(train_data_size))
  18. print("测试数据集的长度为：{}".format(test_data_size))
  19. ​
  20. # 利用DataLoader来加载数据集
  21. train_dataloader = DataLoader(train_data, batch_size=64)
  22. test_dataloader = DataLoader(test_data, batch_size=64)
  23. ​
  24. # 创建网络模型
  25. jzh = Jzh()
  26. ​
  27. # 创建损失函数
  28. loss_fn = nn.CrossEntropyLoss()
  29. ​
  30. # 优化器
  31. # learning_rate = 0.01
  32. # 1e-2=1 x (10)^(-2) = 1/100 = 0.01
  33. learning_rate = 1e-2
  34. optimizer = torch.optim.SGD(jzh.parameters(), lr=learning_rate)
  35. ​
  36. # 设置网络的一些参数
  37. # 记录训练次数
  38. total_train_step = 0
  39. # 记录测试次数
  40. total_test_step = 0
  41. # 记录训练的轮数
  42. epoch = 10
  43. ​
  44. # 添加tensorboard
  45. writer = SummaryWriter("./logs_train")
  46. ​
  47. for i in range(epoch):
  48.     print("------第 {} 轮训练开始------".format(i+1))
  49.     # 训练步骤开始
  50.     jzh.train()
  51.     for data in train_dataloader:
  52.         imgs, targets = data
  53.         outputs = jzh(imgs)
  54.         loss = loss_fn(outputs, targets)
  55. ​
  56.         # 优化器调优
  57.         optimizer.zero_grad()
  58.         loss.backward()
  59.         optimizer.step()
  60. ​
  61.         total_train_step = total_train_step + 1
  62.         if total_train_step % 100 == 0:
  63.             print("训练次数: {}, loss: {}".format(total_train_step, loss.item()))
  64.             writer.add_scalar("train_loss", loss.item(), total_train_step)
  65. ​
  66.     # 测试步骤开始
  67.     jzh.eval()
  68.     total_test_loss = 0
  69.     total_accuracy = 0
  70.     with torch.no_grad():
  71.         for data in test_dataloader:
  72.             imgs, targets = data
  73.             outputs = jzh(imgs)
  74.             loss = loss_fn(outputs, targets)
  75.             total_test_loss = total_test_loss + loss.item()
  76.             accuracy = (outputs.argmax(1) == targets).sum()
  77.             total_accuracy = total_accuracy + accuracy
  78.     print("整体测试集上的loss: {}".format(total_test_loss))
  79.     print("整体测试集上的正确率: {}".format(total_accuracy/test_data_size))
  80.     writer.add_scalar("test_loss", total_test_loss, total_test_step)
  81.     writer.add_scalar("test_accuracy", total_accuracy/test_data_size, total_test_step)
  82.     total_test_step = total_test_step + 1
  83. ​
  84.     # 保存模型
  85.     torch.save(jzh, "jzh_{}.pth".format(i))
  86.     print("模型已保存")
  87. writer.close()
  88. ​
11.2model
  1. import torch
  2. from torch import nn
  3. ​
  4. # 搭建神经网络
  5. class Jzh(nn.Module):
  6.     def __init__(self):
  7.         super(Jzh, self).__init__()
  8.         self.model = nn.Sequential(
  9.             nn.Conv2d(3, 32, 5, 1,  padding=2),
  10.             nn.MaxPool2d(2),
  11.             nn.Conv2d(32, 32, 5, 1, padding=2),
  12.             nn.MaxPool2d(2),
  13.             nn.Conv2d(32, 64, 5, 1, padding=2),
  14.             nn.MaxPool2d(2),
  15.             nn.Flatten(),
  16.             nn.Linear(1024, 64),
  17.             nn.Linear(64, 10)
  18.         )
  19. ​
  20.     def forward(self, x):
  21.         x = self.model(x)
  22.         return x
  23. ​
  24. ​
  25. if __name__ == '__main__':
  26.     jzh = Jzh()
  27.     input = torch.ones((64, 3, 32, 32))
  28.     output = jzh(input)
  29.     print(output.shape)
  30.

部分输出结果：

训练数据集的长度为：50000
测试数据集的长度为：10000
------第 1 轮训练开始------
训练次数: 100, loss: 2.2846009731292725
训练次数: 200, loss: 2.2844748497009277
训练次数: 300, loss: 2.2514917850494385
训练次数: 400, loss: 2.148555278778076
训练次数: 500, loss: 2.1040234565734863
训练次数: 600, loss: 2.033297061920166
训练次数: 700, loss: 1.9678012132644653
整体测试集上的loss: 320.23996794223785
整体测试集上的正确率: 0.26930001378059387
模型已保存
------第 2 轮训练开始------
训练次数: 800, loss: 1.8451868295669556
训练次数: 900, loss: 1.8664506673812866
训练次数: 1000, loss: 1.905165433883667
训练次数: 1100, loss: 1.979297161102295
训练次数: 1200, loss: 1.6892757415771484
训练次数: 1300, loss: 1.655542254447937
训练次数: 1400, loss: 1.725655436515808
训练次数: 1500, loss: 1.8056442737579346
整体测试集上的loss: 287.658221244812
整体测试集上的正确率: 0.3418999910354614
模型已保存

模型tensorboard图：

[i]

[i]

[i]

总结来说，完整的模型训练套路为：准备数据，加载数据，准备模型，设置损失函数，设置优化器，开始训练，最后验证，结果聚合展示

12、模型测试

12.1test
  1. import torch
  2. import torchvision
  3. from PIL import Image
  4. from torch import nn
  5. ​
  6. image_path = "./imgs/airplan.png"
  7. image = Image.open(image_path)
  8. # 保留颜色通道，加上这一步后可以适应png、jpg各种格式图片
  9. # image = image.convert('RGB')
  10. print(image)
  11. ​
  12. transform = torchvision.transforms.Compose([torchvision.transforms.Resize((32, 32)),
  13.                                             torchvision.transforms.ToTensor()])
  14. ​
  15. image = transform(image)
  16. print(image.shape)
  17. ​
  18. class Jzh(nn.Module):
  19.     def __init__(self):
  20.         super(Jzh, self).__init__()
  21.         self.model = nn.Sequential(
  22.             nn.Conv2d(3, 32, 5, 1,  padding=2),
  23.             nn.MaxPool2d(2),
  24.             nn.Conv2d(32, 32, 5, 1, padding=2),
  25.             nn.MaxPool2d(2),
  26.             nn.Conv2d(32, 64, 5, 1, padding=2),
  27.             nn.MaxPool2d(2),
  28.             nn.Flatten(),
  29.             nn.Linear(1024, 64),
  30.             nn.Linear(64, 10)
  31.         )
  32. ​
  33.     def forward(self, x):
  34.         x = self.model(x)
  35.         return x
  36. ​
  37. model = torch.load("./jzh_9.pth")
  38. # 若使用GPU训练的模型，一定要使用下述语句将其映射到CPU上
  39. # model = torch.load("jzh_gpu.pth" ,map_location=torch.device('cpu'))
  40. print(model)
  41. # 数据要和模型一致
  42. image = torch.reshape(image, (1, 3, 32, 32))
  43. model.eval()
  44. with torch.no_grad():
  45.     output = model(image)
  46. print(output)
  47.

如图为CIFAR10数据集对应的物体类别：

[i]

如下为预测结果：

D:\software\anaconda\Ana\envs\pycyy\python.exe D:\code\Python\pycyy\test.py 
<PIL.PngImagePlugin.PngImageFile image mode=RGB size=295x183 at 0x21FE599AC08>
torch.Size([3, 32, 32])
Jzh(
  (model): Sequential(
    (0): Conv2d(3, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
    (1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (2): Conv2d(32, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
    (3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (4): Conv2d(32, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
    (5): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (6): Flatten(start_dim=1, end_dim=-1)
    (7): Linear(in_features=1024, out_features=64, bias=True)
    (8): Linear(in_features=64, out_features=10, bias=True)
  )
)
tensor([[10.5353,  1.8883,  1.5429, -2.5516,  0.0149, -4.7008, -5.5488, -5.0510,
          3.8907, -1.5681]])
tensor([0])

Process finished with exit code 0

其中airplan对应类别下标为00，其预测概率最大，模型预测正确

后续将继续学习github上优秀的开源项目，加油！！！

Author:####Jzh##

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

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

  

闽ICP备14008679号