💡💡💡本专栏所有程序均经过测试，可成功执行💡💡💡

尽管Ultralytics 推出了最新版本的 YOLOv8 模型。但YOLOv5作为一个anchor base的目标检测的算法，YOLOv5可能比YOLOv8的效果更好。在YOLOv5提取特征的时候，卷积的核是固定的K*K大小，导致参数数量随着大小的增加呈平方级增长。显然，不同数据集和目标的形状及大小各异，而固定形状和大小的卷积核无法灵活适应这种变化。本文给大家带来的教程是将YOLOv5的backbone的Conv用AKConv替换来提取特征。文章在介绍主要的原理后，将手把手教学如何进行模块的代码添加和修改，并将修改后的完整代码放在文章的最后，方便大家一键运行，小白也可轻松上手实践。此外还增加了进阶模块，来提高学有能力的同学进一步增长知识。帮助您更好地学习深度学习目标检测YOLO系列的挑战。

专栏地址： YOLOv5改进+入门——持续更新各种有效涨点方法点击即可跳转

1.原理

基于卷积运算的神经网络在深度学习领域取得了令人瞩目的成果，但标准卷积运算存在两个固有的缺陷。一方面，卷积运算仅限于局部窗口，无法捕获其他位置的信息，并日它的采样形状是固定的。另一方面，卷积核的大小周定为kxK，是一个固定的正方形，参数的数量往往随大小呈平方增长。很明显，不同数据集和不同位置的目标的形状和大小是不同的。具有固定样本形状和正方形的卷积核不能很好地适应不断变化的目标。针对上述问题，探索了可改变核卷积(AKConv)，它赋予卷积核任意数量的参数和任意采样形状，为网络开销和性能之间的权衡提供更丰富的选择。在 AKConv 中，通过新的坐标生成算法定义任意大小的卷积核的初始位置。为了适应目标的变化，引入了偏移量来调整每个位置的样本形状。此外，通过使用具有相同大小和不同初始采样形状的AKCony 来探索神经网络的效果。 AKCony 通过不规则卷积运算完成高效特征提取的过程，为卷积采样形状带来更多探索选择。

论文地址: AKConv: Convolutional Kernel with Arbitrary Sampled Shapes and Arbitrary Number of Parameters——点击即可跳转

官方代码：官方代码仓库——点击即可跳转

AKConv通过引入新的坐标生成算法来定义卷积核的初始位置，并通过引入偏移量来调整每个位置的采样形状，以适应目标的变化。这种方法使得卷积核可以根据目标的形状和大小动态地调整自身的形状和大小，从而更有效地捕获目标的特征信息。

此外，AKConv还引入了AKCony，利用不规则卷积操作来实现高效的特征提取过程。AKCony允许卷积核具有相同大小但具有不同初始采样形状，从而进一步拓展了网络的性能和适应性。

AKConv为神经网络提供了一种更加灵活和适应性强的卷积操作，能够更有效地处理不同形状和大小的目标。

总结：AKConv

2. 代码实现

2.1 将代码添加到YOLOv5中

关键步骤一: 将下面代码粘贴到/projects/yolov5-6.1/models/common.py文件中

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.checkpoint as checkpoint
import math
import numpy as np
from einops import rearrange



class AKConv(nn.Module):
    def __init__(self, inc, outc, num_param=5, stride=1, bias=None):
        super(AKConv, self).__init__()
        self.num_param = num_param
        self.stride = stride
        self.conv = nn.Sequential(nn.Conv2d(inc, outc, kernel_size=(num_param, 1), stride=(num_param, 1), bias=bias),
                                  nn.BatchNorm2d(outc),
                                  nn.SiLU())  # the conv adds the BN and SiLU to compare original Conv in YOLOv5.
        self.p_conv = nn.Conv2d(inc, 2 * num_param, kernel_size=3, padding=1, stride=stride)
        nn.init.constant_(self.p_conv.weight, 0)
        # self.p_conv.register_full_backward_hook(self._set_lr)

    @staticmethod
    def _set_lr(module, grad_input, grad_output):
        grad_input = (grad_input[i] * 0.1 for i in range(len(grad_input)))
        grad_output = (grad_output[i] * 0.1 for i in range(len(grad_output)))

    def forward(self, x):
        # N is num_param.
        offset = self.p_conv(x)
        dtype = offset.data.type()
        N = offset.size(1) // 2
        # (b, 2N, h, w)
        p = self._get_p(offset, dtype)

        # (b, h, w, 2N)
        p = p.contiguous().permute(0, 2, 3, 1)
        q_lt = p.detach().floor()
        q_rb = q_lt + 1

        q_lt = torch.cat([torch.clamp(q_lt[..., :N], 0, x.size(2) - 1), torch.clamp(q_lt[..., N:], 0, x.size(3) - 1)],
                         dim=-1).long()
        q_rb = torch.cat([torch.clamp(q_rb[..., :N], 0, x.size(2) - 1), torch.clamp(q_rb[..., N:], 0, x.size(3) - 1)],
                         dim=-1).long()
        q_lb = torch.cat([q_lt[..., :N], q_rb[..., N:]], dim=-1)
        q_rt = torch.cat([q_rb[..., :N], q_lt[..., N:]], dim=-1)

        # clip p
        p = torch.cat([torch.clamp(p[..., :N], 0, x.size(2) - 1), torch.clamp(p[..., N:], 0, x.size(3) - 1)], dim=-1)

        # bilinear kernel (b, h, w, N)
        g_lt = (1 + (q_lt[..., :N].type_as(p) - p[..., :N])) * (1 + (q_lt[..., N:].type_as(p) - p[..., N:]))
        g_rb = (1 - (q_rb[..., :N].type_as(p) - p[..., :N])) * (1 - (q_rb[..., N:].type_as(p) - p[..., N:]))
        g_lb = (1 + (q_lb[..., :N].type_as(p) - p[..., :N])) * (1 - (q_lb[..., N:].type_as(p) - p[..., N:]))
        g_rt = (1 - (q_rt[..., :N].type_as(p) - p[..., :N])) * (1 + (q_rt[..., N:].type_as(p) - p[..., N:]))

        # resampling the features based on the modified coordinates.
        x_q_lt = self._get_x_q(x, q_lt, N)
        x_q_rb = self._get_x_q(x, q_rb, N)
        x_q_lb = self._get_x_q(x, q_lb, N)
        x_q_rt = self._get_x_q(x, q_rt, N)

        # bilinear
        x_offset = g_lt.unsqueeze(dim=1) * x_q_lt + \
                   g_rb.unsqueeze(dim=1) * x_q_rb + \
                   g_lb.unsqueeze(dim=1) * x_q_lb + \
                   g_rt.unsqueeze(dim=1) * x_q_rt

        x_offset = self._reshape_x_offset(x_offset, self.num_param)
        out = self.conv(x_offset)

        return out

    # generating the inital sampled shapes for the AKConv with different sizes.
    def _get_p_n(self, N, dtype):
        base_int = round(math.sqrt(self.num_param))
        row_number = self.num_param // base_int
        mod_number = self.num_param % base_int
        p_n_x, p_n_y = torch.meshgrid(
            torch.arange(0, row_number),
            torch.arange(0, base_int))
        p_n_x = torch.flatten(p_n_x)
        p_n_y = torch.flatten(p_n_y)
        if mod_number > 0:
            mod_p_n_x, mod_p_n_y = torch.meshgrid(
                torch.arange(row_number, row_number + 1),
                torch.arange(0, mod_number))

            mod_p_n_x = torch.flatten(mod_p_n_x)
            mod_p_n_y = torch.flatten(mod_p_n_y)
            p_n_x, p_n_y = torch.cat((p_n_x, mod_p_n_x)), torch.cat((p_n_y, mod_p_n_y))
        p_n = torch.cat([p_n_x, p_n_y], 0)
        p_n = p_n.view(1, 2 * N, 1, 1).type(dtype)
        return p_n

    # no zero-padding
    def _get_p_0(self, h, w, N, dtype):
        p_0_x, p_0_y = torch.meshgrid(
            torch.arange(0, h * self.stride, self.stride),
            torch.arange(0, w * self.stride, self.stride))

        p_0_x = torch.flatten(p_0_x).view(1, 1, h, w).repeat(1, N, 1, 1)
        p_0_y = torch.flatten(p_0_y).view(1, 1, h, w).repeat(1, N, 1, 1)
        p_0 = torch.cat([p_0_x, p_0_y], 1).type(dtype)

        return p_0

    def _get_p(self, offset, dtype):
        N, h, w = offset.size(1) // 2, offset.size(2), offset.size(3)

        # (1, 2N, 1, 1)
        p_n = self._get_p_n(N, dtype)
        # (1, 2N, h, w)
        p_0 = self._get_p_0(h, w, N, dtype)
        p = p_0 + p_n + offset
        return p

    def _get_x_q(self, x, q, N):
        b, h, w, _ = q.size()
        padded_w = x.size(3)
        c = x.size(1)
        # (b, c, h*w)
        x = x.contiguous().view(b, c, -1)

        # (b, h, w, N)
        index = q[..., :N] * padded_w + q[..., N:]  # offset_x*w + offset_y
        # (b, c, h*w*N)
        index = index.contiguous().unsqueeze(dim=1).expand(-1, c, -1, -1, -1).contiguous().view(b, c, -1)

        x_offset = x

当使用可变核卷积（AKConv）进行卷积处理时，会经历以下流程：

初始化：首先，需要确定卷积核的初始位置和采样形状。这可以通过新的坐标生成算法来实现，该算法可以根据输入数据的特征和网络结构来确定合适的初始位置。

特征提取：一旦确定了卷积核的初始位置和采样形状，就可以开始进行特征提取。在每个位置，卷积核会对输入数据进行采样，并根据采样结果计算出相应的特征值。这些特征值将被用于后续的处理和分析。

适应性

2.2 新增yaml文件

关键步骤二：在/projects/yolov5-6.1/models下新建文件 yolov5_akConv.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, AKConv, [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, 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)

温馨提示：本文只是对yolov5l基础上添加swin模块，如果要对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 multiple

2.3 注册模块

关键步骤三：在yolo.py中注册, 大概在260行左右添加 ‘AKConv’

完整内容：YOLOv5 | 卷积模块 | 即插即用的可变核卷积AKConv【附代码+小白可上手】——点击即可跳转

2.4 执行程序

在train.py中，将cfg的参数路径设置为yolov5_AKConv.yaml的路径

建议大家写绝对路径，确保一定能找到

🚀运行程序，如果出现下面的内容则说明添加成功🚀

3. 完整代码分享

完整内容：YOLOv5 | 卷积模块 | 即插即用的可变核卷积AKConv【附代码+小白可上手】——点击即可跳转

提取码: r916

4. GFLOPs

关于GFLOPs的计算方式可以查看：百面算法工程师 | 卷积基础知识——Convolution

未改进的YOLOv5l的GFLOPs

改进后的YOLOv5l的GFLOPs

5.进阶

如果想计算量变化更小，如何修改呢，看过我的修改你是否学会了呢？不如动手试试吧

如果你想尝试但又不知从何下手，可以在评论区问问大家，我看到后也会及时回复

6.总结

AKConv（可变核卷积）是一种改进的卷积操作，旨在克服传统卷积操作的限制。其核心思想是允许卷积核拥有任意数量的参数和采样形状，通过新的坐标生成算法确定初始位置，并引入偏移量调整采样形状，以适应不同形状和大小的目标。AKConv不仅提供了更灵活的卷积操作，还通过高效的特征提取过程实现了对目标的有效捕获，从而为神经网络带来更大的性能和适应性提升。

YOLOv5 | 卷积模块 | 即插即用的可变核卷积AKConv【附代码+小白可上手】

专栏地址： YOLOv5改进+入门——持续更新各种有效涨点方法点击即可跳转

1.原理

2. 代码实现

2.1 将代码添加到YOLOv5中

2.2 新增yaml文件

2.3 注册模块

完整内容：YOLOv5 | 卷积模块 | 即插即用的可变核卷积AKConv【附代码+小白可上手】——点击即可跳转

2.4 执行程序

3. 完整代码分享

完整内容：YOLOv5 | 卷积模块 | 即插即用的可变核卷积AKConv【附代码+小白可上手】——点击即可跳转

4. GFLOPs

关于GFLOPs的计算方式可以查看：百面算法工程师 | 卷积基础知识——Convolution

5.进阶

6.总结

视觉智能

热门文章

最新文章

相关课程

相关电子书

相关实验场景

YOLOv5 | 卷积模块 | 即插即用的可变核卷积AKConv【附代码+小白可上手】

专栏地址： YOLOv5改进+入门——持续更新各种有效涨点方法 点击即可跳转

1.原理

2. 代码实现

2.1 将代码添加到YOLOv5中

2.2 新增yaml文件

2.3 注册模块

完整内容：YOLOv5 | 卷积模块 | 即插即用的可变核卷积AKConv【附代码+小白可上手】——点击即可跳转

2.4 执行程序

3. 完整代码分享

完整内容：YOLOv5 | 卷积模块 | 即插即用的可变核卷积AKConv【附代码+小白可上手】——点击即可跳转

4. GFLOPs

关于GFLOPs的计算方式可以查看：百面算法工程师 | 卷积基础知识——Convolution

5.进阶

6.总结

视觉智能

热门文章

最新文章

相关课程

相关电子书

相关实验场景

专栏地址： YOLOv5改进+入门——持续更新各种有效涨点方法点击即可跳转