注意力机制学习（一）——通道注意力与pytorch案例

最新推荐文章于 2025-04-02 13:47:58 发布
最新推荐文章于 2025-04-02 13:47:58 发布
阅读量1.1w 收藏 123
点赞数 11
分类专栏： pytorch/神经网络 文章标签： 通道注意力机制 PyTorch 卷积神经网络 模型增强 自适应池化
本文为CSDN博主"呆萌的代Ma"原创文章，转载请注明博客链接：https://blog.csdn.net/weixin_35757704/
本文链接：https://blog.csdn.net/weixin_35757704/article/details/119924585
版权
本文详细介绍了通道注意力机制，并提供了两个PyTorch实现案例。第一个案例展示了如何单独使用通道注意力机制，第二个案例则将注意力机制整合到一个自定义模型中，用于增强模型的表示能力。通过训练数据的处理和模型的训练，展示了通道注意力在实际任务中的应用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

文章目录

一、通道注意力机制简介

下面的图形象的说明了通道注意力机制
在这里插入图片描述

二、通道注意力机制pytorch代码

通道注意力机制的pytorch代码如下：

import torch
import torch.nn as nn
import torch.utils.data as Data


class ChannelAttention(nn.Module):
    def __init__(self, in_planes, ratio=16):
        super(ChannelAttention, self).__init__()
        self.avg_pool = nn.AdaptiveAvgPool2d(1)
        self.max_pool = nn.AdaptiveMaxPool2d(1)

        self.fc1 = nn.Conv2d(in_planes, in_planes // ratio, 1, bias=False)
        self.relu1 = nn.ReLU()
        self.fc2 = nn.Conv2d(in_planes // ratio, in_planes, 1, bias=False)
        self.sigmoid = nn.Sigmoid()

    def forward(self, x): # x 的输入格式是：[batch_size, C, H, W]
        avg_out = self.fc2(self.relu1(self.fc1(self.avg_pool(x))))
        max_out = self.fc2(self.relu1(self.fc1(self.max_pool(x))))
        out = avg_out + max_out
        return self.sigmoid(out)

1. 单独使用通道注意力机制的小案例

import torch
import torch.nn as nn
import torch.utils.data as Data


class ChannelAttention(nn.Module):
    def __init__(self, in_planes, ratio=16):
        super(ChannelAttention, self).__init__()
        self.avg_pool = nn.AdaptiveAvgPool2d(1)
        self.max_pool = nn.AdaptiveMaxPool2d(1)

        self.fc1 = nn.Conv2d(in_planes, in_planes // ratio, 1, bias=False)
        self.relu1 = nn.ReLU()
        self.fc2 = nn.Conv2d(in_planes // ratio, in_planes, 1, bias=False)
        self.sigmoid = nn.Sigmoid()

    def forward(self, x):
        avg_out = self.fc2(self.relu1(self.fc1(self.avg_pool(x))))
        max_out = self.fc2(self.relu1(self.fc1(self.max_pool(x))))
        out = avg_out + max_out
        return self.sigmoid(out)


def get_total_train_data(H, W, C, class_count):
    """得到全部的训练数据，这里需要替换成自己的数据"""
    import numpy as np
    x_train = torch.Tensor(
        np.random.random((1000, H, W, C)))  # 维度是 [ 数据量, 高H, 宽W, 长C]
    y_train = torch.Tensor(
        np.random.randint(0, class_count, size=(1000, 1))).long()  # [ 数据量, 句子的分类], 这里的class_count=4，就是四分类任务
    return x_train, y_train


if __name__ == '__main__':
    # ================训练参数=================
    epochs = 100
    batch_size = 30
    output_class = 14
    H = 40
    W = 50
    C = 30
    # ================准备数据=================
    x_train, y_train = get_total_train_data(H, W, C, class_count=output_class)
    train_loader = Data.DataLoader(
        dataset=Data.TensorDataset(x_train, y_train),  # 封装进Data.TensorDataset()类的数据，可以为任意维度
        batch_size=batch_size,  # 每块的大小
        shuffle=True,  # 要不要打乱数据 (打乱比较好)
        num_workers=6,  # 多进程（multiprocess）来读数据
        drop_last=True,
    )
    # ================初始化模型=================
    model = ChannelAttention(in_planes=H)
    # ================开始训练=================
    for i in range(epochs):
        for seq, labels in train_loader:
            attention_out = model(seq)
            seq_attention_out = attention_out.squeeze()
            for i in range(seq_attention_out.size()[0]):
                print(seq_attention_out[i])

可以看到输出是：

tensor([0.4440, 0.5005, 0.5533, 0.4530, 0.5494, 0.5430, 0.4911, 0.5339, 0.4627,
        0.5182, 0.4940, 0.4497, 0.4544, 0.5337, 0.4663, 0.4333, 0.5343, 0.4335,
        0.4711, 0.4569, 0.4508, 0.4532, 0.5102, 0.4824, 0.5231, 0.5328, 0.5092,
        0.5567, 0.5075, 0.5520, 0.5588, 0.4344, 0.5577, 0.4408, 0.4539, 0.4891,
        0.4513, 0.4472, 0.4983, 0.4991], grad_fn=<SelectBackward>)
tensor([0.4444, 0.5005, 0.5530, 0.4533, 0.5491, 0.5427, 0.4911, 0.5337, 0.4630,
        0.5181, 0.4940, 0.4500, 0.4546, 0.5335, 0.4665, 0.4337, 0.5341, 0.4339,
        0.4713, 0.4572, 0.4511, 0.4535, 0.5101, 0.4825, 0.5229, 0.5326, 0.5092,
        0.5564, 0.5074, 0.5516, 0.5584, 0.4348, 0.5574, 0.4412, 0.4541, 0.4892,
        0.4516, 0.4475, 0.4983, 0.4991], grad_fn=<SelectBackward>)
.......

这个就是每个batch中，每层的权重，其中输入模型的size是[30, 40, 50, 30]，输出的attention_out的size是[30, 40, 1, 1]

2. 使用通道注意力机制的小案例

import torch
import torch.nn as nn
import torch.utils.data as Data


class ChannelAttention(nn.Module):
    def __init__(self, in_planes, ratio=16):
        super(ChannelAttention, self).__init__()
        self.avg_pool = nn.AdaptiveAvgPool2d(1)
        self.max_pool = nn.AdaptiveMaxPool2d(1)

        self.fc1 = nn.Conv2d(in_planes, in_planes // ratio, 1, bias=False)
        self.relu1 = nn.ReLU()
        self.fc2 = nn.Conv2d(in_planes // ratio, in_planes, 1, bias=False)
        self.sigmoid = nn.Sigmoid()

    def forward(self, x):
        avg_out = self.fc2(self.relu1(self.fc1(self.avg_pool(x))))
        max_out = self.fc2(self.relu1(self.fc1(self.max_pool(x))))
        out = avg_out + max_out
        return self.sigmoid(out)


class UseAttentionModel(nn.Module): # 这里可以随便定义自己的模型
    def __init__(self, H):
        super(UseAttentionModel, self).__init__()
        self.channel_attention = ChannelAttention(H)

    def forward(self, x):  # 反向传播
        attention_value = self.channel_attention(x)
        out = x.mul(attention_value) # 得到借助注意力机制后的输出
        return out


def get_total_train_data(H, W, C, class_count):
    """得到全部的训练数据，这里需要替换成自己的数据"""
    import numpy as np
    x_train = torch.Tensor(
        np.random.random((1000, H, W, C)))  # 维度是 [ 数据量, 高H, 宽W, 长C]
    y_train = torch.Tensor(
        np.random.randint(0, class_count, size=(1000, 1))).long()  # [ 数据量, 句子的分类], 这里的class_count=4，就是四分类任务
    return x_train, y_train


if __name__ == '__main__':
    # ================训练参数=================
    epochs = 100
    batch_size = 30
    output_class = 14
    H = 40
    W = 50
    C = 30
    # ================准备数据=================
    x_train, y_train = get_total_train_data(H, W, C, class_count=output_class)
    train_loader = Data.DataLoader(
        dataset=Data.TensorDataset(x_train, y_train),  # 封装进Data.TensorDataset()类的数据，可以为任意维度
        batch_size=batch_size,  # 每块的大小
        shuffle=True,  # 要不要打乱数据 (打乱比较好)
        num_workers=6,  # 多进程（multiprocess）来读数据
        drop_last=True,
    )
    # ================初始化模型=================
    model = UseAttentionModel(H)
    cross_loss = nn.CrossEntropyLoss()
    optimizer = torch.optim.Adam(model.parameters(), lr=0.001)  # 优化器
    model.train()
    # ================开始训练=================
    for i in range(epochs):
        for seq, labels in train_loader:
            attention_out = model(seq)
            print(attention_out.size())
            print(attention_out)
【深度学习中的注意力机制7】11种主流注意力机制112个创新研究paper+代码——通道注意力（Channel Attention）
985小水博的摸鱼日常
10-23 1845
【深度学习中的注意力机制7】11种主流注意力机制112个创新研究paper+代码——通道注意力（Channel Attention）
【PyTorch深度学习项目实战100例目录】项目详解 + 数据集 + 完整源码
热门推荐
CSDN 精品推荐
09-30 9万+
大家好，我是阿光。本专栏整理了《深度学习100例》，内包含了各种不同的深度学习项目，包含项目原理以及源码，每一个项目实例都附带有完整的代码+数据集。正在更新中~ ✨。
注意力机制汇总----(1)
qq_43043457的博客
01-18 1237
注意力机制详解----(1) 通道/空间
【Attention】CBAM通道空间注意力模块
weixin_59422604的博客
03-17 393
由于SEAttention只考虑了通道之间的相关性，而忽略了空间位置的重要性，通常空间结构是最重要的。因此，本文将通道注意力与空间注意力进行了串联，并在squeeze过程中使用了最大池化和平均池化。
自注意力与交叉注意力的PyTorch 简单实现
最新发布
XavierJ的博客
04-02 554
注意力机制允许模型在处理输入序列时自动聚焦于最相关的部分，从而增强建模能力。以 Transformer 为例，它通过注意力机制建立了序列中不同位置之间的信息关联。模块Query 来自Key/Value 来自典型应用当前输入当前输入BERT、GPT、自注意图像建模当前输入外部上下文编解码结构、跨模态、条件生成。
Pytorch 实现注意力机制
01-06
import math import torch import torch.nn as nn import os def file_name_walk(file_dir): for root, dirs, files in os.walk(file_dir): # print(root, root) # 当前目录路径 print(dirs, dirs) # 当前路径下所有子目录 print(files, files) # 当前路径下所有非目录子文件 file_name_walk(/home/kesci/input
PyTorch 通道/空间注意力机制
m0_38139098的博客
09-22 1万+
哈哈哈，这是我摘抄出来的… 通道注意力机制就是学习一个不同通道的加权系数，同时考虑到了所有区域 空间注意力机制就是学习整个画面不同区域的系数，同时考虑到了所有通道 class ChannelAttention(nn.Module): def __init__(self, in_planes, ratio=16): super(ChannelAttention, self).__init__() self.avg_pool = nn.AdaptiveAvgPool2d
pytorch注意力机制
一个学长的博客
04-14 3518
最近看了一篇大佬的注意力机制的文章然后自己花了一上午的时间把按照大佬的图把大佬提到的注意力机制都复现了一遍，大佬有一些写的复杂的网络我按照自己的理解写了几个简单的版本接下来就放出我写的代码。顺便从大佬手里盗走一些图片，等我有时间一起进行替换，在此特别鸣谢这位大佬。
通道注意力+像素注意力 pytorch实现
ResumeProject的博客
08-20 2002
代码】通道注意力+像素注意力 pytorch实现。
一种空间和通道注意力模块pytorch复现
qq_39351946的博客
12-09 1941
自己在查阅文献的时候，发现了这篇文章，觉得里面提到的SCA和CCA模块很有意思，自己尝试复现出来了，即插即用的模块，用在我的方法中，提点很明显。 import torch from torchvision import models import torch.nn as nn import math import torch.utils.model_zoo as model_zoo from torch.nn import functional as F import warnings class SCA
深度学习PyTorch中基于SimAM注意力机制的图像分类Swin Transformer模型优化与实现
02-23
作者定义了一个自适应注意力机制——SimpleAdaptiveMethod（简称为SimAM），它不引入额外的参数或复杂的数学计算便能提升模型表现。接着实现了create_model函数，可以根据用户指定的模型型号创建预训练权重加载过的...
CVPR2021注意力机制——Coordinate Attention || Pytorch代码实现
qq_42962681的博客
04-12 7242
即插即用！CoordAttention简单灵活且高效，可以插入经典的轻量级网络在几乎不带来额外计算开销的前提下，提升网络的精度。实验表明，CoordAttention不仅仅对于分类任务有不错的提高，对目标检测、实例分割这类密集预测的任务，效果提升更加明显。
Python实现基于TCN-selfAttention自注意力机制结合时间卷积神经网络多变量时间序列预测的详细项目实例（含完整的程序，GUI设计和代码详解）
03-23
内容概要：本文档详细介绍了一个基于TCN（时间卷积神经网络）和自注意力机制（Self-Attention）的多变量时间序列预测项目的全过程，旨在解决传统方法存在的缺陷并在工业领域实现高精度预测。文中首先阐述了背景和...
SAttention：一种基于自注意力机制的YOLOv8轻量化检测头，提升目标检测与多任务学习【附核心代码】
一键难忘的博客
02-08 2393
轻量化：保持较低的计算成本，适应资源有限的设备。高效的多任务学习能力：能够适应目标检测、实例分割、关键点检测（Pose Estimation）等多种计算机视觉任务。增强特征学习能力：通过引入选择性注意力机制，自动选择与任务最相关的特征进行学习，从而提高精度。本文深入探讨了基于YOLOv8模型的最新改进——自研轻量化检测头SAttention，并详细介绍了其在目标检测、实例分割、和姿态估计等多任务学习中的应用。
Pytorch通道注意力和空间注意力代码
mainzld的博客
12-25 686
请依据自身需要进行更改：代码可以直接运行。
pytorch—实现各种注意力
m0_47005029的博客
07-08 5817
所谓Attention机制，便是聚焦于局部信息的机制，比如图像中的某一个图像区域。随着任务的变化，注意力区域往往会发生变化。面对上面这样的一张图，如果你只是从整体来看，只看到了很多人头，但是你拉近一个一个仔细看就了不得了，都是天才科学家。图中除了人脸之外的信息其实都是无用的，也做不了什么任务，Attention机制便是要找到这些最有用的信息，可以想见最简单的场景就是从照片中检测人脸了。注意力机制的核心重点就是让网络关注到它更需要关注的地方。
注意力机制论文:CBAM: Convolutional Block Attention Module及其PyTorch实现
mingo_敏
02-26 1万+
CBAM: Convolutional Block Attention Module PDF: https://arxiv.org/pdf/1807.06521.pdf PyTorch代码: https://github.com/shanglianlm0525/PyTorch-Networks PyTorch代码:
pytorch attention 注意力
jacke121的专栏
12-23 6760
pytorch attention   https://github.com/szagoruyko/attention-transfer   这也是一个例子： https://blog.csdn.net/uhauha2929/article/details/81951760
轻量级channel-attention代码 pytorch
Vertira的博客
11-17 866
轻量级channel-attention代码 pytorch
yolo通道注意力机制代码
01-06
### YOLO 模型中通道注意力机制的实现 在YOLO模型中加入通道注意力机制可以有效增强特征表达能力，从而改善目标检测的效果。对于混合局部通道注意力机制（MLCA），其核心在于融合了通道信息和空间信息，并兼顾局部与全局特性来优化特征图。 以下是基于Python编写的简化版MLCA模块代码示例： ```python import torch import torch.nn as nn class MLCA(nn.Module): def __init__(self, channel, reduction=16): super(MLCA, self).__init__() # 定义卷积层用于提取局部特征 self.local_conv = nn.Conv2d(channel, channel, kernel_size=3, padding=1, groups=channel) # 全局平均池化获取全局上下文信息 self.global_avg_pool = nn.AdaptiveAvgPool2d(1) # MLP结构处理通道维度上的特征向量 self.fc = nn.Sequential( nn.Linear(channel, channel // reduction), nn.ReLU(inplace=True), nn.Linear(channel // reduction, channel), nn.Sigmoid() ) def forward(self, x): b, c, _, _ = x.size() # 获取局部特征表示 local_feature = self.local_conv(x).mean(dim=(2, 3), keepdim=False) # 计算全局描述子 global_descriptor = self.global_avg_pool(x).view(b,c) # 将两者相加并送入MLP得到权重系数 weight = self.fc(local_feature + global_descriptor).view(b, c, 1, 1) return x * weight.expand_as(x) if __name__ == '__main__': input_tensor = torch.randn((8, 512, 7, 7)) mlca_module = MLCA(channel=512) output_tensor = mlca_module(input_tensor) print(output_tensor.shape) ``` 此段代码定义了一个名为`MLCA` 的类，它继承自 `torch.nn.Module`. 这个类实现了混合局部通道注意力机制的功能[^1]. 需要注意的是，在实际应用到YOLOv11或其他版本时还需要考虑具体架构特点做适当调整.
评论 12
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

呆萌的代Ma

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值