SENet代码及解释（pytorch）

已于 2023-05-24 09:20:35 修改
阅读量1k 收藏 8
点赞数 2
分类专栏： 深度学习 文章标签： pytorch 深度学习 python
于 2023-05-24 09:17:15 首次发布
原文链接：https://blog.csdn.net/weixin_43334693/article/details/128567913
版权

1.SEblock搭建

全局平均池化+1*1卷积核+ReLu+1*1卷积核+Sigmoid

import torch.nn as nn
#全局平均池化+1*1卷积核+ReLu+1*1卷积核+Sigmoid
class SE_Block(nn.Module):
    def __init__(self, inchannel, ratio=16):
        super(SE_Block, self).__init__()
        # 全局平均池化(Fsq操作)
        self.gap = nn.AdaptiveAvgPool2d((1, 1))
        # 两个全连接层(Fex操作)
        self.fc = nn.Sequential(
            nn.Linear(inchannel, inchannel // ratio, bias=False),  # 从 c -> c/r
            nn.ReLU(),
            nn.Linear(inchannel // ratio, inchannel, bias=False),  # 从 c/r -> c
            nn.Sigmoid()
        )
 
    def forward(self, x):
            # 读取批数据图片数量及通道数
            b, c, h, w = x.size()
            # Fsq操作：经池化后输出b*c的矩阵
            y = self.gap(x).view(b, c)
            # Fex操作：经全连接层输出（b，c，1，1）矩阵
            y = self.fc(y).view(b, c, 1, 1)
            # Fscale操作：将得到的权重乘以原来的特征图x
            return x * y.expand_as(x)

2.将SEblock嵌入残差模块

将SE模块分别嵌入ResNet的BasicBlock和Bottleneck中，得到 SEBasicBlock和SEBottleneck

BasicBlock模块

'''-------------二、BasicBlock模块-----------------------------'''
# 左侧的 residual block 结构（18-layer、34-layer）
class BasicBlock(nn.Module):
    expansion = 1
 
    def __init__(self, inchannel, outchannel, stride=1):
        super(BasicBlock, self).__init__()
        self.conv1 = nn.Conv2d(inchannel, outchannel, kernel_size=3,
                               stride=stride, padding=1, bias=False)
        self.bn1 = nn.BatchNorm2d(outchannel)
        self.conv2 = nn.Conv2d(outchannel, outchannel, kernel_size=3,
                               stride=1, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(outchannel)
        # SE_Block放在BN之后，shortcut之前
        self.SE = SE_Block(outchannel)
 
        self.shortcut = nn.Sequential()
        if stride != 1 or inchannel != self.expansion*outchannel:
            self.shortcut = nn.Sequential(
                nn.Conv2d(inchannel, self.expansion*outchannel,
                          kernel_size=1, stride=stride, bias=False),
                nn.BatchNorm2d(self.expansion*outchannel)
            )
 
    def forward(self, x):
        out = F.relu(self.bn1(self.conv1(x)))
        out = self.bn2(self.conv2(out))
        SE_out = self.SE(out)
        out = out * SE_out
        out += self.shortcut(x)
        out = F.relu(out)
        return out

Bottleneck模块 

'''-------------三、Bottleneck模块-----------------------------'''
# 右侧的 residual block 结构（50-layer、101-layer、152-layer）
class Bottleneck(nn.Module):
    expansion = 4
 
    def __init__(self, inchannel, outchannel, stride=1):
        super(Bottleneck, self).__init__()
        self.conv1 = nn.Conv2d(inchannel, outchannel, kernel_size=1, bias=False)
        self.bn1 = nn.BatchNorm2d(outchannel)
        self.conv2 = nn.Conv2d(outchannel, outchannel, kernel_size=3,
                               stride=stride, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(outchannel)
        self.conv3 = nn.Conv2d(outchannel, self.expansion*outchannel,
                               kernel_size=1, bias=False)
        self.bn3 = nn.BatchNorm2d(self.expansion*outchannel)
        # SE_Block放在BN之后，shortcut之前
        self.SE = SE_Block(self.expansion*outchannel)
 
        self.shortcut = nn.Sequential()
        if stride != 1 or inchannel != self.expansion*outchannel:
            self.shortcut = nn.Sequential(
                nn.Conv2d(inchannel, self.expansion*outchannel,
                          kernel_size=1, stride=stride, bias=False),
                nn.BatchNorm2d(self.expansion*outchannel)
            )
 
    def forward(self, x):
        out = F.relu(self.bn1(self.conv1(x)))
        out = F.relu(self.bn2(self.conv2(out)))
        out = self.bn3(self.conv3(out))
        SE_out = self.SE(out)
        out = out * SE_out
        out += self.shortcut(x)
        out = F.relu(out)
        return out

3.搭建SE_ResNet结构

'''-------------四、搭建SE_ResNet结构-----------------------------'''
class SE_ResNet(nn.Module):
    def __init__(self, block, num_blocks, num_classes=10):
        super(SE_ResNet, self).__init__()
        self.in_planes = 64
 
        self.conv1 = nn.Conv2d(3, 64, kernel_size=3,
                               stride=1, padding=1, bias=False)                  # conv1
        self.bn1 = nn.BatchNorm2d(64)
        self.layer1 = self._make_layer(block, 64, num_blocks[0], stride=1)       # conv2_x
        self.layer2 = self._make_layer(block, 128, num_blocks[1], stride=2)      # conv3_x
        self.layer3 = self._make_layer(block, 256, num_blocks[2], stride=2)      # conv4_x
        self.layer4 = self._make_layer(block, 512, num_blocks[3], stride=2)      # conv5_x
        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
        self.linear = nn.Linear(512 * block.expansion, num_classes)
 
    def _make_layer(self, block, planes, num_blocks, stride):
        strides = [stride] + [1]*(num_blocks-1)
        layers = []
        for stride in strides:
            layers.append(block(self.in_planes, planes, stride))
            self.in_planes = planes * block.expansion
        return nn.Sequential(*layers)
 
    def forward(self, x):
        x = F.relu(self.bn1(self.conv1(x)))
        x = self.layer1(x)
        x = self.layer2(x)
        x = self.layer3(x)
        x = self.layer4(x)
        x = self.avgpool(x)
        x = torch.flatten(x, 1)
        out = self.linear(x)
        return out

4.完整代码

import torch
import torch.nn as nn
import torch.nn.functional as F
from torchsummary import summary
 
'''-------------一、SE模块-----------------------------'''
#全局平均池化+1*1卷积核+ReLu+1*1卷积核+Sigmoid
class SE_Block(nn.Module):
    def __init__(self, inchannel, ratio=16):
        super(SE_Block, self).__init__()
        # 全局平均池化(Fsq操作)
        self.gap = nn.AdaptiveAvgPool2d((1, 1))
        # 两个全连接层(Fex操作)
        self.fc = nn.Sequential(
            nn.Linear(inchannel, inchannel // ratio, bias=False),  # 从 c -> c/r
            nn.ReLU(),
            nn.Linear(inchannel // ratio, inchannel, bias=False),  # 从 c/r -> c
            nn.Sigmoid()
        )
 
    def forward(self, x):
            # 读取批数据图片数量及通道数
            b, c, h, w = x.size()
            # Fsq操作：经池化后输出b*c的矩阵
            y = self.gap(x).view(b, c)
            # Fex操作：经全连接层输出（b，c，1，1）矩阵
            y = self.fc(y).view(b, c, 1, 1)
            # Fscale操作：将得到的权重乘以原来的特征图x
            return x * y.expand_as(x)
 
'''-------------二、BasicBlock模块-----------------------------'''
# 左侧的 residual block 结构（18-layer、34-layer）
class BasicBlock(nn.Module):
    expansion = 1
 
    def __init__(self, inchannel, outchannel, stride=1):
        super(BasicBlock, self).__init__()
        self.conv1 = nn.Conv2d(inchannel, outchannel, kernel_size=3,
                               stride=stride, padding=1, bias=False)
        self.bn1 = nn.BatchNorm2d(outchannel)
        self.conv2 = nn.Conv2d(outchannel, outchannel, kernel_size=3,
                               stride=1, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(outchannel)
        # SE_Block放在BN之后，shortcut之前
        self.SE = SE_Block(outchannel)
 
        self.shortcut = nn.Sequential()
        if stride != 1 or inchannel != self.expansion*outchannel:
            self.shortcut = nn.Sequential(
                nn.Conv2d(inchannel, self.expansion*outchannel,
                          kernel_size=1, stride=stride, bias=False),
                nn.BatchNorm2d(self.expansion*outchannel)
            )
 
    def forward(self, x):
        out = F.relu(self.bn1(self.conv1(x)))
        out = self.bn2(self.conv2(out))
        SE_out = self.SE(out)
        out = out * SE_out
        out += self.shortcut(x)
        out = F.relu(out)
        return out
 
'''-------------三、Bottleneck模块-----------------------------'''
# 右侧的 residual block 结构（50-layer、101-layer、152-layer）
class Bottleneck(nn.Module):
    expansion = 4
 
    def __init__(self, inchannel, outchannel, stride=1):
        super(Bottleneck, self).__init__()
        self.conv1 = nn.Conv2d(inchannel, outchannel, kernel_size=1, bias=False)
        self.bn1 = nn.BatchNorm2d(outchannel)
        self.conv2 = nn.Conv2d(outchannel, outchannel, kernel_size=3,
                               stride=stride, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(outchannel)
        self.conv3 = nn.Conv2d(outchannel, self.expansion*outchannel,
                               kernel_size=1, bias=False)
        self.bn3 = nn.BatchNorm2d(self.expansion*outchannel)
        # SE_Block放在BN之后，shortcut之前
        self.SE = SE_Block(self.expansion*outchannel)
 
        self.shortcut = nn.Sequential()
        if stride != 1 or inchannel != self.expansion*outchannel:
            self.shortcut = nn.Sequential(
                nn.Conv2d(inchannel, self.expansion*outchannel,
                          kernel_size=1, stride=stride, bias=False),
                nn.BatchNorm2d(self.expansion*outchannel)
            )
 
    def forward(self, x):
        out = F.relu(self.bn1(self.conv1(x)))
        out = F.relu(self.bn2(self.conv2(out)))
        out = self.bn3(self.conv3(out))
        SE_out = self.SE(out)
        out = out * SE_out
        out += self.shortcut(x)
        out = F.relu(out)
        return out
 
'''-------------四、搭建SE_ResNet结构-----------------------------'''
class SE_ResNet(nn.Module):
    def __init__(self, block, num_blocks, num_classes=10):
        super(SE_ResNet, self).__init__()
        self.in_planes = 64
 
        self.conv1 = nn.Conv2d(3, 64, kernel_size=3,
                               stride=1, padding=1, bias=False)                  # conv1
        self.bn1 = nn.BatchNorm2d(64)
        self.layer1 = self._make_layer(block, 64, num_blocks[0], stride=1)       # conv2_x
        self.layer2 = self._make_layer(block, 128, num_blocks[1], stride=2)      # conv3_x
        self.layer3 = self._make_layer(block, 256, num_blocks[2], stride=2)      # conv4_x
        self.layer4 = self._make_layer(block, 512, num_blocks[3], stride=2)      # conv5_x
        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
        self.linear = nn.Linear(512 * block.expansion, num_classes)
 
    def _make_layer(self, block, planes, num_blocks, stride):
        strides = [stride] + [1]*(num_blocks-1)
        layers = []
        for stride in strides:
            layers.append(block(self.in_planes, planes, stride))
            self.in_planes = planes * block.expansion
        return nn.Sequential(*layers)
 
    def forward(self, x):
        x = F.relu(self.bn1(self.conv1(x)))
        x = self.layer1(x)
        x = self.layer2(x)
        x = self.layer3(x)
        x = self.layer4(x)
        x = self.avgpool(x)
        x = torch.flatten(x, 1)
        out = self.linear(x)
        return out
 
 
def SE_ResNet18():
    return SE_ResNet(BasicBlock, [2, 2, 2, 2])
 
 
def SE_ResNet34():
    return SE_ResNet(BasicBlock, [3, 4, 6, 3])
 
 
def SE_ResNet50():
    return SE_ResNet(Bottleneck, [3, 4, 6, 3])
 
 
def SE_ResNet101():
    return SE_ResNet(Bottleneck, [3, 4, 23, 3])
 
 
def SE_ResNet152():
    return SE_ResNet(Bottleneck, [3, 8, 36, 3])
 
 
'''
if __name__ == '__main__':
    model = SE_ResNet50()
    print(model)
    input = torch.randn(1, 3, 224, 224)
    out = model(input)
    print(out.shape)
# test()
'''
if __name__ == '__main__':
    net = SE_ResNet50().cuda()
    summary(net, (3, 224, 224))

--好好学算法--
关注
  • 2
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【图像分类】用最简短的代码复现SeNet，小白一定要收藏（keras，Tensorflow2
m0_61067876的博客
05-01 1033
不知道你们用的什么环境，我一般都是用的Python3.6环境和pycharm解释器，没有软件，或者没有资料，没人解答问题，都可以免费领取（包括今天的代码），过几天我还会做个视频教程出来，有需要也可以领取~给大家准备的学习资料包括但不限于：Python 环境、pycharm编辑器/永久激活/翻译插件python 零基础视频教程Python 界面开发实战教程Python 爬虫实战教程Python 数据分析实战教程python 游戏开发实战教程Python 电子书100本。
SENet：Squeeze-and-Excitation Networks详解及Pytorch实现
热门推荐
畅游计算机视觉的海洋
04-23 20万+
文章目录前言一、什么是SENetSqueezeExcitation二、完整SE block的Pytorch实现总结 前言 计算机视觉研究领域的一个核心理论就是如何提高网络的表现力使其关注到图片的关键位置，从而提升网络性能。与一般网络通过空间维度优化不同，SENet(Squeeze-and-Excitation Networks)着手于优化channel维度，通过引入注意力机制，增加少量参数，使模型可以更好地获取不同channel上的特征，从而提高准确率。 与其称为SENet，不如称其为SE Block。因
【图像分类】用最简短的代码复现SeNet，小白一定要收藏（keras，Tensorflow2(1)
2401_83703866的博客
04-13 825
该从何学起的朋友，同时减轻大家的负担。**[外链图片转存中…(img-V055W3JO-1712969874546)][外链图片转存中…(img-dDMSaRHk-1712969874546)][外链图片转存中…(img-cf1q93Bq-1712969874546)][外链图片转存中…(img-RyDdtbDs-1712969874547)]
Pytorch实现ECA
2401_83817343的博客
04-08 457
self.b = breturn out。
pytorch实现Senet 代码详解
cp1314971的博客
02-25 1万+
Senet的优点 senet的优点在于增加少量的参数便可以一定程度的提高模型的准确率，是第一个在成型的模型基础之上建立的策略，创新点非常的好，很适合自己创作新模型刷高准确率的一种方法。 Senet的结构 本文的代码讲解是以resnet50讲解，上图便是senet的结构，应用于已经构造完成的resnet模型，只不过在加上了一层se结构的卷积。se结构是在特征图最后进行的，out_channels，...
SENet论文理解与代码复现（pytorch）
qq_63197247的博客
01-30 637
通过自动学习的方式（用另外一个神经网络实现）获取到每个特征通道的重要程度，然后用这个重要程度去给每一个特征通道赋予权重值，从而让神经网络重点关注某些特征通道。在神经网络中加入注意力机制有很多方法，可以在空间维度引入注意力机制（eg inception结构，让并联的卷积层分配不同的权重），也可以在通道维度引入attention机制。SENet的核心思想在于通过全连接网络根据loss去自动学习特征权重（并不是直接根据特征通道的数值分布来判断），使得有效的特征通道权重大。SENet-pytorch代码链接。
SENet代码复现＋超详细注释（PyTorch）
路人贾的博客
01-05 1万+
SENet代码复现（PyTorch），每一行都有超详细注释，新手小白都能看懂，亲测可运行
SENet注意力机制——pytorch实现
Peach_____的博客
01-13 980
【代码】SENet注意力机制——pytorch实现。
经典注意力网络: SeNet及pytorch实践
Ethan_Rich的博客
11-10 318
先看输入特征数据其中代表卷积运算后输出通道的特征数据，代表通道的输入数据，代表个输入通道为的卷积核。由于输出是通过所有通道的求和产生的，因此通道依赖关系隐式嵌入在中，但这些依赖关系与过滤器捕获的空间相关性纠缠在一起。全局注意力可以对整张特征图的每个像素点的关系进行建模，那么同样特征图通道之间也存在联系。SeNet通过显式建模通道相互依赖性来实现这一目标，以便在将卷积核响应馈送到下一个变换之前，分两个步骤(挤压和激励)重新校准滤卷积核响应。压缩与激励模块。
CBAM解析及代码（Pytorch）
Ethan_Rich的博客
03-23 1503
CBAM，全称Convolutional Block Attention Module，是一种注意力机制模块，用于增强卷积神经网络（CNN）的特征表达能力。该模块由通道注意力模块和空间注意力模块两部分组成，能够分别关注输入特征图的通道信息和空间信息，进而提升模型对于重要特征的关注度。在通道注意力模块中，CBAM通过全局平均池化和最大池化操作捕获通道间的依赖关系，生成两个通道描述子。这两个描述子随后通过共享的全连接层和ReLU激活函数进行变换，再经过Sigmoid函数得到通道注意力权重。
pytorch SENet实现案例
12-17
**PyTorch中的SENet实现** SENet（Squeeze-and-Excitation Networks）是由Huang等人在2017年提出的，它引入了一种新的结构——SE Block（Squeeze-and-Excitation Block），用于增强卷积神经网络（CNN）的性能，特别...
SENet-PyTorch
05-10
这是SENet的PyTorch实施（在ImageNet数据集上进行训练） 论文： 用法 准备数据 该代码以ImageNet数据集为例。 您可以下载ImageNet数据集，并将其放入如下位置。 由于内存限制，我仅提供ILSVRC2012_dev_kit_t12 ，...
pytorch--SENet:挤压与激励网络的重新实现
03-17
### Squeeze-和-Excitation Networks实施（pytorch） 为了训练 python main.py # argparser Default --print_freq 32 --save_dir ./save_model/ --save_every 10 --lr 0.1 --weight_decay 1e-4 --momentum 0.9 --...
SENet-CIFAR10
12-26
**SENet-CIFAR10** 是一个使用PyTorch框架实现的深度学习项目，它在CIFAR-10数据集上应用了SENet（Squeeze-and-Excitation Networks）模型进行图像分类任务。CIFAR-10数据集包含60000张32x32像素的彩色图像，分为10...
Python库 | segmentation_models_pytorch-0.0.2.tar.gz
03-10
`segmentation_models_pytorch`库简化了这一过程，使得开发者无需从零开始编写复杂的网络结构和训练代码。 首先，我们来了解下这个库的核心特性。`segmentation_models_pytorch`包含了多种预训练的卷积神经网络...
pytorch backbone
weixin_45706801的博客
07-23 513
在PyTorch深度学习中，预训练backbone（骨干网络）是一个常见的做法，特别是在处理图像识别、目标检测、图像分割等任务时。预训练backbone通常是指在大型数据集（如ImageNet）上预先训练好的卷积神经网络（CNN）模型，这些模型能够提取图像中的通用特征，这些特征在多种任务中都是有用的。
PyTorch 的各个核心模块和它们的功能
最新发布
SisterRu的博客
07-25 575
通过这些模块，PyTorch 提供了构建、训练、优化和部署深度学习模型所需的全面支持。
【PyTorch】单目标检测项目部署
Frost_Descent的博客
07-23 440
详细参照前文【PyTorch】单目标检测项目import os# 定义一个函数，用于将a列表中的元素除以b列表中的对应元素，返回一个新的列表# 使用zip函数将a和b列表中的元素一一对应# 返回新的列表return div# 定义一个函数，用于将a列表中的元素乘以b列表中的对应元素，返回一个新的列表# 使用zip函数将a和b列表中的元素一一对应# 返回新的列表return div# 定义一个函数，用于调整图像和标签的大小# 获取原始图像的宽度和高度# 获取目标图像的宽度和高度。
senet注意力机制pytorch
05-26
SENet（Squeeze-and-Excitation Network）是一种用于卷积神经网络（CNN）中的注意力机制，它通过学习通道间的关系来增强特征表示的重要性。在SENet中，网络会自动学习特征通道之间的相关性，并针对每个通道进行加权，以提高整体特征表示的性能。 在PyTorch中，可以使用以下代码实现SENet注意力机制： ```python import torch.nn as nn 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) ``` 在上面的代码中，我们定义了一个SELayer类，它包含两个部分：全局平均池化和全连接层。首先，我们使用全局平均池化对每个通道进行平均池化，然后将结果输入到全连接层中。全连接层通过两个线性层和ReLU激活函数来学习特征通道之间的关系，最后使用Sigmoid函数将输出值压缩到0到1之间。最后，我们将SELayer应用于输入特征图上，以增强特征表示的重要性。 SENet是一种非常有效的注意力机制，可以提高卷积神经网络的性能。在实际应用中，可以将SELayer添加到现有的CNN架构中，以提高模型的性能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值