深度学习（十二）——神经网络：搭建小实战和Sequential的使用

一、torch.nn.Sequential代码栗子#

官方文档：Sequential — PyTorch 2.0 documentation

Copy
# Using Sequential to create a small model. When `model` is run,
# input will first be passed to `Conv2d(1,20,5)`. The output of
# `Conv2d(1,20,5)` will be used as the input to the first
# `ReLU`; the output of the first `ReLU` will become the input
# for `Conv2d(20,64,5)`. Finally, the output of
# `Conv2d(20,64,5)` will be used as input to the second `ReLU`
model = nn.Sequential(
          nn.Conv2d(1,20,5),
          nn.ReLU(),
          nn.Conv2d(20,64,5),
          nn.ReLU()
        )

• 在第一个变量名model中，依次执行nn.Convd2d(1,20,5)、nn.ReLU()、nn.Conv2d(20,64,5)、nn.ReLU()四个函数。这样写起来的好处是使代码更简洁。

• 由此可见，函数$Sequential$的主要作用为依次执行括号内的函数

二、神经网络搭建实战#

采用$CIFAR10$中的数据，并对其进行简单的分类。以下图为例：

• 输入：3通道，32×32 → 经过一个5×5的卷积 → 变成32通道，32×32的图像 → 经过2×2的最大池化 → 变成32通道，16×16的图像.... → ... → 变成64通道，4×4的图像 → 把图像展平（Flatten）→ 变成64通道，1×1024 （64×4×4） 的图像 → 通过两个线性层，最后$out\mathrm{\_}feature=10$ → 得到最终图像

以上，就是CIFAR10模型的结构。本节的代码也基于CIFAR10 model的结构构建。

1. 神经网络中的参数设计及计算#

（1）卷积层的参数设计（以第一个卷积层conv1为例）#

• 输入图像为3通道，输出图像为32通道，故：$in\mathrm{\_}channels=3$；$out\mathrm{\_}channels=32$

• 卷积核尺寸为$5\times 5$

• 图像经过卷积层conv1前后的尺寸均为32×32，根据公式：

  $$H_{out}=\lfloor \frac{H_{in}+2\times padding[0]-dilation[0]\times (kernel\mathrm{\_}size[0]-1)-1}{stride[0]}+1\rfloor$$
  $$W_{out}=\lfloor \frac{W_{in}+2\times padding[1]-dilation[1]\times (kernel\mathrm{\_}size[1]-1)-1}{stride[1]}+1\rfloor$$

  可得：

  $$H_{out}=\lfloor \frac{32+2\times padding[0]-1\times (5-1)-1}{stride[0]}+1\rfloor =32$$
  $$W_{out}=\lfloor \frac{32+2\times padding[1]-1\times (5-1)-1}{stride[1]}+1\rfloor =32$$

  即：

  $$\frac{27+2\times padding[0]}{stride[0]}=31$$
  $$\frac{27+2\times padding[1]}{stride[1]}=31$$

  若$stride[0]$或$stride[1]$设置为2，那么上面的$padding$也会随之扩展为一个很大的数，这很不合理。所以这里设置：$stride[0]=stride[1]=1$，由此可得：$padding[0]=padding[1]=2$

其余卷积层的参数设计及计算方法均同上。

（2）最大池化操作的参数设计（以第一个池化操作maxpool1为例）#

• 由图可得，$kennel\mathrm{\_}size=2$

其余最大池化参数设计方法均同上。

（3）线性层的参数设计#

• 通过三次卷积和最大池化操作后，图像尺寸变为64通道4×4。之后使用$Flatten()$函数将图像展成一列，此时图像尺寸变为：1×(64×4×4)，即$1\times 1024$

• 因此，之后通过第一个线性层，$in\mathrm{\_}features=1024$，$out\mathrm{\_}features=64$

• 通过第二个线性层，$in\mathrm{\_}features=64$，$out\mathrm{\_}features=10$

2. 构建神经网络实战#

Copy
import torch
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear

class Demo(nn.Module):
    def __init__(self):
        super(Demo,self).__init__()

        # 搭建第一个卷积层:in_channels=3，out_channels=32，卷积核尺寸为5×5,通过计算得出：padding=2;stride默认情况下为1，不用设置
        self.conv1=Conv2d(3,32,5,padding=2)

        # 第一个最大池化操作,kennel_size=2
        self.maxpool1=MaxPool2d(2)

        # 第二个卷积层及最大池化操作
        self.conv2=Conv2d(32,32,5,padding=2)
        self.maxpool2=MaxPool2d(2)

        # 第三个卷积层及最大池化操作
        self.conv3=Conv2d(32,64,5,padding=2)
        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)   #如果线性层的1024和64不会计算，可以在self.flatten之后print(x.shape)查看尺寸，以此设定linear的参数
        x = self.linear2(x)
        return x

demo=Demo()
print(demo)
"""
[Run]
Demo(
  (conv1): Conv2d(3, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
  (maxpool1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (conv2): Conv2d(32, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
  (maxpool2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (conv3): Conv2d(32, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
  (maxpool3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (flatten): Flatten(start_dim=1, end_dim=-1)
  (linear1): Linear(in_features=1024, out_features=64, bias=True)
  (linear2): Linear(in_features=64, out_features=10, bias=True)
)

可以看出，网络还是有模有样的
"""

#构建输入，测试神经网络
input=torch.ones((64,3,32,32))  #构建图像，batch_size=64,3通道,32×32
output=demo(input)
print(output.shape)  #[Run] torch.Size([64, 10])

这里的$forward$函数写的有点烦，这时候$Sequential$函数的优越就体现出来了（墨镜黄豆）。下面是$class$ $Demo$优化后的代码：

Copy
class Demo(nn.Module):
    def __init__(self):
        super(Demo,self).__init__()

        self.model1=Sequential(
            Conv2d(3,32,5,padding=2),
            MaxPool2d(2),
            Conv2d(32, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 64, 5, padding=2),
            MaxPool2d(2),
            Flatten(),
            Linear(1024, 64),
            Linear(64, 10)
        )

    def forward(self,x):
        x=self.model1(x)
        return x

极简主义者看过后表示很满意ε٩(๑> ₃ <)۶з

3. 可视化神经网络#

Copy
from torch.utils.tensorboard import SummaryWriter
writer=SummaryWriter("logs_seq")
writer.add_graph(demo,input)
writer.close()

这样就可以清晰地看到神经网络的相关参数啦