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

【pytorch】实现简单的CNN卷积神经网络_卷积层pytorch代码

作者：从前慢现在也慢 | 2024-06-14 07:47:43

赞

踩

卷积层pytorch代码

目录

一. 卷积层 nn.Conv2d()

参数设置

代码示例

二. 池化层 nn.MaxPool1d() 和 nn.MaxPool2d()

参数设置

代码示例

三. 激活函数层 nn.ReLU()

参数设置

四. CNN的简单实现

一. 卷积层 nn.Conv2d()

参数设置

在Pytorch的nn模块中，封装了nn.Conv2d()类作为二维卷积的实现。参数如下图所示

卷积形参

  • in_channels：输入张量的channels数
  • out_channels：输出张量的channels数
  • kernel_size：卷积核的大小。一般我们会使用3x3这种两个数相同的卷积核，这种情况只需要写kernel_size = 3就行了。如果左右两个数不同，比如3x5，那么写作kernel_size = (3, 5)
  • stride = 1：步长
  • padding：填充图像的上下左右，后面的常数代表填充的多少（行数、列数），默认为0。padding = 1时，若原始图像大小为32x32，则padding后的图像大小为34x34
  • dilation = 1：是否采用空洞卷积，默认为1（即不采用）
  • groups = 1：决定了是否采用分组卷积，默认为1可以参考一下：groups参数的理解
  • bias = True：是否要添加偏置参数作为可学习参数的一个，默认为True
  • padding_mode = ‘zeros’：padding的模式，默认采用零填充

前三个参数需要手动提供，后面的都有默认值

代码示例

  1. class Net(nn.Module):
  2.     def __init__(self):
  3.         nn.Module.__init__(self)
  4.         self.conv2d = nn.Conv2d(in_channels=3,out_channels=64,kernel_size=4,stride=2,padding=1)
  5.  
  6.     def forward(self, x):
  7.         print(x.requires_grad)
  8.         x = self.conv2d(x)
  9.         return x
  10.     
  11. # 查看卷积层的权重和偏置
  12. print(net.conv2d.weight)
  13. print(net.conv2d.bias)

二. 池化层 nn.MaxPool1d() 和 nn.MaxPool2d()

参数设置

class torch.nn.MaxPool1d(kernel_size, stride=None, padding=0, dilation=1, return_indices=False, ceil_mode=False)
class torch.nn.MaxPool2d(kernel_size, stride=None, padding=0, dilation=1, return_indices=False, ceil_mode=False)
  • kernel_size：(int or tuple)max pooling的窗口大小
  • stride：(int or tuple, optional)max pooling的窗口移动的步长。默认值是kernel_size
  • padding：(int or tuple, optional)输入的每一条边补充0的层数
  • dilation：(int or tuple, optional)控制窗口中元素步幅的参数
  • return_indices：如果等于True，会返回输出最大值的序号，对于上采样操作会有帮助
  • ceil_mode：如果等于True，计算输出信号大小的时候，会使用向上取整，代替默认的向下取整的操作

代码示例

  1. import torch
  2. import torch.nn as nn
  3. from torch.autograd import Variable
  4.  
  5. input = Variable(torch.randn(2, 5, 5))
  6. m1 = nn.MaxPool1d(3, stride=2)
  7. m2 = nn.MaxPool2d(3, stride=2)
  8. output1 = m1(input)
  9. output2 = m2(input)
  10.  
  11. print(input)
  12. print(output1)
  13. print(output2)
  1. # 输出结果，可对比二者区别
  2. tensor([[[ 2.4444e-01,  1.0226e+00,  2.4089e-01,  4.3374e-01,  8.6254e-01],
  3.          [-1.1597e-01, -5.1438e-01,  4.9354e-01,  1.3846e+00, -1.4846e+00],
  4.          [-5.2985e-01, -9.7652e-01, -1.1763e+00, -1.0564e+00,  1.8538e+00],
  5.          [-1.5157e+00,  2.4466e-03, -1.3180e+00, -6.4395e-01,  1.6216e-01],
  6.          [ 5.0826e-01, -4.2336e-01, -1.1817e+00, -3.9826e-01,  1.1857e-01]],
  7.  
  8.         [[-7.9605e-01,  2.2759e-01,  2.1400e+00, -2.2706e-01,  9.8575e-01],
  9.          [-3.0485e+00, -6.6409e-01,  2.9864e-01,  1.3190e+00, -1.5249e+00],
  10.          [ 3.1127e-01,  4.2901e-01,  1.0026e+00,  6.4803e-01,  9.4203e-01],
  11.          [-5.6758e-01,  3.2101e-01, -4.5395e-01,  1.8376e+00, -8.6135e-01],
  12.          [ 7.8916e-01, -1.3624e+00, -1.3352e+00, -2.5927e+00, -3.1461e-01]]])
  13. tensor([[[ 1.0226,  0.8625],
  14.          [ 0.4935,  1.3846],
  15.          [-0.5298,  1.8538],
  16.          [ 0.0024,  0.1622],
  17.          [ 0.5083,  0.1186]],
  18.  
  19.         [[ 2.1400,  2.1400],
  20.          [ 0.2986,  1.3190],
  21.          [ 1.0026,  1.0026],
  22.          [ 0.3210,  1.8376],
  23.          [ 0.7892, -0.3146]]])
  24.  
  25. tensor([[[1.0226, 1.8538],
  26.          [0.5083, 1.8538]],
  27.  
  28.         [[2.1400, 2.1400],
  29.          [1.0026, 1.8376]]])
  30.  
  31. Process finished with exit code 0

三. 激活函数层 nn.ReLU()

参数设置

nn.ReLU(inplace=True)

nn.ReLU()用来实现Relu函数，实现非线性。ReLU函数有个inplace参数，如果设为True，它会把输出直接覆盖到输入中，这样可以节省内存。之所以可以覆盖是因为在计算ReLU的反向传播时，只需根据输出就能够推算出反向传播的梯度。一般不使用inplace操作。

四. CNN的简单实现

  1. import os
  2. import numpy as np
  3. import torch
  4. import torch.nn as nn
  5. import torch.utils.data as Data
  6. import torchvision
  7. import matplotlib.pyplot as plt
  8.  
  9. # 循环次数
  10. EPOCH = 2
  11. BATCH_SIZE = 50
  12.  
  13. # 下载mnist数据集
  14. train_data = torchvision.datasets.MNIST(root='./mnist/', train=True, transform=torchvision.transforms.ToTensor(),
  15.                                         download=True, )
  16. # (60000, 28, 28)
  17. print(train_data.data.size())
  18. # (60000)
  19. print(train_data.targets.size())
  20.  
  21. train_loader = Data.DataLoader(dataset=train_data, batch_size=BATCH_SIZE, shuffle=True)
  22.  
  23. # 测试集
  24. test_data = torchvision.datasets.MNIST(root='./mnist/', train=False)
  25.  
  26. # (2000, 1, 28, 28)
  27. # 标准化
  28. test_x = torch.unsqueeze(test_data.data, dim=1).type(torch.FloatTensor)[:2000] / 255.
  29. test_y = test_data. targets[:2000]
  30.  
  31.  
  32. # 建立pytorch神经网络
  33. class CNN(nn.Module):
  34.     def __init__(self):
  35.         super(CNN, self).__init__()
  36.         #   第一部分卷积
  37.         self.conv1 = nn.Sequential(
  38.             nn.Conv2d(
  39.                 in_channels=1,
  40.                 out_channels=32,
  41.                 kernel_size=5,
  42.                 stride=1,
  43.                 padding=2,
  44.                 dilation=1
  45.             ),
  46.             nn.ReLU(),
  47.             nn.MaxPool2d(kernel_size=2),
  48.         )
  49.         #   第二部分卷积
  50.         self.conv2 = nn.Sequential(
  51.             nn.Conv2d(
  52.                 in_channels=32,
  53.                 out_channels=64,
  54.                 kernel_size=3,
  55.                 stride=1,
  56.                 padding=1,
  57.                 dilation=1
  58.             ),
  59.             nn.ReLU(),
  60.             nn.MaxPool2d(kernel_size=2),
  61.         )
  62.         #   全连接+池化+全连接
  63.         self.ful1 = nn.Linear(64 * 7 * 7, 512)
  64.         self.drop = nn.Dropout(0.5)
  65.         self.ful2 = nn.Sequential(nn.Linear(512, 10), nn.Softmax(dim=1))
  66.  
  67.     #   前向传播
  68.     def forward(self, x):
  69.         x = self.conv1(x)
  70.         x = self.conv2(x)
  71.         x = x.view(x.size(0), -1)
  72.         x = self.ful1(x)
  73.         x = self.drop(x)
  74.         output = self.ful2(x)
  75.  
  76.         return output
  77.  
  78.  
  79. cnn = CNN()
  80. # 指定优化器
  81. optimizer = torch.optim.Adam(cnn.parameters(), lr=1e-3)
  82. # 指定loss函数
  83. loss_func = nn.CrossEntropyLoss()
  84.  
  85. for epoch in range(EPOCH):
  86.     for step, (b_x, b_y) in enumerate(train_loader):
  87.         #   计算loss并修正权值
  88.         output = cnn(b_x)
  89.         loss = loss_func(output, b_y)
  90.         optimizer.zero_grad()
  91.         loss.backward()
  92.         optimizer.step()
  93.         #   打印
  94.         if step % 50 == 0:
  95.             test_output = cnn(test_x)
  96.  
  97.             pred_y = torch.max(test_output, 1)[1].data.numpy()
  98.             accuracy = float((pred_y == test_y.data.numpy()).astype(int).sum()) / float(test_y.size(0))
  99.             print('Epoch: %2d' % epoch, ', loss: %.4f' % loss.data.numpy(), ', accuracy: %.4f' % accuracy)
  100.  
  1. # 输出结果
  2. torch.Size([60000, 28, 28])
  3. torch.Size([60000])
  4. Epoch:  0 , loss: 2.3028 , accuracy: 0.0885
  5. Epoch:  0 , loss: 1.7379 , accuracy: 0.7115
  6. Epoch:  0 , loss: 1.6186 , accuracy: 0.8775
  7. Epoch:  0 , loss: 1.5239 , accuracy: 0.9120
  8. Epoch:  0 , loss: 1.6127 , accuracy: 0.9170
  9. Epoch:  0 , loss: 1.5039 , accuracy: 0.9250
  10. Epoch:  0 , loss: 1.4878 , accuracy: 0.9415
  11. Epoch:  0 , loss: 1.5210 , accuracy: 0.9430
  12. Epoch:  0 , loss: 1.4822 , accuracy: 0.9425
  13. Epoch:  0 , loss: 1.5443 , accuracy: 0.9505
  14. Epoch:  0 , loss: 1.4634 , accuracy: 0.9510
  15. Epoch:  0 , loss: 1.5371 , accuracy: 0.9310
  16. Epoch:  0 , loss: 1.4888 , accuracy: 0.9585
  17. Epoch:  0 , loss: 1.4767 , accuracy: 0.9575
  18. Epoch:  0 , loss: 1.5294 , accuracy: 0.9610
  19. Epoch:  0 , loss: 1.4813 , accuracy: 0.9650
  20. Epoch:  0 , loss: 1.4972 , accuracy: 0.9635
  21. Epoch:  0 , loss: 1.5218 , accuracy: 0.9585
  22. Epoch:  0 , loss: 1.4837 , accuracy: 0.9605
  23. Epoch:  0 , loss: 1.4762 , accuracy: 0.9595
  24. Epoch:  0 , loss: 1.5419 , accuracy: 0.9565
  25. Epoch:  0 , loss: 1.4810 , accuracy: 0.9590
  26. Epoch:  0 , loss: 1.4621 , accuracy: 0.9575
  27. Epoch:  0 , loss: 1.5410 , accuracy: 0.9595
  28. Epoch:  1 , loss: 1.4650 , accuracy: 0.9670
  29. Epoch:  1 , loss: 1.4890 , accuracy: 0.9610
  30. Epoch:  1 , loss: 1.4875 , accuracy: 0.9630
  31. Epoch:  1 , loss: 1.4800 , accuracy: 0.9680
  32. Epoch:  1 , loss: 1.5326 , accuracy: 0.9655
  33. Epoch:  1 , loss: 1.4763 , accuracy: 0.9670
  34. Epoch:  1 , loss: 1.5177 , accuracy: 0.9685
  35. Epoch:  1 , loss: 1.4612 , accuracy: 0.9520
  36. Epoch:  1 , loss: 1.4632 , accuracy: 0.9605
  37. Epoch:  1 , loss: 1.5207 , accuracy: 0.9615
  38. Epoch:  1 , loss: 1.5021 , accuracy: 0.9645
  39. Epoch:  1 , loss: 1.5303 , accuracy: 0.9645
  40. Epoch:  1 , loss: 1.4821 , accuracy: 0.9565
  41. Epoch:  1 , loss: 1.4812 , accuracy: 0.9660
  42. Epoch:  1 , loss: 1.4762 , accuracy: 0.9685
  43. Epoch:  1 , loss: 1.4812 , accuracy: 0.9690
  44. Epoch:  1 , loss: 1.4614 , accuracy: 0.9490
  45. Epoch:  1 , loss: 1.4740 , accuracy: 0.9580
  46. Epoch:  1 , loss: 1.4625 , accuracy: 0.9695
  47. Epoch:  1 , loss: 1.5190 , accuracy: 0.9685
  48. Epoch:  1 , loss: 1.5242 , accuracy: 0.9645
  49. Epoch:  1 , loss: 1.4612 , accuracy: 0.9755
  50. Epoch:  1 , loss: 1.4812 , accuracy: 0.9580
  51. Epoch:  1 , loss: 1.4812 , accuracy: 0.9625
  52.  
  53. Process finished with exit code 0

最后这个完整代码是刚学的时候网上找的，不太记得出处了

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

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

  

闽ICP备14008679号