【图像分类】用最简单的代码复现SENet，初学者一定不要错过（pytorch）

怼烎@ 2022-10-17 05:27 369阅读 0赞

**目录**

摘要

一、SENet概述

二、SENet 结构组成详解

三、详细的计算过程

SENet 在具体网络中应用（代码实现SE\_ResNet）

SE模块

第一个残差模块

第二个残差模块

SEResNet18、SEResNet34模型的完整代码

SEResNet50、SEResNet101、SEResNet152完整

--------------------

# 摘要 #

## 一、SENet概述 ##

Squeeze-and-Excitation Networks（简称 SENet）是 Momenta 胡杰团队（WMW）提出的新的网络结构，利用SENet，一举取得最后一届 ImageNet 2017 竞赛 Image Classification 任务的冠军，在ImageNet数据集上将top-5 error降低到2.251%，原先的最好成绩是2.991%。

作者在文中将SENet block插入到现有的多种分类网络中，都取得了不错的效果。作者的动机是希望显式地建模特征通道之间的相互依赖关系。另外，作者并未引入新的空间维度来进行特征通道间的融合，而是采用了一种全新的「特征重标定」策略。具体来说，就是通过学习的方式来自动获取到每个特征通道的重要程度，然后依照这个重要程度去提升有用的特征并抑制对当前任务用处不大的特征。

通俗的来说SENet的核心思想在于通过网络根据loss去学习特征权重，使得有效的feature map权重大，无效或效果小的feature map权重小的方式训练模型达到更好的结果。SE block嵌在原有的一些分类网络中不可避免地增加了一些参数和计算量，但是在效果面前还是可以接受的 。Sequeeze-and-Excitation(SE) block并不是一个完整的网络结构，而是一个子结构，可以嵌到其他分类或检测模型中。

## 二、SENet 结构组成详解 ##

上述结构中，Squeeze 和 Excitation 是两个非常关键的操作，下面进行详细说明。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hoaGhoaGhoaGh3d3d3d3d3d3d3_size_16_color_FFFFFF_t_70][]

上图是SE 模块的示意图。给定一个输入 x，其特征通道数为 ![\{C\}'][C]，通过一系列卷积等一般变换后得到一个特征通道数为C 的特征。通过下面的三个操作还重标前面得到的特征：

1、Squeeze 操作，顺着空间维度来进行特征压缩，将每个二维的特征通道变成一个实数，这个实数某种程度上具有全局的感受野，并且输出的维度和输入的特征通道数相匹配。它表征着在特征通道上响应的全局分布，而且使得靠近输入的层也可以获得全局的感受野，这一点在很多任务中都是非常有用的。

2、 Excitation 操作，它是一个类似于循环神经网络中门的机制。通过参数 w 来为每个特征通道生成权重，其中参数 w 被学习用来显式地建模特征通道间的相关性。

3、 Reweight 操作，将 Excitation 的输出的权重看做是进过特征选择后的每个特征通道的重要性，然后通过乘法逐通道加权到先前的特征上，完成在通道维度上的对原始特征的重标定。

## 三、详细的计算过程 ##

首先![F\_\{tr\}][F_tr]这一步是转换操作（严格讲并不属于SENet，而是属于原网络，可以看后面SENet和Inception及ResNet网络的结合），在文中就是一个标准的卷积操作而已，输入输出的定义如下表示：

![20210601093418748.png][]

那么这个![F\_\{tr\}][F_tr]的公式就是下面的公式1（卷积操作，![V\_\{c\}][V_c]表示第c个卷积核，![X^\{s\}][X_s]表示第s个输入）。

![20210601093521324.png][]  
    ![F\_\{tr\}][F_tr]得到的U就是Figure1中的左边第二个三维矩阵，也叫tensor，或者叫C个大小为H\*W的feature map。而uc表示U中第c个二维矩阵，下标c表示channel。  
    接下来就是Squeeze操作，公式非常简单，就是一个global average pooling:  
                              ![20210601093756551.png][]  
    因此公式2就将H\*W\*C的输入转换成1\*1\*C的输出，对应Figure1中的Fsq操作。为什么会有这一步呢？这一步的结果相当于表明该层C个feature map的数值分布情况，或者叫全局信息。  
    再接下来就是Excitation操作，如公式3。直接看最后一个等号，前面squeeze得到的结果是z，这里先用W1乘以z，就是一个全连接层操作，W1的维度是C/r \* C，这个r是一个缩放参数，在文中取的是16，这个参数的目的是为了减少channel个数从而降低计算量。又因为z的维度是1\*1\*C，所以W1z的结果就是1\*1\*C/r；然后再经过一个ReLU层，输出的维度不变；然后再和W2相乘，和W2相乘也是一个全连接层的过程，W2的维度是C\*C/r，因此输出的维度就是1\*1\*C；最后再经过sigmoid函数，得到s：  
                                    ![2021060109384533.png][]  
    也就是说最后得到的这个s的维度是1\*1\*C，C表示channel数目。这个s其实是本文的核心，它是用来刻画tensor U中C个feature map的权重。而且这个权重是通过前面这些全连接层和非线性层学习得到的，因此可以end-to-end训练。这两个全连接层的作用就是融合各通道的feature map信息，因为前面的squeeze都是在某个channel的feature map里面操作。  
    在得到s之后，就可以对原来的tensor U操作了，就是下面的公式4。也很简单，就是channel-wise multiplication，什么意思呢？![u\_\{c\}][u_c]是一个二维矩阵，![s\_\{c\}][s_c]是一个数，也就是权重，因此相当于把![u\_\{c\}][u_c]矩阵中的每个值都乘以![s\_\{c\}][s_c]。对应Figure1中的Fscale。

#                                                   ![20210601093928973.png][] #

# SENet 在具体网络中应用（代码实现SE\_ResNet） #

介绍完具体的公式实现，下面介绍下SE block怎么运用到具体的网络之中。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hoaGhoaGhoaGh3d3d3d3d3d3d3_size_16_color_FFFFFF_t_70 1][]![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hoaGhoaGhoaGh3d3d3d3d3d3d3_size_16_color_FFFFFF_t_70 2][]  
    上图是将 SE 模块嵌入到 Inception 结构的一个示例。方框旁边的维度信息代表该层的输出。

这里我们使用 global average pooling 作为 Squeeze 操作。紧接着两个 Fully Connected 层组成一个 Bottleneck 结构去建模通道间的相关性，并输出和输入特征同样数目的权重。我们首先将特征维度降低到输入的 1/16，然后经过 ReLu 激活后再通过一个 Fully Connected 层升回到原来的维度。这样做比直接用一个 Fully Connected 层的好处在于：

1）具有更多的非线性，可以更好地拟合通道间复杂的相关性；

2）极大地减少了参数量和计算量。然后通过一个 Sigmoid 的门获得 0~1 之间归一化的权重，最后通过一个 Scale 的操作来将归一化后的权重加权到每个通道的特征上。

除此之外，SE 模块还可以嵌入到含有 skip-connections 的模块中。上右图是将 SE 嵌入到 ResNet 模块中的一个例子，操作过程基本和 SE-Inception 一样，只不过是在 Addition 前对分支上 Residual 的特征进行了特征重标定。如果对 Addition 后主支上的特征进行重标定，由于在主干上存在 0~1 的 scale 操作，在网络较深 BP 优化时就会在靠近输入层容易出现梯度消散的情况，导致模型难以优化。

目前大多数的主流网络都是基于这两种类似的单元通过 repeat 方式叠加来构造的。由此可见，SE 模块可以嵌入到现在几乎所有的网络结构中。通过在原始网络结构的 building block 单元中嵌入 SE 模块，我们可以获得不同种类的 SENet。如 SE-BN-Inception、SE-ResNet、SE-ReNeXt、SE-Inception-ResNet-v2 等等。

本例通过实现SE-ResNet,来显示如何将SE模块嵌入到ResNet网络中。SE-ResNet模型如下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hoaGhoaGhoaGh3d3d3d3d3d3d3_size_16_color_FFFFFF_t_70 3][]

## SE模块 ##

class SELayer(nn.Module):
        def __init__(self, channel, reduction=16):
            super(SELayer, self).__init__()
            self.avg_pool = nn.AdaptiveAvgPool2d(1)
            self.fc = nn.Sequential(
                nn.Linear(channel, channel // reduction, bias=False),
                nn.ReLU(inplace=True),
                nn.Linear(channel // reduction, channel, bias=False),
                nn.Sigmoid()
            )
    
        def forward(self, x):
            b, c, _, _ = x.size()
            y = self.avg_pool(x).view(b, c)
            y = self.fc(y).view(b, c, 1, 1)
            return x * y.expand_as(x)

## 第一个残差模块 ##

第一个残差模块用于实现ResNet18、ResNet34模型，SENet嵌入到第二个卷积的后面。

class ResidualBlock(nn.Module):
        """
        实现子module: Residual Block
        """
    
        def __init__(self, inchannel, outchannel, stride=1, shortcut=None):
            super(ResidualBlock, self).__init__()
            self.left = nn.Sequential(
                nn.Conv2d(inchannel, outchannel, 3, stride, 1, bias=False),
                nn.BatchNorm2d(outchannel),
                nn.ReLU(inplace=True),
                nn.Conv2d(outchannel, outchannel, 3, 1, 1, bias=False),
                nn.BatchNorm2d(outchannel)
            )
            self.se = SELayer(outchannel, 16)
            self.right = shortcut
    
        def forward(self, x):
            out = self.left(x)
            out= self.se(out)
            residual = x if self.right is None else self.right(x)
            out += residual
            return F.relu(out)

## 第二个残差模块 ##

第二个残差模块用于实现ResNet50、ResNet101、ResNet152模型，SENet模块嵌入到第三个卷积后面。``

class Bottleneck(nn.Module):
        def __init__(self, in_places, places, stride=1, downsampling=False, expansion=4):
            super(Bottleneck, self).__init__()
            self.expansion = expansion
            self.downsampling = downsampling
    
            self.bottleneck = nn.Sequential(
                nn.Conv2d(in_channels=in_places, out_channels=places, kernel_size=1, stride=1, bias=False),
                nn.BatchNorm2d(places),
                nn.ReLU(inplace=True),
                nn.Conv2d(in_channels=places, out_channels=places, kernel_size=3, stride=stride, padding=1, bias=False),
                nn.BatchNorm2d(places),
                nn.ReLU(inplace=True),
                nn.Conv2d(in_channels=places, out_channels=places * self.expansion, kernel_size=1, stride=1, bias=False),
                nn.BatchNorm2d(places * self.expansion),
            )
            self.se = SELayer(places * self.expansion, 16)
            if self.downsampling:
                self.downsample = nn.Sequential(
                    nn.Conv2d(in_channels=in_places, out_channels=places * self.expansion, kernel_size=1, stride=stride,
                              bias=False),
                    nn.BatchNorm2d(places * self.expansion)
                )
            self.relu = nn.ReLU(inplace=True)
    
        def forward(self, x):
            residual = x
            out = self.bottleneck(x)
            out = self.se(out)
            if self.downsampling:
                residual = self.downsample(x)
    
            out += residual
            out = self.relu(out)
            return out

## SEResNet18、SEResNet34模型的完整代码`` ##

import torch
    import torchvision
    from torch import nn
    from torch.nn import functional as F
    from torchsummary import summary
    
    class SELayer(nn.Module):
        def __init__(self, channel, reduction=16):
            super(SELayer, self).__init__()
            self.avg_pool = nn.AdaptiveAvgPool2d(1)
            self.fc = nn.Sequential(
                nn.Linear(channel, channel // reduction, bias=False),
                nn.ReLU(inplace=True),
                nn.Linear(channel // reduction, channel, bias=False),
                nn.Sigmoid()
            )
    
        def forward(self, x):
            b, c, _, _ = x.size()
            y = self.avg_pool(x).view(b, c)
            y = self.fc(y).view(b, c, 1, 1)
            return x * y.expand_as(x)
    
    class ResidualBlock(nn.Module):
        """
        实现子module: Residual Block
        """
    
        def __init__(self, inchannel, outchannel, stride=1, shortcut=None):
            super(ResidualBlock, self).__init__()
            self.left = nn.Sequential(
                nn.Conv2d(inchannel, outchannel, 3, stride, 1, bias=False),
                nn.BatchNorm2d(outchannel),
                nn.ReLU(inplace=True),
                nn.Conv2d(outchannel, outchannel, 3, 1, 1, bias=False),
                nn.BatchNorm2d(outchannel)
            )
            self.se = SELayer(outchannel, 16)
            self.right = shortcut
    
        def forward(self, x):
            out = self.left(x)
            out= self.se(out)
            residual = x if self.right is None else self.right(x)
            out += residual
            return F.relu(out)
    
    
    class ResNet(nn.Module):
        """
        实现主module：ResNet34
        ResNet34包含多个layer，每个layer又包含多个Residual block
        用子module来实现Residual block，用_make_layer函数来实现layer
        """
    
        def __init__(self, blocks, num_classes=1000):
            super(ResNet, self).__init__()
            self.model_name = 'resnet34'
    
            # 前几层: 图像转换
            self.pre = nn.Sequential(
                nn.Conv2d(3, 64, 7, 2, 3, bias=False),
                nn.BatchNorm2d(64),
                nn.ReLU(inplace=True),
                nn.MaxPool2d(3, 2, 1))
    
            # 重复的layer，分别有3，4，6，3个residual block
            self.layer1 = self._make_layer(64, 64, blocks[0])
            self.layer2 = self._make_layer(64, 128, blocks[1], stride=2)
            self.layer3 = self._make_layer(128, 256, blocks[2], stride=2)
            self.layer4 = self._make_layer(256, 512, blocks[3], stride=2)
    
            # 分类用的全连接
            self.fc = nn.Linear(512, num_classes)
    
        def _make_layer(self, inchannel, outchannel, block_num, stride=1):
            """
            构建layer,包含多个residual block
            """
            shortcut = nn.Sequential(
                nn.Conv2d(inchannel, outchannel, 1, stride, bias=False),
                nn.BatchNorm2d(outchannel),
                nn.ReLU()
            )
    
            layers = []
            layers.append(ResidualBlock(inchannel, outchannel, stride, shortcut))
    
            for i in range(1, block_num):
                layers.append(ResidualBlock(outchannel, outchannel))
            return nn.Sequential(*layers)
    
        def forward(self, x):
            x = self.pre(x)
    
            x = self.layer1(x)
            x = self.layer2(x)
            x = self.layer3(x)
            x = self.layer4(x)
    
            x = F.avg_pool2d(x, 7)
            x = x.view(x.size(0), -1)
            return self.fc(x)
    
    
    def Se_ResNet18():
        return ResNet([2, 2, 2, 2])
    
    
    def Se_ResNet34():
        return ResNet([3, 4, 6, 3])
    
    
    if __name__ == '__main__':
        device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
        model = Se_ResNet34()
        model.to(device)
        summary(model, (3, 224, 224))

## SEResNet50、SEResNet101、SEResNet152完整 ##

import torch
    import torch.nn as nn
    import torchvision
    import numpy as np
    from torchsummary import summary
    
    print("PyTorch Version: ", torch.__version__)
    print("Torchvision Version: ", torchvision.__version__)
    
    __all__ = ['SEResNet50', 'SEResNet101', 'SEResNet152']
    
    class SELayer(nn.Module):
        def __init__(self, channel, reduction=16):
            super(SELayer, self).__init__()
            self.avg_pool = nn.AdaptiveAvgPool2d(1)
            self.fc = nn.Sequential(
                nn.Linear(channel, channel // reduction, bias=False),
                nn.ReLU(inplace=True),
                nn.Linear(channel // reduction, channel, bias=False),
                nn.Sigmoid()
            )
    
        def forward(self, x):
            b, c, _, _ = x.size()
            y = self.avg_pool(x).view(b, c)
            y = self.fc(y).view(b, c, 1, 1)
            return x * y.expand_as(x)
    
    def Conv1(in_planes, places, stride=2):
        return nn.Sequential(
            nn.Conv2d(in_channels=in_planes, out_channels=places, kernel_size=7, stride=stride, padding=3, bias=False),
            nn.BatchNorm2d(places),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
        )
    
    
    class Bottleneck(nn.Module):
        def __init__(self, in_places, places, stride=1, downsampling=False, expansion=4):
            super(Bottleneck, self).__init__()
            self.expansion = expansion
            self.downsampling = downsampling
    
            self.bottleneck = nn.Sequential(
                nn.Conv2d(in_channels=in_places, out_channels=places, kernel_size=1, stride=1, bias=False),
                nn.BatchNorm2d(places),
                nn.ReLU(inplace=True),
                nn.Conv2d(in_channels=places, out_channels=places, kernel_size=3, stride=stride, padding=1, bias=False),
                nn.BatchNorm2d(places),
                nn.ReLU(inplace=True),
                nn.Conv2d(in_channels=places, out_channels=places * self.expansion, kernel_size=1, stride=1, bias=False),
                nn.BatchNorm2d(places * self.expansion),
            )
            self.se = SELayer(places * self.expansion, 16)
            if self.downsampling:
                self.downsample = nn.Sequential(
                    nn.Conv2d(in_channels=in_places, out_channels=places * self.expansion, kernel_size=1, stride=stride,
                              bias=False),
                    nn.BatchNorm2d(places * self.expansion)
                )
            self.relu = nn.ReLU(inplace=True)
    
        def forward(self, x):
            residual = x
            out = self.bottleneck(x)
            out = self.se(out)
            if self.downsampling:
                residual = self.downsample(x)
    
            out += residual
            out = self.relu(out)
            return out
    
    
    class ResNet(nn.Module):
        def __init__(self, blocks, num_classes=1000, expansion=4):
            super(ResNet, self).__init__()
            self.expansion = expansion
    
            self.conv1 = Conv1(in_planes=3, places=64)
    
            self.layer1 = self.make_layer(in_places=64, places=64, block=blocks[0], stride=1)
            self.layer2 = self.make_layer(in_places=256, places=128, block=blocks[1], stride=2)
            self.layer3 = self.make_layer(in_places=512, places=256, block=blocks[2], stride=2)
            self.layer4 = self.make_layer(in_places=1024, places=512, block=blocks[3], stride=2)
    
            self.avgpool = nn.AvgPool2d(7, stride=1)
            self.fc = nn.Linear(2048, num_classes)
    
            for m in self.modules():
                if isinstance(m, nn.Conv2d):
                    nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
                elif isinstance(m, nn.BatchNorm2d):
                    nn.init.constant_(m.weight, 1)
                    nn.init.constant_(m.bias, 0)
    
        def make_layer(self, in_places, places, block, stride):
            layers = []
            layers.append(Bottleneck(in_places, places, stride, downsampling=True))
            for i in range(1, block):
                layers.append(Bottleneck(places * self.expansion, places))
    
            return nn.Sequential(*layers)
    
        def forward(self, x):
            x = self.conv1(x)
    
            x = self.layer1(x)
            x = self.layer2(x)
            x = self.layer3(x)
            x = self.layer4(x)
    
            x = self.avgpool(x)
            x = x.view(x.size(0), -1)
            x = self.fc(x)
            return x
    
    
    def SEResNet50():
        return ResNet([3, 4, 6, 3])
    
    
    def SEResNet101():
        return ResNet([3, 4, 23, 3])
    
    
    def SEResNet152():
        return ResNet([3, 8, 36, 3])
    
    
    if __name__ == '__main__':
        device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
        model = SEResNet50()
        model.to(device)
        summary(model, (3, 224, 224))

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hoaGhoaGhoaGh3d3d3d3d3d3d3_size_16_color_FFFFFF_t_70]: /images/20221014/032f57a21a2746d389d161b8ee2c8844.png
[C]: https://latex.codecogs.com/gif.latex?%7BC%7D%27
[F_tr]: https://latex.codecogs.com/gif.latex?F_%7Btr%7D
[20210601093418748.png]: /images/20221014/24db10a534a742649598e90c97ea0026.png
[V_c]: https://latex.codecogs.com/gif.latex?V_%7Bc%7D
[X_s]: https://latex.codecogs.com/gif.latex?X%5E%7Bs%7D
[20210601093521324.png]: /images/20221014/a4cba2fa7e6a41a6ae31e729df6c885d.png
[20210601093756551.png]: /images/20221014/2e3d60fd35204cf6ae6c6343afe5be41.png
[2021060109384533.png]: /images/20221014/0f72e30c555b436f8b2eaefc2ca87c8d.png
[u_c]: https://latex.codecogs.com/gif.latex?u_%7Bc%7D
[s_c]: https://latex.codecogs.com/gif.latex?s_%7Bc%7D
[20210601093928973.png]: /images/20221014/f6ee605eed5c4a52a702ec5dc81e1481.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hoaGhoaGhoaGh3d3d3d3d3d3d3_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20210601094233873.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hoaGhoaGhoaGh3d3d3d3d3d3d3,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hoaGhoaGhoaGh3d3d3d3d3d3d3_size_16_color_FFFFFF_t_70 2]: /images/20221014/892fc79378664a9590c85c391b2652b5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hoaGhoaGhoaGh3d3d3d3d3d3d3_size_16_color_FFFFFF_t_70 3]: /images/20221014/8fb37f82672549c68aab4dfecd13d855.png