Pytorch实战 |Y3 yolov5s.yaml文件解读

• Yolov5配置了4种不同大小的网络模型，分别是YOLOv5s、YOLOv5m、YOLOv5l、YOLOv5x，其中YOLOv5s是网络深度和宽度最小但检测速度最快的模型，其他3种模型都是在YOLOv5的基础上不断加深、加宽网络是的网络规模扩大，在增强模型检测性能的同时，增加了计算资源和速度。处于对检测精度、模型大小以及检测速度的综合考量，本文对YOLOv5s进行研究。
• ./models/yolov5s.yaml文件是yolov5s的网络结构，如果要改算法网络结构可以再此文件中进行修改，然后再修改./models/common.py和./models/yolo.py中的代码。

一、YOLOv5s网络结构

如下图，根据yolov5s.yaml文件中结构，参考网上资料使用PPT画的。

二、代码解读

1、参数配置

nc: 80  # number of classes
depth_multiple: 0.33  # model depth multiple  控制模型的深度
width_multiple: 0.50  # layer channel multiple 控制Conv通道channel个数

• depth_multiple 表示 BottleneckCSP 模块层的缩放因子,将所有的 BottleneckCSP 模块的 Bottleneck 乘上该参数得到最终个数。控制子模块数量=int(number*depth)
• width_multiple 表示卷积通道的缩放因子,就是将配置里面的 backbone 和 head 部分有关 Conv 通道的设置，全部乘以该系数。控制卷积核的数量=int(number*width)

YOLOv5s、YOLOv5m、YOLOv5l、YOLOv5x四种模型的区别仅在于depth_multiple 和width_multiple两个参数的不同。
以上三个参数，会用于模型搭建yolo.py文件中

读取 yaml 中的 anchors 和 parameters
anchors, nc, gd, gw = d['anchors'], d['nc'], d['depth_multiple'], d['width_multiple'] 

通过深度参数 depth gain, 在搭建每层时, 实际深度 = 理论深度（每一层的参数n）* depth_multiple，起到动态调整模型深度的作用

n = max(round(n * gd), 1) if n > 1 else n  # depth gain

在模型中间层的每一层的实际输出 channel = 理论channel（每一层的参数c2）* width_multiple，起到动态调整模型宽度的作用。

控制宽度(卷积核个数)的代码
c2 = make_divisible(c2 * gw, 8) if c2 != no else c2

2、anchors配置

anchors:
  - [10,13, 16,30, 33,23]  # P3/8 ，检测小目标，10,13是一组尺寸，总共三组检测小目标
  - [30,61, 62,45, 59,119]  # P4/16，检测中目标，共三组
  - [116,90, 156,198, 373,326]  # P5/32，检测大目标，共三组

yolov5初始化了9个anchors，在三个Detect层使用（3个feature map）中使用，每个feature map的买个grid cell 都有三个anchor进行预测。
分配规则：

• 尺度越大的 feature map 越靠前，相对原图的下采样率越小，感受野越小，所以相对可以预测一些尺度比较小的物体，所以分配到的 anchors 越小；
• 尺度越小的 feature map 越靠后，相对原图的下采样率越大，感受野越大，所以可以预测一些尺度比较大的物体，所以分配到的 anchors 越大；
• 即在小特征图（feature map）上检测大目标，在大特征图上检测小目标。

YOLOv5 根据经验得到了这么 3 组 anchors，对于很多数据集而言确实挺合适的。但是也不能保证这 3 组 anchors 就适用于所有的数据集，所有 yolov5 还有一个anchor进化的策略：使用 k-means 和遗传进化算法，找到与当前数据集最吻合的 anchors。

3、backbone

 # YOLOv5 v6.0 backbone
backbone:
  # [from, number, module, args]
  [[-1, 1, Conv, [64, 6, 2, 2]],  # 0-P1/2
   [-1, 1, Conv, [128, 3, 2]],  # 1-P2/4
   [-1, 3, C3, [128]],
   [-1, 1, Conv, [256, 3, 2]],  # 3-P3/8
   [-1, 6, C3, [256]],
   [-1, 1, Conv, [512, 3, 2]],  # 5-P4/16
   [-1, 9, C3, [512]],
   [-1, 1, Conv, [1024, 3, 2]],  # 7-P5/32
   [-1, 3, C3, [1024]],
   [-1, 1, SPPF, [1024, 5]],  # 9
  ]

• from：表示当前模块的输入来自那一层的输出，-1表示来自上一层的输出。
• number：表示当前模块的理论重复次数，实际的重复次数还要由上面的参数 depth_multiple 共同决定，决定网络模型的深度。
• module：模块类名，通过这个类名去 common.py 中寻找相应的类，进行模块化的搭建网络。
• args：是一个 list，模块搭建所需参数，channel，kernel_size，stride，padding，bias等,会在网络搭建过程中根据不同层进行改变.

4、head

# YOLOv5 v6.0 head
head:
  [[-1, 1, Conv, [512, 1, 1]],
   [-1, 1, nn.Upsample, [None, 2, 'nearest']],
   [[-1, 6], 1, Concat, [1]],  # cat backbone P4
   [-1, 3, C3, [512, False]],  # 13

   [-1, 1, Conv, [256, 1, 1]],
   [-1, 1, nn.Upsample, [None, 2, 'nearest']],
   [[-1, 4], 1, Concat, [1]],  # cat backbone P3
   [-1, 3, C3, [256, False]],  # 17 (P3/8-small)

   [-1, 1, Conv, [256, 3, 2]],
   [[-1, 14], 1, Concat, [1]],  # cat head P4
   [-1, 3, C3, [512, False]],  # 20 (P4/16-medium)

   [-1, 1, Conv, [512, 3, 2]],
   [[-1, 10], 1, Concat, [1]],  # cat head P5
   [-1, 3, C3, [1024, False]],  # 23 (P5/32-large)

   [[17, 20, 23], 1, Detect, [nc, anchors]],  # Detect(P3, P4, P5)
  ]

和backbone基本一样，由4个参数构成

5、整体模型

                 from  n    params  module                                  arguments                     
  0                -1  1      3520  models.common.Conv                      [3, 32, 6, 2, 2]              
  1                -1  1     18560  models.common.Conv                      [32, 64, 3, 2]                
  2                -1  1     18816  models.common.C3                        [64, 64, 1]                   
  3                -1  1     73984  models.common.Conv                      [64, 128, 3, 2]               
  4                -1  2    115712  models.common.C3                        [128, 128, 2]                 
  5                -1  1    295424  models.common.Conv                      [128, 256, 3, 2]              
  6                -1  3    625152  models.common.C3                        [256, 256, 3]                 
  7                -1  1   1180672  models.common.Conv                      [256, 512, 3, 2]              
  8                -1  1   1182720  models.common.C3                        [512, 512, 1]                 
  9                -1  1    656896  models.common.SPPF                      [512, 512, 5]
 10                -1  1    131584  models.common.Conv                      [512, 256, 1, 1]
 11                -1  1         0  torch.nn.modules.upsampling.Upsample    [None, 2, 'nearest']
 12           [-1, 6]  1         0  models.common.Concat                    [1]
 13                -1  1    361984  models.common.C3                        [512, 256, 1, False]          
 14                -1  1     33024  models.common.Conv                      [256, 128, 1, 1]
 15                -1  1         0  torch.nn.modules.upsampling.Upsample    [None, 2, 'nearest']
 16           [-1, 4]  1         0  models.common.Concat                    [1]
 17                -1  1     90880  models.common.C3                        [256, 128, 1, False]
 18                -1  1    147712  models.common.Conv                      [128, 128, 3, 2]
 19          [-1, 14]  1         0  models.common.Concat                    [1]
 20                -1  1    296448  models.common.C3                        [256, 256, 1, False]
 21                -1  1    590336  models.common.Conv                      [256, 256, 3, 2]
 22          [-1, 10]  1         0  models.common.Concat                    [1]
 23                -1  1   1182720  models.common.C3                        [512, 512, 1, False]          
 24      [17, 20, 23]  1     24273  models.yolo.Detect                      [4, [[10, 13, 16, 30, 33, 23], [30, 61, 62, 45, 59, 119], [116, 90, 156, 198, 373, 326]], [128, 256, 512]] 
 YOLOv5s summary: 214 layers, 7030417 parameters, 7030417 gradients, 16.0 GFLOPs