第Y9周:重要模块解读

🍨 本文为🔗365天深度学习训练营中的学习记录博客
🍖 原作者：K同学啊 | 接辅导、项目定制
🚀 文章来源：K同学的学习圈子

以con.py为例：

一、autopad

二、Conv

三、Focus

四、C2f

文件路径：\ultralytics-main\ultralytics\nn\modules\*

本篇文章仅仅介绍YOLOv8中涉及的主要模块，其他可以查看我之前YOLOV5的文章。

以con.py为例：

开头列举了该文件中定义的所有模型，如果你需要新加一个模块，记得在该文件开头这里将其名称加入。(这是YOLOv8新增的一个类似声明的内容)

# Ultralytics YOLO 🚀, AGPL-3.0 license
"""Convolution modules."""

import math

import numpy as np
import torch
import torch.nn as nn

__all__ = (
    "Conv",
    "Conv2",
    "LightConv",
    "DWConv",
    "DWConvTranspose2d",
    "ConvTranspose",
    "Focus",
    "GhostConv",
    "ChannelAttention",
    "SpatialAttention",
    "CBAM",
    "Concat",
    "RepConv",
)

Conv：这是一个标准的卷积层，用于图像的特征提取。
Conv2：这是一个扩展的卷积层。
LightConv：这是一个轻量级的卷积层，旨在减少模型的计算量和参数数量。
DWConv：深度可分离卷积（Depthwise Separable Convolution），它将标准卷积分解为深度卷积和点卷积，以减少参数和计算量。
DWConvTranspose2d：深度可分离转置卷积，用于上采样操作，常用于生成高分辨率特征图。
ConvTranspose：转置卷积（或反卷积），用于上采样和特征图的尺寸增加。
Focus：这是一个特殊的模块，用于减少图像的分辨率同时增加其深度，有助于网络关注更细粒度的特征。
GhostConv：Ghost卷积，一种高效的卷积方式，通过廉价操作生成更多的特征图。
ChannelAttention：通道注意力机制，用于增强网络对重要通道的关注。
SpatialAttention：空间注意力机制，用于增强网络对重要空间位置的关注。
CBAM：结合通道注意力和空间注意力，共同增强网络对特征的关注。
Concat：这是一个简单的连接模块，用于合并多个特征图。

一、autopad

文件路径：\ultralytics-main\ultralytics\nn\modules\conv.py

def autopad(k, p=None, d=1):  # kernel, padding, dilation
    """Pad to 'same' shape outputs."""
    if d > 1:
        k = d * (k - 1) + 1 if isinstance(k, int) else [d * (x - 1) + 1 for x in k]  # actual kernel-size
    if p is None:
        p = k // 2 if isinstance(k, int) else [x // 2 for x in k]  # auto-pad
    return p

这段代码定义了一个名为 autopad 的函数，其目的是为了在卷积操作中实现 ‘same’ padding，即输入和输出具有相同的空间维度。

这个函数接受三个参数：k（卷积核大小），p（可选的填充大小），和 d（膨胀率，默认为1）。下面是函数的详细解释：

k：卷积核的大小。它可以是单个整数，也可以是整数列表（对于不同维度的卷积核）。
p：填充大小。如果未提供，函数将自动计算。
d：膨胀率（dilation rate），默认为1。膨胀卷积是一种可以增大卷积核感受野的卷积方式，不影响参数数量。

autopad 函数在实现卷积神经网络时非常有用，特别是在需要保持特征图尺寸不变的情况下。通过自动计算填充大小，它简化了卷积层的实现过程。

二、Conv

文件路径：\ultralytics-main\ultralytics\nn\modules\conv.py

class Conv(nn.Module):
    """Standard convolution with args(ch_in, ch_out, kernel, stride, padding, groups, dilation, activation)."""

    default_act = nn.SiLU()  # default activation

    def __init__(self, c1, c2, k=1, s=1, p=None, g=1, d=1, act=True):
        """Initialize Conv layer with given arguments including activation."""
        super().__init__()
        self.conv = nn.Conv2d(c1, c2, k, s, autopad(k, p, d), groups=g, dilation=d, bias=False)
        self.bn = nn.BatchNorm2d(c2)
        self.act = self.default_act if act is True else act if isinstance(act, nn.Module) else nn.Identity()

    def forward(self, x):
        """Apply convolution, batch normalization and activation to input tensor."""
        return self.act(self.bn(self.conv(x)))

    def forward_fuse(self, x):
        """Perform transposed convolution of 2D data."""
        return self.act(self.conv(x))

类属性：
- default_act：这是一个类属性，定义了默认的激活函数，这里使用的是 SiLU 激活函数。
构造函数 __init__：
- 这个函数初始化卷积层。它接受多个参数：
  - c1：输入通道数。
  - c2：输出通道数。
  - k：卷积核大小，默认为1。
  - s：步长，默认为1。
  - p：填充大小。如果没有提供，将使用 autopad 函数自动计算。
  - g：groups参数，用于控制分组卷积，默认为1。
  - d：膨胀率，默认为1。
  - act：激活函数。如果为True，则使用默认的SiLU激活函数；如果是一个 nn.Module 实例，则使用该实例；否则不使用激活函数。
- 在构造函数中，创建了 nn.Conv2d、nn.BatchNorm2d 和激活函数实例。
前向传播函数 forward：
- 这个函数定义了数据通过层的传播方式。它首先应用卷积，然后是批量归一化，最后是激活函数。
前向融合函数 forward_fuse：
- 这个函数与 forward 类似，但不使用批量归一化。它直接在卷积操作后应用激活函数。这个函数可能在某些特定情况下使用，例如当模型需要融合某些层以优化性能时。

这个 Conv 类是一个构建块，常用于构建更复杂的卷积神经网络模型。通过将卷积、批量归一化和激活函数组合在一起，它简化了模型构建过程，并提高了代码的可读性和可维护性。

三、Focus

文件路径：\ultralytics-main\ultralytics\nn\modules\conv.py

Focus模块是作者自己设计出来，为了减少浮点数和提高速度，而不是增加feature map的，本质就是将图像进行切片，类似于下采样取值，将原图像的宽高信息切分，聚合到channel通道中。

结构如下所示：

class Focus(nn.Module):
    """Focus wh information into c-space."""

    def __init__(self, c1, c2, k=1, s=1, p=None, g=1, act=True):
        """Initializes Focus object with user defined channel, convolution, padding, group and activation values."""
        super().__init__()
        self.conv = Conv(c1 * 4, c2, k, s, p, g, act=act)
        # self.contract = Contract(gain=2)

    def forward(self, x):
        """
        Applies convolution to concatenated tensor and returns the output.

        Input shape is (b,c,w,h) and output shape is (b,4c,w/2,h/2).
        """
        return self.conv(torch.cat((x[..., ::2, ::2], x[..., 1::2, ::2], x[..., ::2, 1::2], x[..., 1::2, 1::2]), 1))
        # return self.conv(self.contract(x))

Focus类实现了一个特殊的操作，将宽度和高度信息“聚焦”到通道空间中，这通常用于减少图像的分辨率同时增加其深度。下面是对这个类的详细解释：

构造函数 __init__：
- 这个函数初始化 Focus 层。它接受多个参数，与 Conv 类似，包括输入和输出通道数、卷积核大小、步长、填充、分组等。
- 在构造函数中，创建了一个 Conv 实例，其输入通道数是原始通道数的4倍。这是因为 Focus 层会将输入图像分割成四个部分并沿通道维度拼接。
前向传播函数 forward：
- 这个函数定义了数据通过层的传播方式。它首先将输入图像 x 沿宽度和高度维度分成四个部分，然后将这四个部分沿通道维度拼接。
- 拼接后的张量随后被送入卷积层进行处理。
- 输出张量的形状是 (b, 4c, w/2, h/2)，其中 b 是批量大小，c 是原始通道数，w 和 h 是宽度和高度的一半。

这个 Focus 类是 YOLOv8 中的一个关键组件，它通过将图像分割成四个部分并沿通道维度拼接，有效地减少了图像的分辨率，同时增加了通道数。这种方法有助于网络关注更细粒度的特征，同时保持计算效率。

四、C2f

文件路径：\ultralytics-main\ultralytics\nn\modules\block.py

class C2f(nn.Module):
    """Faster Implementation of CSP Bottleneck with 2 convolutions."""

    def __init__(self, c1, c2, n=1, shortcut=False, g=1, e=0.5):
        """Initialize CSP bottleneck layer with two convolutions with arguments ch_in, ch_out, number, shortcut, groups,
        expansion.
        """
        super().__init__()
        self.c = int(c2 * e)  # hidden channels
        self.cv1 = Conv(c1, 2 * self.c, 1, 1)
        self.cv2 = Conv((2 + n) * self.c, c2, 1)  # optional act=FReLU(c2)
        self.m = nn.ModuleList(Bottleneck(self.c, self.c, shortcut, g, k=((3, 3), (3, 3)), e=1.0) for _ in range(n))

    def forward(self, x):
        """Forward pass through C2f layer."""
        y = list(self.cv1(x).chunk(2, 1))
        y.extend(m(y[-1]) for m in self.m)
        return self.cv2(torch.cat(y, 1))

    def forward_split(self, x):
        """Forward pass using split() instead of chunk()."""
        y = list(self.cv1(x).split((self.c, self.c), 1))
        y.extend(m(y[-1]) for m in self.m)
        return self.cv2(torch.cat(y, 1))

C2f 类是 CSP（Cross Stage Partial）瓶颈层的更快实现版本，包含两个卷积层。这个类继承自 PyTorch 的 nn.Module 类。下面是对这个类的详细解释：

构造函数 __init__：
- 这个函数初始化 C2f 层。它接受多个参数：
  - c1：输入通道数。
  - c2：输出通道数。
  - n：Bottleneck 模块的重复次数。
  - shortcut：是否使用捷径连接。
  - g：分组数。
  - e：膨胀系数，用于计算隐藏层通道数。
- 在构造函数中，创建了两个卷积层 cv1 和 cv2，以及一个 nn.ModuleList，其中包含 n 个 Bottleneck 模块。
前向传播函数 forward：
- 这个函数定义了数据通过层的传播方式。首先，输入 x 通过 cv1 卷积层，然后其输出被分割成两部分。
- 分割后的两部分以及通过 Bottleneck 模块的输出被连接起来，然后通过 cv2 卷积层。
前向分割函数 forward_split：
- 这个函数与 forward 类似，但使用 split() 而不是 chunk() 来分割张量。