【datawhale202203】深入浅出PyTorch：PyTorch模型定义及模型搭建

小结

本节包含了PyTorch模型的定义方式，利用模型搭建复杂网络的方法（其实前两部分的模型称为模块或许更加合适），以及修改现有模型的方法，最后是关于整个模型的保存及读取。

本节内容非常具有实用价值，尤其是在修改现有模型这个部分，之后预计附加一些实际操作巩固。

1 PyTorch模型定义的方式

1.1 关于模型定义的必要知识

• Module 类是torch.nn模块里提供的一个模型构造类 (nn.Module)，是所有神经⽹网络模块的基类，我们可以继承它来定义我们想要的模型；
• PyTorch模型定义应包括两个主要部分：各个部分的初始化（__init__）；数据流向定义（forward）

我们可以基于nn.Module,通过Sequential，ModuleList和ModuleDict三种方式定义PyTorch模型

1.2 Sequential

对应模块为nn.Sequential()。

这种方式是简单串联各个层。

当模型的前向计算为简单串联各个层的计算时， Sequential 类可以通过更加简单的方式定义模型。

它可以接收一个子模块的有序字典(OrderedDict) 或者一系列子模块作为参数来逐一添加 Module 的实例，⽽模型的前向计算就是将这些实例按添加的顺序逐⼀计算。

OrderedDict
OrderedDict是dict的一个子类，实现了对字典对象中元素的排序。
可从collections中 import

使用Sequential定义模型有两种方式

• 直接排列

import torch.nn as nn
net = nn.Sequential(
        nn.Linear(784, 256),
        nn.ReLU(),
        nn.Linear(256, 10), 
        )
print(net)

输出结果如下

Sequential(
  (0): Linear(in_features=784, out_features=256, bias=True)
  (1): ReLU()
  (2): Linear(in_features=256, out_features=10, bias=True)
)

• 使用OrderedDict

import collections
import torch.nn as nn
net2 = nn.Sequential(collections.OrderedDict([
          ('fc1', nn.Linear(784, 256)),
          ('relu1', nn.ReLU()),
          ('fc2', nn.Linear(256, 10))
          ]))
print(net2)

输出结果如下

Sequential(
  (fc1): Linear(in_features=784, out_features=256, bias=True)
  (relu1): ReLU()
  (fc2): Linear(in_features=256, out_features=10, bias=True)
)

相较而言，OrderedDict可以给各个层起名字，会更好用些

使用Sequential定义模型的好处包括：

• 简单、易读
• 使用Sequential定义的模型不需要再写forward，因为顺序已经定义好了

但Sequential也不是在所有场合都可以使用

• 模型定义需要灵活性的场合
  比如需要在模型中间加入一个外部输入时就不适合用Sequential的方式实现。

使用时需根据实际需求加以选择。

1.3 ModuleList

对应模块为nn.ModuleList()

这种模式是把Module拼在一起。

ModuleList接收一个子模块（或层，需属于nn.Module类）的列表作为输入，然后也可以类似List那样进行append和extend操作。同时，子模块或层的权重也会自动添加到网络中来。

net = nn.ModuleList([nn.Linear(784, 256), nn.ReLU()])

可以像List那样增加和索引

net.append(nn.Linear(256, 10)) # # 类似List的append操作
print(net[-1])  # 类似List的索引访问
print(net)

输出如下

Linear(in_features=256, out_features=10, bias=True)
ModuleList(
  (0): Linear(in_features=784, out_features=256, bias=True)
  (1): ReLU()
  (2): Linear(in_features=256, out_features=10, bias=True)
)

需要注意的是nn.ModuleList并没有定义一个网络，它只是将不同的模块储存在一起。

ModuleList中元素的先后顺序并不代表其在网络中的真实位置顺序，需要经过forward函数指定各个层的先后顺序后才算完成了模型的定义。

如下

class model(nn.Module):
  def __init__(self, ...):
    self.modulelist = ...
    ...
    
  def forward(self, x):
    for layer in self.modulelist:
      x = layer(x)
    return x

并不如Sequential来的简洁。

1.4 ModuleDict

对应模块为nn.ModuleDict()。

ModuleDict和ModuleList的作用类似，只是ModuleDict能够更方便地为神经网络的层添加名称

net = nn.ModuleDict({
    'linear': nn.Linear(784, 256),
    'act': nn.ReLU(),
})
net['output'] = nn.Linear(256, 10) # 添加
print(net['linear']) # 访问
print(net.output)
print(net)

Linear(in_features=784, out_features=256, bias=True)
Linear(in_features=256, out_features=10, bias=True)
ModuleDict(
  (act): ReLU()
  (linear): Linear(in_features=784, out_features=256, bias=True)
  (output): Linear(in_features=256, out_features=10, bias=True)
)

1.5 三种方法的比较

	Sequential	ModuleList	ModuleDict
补充forward定义	不需要	需要	需要
重复层逐条定义	需要	不需要	不需要

所以，当我们需要之前层的信息的时候，比如 ResNets 中的残差计算，当前层的结果需要和之前层中的结果进行融合，一般使用 ModuleList,ModuleDict比较方便。

2 利用模型搭建复杂网络

仔细观察许多复杂网络可以发现，大部分模型结构（比如ResNet、DenseNet等），虽然模型有很多层，但是其中有很多重复出现的结构。

考虑到每一层有其输入和输出，若干层串联成的”模块“也有其输入和输出，如果我们能将这些重复出现的层定义为一个”模块“，每次只需要向网络中添加对应的模块来构建模型，这样将会极大便利模型构建的过程。

2.1 U-Net简介及模型块分析

在这里我们使用U-Net来了解网络的搭建过程

U-Net是分割 (Segmentation) 模型的杰作，在以医学影像为代表的诸多领域有着广泛的应用。U-Net模型结构如下图所示，通过残差连接结构解决了模型学习中的退化问题，使得神经网络的深度能够不断扩展。
模型结构如下

U-Net模型具有非常好的对称性，结构可以分析如下：

• 每层由左侧和右侧两个模型块组成
• 存在邻层连接和同层连接
  • 每侧的模型块与其上下模型块之间有连接
  • 同时位于同一层左右两侧的模型块之间也有连接，称为“Skip-connection”
• 还有输入和输出处理等其他组成部分。

由于模型的形状非常像英文字母的“U”，因此被命名为“U-Net”。

组成U-Net的模型块主要有如下几个部分：

1. 每个子块内部的两次卷积（Double Convolution）

2. 左侧模型块之间的下采样连接，即最大池化（Max pooling）

3. 右侧模型块之间的上采样连接（Up sampling）

4. 输出层的处理

除模型块外，还有模型块之间的横向连接，输入和U-Net底部的连接等计算，这些单独的操作可以通过forward函数来实现。

2.2 U-Net模块的PyTorch实现

先定义好模型块，再定义模型块之间的连接顺序和计算方式。就好比装配零件一样，我们先装配好一些基础的部件，之后再用这些可以复用的部件得到整个装配体。

对应上面分析的四个模型块，分别命名为：

1. DoubleConv
2. Down
3. Up
4. OutConv

下面在PyTorch中来尝试实现，先导入需要的模块

import torch
import torch.nn as nn
import torch.nn.functional as F

2.2.1 DoubleConv

使用Sequential来构建，设置in_channels，out_channels，mid_channels参数来通用不同的位置的DoubleConv。

每一个DoubleConv由两个卷积层以及中间的BatchNorm组合而成.

其中nn.Conv2d的卷积核大小为3×3，周围上下填充1（padding=1），不添加偏置参数（bias=False）

class DoubleConv(nn.Module):
    """(convolution => [BN] => ReLU) * 2"""

    def __init__(self, in_channels, out_channels, mid_channels=None):
        super().__init__()
        if not mid_channels:
            mid_channels = out_channels
        self.double_conv = nn.Sequential(
            nn.Conv2d(in_channels, mid_channels, kernel_size=3, padding=1, bias=False),
            nn.BatchNorm2d(mid_channels),
            nn.ReLU(inplace=True),
            nn.Conv2d(mid_channels, out_channels, kernel_size=3, padding=1, bias=False),
    def forward(self, x):
        return self.double_conv(x)

2.2.2 Down

Down描述的是上接下的过程，即包括池化，又包括下一层的搭建。

为啥这样做？
可能是封装后写起来比较简洁一些。

依然使用Sequential来构建。

class Down(nn.Module):
    """Downscaling with maxpool then double conv"""

    def __init__(self, in_channels, out_channels):
        super().__init__()
        self.maxpool_conv = nn.Sequential(
            nn.MaxPool2d(2),
            DoubleConv(in_channels, out_channels)
        )

    def forward(self, x):
        return self.maxpool_conv(x)

2.2.3 Up

Up描述的是下接上的过程，先是一个采样的过程，要稍微复杂一些，随后同样有下一层的搭建。

设置bilinear参数区分采样方式。

当bilinear=True时，使用nn.UpSample实现上采样，否则就使用nn.ConvTranspose2d转置卷积实现采样（类似于反卷积，这篇博文]nn.ConvTranspose2d详解写得蛮好的）。

？input是CHW那段属实是没看明白

class Up(nn.Module):
    """Upscaling then double conv"""

    def __init__(self, in_channels, out_channels, bilinear=True):
        super().__init__()

        # if bilinear, use the normal convolutions to reduce the number of channels
        if bilinear:
            self.up = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True)
            self.conv = DoubleConv(in_channels, out_channels, in_channels // 2)
        else:
            self.up = nn.ConvTranspose2d(in_channels, in_channels // 2, kernel_size=2, stride=2)
            self.conv = DoubleConv(in_channels, out_channels)

    def forward(self, x1, x2):
        x1 = self.up(x1)
        # input is CHW
        diffY = x2.size()[2] - x1.size()[2]
        diffX = x2.size()[3] - x1.size()[3]

        x1 = F.pad(x1, [diffX // 2, diffX - diffX // 2,
                        diffY // 2, diffY - diffY // 2])
        # if you have padding issues, see
        # https://github.com/HaiyongJiang/U-Net-Pytorch-Unstructured-Buggy/commit/0e854509c2cea854e247a9c615f175f76fbb2e3a
        # https://github.com/xiaopeng-liao/Pytorch-UNet/commit/8ebac70e633bac59fc22bb5195e513d5832fb3bd
        x = torch.cat([x2, x1], dim=1)
        return self.conv(x)

2.2.4 OutConv

输出就是一个单独的卷积层。

class OutConv(nn.Module):
    def __init__(self, in_channels, out_channels):
        super(OutConv, self).__init__()
        self.conv = nn.Conv2d(in_channels, out_channels, kernel_size=1)

    def forward(self, x):
        return self.conv(x)

2.3 组装U-Net

使用写好的模型块，可以非常方便地组装U-Net模型。

中间的那一层down特殊些。

class UNet(nn.Module):
    def __init__(self, n_channels, n_classes, bilinear=True):
        super(UNet, self).__init__()
        self.n_channels = n_channels
        self.n_classes = n_classes
        self.bilinear = bilinear

        self.inc = DoubleConv(n_channels, 64)
        self.down1 = Down(64, 128)
        self.down2 = Down(128, 256)
        self.down3 = Down(256, 512)
        factor = 2 if bilinear else 1
        self.down4 = Down(512, 1024 // factor)
        self.up1 = Up(1024, 512 // factor, bilinear)
        self.up2 = Up(512, 256 // factor, bilinear)
        self.up3 = Up(256, 128 // factor, bilinear)
        self.up4 = Up(128, 64, bilinear)
        self.outc = OutConv(64, n_classes)

    def forward(self, x):
        x1 = self.inc(x)
        x2 = self.down1(x1)
        x3 = self.down2(x2)
        x4 = self.down3(x3)
        x5 = self.down4(x4)
        x = self.up1(x5, x4)
        x = self.up2(x, x3)
        x = self.up3(x, x2)
        x = self.up4(x, x1)
        logits = self.outc(x)
        return logits

再对着图看一遍

Copy and Crop那块去哪了呢？？？

bilinear干什么使的

可能得看一下原项目了，先记录一个项目连接

3 修改现有模型

这是一个非常重要的技能！可以充分利用前人的工作。

除了自己构建PyTorch模型外，还有另一种应用场景：我们已经有一个现成的模型，但该模型中的部分结构不符合我们的要求，为了使用模型，我们需要对模型结构进行必要的修改。

包括以下三种修改：

在已有模型的基础上：

• 修改模型若干层
• 添加额外输入
• 添加额外输出

3.1 ResNet50

以pytorch官方视觉库torchvision预定义好的模型ResNet50为例

已有的模型长这样：

图片来源于ResNet50网络结构图及结构详解，感谢博主手工制作

ResNet(
  (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
  (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (relu): ReLU(inplace=True)
  (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)
  (layer1): Sequential(
    (0): Bottleneck(
      (conv1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (downsample): Sequential(
        (0): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
..............
  (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))
  (fc): Linear(in_features=2048, out_features=1000, bias=True)
)

总的来说结构还是挺复杂的，这里为了适配ImageNet预训练的权重，最后全连接层（fc）的输出节点数是1000。

3.2 修改模型层

假设我们要用ResNet50模型去做一个10分类的问题，就应该修改模型的fc层，将其输出节点数替换为10。

我们还可以再加一层全连接层。

from collections import OrderedDict
classifier = nn.Sequential(OrderedDict([('fc1', nn.Linear(2048, 128)),
                          ('relu1', nn.ReLU()), 
                          ('dropout1',nn.Dropout(0.5)),
                          ('fc2', nn.Linear(128, 10)),
                          ('output', nn.Softmax(dim=1))
                          ]))
    
net.fc = classifier

这里的操作相当于将模型（net）最后名称为“fc”的层替换成了名称为“classifier”的结构，该结构是我们自己定义的。

直接把层替掉真的太酷了~

3.3 添加外部输入※

有时候在模型训练中，除了已有模型的输入之外，还需要输入额外的信息。

比如在CNN网络中，我们除了输入图像，还需要同时输入图像对应的其他信息，这时候就需要在已有的CNN网络中添加额外的输入变量。

基本思路是：将原模型添加输入位置前的部分作为一个整体，同时在forward中定义好原模型不变的部分、添加的输入和后续层之间的连接关系，从而完成模型的修改。

同样还是ResNet50适配10分类任务，不同点在于，我们希望利用已有的模型结构，在倒数第二层增加一个额外的输入变量add_variable来辅助预测

用了一个torch.cat实现了tensor的拼接。

class Model(nn.Module):
    def __init__(self, net):
        super(Model, self).__init__()
        self.net = net
        self.relu = nn.ReLU()
        self.dropout = nn.Dropout(0.5)
        self.fc_add = nn.Linear(1001, 10, bias=True)
        self.output = nn.Softmax(dim=1)
        
    def forward(self, x, add_variable):
        x = self.net(x)
        x = torch.cat((self.dropout(self.relu(x)), add_variable.unsqueeze(1)),1)
        x = self.fc_add(x)
        x = self.output(x)
        return x

torchvision中的resnet50输出是一个1000维的tensor，我们通过修改forward函数（配套定义一些层），先将2048维的tensor通过激活函数层和dropout层（ReLU和dropout在代码里哪里调用了哇），再和外部输入变量add_variable拼接，最后通过全连接层映射到指定的输出维度10。

另外这里对外部输入变量"add_variable"进行unsqueeze操作是为了和net输出的tensor保持维度一致，常用于add_variable是单一数值 (scalar) 的情况，此时add_variable的维度是 (batch_size, )，需要在第二维补充维数1，从而可以和tensor进行torch.cat操作。

之后对我们修改好的模型结构进行实例化，就可以使用了。

import torchvision.models as models
net = models.resnet50()
model = Model(net).cuda() #加上去了

训练中在输入数据的时候要给两个inputs（调用forward）

outputs = model(inputs, add_var)

3.4 添加额外输出※

有时候在模型训练中，除了模型最后的输出外，我们需要输出模型某一中间层的结果，以施加额外的监督，获得更好的中间层结果。

基本的思路是修改模型定义中forward函数的return变量。

依然以ResNet50适配10分类任务，在已经定义好的模型结构上，同时输出1000维的倒数第二层和10维的最后一层结果。

class Model(nn.Module):
    def __init__(self, net):
        super(Model, self).__init__()
        self.net = net
        self.relu = nn.ReLU()
        self.dropout = nn.Dropout(0.5)
        self.fc1 = nn.Linear(1000, 10, bias=True)
        self.output = nn.Softmax(dim=1)
        
    def forward(self, x, add_variable):
        x1000 = self.net(x)
        x10 = self.dropout(self.relu(x1000))
        x10 = self.fc1(x10)
        x10 = self.output(x10)
        return x10, x1000

也就是x10和x100两个输出。

实例化使用

import torchvision.models as models
net = models.resnet50()
model = Model(net).cuda()

另外别忘了，训练中在输入数据后会有两个outputs：

out10, out1000 = model(inputs, add_var)

4 PyTorch模型保存与读取

4.1 模型的存储格式

PyTorch存储模型主要采用以下三种格式。就使用层面来说没有区别

• pkl
• pt
• pth

4.2 模型存储内容

一个PyTorch模型主要包含两个部分

• 模型结构
• 权重

其中模型是继承nn.Module的类，权重的数据结构是一个字典（key是层名，value是权重向量）

存储也由此分为两种形式

• 存储整个模型（包括结构和权重）
• -只存储模型权重。

对应的实现代码如下

from torchvision import models
model = models.resnet152(pretrained=True)

# 保存整个模型
torch.save(model, save_dir)
# 保存模型权重
torch.save(model.state_dict, save_dir)

对于PyTorch而言，pt, pth和pkl三种数据格式均支持模型权重和整个模型的存储，因此使用上没有差别。

4.3 单卡和多卡模型存储

单卡和多卡模型在存储内容上有区别，因此需要区分存储及加载的方法。

亦可以在存储及加载过程中进行转换。

参考阅读

1. Pytorch的nn.Conv2d（）详解
2. pytorch torch.nn 实现上采样——nn.Upsample
3. nn.ConvTranspose2d详解
4. ResNet50网络结构图及结构详解