小结
本节包含了PyTorch模型的定义方式，利用模型搭建复杂网络的方法（其实前两部分的模型称为模块或许更加合适），以及修改现有模型的方法，最后是关于整个模型的保存及读取。
本节内容非常具有实用价值，尤其是在修改现有模型这个部分，之后预计附加一些实际操作巩固。
目录
- 小结
- 1 PyTorch模型定义的方式
- 1.1 关于模型定义的必要知识
- 1.2 Sequential
- 1.3 ModuleList
- 1.4 ModuleDict
- 1.5 三种方法的比较
- 2 利用模型搭建复杂网络
- 2.1 U-Net简介及模型块分析
- 2.2 U-Net模块的PyTorch实现
- 2.2.1 DoubleConv
- 2.2.2 Down
- 2.2.3 Up
- 2.2.4 OutConv
- 2.3 组装U-Net
- 3 修改现有模型
- 3.1 ResNet50
- 3.2 修改模型层
- 3.3 添加外部输入※
- 3.4 添加额外输出※
- 4 PyTorch模型保存与读取
- 4.1 模型的存储格式
- 4.2 模型存储内容
- 4.3 单卡和多卡模型存储
- 参考阅读
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的模型块主要有如下几个部分：
- 每个子块内部的两次卷积（Double Convolution）
- 左侧模型块之间的下采样连接，即最大池化（Max pooling）
- 右侧模型块之间的上采样连接（Up sampling）
- 输出层的处理
除模型块外，还有模型块之间的横向连接，输入和U-Net底部的连接等计算，这些单独的操作可以通过forward函数来实现。
2.2 U-Net模块的PyTorch实现
先定义好模型块，再定义模型块之间的连接顺序和计算方式。就好比装配零件一样，我们先装配好一些基础的部件，之后再用这些可以复用的部件得到整个装配体。
对应上面分析的四个模型块，分别命名为：
- DoubleConv
- Down
- Up
- OutConv
下面在PyTorch中来尝试实现，先导入需要的模块
import torch
import torch.nn as nn
import torch.nn.functional as F2.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 xtorchvision中的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 单卡和多卡模型存储
单卡和多卡模型在存储内容上有区别，因此需要区分存储及加载的方法。
亦可以在存储及加载过程中进行转换。
参考阅读
- Pytorch的nn.Conv2d（）详解
- pytorch torch.nn 实现上采样——nn.Upsample
- nn.ConvTranspose2d详解
- ResNet50网络结构图及结构详解
