深入浅出之Bottleneck层、Res unit和ResX模块（YOLO）

已于 2025-04-07 16:35:42 修改
阅读量4.1k 收藏 35
点赞数 10
CC 4.0 BY-SA版权
分类专栏： # 深度学习基础知识 深度学习目标检测 # 目标检测（理论） 文章标签： YOLO 目标跟踪 人工智能
于 2024-09-19 08:34:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a8039974/article/details/142349866

一、Bottleneck层，Res unit和ResX模块概念

Bottleneck层、Res unit（残差单元）和ResX模块是深度学习中，特别是在残差网络（ResNet）及其变体，以及目标检测网络YOLO系列中的重要组件。以下是对这三者的详细解析：

1.1 Bottleneck层

  1. 定义：
    Bottleneck层，又称瓶颈层，是一种在深度残差网络（ResNet）中引入的结构，旨在降低模型的计算复杂度并提升特征提取能力。

  2. 结构：
    Bottleneck层通常由三个卷积层组成：

    • 第一个1×1卷积层：用于降低输入的通道数（维度），以减少后续卷积层的计算量。
    • 第二个3×3卷积层：在降维后的特征图上进行卷积操作，提取特征。
    • 第三个1×1卷积层：将通道数恢复到原始维度，以供下一层使用。

上图右侧图所示结构即为Bottleneck结构。 

  1. 作用：

    • 显著降低计算复杂度，加快模型训练和推理速度。
    • 保持或提升特征提取能力，提高模型性能。

1.2 Res unit（残差单元）

  1. 定义：
    Res unit是借鉴了ResNet中的残差结构，旨在解决深层网络训练中的梯度消失或梯度爆炸问题，使网络能够构建得更深。

  2. 结构：
    Res unit通常由输入层、卷积层（或多个卷积层组成的子块）、批归一化层（BN）、激活函数以及跳跃连接（shortcut connection）组成。

    • 输入层：接收来自上一层的特征图。
    • 卷积层：对输入特征图进行卷积操作，提取特征。
    • 批归一化层：对卷积层的输出进行归一化处理，加速训练过程并稳定模型性能。
    • 激活函数：增加网络的非线性表达能力。
    • 跳跃连接：将输入层的输出直接加到卷积层（或子块）的输出上，形成残差学习的形式。

  1. 作用：

    • 解决深层网络训练中的梯度消失或梯度爆炸问题。
    • 提高网络的表达能力和泛化能力。

1.3 ResX模块

  1. 定义：
    ResX模块是YOLO系列网络中的一个重要组件，它结合了CBL（Conv+Bn+Leaky_relu）和多个Res unit，形成了一个具有强大特征提取能力的结构单元。

  2. 结构：
    ResX模块通常由一个CBL层和多个Res unit组成。

    • CBL层：由卷积层、批归一化层和Leaky_relu激活函数组成，对输入特征图进行初步处理。
    • Res unit：多个残差单元串联而成，对CBL层的输出进行进一步处理，提取更深层次的特征。

  1. 作用：

    • 通过组合CBL和多个Res unit，形成一个具有强大特征提取能力的结构单元。
    • 堆叠多个ResX模块，可以提取多尺度的特征信息，有助于网络更好地检测不同大小的目标。

综上所述，Bottleneck层、Res unit和ResX模块在深度学习中发挥着重要作用。它们共同构成了深度残差网络（ResNet）及其变体，以及目标检测网络YOLO系列的基本构建块，为解决深层神经网络训练中的难题提供了有效方法，并提高了模型的性能和泛化能力。

在YOLO系列算法中，Res unit（残差单元）和ResX是两个重要的组件，它们在网络结构中扮演着关键角色。

二、三者区别与联系

2.1 区别

  1. Bottleneck层：
    • 主要用于ResNet网络中，特别是较深的ResNet变体（如ResNet-50、ResNet-101等）。
    • 通过使用1×1卷积降低维度，3×3卷积进行特征提取，再使用1×1卷积升高维度，显著减少了模型的计算复杂度。
    • 结构上，Bottleneck层是一个三卷积层的组合，中间层通常具有较少的通道数。
  2. Res unit（残差单元）：
    • 是残差网络的基本构建块，旨在解决深层网络训练中的梯度消失或梯度爆炸问题。
    • 包含一个或多个卷积层、批归一化层、激活函数以及一个跳跃连接（shortcut connection）。
    • 跳跃连接将输入直接加到输出上，形成残差学习的形式，有助于梯度在网络中的传播。
  3. ResX模块：
    • 主要用于YOLO系列网络，特别是YOLOv3及以后的版本。
    • 由一个CBL（Conv+Bn+Leaky_relu）和多个Res unit组成，形成了一个具有强大特征提取能力的结构单元。
    • 通过堆叠多个ResX模块，YOLO系列网络能够提取多尺度的特征信息，有助于更好地检测不同大小的目标。

2.2 联系

  1. 结构上的联系：
    • Bottleneck层和Res unit都可以看作是残差学习的实现方式，它们都包含了跳跃连接。
    • ResX模块则结合了CBL和多个Res unit，形成了一个更复杂的结构单元。
  2. 功能上的联系：
    • 三者都旨在提高网络的表达能力和泛化能力。
    • 通过引入残差学习的概念，它们都能够解决深层网络训练中的梯度消失或梯度爆炸问题。

三. 不同网络中的Bottleneck结构参数

2.1 ResNet网络中Bottleneck结构

        下图结构是在ResNet网络中的结构。先通过1x1进行降维，使用3x3进行卷积操作，最后使用1x1升维。

2.2 YOLOV5网络中的Bottleneck结构

        下图为YOLO V5中的结构，与ResNet网络中的Bottleneck结构相比，最大不同是只有2层卷积，最后一层不再使用1x1卷积升维，而是直接输出。

该结构的第一个卷积核为1x1进行降维，然后3x3进行卷积计算后直接输出，在该过程直接设置最终需要的输出Channel数，不再经过1x1卷积进行升维操作。

 YOLOV5 Bottleneck Pytorch实现

 YOLOV5 Bottleneck TensorRT部署 

2.3 YOLOV8网络中Bottleneck结构 


        YOLOV8中的Bottleneck结构和YOLOV5的一致，但是需要注意的是第一个瓶颈操作YOLOV8中使用的卷积核大小是3x3，而不是YOLOV5中使用的1x1,YOLOV8是通过使channel减半，来实现降低参数的目的。

        yoloV8 Bottleneck  pytorch实现

        YOLOV8 Bottleneck TensorRT部署

四、pytorch实现 

4.1 Bottleneck层的PyTorch实现

import torch  
import torch.nn as nn  
  
class Bottleneck(nn.Module):  
    def __init__(self, in_channels, out_channels, stride=1):  
        super(Bottleneck, self).__init__()  
        self.conv1 = nn.Conv2d(in_channels, out_channels // 4, kernel_size=1, stride=stride, bias=False)  
        self.bn1 = nn.BatchNorm2d(out_channels // 4)  
        self.conv2 = nn.Conv2d(out_channels // 4, out_channels // 4, kernel_size=3, stride=1, padding=1, bias=False)  
        self.bn2 = nn.BatchNorm2d(out_channels // 4)  
        self.conv3 = nn.Conv2d(out_channels // 4, out_channels, kernel_size=1, stride=1, bias=False)  
        self.bn3 = nn.BatchNorm2d(out_channels)  
        self.shortcut = nn.Sequential()  
        if stride != 1 or in_channels != out_channels:  
            self.shortcut = nn.Sequential(  
                nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=stride, bias=False),  
                nn.BatchNorm2d(out_channels),  
            )  
  
    def forward(self, x):  
        identity = x  
        out = self.conv1(x)  
        out = self.bn1(out)  
        out = nn.ReLU(inplace=True)(out)  
        out = self.conv2(out)  
        out = self.bn2(out)  
        out = nn.ReLU(inplace=True)(out)  
        out = self.conv3(out)  
        out = self.bn3(out)  
        out += self.shortcut(identity)  
        out = nn.ReLU(inplace=True)(out)  
        return out

4.2 Res Unit（残差单元）的PyTorch实现

在YOLO中，Res unit通常包含多个卷积层、批归一化层和激活层，以及一个残差连接（跳跃连接）。以下是一个简化的Res unit实现：

class ResUnit(nn.Module):  
    def __init__(self, in_channels, out_channels, stride=1):  
        super(ResUnit, self).__init__()  
        self.conv1 = nn.Conv2d(in_channels, out_channels // 2, kernel_size=1, stride=stride, bias=False)  
        self.bn1 = nn.BatchNorm2d(out_channels // 2)  
        self.conv2 = nn.Conv2d(out_channels // 2, out_channels // 2, kernel_size=3, stride=1, padding=1, bias=False)  
        self.bn2 = nn.BatchNorm2d(out_channels // 2)  
        self.conv3 = nn.Conv2d(out_channels // 2, out_channels, kernel_size=1, stride=1, bias=False)  
        self.bn3 = nn.BatchNorm2d(out_channels)  
        self.downsample = None  
        if stride != 1 or in_channels != out_channels:  
            self.downsample = nn.Sequential(  
                nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=stride, bias=False),  
                nn.BatchNorm2d(out_channels),  
            )  
  
    def forward(self, x):  
        identity = x  
        out = self.conv1(x)  
        out = self.bn1(out)  
        out = nn.LeakyReLU(inplace=True)(out, negative_slope=0.1)  
        out = self.conv2(out)  
        out = self.bn2(out)  
        out = nn.LeakyReLU(inplace=True)(out, negative_slope=0.1)  
        out = self.conv3(out)  
        out = self.bn3(out)  
        if self.downsample is not None:  
            identity = self.downsample(x)  
        out += identity  
        out = nn.LeakyReLU(inplace=True)(out, negative_slope=0.1)  
        return out

4.3 ResX模块的PyTorch实现

ResX模块通常包含多个Res unit和可能的下采样层。以下是一个简化的ResX模块实现，假设它包含两个Res unit和一个可选的下采样层：

class ResX(nn.Module):  
    def __init__(self, in_channels, out_channels, num_blocks=2, stride=1):  
        super(ResX, self).__init__()  
        self.cbl = nn.Sequential(  
            nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=stride, bias=False),  
            nn.BatchNorm2d(out_channels),  
            nn.LeakyReLU(inplace=True),  
        )  
        self.blocks = nn.ModuleList([  
            ResUnit(out_channels if i == 0 else out_channels, out_channels, stride if i == 0 else 1)  
            for i in range(num_blocks)  
        ])  
  
    def forward(self, x):  
        out = self.cbl(x)  
        for block in self.blocks:  
            out = block(out)  
        return out
  
# 示例用法  
# 假设in_channels=64, out_channels=128, 需要两个Res unit  
resx_module = ResX(64, 128, num_blocks=2, stride=2)  # 这里stride=2表示该ResX模块包含下采样

 请注意，上面的ResX实现假设所有Res unit的步长除了第一个之外都是1。如果需要在下采样后继续下采样，则需要在网络架构中显式地处理这一点（例如，在ResX模块之间添加额外的下采样层）。此外，YOLO的实际实现可能包含更多的细节和特定的设计选择，因此建议参考具体的YOLO版本和源代码以获取最准确的实现。

打印结果：

ResX(
  (blocks): ModuleList(
    (0): ResUnit(
      (conv1): Conv2d(64, 64, kernel_size=(1, 1), stride=(2, 2), bias=False)
      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(64, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (downsample): Sequential(
        (0): Conv2d(64, 128, kernel_size=(1, 1), stride=(2, 2), bias=False)
        (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): ResUnit(
      (conv1): Conv2d(128, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(64, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
)

五、总结

Bottleneck层、Res unit和ResX是YOLO系列算法中非常重要的组件，它们通过引入残差学习和多尺度特征提取机制，显著提升了网络的性能和效果。在YOLOv3、YOLOv4等版本中，这些组件被广泛应用并不断优化，为目标检测领域的发展做出了重要贡献。

需要注意的是，随着YOLO系列算法的不断发展，新的版本可能会引入更多的创新和改进。因此，在具体应用时，建议参考最新的官方文档和研究成果。

参考：

  1. yolo组件之Bottleneck层总结_yolo的bottleneck-CSDN博客
深度学习瓶颈层（Bottleneck Layer）深度解析
浩瀚之水的专栏
06-04 346
瓶颈层是深度学习中一种战略性降维设计，通过在网络中引入压缩-扩展结构，显著提升模型效率与表达能力。
第三章、用YOLOv8进行检测——第四节 Bottleneck、C2f和 SPPF模块及 Python语言实现
最新发布
u010117029的博客
06-03 367
YOLOv8核心模块设计与优化包括三大部分：1) C2f模块采用跨阶段特征融合机制，通过特征拆分和多分支处理提升1.1%mAP；2) SPPF模块优化传统空间金字塔结构，使用串行池化复用计算结果，速度提升25%；3) 改进版Bottleneck支持多种膨胀系数选择。这些创新模块在保持精度的同时显著降低计算成本，其中C2f替代原C3结构，SPPF取代传统SPP，可灵活集成到自定义网络中。实验表明，模块改进带来显著的精度和速度提升，为计算机视觉任务提供高效解决方案。
YOLOv8中Bottleneck模块详解
zzzyyy8的博客
09-01 5801
Bottleneck 模块在YOLOv8中的作用是进行特征提取和增强，是网络中的核心构建模块之一。它的主要功能是通过卷积操作来处理输入特征图，并在适当情况下应用残差连接，使得信息能够有效地通过网络层进行传播
理解bottleneck architecture
GL3_24的博客
05-28 7834
本篇博文主要是讨论为什么叫 bottleneck architecture bottleneck architecture翻译过来叫做瓶颈结构，瓶颈结构的特点是一头大一头小。 这个是针对于网络结构中输入/输出的维度(dimensions)来讲的。 来看一下Deep Residual Learning for Image Recognition(ResNet)论文当中的一部分。对应结构为下图。 ...
yolo组件之Bottleneck层总结
yueguang8的博客
03-04 1万+
Bottleneck模块的目的就是为了降低网络参数，提高网络训练、推理的速度并提升特征提取能力。文章介绍了在Resnet、yolov5、yolov8不同的网络中，Bottleneck的结构、参数的差异，以及在推理部署的时候需要注意的事项。
深度学习-瓶颈结构（Bottleneck）
weixin_40826634的博客
12-06 8319
深度学习-瓶颈结构（Bottleneck）
深度学习之bottleneck layer
热门推荐
deep_love1314的博客
05-17 3万+
一、 bottleneck layery中文名称：瓶颈层。我初次接触也就是在残差网络中。一般在较深的网络中，如resnet101中使用。 一般的结构如下： 其中两个1X1fliter分别用于降低和升高特征维度，主要目的是为了减少参数的数量，从而减少计算量，且在降维之后可以更加有效、直观地进行数据的训练和特征提取，对比如下图所示： 瓶颈层使用的是1*1的卷积神经网络，之所以称之为瓶颈层，是因为长得比较像一个瓶颈：中间比较细，像一个瓶子的颈部。 如上图所示，经过1x..
轻量级网络：Bottleneck结构（沙漏型结构）
那年聪聪
02-16 2万+
Bottleneck结构为之后的深度可分离卷积Depthwise Separable Conv打下了坚实的基础。
深度学习：ResNet网络与bottleneck架构
HUSTGO的博客
07-14 2422
ResNet（Residual Neural Network）是由何恺明等人在2015年提出的一种深度卷积神经网络。它的核心思想是引入残差块（Residual Block），解决了深度神经网络中常见的梯度消失和梯度爆炸问题，从而使得网络可以更深。残差学习：通过引入恒等映射（Identity Mapping），使网络能够更容易地学习到恒等函数，从而减轻梯度消失问题。跳跃连接：残差块通过跳跃连接（Skip Connection）直接将输入传递到输出，提高了信息传递的效率。更深的网络。
深入浅出之CSPBlock模块（YOLO）
浩瀚之水的专栏
09-19 5957
YOLO CSPX模块是YOLO系列算法中的一个重要组成部分，它通过跨阶段部分连接的方式减少了计算量，同时保证了模型的准确率。在YOLOv4及后续版本中，CSPX模块被广泛应用于主干网络和Neck结构中，为模型提供了强大的特征提取和融合能力。
YOLO算法全家桶（YOLOV1~YOLOV12）
浩瀚之水的专栏
09-10 7512
YOLOV1作为目标检测领域的开创性模型，以其独特的设计理念和高效的检测性能赢得了广泛的关注和应用。尽管存在一些不足之处，但YOLOV1为后续的YOLO系列模型奠定了坚实的基础，推动了目标检测技术的不断发展。YOLOv6专注于提供极致的检测精度和推理效率，适用于自动驾驶、安防监控等多种领域。它支持模型训练、推理及多平台部署等全链条的工业应用需求，并在网络结构、训练策略等算法层面进行了多项改进和优化。Backbone。
YOLOv7算法重构：个人自改，做到像YOLOv5一样简洁，仅为31层
qq_44224801的博客
05-27 622
YOLOv7是很优秀的检测算法，作者将所有构件写入了yaml文件以增强可改造性，但是熟悉了YOLO’v5网络结构的读者，观看YOLOv7还是相对费劲。由于本人最近在改动YOLOv7模型， 改动起来还是不如YOLOv5方便，因此按照本人自身想法，对YOLOv7网络进行重构。
目标检测YOLO实战应用案例100讲-基于深度学习的人眼视线检测（续）
qq_36130719的博客
11-11 396
如4.2.2节所述，双阶段视线检测网络由人眼区域检测网络和眼部关键点检测网络级 联而成。对于人眼区域检测网络，输入为一张人脸图片，输出为检测框类别、中心x坐标、 中心y坐标、宽、高、置信度的一维张量。对于眼部关键点检测网络，输入为一张人眼图片，输出为具有顺序关系的眼部关键点坐标。人眼区域检测网络的输出应为眼部关键点检 测网络的输入，但两个网络在级联部分的数据类型并不相同。
YOLOv7独家首发改进：聚合全局、局部信息D-Mixer和全新重叠空间降维注意力 | TransXNet ，CNN 与 ViT 的完美结合，2023.11发表
11-27 1465
改进1）重叠空间降维注意力(OSRA)，2）混合网络模块(D-Mixer)，聚合全局信息和局部细节，分别引入到YOLOv7，做到二次创新；
深度学习基础--Bottleneck(瓶颈) Architectures
wydbyxr的博客
11-12 2万+
Bottleneck(瓶颈) Architectures   ResNet的核心内容之一，即“Deeper Bottleneck Architectures”（以下简称DBA），论文里的原图是这样的（Bottleneck V1 ）： 作用   换成bottleneck design以后，网络的参数减少了很多，训练也就相对容易一些。然后我们再看一下原作中的ResNet全貌。 ...
Bottleneck结构（附代码）
蓝羽飞鸟的博客
03-20 7797
Bottleneck结构出现在resnet中，参考paper 结构如下 左边是一个resnet block，右边是一个和它时间复杂度类似的bottleneck block。 bottleneck由三层组成：1x1, 3x3, 1x1，其中1x1负责缩小放大channel。 为什么要用这个结构呢，paper里是这样说的： 一般来说，增加网络的深度可以提高accuracy, 但是会增加计算量，而bottleneck既增加了深度，计算量又可以得到节约。 参考代码 class Bottleneck2D(nn.Mo
Bottleneck层
ReDaMancyYYYqy的博客
02-11 511
Bottleneck层是一种具有较少参数和计算量的卷积层，通常用于替代传统的卷积层以减少模型的复杂度和计算负担。这种层结构的设计思路是，通过减少中间层的通道数（即特征图的数量），来“挤压”信息并通过一个较小的“瓶颈”，然后再通过扩展层恢复通道数，从而实现特征的非线性变换和信息的有效传递。Bottleneck层是深度学习网络中一种重要的层结构，它通过减少中间层的通道数来减少模型的计算复杂度和参数数量。这种结构在保持模型性能的同时，提高了计算效率，有助于加速模型的训练和推理过程。
深度学习之Bottleneck Layer or Bottleneck Features
Mihu_Tutu的博客
10-23 1387
在深度学习中经常听闻Bottleneck Layer 或 Bottleneck Features ，亦或 Bottleneck Block，其虽然容易理解，其意思就是输入输出维度差距较大，就像一个瓶颈一样，上窄下宽亦或上宽下窄，然而其正儿八经的官方出处没有一个能说出其所以然来，下面本文将对Bottleneck Layer 或 Bottleneck Features ，亦或 Bottleneck...
bottleneck作用
05-26
Bottleneck是指在神经网络中的一种结构，通常用于减少模型的参数数量和计算量。在卷积神经网络中，Bottleneck结构由一个1x1的卷积层、一个3x3的卷积层和另一个1x1的卷积层组成，这三层卷积层的输出通道数分别为bottleneck尺寸的1/4、bottleneck尺寸、和输出通道数的4倍。Bottleneck的作用是将输入特征映射到一个较低维度的空间，然后再进行卷积操作，以减少计算量和防止过拟合。在ResNet等深度神经网络中，Bottleneck结构被广泛应用，能够有效地提高模型的性能和训练速度。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

浩瀚之水_csdn

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值