秋招面试专栏推荐 ：深度学习算法工程师面试问题总结【百面算法工程师】——点击即可跳转
💡💡💡本专栏所有程序均经过测试，可成功执行💡💡💡
专栏目录 ：《YOLOv8改进有效涨点》专栏介绍 & 专栏目录 | 目前已有80+篇内容，内含各种Head检测头、损失函数Loss、Backbone、Neck、NMS等创新点改进——点击即可跳转
在视觉理解问题中，上下文信息对于语义分割和目标检测等任务是至关重要的。本文介绍一种名为交错的网络（CCNet），以非常高效和有效的方式获取全图像的上下文信息。具体来说，对于每个像素，一个新颖的交错注意力模块在其交错路径上收集所有像素的上下文信息。通过进一步采用递归操作，每个像素最终能够捕获整个图像的依赖关系。总的来说，CCNet具有以下优点：1）对GPU内存友好。与非局部块相比，所提出的递归交错注意力模块所需的GPU内存使用量减少了11倍。2）高计算效率。递归的交错注意力模块显著减少了大约85%的非局部块的计算量。文章在介绍主要的原理后，将手把手教学如何进行模块的代码添加和修改，并将修改后的完整代码放在文章的最后，方便大家一键运行，小白也可轻松上手实践。以帮助您更好地学习深度学习目标检测YOLO系列的挑战。
专栏地址：YOLOv8改进——更新各种有效涨点方法——点击即可跳转 订阅学习不迷路
目录
2. 将CrissCrossAttention添加到YOLOv8中
1.原理
论文地址：CCNet: Criss-Cross Attention for Semantic Segmentation——点击即可跳转
官方代码： 官方代码仓库——点击即可跳转
CCNet，即交叉网络，旨在高效收集全图上下文信息，用于语义分割任务。下面是其主要原理的简单解释，无需使用公式：
交叉注意力模块：
-
CCNet 的核心创新是交叉注意力模块。该模块沿着特征图中每个像素的水平和垂直路径收集上下文信息。
-
与使用密集连接的传统方法不同，交叉注意力模块使用稀疏连接，大大降低了计算复杂度和内存使用量。
-
对于每个像素，模块仅沿着包含相同行和列的交叉路径创建注意力图。与全连接方法相比，这减少了连接数。
循环操作：
-
为了捕获全图依赖关系，CCNet 采用循环操作。这意味着连续多次应用交叉注意力模块。
-
第一遍收集水平和垂直线上的信息。后续的传递继续聚合更多的上下文，最终使每个像素都能从整个图像中收集信息。
-
循环机制确保注意力信息逐渐丰富，从而实现更有效的上下文聚合。
效率：
-
通过使用交叉方法，与非局部块相比，CCNet 在计算需求和内存使用方面均实现了大幅降低。
-
具体而言，它显著减少了浮点运算 (FLOP) 的数量和内存使用量，使其更适用于高分辨率图像和大规模数据集。
类别一致性损失：
-
为了进一步增强交叉注意力模块学习到的特征的判别能力，CCNet 引入了类别一致性损失。
-
该损失函数确保属于同一类别的像素的特征在特征空间中靠得更近，而来自不同类别的像素的特征相距较远。
性能：
-
CCNet 已被证明在各种语义分割基准测试中实现了最先进的性能，包括 Cityscapes、ADE20K 等。这证明了其在利用全图像上下文信息方面的有效性。
总体而言，CCNet 脱颖而出，提供了一种高效且有效地聚合每个像素的全图像上下文的方法，从而提高了语义分割任务的性能，同时提高了计算和内存效率。
2. 将CrissCrossAttention添加到YOLOv8中
2.1 CrissCrossAttention的代码实现
关键步骤一: 将下面代码粘贴到在/ultralytics/ultralytics/nn/modules/block.py中，并在该文件的__all__中添加“CrissCrossAttention”
'''
This code is borrowed from Serge-weihao/CCNet-Pure-Pytorch
'''
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn import Softmax
def INF(B,H,W):
return -torch.diag(torch.tensor(float("inf")).repeat(H),0).unsqueeze(0).repeat(B*W,1,1)
class CrissCrossAttention(nn.Module):
""" Criss-Cross Attention Module"""
def __init__(self, in_dim, c2 = 512):
super(CrissCrossAttention,self).__init__()
self.query_conv = nn.Conv2d(in_channels=in_dim, out_channels=in_dim//8, kernel_size=1)
self.key_conv = nn.Conv2d(in_channels=in_dim, out_channels=in_dim//8, kernel_size=1)
self.value_conv = nn.Conv2d(in_channels=in_dim, out_channels=in_dim, kernel_size=1)
self.softmax = Softmax(dim=3)
self.INF = INF
self.gamma = nn.Parameter(torch.zeros(1))
def forward(self, x):
m_batchsize, _, height, width = x.size()
proj_query = self.query_conv(x)
proj_query_H = proj_query.permute(0,3,1,2).contiguous().view(m_batchsize*width,-1,height).permute(0, 2, 1)
proj_query_W = proj_query.permute(0,2,1,3).contiguous().view(m_batchsize*height,-1,width).permute(0, 2, 1)
proj_key = self.key_conv(x)
proj_key_H = proj_key.permute(0,3,1,2).contiguous().view(m_batchsize*width,-1,height)
proj_key_W = proj_key.permute(0,2,1,3).contiguous().view(m_batchsize*height,-1,width)
proj_value = self.value_conv(x)
proj_value_H = proj_value.permute(0,3,1,2).contiguous().view(m_batchsize*width,-1,height)
proj_value_W = proj_value.permute(0,2,1,3).contiguous().view(m_batchsize*height,-1,width)
energy_H = (torch.bmm(proj_query_H, proj_key_H)+self.INF(m_batchsize, height, width)).view(m_batchsize,width,height,height).permute(0,2,1,3)
energy_W = torch.bmm(proj_query_W, proj_key_W).view(m_batchsize,height,width,width)
concate = self.softmax(torch.cat([energy_H, energy_W], 3))
att_H = concate[:,:,:,0:height].permute(0,2,1,3).contiguous().view(m_batchsize*width,height,height)
#print(concate)
#print(att_H)
att_W = concate[:,:,:,height:height+width].contiguous().view(m_batchsize*height,width,width)
out_H = torch.bmm(proj_value_H, att_H.permute(0, 2, 1)).view(m_batchsize,width,-1,height).permute(0,2,3,1)
out_W = torch.bmm(proj_value_W, att_W.permute(0, 2, 1)).view(m_batchsize,height,-1,width).permute(0,2,1,3)
#print(out_H.size(),out_W.size())
return self.gamma*(out_H + out_W) + xCCNet处理图像的主要流程如下：
1. 输入图像
-
首先，将输入图像传入一个标准的卷积神经网络（CNN）以提取初始的特征图。这些特征图包含了图像的低级和高级特征。
2. Criss-Cross Attention Module
-
初始特征图：将从CNN提取的特征图传入Criss-Cross Attention模块。
-
水平和垂直路径：Criss-Cross Attention模块沿每个像素的水平和垂直路径聚合上下文信息。具体来说，它为每个像素生成一个注意力图，注意力图仅包括同一行和同一列的像素连接，这样可以显著减少计算量和内存使用。
-
加权和操作：根据注意力图，将其他位置的上下文信息加权和，结合到当前像素的位置特征中。
3. 递归操作
-
第一次递归：初次通过Criss-Cross Attention模块收集水平和垂直方向的上下文信息。
-
重复应用：将第一次递归操作的结果传入第二次Criss-Cross Attention模块，通过重复应用这个模块，逐步收集更多的上下文信息，最终使得每个像素都能从整个图像中收集到上下文信息。
-
共享参数：多次递归过程中，Criss-Cross Attention模块的参数是共享的，这样可以保持模型的紧凑性。
4. 融合特征
-
组合信息：经过递归操作后，整合所有位置的上下文信息，将增强的特征图传递给后续的网络层。
5. 类别一致损失（Category Consistent Loss）
-
损失函数：引入类别一致损失，进一步增强特征的判别能力。该损失函数使得同类别像素的特征向量在特征空间中更接近，不同类别的特征向量更远。
-
训练目标：通过这个损失函数，网络可以更准确地区分不同类别的像素，提高分割的准确性。
6. 输出预测
-
最终分割图：将处理后的特征图通过一系列卷积层和上采样层，生成最终的语义分割图。每个像素被分配一个类别标签，表示它属于哪个语义类别。
7. 结果评估
-
评价指标：通过标准的评价指标在测试数据集上评估模型性能，验证模型在实际应用中的效果。
总结
CCNet通过引入Criss-Cross Attention模块和递归操作，有效地聚合了全图像的上下文信息，大大提升了语义分割的性能，同时显著减少了计算资源的消耗。这使得CCNet在多种大规模语义分割基准测试中取得了领先的性能。
2.2 更改init.py文件
关键步骤二：修改modules文件夹下的__init__.py文件，先导入函数
然后在下面的__all__中声明函数
2.3 添加yaml文件
关键步骤三：在/ultralytics/ultralytics/cfg/models/v8下面新建文件yolov8_CCA.yaml文件，粘贴下面的内容
- OD【目标检测】
# Ultralytics YOLO 🚀, AGPL-3.0 license
# YOLOv8 object detection model with P3-P5 outputs. For Usage examples see https://docs.ultralytics.com/tasks/detect
# Parameters
nc: 80 # number of classes
scales: # model compound scaling constants, i.e. 'model=yolov8n.yaml' will call yolov8.yaml with scale 'n'
# [depth, width, max_channels]
n: [0.33, 0.25, 1024] # YOLOv8n summary: 225 layers, 3157200 parameters, 3157184 gradients, 8.9 GFLOPs
s: [0.33, 0.50, 1024] # YOLOv8s summary: 225 layers, 11166560 parameters, 11166544 gradients, 28.8 GFLOPs
m: [0.67, 0.75, 768] # YOLOv8m summary: 295 layers, 25902640 parameters, 25902624 gradients, 79.3 GFLOPs
l: [1.00, 1.00, 512] # YOLOv8l summary: 365 layers, 43691520 parameters, 43691504 gradients, 165.7 GFLOPs
x: [1.00, 1.25, 512] # YOLOv8x summary: 365 layers, 68229648 parameters, 68229632 gradients, 258.5 GFLOPs
# YOLOv8.0n backbone
backbone:
# [from, repeats, module, args]
- [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
- [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
- [-1, 3, C2f, [128, True]]
- [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
- [-1, 6, C2f, [256, True]]
- [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
- [-1, 6, C2f, [512, True]]
- [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
- [-1, 3, C2f, [1024, True]]
- [-1, 1, SPPF, [1024, 5]] # 9
# 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)
- [-1, 1, CrissCrossAttention, [1024]]
- [[15, 18, 22], 1, Detect, [nc]] # Detect(P3, P4, P5)
- Seg【语义分割】
# Ultralytics YOLO 🚀, AGPL-3.0 license
# YOLOv8 object detection model with P3-P5 outputs. For Usage examples see https://docs.ultralytics.com/tasks/detect
# Parameters
nc: 80 # number of classes
scales: # model compound scaling constants, i.e. 'model=yolov8n.yaml' will call yolov8.yaml with scale 'n'
# [depth, width, max_channels]
n: [0.33, 0.25, 1024] # YOLOv8n summary: 225 layers, 3157200 parameters, 3157184 gradients, 8.9 GFLOPs
s: [0.33, 0.50, 1024] # YOLOv8s summary: 225 layers, 11166560 parameters, 11166544 gradients, 28.8 GFLOPs
m: [0.67, 0.75, 768] # YOLOv8m summary: 295 layers, 25902640 parameters, 25902624 gradients, 79.3 GFLOPs
l: [1.00, 1.00, 512] # YOLOv8l summary: 365 layers, 43691520 parameters, 43691504 gradients, 165.7 GFLOPs
x: [1.00, 1.25, 512] # YOLOv8x summary: 365 layers, 68229648 parameters, 68229632 gradients, 258.5 GFLOPs
# YOLOv8.0n backbone
backbone:
# [from, repeats, module, args]
- [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
- [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
- [-1, 3, C2f, [128, True]]
- [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
- [-1, 6, C2f, [256, True]]
- [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
- [-1, 6, C2f, [512, True]]
- [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
- [-1, 3, C2f, [1024, True]]
- [-1, 1, SPPF, [1024, 5]] # 9
# 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)
- [-1, 1, CrissCrossAttention, [1024]]
- [[15, 18, 22], 1, Segment, [nc, 32, 256]] # Segment(P3, P4, P5)
温馨提示：因为本文只是对yolov8基础上添加模块，如果要对yolov8n/l/m/x进行添加则只需要指定对应的depth_multiple 和 width_multiple。
# YOLOv8n
depth_multiple: 0.33 # model depth multiple
width_multiple: 0.25 # layer channel multiple
max_channels: 1024 # max_channels
# YOLOv8s
depth_multiple: 0.33 # model depth multiple
width_multiple: 0.50 # layer channel multiple
max_channels: 1024 # max_channels
# YOLOv8l
depth_multiple: 1.0 # model depth multiple
width_multiple: 1.0 # layer channel multiple
max_channels: 512 # max_channels
# YOLOv8m
depth_multiple: 0.67 # model depth multiple
width_multiple: 0.75 # layer channel multiple
max_channels: 768 # max_channels
# YOLOv8x
depth_multiple: 1.33 # model depth multiple
width_multiple: 1.25 # layer channel multiple
max_channels: 512 # max_channels2.4 注册模块
关键步骤四：在task.py的parse_model函数中注册“CrissCrossAttention”
elif m is CrissCrossAttention:
c1, c2 = ch[f], args[0]
if c2 != nc: # if not output
c2 = make_divisible(min(c2, max_channels) * width, 8)
args = [c1, c2, *args[1:]]
2.5 执行程序
在train.py中，将model的参数路径设置为yolov8_CCA.yaml的路径
建议大家写绝对路径，确保一定能找到
from ultralytics import YOLO
# Load a model
# model = YOLO('yolov8n.yaml') # build a new model from YAML
# model = YOLO('yolov8n.pt') # load a pretrained model (recommended for training)
model = YOLO(r'/projects/ultralytics/ultralytics/cfg/models/v8/yolov8_CCA.yaml') # build from YAML and transfer weights
# Train the model
model.train()🚀运行程序，如果出现下面的内容则说明添加成功🚀
from n params module arguments
0 -1 1 464 ultralytics.nn.modules.conv.Conv [3, 16, 3, 2]
1 -1 1 4672 ultralytics.nn.modules.conv.Conv [16, 32, 3, 2]
2 -1 1 7360 ultralytics.nn.modules.block.C2f [32, 32, 1, True]
3 -1 1 18560 ultralytics.nn.modules.conv.Conv [32, 64, 3, 2]
4 -1 2 49664 ultralytics.nn.modules.block.C2f [64, 64, 2, True]
5 -1 1 73984 ultralytics.nn.modules.conv.Conv [64, 128, 3, 2]
6 -1 2 197632 ultralytics.nn.modules.block.C2f [128, 128, 2, True]
7 -1 1 295424 ultralytics.nn.modules.conv.Conv [128, 256, 3, 2]
8 -1 1 460288 ultralytics.nn.modules.block.C2f [256, 256, 1, True]
9 -1 1 164608 ultralytics.nn.modules.block.SPPF [256, 256, 5]
10 -1 1 0 torch.nn.modules.upsampling.Upsample [None, 2, 'nearest']
11 [-1, 6] 1 0 ultralytics.nn.modules.conv.Concat [1]
12 -1 1 148224 ultralytics.nn.modules.block.C2f [384, 128, 1]
13 -1 1 0 torch.nn.modules.upsampling.Upsample [None, 2, 'nearest']
14 [-1, 4] 1 0 ultralytics.nn.modules.conv.Concat [1]
15 -1 1 37248 ultralytics.nn.modules.block.C2f [192, 64, 1]
16 -1 1 36992 ultralytics.nn.modules.conv.Conv [64, 64, 3, 2]
17 [-1, 12] 1 0 ultralytics.nn.modules.conv.Concat [1]
18 -1 1 123648 ultralytics.nn.modules.block.C2f [192, 128, 1]
19 -1 1 147712 ultralytics.nn.modules.conv.Conv [128, 128, 3, 2]
20 [-1, 9] 1 0 ultralytics.nn.modules.conv.Concat [1]
21 -1 1 493056 ultralytics.nn.modules.block.C2f [384, 256, 1]
22 -1 1 82241 ultralytics.nn.modules.block.CrissCrossAttention[256, 256]
23 [15, 18, 22] 1 897664 ultralytics.nn.modules.head.Detect [80, [64, 128, 256]]
YOLOv8_CCA summary: 230 layers, 3239441 parameters, 3239425 gradients3. 完整代码分享
https://pan.baidu.com/s/1KqeQhsLzcQuGuIJnLn1tWg?pwd=1pec提取码: 1pec
4. GFLOPs
关于GFLOPs的计算方式可以查看：百面算法工程师 | 卷积基础知识——Convolution
未改进的YOLOv8nGFLOPs
改进后的GFLOPs
现在手上没有卡了，等过段时候有卡了把这补上，需要的同学自己测一下
5. 进阶
可以与其他的注意力机制或者损失函数等结合，进一步提升检测效果
6. 总结
CCNet的主要原理是通过引入Criss-Cross Attention模块，沿着每个像素的水平和垂直路径高效地聚合全图像的上下文信息，并通过递归操作进一步整合全局特征，同时结合类别一致损失增强特征的判别能力，从而在语义分割任务中以较低的计算和内存消耗实现高性能分割。
7万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
