Ajax动态内容加载与无刷新页面切换的实现教程

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

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

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

本文介绍的是之前介绍的Efficient Multi-Scale Conv的模块Plus版融合到C2f中。文章在介绍主要的原理后，将手把手教学如何进行模块的代码添加和修改，并将修改后的完整代码放在文章的最后，方便大家一键运行，小白也可轻松上手实践。以帮助您更好地学习深度学习目标检测YOLO系列的挑战。

目录

1. 原理

2. 将C2f_EMSCP添加到yolov8网络中

2.1 C2f_EMSCP 代码实现

2.2 更改init.py文件

2.3 添加yaml文件

2.4 注册模块

2.5 执行程序

3. 完整代码分享

4. GFLOPs

5. 进阶

6. 总结

1. 原理

论文地址：EMCAD: Efficient Multi-scale Convolutional Attention Decoding for Medical Image Segmentation——点击即可跳转 

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

高效多尺度卷积，如论文“EMCAD：用于医学图像分割的高效多尺度卷积注意力解码”中所述，围绕着提高卷积神经网络 (CNN) 用于医学图像分割的效率和有效性的想法。核心创新是在基于注意力的解码框架中使用多尺度深度卷积块，旨在优化特征图的处理以实现高分辨率分割，同时降低计算开销。

关键组件和原理：

多尺度卷积注意力模块 (MSCAM)：

• MSCAM 通过结合三种类型的注意力来细化特征图：

• 通道注意力：专注于选择信息量最大的通道。

• 空间注意力：通过强调最相关的空间区域来捕获局部上下文信息。

• 多尺度卷积块 (MSCB)：通过使用深度卷积以不同尺度处理特征来增强特征。与传统卷积层相比，这使模型能够以更低的计算成本捕获各种尺度和分辨率的细节。

深度卷积：

• 使用深度卷积代替标准卷积在每个通道上独立执行操作，这大大减少了所需的参数和计算量。

• 通过在多个尺度上执行这些卷积，模型可以同时有效地捕获精细细节和更广泛的上下文，这对于准确的医学图像分割至关重要。

大核分组注意力门 (LGAG)：

• 此组件旨在通过将特征图与网络中较早层的跳过连接相结合来细化特征图。它使用大核（例如 3x3）组卷积，允许以较少的计算成本捕获更大的空间上下文，有助于在减少所需操作数的同时保持高精度。

效率提升：

• 整体架构设计为计算高效且高效。例如，当与标准分层视觉编码器集成时，与最先进的方法相比，EMCAD 可以显著减少参数和浮点运算 (FLOP) 的数量，同时保持或提高分割精度。

高效多尺度卷积 方法利用这些原理来解决平衡计算效率和分割性能的挑战，特别是在医学成像领域，高精度至关重要，但计算资源可能有限。

这两个函数EMSConv和EMSConvP都是用于实现高效多尺度卷积（Efficient Multi-Scale Convolution）的PyTorch模块。尽管它们的设计思想相似，都是通过多个不同尺寸的卷积核对输入特征图进行处理，之后将处理结果进行组合，但它们之间有一些重要的区别。

1. 输入通道的划分方式

• EMSConv：输入特征图首先被分成两部分，其中一半的通道数被直接保留（称为x_cheap），另一半的通道数被进一步分组以进行多尺度卷积处理（称为x_group）。

• EMSConvP：整个输入特征图被均匀地分组，每组通道数都用于多尺度卷积处理，没有保留直接传递的部分。

2. 卷积操作的多尺度处理

• EMSConv：多尺度卷积操作仅对输入通道中的一部分（x_group）进行，其余一部分（x_cheap）不参与多尺度卷积处理。这样做的目的是减少计算量，同时保持部分原始特征。

• EMSConvP：对输入的所有通道都进行多尺度卷积处理，整个输入特征图都会经过不同卷积核的处理，再通过1x1卷积将处理后的结果组合成最终的输出特征图。

3. 输出特征图的合成

• EMSConv：将多尺度卷积处理后的特征与直接保留的特征拼接在一起，然后通过一个1x1卷积进行通道融合，生成最终的输出特征图。

• EMSConvP：直接将所有多尺度卷积的结果进行通道融合，然后通过一个1x1卷积进一步整合，得到最终输出特征图。

4. 适用场景的差异

• EMSConv：适合在需要减少计算复杂度的情况下使用，因为它保留了一部分未经过多尺度处理的特征，从而减少了计算量。

• EMSConvP：适合在追求特征提取全面性的场景下使用，因为它对所有输入通道都进行了多尺度处理，因此特征提取更为充分。

总结

EMSConv 通过只对部分通道进行多尺度卷积来降低计算量，而 EMSConvP 则对所有通道进行多尺度卷积，以获得更全面的特征表示。这两种方法在计算成本和特征提取的全面性之间进行了不同的权衡。

2. 将C2f_EMSCP添加到yolov8网络中

2.1 C2f_EMSCP 代码实现

from einops import rearrange

class EMSConv(nn.Module):
    # Efficient Multi-Scale Conv
    def __init__(self, channel=256, kernels=[3, 5]):
        super().__init__()
        self.groups = len(kernels)
        min_ch = channel // 4
        assert min_ch >= 16, f'channel must Greater than {64}, but {channel}'
        
        self.convs = nn.ModuleList([])
        for ks in kernels:
            self.convs.append(Conv(c1=min_ch, c2=min_ch, k=ks))
        self.conv_1x1 = Conv(channel, channel, k=1)
        
    def forward(self, x):
        _, c, _, _ = x.size()
        x_cheap, x_group = torch.split(x, [c // 2, c // 2], dim=1)
        x_group = rearrange(x_group, 'bs (g ch) h w -> bs ch h w g', g=self.groups)
        x_group = torch.stack([self.convs[i](x_group[..., i]) for i in range(len(self.convs))])
        x_group = rearrange(x_group, 'g bs ch h w -> bs (g ch) h w')
        x = torch.cat([x_cheap, x_group], dim=1)
        x = self.conv_1x1(x)
        
        return x

class EMSConvP(nn.Module):
    # Efficient Multi-Scale Conv Plus
    def __init__(self, channel=256, kernels=[1, 3, 5, 7]):
        super().__init__()
        self.groups = len(kernels)
        min_ch = channel // self.groups
        assert min_ch >= 16, f'channel must Greater than {16 * self.groups}, but {channel}'
        
        self.convs = nn.ModuleList([])
        for ks in kernels:
            self.convs.append(Conv(c1=min_ch, c2=min_ch, k=ks))
        self.conv_1x1 = Conv(channel, channel, k=1)
        
    def forward(self, x):
        x_group = rearrange(x, 'bs (g ch) h w -> bs ch h w g', g=self.groups)
        x_convs = torch.stack([self.convs[i](x_group[..., i]) for i in range(len(self.convs))])
        x_convs = rearrange(x_convs, 'g bs ch h w -> bs (g ch) h w')
        x_convs = self.conv_1x1(x_convs)
        
        return x_convs

class Bottleneck_EMSC(Bottleneck):
    def __init__(self, c1, c2, shortcut=True, g=1, k=(3, 3), e=0.5):
        super().__init__(c1, c2, shortcut, g, k, e)
        c_ = int(c2 * e)  # hidden channels
        self.cv1 = Conv(c1, c_, k[0], 1)
        self.cv2 = EMSConv(c2)

class Bottleneck_EMSCP(Bottleneck):
    def __init__(self, c1, c2, shortcut=True, g=1, k=(3, 3), e=0.5):
        super().__init__(c1, c2, shortcut, g, k, e)
        c_ = int(c2 * e)  # hidden channels
        self.cv1 = Conv(c1, c_, k[0], 1)
        self.cv2 = EMSConvP(c2)

class C3_EMSCP(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_EMSCP(c_, c_, shortcut, g, k=((1, 1), (3, 3)), e=1.0) for _ in range(n)))

class C2f_EMSCP(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_EMSCP(self.c, self.c, shortcut, g, k=(3, 3), e=1.0) for _ in range(n))

EMSC（Efficient Multi-scale Convolutional Attention Decoding）在处理图像时，通过多步骤的流程来进行高效的医疗图像分割。以下是其主要流程的详细说明：

1. 特征提取（Feature Extraction）

• 输入的医疗图像首先通过预训练的分层视觉编码器（例如，CNN或Transformer架构）进行处理，提取出多阶段的特征图。编码器将图像分解为不同层次的特征表示，通常包括四个主要阶段的特征图（X1, X2, X3, X4）。

2. 多尺度卷积注意模块（MSCAM）

• 每个阶段提取的特征图首先进入多尺度卷积注意模块（MSCAM）。MSCAM使用通道注意力、空间注意力和多尺度卷积块来细化这些特征图：

  • 通道注意力（Channel Attention）增强那些对任务最有贡献的通道。

  • 空间注意力（Spatial Attention）聚焦在图像中最相关的空间区域。

  • 多尺度卷积块（MSCB）使用多尺度的深度卷积来捕获不同尺度和分辨率的特征，保证细节与全局信息的兼顾。

3. 大核分组注意力门（LGAG）

• 经过MSCAM处理后的特征图会通过大核分组注意力门（LGAG）进行进一步优化。LGAG融合了当前特征图与来自跳跃连接（skip connection）的特征，利用大核分组卷积在更大的局部上下文中捕获重要特征，同时减少计算负担。

4. 上采样与特征增强（Upsampling and Feature Enhancement）

• 优化后的特征图通过高效上卷积块（EUCB）进行上采样，使其分辨率逐步恢复到原始输入图像的大小。在上采样的过程中，EUCB进一步增强特征图，以确保最终的分割结果具有高分辨率和准确性。

5. 分割输出（Segmentation Output）

• 在每个特征提取阶段的末端，通过分割头（Segmentation Head）生成阶段性的分割图。这些分割图会在最后累加，得到最终的分割输出图。

6. 多阶段集成与输出

• EMSC通过集成来自多个阶段的分割图，结合细化后的特征，最终生成精准的医疗图像分割结果。这个过程确保了分割输出既具有细节分辨能力，又能捕捉全局信息，适应不同分辨率和尺度的需求。

这种处理流程使得EMSC在保持高精度的同时，极大地降低了计算开销和参数数量，适用于资源受限的医疗图像处理任务。

2.2 更改init.py文件

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

2.3 添加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_EMSCP, [512, True]]
  - [-1, 1, Conv, [1024, 3, 2]]  # 7-P5/32
  - [-1, 3, C2f_EMSCP, [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_EMSCP, [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_EMSCP, [512]]  # 18 (P4/16-medium)

  - [-1, 1, Conv, [512, 3, 2]]
  - [[-1, 9], 1, Concat, [1]]  # cat head P5
  - [-1, 3, C2f_EMSCP, [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, [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_EMSCP, [512, True]]
  - [-1, 1, Conv, [1024, 3, 2]]  # 7-P5/32
  - [-1, 3, C2f_EMSCP, [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_EMSCP, [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_EMSCP, [512]]  # 18 (P4/16-medium)

  - [-1, 1, Conv, [512, 3, 2]]
  - [[-1, 9], 1, Concat, [1]]  # cat head P5
  - [-1, 3, C2f_EMSCP, [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 注册模块

2.5 执行程序

在train.py中，将model的参数路径设置为yolov8_C2f_EMSCP.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      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    175360  ultralytics.nn.modules.block.C2f_EMSCP       [128, 128, 2, True]
  7                  -1  1    295424  ultralytics.nn.modules.conv.Conv             [128, 256, 3, 2]
  8                  -1  1    415488  ultralytics.nn.modules.block.C2f_EMSCP       [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    137088  ultralytics.nn.modules.block.C2f_EMSCP       [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    112512  ultralytics.nn.modules.block.C2f_EMSCP       [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    448256  ultralytics.nn.modules.block.C2f_EMSCP       [384, 256, 1]
 22        [15, 18, 21]  1    897664  ultralytics.nn.modules.head.Detect           [80, [64, 128, 256]]
YOLOv8_C2f_EMSCP summary: 309 layers, 3023056 parameters, 3023040 gradients, 8.6 GFLOPs

3. 完整代码分享

https://pan.baidu.com/s/1lrKsYqbKKplarVbNZdGFmw?pwd=rkps

提取码: rkps 

4. GFLOPs

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

未改进的YOLOv8nGFLOPs

改进后的GFLOPs

5. 进阶

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

6. 总结

Efficient Multi-Scale Convolution 通过引入多尺度深度卷积块和注意力机制，优化了医疗图像分割中的解码过程。EMCAD利用多尺度卷积捕捉不同尺度和分辨率的特征，结合通道注意力和空间注意力机制，有效增强了特征图的表达能力。通过使用深度卷积和大核分组注意力门，EMCAD在减少计算量的同时，保持了对复杂空间关系和重要区域的准确捕捉。最终，这种设计大幅降低了模型的参数量和计算复杂度，在提高分割精度的同时实现了计算资源的高效利用。