Yolov5（1）：Detect源码逐行解析
开学时，给自己定的学习任务，直到今天才有闲空来完成。一方面是yolo代码初看觉得乱糟糟的，不想读；其次，yolo算法对于初触深度学习的我而言，还是有较大的难度。
今天学习成果就是弄懂了，yolov5的Idea+模型的构建+实现源码
类似ViT的阅读，阅读完后觉得，还是自顶向下解析比较清晰。
YOLOv5系列：解析索引
一、Yolo v5 模型结构
模型整体分为：
1.BackBone
2.Neck
3.Head（在代码中，直观上看似乎作者将Neck和Head放在一起实现了）
下方的图中，用四个黄颜色圈出来的部分，分别表示为4个Head部分。
二、Yolo v5 的模块
作者实现为了保证模型的灵活可调，将几乎所有的参数都预设到yaml文件中了，因此在构建模型的时候，只要清楚模块的实现即可，对应参数在yaml文件中已经给出。
核心子模块：
1.Focus: Slice=interlace-stride2-DownSample 步长为2的横纵向交错采样
2.Conv: conv+BN+HardSwish
3.Bottleneck-True:
+ Conv*2 4.Bottleneck-False: Conv*2
5.C3-True: BCSP3-True
6.C3-False: BCSP3-False
7.BCSPn-True:
Concate
Conv+Bottleneck-True*n+conv Concate
conv 8.BCSPn-False:
Bottleneck-False*n
9.SPP：金字塔池化--通过不同kernal_size的池化结果的拼接
三、Yolo v5 Detect部分源码详解
class Detect(nn.Module):
stride = None # strides computed during build
onnx_dynamic = False # ONNX export parameter
def __init__(self, nc=80, anchors=(), ch=(), inplace=True): # detection layer
super().__init__()
self.nc = nc # number of classes
# 每一个 预选框预测输出，前nc个01字符对应类别，后5个对应：是否有目标，目标框的中心，目标框的宽高
self.no = nc + 5 # number of outputs per anchor
# 表示预选层数，yolov5是3层预选
self.nl = len(anchors)
# 预选框数量，anchors数据中每一对数据表示一个预选框的宽高
self.na = len(anchors[0]) // 2
# 初始化grid列表大小，空列表
self.grid = [torch.zeros(1)] * self.nl
# 初始化anchor_grid列表大小，空列表
self.anchor_grid = [torch.zeros(1)] * self.nl
# 注册常量anchor，并将预选框（尺寸）以数对形式存入 ---- 实际存的是框的宽高
self.register_buffer('anchors', torch.tensor(anchors).float().view(self.nl, -1, 2))
# 每一张进行三次预测，每一个预测结果包含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
self.inplace = inplace # use in-place ops (e.g. slice assignment)
def forward(self, x):
z = [] # inference output
# 输入的x是来自三层金字塔的预测结果(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个框
x[i] = self.m[i](x[i])
bs, _, ny, nx = x[i].shape
# contiguous 将数据保证内存中位置连续
x[i] = x[i].view(bs, self.na, self.no, ny, nx).permute(0, 1, 3, 4, 2).contiguous()
# self.training 作为nn.Module的参数，默认是True，因此下方代码先不考虑
if not self.training: # inference
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[i] = (3, 20, 20, 2), y = [n, 3, 20, 20, nc+5]
# grid实际是 位置基准 或者理解为 cell的预测初始位置，而y[..., 0:2]是作为在grid坐标基础上的位置偏移
# anchor_grid实际是 预测框基准 或者理解为 预测框的初始位置，而 y[..., 2:4]是作为预测框位置的调整
y[..., 0:2] = (y[..., 0:2] * 2 - 0.5 + self.grid[i]) * self.stride[i] # xy
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），
# 相当于预选框上下左右都扩大了0.5倍的移动区域，不易大于0.5倍，否则就重复检验了其他网格的内容了
# 此处的1表示一个grid cell的尺寸，尽量让预测框的中心在grid cell中心附近
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))
return x if self.training else (torch.cat(z, 1), x)
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
# 网格标尺坐标
# 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()
# 与grid同理
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