关键词：注意力机制 、 卷积 、 CVPR 、 ECA模块
原文：1910.03151.pdf (arxiv.org)
代码：ECANet
导读
ECA-Net是一种基于注意力机制的神经网络模型，它在图像分类和目标检测等计算机视觉任务中取得了非常好的表现。近年来，深度学习技术在计算机视觉领域得到了广泛应用，但是在处理大尺度高分辨率图像时，常规的卷积神经网络模型存在一些局限性。ECA-Net通过引入可变的全局上下文信息，解决了这个问题。
ECA讲解
一个人能否以更有效的方式学习有效的集中注意力?由于在SE-NET中使用了降维操作，对通道注意力带来了一定的负面影响，并且获取到的通道之间的互相关系是非必要的。为了消除这个负面影响提出了ECA。我们今天在ECA中将找到答案。
精髓
ECA模块的精髓在于引入了可扩展卷积注意力机制，可以自适应地对每个通道的特征图进行加权，以提高模型在处理大尺度高分辨率图像时的表现。相比于传统的卷积操作，ECA模块可以更好地捕捉图像中的细节信息，从而提高模型的准确率和鲁棒性。
步骤
ECA卷积模块是ECA-Net中引入的一种新型卷积操作，它利用注意力机制对特征图进行自适应的加权，以提高模型对图像中细节信息的提取能力。ECA卷积模块主要包括以下三个步骤：
- 全局平均池化（Global Average Pooling）：将每个通道的特征图进行平均池化，得到一个全局的特征向量，用来表示整张图像的上下文信息。
- 一维卷积（1D Convolution）：对全局特征向量进行一维卷积操作，以学习到通道之间的关联性。
- Sigmoid激活函数：将卷积输出进行Sigmoid激活，以得到每个通道的权重系数。这些权重系数将被用于对每个通道的特征图进行加权，以提高模型对图像中细节信息的提取能力。
在下图中我们的有效通道注意力(ECA)模块示意图。考虑到通过全球平均池化(GAP)获得的聚合特征，ECA通过执行大小为k的快速1D卷积来生成信道权重，其中k是通过信道维度C的映射自适应确定的。
代码
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为例子：
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值的对比：
结尾
又是一年毕业季，又到了各路学子们“写论文”的时候了，你是不是还在担心自己的论文无法过关？来看本文中提到的ECA-Net，顶刊级别的结构融入到你论文中还怕无法通过学校的检查么，这不直接吊炸天了啊
*本文正在参加 人工智能创作者扶持计划 ” *
