Pytorch深度学习-----神经网络之Sequential的详细使用及实战详解

系列文章目录

PyTorch深度学习——Anaconda和PyTorch安装
Pytorch深度学习-----数据模块Dataset类
Pytorch深度学习------TensorBoard的使用
Pytorch深度学习------Torchvision中Transforms的使用（ToTensor，Normalize，Resize ，Compose，RandomCrop）
Pytorch深度学习------torchvision中dataset数据集的使用（CIFAR10）
Pytorch深度学习-----DataLoader的用法
Pytorch深度学习-----神经网络的基本骨架-nn.Module的使用
Pytorch深度学习-----神经网络的卷积操作
Pytorch深度学习-----神经网络之卷积层用法详解
Pytorch深度学习-----神经网络之池化层用法详解及其最大池化的使用
Pytorch深度学习-----神经网络之非线性激活的使用(ReLu、Sigmoid)
Pytorch深度学习-----神经网络之线性层用法

---

一、什么是Sequential？

"Sequential"是一个时序容器，可以将各种层按顺序添加到容器中，从而简化神经网络模型的搭建。它可以从头开始构建模型，也可以在其他容器（如Sequential、Functional、Subclass）中构建模型，还可以与其他容器组合使用。

官网解释：

官网的举例应用

# 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()
        )

# Using Sequential with OrderedDict. This is functionally the
# same as the above code
model = nn.Sequential(OrderedDict([
          ('conv1', nn.Conv2d(1,20,5)),
          ('relu1', nn.ReLU()),
          ('conv2', nn.Conv2d(20,64,5)),
          ('relu2', nn.ReLU())
        ]))

二、实战

构建如下图所示的神经网络模型

由上述可以观察到输入图像是3通道的32×32的，先后经过卷积层(5×5的卷积核)、最大池化层(2×2的池化核)、卷积层(5×5的卷积核)、最大池化层(2×2的池化核)、卷积层(5×5的卷积核)、最大池化层(2×2的池化核)、拉直、全连接层的处理，最后输出的大小为10。

1.不使用Sequential实现上述项目

在实战前先认识torch.ones()：
torch.ones((64, 3, 32, 32)) 表示创建一个形状为 (64, 3, 32, 32) 的张量，其中张量的第一个维度表示批量大小，第二个维度表示通道数，第三和第四个维度表示图像的高度和宽度。在这个例子中，张量有 64 个样本，每个样本是一个 3通道、32x32 大小的图像。

这个张量的每个元素都被初始化为1，也就是说，张量的每个元素的值都是1。这个张量可以用于深度学习中的一些操作，例如卷积、池化等。

注意，这个张量的数据类型默认为 float。如果你需要使用其他数据类型，可以通过 dtype 参数进行指定。例如，要创建一个数据类型为 torch.int 的张量，可以这样做：
代码如下：

import torch  
  
t = torch.ones((64, 3, 32, 32), dtype=torch.int)

进入实战代码：

import torch

# 准备数据集
input = torch.ones((64, 3, 32, 32))
# 根据图片描述搭建神经网络
"""
输入图像是3通道的32×32的，
先后经过卷积层(5×5的卷积核)、
最大池化层(2×2的池化核)、
卷积层(5×5的卷积核)、
最大池化层(2×2的池化核)、
卷积层(5×5的卷积核)、
最大池化层(2×2的池化核)、
拉直、
全连接层的处理，
最后输出的大小为10
"""

class Lgl(torch.nn.Module):
    def __init__(self):
        super(Lgl, self).__init__()
        self.conv1 = torch.nn.Conv2d(in_channels=3,out_channels=32,kernel_size=5,padding=2)
        self.maxpool1 = torch.nn.MaxPool2d(kernel_size=2)
        self.conv2 = torch.nn.Conv2d(in_channels=32,out_channels=32,kernel_size=5,padding=2)
        self.maxpool2 = torch.nn.MaxPool2d(kernel_size=2)
        self.conv3 = torch.nn.Conv2d(in_channels=32,out_channels=64,kernel_size=5,padding=2)
        self.maxpool3 = torch.nn.MaxPool2d(kernel_size=2)
        self.flatten = torch.nn.Flatten()
        self.linear1 = torch.nn.Linear(1024,64)
        self.linear2 = torch.nn.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)
         x = self.linear2(x)
         return x
# 实例化
l = Lgl()
print(l)
# 进行上面的神经网络模型后
output = l(input)
print(output.shape)

结果：

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

对其中padding=2参数设置的解释与计算：
由官网中给出的shape相关的计算可以得到padding

以上述为例
 其中输出的高为Hout=32，输入的高为Hin=32，采样的步长dilation[0]=1，卷积核大小kernel_size[0]=5，移动的步长stride为1，将其带入到Hout的公式，计算过程如下：
32 =((32+2×padding[0]-1×(5-1)-1))+1，简化之后的式子为：
27+2×padding[0]=31，所以padding[0]=2。

2.采用Sequential对上述实战优化并在tensorboard中显示

在实战前先认识tensorboard中的add_graph()函数

在TensorBoard中，add_graph函数用于将PyTorch模型图添加到TensorBoard中。通过这个函数，您可以以可视化的方式展示模型的计算图，使其他人更容易理解您的模型结构和工作流程。

add_graph(model, input_to_model, strip_default_attributes=True)

参数说明：

model：要添加的PyTorch模型。
input_to_model：用于生成模型图的输入数据。
strip_default_attributes：是否删除模型中的默认属性，默认为True。

代码如下

import torch
from torch.utils.tensorboard import SummaryWriter

# 准备数据集
input = torch.ones((64, 3, 32, 32))

# 搭建一个自己的神经网络
class Lgl(torch.nn.Module):
    def __init__(self):
        super(Lgl, self).__init__()
        self.seq = torch.nn.Sequential(
            torch.nn.Conv2d(in_channels=3, out_channels=32, kernel_size=5, padding=2),
            torch.nn.MaxPool2d(kernel_size=2),
            torch.nn.Conv2d(in_channels=32, out_channels=32, kernel_size=5, padding=2),
            torch.nn.MaxPool2d(kernel_size=2),
            torch.nn.Conv2d(in_channels=32, out_channels=64, kernel_size=5, padding=2),
            torch.nn.MaxPool2d(kernel_size=2),
            torch.nn.Flatten(),
            torch.nn.Linear(1024, 64),
            torch.nn.Linear(64, 10)
        )
    def forward(self, x):
        x = self.seq(x)
        return x
# 实例化
l = Lgl()
print(l)
# 进行上面的神经网络模型后
output = l(input)
print(output.shape)
# 在tensorboard中显示
writer = SummaryWriter("logs")
writer.add_graph(l, input)  # 定义的模型，数据
writer.close()

控制台结果：

Lgl(
  (seq): 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])

tensorboard中显示