YOLO系列笔记（十七）—— YOLOv5各层详细介绍（附python代码）：Focus，Conv，C3，SPPF，特征金字塔及多尺度训练

XISHI_TIANLAN

于 2024-05-20 14:19:46 发布

阅读量1.1k

点赞数 20

文章标签： YOLO 笔记 python 深度学习计算机视觉

本文链接：https://blog.csdn.net/XISHI_TIANLAN/article/details/139051857

版权

前言

在目标检测任务中，模型的结构和各个模块的设计对检测性能有着至关重要的影响。本文将详细介绍YOLOv5中的一些关键模块和技术，包括Focus层、卷积层（Conv）、C3层、SPPF层、特征金字塔（Feature Pyramid）以及多尺度训练（Multi-scale Training）。这些模块和技术共同构成了YOLOv5强大的目标检测能力。

如果觉得该笔记对您有用的话，可以点个小小的赞，或者点赞收藏关注一键三连ヾ(◍’౪`◍) ~ 谢谢！！

一、 Focus层

Focus层是YOLOv5模型中引入的一种创新层，用于在不丢失信息的情况下增加计算效率。它通过将空间维度的信息重新排列到通道维度，从而提高模型的计算效率。

1.1 什么是Focus层？

Focus层的核心思想是将输入图像的空间信息（即宽度和高度）重新排列成更多的通道信息。具体来说，它通过将输入图像中的每个2x2块像素提取出来，并将其组合成新的通道（如下图）。这样做可以在减少空间尺寸的同时保持输入图像的信息。
在这里插入图片描述

1.2 详细操作步骤

假设输入图像的尺寸为 $\times W \times C )$ ，其中 H 是高度， W 是宽度， C 是通道数。Focus层的操作步骤如下：

划分2x2块：
- 将输入图像划分为多个2x2的块。
重排像素到通道：
- 每个2x2的块包含4个像素，将这4个像素重新排列到新的通道上。
- 这样，新的通道数将是原始通道数的4倍，而空间维度（宽度和高度）将减半。

通过这种操作，输入图像的信息被重新排列为较少的空间维度和较多的通道维度。

1.3 公式表达

假设输入图像的尺寸为 $\times W \times C )$ ，经过Focus层后，输出图像的尺寸将变为 $\frac{H}{2} \times \frac{W}{2} \times 4C )$ 。

1.4 Python实现

下面是用Python和PyTorch实现Focus层的示例：

import torch
import torch.nn as nn

class Focus(nn.Module):
    def __init__(self):
        super(Focus, self).__init__()
    
    def forward(self, x):
        # x: (batch_size, channels, height, width)
        return torch.cat([x[..., ::2, ::2],  # 每隔一个像素取值
                          x[..., 1::2, ::2],  # 从第二个像素开始，每隔一个像素取值
                          x[..., ::2, 1::2],  # 每隔一个像素取值，从第二列开始
                          x[..., 1::2, 1::2]],  # 从第二个像素和第二列开始，每隔一个像素取值
                          dim=1)  # 在通道维度上拼接

# 测试Focus层
x = torch.randn(1, 3, 640, 640)  # 假设输入为640x640的RGB图像
focus = Focus()
y = focus(x)
print(y.shape)  # 输出形状为(1, 12, 320, 320)，即通道数变为原来的4倍，空间维度减半

1.5 优势分析

提高计算效率：
- 通过减少空间维度（从640x640到320x320），减少了后续卷积层的计算量。
- 增加通道数使得每个卷积核能够捕获更多的信息。
不丢失信息：
- 重新排列操作只是改变了数据的排列方式，并没有丢失任何信息。
- 原始图像的所有像素值都被保留下来，只是分布在不同的通道上。
实现有效的下采样：
- Focus层在下采样的同时保留了更多的原始信息，这比直接使用卷积下采样（如stride为2的卷积）更有效。

1.6 总结

Focus层通过将空间维度的信息重新排列到通道维度，达到了在不丢失信息的情况下提高计算效率的目的。这种方法在YOLOv5中被有效地应用，从而提高了模型的性能和效率。

二、Conv层

卷积层（Convolutional Layer, 简称 Conv 层）是卷积神经网络（Convolutional Neural Network, CNN）的基本构建模块之一。它通过在输入图像上应用卷积操作来提取特征。以下是对卷积层的详细解释，包括其目的、工作原理、参数和应用。

2.1 目的

卷积层的主要目的是通过学习多个滤波器（或称为卷积核）来提取输入图像的特征。滤波器可以识别不同层次的特征，例如边缘、纹理、形状和对象。

2.2 工作原理

卷积操作是指用一个滤波器在输入图像上滑动（或卷积），计算滤波器与图像局部区域的点积，生成特征图（Feature Map）。这个过程通常包括以下步骤：

滤波器初始化：
- 滤波器是一个小矩阵，通常为3x3、5x5或7x7。
- 滤波器的参数（权重）在训练过程中通过反向传播算法进行优化。
滑动滤波器：
- 滤波器在输入图像上以一定的步幅（Stride）滑动。
- 每次滑动时，计算滤波器与当前覆盖区域的点积，得到一个值作为特征图上的一个像素。
生成特征图：
- 滤波器在整个输入图像上滑动完成后，生成一个特征图。
- 使用多个滤波器可以生成多个特征图，每个特征图对应一个滤波器。

2.3 参数

卷积层有几个重要的超参数，这些参数决定了卷积操作的具体方式：

滤波器大小（Kernel Size）：
- 滤波器的尺寸，如3x3、5x5等。
- 滤波器越大，捕捉的特征越多，但计算复杂度也越高。
步幅（Stride）：
- 滤波器在输入图像上滑动的步幅大小。
- 步幅越大，生成的特征图越小。
填充（Padding）：
- 在输入图像的边缘填充额外的像素，以控制特征图的尺寸。
- 常见的填充方式包括VALID（无填充）和SAME（填充使得输出尺寸与输入相同）。
滤波器数量（Number of Filters）：
- 卷积层中使用的滤波器的数量。
- 每个滤波器生成一个特征图，滤波器越多，生成的特征图越多。

具体的计算公式可参考笔者之前的博客：YOLO系列笔记（十）—— 基础：卷积层及其计算公式。

2.4. 应用

卷积层在各种计算机视觉任务中有广泛的应用，主要包括：

图像分类：提取不同层次的特征，用于识别和分类图像中的对象。
目标检测：定位和识别图像中的多个对象。
图像分割：将图像分割成不同的区域，每个区域对应不同的对象或背景。
特征提取：在更高级别的任务中作为预处理步骤，提取有用的特征。

2.5 Python实现

以下是一个使用PyTorch定义和应用卷积层的示例代码：

import torch
import torch.nn as nn
import torch.nn.functional as F

class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        # 定义一个卷积层
        self.conv1 = nn.Conv2d(in_channels=3, out_channels=16, kernel_size=3, stride=1, padding=1)
        # 定义一个池化层
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2, padding=0)
        # 定义一个全连接层
        self.fc1 = nn.Linear(16 * 16 * 16, 10)  # 假设输入图像大小为32x32

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))  # 应用卷积、ReLU激活和池化
        x = x.view(-1, 16 * 16 * 16)  # 展平
        x = self.fc1(x)  # 应用全连接层
        return x

# 创建一个简单的CNN模型
model = SimpleCNN()
print(model)

# 假设输入图像大小为32x32
input_tensor = torch.randn(1, 3, 32, 32)
output = model(input_tensor)
print(output.shape)  # 输出形状

2.6 总结

卷积层通过应用多个滤波器在输入图像上滑动，提取局部特征并生成特征图。这些特征图用于捕捉图像中的不同模式和结构，是计算机视觉任务中非常有效的工具。通过调整卷积层的超参数（如滤波器大小、步幅、填充和滤波器数量），可以优化模型以适应特定的任务和数据集。

三、C3层

C3层是YOLOv5网络架构中的一个重要模块，它在提升模型性能和计算效率方面起着关键作用。C3层结合了残差结构和跨层连接的思想，类似于ResNet中的Bottleneck结构，但进行了改进以适应YOLOv5的需求。以下是对C3层的详细解释，包括其目的、结构和工作原理。

3.1 目的

C3层旨在增强特征提取能力和特征融合能力，同时保持计算效率。它通过将输入特征进行分组处理，并通过跨层连接来融合不同层次的特征，从而提高模型的表达能力。

3.2 结构

C3层由以下几个主要部分组成：

1x1卷积：用于减少特征维度，从而降低计算量。
Bottleneck模块：类似于ResNet中的Bottleneck结构，由多个串联的卷积层和跨层连接组成。
跨层连接（Residual Connection）：将输入特征直接添加到输出特征上，促进特征的流动，防止梯度消失。
特征融合：将不同路径的特征进行融合，增强特征表达能力。

3.3 工作原理

以下是C3层的详细工作原理：

输入特征分组：
- 输入特征被分成两组，其中一组直接通过一个Bottleneck模块，另一组经过卷积模块。
Bottleneck模块处理：
- 每个Bottleneck模块由多个卷积层和跨层连接组成，用于提取高级特征。
- 跨层连接使得输入特征可以直接传递到输出层，促进特征的流动。
特征融合：
- 将两个Bottleneck模块的输出特征进行融合，通常通过拼接（Concatenation）或加法（Addition）的方式。
输出特征：
- 最终输出的特征包含了经过不同路径处理的特征，增强了特征的多样性和表达能力。

3.4 实现

以下是一个使用PyTorch实现C3层的示例代码：

import torch
import torch.nn as nn

class Bottleneck(nn.Module):
    def __init__(self, in_channels, out_channels, shortcut=True, groups=1, expansion=0.5):
        super(Bottleneck, self).__init__()
        hidden_channels = int(out_channels * expansion)
        self.conv1 = nn.Conv2d(in_channels, hidden_channels, 1, 1, 0, bias=False)
        self.bn1 = nn.BatchNorm2d(hidden_channels)
        self.act1 = nn.LeakyReLU(0.1, inplace=True)
        self.conv2 = nn.Conv2d(hidden_channels, out_channels, 3, 1, 1, groups=groups, bias=False)
        self.bn2 = nn.BatchNorm2d(out_channels)
        self.act2 = nn.LeakyReLU(0.1, inplace=True)
        self.shortcut = shortcut and in_channels == out_channels

    def forward(self, x):
        y = self.conv1(x)
        y = self.bn1(y)
        y = self.act1(y)
        y = self.conv2(y)
        y = self.bn2(y)
        if self.shortcut:
            y = y + x
        return self.act2(y)

class C3(nn.Module):
    def __init__(self, in_channels, out_channels, num_bottlenecks=3, groups=1, expansion=0.5):
        super(C3, self).__init__()
        hidden_channels = int(out_channels * expansion)
        self.conv1 = nn.Conv2d(in_channels, hidden_channels, 1, 1, 0, bias=False)
        self.conv2 = nn.Conv2d(in_channels, hidden_channels, 1, 1, 0, bias=False)
        self.conv3 = nn.Conv2d(2 * hidden_channels, out_channels, 1, 1, 0, bias=False)
        self.bn = nn.BatchNorm2d(out_channels)
        self.act = nn.LeakyReLU(0.1, inplace=True)
        self.bottlenecks = nn.Sequential(
            *[Bottleneck(hidden_channels, hidden_channels, shortcut=True, groups=groups, expansion=1.0) for _ in range(num_bottlenecks)]
        )

    def forward(self, x):
        y1 = self.bottlenecks(self.conv1(x))
        y2 = self.conv2(x)
        y = torch.cat((y1, y2), dim=1)
        y = self.conv3(y)
        y = self.bn(y)
        return self.act(y)

# 测试C3层
x = torch.randn(1, 64, 256, 256)  # 假设输入为256x256的特征图
c3_layer = C3(in_channels=64, out_channels=128)
y = c3_layer(x)
print(y.shape)  # 输出形状为(1, 128, 256, 256)

3.5 优势

增强特征表达：通过多路径处理和跨层连接，C3层能够提取更加丰富和多样的特征。
保持计算效率：通过1x1卷积和Bottleneck结构，C3层在增强特征提取能力的同时，保持了较低的计算量。
防止梯度消失：跨层连接有助于梯度的传递，避免了深层网络中常见的梯度消失问题。

3.6 总结

C3层是YOLOv5中一个关键的结构模块，通过结合Bottleneck结构和跨层连接来增强特征提取和融合能力。它在保持计算效率的同时，提高了模型的特征表达能力，从而提升了目标检测的性能。

四、SPPF层

SPPF层是YOLOv5架构中的一个模块，全称为“Spatial Pyramid Pooling - Fast”。SPPF层的设计目的是通过一种高效的方式来进行多尺度特征融合，从而提升模型的特征提取能力，同时保持较低的计算复杂度。它是对原始SPP（Spatial Pyramid Pooling）层的改进版本。

4.1 SPP层回顾

SPP（Spatial Pyramid Pooling）层的主要作用是在不同尺度的特征图上进行池化操作，以获取多尺度的上下文信息。这种方法通过在不同尺度上进行池化操作，然后将结果拼接在一起，增强了模型对不同尺度特征的表达能力。

4.2 SPPF层特点

SPPF（Spatial Pyramid Pooling - Fast）层在保持SPP层核心思想的基础上进行了优化，以提高计算效率。具体来说，SPPF层通过减少冗余计算和优化操作顺序，实现了更高效的特征融合。

4.3 工作原理

特征提取：
- 输入特征图经过几次池化操作，得到不同尺度的特征图。
池化操作：
- SPPF层通常使用较大的池化窗口（如5x5），并通过多次池化操作来获取多尺度的特征。
特征拼接：
- 将不同尺度池化操作的结果在通道维度上进行拼接，从而生成具有多尺度信息的特征图。

4.4 实现

以下是使用PyTorch实现SPPF层的示例代码：

import torch
import torch.nn as nn

class SPPF(nn.Module):
    def __init__(self, in_channels, out_channels, kernel_size=5):
        super(SPPF, self).__init__()
        hidden_channels = in_channels // 2
        self.conv1 = nn.Conv2d(in_channels, hidden_channels, 1, 1, 0, bias=False)
        self.bn1 = nn.BatchNorm2d(hidden_channels)
        self.act1 = nn.LeakyReLU(0.1, inplace=True)
        self.pool = nn.MaxPool2d(kernel_size=kernel_size, stride=1, padding=kernel_size // 2)
        self.conv2 = nn.Conv2d(hidden_channels * 4, out_channels, 1, 1, 0, bias=False)
        self.bn2 = nn.BatchNorm2d(out_channels)
        self.act2 = nn.LeakyReLU(0.1, inplace=True)

    def forward(self, x):
        x = self.act1(self.bn1(self.conv1(x)))
        y1 = self.pool(x)
        y2 = self.pool(y1)
        y3 = self.pool(y2)
        y = torch.cat([x, y1, y2, y3], 1)
        y = self.act2(self.bn2(self.conv2(y)))
        return y

# 测试SPPF层
x = torch.randn(1, 64, 256, 256)  # 假设输入为256x256的特征图
sppf_layer = SPPF(in_channels=64, out_channels=128)
y = sppf_layer(x)
print(y.shape)  # 输出形状为(1, 128, 256, 256)

4.5 优势

多尺度特征融合：
- 通过不同尺度的池化操作，SPPF层可以有效地捕获多尺度的特征，提高模型对不同尺度目标的识别能力。
计算效率高：
- 相对于原始的SPP层，SPPF层通过减少冗余计算和优化操作顺序，实现了更高的计算效率。
简单易用：
- SPPF层通过简单的池化和拼接操作就能实现复杂的多尺度特征融合，易于在各种网络架构中集成。

4.6 总结

SPPF层在YOLOv5中起到了重要的作用，通过多尺度池化和特征融合，增强了模型对不同尺度目标的识别能力。同时，通过优化计算过程，SPPF层在保持计算效率的前提下实现了强大的特征提取能力。这样的设计使得YOLOv5在目标检测任务中能够高效地处理各种尺度的目标。

—————————————————————我是分界线——————————————————————

以上介绍的是属于Backbone，也就是主干网络中的层，主要负责提取输入图像的特征，在保证较高检测精度的同时，尽可能地减少计算量和内存占用。这里需要明确C3模块则将前面的特征图进行自适应聚合，SPPF模块通过全局特征与局部特征的加权融合，获取更全面的空间信息。在Backbone之后会跟着Head部分，该部分负责对Backbone提取的特征进行多尺度特征融合，并最后输出预测结果。运用到的技术是接下来要介绍的特征金字塔技术。在目标检测中，特征金字塔（Feature Pyramid）是指由不同尺度的特征图组成的层级结构。这种结构有助于模型在不同尺度上提取和融合特征，以便更好地检测图像中的各种目标。

五、特征金字塔

特征金字塔是一种多尺度特征提取和表示的方法。它通过在卷积神经网络的不同层级上提取特征图，形成一个由多尺度特征图组成的层级结构。每个层级的特征图包含不同尺度的图像信息。

5.1 高层级特征图 vs. 低层级特征图

高层级特征图（Higher-level Feature Maps）：
- 较低的空间分辨率：特征图的宽度和高度较小，即图像被缩小了很多倍。
- 更高级的语义信息：这些特征图经过多层卷积和下采样（如池化层或步幅卷积）后，能够捕捉到图像中更复杂和抽象的特征，如物体的类别、形状和语义信息。
- 举例：如果输入图像是256x256，高层级特征图可能是16x16，但每个特征图上的像素点包含丰富的语义信息。
低层级特征图（Lower-level Feature Maps）：
- 较高的空间分辨率：特征图的宽度和高度较大，即图像被缩小的倍数较小。
- 较少的语义信息：这些特征图主要捕捉图像中的低级特征，如边缘、纹理和颜色，但缺乏复杂的语义信息。
- 举例：如果输入图像是256x256，低层级特征图可能是128x128，包含更多的空间细节，但语义信息较少。

5.2 特征金字塔的层级结构

特征金字塔在不同层级上提供了不同尺度的特征图。这个层级结构有助于模型在不同尺度上检测目标，从而提高检测的准确性和鲁棒性。

低层级特征图：捕捉到的细节信息多，适用于检测小物体。
高层级特征图：捕捉到的语义信息多，适用于检测大物体和复杂背景中的目标。

5.3 特征金字塔在目标检测中的应用

特征金字塔被广泛应用于各种目标检测模型中，如Faster R-CNN、YOLOv5和RetinaNet等。这些模型利用特征金字塔进行多尺度特征提取和融合，以实现对不同尺度目标的有效检测。

FPN（Feature Pyramid Network）：通过自上而下的路径增强和横向连接，融合不同层级的特征图，以提高模型的多尺度检测能力。
YOLOv5：在其架构中使用了特征金字塔来提取和融合多尺度特征，从而提高目标检测的性能。

5.4代码示例

以下是一个简单的示例，展示如何在PyTorch中构建特征金字塔：

import torch
import torch.nn as nn
import torch.nn.functional as F

class FeaturePyramidNetwork(nn.Module):
    def __init__(self, in_channels_list, out_channels):
        super(FeaturePyramidNetwork, self).__init__()
        self.inner_blocks = nn.ModuleList()
        self.layer_blocks = nn.ModuleList()
        
        for in_channels in in_channels_list:
            self.inner_blocks.append(nn.Conv2d(in_channels, out_channels, 1))
            self.layer_blocks.append(nn.Conv2d(out_channels, out_channels, 3, padding=1))

    def forward(self, x):
        # Assume x is a list of feature maps from different layers of a backbone
        results = []
        last_inner = self.inner_blocks[-1](x[-1])
        results.append(self.layer_blocks[-1](last_inner))
        
        for i in range(len(x) - 2, -1, -1):
            inner_lateral = self.inner_blocks[i](x[i])
            feat_shape = inner_lateral.shape[-2:]
            inner_top_down = F.interpolate(last_inner, size=feat_shape, mode="nearest")
            last_inner = inner_lateral + inner_top_down
            results.insert(0, self.layer_blocks[i](last_inner))
        
        return results

# 示例输入
x = [torch.randn(1, 256, 64, 64), torch.randn(1, 512, 32, 32), torch.randn(1, 1024, 16, 16)]
fpn = FeaturePyramidNetwork([256, 512, 1024], 256)
y = fpn(x)

for feature in y:
    print(feature.shape)

5.5 总结

特征金字塔通过在不同尺度上提取和融合特征图，增强了模型在不同尺度上检测目标的能力。
较高层级的特征图具有更低的空间分辨率和更高级的语义信息，适用于检测大物体和复杂背景中的目标；而较低层级的特征图具有更高的空间分辨率和较少的语义信息，适用于检测小物体。
特征金字塔的这种层级结构使得目标检测模型能够更好地处理不同尺度的目标，提高检测的准确性和鲁棒性。

六、多尺度训练

多尺度训练（Multi-scale Training）是一种在深度学习中特别是在计算机视觉任务（如目标检测、图像分割）中常用的训练策略。它的核心思想是通过在训练过程中使用不同尺度的图像来增强模型的鲁棒性和泛化能力。这种策略能够让模型在不同尺寸的输入图像上表现良好，而不仅仅是固定尺寸的图像。

6.1 实现步骤

图像缩放：
在每个训练迭代中，随机选择一个缩放比例，对输入图像进行缩放。这样，模型在训练过程中会看到各种尺度的图像。
调整输入尺寸：
由于不同的缩放比例会产生不同尺寸的图像，模型需要能够处理这些不同尺寸的输入。通常，输入尺寸是在一定范围内随机选择的，比如从320到608之间的任何尺寸。
数据增强：
多尺度训练本身就是一种数据增强方法，它与其他数据增强技术（如旋转、翻转、颜色抖动等）结合使用效果更佳。
保持目标比例：
缩放图像时，要保持目标物体的比例，这样可以防止目标物体变形。

6.2 多尺度训练的优势

提高鲁棒性：
模型可以在不同尺寸的输入图像上表现良好，增强了模型对尺度变化的鲁棒性。
增强泛化能力：
通过在不同尺度的图像上进行训练，模型学习到了更丰富的特征，从而提高了在测试集上的泛化能力。
适应不同设备：
由于实际应用中，图像的分辨率可能不同，多尺度训练可以使模型更好地适应各种分辨率的输入。

6.3 实现多尺度训练

以下是一个使用 PyTorch 实现多尺度训练的示例代码：

import torch
import torch.nn as nn
import random
import cv2

class RandomResize:
    def __init__(self, min_size=320, max_size=608, step=32):
        self.min_size = min_size
        self.max_size = max_size
        self.step = step

    def __call__(self, image, targets):
        size = random.choice(range(self.min_size, self.max_size + 1, self.step))
        image = cv2.resize(image, (size, size))
        # 需要同步调整 targets 位置（例如边界框）
        return image, targets

# 假设有一个简单的神经网络
class SimpleModel(nn.Module):
    def __init__(self):
        super(SimpleModel, self).__init__()
        self.conv1 = nn.Conv2d(3, 16, kernel_size=3, stride=1, padding=1)
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2, padding=0)
        self.fc1 = nn.Linear(16 * 16 * 16, 10)  # 假设输入是32x32，经过下采样变为16x16

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = x.view(-1, 16 * 16 * 16)
        x = self.fc1(x)
        return x

# 训练循环中的多尺度训练部分
def train(model, dataloader, criterion, optimizer, device):
    model.train()
    for images, targets in dataloader:
        # 将图像和目标放在设备上
        images, targets = images.to(device), targets.to(device)
        
        # 随机调整图像尺寸
        random_resize = RandomResize()
        images, targets = random_resize(images, targets)
        
        # 前向传播
        outputs = model(images)
        loss = criterion(outputs, targets)
        
        # 反向传播和优化
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

# 假设你有一个数据加载器
dataloader = ...  # 定义你的数据加载器

# 定义模型、损失函数和优化器
model = SimpleModel().to(device)
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9)

# 训练模型
train(model, dataloader, criterion, optimizer, device)

6.4 总结

多尺度训练通过在训练过程中随机调整输入图像的尺寸，使得模型在不同尺寸的输入图像上都能表现良好，从而增强了模型的鲁棒性和泛化能力。这种策略在目标检测和图像分割任务中尤为有效，因为它能够帮助模型更好地应对现实世界中的尺度变化。

XISHI_TIANLAN

关注

20
点赞
踩
27

收藏

觉得还不错? 一键收藏
0
评论
YOLO系列笔记（十七）—— YOLOv5各层详细介绍（附python代码）：Focus，Conv，C3，SPPF，特征金字塔及多尺度训练

在目标检测任务中，模型的结构和各个模块的设计对检测性能有着至关重要的影响。本文将详细介绍YOLOv5中的一些关键模块和技术，包括Focus层、卷积层（Conv）、C3层、SPPF层、特征金字塔（Feature Pyramid）以及多尺度训练（Multi-scale Training）。这些模块和技术共同构成了YOLOv5强大的目标检测能力。！Focus层的核心思想是将输入图像的空间信息（即宽度和高度）重新排列成更多的通道信息。
复制链接

扫一扫