devbox
花生_TL007
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

深度学习中的注意力机制（SENet、ECA、CBAM）pytorch验证_se注意力机制

作者：花生_TL007 | 2024-03-22 20:55:36

赞

踩

se注意力机制

先验证 SENet

介绍一下：SE注意力机制（Squeeze-and-Excitation Networks），它是一种通道类型的注意力机制，就是在通道维度上增加注意力机制，主要内容是是squeeze和excitation。

在原来学习机制的基础上，开辟一个新的网络路径，经过操作，获得特征图中的每个通道的注意力程度，并根据这个程度为每个特征通道配置一个注意力权重，从而让卷积网络更加关注这些特征通道，近而实现对当前任务有用的特征图的通道，并抑制对当前任务用处不大的特征通道。

如上图所示，在输入SE注意力机制之前（左侧图C），特征图的每个通道的注意力程度都是一样的，通过SENet之后（右侧彩图C），不同颜色代表不同的权重，使每个特征通道的重要性变得不一样了，使卷积神经网络有意识的重点关注某些权重值大的通道。 

 

SE注意力机制的实现步骤如下：

（1）Squeeze：通过全局平均池化，将每个通道的二维特征（H*W）压缩为1个实数，将特征图从 [h, w, c] ==> [1,1,c]

（2）excitation：给每个特征通道生成一个权重值，论文中通过两个全连接层构建通道间的相关性，输出的权重值数目和输入特征图的通道数相同。[1,1,c] ==> [1,1,c]

（3）Scale：将前面得到的归一化权重加权到每个通道的特征上。论文中使用的是乘法，逐通道乘以权重系数。[h,w,c]*[1,1,c] ==> [h,w,c]
 

SE是通过全连接网络的损失函数loss()来自动学习特征权重，就像把卷积最后的loss 全连接复制到这个地方了，提前的粗略的对通道进行一下识别，并分配权重；使有效的特征通道的权重大。当然SE注意力机制不可避免的增加了一些参数和计算量，但性价比还是挺高的。

论文作者认为excitation操作中使用两个全连接层相比直接使用一个全连接层，它的好处在于，具有更多的非线性，可以更好地拟合通道间的复杂关联。

代码实现：

  1. # -------------------------------------------- #
  2. #（1）SE 通道注意力机制
  3. # -------------------------------------------- #
  4. import torch
  5. from torch import nn
  6. from torchstat import stat  # 查看网络参数
  7.  
  8. # 定义SE注意力机制的类
  9. class se_block(nn.Module):
  10.     # 初始化, in_channel代表输入特征图的通道数, ratio代表第一个全连接下降通道的倍数
  11.     def __init__(self, in_channel, ratio=4):
  12.         # 继承父类初始化方法
  13.         super(se_block, self).__init__()
  14.         
  15.         # 属性分配
  16.         # 全局平均池化，输出的特征图的宽高=1
  17.         self.avg_pool = nn.AdaptiveAvgPool2d(output_size=1)
  18.         # 第一个全连接层将特征图的通道数下降4倍
  19.         self.fc1 = nn.Linear(in_features=in_channel, out_features=in_channel//ratio, bias=False)
  20.         # relu激活
  21.         self.relu = nn.ReLU()
  22.         # 第二个全连接层恢复通道数
  23.         self.fc2 = nn.Linear(in_features=in_channel//ratio, out_features=in_channel, bias=False)
  24.         # sigmoid激活函数，将权值归一化到0-1
  25.         self.sigmoid = nn.Sigmoid()
  26.         
  27.     # 前向传播
  28.     def forward(self, inputs):  # inputs 代表输入特征图
  29.     
  30.         # 获取输入特征图的shape
  31.         b, c, h, w = inputs.shape
  32.         # 全局平均池化 [b,c,h,w]==>[b,c,1,1]
  33.         x = self.avg_pool(inputs)
  34.         # 维度调整 [b,c,1,1]==>[b,c]
  35.         x = x.view([b,c])
  36.         
  37.         # 第一个全连接下降通道 [b,c]==>[b,c//4]
  38.         x = self.fc1(x)
  39.         x = self.relu(x)
  40.         # 第二个全连接上升通道 [b,c//4]==>[b,c]
  41.         x = self.fc2(x)
  42.         # 对通道权重归一化处理
  43.         x = self.sigmoid(x)
  44.         
  45.         # 调整维度 [b,c]==>[b,c,1,1]
  46.         x = x.view([b,c,1,1])
  47.         
  48.         # 将输入特征图和通道权重相乘
  49.         outputs = x * inputs
  50.         return outputs

构造输入层，查看一次前向传播的输出结果，打印网络结构

  1. # 构造输入层shape==[4,32,16,16]
  2. inputs = torch.rand(4,32,16,16)
  3. # 获取输入通道数
  4. in_channel = inputs.shape[1]
  5. # 模型实例化
  6. model = se_block(in_channel=in_channel)
  7.  
  8. # 前向传播查看输出结果
  9. outputs = model(inputs)
  10. print(outputs.shape)  # [4,32,16,16])
  11.  
  12. print(model) # 查看模型结构
  13. stat(model, input_size=[32,16,16])  # 查看参数，不需要指定batch维度

网络的参数量如下：

  1.       module name  input shape output shape  params memory(MB)   MAdd  Flops  MemRead(B)  MemWrite(B) duration[%]  MemR+W(B)
  2. 0        avg_pool   32  16  16   32   1   1     0.0       0.00    0.0    0.0         0.0          0.0      99.99%        0.0
  3. 1             fc1           32            8   256.0       0.00  504.0  256.0      1152.0         32.0       0.00%     1184.0
  4. 2            relu            8            8     0.0       0.00    8.0    8.0        32.0         32.0       0.00%       64.0
  5. 3             fc2            8           32   256.0       0.00  480.0  256.0      1056.0        128.0       0.00%     1184.0
  6. 4         sigmoid           32           32     0.0       0.00    0.0    0.0         0.0          0.0       0.00%        0.0
  7. total                                         512.0       0.00  992.0  520.0         0.0          0.0      99.99%     2432.0
  8. ============================================================================================================================
  9. Total params: 512
  10. ----------------------------------------------------------------------------------------------------------------------------
  11. Total memory: 0.00MB
  12. Total MAdd: 992MAdd
  13. Total Flops: 520Flops
  14. Total MemR+W: 2.38KB

 然后、ECANet

 ECANet 是通道注意力机制的一种实现形式，ECANet 可以看做是 SENet 的改进版。

作者表明 SENet 中的降维会给通道注意力机制带来副作用，并且捕获所有通道之间的依存关系是效率不高的，而且是不必要的。

ECA 注意力机制模块直接在全局平均池化层之后使用1x1卷积层，去除了全连接层。该模块避免了维度缩减，并有效捕获了跨通道交互。并且 ECANet 只涉及少数参数就能达到很好的效果。

ECANet 通过 一维卷积 layers.Conv1D 来完成跨通道间的信息交互，卷积核的大小通过一个函数来自适应变化，使得通道数较大的层可以更多地进行跨通道交互。
 

自适应函数为:

 

 ECA注意力机制的实现过程如下：

（1）将输入特征图经过全局平均池化，特征图从 [h,w,c] 的矩阵变成 [1,1,c] 的向量

（2）根据特征图的通道数计算得到自适应的一维卷积核大小 kernel_size

（3）将 kernel_size 用于一维卷积中，得到对于特征图的每个通道的权重

（4）将归一化权重和原输入特征图逐通道相乘，生成加权后的特征图
 

 代码展示

ECA注意力机制的代码如下：

  1. # --------------------------------------------------------- #
  2. #（2）ECANet 通道注意力机制
  3. # 使用1D卷积代替SE注意力机制中的全连接层
  4. # --------------------------------------------------------- #
  5.  
  6. import torch
  7. from torch import nn
  8. import math
  9. from torchstat import stat  # 查看网络参数
  10.  
  11. # 定义ECANet的类
  12. class eca_block(nn.Module):
  13.     # 初始化, in_channel代表特征图的输入通道数, b和gama代表公式中的两个系数
  14.     def __init__(self, in_channel, b=1, gama=2):
  15.         # 继承父类初始化
  16.         super(eca_block, self).__init__()
  17.         
  18.         # 根据输入通道数自适应调整卷积核大小
  19.         kernel_size = int(abs((math.log(in_channel, 2)+b)/gama))
  20.         # 如果卷积核大小是奇数，就使用它
  21.         if kernel_size % 2:
  22.             kernel_size = kernel_size
  23.         # 如果卷积核大小是偶数，就把它变成奇数
  24.         else:
  25.             kernel_size = kernel_size
  26.         
  27.         # 卷积时，为例保证卷积前后的size不变，需要0填充的数量
  28.         padding = kernel_size // 2
  29.         
  30.         # 全局平均池化，输出的特征图的宽高=1
  31.         self.avg_pool = nn.AdaptiveAvgPool2d(output_size=1)
  32.         # 1D卷积，输入和输出通道数都=1，卷积核大小是自适应的
  33.         self.conv = nn.Conv1d(in_channels=1, out_channels=1, kernel_size=kernel_size,
  34.                               bias=False, padding=padding)
  35.         # sigmoid激活函数，权值归一化
  36.         self.sigmoid = nn.Sigmoid()
  37.     
  38.     # 前向传播
  39.     def forward(self, inputs):
  40.         # 获得输入图像的shape
  41.         b, c, h, w = inputs.shape
  42.         
  43.         # 全局平均池化 [b,c,h,w]==>[b,c,1,1]
  44.         x = self.avg_pool(inputs)
  45.         # 维度调整，变成序列形式 [b,c,1,1]==>[b,1,c]
  46.         x = x.view([b,1,c])
  47.         # 1D卷积 [b,1,c]==>[b,1,c]
  48.         x = self.conv(x)
  49.         # 权值归一化
  50.         x = self.sigmoid(x)
  51.         # 维度调整 [b,1,c]==>[b,c,1,1]
  52.         x = x.view([b,c,1,1])
  53.         
  54.         # 将输入特征图和通道权重相乘[b,c,h,w]*[b,c,1,1]==>[b,c,h,w]
  55.         outputs = x * inputs
  56.         return outputs

构造输入层，查看一次前向传播的输出结果，打印网络结构

  1. # 构造输入层 [b,c,h,w]==[4,32,16,16]
  2. inputs = torch.rand([4,32,16,16])
  3. # 获取输入图像的通道数
  4. in_channel = inputs.shape[1]
  5. # 模型实例化
  6. model = eca_block(in_channel=in_channel)
  7. # 前向传播
  8. outputs = model(inputs)
  9.  
  10. print(outputs.shape)  # 查看输出结果
  11. print(model)    # 查看网络结构
  12. stat(model, input_size=[32,16,16])  # 查看网络参数

网络的参数量如下：

  1.       module name  input shape output shape  params memory(MB) MAdd Flops  MemRead(B)  MemWrite(B) duration[%]  MemR+W(B)
  2. 0        avg_pool   32  16  16   32   1   1     0.0       0.00  0.0   0.0         0.0          0.0       0.00%        0.0
  3. 1            conv        1  32        1  32     3.0       0.00  0.0   0.0         0.0          0.0       0.00%        0.0
  4. 2         sigmoid        1  32        1  32     0.0       0.00  0.0   0.0         0.0          0.0       0.00%        0.0
  5. total                                           3.0       0.00  0.0   0.0         0.0          0.0       0.00%        0.0
  6. =========================================================================================================================
  7. Total params: 3
  8. -------------------------------------------------------------------------------------------------------------------------
  9. Total memory: 0.00MB
  10. Total MAdd: 0MAdd
  11. Total Flops: 0Flops
  12. Total MemR+W: 0B

CBAM 注意力机制

CBAM注意力机制是由通道注意力机制（channel）和空间注意力机制（spatial）组成。

传统基于卷积神经网络的注意力机制更多的是关注对通道域的分析，局限于考虑特征图通道之间的作用关系。CBAM从 channel 和 spatial 两个作用域出发，引入空间注意力和通道注意力两个分析维度，实现从通道到空间的顺序注意力结构。空间注意力可使神经网络更加关注图像中对分类起决定作用的像素区域而忽略无关紧要的区域，通道注意力则用于处理特征图通道的分配关系，同时对两个维度进行注意力分配增强了注意力机制对模型性能的提升效果。
 

通道注意力机制模块
CBAM中的通道注意力机制模块流程图如下。先将输入特征图分别进行全局最大池化和全局平均池化，对特征映射基于两个维度压缩，获得两张不同维度的特征描述。池化后的特征图共用一个多层感知器网络，先通过一个全连接层下降通道数，再通过另一个全连接恢复通道数。将两张特征图在通道维度堆叠，经过 sigmoid 激活函数将特征图的每个通道的权重归一化到0-1之间。将归一化后的权重和输入特征图相乘。
 

 

 代码实现：

  1. #（1）通道注意力机制
  2. class channel_attention(nn.Module):
  3.     # 初始化, in_channel代表输入特征图的通道数, ratio代表第一个全连接的通道下降倍数
  4.     def __init__(self, in_channel, ratio=4):
  5.         # 继承父类初始化方法
  6.         super(channel_attention, self).__init__()
  7.         
  8.         # 全局最大池化 [b,c,h,w]==>[b,c,1,1]
  9.         self.max_pool = nn.AdaptiveMaxPool2d(output_size=1)
  10.         # 全局平均池化 [b,c,h,w]==>[b,c,1,1]
  11.         self.avg_pool = nn.AdaptiveAvgPool2d(output_size=1)
  12.         
  13.         # 第一个全连接层, 通道数下降4倍
  14.         self.fc1 = nn.Linear(in_features=in_channel, out_features=in_channel//ratio, bias=False)
  15.         # 第二个全连接层, 恢复通道数
  16.         self.fc2 = nn.Linear(in_features=in_channel//ratio, out_features=in_channel, bias=False)
  17.         
  18.         # relu激活函数
  19.         self.relu = nn.ReLU()
  20.         # sigmoid激活函数
  21.         self.sigmoid = nn.Sigmoid()
  22.     
  23.     # 前向传播
  24.     def forward(self, inputs):
  25.         # 获取输入特征图的shape
  26.         b, c, h, w = inputs.shape
  27.         
  28.         # 输入图像做全局最大池化 [b,c,h,w]==>[b,c,1,1]
  29.         max_pool = self.max_pool(inputs)
  30.         # 输入图像的全局平均池化 [b,c,h,w]==>[b,c,1,1]
  31.         avg_pool = self.avg_pool(inputs)
  32.  
  33.         # 调整池化结果的维度 [b,c,1,1]==>[b,c]
  34.         max_pool = max_pool.view([b,c])
  35.         avg_pool = avg_pool.view([b,c])
  36.  
  37.         # 第一个全连接层下降通道数 [b,c]==>[b,c//4]
  38.         x_maxpool = self.fc1(max_pool)
  39.         x_avgpool = self.fc1(avg_pool)
  40.  
  41.         # 激活函数
  42.         x_maxpool = self.relu(x_maxpool)
  43.         x_avgpool = self.relu(x_avgpool)
  44.         
  45.         # 第二个全连接层恢复通道数 [b,c//4]==>[b,c]
  46.         x_maxpool = self.fc2(x_maxpool)
  47.         x_avgpool = self.fc2(x_avgpool)
  48.         
  49.         # 将这两种池化结果相加 [b,c]==>[b,c]
  50.         x = x_maxpool + x_avgpool
  51.         # sigmoid函数权值归一化
  52.         x = self.sigmoid(x)
  53.         # 调整维度 [b,c]==>[b,c,1,1]
  54.         x = x.view([b,c,1,1])
  55.         # 输入特征图和通道权重相乘 [b,c,h,w]
  56.         outputs = inputs * x
  57.         
  58.         return outputs

空间注意力机制模块

CBAM中的空间注意力机制模块如下。对通道注意力机制的输出特征图进行空间域的处理。首先，对输入特征图在通道维度下做最大池化和平均池化，将池化后的两张特征图在通道维度堆叠。然后，使用 7*7 （或3*3、1*1）大小的卷积核融合通道信息，特征图的shape从 [b,2,h,w] 变成 [b,1,h,w]。最后，将卷积后的结果经过 sigmoid 函数对特征图的空间权重归一化，再将输入特征图和权重相乘。

 

  1. #（2）空间注意力机制
  2. class spatial_attention(nn.Module):
  3.     # 初始化，卷积核大小为7*7
  4.     def __init__(self, kernel_size=7):
  5.         # 继承父类初始化方法
  6.         super(spatial_attention, self).__init__()
  7.         
  8.         # 为了保持卷积前后的特征图shape相同，卷积时需要padding
  9.         padding = kernel_size // 2
  10.         # 7*7卷积融合通道信息 [b,2,h,w]==>[b,1,h,w]
  11.         self.conv = nn.Conv2d(in_channels=2, out_channels=1, kernel_size=kernel_size,
  12.                               padding=padding, bias=False)
  13.         # sigmoid函数
  14.         self.sigmoid = nn.Sigmoid()
  15.     
  16.     # 前向传播
  17.     def forward(self, inputs):
  18.         
  19.         # 在通道维度上最大池化 [b,1,h,w]  keepdim保留原有深度
  20.         # 返回值是在某维度的最大值和对应的索引
  21.         x_maxpool, _ = torch.max(inputs, dim=1, keepdim=True)
  22.         
  23.         # 在通道维度上平均池化 [b,1,h,w]
  24.         x_avgpool = torch.mean(inputs, dim=1, keepdim=True)
  25.         # 池化后的结果在通道维度上堆叠 [b,2,h,w]
  26.         x = torch.cat([x_maxpool, x_avgpool], dim=1)
  27.         
  28.         # 卷积融合通道信息 [b,2,h,w]==>[b,1,h,w]
  29.         x = self.conv(x)
  30.         # 空间权重归一化
  31.         x = self.sigmoid(x)
  32.         # 输入特征图和空间权重相乘
  33.         outputs = inputs * x
  34.         
  35.         return outputs

CBAM注意力机制

CBAM的总体流程图如下。输入特征图先经过通道注意力机制，将通道权重和输入特征图相乘后再送入空间注意力机制，将归一化后的空间权重和空间注意力机制的输入特征图相乘，得到最终加权后的特征图。

 

 完整代码展示：

  1. # ---------------------------------------------------- #
  2. # CBAM注意力机制
  3. # 结合了通道注意力机制和空间注意力机制
  4. # ---------------------------------------------------- #
  5.  
  6. import torch
  7. from torch import nn
  8. from torchstat import stat  # 查看网络参数
  9.  
  10. #（1）通道注意力机制
  11. class channel_attention(nn.Module):
  12.     # 初始化, in_channel代表输入特征图的通道数, ratio代表第一个全连接的通道下降倍数
  13.     def __init__(self, in_channel, ratio=4):
  14.         # 继承父类初始化方法
  15.         super(channel_attention, self).__init__()
  16.         
  17.         # 全局最大池化 [b,c,h,w]==>[b,c,1,1]
  18.         self.max_pool = nn.AdaptiveMaxPool2d(output_size=1)
  19.         # 全局平均池化 [b,c,h,w]==>[b,c,1,1]
  20.         self.avg_pool = nn.AdaptiveAvgPool2d(output_size=1)
  21.         
  22.         # 第一个全连接层, 通道数下降4倍
  23.         self.fc1 = nn.Linear(in_features=in_channel, out_features=in_channel//ratio, bias=False)
  24.         # 第二个全连接层, 恢复通道数
  25.         self.fc2 = nn.Linear(in_features=in_channel//ratio, out_features=in_channel, bias=False)
  26.         
  27.         # relu激活函数
  28.         self.relu = nn.ReLU()
  29.         # sigmoid激活函数
  30.         self.sigmoid = nn.Sigmoid()
  31.     
  32.     # 前向传播
  33.     def forward(self, inputs):
  34.         # 获取输入特征图的shape
  35.         b, c, h, w = inputs.shape
  36.         
  37.         # 输入图像做全局最大池化 [b,c,h,w]==>[b,c,1,1]
  38.         max_pool = self.max_pool(inputs)
  39.         # 输入图像的全局平均池化 [b,c,h,w]==>[b,c,1,1]
  40.         avg_pool = self.avg_pool(inputs)
  41.  
  42.         # 调整池化结果的维度 [b,c,1,1]==>[b,c]
  43.         max_pool = max_pool.view([b,c])
  44.         avg_pool = avg_pool.view([b,c])
  45.  
  46.         # 第一个全连接层下降通道数 [b,c]==>[b,c//4]
  47.         x_maxpool = self.fc1(max_pool)
  48.         x_avgpool = self.fc1(avg_pool)
  49.  
  50.         # 激活函数
  51.         x_maxpool = self.relu(x_maxpool)
  52.         x_avgpool = self.relu(x_avgpool)
  53.         
  54.         # 第二个全连接层恢复通道数 [b,c//4]==>[b,c]
  55.         x_maxpool = self.fc2(x_maxpool)
  56.         x_avgpool = self.fc2(x_avgpool)
  57.         
  58.         # 将这两种池化结果相加 [b,c]==>[b,c]
  59.         x = x_maxpool + x_avgpool
  60.         # sigmoid函数权值归一化
  61.         x = self.sigmoid(x)
  62.         # 调整维度 [b,c]==>[b,c,1,1]
  63.         x = x.view([b,c,1,1])
  64.         # 输入特征图和通道权重相乘 [b,c,h,w]
  65.         outputs = inputs * x
  66.         
  67.         return outputs
  68.  
  69. # ---------------------------------------------------- #
  70. #（2）空间注意力机制
  71. class spatial_attention(nn.Module):
  72.     # 初始化，卷积核大小为7*7
  73.     def __init__(self, kernel_size=7):
  74.         # 继承父类初始化方法
  75.         super(spatial_attention, self).__init__()
  76.         
  77.         # 为了保持卷积前后的特征图shape相同，卷积时需要padding
  78.         padding = kernel_size // 2
  79.         # 7*7卷积融合通道信息 [b,2,h,w]==>[b,1,h,w]
  80.         self.conv = nn.Conv2d(in_channels=2, out_channels=1, kernel_size=kernel_size,
  81.                               padding=padding, bias=False)
  82.         # sigmoid函数
  83.         self.sigmoid = nn.Sigmoid()
  84.     
  85.     # 前向传播
  86.     def forward(self, inputs):
  87.         
  88.         # 在通道维度上最大池化 [b,1,h,w]  keepdim保留原有深度
  89.         # 返回值是在某维度的最大值和对应的索引
  90.         x_maxpool, _ = torch.max(inputs, dim=1, keepdim=True)
  91.         
  92.         # 在通道维度上平均池化 [b,1,h,w]
  93.         x_avgpool = torch.mean(inputs, dim=1, keepdim=True)
  94.         # 池化后的结果在通道维度上堆叠 [b,2,h,w]
  95.         x = torch.cat([x_maxpool, x_avgpool], dim=1)
  96.         
  97.         # 卷积融合通道信息 [b,2,h,w]==>[b,1,h,w]
  98.         x = self.conv(x)
  99.         # 空间权重归一化
  100.         x = self.sigmoid(x)
  101.         # 输入特征图和空间权重相乘
  102.         outputs = inputs * x
  103.         
  104.         return outputs
  105.  
  106. # ---------------------------------------------------- #
  107. #（3）CBAM注意力机制
  108. class cbam(nn.Module):
  109.     # 初始化，in_channel和ratio=4代表通道注意力机制的输入通道数和第一个全连接下降的通道数
  110.     # kernel_size代表空间注意力机制的卷积核大小
  111.     def __init__(self, in_channel, ratio=4, kernel_size=7):
  112.         # 继承父类初始化方法
  113.         super(cbam, self).__init__()
  114.         
  115.         # 实例化通道注意力机制
  116.         self.channel_attention = channel_attention(in_channel=in_channel, ratio=ratio)
  117.         # 实例化空间注意力机制
  118.         self.spatial_attention = spatial_attention(kernel_size=kernel_size)
  119.     
  120.     # 前向传播
  121.     def forward(self, inputs):
  122.         
  123.         # 先将输入图像经过通道注意力机制
  124.         x = self.channel_attention(inputs)
  125.         # 然后经过空间注意力机制
  126.         x = self.spatial_attention(x)
  127.         
  128.         return x

查看网络结构

  1. # 构造输入层 [b,c,h,w]==[4,32,16,16]
  2. inputs = torch.rand([4,32,16,16])
  3. # 获取输入图像的通道数
  4. in_channel = inputs.shape[1]
  5. # 模型实例化
  6. model = cbam(in_channel=in_channel)
  7. # 前向传播
  8. outputs = model(inputs)
  9.  
  10. print(outputs.shape)  # 查看输出结果
  11. print(model)    # 查看网络结构
  12. stat(model, input_size=[32,16,16])  # 查看网络参数

查看模型参数量

  1.                       module name  input shape output shape  params memory(MB)      MAdd     Flops  MemRead(B)  MemWrite(B) duration[%]  MemR+W(B)
  2. 0      channel_attention.max_pool   32  16  16   32   1   1     0.0       0.00       0.0       0.0         0.0          0.0       0.00%        0.0
  3. 1      channel_attention.avg_pool   32  16  16   32   1   1     0.0       0.00       0.0       0.0         0.0          0.0      99.99%        0.0
  4. 2           channel_attention.fc1           32            8   256.0       0.00     504.0     256.0      1152.0         32.0       0.00%     1184.0
  5. 3           channel_attention.fc2            8           32   256.0       0.00     480.0     256.0      1056.0        128.0       0.00%     1184.0
  6. 4          channel_attention.relu            8            8     0.0       0.00       8.0       8.0        32.0         32.0       0.00%       64.0
  7. 5       channel_attention.sigmoid           32           32     0.0       0.00       0.0       0.0         0.0          0.0       0.00%        0.0
  8. 6          spatial_attention.conv    2  16  16    1  16  16    98.0       0.00  49,920.0  25,088.0      2440.0       1024.0       0.00%     3464.0
  9. 7       spatial_attention.sigmoid    1  16  16    1  16  16     0.0       0.00       0.0       0.0         0.0          0.0       0.00%        0.0
  10. total                                                         610.0       0.00  50,912.0  25,608.0         0.0          0.0      99.99%     5896.0
  11. ==================================================================================================================================================
  12. Total params: 610
  13. --------------------------------------------------------------------------------------------------------------------------------------------------
  14. Total memory: 0.00MB
  15. Total MAdd: 50.91KMAdd
  16. Total Flops: 25.61KFlops
  17. Total MemR+W: 5.76KB

欢迎点赞  收藏   加 关注

参考：

(59条消息) 【深度学习】(1) CNN中的注意力机制（SE、ECA、CBAM），附Pytorch完整代码_立Sir的博客-CSDN博客_se注意力机制

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/花生_TL007/article/detail/290830
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号