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

2022-10-08 11:38:20

小结

本节包含了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.nnas 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 collectionsimport torch.nnas 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函数指定各个层的先后顺序后才算完成了模型的定义。

如下

classmodel(nn.Module):def__init__(self,...):
    self.modulelist=......defforward(self, x):for layerin 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 三种方法的比较

SequentialModuleListModuleDict
补充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 torchimport torch.nnas nnimport torch.nn.functionalas F

2.2.1 DoubleConv

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

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

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

classDoubleConv(nn.Module):"""(convolution => [BN] => ReLU) * 2"""def__init__(self, in_channels, out_channels, mid_channels=None):super().__init__()ifnot 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),defforward(self, x):return self.double_conv(x)

2.2.2 Down

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

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

依然使用Sequential来构建。

classDown(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))defforward(self, x):return self.maxpool_conv(x)

2.2.3 Up

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

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

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

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

classUp(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 channelsif 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)defforward(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

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

classOutConv(nn.Module):def__init__(self, in_channels, out_channels):super(OutConv, self).__init__()
        self.conv= nn.Conv2d(in_channels, out_channels, kernel_size=1)defforward(self, x):return self.conv(x)

2.3 组装U-Net

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

中间的那一层down特殊些。

classUNet(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=2if bilinearelse1
        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)defforward(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 collectionsimport 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的拼接。

classModel(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)defforward(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.modelsas models
net= models.resnet50()
model= Model(net).cuda()#加上去了

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

outputs= model(inputs, add_var)

3.4 添加额外输出※

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

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

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

classModel(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)defforward(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.modelsas 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 torchvisionimport 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网络结构图及结构详解
  • 作者：SheltonXiao
  • 原文链接：https://blog.csdn.net/qq_40990057/article/details/123534527
    更新时间：2022-10-08 11:38:20