什么是注意力机制

注意力机制的核心重点就是让网络关注到它更需要关注的地方。

当我们使用卷积神经网络去处理图片的时候，我们会更希望卷积神经网络去注意应该注意的地方，而不是什么都关注，我们不可能手动去调节需要注意的地方，这个时候，如何让卷积神经网络去自适应的注意重要的物体变得极为重要。

注意力机制就是实现网络自适应注意的一个方式。

注意力机制可以分为通道注意力机制，空间注意力机制，以及二者的结合。

通道注意力机制关注的是某些重要的通道，空间注意力机制关注的是图片中某些重要的区域。

注意力机制的实现方式

在深度学习中，常见的注意力机制的实现方式有SENet，CBAM，ECA等等。

1.SENet的实现

SENet是通道注意力机制的典型实现。
对于输入进来的特征层，我们关注其每一个通道的权重，对于SENet而言，其重点是获得输入进来的特征层，每一个通道的权值。利用SENet，我们可以让网络关注它最需要关注的通道。

其具体实现方式就是：
1、对输入进来的特征层进行全局平均池化。
2、然后进行两次全连接，第一次全连接神经元个数较少，第二次全连接神经元个数和输入特征层相同。
3、在完成两次全连接后，我们再取一次Sigmoid将值固定到0-1之间，此时我们获得了输入特征层每一个通道的权值（0-1之间）。
4、在获得这个权值后，我们将这个权值乘上原输入特征层即可。

实现代码：

def se_block(input_feature, ratio=16, name=""):
	channel = input_feature._keras_shape[-1]

	se_feature = GlobalAveragePooling2D()(input_feature)
	se_feature = Reshape((1, 1, channel))(se_feature)

	se_feature = Dense(channel // ratio,
					   activation='relu',
					   kernel_initializer='he_normal',
					   use_bias=False,
					   bias_initializer='zeros',
					   name = "se_block_one_"+str(name))(se_feature)
					   
	se_feature = Dense(channel,
					   kernel_initializer='he_normal',
					   use_bias=False,
					   bias_initializer='zeros',
					   name = "se_block_two_"+str(name))(se_feature)
	se_feature = Activation('sigmoid')(se_feature)

	se_feature = multiply([input_feature, se_feature])
	return se_feature

2.CBAM的实现

CBAM将通道注意力机制和空间注意力机制进行一个结合，相比于SENet只关注通道的注意力机制可以取得更好的效果。CBAM会对输入进来的特征层，分别进行通道注意力机制的处理和空间注意力机制的处理。
通道注意力机制的实现可以分为两个部分，我们会对输入进来的单个特征层，分别进行全局平均池化和全局最大池化。之后对平均池化和最大池化的结果，利用共享的全连接层进行处理，我们会对处理后的两个结果进行相加，然后取一个sigmoid，此时我们获得了输入特征层每一个通道的权值（0-1之间）。在获得这个权值后，我们将这个权值乘上原输入特征层即可。

空间注意力机制的实现：我们会对输入进来的特征层，在每一个特征点的通道上取最大值和平均值。之后将这两个结果进行一个堆叠，利用一次通道数为1的卷积调整通道数，然后取一个sigmoid，此时我们获得了输入特征层每一个特征点的权值（0-1之间）。在获得这个权值后，我们将这个权值乘上原输入特征层即可。

实现代码如下：

def channel_attention(input_feature, ratio=8, name=""):
	
	channel = input_feature._keras_shape[-1]
	
	shared_layer_one = Dense(channel//ratio,
							 activation='relu',
							 kernel_initializer='he_normal',
							 use_bias=False,
							 bias_initializer='zeros',
							 name = "channel_attention_shared_one_"+str(name))
	shared_layer_two = Dense(channel,
							 kernel_initializer='he_normal',
							 use_bias=False,
							 bias_initializer='zeros',
							 name = "channel_attention_shared_two_"+str(name))
	
	avg_pool = GlobalAveragePooling2D()(input_feature)    
	max_pool = GlobalMaxPooling2D()(input_feature)

	avg_pool = Reshape((1,1,channel))(avg_pool)
	max_pool = Reshape((1,1,channel))(max_pool)

	avg_pool = shared_layer_one(avg_pool)
	max_pool = shared_layer_one(max_pool)

	avg_pool = shared_layer_two(avg_pool)
	max_pool = shared_layer_two(max_pool)
	
	cbam_feature = Add()([avg_pool,max_pool])
	cbam_feature = Activation('sigmoid')(cbam_feature)
	
	
	return multiply([input_feature, cbam_feature])

def spatial_attention(input_feature, name=""):
	kernel_size = 7

	cbam_feature = input_feature
	
	avg_pool = Lambda(lambda x: K.mean(x, axis=3, keepdims=True))(cbam_feature)
	max_pool = Lambda(lambda x: K.max(x, axis=3, keepdims=True))(cbam_feature)
	concat = Concatenate(axis=3)([avg_pool, max_pool])

	cbam_feature = Conv2D(filters = 1,
					kernel_size=kernel_size,
					strides=1,
					padding='same',
					kernel_initializer='he_normal',
					use_bias=False,
					name = "spatial_attention_"+str(name))(concat)	
	cbam_feature = Activation('sigmoid')(cbam_feature)
		
	return multiply([input_feature, cbam_feature])

def cbam_block(cbam_feature, ratio=8, name=""):
	cbam_feature = channel_attention(cbam_feature, ratio, name=name)
	cbam_feature = spatial_attention(cbam_feature, name=name)
	return cbam_feature

3、ECA的实现
ECANet是也是通道注意力机制的一种实现形式。ECANet可以看作是SENet的改进版。
ECANet的作者认为SENet对通道注意力机制的预测带来了副作用，捕获所有通道的依赖关系是低效并且是不必要的。
ECA模块的思想是非常简单的，它去除了原来SE模块中的全连接层，直接在全局平均池化之后的特征上通过一个1D卷积进行学习。

既然使用到了1D卷积，那么1D卷积的卷积核大小的选择就变得非常重要了，了解过卷积原理的同学很快就可以明白，1D卷积的卷积核大小会影响注意力机制每个权重的计算要考虑的通道数量。

实现代码如下：

def eca_block(input_feature, b=1, gamma=2, name=""):
	channel = input_feature._keras_shape[-1]
	kernel_size = int(abs((math.log(channel, 2) + b) / gamma))
	kernel_size = kernel_size if kernel_size % 2 else kernel_size + 1
	
	avg_pool = GlobalAveragePooling2D()(input_feature)
	
	x = Reshape((-1,1))(avg_pool)
	x = Conv1D(1, kernel_size=kernel_size, padding="same", name = "eca_layer_"+str(name), use_bias=False,)(x)
	x = Activation('sigmoid')(x)
	x = Reshape((1, 1, -1))(x)

	output = multiply([input_feature,x])
	return output

开始应用：将注意力机制加入到YOLOv8中

1.找到conv.py文件

2.在conv.py中添加名字

3.在__init__.py中添加名字

4.在tasks.py文件中添加名字

5.在tasks.py中添加配置

在该函数中添加代码

添加的代码为：

elif m in {CBAM}:
    c1, c2 = ch[f], args[0]
    if c2 != nc:
        c2 = make_divisible(min(c2, max_channels) * width, 8)
    args = [c1, *args[1:]]

添加后的为：

6.打开yaml文件

7.尽量不要在这个文件中更改内容，我们可以自己创建一个yaml文件（my_yolov8_CBAM.yaml），然后将yolov8.yaml中的内容复制过来

8.在backbone中进行修改

from列中的-1表示应用上一层的参数、repeats列表示重复多少次、module列表示模型的名字、args列表示参数，

9.第八点操作添加完后层数会改变，head部分需要进行相应的修改

修改前：

# YOLOv8.0n head
head:
  - [ -1, 1, nn.Upsample, [ None, 2, "nearest" ] ]
  - [ [ -1, 6 ], 1, Concat, [ 1 ] ] # cat backbone P4
  - [ -1, 3, C2f, [ 512 ] ] # 12

  - [ -1, 1, nn.Upsample, [ None, 2, "nearest" ] ]
  - [ [ -1, 4 ], 1, Concat, [ 1 ] ] # cat backbone P3
  - [ -1, 3, C2f, [ 256 ] ] # 15 (P3/8-small)

  - [ -1, 1, Conv, [ 256, 3, 2 ] ]
  - [ [ -1, 12 ], 1, Concat, [ 1 ] ] # cat head P4
  - [ -1, 3, C2f, [ 512 ] ] # 18 (P4/16-medium)

  - [ -1, 1, Conv, [ 512, 3, 2 ] ]
  - [ [ -1, 9 ], 1, Concat, [ 1 ] ] # cat head P5
  - [ -1, 3, C2f, [ 1024 ] ] # 21 (P5/32-large)

  - [ [ 15, 18, 21 ], 1, Detect, [ nc ] ] # Detect(P3, P4, P5)

修改后：

为什么都+1了？

举个例子，原来要连接第六层，加了注意力层后，原来的第六层就变成第七层，所以在Concat连接时需要修改相应的层数

至此，注意力机制已经插入，可以开始使用了

10.在根目录下新建一个main.py文件，代码如下：

from ultralytics import YOLO

model = (YOLO("ultralytics/cfg/models/v8/my_yolov8_CBAM.yaml"))
model.train(**{'cfg': 'ultralytics/cfg/default.yaml'})

运行即可开始训练