神经网络的搭建 (1)

神经网络的搭建(1)

一、Sequential的使用

可将神经网络构造函数__init__()中的可学习的参数层进行一个整体的打包

CLASS  torch.nn.Sequential(*args: Module)

CLASStorch.nn.Sequential(arg: OrderedDict[str, Module])

二、搭建网络

CIFAR-10 模型结构：

输入(3通道 32*32) -----》 卷积（5*5的卷积核）=====》 变成（32通道 32*32）-----》 最大池化（2*2 核心） =====》 变成（32通道 16*16）
-----》 卷积（5*5的卷积核） =====》 变成（32通道 16*16） -----》 最大池化（2*2 核心） =====》 变成（32通道 8*8）-----》 卷积（5*5的卷积核）
=====》 变成（64通道 8*8） -----》 最大池化（2*2 核心） =====》 变成（64通道 2*2） -----》 展平层（Flatten） =====> 变成64
-----》 通过一个线性层 =====》 变成10 输出

通过官网公式计算：padding与dilation(默认为1)

CLASStorch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True, padding_mode='zeros', device=None, dtype=None)

如第一个卷积层的 参数，dilation默认为1，将Hin=32,kernel_size[0]=5,Hout=32，带入易得stride[0]=1,最后得到padding[0]=1

网络代码:

"""
    通过CIFAR-10 网络模型架构 构建网络
"""

from torch import nn
import torch

# 创建网络
class Module(nn.Module):
    def __init__(self):
        super(Module, 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(),            # 展平
            nn.Linear(64 * 4 * 4, 64),  # 线性层
            nn.Linear(64, 10)
        )

    def forward(self,input):
        output = self.model(input)
        return output

if __name__ == '__main__':
    # 创建网络实例
    mymodule = Module()
    print(mymodule)  # 可输出网络架构

    # 验证网络输入输出的正确性
    input = torch.ones((64,3,32,32))  # 该张量元素全部为 1
    output = mymodule(input)
    print(output.shape)

运行结果：

Module(
  (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)
  )
)
torch.Size([64, 10])