语义分割注意力机制SE模块tensorflow代码实现

最新推荐文章于 2025-10-17 12:33:32 发布
原创 最新推荐文章于 2025-10-17 12:33:32 发布 · 4.9k 阅读 · 51 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#深度学习 #卷积神经网络 #tensorflow

部署运行你感兴趣的模型镜像

介绍

Spatial Squeeze and Channel Excitation Block

在这里插入图片描述
在这里插入图片描述

from tensorflow import keras
from tensorflow.keras import layers
import tensorflow.keras.backend as K
import tensorflow as tf


def normal_conv2d(x, kernel_size, filters, strides, activation='relu', Separable=False):
    """
    卷积模块
    :param x: 输入数组[b, w, h, filter]
    :param kernel_size: 卷积尺寸
    :param filters: 卷积核数量
    :param strides: 卷积步长
    :param Separable: 是否使用可分离卷积
    :param coord_conv2d: 是否使用坐标卷积
    :param activation: 激活函数
    :return: 输出数组[b, w, h, filters]
    """
    if Separable:
        x = layers.SeparableConv2D(kernel_size=kernel_size, filters=filters, strides=strides, padding='same')(x)
    else:
		x = layers.Conv2D(kernel_size=kernel_size, filters=filters, strides=strides, padding='same')(x)
    x = layers.BatchNormalization()(x)
    x = layers.Activation(activation)(x)

    return x


def CAttention(x, channel):
    x_origin = x
    x = layers.GlobalAveragePooling2D()(x)
    x = K.expand_dims(x, axis=1)
    x = K.expand_dims(x, axis=1)
    x = normal_conv2d(x=x, strides=1, kernel_size=1, filters=channel//2, activation='relu')
    x = normal_conv2d(x=x, strides=1, kernel_size=1, filters=channel, activation='sigmoid')
    x = layers.UpSampling2D(size=(x_origin.shape[1], x_origin.shape[2]), interpolation='nearest')(x)
    x = tf.multiply(x, x_origin)

    return x

Channel Squeeze and Spatial Excitation Block

在这里插入图片描述

def SAttention(x):
    x_origin = x
    x = normal_conv2d(x=x, strides=1, kernel_size=1, filters=1, activation='sigmoid')
    x = tf.multiply(x, x_origin)

    return x

Spatial and Channel Squeeze & Excitation Block (scSE)

在这里插入图片描述

def SCAttention(x, channel):
    x1 = CAttention(x, channel)
    x2 = SAttention(x)
    x = layers.Add()([x1, x2])

    return x

模型代码示例

"""
SCAttentionNet: with attention
Author: XG_hechao
Begin Date: 20201113
End Date:
"""
from tensorflow import keras
from tensorflow.keras import layers
import tensorflow.keras.backend as K
from CoordConv2 import Coord_Conv2d
import tensorflow as tf


def Channel_Split(x):
    """
    通道划分
    :param x: 输入数组[b, w, h, filters]
    :return: 两个数组[b, w, h, 0：filters/2]和[b, w, h, filters/2：]
    """
    channel_before = x.shape.as_list()[1:]  # 取通道数
    split_channel_num = channel_before[2] // 2  # 取一半通道
    channel_one = x[:, :, :, 0:split_channel_num]  # 取前一半通道
    channel_two = x[:, :, :, split_channel_num:]  # 取后一半通道
    return channel_one, channel_two


def Channel_Shuffle(x):
    """
    通道洗牌
    :param x: 输入数组[b, w, h, filters]
    :return: 输出数组[b, w, h, filters_new]
    """
    height, width, channels = x.shape.as_list()[1:]  # 取通道数
    channels_per_split = channels // 2  # 取一半
    x = K.reshape(x, [-1, height, width, 2, channels_per_split])  # 将n维打乱为[2, n/2]维
    x = K.permute_dimensions(x, (0, 1, 2, 4, 3))  # 维度重排序
    x = K.reshape(x, [-1, height, width, channels])  # 通道重组  [2, n/2]--->n
    return x


def branch(x, filters, dilation_rate, unit_num, right=False):
    """
    卷积分支
    :param x: 输入数组[b, w, h, filter]
    :param filters: 卷积核数量
    :param dilation_rate: 扩张卷积率
    :param unit_num: int
    :param right: 分支卷积方式， False为使用右侧卷积方式
    :return: 输出数组[b, w, h, filters]
    """
    if right:

        x = layers.Conv2D(filters=filters, kernel_size=(3, 1), padding='same', strides=1)(x)  # 卷积
        x = layers.Activation('relu')(x)  # 激活

        x = layers.Conv2D(filters=filters, kernel_size=(1, 3), padding='same', strides=1)(x)
        x = layers.BatchNormalization()(x)  # BN归一化
        x = layers.Activation('relu')(x)

        x = layers.Conv2D(filters=filters, kernel_size=(3, 1), padding='same', strides=1, dilation_rate=dilation_rate,
                          name='dilation_conv2d_right_{0}_1_{1}'.format(unit_num, dilation_rate))(x)
        x = layers.Activation('relu')(x)

        x = layers.Conv2D(filters=filters, kernel_size=(1, 3), padding='same', strides=1, dilation_rate=dilation_rate,
                          name='dilation_conv2d_right_{0}_2_{1}'.format(unit_num, dilation_rate*2))(x)
        x = layers.BatchNormalization()(x)
        x = layers.Activation('relu')(x)

    else:
        x = layers.Conv2D(filters=filters, kernel_size=(1, 3), padding='same', strides=1)(x)
        x = layers.Activation('relu')(x)

        x = layers.Conv2D(filters=filters, kernel_size=(3, 1), padding='same', strides=1)(x)
        x = layers.BatchNormalization()(x)
        x = layers.Activation('relu')(x)

        x = layers.Conv2D(filters=filters, kernel_size=(1, 3), padding='same', strides=1, dilation_rate=dilation_rate,
                          name='dilation_conv2d_left_{0}_1_{1}'.format(unit_num, dilation_rate))(x)
        x = layers.Activation('relu')(x)

        x = layers.Conv2D(filters=filters, kernel_size=(3, 1), padding='same', strides=1, dilation_rate=dilation_rate,
                          name='dilation_conv2d_left_{0}_2_{1}'.format(unit_num, dilation_rate*2))(x)
        x = layers.BatchNormalization()(x)
        x = layers.Activation('relu')(x)

    return x


def split_shuffle_module(x, filters, unit_num, dilation_rate_value):
    """
    卷积通道分离、打乱模块
    :param x: 输入数组[b, w, h, filter]
    :param filters: 卷积核数量
    :param unit_num: 循环单元数
    :param dilation_rate_value: 扩张卷积率
    :return: 输出数组[b, w, h, filters]
    """
    for i in range(unit_num):
        # if len(dilation_rate_value) is not 1:
        dilation_rate = dilation_rate_value[i]
        # else:
        #     dilation_rate = dilation_rate_value
        add = x
        x_one, x_two = Channel_Split(x)  # 函数调用
        x_one = branch(x_one, filters=filters//2, dilation_rate=dilation_rate, unit_num=i, right=True)  # 函数调用
        x_two = branch(x_two, filters=filters//2, dilation_rate=dilation_rate, unit_num=i, right=False)
        x = layers.Concatenate()([x_one, x_two])  # 通道叠加
        x = layers.Add()([add, x])  # 元素相加
        x = layers.Activation('relu')(x)
        x = Channel_Shuffle(x)  # 函数调用

    return x


def normal_conv2d(x, kernel_size, filters, strides, activation='relu', Separable=False, coord_conv2d=False):
    """
    卷积模块
    :param x: 输入数组[b, w, h, filter]
    :param kernel_size: 卷积尺寸
    :param filters: 卷积核数量
    :param strides: 卷积步长
    :param Separable: 是否使用可分离卷积
    :param coord_conv2d: 是否使用坐标卷积
    :param activation: 激活函数
    :return: 输出数组[b, w, h, filters]
    """
    if Separable:
        x = layers.SeparableConv2D(kernel_size=kernel_size, filters=filters, strides=strides, padding='same')(x)
    else:
        if coord_conv2d:
            x = layers.Conv2D(kernel_size=kernel_size, filters=filters, strides=strides, padding='same')(x)
            x = Coord_Conv2d(x)
            x = layers.Conv2D(kernel_size=kernel_size, filters=filters, strides=1, padding='same')(x)
        else:
            x = layers.Conv2D(kernel_size=kernel_size, filters=filters, strides=strides, padding='same')(x)
    x = layers.BatchNormalization()(x)
    x = layers.Activation(activation)(x)

    return x


def upsample(x, kernel_size, filters, strides, coord_conv2d=False):
    """
    上采样模块
    :param x: 输入数组[b, w, h, filter]
    :param kernel_size: 卷积尺寸
    :param filters: 卷积核数量
    :param strides: 卷积步长
    :param coord_conv2d: 是否使用坐标卷积
    :return: 输出数组[b, w, h, filters]
    """
    if coord_conv2d:
        x = Coord_Conv2d(x)
        x = layers.Conv2DTranspose(kernel_size=kernel_size, filters=filters, strides=strides, padding='same')(x)
    else:
        x = layers.Conv2DTranspose(kernel_size=kernel_size, filters=filters, strides=strides, padding='same')(x)
    x = layers.BatchNormalization()(x)
    x = layers.Activation('relu')(x)

    return x


def CAttention(x, channel):
    x_origin = x
    x = layers.GlobalAveragePooling2D()(x)
    x = K.expand_dims(x, axis=1)
    x = K.expand_dims(x, axis=1)
    x = normal_conv2d(x=x, strides=1, kernel_size=1, filters=channel//2)
    x = normal_conv2d(x=x, strides=1, kernel_size=1, filters=channel, activation='sigmoid')
    x = layers.UpSampling2D(size=(x_origin.shape[1], x_origin.shape[2]), interpolation='nearest')(x)
    x = tf.multiply(x, x_origin)

    return x


def SAttention(x):
    x_origin = x
    x = normal_conv2d(x=x, strides=1, kernel_size=1, filters=1, activation='sigmoid')
    x = tf.multiply(x, x_origin)

    return x


def SCAttention(x, channel):
    x1 = CAttention(x, channel)
    x2 = SAttention(x)
    x = layers.Add()([x1, x2])

    return x


def Encoder(x):
    """
    编码器
    :param x: 输入数组[b, w, h, filter]
    :return: 输出数组[b, w, h, filter_new]
    """
    FF_layers = []
    x = normal_conv2d(x, 3, 32, 2, coord_conv2d=False)  # 函数调用
    x = split_shuffle_module(x, 32, 1, [2])  # 函数调用
    x = SCAttention(x, 32)
    FF_layers.append(x)

    x = normal_conv2d(x, 3, 64, 2, coord_conv2d=False)
    x = split_shuffle_module(x, 64, 1, [5])
    x = SCAttention(x, 64)
    FF_layers.append(x)

    x = normal_conv2d(x, 3, 128, 2, coord_conv2d=False)
    x = split_shuffle_module(x, 128, 1, [8])
    x = SCAttention(x, 128)
    FF_layers.append(x)

    x = normal_conv2d(x, 3, 256, 2, Separable=True)

    return x, FF_layers


def Decoder(x, num_classes, FF_layers):
    x = layers.UpSampling2D(size=2, interpolation='bilinear')(x)
    x = layers.Concatenate()([x, FF_layers[2]])
    x = upsample(x, 3, num_classes, 2, coord_conv2d=False)
    x = layers.Concatenate()([x, FF_layers[1]])
    x = upsample(x, 3, num_classes, 2, coord_conv2d=False)
    x = layers.Concatenate()([x, FF_layers[0]])

    return x


def SCAttention_Net(input_size, num_classes):
    inputs = keras.Input(shape=input_size + (3,))

    x, FF_layers = Encoder(inputs)
    x = Decoder(x, num_classes, FF_layers)
    x = upsample(x=x, strides=2, kernel_size=3, filters=num_classes)
    outputs = layers.Conv2D(filters=num_classes, kernel_size=3, padding='same', activation='softmax')(x)

    models = keras.Model(inputs, outputs)

    return models


if __name__ == '__main__':
    model = SCAttention_Net((512, 512), 5)
    model.summary()
    #keras.utils.plot_model(model, dpi=96, to_file='./SCAttention_Net.png', show_shapes=True)

import 的coord_conv2d.py

import tensorflow.keras.backend as K


def Coord_Conv2d(inputs, radius=False):
    input_shape = K.shape(inputs)
    input_shape = [input_shape[i] for i in range(4)]
    batch_shape, dim1, dim2, channels = input_shape

    xx_ones = K.ones(K.stack([batch_shape, dim2]), dtype='int32')  # 创建[batch_size, dim2]大小的空数组
    xx_ones = K.expand_dims(xx_ones, axis=-1)  # 扩维至[batch_size, dim2, 1]，例：[4,128,1]

    xx_range = K.tile(K.expand_dims(K.arange(0, dim1), axis=0),
                      K.stack([batch_shape, 1]))  # K.tile 复制数组，K.tile(shape([128,1],shape([4,1)) = shape[4,128]
    xx_range = K.expand_dims(xx_range, axis=1)  # 从[4,128]扩维至[4,1,128]
    xx_channels = K.batch_dot(xx_ones, xx_range, axes=[2, 1])  # 矩阵乘[4,128,1]*[4,1,128]=[4,128,128]
    xx_channels = K.expand_dims(xx_channels, axis=-1)  # [4,128,128,1]
    xx_channels = K.permute_dimensions(xx_channels, [0, 2, 1, 3])  # 交换维度 [4,128,128,1]

    yy_ones = K.ones(K.stack([batch_shape, dim1]), dtype='int32')
    yy_ones = K.expand_dims(yy_ones, axis=1)

    yy_range = K.tile(K.expand_dims(K.arange(0, dim2), axis=0),
                      K.stack([batch_shape, 1]))
    yy_range = K.expand_dims(yy_range, axis=-1)

    yy_channels = K.batch_dot(yy_range, yy_ones, axes=[2, 1])
    yy_channels = K.expand_dims(yy_channels, axis=-1)
    yy_channels = K.permute_dimensions(yy_channels, [0, 2, 1, 3])

    xx_channels = K.cast(xx_channels, K.floatx())  # int--->float
    xx_channels = xx_channels / K.cast(dim1 - 1, K.floatx())
    xx_channels = (xx_channels * 2) - 1.

    yy_channels = K.cast(yy_channels, K.floatx())
    yy_channels = yy_channels / K.cast(dim2 - 1, K.floatx())
    yy_channels = (yy_channels * 2) - 1.

    outputs = K.concatenate([inputs, xx_channels, yy_channels], axis=-1)

    if radius:
        radius_layer = K.sqrt(K.square(xx_channels-0.5) + K.square(yy_channels-0.5))
        outputs = K.concatenate([outputs, radius_layer], axis=-1)
    return outputs


if __name__ == '__main__':
    x = K.ones([4, 32, 32, 3])
    x = Coord_Conv2d(x)
    print(x.shape)

您可能感兴趣的与本文相关的镜像

TensorFlow-v2.15

TensorFlow-v2.15

TensorFlow

TensorFlow 是由Google Brain 团队开发的开源机器学习框架,广泛应用于深度学习研究和生产环境。 它提供了一个灵活的平台,用于构建和训练各种机器学习模型

结合全局注意力机制的实时语义分割网络
罗伯特技术屋
12-02 1067
针对轻量化网络结构从特征图提取有效语义信息不足，以及语义信息与空间细节信息融合模块设计不合理而导致分割精度降低的问题，本文提出一种结合全局注意力机制的实时语义分割网络(global attention mechanism with real time semantic segmentation network ,GaSeNet)。首先在双分支结构的语义分支中引入全局注意力机制，在通道与空间两个维度引导卷积神经网来关注与分割任务相关的语义类别，以提取更多有效语义信息；
【YOLO】添加注意力机制（SE、CBAM、ECA、CA）
m0_37556124的博客
07-20 4267
注意力机制（attention mechanism）受人类视觉机制的研究，让网络学习更关注的特征。注意力机制主要有：自注意力(self-attention)、软注意力（soft-attention）、硬注意力(hard-attention)。其已经广泛应用于分类、检测、分割等任务。在models/common.py中注册SE模块以上就是今天要讲的内容，体验了使用yolov5进行推理的过程中加入不同的注意力模块，从而提高目标检测准确度，当然注意力种类繁多，也可以尝试排列组合使用，如上C3SE和C3CA。
注意力机制可视化_语义分割 注意力模块(1)
weixin_39681161的博客
12-03 1601
最近英伟达的团队提出了一个语义分割的新的注意力模块论文地址：https://arxiv.org/abs/2005.10821代码地址：未开源这算一篇比较新的关于语义分割的attention模块，在类似Cityscape等多个数据集上都取得了最好的效果，并且针对于注意力机制的引入，相对于其他的方法，大大降低了其算力开销，可惜的代码还未开源。为了方便，在本文中我们将文章中的hierarchical m...
什么是 SE 模块：经典的通道注意力机制
最新发布
彬彬侠的博客
10-17 1180
SE模块(Squeeze-and-Excitation Module)是计算机视觉中的一种轻量级通道注意力机制，由2017年提出的SENet首次引入。该模块通过压缩（Squeeze）和激励（Excitation）两个步骤动态学习通道权重，强化重要特征通道，抑制无关通道。其核心是全局平均池化获取通道统计信息，再通过全连接层生成注意力权重，实现高效的特征校准。典型应用包括提升ResNet、MobileNet等模型的分类准确率，在图像分类、目标检测等任务中表现优异。
Attention(注意力机制代码)
07-16
Attention.zip文件中总结了几种关于注意力机制的代码，有keras和tensorflow，还有PyTorch框架的
注意力机制 SE-Net 原理与 TensorFlow2.0 实现
“365天深度学习训练营”报名进行中～
06-06 5125
SENet 是 ImageNet 2017（ImageNet 收官赛）的冠军模型，是由WMW团队发布。具有复杂度低，参数少和计算量小的优点。且SENet 思路很简单，很容易扩展到已有网络结构如 Inception 和 ResNet 中。已经有很多工作在空间维度上来提升网络的性能，如 Inception 等，而 SENet 将关注点放在了特征通道之间的关系上。其具体策略为：通过学习的方式来自动获取到每个特征通道的重要程度，然后依照这个重要程度去提升有用的特征并抑制对当前任务用处不大的特征，这又叫做“特征重标定
注意力机制——SEnet 代码实现及解释(Tensorflow and Pytorch)
m0_71995775的博客
07-26 1509
Squeeze-and-Excitation Networks（挤压和激励网络）是一种通道注意力机制，类似一个小插件嵌入在深度学习网络中，通过对不同通道的权重重新标定来实现对重要信息的注意。PS：简单来说通过卷积得到的特征图就是所谓的通道，通道数量就是卷积层的过滤器数量。我们通过结合下面的图像来理解SE的工作原理,以三维为例子进行解释，二维同样适用。心急的小伙伴可以直接划到下方使用代码哦。1.在图的上方D×H×W×C是输入数据的形状，分别为深度×高度×宽度×通道数，二维则没有深度；
语义分割模型 注意力模块Attention（学习笔记）
m0_64931337的博客
01-17 1986
深度学习入门：注意力机制的理解
基于Keras实现CBAM注意力机制的卷积模块
该项目不仅实现了 CBAM 模块本身，还集成了 SE（Squeeze-and-Excitation）模块作为对比实验的一部分，使得研究人员和开发者可以在相同的训练环境下比较不同注意力机制对模型性能的影响。这种设计极大地方便了对注意...
图像处理源码-多尺度空间注意力的语义分割
07-07
在图像处理领域，多尺度空间注意力机制是一种先进的技术，它被广泛应用于语义分割任务中。语义分割是计算机视觉中的一个关键问题，其目标是将图像中的每个像素分配到预定义的类别中，比如人、车、建筑物等。这个过程...
语义分割模型底层实现与图像处理流水线集成
qq_40552871的博客
04-09 1071
语义分割模型的架构设计是实现精准图像分割的基础。当前，卷积神经网络（CNN）是语义分割模型的主流架构选择。以 U-Net 为例，其采用对称的 U 形结构，包含编码器和解码器两部分。编码器通过卷积和池化操作逐步提取图像的高层语义特征，同时降低特征图的空间分辨率；解码器则通过上采样和卷积操作逐步恢复图像的空间分辨率，并融合来自编码器的特征，以实现像素级别的分类。U-Net 在医学图像分割领域取得了显著效果，其分割精度可达 90%以上，这得益于其能够很好地捕捉图像的局部和全局特征。
将SE模块与密集连接网络结合的代码
05-07
主要是将SE模块融合到密集连接模块，并使用共享显存的方式减少显存的大小。
SE
03-16
东南
注意力机制 ECA-Net 学习记录
chen_znn的博客
09-06 4360
一种即插即用的注意力机制
【Semantic Segmentation】语义分割综述 -- Attention
Arron_hou的博客
09-20 2894
【Semantic Segmentation】语义分割综述 -- AttentionAttention[Attention U-Net] Learning Where to Look for the Pancreas（ MIDL 2018）[PAN] Pyramid Attention Network for Semantic Segmentation (BMVC 2018)[PSANet] Po...
基于注意力的语义分割之PSANet、DANet、OCNet、CCNet、EMANet、SANet等
热门推荐
迷路的咸鱼的博客
10-15 1万+
注意力机制（Attention Mechanism）如今被广泛使用在自然语言处理、图像识别等各种不同类型的深度学习任务中，是深度学习技术中值得关注与深入了解的核心技术之一。对注意力机制的研究动机是受到人脑注意力的启发，人脑可以快速地从视觉信号中选择需要关注的区域，即注意力焦点。因此，在观察图像时，人类会根据之前观察的图像学习到未来要观察图像时注意力应该集中的位置，同时给予周围图像区域较低的注意力，而不是一次读取整幅图像的所有像素，并且随着时间推移调整焦点。
【tf学习笔记2】tensorflow2.3张量中None占位符问题-搭建注意力模块SE-Net
qq_53383206的博客
12-30 737
tensorflow2.3keras搭建SE-Net遇到问题。 与reshape中的None占位符有关。Failed to convert object of type to Tensor.
注意力机制的介绍
吃葡萄不吐葡萄皮
05-02 1万+
具体来说，模型可以使用卷积神经网络（Convolutional Neural Network，CNN）从图片中提取特征，然后通过一个全连接神经网络（Fully Connected Network，FCN）来计算每个特征的注意力权重，从而给予不同的关注程度。在图像分类任务中，可以将空间注意力应用于卷积层的输出上，从而得到更准确的特征表示。在硬注意力中，模型不再给出一个连续的加权平均，而是在每个时间步显式地选择图片中的一个区域，这个区域可以是整张图片的一个局部区域，也可以是图片中的一个特定物体或区域。
用于一维序列（1D）的SE Block的Tensorflow实现
Ben出没冇注意的博客
01-29 3126
注意力机制
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值