pytorch深度学习基础（十一）——常用结构化CNN模型构建

在本专栏的上一篇博客中我们介绍了常用的线性模型&＃xff0c;在本文中我们将介绍GoogleNet、resNet、denseNet这类结构化的模型的构建方式。

结构

整体的结构似乎有些吓人&＃xff0c;但其实他也是用了块的思维&＃xff0c;仔细观察可以发现&＃xff0c;他中间一段很多层的结构都是相似的

Inception块

这个块就是其中重复的块&＃xff0c;这个块分成了四个分支&＃xff1a;1x1卷积、1x1卷积&＃43;3x3卷积、1x1卷积&＃43;5x5卷积、3x3卷积&＃43;1x1卷积&＃xff0c;最后将这四个分支通道合并

class Inception(nn.Module):
def __init__(self, in_channels, c1, c2, c3, c4, **kwargs):
super(Inception, self).__init__(**kwargs)
self.p1_1 &＃61; nn.Conv2d(in_channels, c1, kernel_size&＃61;1)

self.p2_1 &＃61; nn.Conv2d(in_channels, c2[0], kernel_size&＃61;1)
self.p2_2 &＃61; nn.Conv2d(c2[0], c2[1], kernel_size&＃61;3, padding&＃61;1)

self.p3_1 &＃61; nn.Conv2d(in_channels, c3[0], kernel_size&＃61;1)
self.p3_2 &＃61; nn.Conv2d(c3[0], c3[1], kernel_size&＃61;5, padding&＃61;2)

self.p4_1 &＃61; nn.MaxPool2d(kernel_size&＃61;3, stride&＃61;1, padding&＃61;1)
self.p4_2 &＃61; nn.Conv2d(in_channels, c4, kernel_size&＃61;1)

def forward(self, x):
p1 &＃61; F.relu(self.p1_1(x))
p2 &＃61; F.relu(self.p2_2(F.relu(self.p2_1(x))))
p3 &＃61; F.relu(self.p3_2(F.relu(self.p3_1(x))))
p4 &＃61; F.relu(self.p4_2(self.p4_1(x)))

return torch.cat((p1, p2, p3, p4), dim&＃61;1)


模型构建

b1 &＃61; nn.Sequential(nn.Conv2d(1, 64, kernel_size&＃61;7, stride&＃61;2, padding&＃61;3),
nn.ReLU(),
nn.MaxPool2d(kernel_size&＃61;3, stride&＃61;2, padding&＃61;1)
)
b2 &＃61; nn.Sequential(nn.Conv2d(64, 64, kernel_size&＃61;1),
nn.ReLU(),
nn.Conv2d(64, 192, kernel_size&＃61;3, padding&＃61;1),
nn.ReLU(),
nn.MaxPool2d(kernel_size&＃61;3, stride&＃61;2, padding&＃61;1)
)
b3 &＃61; nn.Sequential(Inception(192, 64, (96, 128), (16, 32), 32),
Inception(256, 128, (128, 192), (32, 96), 64),
nn.MaxPool2d(kernel_size&＃61;3, stride&＃61;2, padding&＃61;1)
)
b4 &＃61; nn.Sequential(Inception(480, 192, (96, 208), (16, 48), 64),
Inception(512, 160, (112, 224), (24, 64), 64),
Inception(512, 128, (128, 256), (24, 64), 64),
Inception(512, 112, (144, 288), (32, 64), 64),
Inception(528, 256, (160, 320), (32, 128), 128),
nn.MaxPool2d(kernel_size&＃61;3, stride&＃61;2, padding&＃61;1)
)
b5 &＃61; nn.Sequential(Inception(832, 256, (160, 320), (32, 128), 128),
Inception(832, 384, (192, 384), (48, 128), 128),
nn.AdaptiveAvgPool2d((1, 1)),
nn.Flatten()
)
net &＃61; nn.Sequential(b1, b2, b3, b4, b5, nn.Linear(1024, 10))

resNet18

模型结构

这个模型似乎要更加简洁一些&＃xff0c;因为这里只有两个分支&＃xff0c;但是他有两种分支方式&＃xff0c;一种是卷积&＃43;残差&＃xff0c;另外一种是卷积&＃43;经过1x1卷积处理过的残差

残差块

class Residual(nn.Module):
def __init__(self, input_channels, num_channels, use_1x1conv&＃61;False, strides&＃61;1):
super().__init__()
self.conv1 &＃61; nn.Conv2d(input_channels, num_channels, kernel_size&＃61;3, padding&＃61;1, stride&＃61;strides)
self.conv2 &＃61; nn.Conv2d(num_channels, num_channels, kernel_size&＃61;3, padding&＃61;1)
if use_1x1conv:
self.conv3 &＃61; nn.Conv2d(input_channels, num_channels, kernel_size&＃61;1, stride&＃61;strides)

else:
self.conv3 &＃61; None

self.bn1 &＃61; nn.BatchNorm2d(num_channels)
self.bn2 &＃61; nn.BatchNorm2d(num_channels)

def forward(self, X):
Y &＃61; F.relu(self.bn1(self.conv1(X)))
Y &＃61; self.bn2(self.conv2(Y))
if self.conv3:
X &＃61; self.conv3(X)

Y &＃43;&＃61; X
return F.relu(Y)


构建时依次使用两种分支方式

def resnet_block(input_channels, num_channels, num_residuals, first_block&＃61;False):
blk &＃61; []
for i in range(num_residuals):
if i &＃61;&＃61; 0 and not first_block:
blk.append(Residual(input_channels, num_channels, use_1x1conv&＃61;True, strides&＃61;2))
else:
blk.append(Residual(num_channels, num_channels))

return blk


模型构建

b1 &＃61; nn.Sequential(nn.Conv2d(1, 64, kernel_size&＃61;7, stride&＃61;2, padding&＃61;3),
nn.BatchNorm2d(64), nn.ReLU(),
nn.MaxPool2d(kernel_size&＃61;3, stride&＃61;2, padding&＃61;1)
)
b2 &＃61; nn.Sequential(*resnet_block(64, 64, 2, first_block&＃61;True))
b3 &＃61; nn.Sequential(*resnet_block(64, 128, 2))
b4 &＃61; nn.Sequential(*resnet_block(128, 256, 2))
b5 &＃61; nn.Sequential(*resnet_block(256, 512, 2))
net &＃61; nn.Sequential(b1, b2, b3, b4, b5,
nn.AdaptiveAvgPool2d((1, 1)),
nn.Flatten(),
nn.Linear(512, 10)
)

denseNet

模型结构

这个模型的主要思路就是把每一次的输出和输入合并起来&＃xff0c;同时作为下一层的输入&＃xff0c;具体的细节还要结合代码解释

DenseBlock

我们看下面的代码&＃xff0c;注意init中的循环以及forward时对于X的处理。我们可以发现&＃xff0c;每经过一个conv_block都会将conv_block的输出并入到输入&＃xff0c;以此作为下一层的输入

def conv_block(input_channels, num_channels):
return nn.Sequential(nn.BatchNorm2d(input_channels), nn.ReLU(),
nn.Conv2d(input_channels, num_channels, kernel_size&＃61;3, padding&＃61;1)
)

class DenseBlock(nn.Module):
def __init__(self, num_convs, input_channels, num_channels):
super(DenseBlock, self).__init__()
layer &＃61; []
for i in range(num_convs):
layer.append(conv_block(
num_channels * i &＃43; input_channels, num_channels
))
self.net &＃61; nn.Sequential(*layer)

def forward(self, X):
for blk in self.net:
Y &＃61; blk(X)
X &＃61; torch.cat((X, Y), dim&＃61;1)

return X


transition_block

这个块的主要作用是减少通道&＃xff0c;因为在前面的块中&＃xff0c;通道数会持续的增长&＃xff0c;考虑到计算量&＃xff0c;需要在中间加入减少通道的块

def transition_block(input_channels, num_channels):
return nn.Sequential(nn.BatchNorm2d(input_channels), nn.ReLU(),
nn.Conv2d(input_channels, num_channels, kernel_size&＃61;1),
nn.AvgPool2d(kernel_size&＃61;2, stride&＃61;2)
)


模型构建

b1 &＃61; nn.Sequential(nn.Conv2d(1, 64, kernel_size&＃61;7, stride&＃61;2, padding&＃61;3),
nn.BatchNorm2d(64), nn.ReLU(),
nn.MaxPool2d(kernel_size&＃61;3, stride&＃61;2, padding&＃61;1)
)

num_channels, growth_rate &＃61; 64, 32
num_convs_in_dense_blocks &＃61; [4, 4, 4, 4]
blks &＃61; []
for i, num_convs in enumerate(num_convs_in_dense_blocks):
blks.append(DenseBlock(num_convs, num_channels, growth_rate))
num_channels &＃43;&＃61; num_convs * growth_rate
if i !&＃61; len(num_convs_in_dense_blocks) - 1:
blks.append(transition_block(num_channels, num_channels // 2))
num_channels &＃61; num_channels // 2
net &＃61; nn.Sequential(b1, *blks,
nn.BatchNorm2d(num_channels), nn.ReLU(),
nn.AdaptiveAvgPool2d((1, 1)),
nn.Flatten(),
nn.Linear(num_channels, 10)
)

结尾

我们到现在模型就已经构建好了&＃xff0c;测试的过程可以参照本专栏的上一篇博客
pytorch深度学习基础&＃xff08;十&＃xff09;——常用线性CNN模型的结构与训练