YOLOv8 多种任务网络结构详细解析 | 目标检测、实例分割、人体关键点检测、图像分类

秋山丶雪绪2024-06-02 11:21

前言

本文仅根据模型的预测过程，即从输入图像到输出结果（图像预处理、模型推理、后处理），来展现不同任务下的网络结构，OBB 任务暂不包含。

Backbone

1. yolov8m

2. yolov8m-p2

3. yolov8m-p6

4. 细节

  • 图中 CBS = Conv2d + BatchNorm2d + SiLU，上方为卷积参数对应 size, stride, padding
  • 各模块细节至 [附录 - Block Modules](#附录 - Block Modules) 查看
  • yolov8m-p2 通过增加一次上采样，与 2-P2 融合得到针对小目标的 P2 输出。
  • yolov8m-p6 通过增加一次下采样和一次上采样，与 10-P6 融合得到针对大目标的 P6 输出；因为多了一次下采样需要图像的分辨率能被64整除，所以图像预处理输出的分辨率有所不同。
  • yolov8m-p6 将 SPPF 之后的 C2f 模块替换为了 C2 模块。
  • SPPF 之前的 C2f 模块中的 Bottleneck 启用 add，而其之后的 C2f / C2 中的 Bottleneck 未启用 add

5. Image Preprocess


  上图按 yolov8m-p6 绘制，LetterBox 环节先保持长宽比将图像较长边缩放至 640，再对四周做填充，使 h , w h,w h,w 都可被模型最大下采样倍率整除（ p 6 → 2 6 = 64 \mathrm{p6}\to2^6=64 p6→26=64）

python 复制代码 
img = cv2.copyMakeBorder(
	img, top, bottom, left, right, cv2.BORDER_CONSTANT, value=(114, 114, 114)
)

1. Detect


  Detect 部分尤为重要，Segment 和 Pose 都包含 Detect Head，依赖目标检测的结果。

实际上 Concat 后获得的 x 0 , x 1 , x 2 x_0, x_1, x_2 x0,x1,x2 就是训练阶段网络的输出，后续的步骤中不包含网络中需要训练的参数。
  Detect head 通过两个分支 cv2 和 cv3 分别得到检测框和分类的输出。分类的输出较好理解，在后续步骤中通过 Sigmoid 直接得到对应 80 个类别的置信度。检测框的部分需要结合 DFL 理解。

python 复制代码 
class DFL(nn.Module):
    def __init__(self, c1=16):
        super().__init__()
        self.conv = nn.Conv2d(c1, 1, 1, bias=False).requires_grad_(False)
        x = torch.arange(c1, dtype=torch.float)
        self.conv.weight.data[:] = nn.Parameter(x.view(1, c1, 1, 1))
        self.c1 = c1
        
    def forward(self, x):
        b, _, a = x.shape  # batch, channels, anchors
        return self.conv(x.view(b, 4, self.c1, a).transpose(2, 1).softmax(1)).view(b, 4, a)


  box 中的 64 代表 4 个位置坐标，每个坐标是长度 16 的向量，经过 softmax 得到 16 个概率值；DFL 中卷积参数为固定值 0~15，卷积运算便是与这 16 个概率值做加权求和，最终得到坐标值，其范围也是 [0, 15]。

python 复制代码 
lt, rb = dfl(box).chunk(2, dim=1)
x1y1 = anchor_points - lt
x2y2 = anchor_points + rb

Anchor：以 x 0 x_0 x0 为例，按其分辨率 80 × 60 80\times60 80×60 绘制一个网格，每个格子边长为 1 1 1，左上角为原点， x x x 轴向右， y y y 轴向下，每个格子的中心点坐标就是 Anchor 坐标，例如左上角坐标为 ( 0.5 , 0.5 ) (0.5,0.5) (0.5,0.5)，右下角坐标为 ( 59.5 , 79.5 ) (59.5,79.5) (59.5,79.5)。
  从代码中可以看出，DFL 得到的坐标为目标框左上角和右下角坐标与 Anchor 坐标的距离。

Postprocess - NMS

  1. 根据阈值 conf_thres=0.25 筛选出置信度较高的 Anchor
  2. 若数量较多，则选取置信度较高的 max_nms=30000 项参与 NMS
  3. i = torchvision.ops.nms(boxes, scores, iou_thres)
  4. 若数量较多，则选取 i 中前 max_det=300 项作为最终检测结果

2. Segment


  Segment 添加了一个类似 Detect 中 cv2 和 cv3 的分支 cv4 计算分割结果

mc 中 6300 代表 Anchor，32 代表 Mask。在 Detect 中每个 Anchor 对应了一个检测结果，mc 则是每个检测结果对应的分割结果 Mask，而 Mask 使用一个长度为 32 的向量表示。
  p 用于将 mc 中的 Mask 解码成常规的 Mask（二值图），具体步骤如下：

  • mc @ p.view(32, -1).sigmoid().view(-1, 160, 120)
    这里的 mc 大小为 [n, 32]，n 为经过 NMS 等后处理后最终目标检测的数量，通过矩阵乘法、Sigmoid、Reshape 操作得到了 Mask
  • crop_mask(masks, downsampled_bboxes)
    根据对应的检测结果，将检测框外的 Mask 数值置零
  • F.interpolate(masks, image_shape, mode="bilinear", align_corners=False)
    上采样至原图分辨率
  • masks.gt_(0.5)
    以 0.5 为阈值转为零一矩阵，即最终每个检测目标对应的 Mask

3. Pose


  上图以 yolov8m-p6 作为 backbone， 51 = 17 × 3 51=17\times3 51=17×3 即 17 个关键点，每个点有 ( x , y , v i s i b l e ) (x,y,\mathrm{visible}) (x,y,visible) 3 个值，visible 代表该关键点是否可见，可视化时会根据阈值（默认 0.25）判断关键点是否可见。

python 复制代码 
y = kpts.clone()
if ndim == 3:
    y[:, 2::3] = y[:, 2::3].sigmoid()
y[:, 0::ndim] = (y[:, 0::ndim] * 2.0 + (self.anchors[0] - 0.5)) * self.strides
y[:, 1::ndim] = (y[:, 1::ndim] * 2.0 + (self.anchors[1] - 0.5)) * self.strides

上述代码为图中 decode 过程。Anchor 坐标与 Detect 部分略有不同，anchors - 0.5 可以看作以网格左上角而非中心点作为 Anchor 坐标。 x , y x,y x,y 为距离 Anchor 坐标的一半（为何采用一半？）。

Classify

1. Backbone

2. Head

3. Image Preprocess


Normalize 对图像数据并无影响

附录

1. 模型配置文件 yaml

https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models

python 复制代码 
# yolov8.yaml

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]]	# 2
  - [-1, 1, Conv, [256, 3, 2]] 	# 3-P3/8
  - [-1, 6, C2f, [256, True]]	# 4
  - [-1, 1, Conv, [512, 3, 2]] 	# 5-P4/16
  - [-1, 6, C2f, [512, True]]	# 6
  - [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
  - [-1, 3, C2f, [1024, True]]	# 8
  - [-1, 1, SPPF, [1024, 5]] 	# 9

# YOLOv8.0n head
head:
  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]	# 10
  - [[-1, 6], 1, Concat, [1]] 	# 11 cat backbone P4
  - [-1, 3, C2f, [512]] 		# 12

  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]	#13
  - [[-1, 4], 1, Concat, [1]] 	# 14 cat backbone P3
  - [-1, 3, C2f, [256]] 		# 15 (P3/8-small)

  - [-1, 1, Conv, [256, 3, 2]]	# 16
  - [[-1, 12], 1, Concat, [1]] 	# 17 cat head P4
  - [-1, 3, C2f, [512]] 		# 18 (P4/16-medium)

  - [-1, 1, Conv, [512, 3, 2]]	# 19
  - [[-1, 9], 1, Concat, [1]] 	# 20 cat head P5
  - [-1, 3, C2f, [1024]] 		# 21 (P5/32-large)

  - [[15, 18, 21], 1, Detect, [nc]] # Detect(P3, P4, P5)
python 复制代码 
[-1, 3, C2f, [1024, True]]	# 8
"""
from: 	-1, 代表这一层的输入为上一层的输出
repeats: 3, 代表 C2f 中有3个 Bottleneck, 实际不同尺度的模型会根据 depth 调整数量
			例如 yolov8m 该层实际的 repeats = 3*0.67 = 2
module:	C2f
args:	[1024, True], 代表 module 的参数
			1024 代表 channel 数, 实际不同尺度的模型会根据 width 和 max_channels
			例如 yolov8m 该层实际的 channel = min(1024, 768)*0.75 = 576
			True 代表 Bottleneck 中是否启用 add
"""

2. Block Modules

https://github.com/ultralytics/ultralytics/blob/main/ultralytics/nn/modules/block.py

SPP & SPPF


  对比下方源码可知，SPP 与 SPPF 的区别主要在于 MaxPool2d 的 kernel size & padding，SPP 依次递增，SPPF 保持不变重复利用一个池化层。

python 复制代码 
class SPP(nn.Module):
    def __init__(self, c1, c2, k=(5, 9, 13)):
        super().__init__()
        c_ = c1 // 2  # hidden channels
        self.cv1 = Conv(c1, c_, 1, 1)
        self.cv2 = Conv(c_ * (len(k) + 1), c2, 1, 1)
        self.m = nn.ModuleList([nn.MaxPool2d(kernel_size=x, stride=1, padding=x // 2) for x in k])

    def forward(self, x):
        x = self.cv1(x)
        return self.cv2(torch.cat([x] + [m(x) for m in self.m], 1))


class SPPF(nn.Module):
    def __init__(self, c1, c2, k=5):
        super().__init__()
        c_ = c1 // 2  # hidden channels
        self.cv1 = Conv(c1, c_, 1, 1)
        self.cv2 = Conv(c_ * 4, c2, 1, 1)
        self.m = nn.MaxPool2d(kernel_size=k, stride=1, padding=k // 2)

    def forward(self, x):
        y = [self.cv1(x)]
        y.extend(self.m(y[-1]) for _ in range(3))
        return self.cv2(torch.cat(y, 1))

C2

C2f

Bottleneck

相关推荐
喵~来学编程啦36 分钟前
【论文精读】LPT: Long-tailed prompt tuning for image classification
人工智能·深度学习·机器学习·计算机视觉·论文笔记
蒙娜丽宁6 小时前
《Python OpenCV从菜鸟到高手》——零基础进阶，开启图像处理与计算机视觉的大门！
python·opencv·计算机视觉
好喜欢吃红柚子6 小时前
万字长文解读空间、通道注意力机制机制和超详细代码逐行分析（SE,CBAM,SGE,CA,ECA,TA）
人工智能·pytorch·python·计算机视觉·cnn
AI小杨6 小时前
【车道线检测】一、传统车道线检测：基于霍夫变换的车道线检测史诗级详细教程
人工智能·opencv·计算机视觉·霍夫变换·车道线检测
撞南墙者9 小时前
OpenCV自学系列（1）——简介和GUI特征操作
人工智能·opencv·计算机视觉
王哈哈^_^9 小时前
【数据集】【YOLO】【VOC】目标检测数据集，查找数据集，yolo目标检测算法详细实战训练步骤！
人工智能·深度学习·算法·yolo·目标检测·计算机视觉·pyqt
柳鲲鹏10 小时前
OpenCV视频防抖源码及编译脚本
人工智能·opencv·计算机视觉
咔叽布吉12 小时前
【论文阅读笔记】CamoFormer: Masked Separable Attention for Camouflaged Object Detection
论文阅读·笔记·目标检测
浮生如梦_15 小时前
Halcon基于laws纹理特征的SVM分类
图像处理·人工智能·算法·支持向量机·计算机视觉·分类·视觉检测
深度学习lover15 小时前
＜项目代码＞YOLOv8 苹果腐烂识别＜目标检测＞
人工智能·python·yolo·目标检测·计算机视觉·苹果腐烂识别
热门推荐
01【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总02(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04【AIGC】重塑未来的科技巨轮05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06【经验分享】Ubuntu22.04安装微信(linux官方版)07基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测08Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO09RAG 实践- Ollama+RagFlow 部署本地知识库10【TC3xx芯片】TC3xx芯片电源管理系统PMS详解