【CVPR2020】ECA-Net:深度卷积神经网络的有效通道注意力

简介: 【CVPR2020】ECA-Net:深度卷积神经网络的有效通道注意力

导读

  ECA-Net是一种基于注意力机制的神经网络模型,它在图像分类和目标检测等计算机视觉任务中取得了非常好的表现。近年来,深度学习技术在计算机视觉领域得到了广泛应用,但是在处理大尺度高分辨率图像时,常规的卷积神经网络模型存在一些局限性。ECA-Net通过引入可变的全局上下文信息,解决了这个问题。

ECA讲解

  一个人能否以更有效的方式学习有效的集中注意力?由于在SE-NET中使用了降维操作,对通道注意力带来了一定的负面影响,并且获取到的通道之间的互相关系是非必要的。为了消除这个负面影响提出了ECA。我们今天在ECA中将找到答案。

精髓

  ECA模块的精髓在于引入了可扩展卷积注意力机制,可以自适应地对每个通道的特征图进行加权,以提高模型在处理大尺度高分辨率图像时的表现。相比于传统的卷积操作,ECA模块可以更好地捕捉图像中的细节信息,从而提高模型的准确率和鲁棒性。

步骤

  ECA卷积模块是ECA-Net中引入的一种新型卷积操作,它利用注意力机制对特征图进行自适应的加权,以提高模型对图像中细节信息的提取能力。ECA卷积模块主要包括以下三个步骤:

  1. 全局平均池化(Global Average Pooling):将每个通道的特征图进行平均池化,得到一个全局的特征向量,用来表示整张图像的上下文信息。
  2. 一维卷积(1D Convolution):对全局特征向量进行一维卷积操作,以学习到通道之间的关联性。
  3. Sigmoid激活函数:将卷积输出进行Sigmoid激活,以得到每个通道的权重系数。这些权重系数将被用于对每个通道的特征图进行加权,以提高模型对图像中细节信息的提取能力。

  在下图中我们的有效通道注意力(ECA)模块示意图。考虑到通过全球平均池化(GAP)获得的聚合特征,ECA通过执行大小为k的快速1D卷积来生成信道权重,其中k是通过信道维度C的映射自适应确定的。

image.png

代码

ini

复制代码

import torch
from torch import nn
class eca_layer(nn.Module):
   def __init__(self, channel, k_size):
       super(eca_layer, self).__init__()
       self.avg_pool = nn.AdaptiveAvgPool2d(1)
       self.k_size = k_size
       self.conv = nn.Conv1d(channel, channel, kernel_size=k_size, bias=False, groups=channel)
       self.sigmoid = nn.Sigmoid()
   def forward(self, x):
       b, c, _, _ = x.size()
       y = self.avg_pool(x)
       y = nn.functional.unfold(y.transpose(-1, -3), kernel_size=(1, self.k_size), padding=(0, (self.k_size - 1) // 2))
       y = self.conv(y.transpose(-1, -2)).unsqueeze(-1)
       y = self.sigmoid(y)
       x = x * y.expand_as(x)
       return x
       
if __name__ == "__main__":
   x = torch.zeros(1,3,224,224)
   model = eca_layer(3,3)
   y = model(x)
   print(y.shape)
----torch.Size([1, 3, 224, 224])

  ECA模块能够自适应地对每个通道的特征图进行加权,从而提高模型在处理大尺度高分辨率图像时的表现。实验证明,在多项计算机视觉任务中,ECA模块能够显著提高模型的准确率和鲁棒性。 ECA模块可以轻松地嵌入到现有的卷积神经网络模型中,而不会增加太多的计算和存储成本。这使得ECA模块的应用非常灵活和方便。

ECA嵌入

一般我们是将ECA模块嵌入到卷积层之后或者是激活函数之前,在嵌入的时候需要注意的是输入与输出的确定,卷积层的输出量即为ECA模块的输入输出部分。根据实际需要,选择ECA模块的超参数,包括卷积核大小、步长、填充方式等。这些超参数的选择可以通过实验来确定。 我们以RESNET为例子:

python

复制代码

import torch.nn as nn
import math
# import torch.utils.model_zoo as model_zoo
from .eca_module import eca_layer
def conv3x3(in_planes, out_planes, stride=1):
    """3x3 convolution with padding"""
    return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride,
                     padding=1, bias=False)
class ECABasicBlock(nn.Module):
    expansion = 1
    def __init__(self, inplanes, planes, stride=1, downsample=None, k_size=3):
        super(ECABasicBlock, self).__init__()
        self.conv1 = conv3x3(inplanes, planes, stride)
        self.bn1 = nn.BatchNorm2d(planes)
        self.relu = nn.ReLU(inplace=True)
        self.conv2 = conv3x3(planes, planes, 1)
        self.bn2 = nn.BatchNorm2d(planes)
        self.eca = eca_layer(planes, k_size)
        self.downsample = downsample
        self.stride = stride
    def forward(self, x):
        residual = x
        out = self.conv1(x)
        out = self.bn1(out)
        out = self.relu(out)
        out = self.conv2(out)
        out = self.bn2(out)
        out = self.eca(out)
        if self.downsample is not None:
            residual = self.downsample(x)
        out += residual
        out = self.relu(out)
        return out
class ECABottleneck(nn.Module):
    expansion = 4
    def __init__(self, inplanes, planes, stride=1, downsample=None, k_size=3):
        super(ECABottleneck, self).__init__()
        self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False)
        self.bn1 = nn.BatchNorm2d(planes)
        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride,
                               padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(planes)
        self.conv3 = nn.Conv2d(planes, planes * 4, kernel_size=1, bias=False)
        self.bn3 = nn.BatchNorm2d(planes * 4)
        self.relu = nn.ReLU(inplace=True)
        self.eca = eca_layer(planes * 4, k_size)
        self.downsample = downsample
        self.stride = stride
    def forward(self, x):
        residual = x
        out = self.conv1(x)
        out = self.bn1(out)
        out = self.relu(out)
        out = self.conv2(out)
        out = self.bn2(out)
        out = self.relu(out)
        out = self.conv3(out)
        out = self.bn3(out)
        out = self.eca(out)
        if self.downsample is not None:
            residual = self.downsample(x)
        out += residual
        out = self.relu(out)
        return out
class ResNet(nn.Module):
    def __init__(self, block, layers, num_classes=1000, k_size=[3, 3, 3, 3]):
        self.inplanes = 64
        super(ResNet, self).__init__()
        self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3,
                               bias=False)
        self.bn1 = nn.BatchNorm2d(64)
        self.relu = nn.ReLU(inplace=True)
        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
        self.layer1 = self._make_layer(block, 64, layers[0], int(k_size[0]))
        self.layer2 = self._make_layer(block, 128, layers[1], int(k_size[1]), stride=2)
        self.layer3 = self._make_layer(block, 256, layers[2], int(k_size[2]), stride=2)
        self.layer4 = self._make_layer(block, 512, layers[3], int(k_size[3]), stride=2)
        self.avgpool = nn.AvgPool2d(7, stride=1)
        self.fc = nn.Linear(512 * block.expansion, num_classes)
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
                m.weight.data.normal_(0, math.sqrt(2. / n))
            elif isinstance(m, nn.BatchNorm2d):
                m.weight.data.fill_(1)
                m.bias.data.zero_()
    def _make_layer(self, block, planes, blocks, k_size, stride=1):
        downsample = None
        if stride != 1 or self.inplanes != planes * block.expansion:
            downsample = nn.Sequential(
                nn.Conv2d(self.inplanes, planes * block.expansion,
                          kernel_size=1, stride=stride, bias=False),
                nn.BatchNorm2d(planes * block.expansion),
            )
        layers = []
        layers.append(block(self.inplanes, planes, stride, downsample, k_size))
        self.inplanes = planes * block.expansion
        for i in range(1, blocks):
            layers.append(block(self.inplanes, planes, k_size=k_size))
        return nn.Sequential(*layers)
    def forward(self, x):
        x = self.conv1(x)
        x = self.bn1(x)
        x = self.relu(x)
        x = self.maxpool(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 eca_resnet18(k_size=[3, 3, 3, 3], num_classes=1_000, pretrained=False):
    """Constructs a ResNet-18 model.
    Args:
        k_size: Adaptive selection of kernel size
        pretrained (bool): If True, returns a model pre-trained on ImageNet
        num_classes:The classes of classification
    """
    model = ResNet(ECABasicBlock, [2, 2, 2, 2], num_classes=num_classes, k_size=k_size)
    model.avgpool = nn.AdaptiveAvgPool2d(1)
    return model
def eca_resnet34(k_size=[3, 3, 3, 3], num_classes=1_000, pretrained=False):
    """Constructs a ResNet-34 model.
    Args:
        k_size: Adaptive selection of kernel size
        pretrained (bool): If True, returns a model pre-trained on ImageNet
        num_classes:The classes of classification
    """
    model = ResNet(ECABasicBlock, [3, 4, 6, 3], num_classes=num_classes, k_size=k_size)
    model.avgpool = nn.AdaptiveAvgPool2d(1)
    return model
def eca_resnet50(k_size=[3, 3, 3, 3], num_classes=1000, pretrained=False):
    """Constructs a ResNet-50 model.
    Args:
        k_size: Adaptive selection of kernel size
        num_classes:The classes of classification
        pretrained (bool): If True, returns a model pre-trained on ImageNet
    """
    print("Constructing eca_resnet50......")
    model = ResNet(ECABottleneck, [3, 4, 6, 3], num_classes=num_classes, k_size=k_size)
    model.avgpool = nn.AdaptiveAvgPool2d(1)
    return model
def eca_resnet101(k_size=[3, 3, 3, 3], num_classes=1_000, pretrained=False):
    """Constructs a ResNet-101 model.
    Args:
        k_size: Adaptive selection of kernel size
        num_classes:The classes of classification
        pretrained (bool): If True, returns a model pre-trained on ImageNet
    """
    model = ResNet(ECABottleneck, [3, 4, 23, 3], num_classes=num_classes, k_size=k_size)
    model.avgpool = nn.AdaptiveAvgPool2d(1)
    return model
def eca_resnet152(k_size=[3, 3, 3, 3], num_classes=1_000, pretrained=False):
    """Constructs a ResNet-152 model.
    Args:
        k_size: Adaptive selection of kernel size
        num_classes:The classes of classification
        pretrained (bool): If True, returns a model pre-trained on ImageNet
    """
    model = ResNet(ECABottleneck, [3, 8, 36, 3], num_classes=num_classes, k_size=k_size)
    model.avgpool = nn.AdaptiveAvgPool2d(1)
    return model

  在论文中我们可以看到一系列经过ECA模块改良后的acc值的对比:

image.png

结尾

  又是一年毕业季,又到了各路学子们“写论文”的时候了,你是不是还在担心自己的论文无法过关?来看本文中提到的ECA-Net,顶刊级别的结构融入到你论文中还怕无法通过学校的检查么,这不直接吊炸天了啊


相关文章
|
6天前
|
机器学习/深度学习 存储 监控
数据分享|Python卷积神经网络CNN身份识别图像处理在疫情防控下口罩识别、人脸识别
数据分享|Python卷积神经网络CNN身份识别图像处理在疫情防控下口罩识别、人脸识别
|
1天前
|
机器学习/深度学习 编解码 边缘计算
YOLOv5改进 | 卷积模块 | 用ShuffleNetV2卷积替换Conv【轻量化网络】
本文介绍了如何在YOLOv5中用ShuffleNetV2替换卷积以减少计算量。ShuffleNetV2是一个轻量级网络,采用深度可分离卷积、通道重组和多尺度特征融合技术。文中提供了一个逐步教程,包括ShuffleNetV2模块的代码实现和在YOLOv5配置文件中的添加方法。此外,还分享了完整的代码链接和GFLOPs的比较,显示了GFLOPs的显著减少。该教程适合初学者实践,以提升深度学习目标检测技能。
YOLOv5改进 | 卷积模块 | 用ShuffleNetV2卷积替换Conv【轻量化网络】
|
6天前
|
机器学习/深度学习 算法 PyTorch
卷积神经网络的结构组成与解释(详细介绍)
卷积神经网络的结构组成与解释(详细介绍)
26 0
|
6天前
|
机器学习/深度学习 算法 数据挖掘
深度学习500问——Chapter05: 卷积神经网络(CNN)(4)
深度学习500问——Chapter05: 卷积神经网络(CNN)(4)
15 1
|
6天前
|
机器学习/深度学习 自然语言处理 计算机视觉
深度学习500问——Chapter05: 卷积神经网络(CNN)(3)
深度学习500问——Chapter05: 卷积神经网络(CNN)(3)
12 1
|
6天前
|
机器学习/深度学习 存储 算法
卷积神经网络(CNN)的数学原理解析
卷积神经网络(CNN)的数学原理解析
35 1
卷积神经网络(CNN)的数学原理解析
|
6天前
|
机器学习/深度学习 自然语言处理 计算机视觉
深度学习500问——Chapter05: 卷积神经网络(CNN)(2)
深度学习500问——Chapter05: 卷积神经网络(CNN)(2)
14 2
|
6天前
|
机器学习/深度学习 算法 PyTorch
卷积神经网络(CNN)——基础知识整理
卷积神经网络(CNN)——基础知识整理
30 2
|
6天前
|
机器学习/深度学习 存储 自然语言处理
深度学习500问——Chapter05: 卷积神经网络(CNN)(1)
深度学习500问——Chapter05: 卷积神经网络(CNN)(1)
18 1
|
6天前
|
机器学习/深度学习 PyTorch 算法框架/工具
使用Python实现卷积神经网络(CNN)
使用Python实现卷积神经网络(CNN)的博客教程
34 1

热门文章

最新文章