💡💡💡本专栏所有程序均经过测试，可成功执行💡💡💡
现有的基于CNN的SISR方法主要关注更宽或更深的架构设计，忽视了探索中间层的特征相关性，因此阻碍了CNN的表达能力。为了解决这一问题，研究人员提出了一个二阶注意力网络（SAN），用于更强大的特征表达和特征相关性学习。具体来说，就是开发了一个新颖的可训练的二阶通道注意力（SOCA）模块，通过使用二阶特征统计自适应地重新缩放逐通道特征，以获得更具辨识力的表征。在本文中，给大家带来的教程是在原来的主干网络添加SOCA模块。文章在介绍主要的原理后，将手把手教学如何进行模块的代码添加和修改，并将修改后的完整代码放在文章的最后，方便大家一键运行，小白也可轻松上手实践。以帮助您更好地学习深度学习目标检测YOLO系列的挑战。
目录
1.原理
官方论文：Second-order Attention Network for Single Image Super-Resolution——点击即可跳转
官方代码：官方代码仓库——点击即可跳转
1. 概述
SOCA模块旨在通过考虑特征的二阶统计量来提高网络的判别能力，而不仅仅使用之前常用的一阶统计量。
2. 动机
以前的模型，例如SENet，利用一阶统计量（例如全局平均池化）来重新调整通道特征。然而，这种方法不能完全捕捉特征之间的复杂依赖关系。研究表明，二阶统计量可以在深度CNN中提供更具判别力的表示。
3.实现
特征图重塑和协方差计算：
给定尺寸为
（高度、宽度和通道数）的特征图 F ，它被重塑成一个特征矩阵 X ，其中包含
个 C 维的特征。
样本协方差矩阵
计算如下：
其中 I 是包含均值减法成分的单位矩阵。
协方差归一化：
协方差矩阵
，其中 U 是正交矩阵，
是特征值的对角矩阵。
协方差归一化应用如下：
其中
，有助于平衡特征值以获得更好的特征表示。
通道注意力：
归一化的协方差矩阵表示通道间的相关性，通过全局协方差池化用作描述符。
这允许网络通过自适应重新调整通道特征来学习和强调更有信息量和判别力的特征。
4. 优点
增强判别能力：通过使用二阶统计量，SOCA模块使网络能够集中注意力于更有信息量的特征，从而更有效地区分不同的特征。
更好的性能：与一阶统计量相比，使用二阶统计量在图像超分辨率任务中表现出更优越的性能。
5. 在SAN中的集成
SOCA模块嵌入在每个局部源残差注意力组（LSRAG）的尾部。这个位置帮助在将特征图传递到后续层之前，通过考虑复杂的特征依赖关系来精细化特征图，从而增强整体超分辨率性能。
6. 总结
SOCA模块通过利用二阶统计量来重新调整特征，提供了一种更强大和判别力更强的特征表示机制。这有助于SAN在单图像超分辨率任务中表现出色。
2. SOCA代码实现
2.1 将SOCA添加到YOLOv5代码中
关键步骤一: 将下面代码粘贴到/projects/yolov5-6.1/models/common.py文件中
from torch.autograd import Function
class Covpool(Function):
@staticmethod
def forward(ctx, input):
x = input
batchSize = x.data.shape[0]
dim = x.data.shape[1]
h = x.data.shape[2]
w = x.data.shape[3]
M = h*w
x = x.reshape(batchSize,dim,M)
I_hat = (-1./M/M)*torch.ones(M,M,device = x.device) + (1./M)*torch.eye(M,M,device = x.device)
I_hat = I_hat.view(1,M,M).repeat(batchSize,1,1).type(x.dtype)
y = x.bmm(I_hat).bmm(x.transpose(1,2))
ctx.save_for_backward(input,I_hat)
return y
@staticmethod
def backward(ctx, grad_output):
input,I_hat = ctx.saved_tensors
x = input
batchSize = x.data.shape[0]
dim = x.data.shape[1]
h = x.data.shape[2]
w = x.data.shape[3]
M = h*w
x = x.reshape(batchSize,dim,M)
grad_input = grad_output + grad_output.transpose(1,2)
grad_input = grad_input.bmm(x).bmm(I_hat)
grad_input = grad_input.reshape(batchSize,dim,h,w)
return grad_input
class Sqrtm(Function):
@staticmethod
def forward(ctx, input, iterN):
x = input
batchSize = x.data.shape[0]
dim = x.data.shape[1]
dtype = x.dtype
I3 = 3.0*torch.eye(dim,dim,device = x.device).view(1, dim, dim).repeat(batchSize,1,1).type(dtype)
normA = (1.0/3.0)*x.mul(I3).sum(dim=1).sum(dim=1)
A = x.div(normA.view(batchSize,1,1).expand_as(x))
Y = torch.zeros(batchSize, iterN, dim, dim, requires_grad = False, device = x.device)
Z = torch.eye(dim,dim,device = x.device).view(1,dim,dim).repeat(batchSize,iterN,1,1)
if iterN < 2:
ZY = 0.5*(I3 - A)
Y[:,0,:,:] = A.bmm(ZY)
else:
ZY = 0.5*(I3 - A)
Y[:,0,:,:] = A.bmm(ZY)
Z[:,0,:,:] = ZY
for i in range(1, iterN-1):
ZY = 0.5*(I3 - Z[:,i-1,:,:].bmm(Y[:,i-1,:,:]))
Y[:,i,:,:] = Y[:,i-1,:,:].bmm(ZY)
Z[:,i,:,:] = ZY.bmm(Z[:,i-1,:,:])
ZY = 0.5*Y[:,iterN-2,:,:].bmm(I3 - Z[:,iterN-2,:,:].bmm(Y[:,iterN-2,:,:]))
y = ZY*torch.sqrt(normA).view(batchSize, 1, 1).expand_as(x)
ctx.save_for_backward(input, A, ZY, normA, Y, Z)
ctx.iterN = iterN
return y
@staticmethod
def backward(ctx, grad_output):
input, A, ZY, normA, Y, Z = ctx.saved_tensors
iterN = ctx.iterN
x = input
batchSize = x.data.shape[0]
dim = x.data.shape[1]
dtype = x.dtype
der_postCom = grad_output*torch.sqrt(normA).view(batchSize, 1, 1).expand_as(x)
der_postComAux = (grad_output*ZY).sum(dim=1).sum(dim=1).div(2*torch.sqrt(normA))
I3 = 3.0*torch.eye(dim,dim,device = x.device).view(1, dim, dim).repeat(batchSize,1,1).type(dtype)
if iterN < 2:
der_NSiter = 0.5*(der_postCom.bmm(I3 - A) - A.bmm(der_sacleTrace))
else:
dldY = 0.5*(der_postCom.bmm(I3 - Y[:,iterN-2,:,:].bmm(Z[:,iterN-2,:,:])) -
Z[:,iterN-2,:,:].bmm(Y[:,iterN-2,:,:]).bmm(der_postCom))
dldZ = -0.5*Y[:,iterN-2,:,:].bmm(der_postCom).bmm(Y[:,iterN-2,:,:])
for i in range(iterN-3, -1, -1):
YZ = I3 - Y[:,i,:,:].bmm(Z[:,i,:,:])
ZY = Z[:,i,:,:].bmm(Y[:,i,:,:])
dldY_ = 0.5*(dldY.bmm(YZ) -
Z[:,i,:,:].bmm(dldZ).bmm(Z[:,i,:,:]) -
ZY.bmm(dldY))
dldZ_ = 0.5*(YZ.bmm(dldZ) -
Y[:,i,:,:].bmm(dldY).bmm(Y[:,i,:,:]) -
dldZ.bmm(ZY))
dldY = dldY_
dldZ = dldZ_
der_NSiter = 0.5*(dldY.bmm(I3 - A) - dldZ - A.bmm(dldY))
grad_input = der_NSiter.div(normA.view(batchSize,1,1).expand_as(x))
grad_aux = der_NSiter.mul(x).sum(dim=1).sum(dim=1)
for i in range(batchSize):
grad_input[i,:,:] += (der_postComAux[i] \
- grad_aux[i] / (normA[i] * normA[i])) \
*torch.ones(dim,device = x.device).diag()
return grad_input, None
def CovpoolLayer(var):
return Covpool.apply(var)
def SqrtmLayer(var, iterN):
return Sqrtm.apply(var, iterN)
class SOCA(nn.Module):
# second-order Channel attention
def __init__(self, channel, reduction=8):
super(SOCA, self).__init__()
self.max_pool = nn.MaxPool2d(kernel_size=2)
self.conv_du = nn.Sequential(
nn.Conv2d(channel, channel // reduction, 1, padding=0, bias=True),
nn.ReLU(inplace=True),
nn.Conv2d(channel // reduction, channel, 1, padding=0, bias=True),
nn.Sigmoid()
)
def forward(self, x):
batch_size, C, h, w = x.shape # x: NxCxHxW
N = int(h * w)
min_h = min(h, w)
h1 = 1000
w1 = 1000
if h < h1 and w < w1:
x_sub = x
elif h < h1 and w > w1:
W = (w - w1) // 2
x_sub = x[:, :, :, W:(W + w1)]
elif w < w1 and h > h1:
H = (h - h1) // 2
x_sub = x[:, :, H:H + h1, :]
else:
H = (h - h1) // 2
W = (w - w1) // 2
x_sub = x[:, :, H:(H + h1), W:(W + w1)]
cov_mat = CovpoolLayer(x_sub) # Global Covariance pooling layer
cov_mat_sqrt = SqrtmLayer(cov_mat,5) # Matrix square root layer( including pre-norm,Newton-Schulz iter. and post-com. with 5 iteration)
cov_mat_sum = torch.mean(cov_mat_sqrt,1)
cov_mat_sum = cov_mat_sum.view(batch_size,C,1,1)
y_cov = self.conv_du(cov_mat_sum)
return y_cov*x理解SOCA模块的工作流程需要考虑以下关键步骤：
特征图重塑和协方差计算：
首先，将输入的特征图重塑为一个二维矩阵，其中每一行对应一个空间位置，而每一列对应一个通道。
接着，计算这个特征矩阵的协方差矩阵。协方差矩阵衡量了特征之间的线性相关性，有助于捕捉特征之间的相关关系。
协方差归一化：
在协方差归一化阶段，对协方差矩阵进行特征值分解。这个过程将协方差矩阵分解为特征向量和特征值。
通过特征值分解，我们可以获得关于特征之间的重要性的信息。特征值表示了特征的重要程度，而特征向量则表示了特征之间的关系。
接着，应用一个归一化操作，通过缩放特征矩阵的特征值，以达到更好地平衡不同特征之间的贡献。
通道注意力：
在这一步中，利用归一化后的协方差矩阵，计算每个通道之间的相关性。
通过全局协方差池化，将这些相关性聚合为一个全局描述符，这个描述符反映了整个特征图中各个通道之间的关系。
最后，利用这些通道间的相关性信息，调整和强调更具信息量和判别力的特征。
总的来说，SOCA模块通过对特征图进行协方差计算和归一化，以及通道注意力的机制，提供了一种更强大和判别力更强的特征表示方式。这有助于提高网络在各种计算机视觉任务中的性能表现。
2.2 新增yaml文件
关键步骤二：在下/projects/yolov5-6.1/models下新建文件 yolov5_SOCA.yaml并将下面代码复制进去
# YOLOv5 🚀 by Ultralytics, GPL-3.0 license
# Parameters
nc: 80 # number of classes
depth_multiple: 1.0 # model depth multiple
width_multiple: 1.0 # layer channel multiple
anchors:
- [10,13, 16,30, 33,23] # P3/8
- [30,61, 62,45, 59,119] # P4/16
- [116,90, 156,198, 373,326] # P5/32
# YOLOv5 v6.0 backbone
backbone:
# [from, number, module, args]
[[-1, 1, Conv, [64, 6, 2, 2]], # 0-P1/2
[-1, 1, Conv, [128, 3, 2]], # 1-P2/4
[-1, 3, C3, [128]],
[-1, 1, Conv, [256, 3, 2]], # 3-P3/8
[-1, 6, C3, [256]],
[-1, 1, Conv, [512, 3, 2]], # 5-P4/16
[-1, 9, C3, [512]],
[-1, 1, Conv, [1024, 3, 2]], # 7-P5/32
[-1, 3, C3, [1024]],
[-1, 1, SOCA, [1024]],
[-1, 1, SPPF, [1024, 5]], # 9
]
# YOLOv5 v6.0 head
head:
[[-1, 1, Conv, [512, 1, 1]],
[-1, 1, nn.Upsample, [None, 2, 'nearest']],
[[-1, 6], 1, Concat, [1]], # cat backbone P4
[-1, 3, C3, [512, False]], # 13
[-1, 1, Conv, [256, 1, 1]],
[-1, 1, nn.Upsample, [None, 2, 'nearest']],
[[-1, 4], 1, Concat, [1]], # cat backbone P3
[-1, 3, C3, [256, False]], # 17 (P3/8-small)
[-1, 1, Conv, [256, 3, 2]],
[[-1, 15], 1, Concat, [1]], # cat head P4
[-1, 3, C3, [512, False]], # 20 (P4/16-medium)
[-1, 1, Conv, [512, 3, 2]],
[[-1, 11], 1, Concat, [1]], # cat head P5
[-1, 3, C3, [1024, False]], # 23 (P5/32-large)
[[18, 21, 24], 1, Detect, [nc, anchors]], # Detect(P3, P4, P5)
]温馨提示：本文只是对yolov5l基础上添加模块，如果要对yolov8n/l/m/x进行添加则只需要指定对应的depth_multiple 和 width_multiple。
# YOLOv5n
depth_multiple: 0.33 # model depth multiple
width_multiple: 0.25 # layer channel multiple
# YOLOv5s
depth_multiple: 0.33 # model depth multiple
width_multiple: 0.50 # layer channel multiple
# YOLOv5l
depth_multiple: 1.0 # model depth multiple
width_multiple: 1.0 # layer channel multiple
# YOLOv5m
depth_multiple: 0.67 # model depth multiple
width_multiple: 0.75 # layer channel multiple
# YOLOv5x
depth_multiple: 1.33 # model depth multiple
width_multiple: 1.25 # layer channel multiple2.3 注册模块
关键步骤三：在yolo.py中注册, 大概在260行左右添加 ‘SOCA’
2.4 执行程序
在train.py中，将cfg的参数路径设置为yolov5_SOCA.yaml的路径
建议大家写绝对路径，确保一定能找到
🚀运行程序，如果出现下面的内容则说明添加成功🚀
3. 完整代码分享
https://pan.baidu.com/s/1J34gHh0sV6ZfQkkRpmGD9g?pwd=dni4提取码: dni4
4. GFLOPs
关于GFLOPs的计算方式可以查看：百面算法工程师 | 卷积基础知识——Convolution
未改进的GFLOPs
改进后的GFLOPs
GFLOPs不变，网络的深度加深了
5. 进阶
你能在不同的位置添加SOCA注意力机制吗？这非常有趣，快去试试吧
6.总结
SOCA（Second-Order Channel Attention）模块的主要原理在于通过考虑特征之间的二阶统计量，即协方差矩阵，来提升网络的判别能力。首先，将特征图转换为特征矩阵，并计算其协方差矩阵，以捕捉特征之间的相关性。然后，通过特征值分解和归一化操作，平衡特征值，使得网络能够更好地理解和表达特征之间的重要性。最后，利用全局协方差池化来描述通道间的相关性，从而调整和强调更具信息量和判别力的特征，进而提高网络的性能和泛化能力。
