前言

在上一篇中，我们简单介绍了YOLOv5的配置文件之一 yolov5s.yaml，这个文件中涉及很多参数，它们的调用会在这篇 yolo.py 和下一篇 common.py 中具体实现。

本篇我们会介绍 yolo.py，这是YOLO的特定模块，和网络构建有关。在YOLOv5源码中，模型的建立是依靠 yolo.py 中的函数和对象完成的，这个文件主要由三个部分：parse_model函数、Detect类和Model类组成。

yolo.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

YOLOv5源码逐行超详细注释与解读（7）——网络结构（2）common.py

目录

前言

一、 导包和基本配置

1.1 导入安装好的python库

1.2 获取当前文件的绝对路径

1.3 加载自定义模块

二、parse_model函数

2.1 获取对应参数

2.2 搭建网络前准备

2.3 更新当前层的参数，计算c2

2.4 使用当前层的参数搭建当前层

2.5 打印和保存layers

三、Detect模块

3.1 获取预测得到的参数

3.2 向前传播

3.3 相对坐标转换到grid绝对坐标系

四、Model类

4.1__init__函数

4.2 数据增强相关函数

4.2.1forward():管理前向传播函数

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.9fuse（）:将Conv2d+BN进行融合

4.2.10 autoshape（）:扩展模型功能

4.2.11 info():打印模型结构信息

4.2.12 _apply():将模块转移到 CPU/ GPU上

五、yolo.py全部注释

一、 导包和基本配置

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.pyROOT = FILE.parents[1]# YOLOv5 root directory 保存着当前项目的父目录,比如 D://yolov5if 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())# relativeROOT设置为相对路径

这段代码会获取当前文件的绝对路径，并使用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包 用于计算FLOPstry:import thop# for FLOPs computationexcept 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_multipleanchors, 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 stringsexcept 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必须是noif 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) * divisor

2.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个数nargs.insert(2, n)# number of repeats# 恢复默认值1n = 1# 判断是否是归一化模块elif m is nn.BatchNorm2d:# BN层只需要返回上一层的输出channelargs = [ch[f]]# 判断是否是tensor连接模块elif m is Concat:# Concat层则将f中所有的输出累加得到这层的输出channelc2 = sum(ch[x] for x in f)# 判断是否是detect模块elif m is Detect:# 在args中加入三个Detect层的输出channelargs.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] ** 2elif m is Expand:# 不怎么用c2 = ch[f] // args[0] ** 2else: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 paramsm_.i, m_.f, m_.type, m_.np = i, f, t, np# attach index, 'from' index, type, number paramsLOGGER.info(f'{i:>3}{str(f):>18}{n_:>3}{np:10.0f}{t:<40}{str(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数加入chch.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个anchorself.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，并将预选框（尺寸）以数对形式存入，并命名为anchorsself.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 outputfor i in range(self.nl):x[i] = self.m[i](x[i])# convbs, _, 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]# whelse:# 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]# why = 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].deviceif check_version(torch.__version__, '1.10.0'):# torch>=1.10.0 meshgrid workaround for torch>=0.7 compatibilityyv, 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，32anchor_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.yamlself.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',则返回值chch = 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一般都是Noneif 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 stridem.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# 初始化biasself._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.1forward():管理前向传播函数

# ===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 = []# outputsfor 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 tailsreturn 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层的输出就为Noney.append(x if m.i in self.save else None)# save output# 将每一层的输出结果保存到yif 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 lrelse:x, y, wh = p[..., 0:1] / scale, p[..., 1:2] / scale, p[..., 2:4] / scale# de-scaleif flips == 2:y = img_size[0] - y# de-flip udelif flips == 3:x = img_size[1] - x# de-flip lrp = 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 tailsnl = self.model[-1].nl# number of detection layers (P3-P5)g = sum(4 ** x for x in range(nl))# grid pointse = 1# exclude layer counti = (y[0].shape[1] // g) * sum(4 ** x for x in range(e))# indicesy[0] = y[0][:, :-i]# largei = (y[-1].shape[1] // g) * sum(4 ** (nl - 1 - x) for x in range(e))# indicesy[-1] = y[-1][:, i:]# smallreturn y

这个没啥要讲的，其实也是一种数据增强方式，用在TTA测试的时候

4.2.6_profile_one_layer（）:打印日志信息

# ===6._profile_one_layer（）:打印日志信息=== #def _profile_one_layer(self, m, x, dt):c = isinstance(m, Detect)# is final layer, copy input as inplace fixo = thop.profile(m, inputs=(x.copy() if c else x,), verbose=False)[0] / 1E9 * 2 if thop else 0# FLOPst = time_sync()for _ in range(10):m(x.copy() if c else x)dt.append((time_sync() - t) * 100)if m == self.model[0]:LOGGER.info(f"{'time (ms)':>10s} {'GFLOPs':>10s} {'params':>10s}{'module'}")LOGGER.info(f'{dt[-1]:10.2f} {o:10.2f} {m.np:10.0f}{m.type}')if c:LOGGER.info(f"{sum(dt):10.2f} {'-':>10s} {'-':>10s}Total")

这个函数用于测试每个网络层的性能

参数为：

• m： 网络层
• x： 该网络层的 from 列表中的网络层输出
• dt： 各网络层推导耗时 (列表)

使用 logging 模块输出有：

• time (ms)： 前向推导时间
• GFLOPs： 浮点运算量，需要安装 thop 模块
• params： 网络层参数量
• module： 网络层名称

4.2.7_initialize_biases（）:初始化偏置biases信息

# ===7._initialize_biases（）:初始化偏置biases信息=== #def _initialize_biases(self, cf=None):# initialize biases into Detect(), cf is class frequency# https://arxiv.org/abs/1708.02002 section 3.3# cf = torch.bincount(torch.tensor(np.concatenate(dataset.labels, 0)[:, 0]).long(), minlength=nc) + 1.m = self.model[-1]# Detect() modulefor mi, s in zip(m.m, m.stride):# fromb = mi.bias.view(m.na, -1)# conv.bias(255) to (3,85)b.data[:, 4] += math.log(8 / (640 / s) ** 2)# obj (8 objects per 640 image)b.data[:, 5:] += math.log(0.6 / (m.nc - 0.999999)) if cf is None else torch.log(cf / cf.sum())# clsmi.bias = torch.nn.Parameter(b.view(-1), requires_grad=True)

这段代码是用来初始化detect的偏置，用在上面的__init__函数上

4.2.8_print_biases（）:打印偏置biases信息

# ===8._print_biases（）:打印偏置biases信息=== #def _print_biases(self):"""打印模型中最后Detect层的偏置bias信息(也可以任选哪些层bias信息)"""m = self.model[-1]# Detect() modulefor mi in m.m:# fromb = mi.bias.detach().view(m.na, -1).T# conv.bias(255) to (3,85)LOGGER.info(('%6g Conv2d.bias:' + '%10.3g' * 6) % (mi.weight.shape[1], *b[:5].mean(1).tolist(), b[5:].mean()))

这段代码主要是打印模型中最后Detect层的偏置bias信息，也可以任选哪些层bias信息

4.2.9fuse（）:将Conv2d+BN进行融合

# ===9.fuse（）:将Conv2d+BN进行融合=== #def fuse(self):# fuse model Conv2d() + BatchNorm2d() layersLOGGER.info('Fusing layers... ')for m in self.model.modules():# 如果当前层是卷积层Conv且有bn结构, 那么就调用fuse_conv_and_bn函数讲conv和bn进行融合, 加速推理if isinstance(m, (Conv, DWConv)) and hasattr(m, 'bn'):# 更新卷积层m.conv = fuse_conv_and_bn(m.conv, m.bn)# update conv# 移除bndelattr(m, 'bn')# remove batchnorm# 更新前向传播m.forward = m.forward_fuse# update forward# 打印conv+bn融合后的模型信息self.info()return self

这段代码主要是调用了fuse_conv_and_bn 这个函数将Conv2d+BN进行融合

用在detect.py、val.py，调用torch_utils.py中的fuse_conv_and_bn函数和common.py中Conv模块的fuseforward函数。最后打印出融合后的模型信息。

4.2.10 autoshape（）:扩展模型功能

# ===10.autoshape（）:扩展模型功能=== #def autoshape(self):# add AutoShape moduleLOGGER.info('Adding AutoShape... ')#此时模型包含前处理、推理、后处理的模块(预处理 + 推理 + nms)m = AutoShape(self)# wrap modelcopy_attr(m, self, include=('yaml', 'nc', 'hyp', 'names', 'stride'), exclude=())# copy attributesreturn m

这段代码直接调用common.py中的AutoShape模块，也是一个扩展模型功能的模块，来实现扩展模型功能

4.2.11 info():打印模型结构信息

# ===11.info():打印模型结构信息=== #def info(self, verbose=False, img_size=640):# print model information model_info(self, verbose, img_size)

这段代码是用在上面的__init__函数上调用torch_utils.py下model_info函数打印模型信息

4.2.12 _apply():将模块转移到 CPU/ GPU上

 # ===12._apply():将模块转移到 CPU/ GPU上=== #def _apply(self, fn):# Apply to(), cpu(), cuda(), half() to model tensors that are not parameters or registered buffersself = super()._apply(fn)m = self.model[-1]# Detect()if isinstance(m, Detect):m.stride = fn(m.stride)m.grid = list(map(fn, m.grid))if isinstance(m.anchor_grid, list):m.anchor_grid = list(map(fn, m.anchor_grid))return self

这段代码主要是将模块转移到 CPU/ GPU上

pytorch中的model.apply(fn)会递归地将函数fn应用到父模块的每个子模块submodule，也包括model这个父模块自身。经常用于初始化init_weights的操作。

（终于写完这一堆函数了，寝室熄灯太难了555）

这里面除了模型搭建还包含很多拓展功能，我们主要看的是__init__和__forward__两个函数。

五、yolo.py全部注释

# YOLOv5by Ultralytics, GPL-3.0 license"""YOLO-specific modulesUsage:$ python path/to/models/yolo.py --cfg yolov5s.yaml"""'''===============================================一、导入包===================================================''''''======================1.导入安装好的python库====================='''import argparse# 解析命令行参数模块import sys# sys系统模块 包含了与Python解释器和它的环境有关的函数from copy import deepcopy# 数据拷贝模块 深拷贝from pathlib import Path# Path将str转换为Path对象 使字符串路径易于操作的模块'''===================2.获取当前文件的绝对路径========================'''FILE = Path(__file__).resolve() # __file__指的是当前文件(即val.py),FILE最终保存着当前文件的绝对路径,比如D://yolov5/modles/yolo.pyROOT = FILE.parents[1]# YOLOv5 root directory 保存着当前项目的父目录,比如 D://yolov5if 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())# relativeROOT设置为相对路径'''===================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包 用于计算FLOPstry:import thop# for FLOPs computationexcept ImportError:thop = None'''===============================================二、Detect模块==================================================='''''' Detect模块是用来构建Detect层的，将输入feature map 通过一个卷积操作和公式计算到我们想要的shape, 为后面的计算损失或者NMS后处理作准备'''class Detect(nn.Module):stride = None# 特征图的缩放步长onnx_dynamic = False# ONNX动态量化'''===================1.获取预测得到的参数============================'''def __init__(self, nc=80, anchors=(), ch=(), inplace=True):# detection layer"""detection layer 相当于yolov3中的YOLOLayer层:params nc: 数据集类别数量:params anchors: 传入3个feature map上的所有anchor的大小（P3、P4、P5）:params ch: [128, 256, 512] 3个输出feature map的channel"""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个anchorself.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，并将预选框（尺寸）以数对形式存入，并命名为anchorsself.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]'''===================2.向前传播============================'''def forward(self, x):z = []# inference output# 对三个feature map分别进行处理# (n, 255, 80, 80),(n, 255, 40, 40),(n, 255, 20, 20)for i in range(self.nl):# 下面3行代码的工作：# (n, 255, _, _) -> (n, 3, nc+5, ny, nx) -> (n, 3, ny, nx, nc+5)# 相当于三层分别预测了80*80、40*40、20*20次，每一次预测都包含3个框# 进行1*1卷积，经过这个卷积就变成（5+分类数）个通道了x[i] = self.m[i](x[i])# convbs, _, 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]# whelse:# 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]# why = 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)'''===================3.相对坐标转换到grid绝对坐标系============================'''def _make_grid(self, nx=20, ny=20, i=0):d = self.anchors[i].deviceif check_version(torch.__version__, '1.10.0'):# torch>=1.10.0 meshgrid workaround for torch>=0.7 compatibility# 网格标尺坐标# indexing='ij' 表示的是i是同一行，j表示同一列# indexing='xy' 表示的是x是同一列，y表示同一行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，这里为啥要乘呢，因为在外面已经把anchors给除了对应的下采样率，这里再乘回来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'''===============================================三、Model模块==================================================='''class Model(nn.Module):'''===================1.__init__函数==========================='''def __init__(self, cfg='yolov5s.yaml', ch=3, nc=None, anchors=None):# model, input channels, number of classes""" :params cfg:YOLO v5模型配置文件 这里使用yolov5s模型 :params ch: 输入图片的通道数 默认为3 :params nc: 数据集的类别个数 :anchors: 表示anchor框, 一般是None"""# 父类的构造方法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.yamlself.yaml_file = Path(cfg).name# 如果配置文件中有中文，打开时要加encoding参数with open(cfg, encoding='ascii', errors='ignore') as f:# 将yaml文件加载为字典self.yaml = yaml.safe_load(f)# model dict 取到配置文件中每条的信息（没有注释内容）'''===================2.获取输入通道============================'''# Define model# 搭建模型# yaml.get('ch', ch)表示若不存在键'ch',则返回值chch = 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一般都是Noneif anchors:# 在终端给出提示LOGGER.info(f'Overriding model.yaml anchors with anchors={anchors}')# 将yaml中的值改为构造方法中的值self.yaml['anchors'] = round(anchors)# override yaml value# 解析模型，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)'''===================3.获取Detect输出模块============================'''# Build strides, anchors# 构造步长、先验框m = self.model[-1]# Detect()# 判断最后一层是否为Detect层if isinstance(m, Detect):# 定义一个256 * 256大小的输入s = 256# 2x min stridem.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# 初始化biasself._initialize_biases()# only run once# Init weights, biases# 初始化权重initialize_weights(self)# 打印模型信息self.info()LOGGER.info('')'''===================4.数据增强============================'''# ===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# ===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 = []# outputsfor 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 tailsreturn torch.cat(y, 1), None# augmented inference, train# ===3._forward_once():训练的forward=== #def _forward_once(self, x, profile=False, visualize=False):""":params x: 输入图像:params profile: True 可以做一些性能评估:params feature_vis: True 可以做一些特征可视化:return train: 一个tensor list 存放三个元素 [bs, anchor_num, grid_w, grid_h, xywh+c+20classes]分别是 [1, 3, 80, 80, 25] [1, 3, 40, 40, 25] [1, 3, 20, 20, 25] inference: 0 [1, 19200+4800+1200, 25] = [bs, anchor_num*grid_w*grid_h, xywh+c+20classes] 1 一个tensor list 存放三个元素 [bs, anchor_num, grid_w, grid_h, xywh+c+20classes] [1, 3, 80, 80, 25] [1, 3, 40, 40, 25] [1, 3, 20, 20, 25]"""# 各网络层输出, 各网络层推导耗时# 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层的输出就为Noney.append(x if m.i in self.save else None)# save output# 将每一层的输出结果保存到yif visualize:# 绘制该 batch 中第一张图像的特征图feature_visualization(x, m.type, m.i, save_dir=visualize)return x# ===4._descale_pred():将推理结果恢复到原图尺寸(逆操作)=== #def _descale_pred(self, p, flips, scale, img_size):# de-scale predictions following augmented inference (inverse operation)''' 用在上面的__init__函数上 将推理结果恢复到原图图片尺寸Test Time Augmentation(TTA)中用到 :params p: 推理结果 :params flips: 翻转标记(2-ud上下, 3-lr左右) :params scale: 图片缩放比例 :params img_size: 原图图片尺寸'''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 lrelse:x, y, wh = p[..., 0:1] / scale, p[..., 1:2] / scale, p[..., 2:4] / scale# de-scaleif flips == 2:y = img_size[0] - y# de-flip udelif flips == 3:x = img_size[1] - x# de-flip lrp = torch.cat((x, y, wh, p[..., 4:]), -1)return p# ===5._clip_augmented（）:TTA的时候对原图片进行裁剪=== ## 也是一种数据增强方式，用在TTA测试的时候def _clip_augmented(self, y):# Clip YOLOv5 augmented inference tailsnl = self.model[-1].nl# number of detection layers (P3-P5)g = sum(4 ** x for x in range(nl))# grid pointse = 1# exclude layer counti = (y[0].shape[1] // g) * sum(4 ** x for x in range(e))# indicesy[0] = y[0][:, :-i]# largei = (y[-1].shape[1] // g) * sum(4 ** (nl - 1 - x) for x in range(e))# indicesy[-1] = y[-1][:, i:]# smallreturn y# ===6._profile_one_layer（）:打印日志信息=== #def _profile_one_layer(self, m, x, dt):c = isinstance(m, Detect)# is final layer, copy input as inplace fixo = thop.profile(m, inputs=(x.copy() if c else x,), verbose=False)[0] / 1E9 * 2 if thop else 0# FLOPst = time_sync()for _ in range(10):m(x.copy() if c else x)dt.append((time_sync() - t) * 100)if m == self.model[0]:LOGGER.info(f"{'time (ms)':>10s} {'GFLOPs':>10s} {'params':>10s}{'module'}")LOGGER.info(f'{dt[-1]:10.2f} {o:10.2f} {m.np:10.0f}{m.type}')if c:LOGGER.info(f"{sum(dt):10.2f} {'-':>10s} {'-':>10s}Total")# ===7._initialize_biases（）:初始化偏置biases信息=== #def _initialize_biases(self, cf=None):# initialize biases into Detect(), cf is class frequency# https://arxiv.org/abs/1708.02002 section 3.3# cf = torch.bincount(torch.tensor(np.concatenate(dataset.labels, 0)[:, 0]).long(), minlength=nc) + 1.m = self.model[-1]# Detect() modulefor mi, s in zip(m.m, m.stride):# fromb = mi.bias.view(m.na, -1)# conv.bias(255) to (3,85)b.data[:, 4] += math.log(8 / (640 / s) ** 2)# obj (8 objects per 640 image)b.data[:, 5:] += math.log(0.6 / (m.nc - 0.999999)) if cf is None else torch.log(cf / cf.sum())# clsmi.bias = torch.nn.Parameter(b.view(-1), requires_grad=True)# ===8._print_biases（）:打印偏置biases信息=== #def _print_biases(self):"""打印模型中最后Detect层的偏置bias信息(也可以任选哪些层bias信息)"""m = self.model[-1]# Detect() modulefor mi in m.m:# fromb = mi.bias.detach().view(m.na, -1).T# conv.bias(255) to (3,85)LOGGER.info(('%6g Conv2d.bias:' + '%10.3g' * 6) % (mi.weight.shape[1], *b[:5].mean(1).tolist(), b[5:].mean()))# def _print_weights(self):# for m in self.model.modules():# if type(m) is Bottleneck:# LOGGER.info('%10.3g' % (m.w.detach().sigmoid() * 2))# shortcut weights# ===9.fuse（）:将Conv2d+BN进行融合=== #def fuse(self):# fuse model Conv2d() + BatchNorm2d() layers"""用在detect.py、val.pyfuse model Conv2d() + BatchNorm2d() layers调用oneflow_utils.py中的fuse_conv_and_bn函数和common.py中Conv模块的fuseforward函数"""LOGGER.info('Fusing layers... ')for m in self.model.modules():# 如果当前层是卷积层Conv且有bn结构, 那么就调用fuse_conv_and_bn函数讲conv和bn进行融合, 加速推理if isinstance(m, (Conv, DWConv)) and hasattr(m, 'bn'):# 更新卷积层m.conv = fuse_conv_and_bn(m.conv, m.bn)# update conv# 移除bndelattr(m, 'bn')# remove batchnorm# 更新前向传播m.forward = m.forward_fuse# update forward# 打印conv+bn融合后的模型信息self.info()return self# ===10.autoshape（）:扩展模型功能=== #def autoshape(self):# add AutoShape module"""add AutoShape module直接调用common.py中的AutoShape模块也是一个扩展模型功能的模块"""LOGGER.info('Adding AutoShape... ')#此时模型包含前处理、推理、后处理的模块(预处理 + 推理 + nms)m = AutoShape(self)# wrap modelcopy_attr(m, self, include=('yaml', 'nc', 'hyp', 'names', 'stride'), exclude=())# copy attributesreturn m# ===11.info():打印模型结构信息=== #def info(self, verbose=False, img_size=640):# print model information"""用在上面的__init__函数上调用torch_utils.py下model_info函数打印模型信息"""model_info(self, verbose, img_size)# ===12._apply():将模块转移到 CPU/ GPU上=== #def _apply(self, fn):# Apply to(), cpu(), cuda(), half() to model tensors that are not parameters or registered buffersself = super()._apply(fn)m = self.model[-1]# Detect()if isinstance(m, Detect):m.stride = fn(m.stride)m.grid = list(map(fn, m.grid))if isinstance(m.anchor_grid, list):m.anchor_grid = list(map(fn, m.anchor_grid))return self'''===============================================四、parse_model模块==================================================='''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': 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必须是noif c2 != no:# if not output# width gain: 控制宽度，如yolov5s: c2*0.5; c2: 当前层的最终输出channel数(间接控制宽度)c2 = make_divisible(c2 * gw, 8)'''===================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个数nargs.insert(2, n)# number of repeats# 恢复默认值1n = 1# 判断是否是归一化模块elif m is nn.BatchNorm2d:# BN层只需要返回上一层的输出channelargs = [ch[f]]# 判断是否是tensor连接模块elif m is Concat:# Concat层则将f中所有的输出累加得到这层的输出channelc2 = sum(ch[x] for x in f)# 判断是否是detect模块elif m is Detect:# 在args中加入三个Detect层的输出channelargs.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] ** 2elif m is Expand:# 不怎么用c2 = ch[f] // args[0] ** 2else:c2 = ch[f]# args不变'''===================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 paramsm_.i, m_.f, m_.type, m_.np = i, f, t, np# attach index, 'from' index, type, number paramsLOGGER.info(f'{i:>3}{str(f):>18}{n_:>3}{np:10.0f}{t:<40}{str(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数加入chch.append(c2)return nn.Sequential(*layers), sorted(save)if __name__ == '__main__':parser = argparse.ArgumentParser() # 创建解析器# --cfg: 模型配置文件parser.add_argument('--cfg', type=str, default='yolov5s.yaml', help='model.yaml')# --device: 选用设备parser.add_argument('--device', default='', help='cuda device, i.e. 0 or 0,1,2,3 or cpu')# --profile: 用户配置文件parser.add_argument('--profile', action='store_true', help='profile model speed')# --test: 测试parser.add_argument('--test', action='store_true', help='test all yolo*.yaml')opt = parser.parse_args()# 增加后的属性赋值给argsopt.cfg = check_yaml(opt.cfg)# 检查YAML文件print_args(FILE.stem, opt) # 检测YOLO v5的github仓库是否更新,若已更新,给出提示device = select_device(opt.device) # 选择设备# Create model# 构造模型model = Model(opt.cfg).to(device)model.train()# Profile#用户自定义配置if opt.profile:img = torch.rand(8 if torch.cuda.is_available() else 1, 3, 640, 640).to(device)y = model(img, profile=True)# Test all models# 测试所有的模型if opt.test:for cfg in Path(ROOT / 'models').rglob('yolo*.yaml'):try:_ = Model(cfg)except Exception as e:print(f'Error in {cfg}: {e}')# Tensorboard (not working https://github.com/ultralytics/yolov5/issues/2898)# from torch.utils.tensorboard import SummaryWriter# tb_writer = SummaryWriter('.')# LOGGER.info("Run 'tensorboard --logdir=models' to view tensorboard at http://localhost:6006/")# tb_writer.add_graph(torch.jit.trace(model, img, strict=False), [])# add model graph

本文参考：

【YOLOV5-5.x 源码解读】yolo.py_yolov5 yolo.py_满船清梦压星河HK的博客-CSDN博客
YOLOv5 源码解析 —— 网络模型建立_yolov5网络模型_荷碧TongZJ的博客