YOLOv8 | 融合改进 | C2f融合可变核卷积AKConv【附代码+小白可上手】

news2024/11/25 14:20:14

 秋招面试专栏推荐 ：深度学习算法工程师面试问题总结【百面算法工程师】——点击即可跳转

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

专栏目录 ：《YOLOv8改进有效涨点》专栏介绍 & 专栏目录 | 目前已有90+篇内容，内含各种Head检测头、损失函数Loss、Backbone、Neck、NMS等创新点改进——点击即可跳转

在目标检测领域内，尽管YOLO系列的算法傲视群雄，但在某些方面仍然存在改进的空间。在YOLOv8提取特征的时候，卷积的核是固定的K*K大小，导致参数数量随着大小的增加呈平方级增长。显然，不同数据集和目标的形状及大小各异，而固定形状和大小的卷积核无法灵活适应这种变化。本文给大家带来的教程是将原来的普通的卷积替换为可变核的卷积AKConv。文章在介绍主要的原理后，将手把手教学如何进行模块的代码添加和修改，并将修改后的完整代码放在文章的最后，方便大家一键运行，小白也可轻松上手实践。以帮助您更好地学习深度学习目标检测YOLO系列的挑战。

 专栏地址：YOLOv8改进——更新各种有效涨点方法——点击即可跳转 订阅学习不迷路   

目录

1.原理 

2. 将C2f_AKConv代码添加到YOLOv8中

2.1 C2f_AKConv的代码实现

2.2 更改__init__.py文件

2.3 添加yaml文件

2.4 注册模块

2.5 执行程序

3. 完整代码分享

4. GFLOPs

5. 进阶

6. 总结

1.原理 

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

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

AKconv 是一种用于卷积神经网络的新型卷积操作方法，其目的是提高网络的特征提取能力，同时解决传统卷积操作中的一些固有局限性。

核心原理：

  1. 灵活的卷积参数数量：

    • AKconv 提供了灵活的卷积核参数数量，可以让卷积核适应不同形状的目标，而不是像传统卷积那样依赖固定大小和形状的卷积核。这种灵活性可以通过调整卷积核的大小和采样点的数量来实现。

  2. 任意采样形状：

    • AKconv 可以根据不同的目标动态调整卷积核的采样形状，而不仅仅是固定的正方形采样格子。通过引入偏移（offset），AKconv 能够更好地适应目标的形状变化，从而提高特征提取的准确性。

  3. 线性增长的参数数量：

    • 与传统的卷积操作不同，AKconv 的卷积参数数量随着卷积核大小的增加呈线性增长，而不是平方增长。这种线性增长有助于降低计算和内存的开销，尤其是在需要大卷积核进行特征提取的情况下。

  4. 适用于不规则卷积操作：

    • AKconv 能够执行不规则卷积操作，即允许卷积核具有不规则的采样点分布。这种灵活性使得 AKconv 能够更有效地捕获不同尺度和形状的特征，提高卷积神经网络在复杂任务中的表现。

  5. 与现有卷积操作的兼容性：

    • AKconv 可以无缝替换现有的卷积操作，从而提升网络性能。此外，AKconv 还可以与其他新型卷积模块（如 FasterBlock 和 GSBottleneck）结合使用，进一步增强这些模块的性能。

AKconv 的设计旨在通过提供更大的灵活性和有效性，克服传统卷积操作中的局限性，从而为深度学习中的特征提取提供更强大的工具。AKconv 是一种用于卷积神经网络的新型卷积操作方法，其目的是提高网络的特征提取能力，同时解决传统卷积操作中的一些固有局限性。

核心原理：

  1. 灵活的卷积参数数量：

    • AKconv 提供了灵活的卷积核参数数量，可以让卷积核适应不同形状的目标，而不是像传统卷积那样依赖固定大小和形状的卷积核。这种灵活性可以通过调整卷积核的大小和采样点的数量来实现。

  2. 任意采样形状：

    • AKconv 可以根据不同的目标动态调整卷积核的采样形状，而不仅仅是固定的正方形采样格子。通过引入偏移（offset），AKconv 能够更好地适应目标的形状变化，从而提高特征提取的准确性。

  3. 线性增长的参数数量：

    • 与传统的卷积操作不同，AKconv 的卷积参数数量随着卷积核大小的增加呈线性增长，而不是平方增长。这种线性增长有助于降低计算和内存的开销，尤其是在需要大卷积核进行特征提取的情况下。

  4. 适用于不规则卷积操作：

    • AKconv 能够执行不规则卷积操作，即允许卷积核具有不规则的采样点分布。这种灵活性使得 AKconv 能够更有效地捕获不同尺度和形状的特征，提高卷积神经网络在复杂任务中的表现。

  5. 与现有卷积操作的兼容性：

    • AKconv 可以无缝替换现有的卷积操作，从而提升网络性能。此外，AKconv 还可以与其他新型卷积模块（如 FasterBlock 和 GSBottleneck）结合使用，进一步增强这些模块的性能。

AKconv 的设计旨在通过提供更大的灵活性和有效性，克服传统卷积操作中的局限性，从而为深度学习中的特征提取提供更强大的工具。

2. 将C2f_AKConv代码添加到YOLOv8中

2.1 C2f_AKConv的代码实现

关键步骤一：将下面代码粘贴到在/ultralytics/ultralytics/nn/modules/block.py中，并在该文件的__all__中添加“C2f_AKconv”

import math
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.gather(dim=-1, index=index).contiguous().view(b, c, h, w, N)

        return x_offset

    
    #  Stacking resampled features in the row direction.
    @staticmethod
    def _reshape_x_offset(x_offset, num_param):
        b, c, h, w, n = x_offset.size()
        # using Conv3d
        # x_offset = x_offset.permute(0,1,4,2,3), then Conv3d(c,c_out, kernel_size =(num_param,1,1),stride=(num_param,1,1),bias= False)
        # using 1 × 1 Conv
        # x_offset = x_offset.permute(0,1,4,2,3), then, x_offset.view(b,c×num_param,h,w)  finally, Conv2d(c×num_param,c_out, kernel_size =1,stride=1,bias= False)
        # using the column conv as follow， then, Conv2d(inc, outc, kernel_size=(num_param, 1), stride=(num_param, 1), bias=bias)
        
        x_offset = rearrange(x_offset, 'b c h w n -> b c (h n) w')
        return x_offset

class Bottleneck_AKConv(Bottleneck):
    """Standard bottleneck with FocusedLinearAttention."""

    def __init__(self, c1, c2, shortcut=True, g=1, k=(3, 3), e=0.5):  # ch_in, ch_out, shortcut, groups, kernels, expand
        super().__init__(c1, c2, shortcut, g, k, e)
        if k[0] == 3:
            self.cv1 = AKConv(c1, c2, k[0])
        self.cv2 = AKConv(c2, c2, k[1])

class C3_AKConv(C3):
    def __init__(self, c1, c2, n=1, shortcut=False, g=1, e=0.5):
        super().__init__(c1, c2, n, shortcut, g, e)
        c_ = int(c2 * e)  # hidden channels
        self.m = nn.Sequential(*(Bottleneck_AKConv(c_, c_, shortcut, g, k=(1, 3), e=1.0) for _ in range(n)))

class C2f_AKConv(C2f):
    def __init__(self, c1, c2, n=1, shortcut=False, g=1, e=0.5):
        super().__init__(c1, c2, n, shortcut, g, e)
        self.m = nn.ModuleList(Bottleneck_AKConv(self.c, self.c, shortcut, g, k=(3, 3), e=1.0) for _ in range(n))

AKConv 处理图像的主要流程可以分为以下几个关键步骤：

1. 初始采样点的生成：

  • 首先，AKConv 通过一个算法生成卷积核的初始采样点。这些采样点可以是任意形状和数量，不再局限于传统的正方形格子。生成的采样点既可以是规则的（如标准的 3x3 或 5x5 网格），也可以是不规则的，适应不同卷积核大小和形状的需求。

2. 计算偏移量（Offsets）：

  • AKConv 在处理图像时，会根据输入图像的特征，计算出每个采样点的偏移量。这些偏移量用于动态调整采样点的位置，使得卷积核能够更好地适应图像中的目标形状和尺度变化。偏移量的计算通常通过一个小的神经网络来完成，该网络根据输入图像的特征生成偏移。

3. 特征提取：

  • 在调整采样点后，AKConv 使用这些经过偏移调整的采样点进行卷积操作，提取图像的局部特征。由于采样点的位置是动态调整的，AKConv 能够捕获更多元和复杂的特征信息，而不仅仅局限于固定位置的局部信息。

4. 线性参数增长：

  • 与传统卷积核的参数数量随卷积核大小平方增长不同，AKConv 的参数数量随着卷积核大小线性增长。这意味着，在处理大卷积核时，AKConv 仍然能够有效控制计算和内存开销。这一步在处理图像时直接影响到模型的效率和资源使用。

5. 输出结果：

  • 最终，AKConv 将通过调整后的卷积操作得到的特征图作为输出，这些特征图能够更准确地表示输入图像的内容。与传统卷积操作相比，AKConv 的输出特征具有更高的灵活性和表达力，这为后续的图像分析任务（如分类、检测等）提供了更丰富的信息。

6. 集成到网络：

  • AKConv 可以作为模块无缝集成到现有的卷积神经网络架构中，替换标准的卷积层以提升整个网络的性能。集成后的网络可以在处理复杂的图像任务时，展示出更强的适应性和更好的表现。

通过以上流程，AKConv 能够在处理图像时更好地捕获和表示图像中的多样性特征，特别是在目标形状和尺度变化较大的场景中，提供了显著的性能提升。

2.2 更改__init__.py文件

关键步骤二：修改modules文件夹下的__init__.py文件，先导入函数

然后在下面的__all__中声明函数

2.3 添加yaml文件

关键步骤三：在/ultralytics/ultralytics/cfg/models/v8下面新建文件yolov8_AKConv.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_AKConv, [128, True]]
  - [-1, 1, Conv, [256, 3, 2]]  # 3-P3/8
  - [-1, 6, C2f_AKConv, [256, True]]
  - [-1, 1, Conv, [512, 3, 2]]  # 5-P4/16
  - [-1, 6, C2f_AKConv, [512, True]]
  - [-1, 1, AKConv, [1024, 3, 2]]  # 7-P5/32
  - [-1, 3, C2f_AKConv, [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)

  - [[15, 18, 21], 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_AKConv, [128, True]]
  - [-1, 1, Conv, [256, 3, 2]]  # 3-P3/8
  - [-1, 6, C2f_AKConv, [256, True]]
  - [-1, 1, Conv, [512, 3, 2]]  # 5-P4/16
  - [-1, 6, C2f_AKConv, [512, True]]
  - [-1, 1, AKConv, [1024, 3, 2]]  # 7-P5/32
  - [-1, 3, C2f_AKConv, [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)

  - [[15, 18, 21], 1, Segment, [nc, 32, 256]] # Segment(P3, P4, P5)

温馨提示：因为本文只是对yolov8基础上添加模块，如果要对yolov8n/l/m/x进行添加则只需要指定对应的depth_multiple 和 width_multiple。不明白的同学可以看这篇文章： yolov8yaml文件解读——点击即可跳转  

# 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_channels

2.4 注册模块

关键步骤四：在task.py的parse_model函数添加 C2f_AKConv,AKConv下面的内容

2.5 执行程序

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

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

from ultralytics import YOLO
import warnings
warnings.filterwarnings('ignore')
from pathlib import Path
 
if __name__ == '__main__':
 
 
    # 加载模型
    model = YOLO("ultralytics/cfg/v8/yolov8.yaml")  # 你要选择的模型yaml文件地址
    # Use the model
    results = model.train(data=r"你的数据集的yaml文件地址",
                          epochs=100, batch=16, imgsz=640, workers=4, name=Path(model.cfg).stem)  # 训练模型

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

                   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      6028  ultralytics.nn.modules.block.C2f_AKConv      [32, 32, 1, True]             
  3                  -1  1     18560  ultralytics.nn.modules.conv.Conv             [32, 64, 3, 2]                
  4                  -1  2     32024  ultralytics.nn.modules.block.C2f_AKConv      [64, 64, 2, True]             
  5                  -1  1     73984  ultralytics.nn.modules.conv.Conv             [64, 128, 3, 2]               
  6                  -1  2    113176  ultralytics.nn.modules.block.C2f_AKConv      [128, 128, 2, True]           
  7                  -1  1    105734  ultralytics.nn.modules.block.AKConv          [128, 256, 3, 2]              
  8                  -1  1    277516  ultralytics.nn.modules.block.C2f_AKConv      [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        [15, 18, 21]  1    897664  ultralytics.nn.modules.head.Detect           [80, [64, 128, 256]]          
YOLOv8_C2f_AKConv summary: 264 layers, 2681310 parameters, 2681294 gradients

3. 完整代码分享

https://pan.baidu.com/s/1F1REf4aTcXr8-1BI6D2_aQ?pwd=vbav

 提取码: vbav 

4. GFLOPs

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

未改进的YOLOv8nGFLOPs

img

改进后的GFLOPs

现在手上没有卡了，等过段时候有卡了把这补上，需要的同学自己测一下

5. 进阶

可以与其他的注意力机制或者损失函数等结合，进一步提升检测效果

6. 总结

AKConv 的主要原理在于通过灵活调整卷积核的参数数量和采样形状，克服传统卷积操作的局限性，实现更高效的特征提取。具体而言，AKConv 允许卷积核的参数数量随需求线性增长，而非传统的平方增长，这大大减少了计算和内存开销。此外，AKConv 能够动态调整卷积核的采样位置，以适应不同目标的形状变化，从而提高对复杂特征的捕捉能力。它支持不规则的卷积操作，能够灵活处理各种尺寸和形状的卷积核，使得网络在复杂任务中的表现更加出色。最重要的是，AKConv 可以无缝集成到现有的卷积神经网络中，替换传统卷积操作，从而提升网络的整体性能。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2035826.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【JavaEE】深入理解Spring IoC与DI：从传统开发到依赖注入的转变

【JavaEE】深入理解Spring IoC与DI：从传统开发到依赖注入的转变

目录 IoC & DI ⼊⻔什么是Spring什么是容器什么是IoCIoC介绍传统程序开发问题分析解决方案IoC程序开发IoC优势 IoC & DI ⼊⻔ IoC：Inversion of Control (控制反转) DI：Dependency Injection 在前⾯我们学习了Spring Boot和Spring MVC的开发, 可…
阅读更多...
DNS相关内容

DNS相关内容

一、dns的两种解析方式 1. 正向解析 将域名解析为 ip 地址 2. 逆向解析 将 ip 地址解析为域名 设置解析方式，都是在 zone 文件中 named.conf 解决权限 named.rfc1912.zone 解决解析方式 3.DNS 方向解析 把 192.168.71.145 这个 ip 地址逆向解析为 www.yuany…
阅读更多...
Android逆向题解攻防世界-easyjava-难度6

Android逆向题解攻防世界-easyjava-难度6

纯Java实现，不涉及so, flag加密之后与指定字符串 “wigwrkaugala"比较判断，循环一个个字符加的，那可以一个个字符对应还原。 加密算法就在a,b类里面，代码直接复制到idea ，枚举暴力破解。 每一位输入范围a-z , 找…
阅读更多...
Lua脚本 快速掌握

Lua脚本 快速掌握

1.Lua脚本概述 Lua是一种轻量级的编程语言，由巴西里约热内卢天主教大学开发。设计初衷是为了嵌入应用程序中，提供灵活的配置和脚本能力。Lua具有简洁的语法和强大的扩展性，使得它在多个领域得到了广泛应用。 Lua的特点包括动态类型、自动内…
阅读更多...
The Sandbox 游戏制作教程第 4 章｜使用装备制作游戏，触发独特互动

The Sandbox 游戏制作教程第 4 章｜使用装备制作游戏，触发独特互动

欢迎回到我们的系列，我们将记录 The Sandbox Game Maker 的 “On-Equip”（装备）功能的多种用途。 如果你刚加入 The Sandbox，On-Equip 功能是 “可收集组件”（Collectable Component）中的一个多功能工具&a…
阅读更多...
C++ list【常用接口、模拟实现等】

C++ list【常用接口、模拟实现等】

1. list的介绍及使用 1.1 list的介绍 1.list是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。 2.list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前…
阅读更多...
MyBatisPlus 第二天

MyBatisPlus 第二天

常用注解 1 TableName:数据库表名和实体类名不同时,会出现以下报错 在实体类上添加 TableName("t_user") 在开发的过程中，我们经常遇到以上的问题，即实体类所对应的表都有固定的前缀，例如t_或tbl_此时，可以使用MyBa…
阅读更多...
el-tree自定义节点内容

el-tree自定义节点内容

<el-tree :data"data" :props"defaultProps" ref"treeRef" show-checkbox check-change"handleCheckChange"><!-- 自定义节点内容 --><template #default"{ node, data, store }"><span class"tr…
阅读更多...
无人值守人工智能智慧系统数据分析：深度洞察与未来展望

无人值守人工智能智慧系统数据分析：深度洞察与未来展望

无人值守人工智能智慧系统数据分析&#xff1a;深度洞察与未来展望 随着科技的飞速发展&#xff0c;人工智能&#xff08;AI&#xff09;技术已逐渐渗透到社会经济的各个领域&#xff0c;其中无人值守人工智能智慧系统作为AI技术应用的前沿阵地&#xff0c;正引领着一场深刻的…
阅读更多...
【数量关系】毛娃儿笔记

【数量关系】毛娃儿笔记

一、导学 1、比例的常见作用 &#xff08;1&#xff09;通过份数求数量 甲&#xff1a;乙1:2 那么甲乙的人数总和一定是3的倍数 &#xff08;2&#xff09;得到倍数关系 不同的说法都可以转化为比例&#xff0c;比如甲是乙的两倍2:1、甲是乙的4/34:3、甲比乙多25%5:4 &am…
阅读更多...
基于vue框架的4S店汽车维修保养管理系统28a7y（程序+源码+数据库+调试部署+开发环境）系统界面在最后面。

基于vue框架的4S店汽车维修保养管理系统28a7y（程序+源码+数据库+调试部署+开发环境）系统界面在最后面。

系统程序文件列表 项目功能&#xff1a;客户,技师,车辆信息,财务,客户维修,维修分配,维修订单,保养预约,保养分配,保养订单,维修费用,保养费用 开题报告内容 基于Vue框架的4S店汽车维修保养管理系统 开题报告 一、项目背景与意义 随着汽车产业的迅猛发展&#xff0c;4S店作…
阅读更多...
【微前端中常见的问题及其解决办法】

【微前端中常见的问题及其解决办法】

随着前端技术的飞速发展&#xff0c;大型应用系统的复杂性和规模性日益增加&#xff0c;传统的单体前端架构逐渐暴露出维护成本高、升级困难、技术栈单一等问题。为了应对这些挑战&#xff0c;微前端&#xff08;Micro-Frontends&#xff09;作为一种新的架构模式应运而生。微前…
阅读更多...
自研Vue3低代码海报制作平台第一步：基础拖拽组件开发

自研Vue3低代码海报制作平台第一步：基础拖拽组件开发

学习来源&#xff1a;稀土掘金 - 幽月之格大佬的技术专栏可拖拽、缩放、旋转组件 - 著作&#xff1a;可拖拽、缩放、旋转组件实现细节 非常感谢大佬&#xff01;受益匪浅&#xff01; 前面我们学习了很多vue3的知识&#xff0c;是时候把它们用起来做一个有意思的平台&#xf…
阅读更多...
合合信息OCR支持30类国内常见票据一站式分类识别，支持医疗发票、数电票识别

合合信息OCR支持30类国内常见票据一站式分类识别，支持医疗发票、数电票识别

合合信息TextIn平台明星产品——国内通用票据识别&#xff0c;重磅更新&#xff01; 产品支持票据类型扩展到23大类、30小类&#xff0c;覆盖场景更全面&#xff0c;同时升级优化了多款票据识别模型&#xff0c;平均识别率较前版本提升11.5%&#xff0c;整体识别速度提升21.9%…
阅读更多...
关于k8s的Pod控制器

关于k8s的Pod控制器

目录 1.Pod控制器及其作用 2.pod控制器类型 2.1 ReplicaSet: 2.2 Deployment 2.3 DaemonSet 2.4 StatefulSet 2.5 Job 2.6 Cronjob 3.Pod与控制器之间的关系 3.1 Deployment 3.2 SatefulSet 3.3 DaemonSet 3.4 job 3.5 cronjob 1.Pod控制器及其作用 Pod控制器&am…
阅读更多...
北京某银行成功替换F5！更多实施细节曝光→

北京某银行成功替换F5！更多实施细节曝光→

随着国家对金融行业技术创新的持续关注&#xff0c;金融行业的诸多用户正积极开展业务系统的数字化创新。 在这一领域&#xff0c;保障业务稳定性和连续性始终是最重要的议题。今天&#xff0c;为大家介绍的最佳实践来自北京某银行&#xff0c;他们通过积极探索和评估&#xf…
阅读更多...
Python酷库之旅-第三方库Pandas(078)

Python酷库之旅-第三方库Pandas(078)

目录 一、用法精讲 321、pandas.Series.str.len方法 321-1、语法 321-2、参数 321-3、功能 321-4、返回值 321-5、说明 321-6、用法 321-6-1、数据准备 321-6-2、代码示例 321-6-3、结果输出 322、pandas.Series.str.ljust方法 322-1、语法 322-2、参数 322-3、…
阅读更多...
HMAC算法：构建安全认证的基石

HMAC算法：构建安全认证的基石

在信息安全领域&#xff0c;数据完整性和认证是至关重要的。HMAC&#xff08;Hash-based Message Authentication Code&#xff09;算法作为一种基于哈希的消息认证码&#xff0c;广泛应用于数据传输过程中的安全认证。本文将带你了解HMAC算法的原理、特点及其应用场景。 HMAC算…
阅读更多...
全方位解析RAG技术：从概念理论到代码实操，一文助你掌握检索增强生成的精髓！

全方位解析RAG技术：从概念理论到代码实操，一文助你掌握检索增强生成的精髓！

一、LLMs 已经具备了较强能力了&#xff0c;为什么还需要 RAG(检索增强生成)? 尽管 LLM 已展现出显著的能力&#xff0c;但以下几个挑战依然值得关注&#xff1a; 幻觉问题&#xff1a;LLM 采用基于统计的概率方法逐词生成文本&#xff0c;这一机制内在地导致其可能出现看似…
阅读更多...
Git基础使用教程

Git基础使用教程

版本控制手册 本文中出现的 [ ] 为根据需求自行修改的变量。 基本命令 git init&#xff1a;将当前目录配置成git仓库&#xff0c;信息记录在隐藏的.git文件夹中。 git config --global user.name [xxx]&#xff1a;设置全局用户名&#xff0c;信息记录在~/.gitconfig文件中。…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023