【图像分类】用最简短的代码复现SeNet，小白一定要收藏（keras，Tensorflow2

2401_84138927

于 2024-04-12 07:43:19 发布

阅读量744

点赞数 25

分类专栏： 2024年程序员学习文章标签：分类 keras tensorflow

本文链接：https://blog.csdn.net/2401_84138927/article/details/137664016

版权

2024年程序员学习专栏收录该内容

126 篇文章 1 订阅

订阅专栏

本文详细介绍了SENet中的关键操作，如卷积、Squeeze、Excitation等，特别关注了如何通过SE模块在ResNet中实现特征权重学习。文章还提供了SE-ResNet的具体代码实现，展示了如何在不同深度的网络结构中嵌入这种注意力机制。

摘要由CSDN通过智能技术生成

那么这个 $F_{tr}$ )的公式就是下面的公式1（卷积操作， $V_{c}$ )表示第c个卷积核， $X^{s}$ )表示第s个输入）。

$F_{tr}$ )得到的U就是Figure1中的左边第二个三维矩阵，也叫tensor，或者叫C个大小为H*W的feature map。而uc表示U中第c个二维矩阵，下标c表示channel。

接下来就是Squeeze操作，公式非常简单，就是一个global average pooling:

因此公式2就将H*W*C的输入转换成1*1*C的输出，对应Figure1中的Fsq操作。为什么会有这一步呢？这一步的结果相当于表明该层C个feature map的数值分布情况，或者叫全局信息。

再接下来就是Excitation操作，如公式3。直接看最后一个等号，前面squeeze得到的结果是z，这里先用W1乘以z，就是一个全连接层操作，W1的维度是C/r * C，这个r是一个缩放参数，在文中取的是16，这个参数的目的是为了减少channel个数从而降低计算量。又因为z的维度是1*1*C，所以W1z的结果就是1*1*C/r；然后再经过一个ReLU层，输出的维度不变；然后再和W2相乘，和W2相乘也是一个全连接层的过程，W2的维度是C*C/r，因此输出的维度就是1*1*C；最后再经过sigmoid函数，得到s：

也就是说最后得到的这个s的维度是1*1*C，C表示channel数目。这个s其实是本文的核心，它是用来刻画tensor U中C个feature map的权重。而且这个权重是通过前面这些全连接层和非线性层学习得到的，因此可以end-to-end训练。这两个全连接层的作用就是融合各通道的feature map信息，因为前面的squeeze都是在某个channel的feature map里面操作。

在得到s之后，就可以对原来的tensor U操作了，就是下面的公式4。也很简单，就是channel-wise multiplication，什么意思呢？ $u_{c}$ )是一个二维矩阵， $s_{c}$ )是一个数，也就是权重，因此相当于把 $u_{c}$ )矩阵中的每个值都乘以 $s_{c}$ )。对应Figure1中的Fscale。

========================================================================================================

SENet 在具体网络中应用（代码实现SE_ResNet）

==============================

介绍完具体的公式实现，下面介绍下SE block怎么运用到具体的网络之中。

上图是将 SE 模块嵌入到 Inception 结构的一个示例。方框旁边的维度信息代表该层的输出。

这里我们使用 global average pooling 作为 Squeeze 操作。紧接着两个 Fully Connected 层组成一个 Bottleneck 结构去建模通道间的相关性，并输出和输入特征同样数目的权重。我们首先将特征维度降低到输入的 1/16，然后经过 ReLu 激活后再通过一个 Fully Connected 层升回到原来的维度。这样做比直接用一个 Fully Connected 层的好处在于：

1）具有更多的非线性，可以更好地拟合通道间复杂的相关性；

2）极大地减少了参数量和计算量。然后通过一个 Sigmoid 的门获得 0~1 之间归一化的权重，最后通过一个 Scale 的操作来将归一化后的权重加权到每个通道的特征上。

除此之外，SE 模块还可以嵌入到含有 skip-connections 的模块中。上右图是将 SE 嵌入到 ResNet 模块中的一个例子，操作过程基本和 SE-Inception 一样，只不过是在 Addition 前对分支上 Residual 的特征进行了特征重标定。如果对 Addition 后主支上的特征进行重标定，由于在主干上存在 0~1 的 scale 操作，在网络较深 BP 优化时就会在靠近输入层容易出现梯度消散的情况，导致模型难以优化。

目前大多数的主流网络都是基于这两种类似的单元通过 repeat 方式叠加来构造的。由此可见，SE 模块可以嵌入到现在几乎所有的网络结构中。通过在原始网络结构的 building block 单元中嵌入 SE 模块，我们可以获得不同种类的 SENet。如 SE-BN-Inception、SE-ResNet、SE-ReNeXt、SE-Inception-ResNet-v2 等等。

本例通过实现SE-ResNet,来显示如何将SE模块嵌入到ResNet网络中。SE-ResNet模型如下图：

第一个残差模块

第一个残差模块用于实现ResNet18、ResNet34模型，SENet嵌入到第二个卷积的后面。

第一个残差模块

class BasicBlock(layers.Layer):

def init(self, filter_num, stride=1):

super(BasicBlock, self).init()

self.conv1 = layers.Conv2D(filter_num, (3, 3), strides=stride, padding=‘same’)

self.bn1 = layers.BatchNormalization()

self.relu = layers.Activation(‘relu’)

self.conv2 = layers.Conv2D(filter_num, (3, 3), strides=1, padding=‘same’)

self.bn2 = layers.BatchNormalization()

se-block

self.se_globalpool = keras.layers.GlobalAveragePooling2D()

self.se_resize = keras.layers.Reshape((1, 1, filter_num))

self.se_fc1 = keras.layers.Dense(units=filter_num // 16, activation=‘relu’,

use_bias=False)

self.se_fc2 = keras.layers.Dense(units=filter_num, activation=‘sigmoid’,

use_bias=False)

if stride != 1:

self.downsample = Sequential()

self.downsample.add(layers.Conv2D(filter_num, (1, 1), strides=stride))

else:

self.downsample = lambda x: x

def call(self, input, training=None):

out = self.conv1(input)

out = self.bn1(out)

out = self.relu(out)

out = self.conv2(out)

out = self.bn2(out)

se_block

b = out

out = self.se_globalpool(out)

out = self.se_resize(out)

out = self.se_fc1(out)

out = self.se_fc2(out)

out = keras.layers.Multiply()([b, out])

identity = self.downsample(input)

output = layers.add([out, identity])

output = tf.nn.relu(output)

return output

第二个残差模块

第二个残差模块用于实现ResNet50、ResNet101、ResNet152模型，SENet模块嵌入到第三个卷积后面。

第二个残差模块

class Block(layers.Layer):

def init(self, filters, downsample=False, stride=1):

super(Block, self).init()

self.downsample = downsample

self.conv1 = layers.Conv2D(filters, (1, 1), strides=stride, padding=‘same’)

self.bn1 = layers.BatchNormalization()

self.relu = layers.Activation(‘relu’)

self.conv2 = layers.Conv2D(filters, (3, 3), strides=1, padding=‘same’)

self.bn2 = layers.BatchNormalization()

self.conv3 = layers.Conv2D(4 * filters, (1, 1), strides=1, padding=‘same’)

self.bn3 = layers.BatchNormalization()

se-block

self.se_globalpool = keras.layers.GlobalAveragePooling2D()

self.se_resize = keras.layers.Reshape((1, 1, 4 * filters))

self.se_fc1 = keras.layers.Dense(units=4 * filters // 16, activation=‘relu’,

use_bias=False)

self.se_fc2 = keras.layers.Dense(units=4 * filters, activation=‘sigmoid’,

use_bias=False)

if self.downsample:

self.shortcut = Sequential()

self.shortcut.add(layers.Conv2D(4 * filters, (1, 1), strides=stride))

self.shortcut.add(layers.BatchNormalization(axis=3))

def call(self, input, training=None):

out = self.conv1(input)

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)

b = out

out = self.se_globalpool(out)

out = self.se_resize(out)

out = self.se_fc1(out)

out = self.se_fc2(out)

out = keras.layers.Multiply()([b, out])

if self.downsample:

shortcut = self.shortcut(input)

else:

shortcut = input

output = layers.add([out, shortcut])

output = tf.nn.relu(output)

return output

ResNet18、ResNet34模型的完整代码

import tensorflow as tf

from tensorflow import keras

from tensorflow.keras import layers, Sequential

第一个残差模块

class BasicBlock(layers.Layer):

def init(self, filter_num, stride=1):

super(BasicBlock, self).init()

self.conv1 = layers.Conv2D(filter_num, (3, 3), strides=stride, padding=‘same’)

self.bn1 = layers.BatchNormalization()

self.relu = layers.Activation(‘relu’)

self.conv2 = layers.Conv2D(filter_num, (3, 3), strides=1, padding=‘same’)

self.bn2 = layers.BatchNormalization()

se-block

self.se_globalpool = keras.layers.GlobalAveragePooling2D()

self.se_resize = keras.layers.Reshape((1, 1, filter_num))

self.se_fc1 = keras.layers.Dense(units=filter_num // 16, activation=‘relu’,

use_bias=False)

self.se_fc2 = keras.layers.Dense(units=filter_num, activation=‘sigmoid’,

use_bias=False)

if stride != 1:

self.downsample = Sequential()

self.downsample.add(layers.Conv2D(filter_num, (1, 1), strides=stride))

else:

self.downsample = lambda x: x

def call(self, input, training=None):

out = self.conv1(input)

out = self.bn1(out)

out = self.relu(out)

out = self.conv2(out)

out = self.bn2(out)

se_block

b = out

out = self.se_globalpool(out)

out = self.se_resize(out)

out = self.se_fc1(out)

out = self.se_fc2(out)

out = keras.layers.Multiply()([b, out])

identity = self.downsample(input)

output = layers.add([out, identity])

output = tf.nn.relu(output)

return output

class ResNet(keras.Model):

def init(self, layer_dims, num_classes=10):

super(ResNet, self).init()

预处理层

self.padding = keras.layers.ZeroPadding2D((3, 3))

self.stem = Sequential([

layers.Conv2D(64, (7, 7), strides=(2, 2)),

layers.BatchNormalization(),

layers.Activation(‘relu’),

layers.MaxPool2D(pool_size=(3, 3), strides=(2, 2), padding=‘same’)

])

resblock

self.layer1 = self.build_resblock(64, layer_dims[0])

self.layer2 = self.build_resblock(128, layer_dims[1], stride=2)

self.layer3 = self.build_resblock(256, layer_dims[2], stride=2)

self.layer4 = self.build_resblock(512, layer_dims[3], stride=2)

全局池化

self.avgpool = layers.GlobalAveragePooling2D()

全连接层

self.fc = layers.Dense(num_classes, activation=tf.keras.activations.softmax)

def call(self, input, training=None):

x= self.padding(input)

x = self.stem(x)

x = self.layer1(x)

x = self.layer2(x)

x = self.layer3(x)

x = self.layer4(x)

[b,c]

x = self.avgpool(x)

x = self.fc(x)

return x

def build_resblock(self, filter_num, blocks, stride=1):

res_blocks = Sequential()

res_blocks.add(BasicBlock(filter_num, stride))

for pre in range(1, blocks):

res_blocks.add(BasicBlock(filter_num, stride=1))

return res_blocks

def ResNet34(num_classes=10):

return ResNet([2, 2, 2, 2], num_classes=num_classes)

def ResNet34(num_classes=10):

return ResNet([3, 4, 6, 3], num_classes=num_classes)

model = ResNet34(num_classes=1000)

model.build(input_shape=(1, 224, 224, 3))

print(model.summary()) # 统计网络参数

ResNet50、ResNet101、ResNet152完整代码

import tensorflow as tf

from tensorflow import keras

from tensorflow.keras import layers, Sequential

第二个残差模块

class Block(layers.Layer):

def init(self, filters, downsample=False, stride=1):

super(Block, self).init()

self.downsample = downsample

self.conv1 = layers.Conv2D(filters, (1, 1), strides=stride, padding=‘same’)

self.bn1 = layers.BatchNormalization()

self.relu = layers.Activation(‘relu’)

self.conv2 = layers.Conv2D(filters, (3, 3), strides=1, padding=‘same’)

self.bn2 = layers.BatchNormalization()

self.conv3 = layers.Conv2D(4 * filters, (1, 1), strides=1, padding=‘same’)

self.bn3 = layers.BatchNormalization()

se-block

self.se_globalpool = keras.layers.GlobalAveragePooling2D()

self.se_resize = keras.layers.Reshape((1, 1, 4 * filters))

self.se_fc1 = keras.layers.Dense(units=4 * filters // 16, activation=‘relu’,

use_bias=False)

self.se_fc2 = keras.layers.Dense(units=4 * filters, activation=‘sigmoid’,

use_bias=False)

if self.downsample:

self.shortcut = Sequential()

self.shortcut.add(layers.Conv2D(4 * filters, (1, 1), strides=stride))

self.shortcut.add(layers.BatchNormalization(axis=3))

def call(self, input, training=None):

out = self.conv1(input)

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)

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Python工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Python开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Python开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以添加V获取：vip1024c （备注Python）

一、Python所有方向的学习路线

Python所有方向路线就是把Python常用的技术点做整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。

二、学习软件

工欲善其事必先利其器。学习Python常用的开发软件都在这里了，给大家节省了很多时间。

三、入门学习视频

我们在看视频学习的时候，不能光动眼动脑不动手，比较科学的学习方法是在理解之后运用它们，这时候练手项目就很适合了。

一个人可以走的很快，但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎扫码加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

29f47b8a67243c1008edf79.png)

二、学习软件

工欲善其事必先利其器。学习Python常用的开发软件都在这里了，给大家节省了很多时间。

三、入门学习视频

我们在看视频学习的时候，不能光动眼动脑不动手，比较科学的学习方法是在理解之后运用它们，这时候练手项目就很适合了。

一个人可以走的很快，但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎扫码加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
[外链图片转存中…(img-UX82TDkd-1712878980299)]

2401_84138927

关注

25
点赞
踩
13

收藏

觉得还不错? 一键收藏
0
评论
【图像分类】用最简短的代码复现SeNet，小白一定要收藏（keras，Tensorflow2

那么这个的公式就是下面的公式1（卷积操作，表示第c个卷积核，表示第s个输入）。得到的U就是Figure1中的左边第二个三维矩阵，也叫tensor，或者叫C个大小为H*W的feature map。而uc表示U中第c个二维矩阵，下标c表示channel。接下来就是Squeeze操作，公式非常简单，就是一个global average pooling:因此公式2就将H*W*C的输入转换成1*1*C的输出，对应Figure1中的Fsq操作。为什么会有这一步呢？
复制链接

扫一扫