YOLOv5源码逐行超详细注释与解读——网络结构yolo.py
Posted 路人贾'ω'
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了YOLOv5源码逐行超详细注释与解读——网络结构yolo.py相关的知识，希望对你有一定的参考价值。
前言
在上一篇中，我们简单介绍了YOLOv5的配置文件之一 yolov5s.yaml，这个文件中涉及很多参数，它们的调用会在这篇 yolo.py 和下一篇 common.py 中具体实现。
本篇我们会介绍 yolo.py，这是YOLO的特定模块，和网络构建有关。在 YOLOv5源码中，模型的建立是依靠 yolo.py 中的函数和对象完成的，这个文件主要由三个部分：parse_model函数、Detect类和Model类组成。
common.py文件位置在./models/yolo.py
文章代码逐行手打注释，每个模块都有对应讲解，一文帮你梳理整个代码逻辑！
友情提示：全文4万字，可以先点
再慢慢看哦~
源码下载地址：mirrors / ultralytics / yolov5 · GitCode
🍀本人YOLOv5源码详解系列：
YOLOv5源码逐行超详细注释与解读（1）——项目目录结构解析
YOLOv5源码逐行超详细注释与解读（2）——推理部分detect.py
YOLOv5源码逐行超详细注释与解读（3）——训练部分train.py
YOLOv5源码逐行超详细注释与解读（4）——验证部分val（test）.py
YOLOv5源码逐行超详细注释与解读（5）——配置文件yolov5s.yaml
目录
4.2.2 _forward_augment():推理的forward
4.2.3 _forward_once():训练的forward
4.2.4 _descale_pred():将推理结果恢复到原图尺寸
4.2.5 _clip_augmented（）:TTA的时候对原图片进行裁剪
4.2.6 _profile_one_layer（）:打印日志信息
4.2.7 _initialize_biases（）:初始化偏置biases信息
4.2.8 _print_biases（）:打印偏置biases信息
4.2.12 _apply():将模块转移到 CPU/ GPU上
🚀一、 导包和基本配置
1.1 导入安装好的python库
'''======================1.导入安装好的python库====================='''
import argparse # 解析命令行参数模块
import sys # sys系统模块 包含了与Python解释器和它的环境有关的函数
from copy import deepcopy # 数据拷贝模块 深拷贝
from pathlib import Path # Path将str转换为Path对象 使字符串路径易于操作的模块首先，导入一下常用的python库：
- argparse： 它是一个用于命令项选项与参数解析的模块，通过在程序中定义好我们需要的参数，argparse 将会从 sys.argv 中解析出这些参数，并自动生成帮助和使用信息
- sys： 它是与python解释器交互的一个接口，该模块提供对解释器使用或维护的一些变量的访问和获取，它提供了许多函数和变量来处理 Python 运行时环境的不同部分
- copy： Python 中赋值语句不复制对象，而是在目标和对象之间创建绑定关系。copy模块提供了通用的浅层复制和深层复制操作
- pathlib： 这个库提供了一种面向对象的方式来与文件系统交互，可以让代码更简洁、更易读
1.2 获取当前文件的绝对路径
'''===================2.获取当前文件的绝对路径========================'''
FILE = Path(__file__).resolve() # __file__指的是当前文件(即val.py),FILE最终保存着当前文件的绝对路径,比如D://yolov5/modles/yolo.py
ROOT = FILE.parents[1] # YOLOv5 root directory 保存着当前项目的父目录,比如 D://yolov5
if str(ROOT) not in sys.path: # sys.path即当前python环境可以运行的路径,假如当前项目不在该路径中,就无法运行其中的模块,所以就需要加载路径
sys.path.append(str(ROOT)) # add ROOT to PATH 把ROOT添加到运行路径上
# ROOT = ROOT.relative_to(Path.cwd()) # relative ROOT设置为相对路径这段代码会获取当前文件的绝对路径，并使用Path库将其转换为Path对象。
这一部分的主要作用有两个：
- 将当前项目添加到系统路径上，以使得项目中的模块可以调用。
- 将当前项目的相对路径保存在ROOT中，便于寻找项目中的文件。
1.3 加载自定义模块
'''===================3..加载自定义模块============================'''
from models.common import * # yolov5的网络结构(yolov5)
from models.experimental import * # 导入在线下载模块
from utils.autoanchor import check_anchor_order # 导入检查anchors合法性的函数
from utils.general import LOGGER, check_version, check_yaml, make_divisible, print_args # 定义了一些常用的工具函数
from utils.plots import feature_visualization # 定义了Annotator类，可以在图像上绘制矩形框和标注信息
from utils.torch_utils import (copy_attr, fuse_conv_and_bn, initialize_weights, model_info, scale_img, select_device,
time_sync) # 定义了一些与PyTorch有关的工具函数
# 导入thop包 用于计算FLOPs
try:
import thop # for FLOPs computation
except ImportError:
thop = None这些都是用户自定义的库，由于上一步已经把路径加载上了，所以现在可以导入，这个顺序不可以调换。具体来说，代码从如下几个文件中导入了部分函数和类：
- models.common： 这个是yolov5的网络结构
- models.experimental： 实验性质的代码，包括MixConv2d、跨层权重Sum等
- utils.autoanchor： 定义了自动生成锚框的方法
- utils.general： 定义了一些常用的工具函数，比如检查文件是否存在、检查图像大小是否符合要求、打印命令行参数等等
- utils.plots： 定义了Annotator类，可以在图像上绘制矩形框和标注信息
- utils.torch_utils： 定义了一些与PyTorch有关的工具函数，比如选择设备、同步时间等
通过导入这些模块，可以更方便地进行目标检测的相关任务，并且减少了代码的复杂度和冗余。
🚀二、parse_model函数
parse_model函数用在DetectionModel模块中，主要作用是解析模型yaml的模块，通过读取yaml文件中的配置，并且到common.py中找到相对于的模块，然后组成一个完整的模型解析模型文件(字典形式)，并搭建网络结构。简单来说，就是把yaml文件中的网络结构实例化成对应的模型。后续如果需要动模型框架的话，需要对这个函数做相应的改动。
2.1 获取对应参数
def parse_model(d, ch): # model_dict, input_channels(3)
'''===================1. 获取对应参数============================'''
# 使用 logging 模块输出列标签
LOGGER.info(f"\\n'':>3'from':>18'n':>3'params':>10 'module':<40'arguments':<30")
# 获取anchors，nc，depth_multiple，width_multiple
anchors, nc, gd, gw = d['anchors'], d['nc'], d['depth_multiple'], d['width_multiple']
# na: 每组先验框包含的先验框数
na = (len(anchors[0]) // 2) if isinstance(anchors, list) else anchors # number of anchors
# no: na * 属性数 (5 + 分类数)
no = na * (nc + 5) # number of outputs = anchors * (classes + 5)这段代码主要是获取配置dict里面的参数，并打印最开始展示的网络结构表的表头。
我们先解释几个参数，d和ch，na和no：
- d: yaml 配置文件（字典形式），yolov5s.yaml中的6个元素 + ch
- ch: 记录模型每一层的输出channel，初始ch=[3]，后面会删除
- na： 判断anchor的数量
- no： 根据anchor数量推断的输出维度
这里有一行代码我们上篇YOLOv5源码逐行超详细注释与解读（5）——配置文件yolov5s.yaml就见过了：
这里就是读取了 yaml 文件的相关参数（参数含义忘了的话再看看上篇哦）
2.2 搭建网络前准备
'''===================2. 搭建网络前准备============================'''
# 网络单元列表, 网络输出引用列表, 当前的输出通道数
layers, save, c2 = [], [], ch[-1] # layers, savelist, ch out
# 读取 backbone, head 中的网络单元
for i, (f, n, m, args) in enumerate(d['backbone'] + d['head']): # from, number, module, args
# 利用 eval 函数, 读取 model 参数对应的类名 如‘Focus’,'Conv'等
m = eval(m) if isinstance(m, str) else m # eval strings
# 利用 eval 函数将字符串转换为变量 如‘None’,‘nc’，‘anchors’等
for j, a in enumerate(args):
try:
args[j] = eval(a) if isinstance(a, str) else a # eval strings
except NameError:
pass这段代码主要是遍历backbone和head的每一层，获取搭建网络前的一系列信息。
我们还是先解释参数，layers、save和c2：
- layers: 保存每一层的层结构
- save: 记录下所有层结构中from不是-1的层结构序号
- c2: 保存当前层的输出channel
然后开始迭代循环backbone与head的配置。for i, (f, n, m, args) in enumerate(d['backbone'] + d['head']):中有几个参数
- f： from，当前层输入来自哪些层
- n： number，当前层次数 初定
- m： module，当前层类别
- args： 当前层类参数 初定
接着还用到一个函数eval（），主要作用是将字符串当成有效的表达式来求值，并且返回执行的结果。在这里简单来说，就是实现list、dict、tuple与str之间的转化。
2.3 更新当前层的参数，计算c2
'''===================3. 更新当前层的参数，计算c2============================'''
# depth gain: 控制深度，如yolov5s: n*0.33
# n: 当前模块的次数(间接控制深度)
n = n_ = max(round(n * gd), 1) if n > 1 else n # depth gain
# 当该网络单元的参数含有: 输入通道数, 输出通道数
if m in [Conv, GhostConv, Bottleneck, GhostBottleneck, SPP, SPPF, DWConv, MixConv2d, Focus, CrossConv,
BottleneckCSP, C3, C3TR, C3SPP, C3Ghost]:
# c1: 当前层的输入channel数; c2: 当前层的输出channel数(初定); ch: 记录着所有层的输出channel数
c1, c2 = ch[f], args[0]
# no=75，只有最后一层c2=no，最后一层不用控制宽度，输出channel必须是no
if c2 != no: # if not output
# width gain: 控制宽度，如yolov5s: c2*0.5; c2: 当前层的最终输出channel数(间接控制宽度)
c2 = make_divisible(c2 * gw, 8)这段代码主要是更新当前层的args，计算c2(当前层的输出channel)
首先网络将C3中的BottleNeck数量乘以模型缩放倍数n*gd控制模块的深度缩放，举个栗子，对于yolo5s来讲，gd为0.33，那么就是n*0.33，也就是把默认的深度缩放为原来的1/3。
然后将m实例化成同名模块，别看列举了那么多模块，目前只用到Conv，SPP，Focus，C3，nn.Upsample。对于以上的这几种类型的模块，ch是一个用来保存之前所有的模块输出的channle，ch[-1]代表着上一个模块的输出通道。args[0]是默认的输出通道。
这样以来，c1=ch[f]就代表输入通道c1为f指向的层的输出通道，c2=args[0]就代表输出通道c2为yaml的args中的第一个变量。注意，如果输出通道不等于255即Detect层的输出通道， 则将通道数乘上width_multiple，并调整为8的倍数。通过函数make_divisible来实现
make_divisible（）代码如下：
# 使得X能够被divisor整除
def make_divisible(x, divisor):
return math.ceil(x / divisor) * divisor2.4 使用当前层的参数搭建当前层
'''===================4.使用当前层的参数搭建当前层============================'''
# 在初始args的基础上更新，加入当前层的输入channel并更新当前层
# [in_channels, out_channels, *args[1:]]
args = [c1, c2, *args[1:]]
# 如果当前层是BottleneckCSP/C3/C3TR/C3Ghost/C3x，则需要在args中加入Bottleneck的个数
# [in_channels, out_channels, Bottleneck个数, Bool(shortcut有无标记)]
if m in [BottleneckCSP, C3, C3TR, C3Ghost]:
# 在第二个位置插入bottleneck个数n
args.insert(2, n) # number of repeats
# 恢复默认值1
n = 1
# 判断是否是归一化模块
elif m is nn.BatchNorm2d:
# BN层只需要返回上一层的输出channel
args = [ch[f]]
# 判断是否是tensor连接模块
elif m is Concat:
# Concat层则将f中所有的输出累加得到这层的输出channel
c2 = sum(ch[x] for x in f)
# 判断是否是detect模块
elif m is Detect:
# 在args中加入三个Detect层的输出channel
args.append([ch[x] for x in f])
if isinstance(args[1], int): # number of anchors 几乎不执行
args[1] = [list(range(args[1] * 2))] * len(f)
elif m is Contract: # 不怎么用
c2 = ch[f] * args[0] ** 2
elif m is Expand: # 不怎么用
c2 = ch[f] // args[0] ** 2
else:
c2 = ch[f] # args不变这段代码主要是使用当前层的参数搭建当前层。
经过以上处理，args里面保存的前两个参数就是module的输入通道数、输出通道数。只有BottleneckCSP和C3这两种module会根据深度参数n调整该模块的重复迭加次数。
然后进行的是其他几种类型的Module判断：
- 如果是BN层，只需要返回上一层的输出channel，通道数保持不变。
- 如果是Concat层，则将f中所有的输出累加得到这层的输出channel，f是所有需要拼接层的index，输出通道c2是所有层的和。
- 如果是Detect层，则对应检测头部分，这块下一小节细讲。
Contract和Expand目前未在模型中使用。
2.5 打印和保存layers
'''===================5.打印和保存layers信息============================'''
# m_: 得到当前层的module，将n个模块组合存放到m_里面
m_ = nn.Sequential(*(m(*args) for _ in range(n))) if n > 1 else m(*args) # module
# 打印当前层结构的一些基本信息
t = str(m)[8:-2].replace('__main__.', '') # module type
# 计算这一层的参数量
np = sum(x.numel() for x in m_.parameters()) # number params
m_.i, m_.f, m_.type, m_.np = i, f, t, np # attach index, 'from' index, type, number params
LOGGER.info(f'i:>3str(f):>18n_:>3np:10.0f t:<40str(args):<30') # print
# 把所有层结构中的from不是-1的值记下 [6,4,14,10,17,20,23]
save.extend(x % i for x in ([f] if isinstance(f, int) else f) if x != -1) # append to savelist
# 将当前层结构module加入layers中
layers.append(m_)
if i == 0:
ch = [] # 去除输入channel[3]
# 把当前层的输出channel数加入ch
ch.append(c2)
return nn.Sequential(*layers), sorted(save)这段代码主要是打印当前层结构的一些基本信息并保存。
把构建的模块保存到layers里，把该层的输出通道数写入ch列表里。待全部循环结束后再构建成模型。
返回值：
- return nn.Sequential(*layers): 网络的每一层的层结构
- return sorted(save): 把所有层结构中from不是-1的值记下 并排序 [4, 6, 10, 14, 17, 20, 23]
至此模型就全部构建完毕了。
下面详细介绍一下各个模块。
🚀 三、Detect模块
Detect 模块是 YOLO 网络模型的最后一层 (对应 yaml 文件最后一行)，通过 yaml 文件进行声明，格式为：
[*from], 1, Detect, [nc, anchors]其中 nc 为分类数，anchors 为先验框，修改 yaml 文件的前几行即可。
在 parse_model 函数中，会根据 from 参数，找到对应网络层的输出通道数。传参给 Detect 对象后，生成对应的 Conv2d，为后面的计算损失或者NMS后处理作准备。
3.1 获取预测得到的参数
class Detect(nn.Module):
stride = None # 特征图的缩放步长
onnx_dynamic = False # ONNX动态量化
'''===================1.获取预测得到的参数============================'''
def __init__(self, nc=80, anchors=(), ch=(), inplace=True): # detection layer
super().__init__()
# nc: 数据集类别数量
self.nc = nc
# no: 表示每个anchor的输出数，前nc个01字符对应类别，后5个对应：是否有目标，目标框的中心，目标框的宽高
self.no = nc + 5 # nc+5=nc+(x,y,w,h,conf)
# nl: 表示预测层数，yolov5是3层预测
self.nl = len(anchors)
# na: 表示anchors的数量，除以2是因为[10,13, 16,30, 33,23]这个长度是6，对应3个anchor
self.na = len(anchors[0]) // 2
# grid: 表示初始化grid列表大小，下面会计算grid，grid就是每个格子的x，y坐标（整数，比如0-19），左上角为(1,1),右下角为(input.w/stride,input.h/stride)
self.grid = [torch.zeros(1)] * self.nl
# anchor_grid: 表示初始化anchor_grid列表大小，空列表
self.anchor_grid = [torch.zeros(1)] * self.nl # init anchor grid
# 注册常量anchor，并将预选框（尺寸）以数对形式存入，并命名为anchors
self.register_buffer('anchors', torch.tensor(anchors).float().view(self.nl, -1, 2)) # shape(nl,na,2) 注意后面就可以通过self.anchors来访问它了
# 每一张进行三次预测，每一个预测结果包含nc+5个值
# (n, 255, 80, 80),(n, 255, 40, 40),(n, 255, 20, 20) --> ch=(255, 255, 255)
# 255 -> (nc+5)*3 ===> 为了提取出预测框的位置信息以及预测框尺寸信息
self.m = nn.ModuleList(nn.Conv2d(x, self.no * self.na, 1) for x in ch) # output conv 3个输出层最后的1乘1卷积
# inplace: 一般都是True，默认不使用AWS，Inferentia加速
self.inplace = inplace # use in-place ops (e.g. slice assignment)
# 如果模型不训练那么将会对这些预测得到的参数进一步处理,然后输出,可以方便后期的直接调用
# 包含了三个信息pred_box [x,y,w,h] pred_conf[confidence] pre_cls[cls0,cls1,cls2,...clsn]这段代码主要是获取预测得到的各种信息。
detection layer 相当于yolov3中的YOLOLayer层，我们解释一下包含的参数：
- nc: 分类数量
- no: 每个anchor的输出数，为(x,y,w,h,conf) + nc = 5 + nc 的总数
- nl: 预测层数，此次为3
- na: anchors的数量，此次为3
- grid: 格子坐标系，左上角为(1,1),右下角为(input.w/stride,input.h/stride)
3.2 向前传播
'''===================2.向前传播============================'''
def forward(self, x):
z = [] # inference output
for i in range(self.nl):
x[i] = self.m[i](x[i]) # conv
bs, _, ny, nx = x[i].shape # x(bs,255,20,20) to x(bs,3,20,20,85)
# 维度重排列: bs, 先验框组数, 检测框行数, 检测框列数, 属性数 + 分类数
x[i] = x[i].view(bs, self.na, self.no, ny, nx).permute(0, 1, 3, 4, 2).contiguous() # contiguous 将数据保证内存中位置连续
'''
向前传播时需要将相对坐标转换到grid绝对坐标系中
'''
if not self.training: # inference
'''
生成坐标系
grid[i].shape = [1,1,ny,nx,2]
[[[[1,1],[1,2],...[1,nx]],
[[2,1],[2,2],...[2,nx]],
...,
[[ny,1],[ny,2],...[ny,nx]]]]
'''
# 换输入后重新设定锚框
if self.onnx_dynamic or self.grid[i].shape[2:4] != x[i].shape[2:4]:
# 加载网格点坐标 先验框尺寸
self.grid[i], self.anchor_grid[i] = self._make_grid(nx, ny, i)
'''
按损失函数的回归方式来转换坐标
'''
y = x[i].sigmoid()
# 改变原数据 计算定位参数
if self.inplace:
# grid: 位置基准 或者理解为 cell的预测初始位置，而y[..., 0:2]是作为在grid坐标基础上的位置偏移
y[..., 0:2] = (y[..., 0:2] * 2 - 0.5 + self.grid[i]) * self.stride[i] # xy
# anchor_grid: 预测框基准 或者理解为 预测框的初始位置，而 y[..., 2:4]是作为预测框位置的调整
y[..., 2:4] = (y[..., 2:4] * 2) ** 2 * self.anchor_grid[i] # wh
else: # for YOLOv5 on AWS Inferentia https://github.com/ultralytics/yolov5/pull/2953
# stride: 是一个grid cell的实际尺寸
# 经过sigmoid, 值范围变成了(0-1),下一行代码将值变成范围（-0.5，1.5）
xy = (y[..., 0:2] * 2 - 0.5 + self.grid[i]) * self.stride[i] # xy
# 范围变成(0-4)倍，设置为4倍的原因是下层的感受野是上层的2倍
# 因下层注重检测大目标，相对比上层而言，计算量更小，4倍是一个折中的选择
wh = (y[..., 2:4] * 2) ** 2 * self.anchor_grid[i] # wh
y = torch.cat((xy, wh, y[..., 4:]), -1)
# 存储每个特征图检测框的信息
z.append(y.view(bs, -1, self.no))
# 训练阶段直接返回x
# 预测阶段返回3个特征图拼接的结果
return x if self.training else (torch.cat(z, 1), x)这段代码主要是对三个feature map分别进行处理：(n, 255, 80, 80),(n, 255, 40, 40),(n, 255, 20, 20)
首先进行for循环，每次i的循环，产生一个z。维度重排列：(n, 255, _, _) -> (n, 3, nc+5, ny, nx) -> (n, 3, ny, nx, nc+5)，三层分别预测了80*80、40*40、20*20次。
接着 构造网格，因为推理返回的不是归一化后的网格偏移量，需要再加上网格的位置，得到最终的推理坐标，再送入nms。所以这里构建网格就是为了纪律每个grid的网格坐标 方面后面使用
最后按损失函数的回归方式来转换坐标，利用sigmoid激活函数计算定位参数，cat(dim=-1)为直接拼接。注意： 训练阶段直接返回x ，而预测阶段返回3个特征图拼接的结果
3.3 相对坐标转换到grid绝对坐标系
'''===================3.相对坐标转换到grid绝对坐标系============================'''
def _make_grid(self, nx=20, ny=20, i=0):
d = self.anchors[i].device
if check_version(torch.__version__, '1.10.0'): # torch>=1.10.0 meshgrid workaround for torch>=0.7 compatibility
yv, xv = torch.meshgrid([torch.arange(ny).to(d), torch.arange(nx).to(d)], indexing='ij')
else:
yv, xv = torch.meshgrid([torch.arange(ny).to(d), torch.arange(nx).to(d)])
# grid --> (20, 20, 2), 复制成3倍，因为是三个框 -> (3, 20, 20, 2)
grid = torch.stack((xv, yv), 2).expand((1, self.na, ny, nx, 2)).float()
# anchor_grid即每个格子对应的anchor宽高，stride是下采样率，三层分别是8，16，32
anchor_grid = (self.anchors[i].clone() * self.stride[i]) \\
.view((1, self.na, 1, 1, 2)).expand((1, self.na, ny, nx, 2)).float()
return grid, anchor_grid
这段代码主要是将相对坐标转换到grid绝对坐标系。
首先构造网格标尺坐标
- indexing='ij' ： 表示的是i是同一行，j表示同一列
- indexing='xy' ： 表示的是x是同一列，y表示同一行
grid复制成3倍，因为是3个框。anchor_grid是每个anchor宽高。anchor_grid = (self.anchors[i].clone() * self.stride[i])。注意这里为啥要乘呢？因为在外面已经把anchors给除了对应的下采样率，这里再乘回来。
🚀四、Model类
Model类是整个模型的构造模块部分。 通过自定义YOLO模型类 ，继承torch.nn.Module。主要作用是指定模型的yaml文件以及一系列的训练参数。
4.1 __init__函数
（1） 首先加载yaml文件
class Model(nn.Module):
'''===================1.__init__函数==========================='''
def __init__(self, cfg='yolov5s.yaml', ch=3, nc=None, anchors=None): # model, input channels, number of classes
# 父类的构造方法
super().__init__()
# 检查传入的参数格式，如果cfg是加载好的字典结果
if isinstance(cfg, dict):
# 直接保存到模型中
self.yaml = cfg # model dict
# 若不是字典 则为yaml文件路径
else: # is *.yaml 一般执行这里
# 导入yaml文件
import yaml # for torch hub
# 保存文件名：cfg file name = yolov5s.yaml
self.yaml_file = Path(cfg).name
# 如果配置文件中有中文，打开时要加encoding参数
with open(cfg, encoding='ascii', errors='ignore') as f:
# 将yaml文件加载为字典
self.yaml = yaml.safe_load(f) # model dict 取到配置文件中每条的信息（没有注释内容）__init__函数主要功能为从yaml中初始化model中各种变量包括网络模型model、通道ch，分类数nc，锚框anchor和三层输出缩放倍数stride等。
- cfg: YOLO v5模型配置文件 这里使用yolov5s模型
- ch: 输入图片的通道数 默认为3
- nc: 数据集的类别个数
- anchors: 表示anchor框, 一般是None
然后判断输入的cfg是否为字典。一般都不是字典，直接进入else，打开yaml文件，转换成字典格式。
（2）接着开始搭建模型
# Define model
# 搭建模型
# yaml.get('ch', ch)表示若不存在键'ch',则返回值ch
ch = self.yaml['ch'] = self.yaml.get('ch', ch) # input channels
# 判断类的通道数和yaml中的通道数是否相等，一般不执行，因为nc=self.yaml['nc']恒成立
if nc and nc != self.yaml['nc']:
# 在终端给出提示
LOGGER.info(f"Overriding model.yaml nc=self.yaml['nc'] with nc=nc")
# 将yaml中的值修改为构造方法中的值
self.yaml['nc'] = nc # override yaml value
# 重写anchor，一般不执行, 因为传进来的anchors一般都是None
if anchors:
# 在终端给出提示
LOGGER.info(f'Overriding model.yaml anchors with anchors=anchors')
# 将yaml中的值改为构造方法中的值
self.yaml['anchors'] = round(anchors) # override yaml value转换为字典以后，就可以进行模型搭建了。首先要判断：
- 判断yaml中是否有设置输入图像的通道ch，如果没有就默认为3。
- 判断分类总数nc和anchor与yaml中是否一致，如果不一致，则使用init函数参数中指定的nc和anchor。
（3） 读取yaml中的网络结构并实例化
# 解析模型，self.model是解析后的模型 self.save是每一层与之相连的层
self.model, self.save = parse_model(deepcopy(self.yaml), ch=[ch]) # deepcopy()复杂产生一个新的对象
# 加载每一类的类别名
self.names = [str(i) for i in range(self.yaml['nc'])] # default names
# inplace指的是原地操作 如x+=1 有利于节约内存
# self.inplace=True 默认True 不使用加速推理
self.inplace = self.yaml.get('inplace', True)这里是通过parse_model来进行解析和建立模型的。
到这一步为止，我们的yolo模型的网络架构就已经全部搭建完成了。
（4）最后来计算图像从输入到输出的缩放倍数和anchor在head上的大小
# Build strides, anchors
# 构造步长、先验框
m = self.model[-1] # Detect()
# 判断最后一层是否为Detect层
if isinstance(m, Detect):
# 定义一个256 * 256大小的输入
s = 256 # 2x min stride
m.inplace = self.inplace
# 保存特征层的stride,并且将anchor处理成相对于特征层的格式
m.stride = torch.tensor([s / x.shape[-2] for x in self.forward(torch.zeros(1, ch, s, s))]) # forward
# 原始定义的anchor是原始图片上的像素值，要将其缩放至特征图的大小
m.anchors /= m.stride.view(-1, 1, 1)
# 检查anchor顺序与stride顺序是否一致
check_anchor_order(m)
# 将步长保存至模型
self.stride = m.stride
# 初始化bias
self._initialize_biases() # only run once
# Init weights, biases
# 初始化权重
initialize_weights(self)
# 打印模型信息
self.info()
LOGGER.info('')主要步骤：
1.获取结构最后一层Detect层
2.定义一个256*256大小的输入
3.将[1, ch, 256, 256]大小的tensor进行一次向前传播，得到3层的输出，用输入大小256分别除以输出大小得到每一层的下采样倍数stride
4.分别用最初的anchor大小除以stride将anchor线性缩放到对应层上
4.2 数据增强相关函数
4.2.1 forward():管理前向传播函数
# ===1.forward():管理前向传播函数=== #
def forward(self, x, augment=False, profile=False, visualize=False):
# 是否在测试时也使用数据增强
if augment:
# 增强训练，对数据采取了一些了操作
return self._forward_augment(x) # augmented inference, None
# 默认执行，正常前向推理
return self._forward_once(x, profile, visualize) # single-scale inference, train
这里做了一个分支，是否在测试时使用数据增强：
- 如果使用增强训练，则返回推理的forward（_forward_augment）
- 如果不使用增强训练，则返回训练的forward（_forward_once）
包含参数：
- x： 原图
- augment ： 是否使用增强式推导
- profile： 是否测试每个网络层的性能
- visualize： 是否输出每个网络层的特征图
4.2.2 _forward_augment():推理的forward
# ===2._forward_augment():推理的forward=== #
# 将图片进行裁剪,并分别送入模型进行检测
def _forward_augment(self, x):
# 获得图像的高和宽
img_size = x.shape[-2:] # height, width
# s是规模
s = [1, 0.83, 0.67] # scales
# flip是翻转，这里的参数表示沿着哪个轴翻转
f = [None, 3, None] # flips (2-ud, 3-lr)
y = [] # outputs
for si, fi in zip(s, f):
# scale_img函数的作用就是根据传入的参数缩放和翻转图像
xi = scale_img(x.flip(fi) if fi else x, si, gs=int(self.stride.max()))
# 模型前向传播
yi = self._forward_once(xi)[0] # forward
# cv2.imwrite(f'img_si.jpg', 255 * xi[0].cpu().numpy().transpose((1, 2, 0))[:, :, ::-1]) # save
# 恢复数据增强前的模样
yi = self._descale_pred(yi, fi, si, img_size)
y.append(yi)
# 对不同尺寸进行不同程度的筛选
y = self._clip_augmented(y) # clip augmented tails
return torch.cat(y, 1), None # augmented inference, train
这里的代码是在推理的时候做数据增强TTA（Test Time Augmentation），其 x 参数是图像所对应的 tensor。
这个函数只在 val、detect 主函数中使用，用于提高推导的精度。
设分类数为 80 、检测框属性数为 5，则基本步骤是：
- 对图像进行变换：总共 3 次，分别是 [ 原图 ]，[ 尺寸缩小到原来的 0.83，同时水平翻转 ]，[ 尺寸缩小到原来的 0.67 ]
- 对图像使用 _forward_once 函数，得到在 eval 模式下网络模型的推导结果。对原图是 shape 为 [1, 22743, 85] 的图像检测框信息 (见 Detect 对象的 forward 函数)
- 根据 尺寸缩小倍数、翻转维度 对检测框信息进行逆变换，添加进列表 y
- 截取 y[0] 对大物体的检测结果，保留 y[1] 所有的检测结果，截取 y[2] 对小物体的检测结果，拼接得到新的检测框信息
4.2.3 _forward_once():训练的forward
# ===3._forward_once():训练的forward=== #
def _forward_once(self, x, profile=False, visualize=False):
# 各网络层输出, 各网络层推导耗时
# y: 存放着self.save=True的每一层的输出，因为后面的层结构concat等操作要用到
# dt: 在profile中做性能评估时使用
y, dt = [], [] # outputs
# 遍历model的各个模块
for m in self.model:
# m.f 就是该层的输入来源，如果不为-1那就不是从上一层而来
if m.f != -1: # if not from previous layer
# from 参数指向的网络层输出的列表
x = y[m.f] if isinstance(m.f, int) else [x if j == -1 else y[j] for j in m.f] # from earlier layers
# 测试该网络层的性能
if profile:
self._profile_one_layer(m, x, dt)
# 使用该网络层进行推导, 得到该网络层的输出
x = m(x) # run
# 存放着self.save的每一层的输出，因为后面需要用来作concat等操作要用到 不在self.save层的输出就为None
y.append(x if m.i in self.save else None) # save output
# 将每一层的输出结果保存到y
if visualize:
# 绘制该 batch 中第一张图像的特征图
feature_visualization(x, m.type, m.i, save_dir=visualize)
return x这个函数是训练的forward，对模型每一层进行迭代。参数为：
- x： 输入图像
- profile： 是否测试每个网络层的性能，是则调用 self._profile_one_layer 函数
- visualize： 是否输出每个网络层的特征图，是则调用 utils.plots.feature_visualization。这个函数是取 batch 中的第一张图像，然后把每个通道上的二维矩阵看成一张灰度图，分别绘制
4.2.4 _descale_pred():将推理结果恢复到原图尺寸
# ===4._descale_pred():将推理结果恢复到原图尺寸(逆操作)=== #
def _descale_pred(self, p, flips, scale, img_size):
# de-scale predictions following augmented inference (inverse operation)
if self.inplace:
# 把x,y,w,h恢复成原来的大小
p[..., :4] /= scale # de-scale
# bs c h w 当flips=2是对h进行变换，那就是上下进行翻转
if flips == 2:
p[..., 1] = img_size[0] - p[..., 1] # de-flip ud
# 同理flips=3是对水平进行翻转
elif flips == 3:
p[..., 0] = img_size[1] - p[..., 0] # de-flip lr
else:
x, y, wh = p[..., 0:1] / scale, p[..., 1:2] / scale, p[..., 2:4] / scale # de-scale
if flips == 2:
y = img_size[0] - y # de-flip ud
elif flips == 3:
x = img_size[1] - x # de-flip lr
p = torch.cat((x, y, wh, p[..., 4:]), -1)
return p这段代码主要是用在上面的__init__函数上，将推理结果恢复到原图图片尺寸TTA中用到
参数为：
- p: 推理结果
- flips: 翻转标记(2-ud上下, 3-lr左右)
- scale: 图片缩放比例
- img_size: 原图图片尺寸
4.2.5 _clip_augmented（）:TTA的时候对原图片进行裁剪
# ===5._clip_augmented（）:TTA的时候对原图片进行裁剪=== #
# 也是一种数据增强方式，用在TTA测试的时候
def _clip_augmented(self, y):
# Clip YOLOv5 augmented inference tails
nl = self.model[-1].nl # number of detection layers (P3-P5)
g = sum(4 ** x for x以上是关于YOLOv5源码逐行超详细注释与解读——网络结构yolo.py的主要内容，如果未能解决你的问题，请参考以下文章
YOLOv5源码逐行超详细注释与解读——训练部分train.py