Ultralytics：解读Bottleneck模块

前言

• 由于本人水平有限，难免出现错漏，敬请批评改正。
• 更多精彩内容，可点击进入Python日常小操作专栏、OpenCV-Python小应用专栏、YOLO系列专栏、自然语言处理专栏、人工智能混合编程实践专栏或我的个人主页查看
• YOLOs-CPP：一个免费开源的YOLO全系列C++推理库（以YOLO26为例）
• PaddleOCR：Win10上安装使用PPOCRLabel标注工具
• 目标检测：使用自己的数据集微调DEIMv2进行物体检测
• 图像分割：PyTorch从零开始实现SegFormer语义分割
• 图像超分：使用自己的数据集微调Real-ESRGAN-x4plus进行超分重建
• 图像生成：PyTorch从零开始实现一个简单的扩散模型
• Stable Diffusion：使用自己的数据集微调 Stable Diffusion 3.5 LoRA 文生图模型
• 图像超分：使用自己的数据集微调Real-ESRGAN-x2plus进行超分重建
• Anomalib：使用Anomalib 2.1.0训练自己的数据集进行异常检测
• Anomalib：在Linux服务器上安装使用Anomalib 2.1.0
• 人工智能混合编程实践：C++调用封装好的DLL进行异常检测推理
• 人工智能混合编程实践：C++调用封装好的DLL进行FP16图像超分重建（v3.0）
• 隔离系统Python：源码编译3.11.8到自定义目录（含PGO性能优化）
• 在线机的Python环境迁移到离线机上
• Nuitka 将 Python 脚本封装为 .pyd 或 .so 文件
• Ultralytics：使用 YOLO11 进行速度估计
• Ultralytics：使用 YOLO11 进行物体追踪
• Ultralytics：使用 YOLO11 进行物体计数
• Ultralytics：使用 YOLO11 进行目标打码
• 人工智能混合编程实践：C++调用Python ONNX进行YOLOv8推理
• 人工智能混合编程实践：C++调用封装好的DLL进行YOLOv8实例分割
• 人工智能混合编程实践：C++调用Python ONNX进行图像超分重建
• 人工智能混合编程实践：C++调用Python AgentOCR进行文本识别
• 通过计算实例简单地理解PatchCore异常检测
• Python将YOLO格式实例分割数据集转换为COCO格式实例分割数据集
• YOLOv8 Ultralytics：使用Ultralytics框架训练RT-DETR实时目标检测模型
• 基于DETR的人脸伪装检测
• YOLOv7训练自己的数据集（口罩检测）
• YOLOv8训练自己的数据集（足球检测）
• YOLOv5：TensorRT加速YOLOv5模型推理
• YOLOv5：IoU、GIoU、DIoU、CIoU、EIoU
• 玩转Jetson Nano（五）：TensorRT加速YOLOv5目标检测
• YOLOv5：添加SE、CBAM、CoordAtt、ECA注意力机制
• YOLOv5：yolov5s.yaml配置文件解读、增加小目标检测层
• Python将COCO格式实例分割数据集转换为YOLO格式实例分割数据集
• YOLOv5：使用7.0版本训练自己的实例分割模型（车辆、行人、路标、车道线等实例分割）
• 使用Kaggle GPU资源免费体验Stable Diffusion开源项目
• Stable Diffusion：在服务器上部署使用Stable Diffusion WebUI进行AI绘图（v2.0）
• Stable Diffusion：使用自己的数据集微调训练LoRA模型（v2.0）

相关介绍

Ultralytics 简介

Ultralytics 基于多年的计算机视觉和人工智能基础研究，创建了最先进的 (SOTA) YOLO 模型。我们的模型不断更新性能和灵活性，快速、准确且易于使用。他们擅长对象检测、跟踪、实例分割、语义分割、图像分类和姿势估计任务。

• 官方文档：https://docs.ultralytics.com/
• 官方代码：https://github.com/ultralytics/ultralytics.git

前提条件

• 熟悉Python、Pytorch

实验环境

Package Version ------------------------ ------------ Python3.11.8 absl-py2.4.0 accelerate1.13.0 annotated-doc0.0.4 anyio4.13.0 calflops0.3.2 certifi2026.4.22 charset-normalizer3.4.7 click8.3.3 colorama0.4.6 contourpy1.3.3 cycler0.12.1 filelock3.29.0 flatbuffers25.12.19 fonttools4.62.1 fsspec2026.4.0 grpcio1.80.0 h110.16.0 hf-xet1.5.0 httpcore1.0.9 httpx0.28.1 huggingface_hub1.14.0 idna3.15Jinja23.1.6 kiwisolver1.5.0 Markdown3.10.2 markdown-it-py4.2.0 MarkupSafe3.0.3 matplotlib3.10.9 mdurl0.1.2 ml_dtypes0.5.0 mpmath1.3.0 networkx3.6.1 numpy1.26.4 nvidia-cublas-cu1212.8.3.14 nvidia-cuda-cupti-cu1212.8.57 nvidia-cuda-nvrtc-cu1212.8.61 nvidia-cuda-runtime-cu1212.8.57 nvidia-cudnn-cu129.7.1.26 nvidia-cufft-cu1211.3.3.41 nvidia-cufile-cu121.13.0.11 nvidia-curand-cu1210.3.9.55 nvidia-cusolver-cu1211.7.2.55 nvidia-cusparse-cu1212.5.7.53 nvidia-cusparselt-cu120.6.3 nvidia-nccl-cu122.26.2 nvidia-nvjitlink-cu1212.8.61 nvidia-nvtx-cu1212.8.55 onnx1.19.0 onnxruntime-gpu1.26.0 onnxslim0.1.94 opencv-python4.6.0.66 packaging26.2pillow12.2.0 pip24.0polars1.40.1 polars-runtime-321.40.1 protobuf7.34.1 psutil7.2.2 pycocotools2.0.11 Pygments2.20.0 pyparsing3.3.2 python-dateutil2.9.0.post0 PyYAML6.0.3 regex2026.5.9 requests2.34.1 rich15.0.0 safetensors0.7.0 scipy1.16.0 setuptools65.5.0 shellingham1.5.4 six1.17.0 sympy1.14.0 tabulate0.10.0 tensorboard2.20.0 tensorboard-data-server0.7.2 tokenizers0.22.2 torch2.7.1+cu128 torchaudio2.7.1+cu128 torchvision0.22.1+cu128 tqdm4.67.3 transformers5.8.1 triton3.3.1 typer0.25.1 typing_extensions4.15.0 ultralytics8.4.58 ultralytics-thop2.0.19 urllib32.7.0 Werkzeug3.1.8

Bottleneck（标准瓶颈模块）

Bottleneck是一种经典的残差模块，广泛用于 ResNet、YOLO 等网络结构中。它通过两个卷积层（先降维后升维）减少计算量，并支持残差连接（shortcut），从而在增加网络深度的同时保持训练稳定性。该实现参考了 YOLOv5/YOLOv8 的设计，提供了灵活的参数配置。

代码实现

importcv2importmathimporttorchimportnumpyasnpimportmatplotlib.pyplotaspltfromtorchimportnndefautopad(k,p=None,d=1):# kernel, padding, dilation"""Pad to 'same' shape outputs."""ifd>1:k=d*(k-1)+1ifisinstance(k,int)else[d*(x-1)+1forxink]# actual kernel-sizeifpisNone:p=k//2ifisinstance(k,int)else[x//2forxink]# auto-padreturnpclassConv(nn.Module):"""Standard convolution module with batch normalization and activation. Attributes: conv (nn.Conv2d): Convolutional layer. bn (nn.BatchNorm2d): Batch normalization layer. act (nn.Module): Activation function layer. default_act (nn.Module): Default activation function (SiLU). """default_act=nn.SiLU()# default activationdef__init__(self,c1,c2,k=1,s=1,p=None,g=1,d=1,act=True):"""Initialize Conv layer with given parameters. Args: c1 (int): Number of input channels. c2 (int): Number of output channels. k (int): Kernel size. s (int): Stride. p (int, optional): Padding. g (int): Groups. d (int): Dilation. act (bool | nn.Module): Activation function. """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_actifactisTrueelseactifisinstance(act,nn.Module)elsenn.Identity()defforward(self,x):"""Apply convolution, batch normalization and activation to input tensor. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Output tensor. """returnself.act(self.bn(self.conv(x)))defforward_fuse(self,x):"""Apply convolution and activation without batch normalization. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Output tensor. """returnself.act(self.conv(x))classBottleneck(nn.Module):"""Standard bottleneck."""def__init__(self,c1:int,c2:int,shortcut:bool=True,g:int=1,k:tuple[int,int]=(3,3),e:float=0.5):"""Initialize a standard bottleneck module. Args: c1 (int): Input channels. c2 (int): Output channels. shortcut (bool): Whether to use shortcut connection. g (int): Groups for convolutions. k (tuple): Kernel sizes for convolutions. e (float): Expansion ratio. """super().__init__()c_=int(c2*e)# hidden channelsself.cv1=Conv(c1,c_,k[0],1)self.cv2=Conv(c_,c2,k[1],1,g=g)self.add=shortcutandc1==c2defforward(self,x:torch.Tensor)->torch.Tensor:"""Apply bottleneck with optional shortcut connection."""returnx+self.cv2(self.cv1(x))ifself.addelseself.cv2(self.cv1(x))

功能

• 特征压缩与恢复：通过c_ = int(c2 * e)将通道压缩（通常e=0.5即减半），然后通过第二个卷积恢复，减少计算量。
• 残差连接：当shortcut=True且输入输出通道数相同时，将输入直接与输出相加，促进梯度流动。
• 灵活配置：支持分组卷积、自定义卷积核大小，适应不同网络设计。

初始化参数

前向方法

• forward(x)：输入x，输出形状[B, c2, H, W]（空间尺寸不变）。

计算流程：

1. y = self.cv1(x)：第一个卷积，通道数变为c_。
2. z = self.cv2(y)：第二个卷积，通道数恢复为c2。
3. 若self.add为真（shortcut=True且c1 == c2），返回x + z；否则返回z。

使用示例

if__name__=='__main__':# 1. 创建随机输入x=torch.randn(1,32,64,64)# 2. 创建 Bottleneck 模块：输入32，输出64，shortcut=False（因为通道不等）bottleneck1=Bottleneck(c1=32,c2=64,shortcut=True,e=0.5,k=(3,3))# 3. 前向传播withtorch.no_grad():out1=bottleneck1(x)print("输入形状:",x.shape)# [1, 32, 64, 64]print("输出形状:",out1.shape)# [1, 64, 64, 64]# 4. 创建通道相等且启用shortcut的模块bottleneck2=Bottleneck(c1=64,c2=64,shortcut=True,e=0.5)withtorch.no_grad():out2=bottleneck2(out1)print("shortcut 输出形状:",out2.shape)# [1, 64, 64, 64]# 5. 使用真实图像演示（单通道扩展为多通道）img_path="cat_640x640.png"img_bgr=cv2.imread(img_path)ifimg_bgrisnotNone:# 缩放到 64x64，转为灰度图img_gray=cv2.cvtColor(cv2.resize(img_bgr,(64,64)),cv2.COLOR_BGR2GRAY)img_tensor=torch.from_numpy(img_gray).float().unsqueeze(0).unsqueeze(0)# [1,1,64,64]# 扩展通道数至 32（模拟特征图）x_img=img_tensor.repeat(1,32,1,1)# [1,32,64,64]# 创建 Bottleneck（输入32，输出32，shortcut启用）bottleneck_img=Bottleneck(c1=32,c2=32,shortcut=True,e=0.5)withtorch.no_grad():out_img=bottleneck_img(x_img)# 可视化：输入通道0、输出通道0inp_ch0=x_img[0,0].cpu().numpy()out_ch0=out_img[0,0].cpu().numpy()defnorm(arr):return(arr-arr.min())/(arr.max()-arr.min()+1e-8)plt.figure(figsize=(12,5),constrained_layout=True)plt.subplot(1,3,1)plt.imshow(img_gray,cmap='gray')plt.title("Original Gray")plt.axis("off")plt.subplot(1,3,2)plt.imshow(norm(inp_ch0),cmap='gray')plt.title("Input Ch0")plt.axis("off")plt.subplot(1,3,3)plt.imshow(norm(out_ch0),cmap='gray')plt.title("Bottleneck Output Ch0")plt.axis("off")plt.savefig("bottleneck_demo.png",dpi=150)print("可视化已保存为 bottleneck_demo.png")

输出示例：

输入形状: torch.Size([1, 32, 64, 64]) 输出形状: torch.Size([1, 64, 64, 64]) shortcut 输出形状: torch.Size([1, 64, 64, 64]) 可视化已保存为 bottleneck_demo.png

流程示意图

代码解读

• __init__：
  • c_ = int(c2 * e)：计算隐藏层通道数，通常小于c2，实现降维。
  • self.cv1：第一个卷积，使用核大小k[0]（默认 3），步长 1，将通道从c1映射到c_。
  • self.cv2：第二个卷积，使用核大小k[1]（默认 3），步长 1，分组数g，将通道从c_映射到c2。
  • self.add：布尔值，决定是否启用残差连接（条件为shortcut=True且c1 == c2）。
• forward：
  • 若self.add为真，返回x + self.cv2(self.cv1(x))，否则仅返回self.cv2(self.cv1(x))。

注意事项

1. 空间尺寸不变：所有卷积步长均为 1，填充自动为 same，因此输入输出空间尺寸相同。
2. 残差条件：只有shortcut=True且c1 == c2时才会添加残差，否则无残差。
3. 扩展比e：通常取 0.5，使隐藏层通道减半，降低参数量。也可根据需要调整（如 1.0 表示不压缩）。
4. 分组卷积：g用于第二个卷积，可减少参数量（如深度可分离卷积）。
5. 核大小灵活性：允许分别指定两个卷积的核大小，适应不同感受野需求。

优缺点

优点

1. 参数高效：通过先降维后升维，减少计算量和参数量，提高模型效率。
2. 残差机制：保持梯度传递，便于训练深层网络。
3. 灵活配置：支持 shortcut 开关、分组卷积、自定义核大小，适配多种场景。
4. 与残差网络兼容：可无缝替换标准 ResNet 瓶颈块。

缺点

1. 表达能力受限：降维比e较小时可能损失部分特征信息。
2. 无跨层融合：与 CSP 结构相比，缺少特征复用机制，梯度多样性稍弱。
3. 对通道数敏感：若c1与c2相差较大，残差失效，可能影响训练。

在 YOLOv5/YOLOv8 中，Bottleneck是构建C2f和C3模块的基础单元。实际使用时，可根据任务设置合适的e、g和k，并注意在深层网络中合理启用 shortcut。

参考文献

[1] https://docs.ultralytics.com/
[2] https://github.com/ultralytics/ultralytics.git

• 由于本人水平有限，难免出现错漏，敬请批评改正。
• 更多精彩内容，可点击进入Python日常小操作专栏、OpenCV-Python小应用专栏、YOLO系列专栏、自然语言处理专栏、人工智能混合编程实践专栏或我的个人主页查看
• YOLOs-CPP：一个免费开源的YOLO全系列C++推理库（以YOLO26为例）
• PaddleOCR：Win10上安装使用PPOCRLabel标注工具
• 目标检测：使用自己的数据集微调DEIMv2进行物体检测
• 图像分割：PyTorch从零开始实现SegFormer语义分割
• 图像超分：使用自己的数据集微调Real-ESRGAN-x4plus进行超分重建
• 图像生成：PyTorch从零开始实现一个简单的扩散模型
• Stable Diffusion：使用自己的数据集微调 Stable Diffusion 3.5 LoRA 文生图模型
• 图像超分：使用自己的数据集微调Real-ESRGAN-x2plus进行超分重建
• Anomalib：使用Anomalib 2.1.0训练自己的数据集进行异常检测
• Anomalib：在Linux服务器上安装使用Anomalib 2.1.0
• 人工智能混合编程实践：C++调用封装好的DLL进行异常检测推理
• 人工智能混合编程实践：C++调用封装好的DLL进行FP16图像超分重建（v3.0）
• 隔离系统Python：源码编译3.11.8到自定义目录（含PGO性能优化）
• 在线机的Python环境迁移到离线机上
• Nuitka 将 Python 脚本封装为 .pyd 或 .so 文件
• Ultralytics：使用 YOLO11 进行速度估计
• Ultralytics：使用 YOLO11 进行物体追踪
• Ultralytics：使用 YOLO11 进行物体计数
• Ultralytics：使用 YOLO11 进行目标打码
• 人工智能混合编程实践：C++调用Python ONNX进行YOLOv8推理
• 人工智能混合编程实践：C++调用封装好的DLL进行YOLOv8实例分割
• 人工智能混合编程实践：C++调用Python ONNX进行图像超分重建
• 人工智能混合编程实践：C++调用Python AgentOCR进行文本识别
• 通过计算实例简单地理解PatchCore异常检测
• Python将YOLO格式实例分割数据集转换为COCO格式实例分割数据集
• YOLOv8 Ultralytics：使用Ultralytics框架训练RT-DETR实时目标检测模型
• 基于DETR的人脸伪装检测
• YOLOv7训练自己的数据集（口罩检测）
• YOLOv8训练自己的数据集（足球检测）
• YOLOv5：TensorRT加速YOLOv5模型推理
• YOLOv5：IoU、GIoU、DIoU、CIoU、EIoU
• 玩转Jetson Nano（五）：TensorRT加速YOLOv5目标检测
• YOLOv5：添加SE、CBAM、CoordAtt、ECA注意力机制
• YOLOv5：yolov5s.yaml配置文件解读、增加小目标检测层
• Python将COCO格式实例分割数据集转换为YOLO格式实例分割数据集
• YOLOv5：使用7.0版本训练自己的实例分割模型（车辆、行人、路标、车道线等实例分割）
• 使用Kaggle GPU资源免费体验Stable Diffusion开源项目
• Stable Diffusion：在服务器上部署使用Stable Diffusion WebUI进行AI绘图（v2.0）
• Stable Diffusion：使用自己的数据集微调训练LoRA模型（v2.0）