build_targets()函数的作用：找出与该gtbox最匹配的先验框（anchor）

下面的代码调试均是将train函数中的batchsize设置为2进行的，且每张数据集图片中只有一个目标

为了更方便直观的理解代码，每一步都输出了变量的值

#这里na为锚框种类数 nt为目标数 这里的na为3，nt为2
na, nt = self.na, targets.shape[0]
# 类别 边界盒 索引 锚框
tcls, tbox, indices, anch = [], [], [], []
# 利用gain来计算目标在某一个特征图上的位置信息，初始化为1
gain = torch.ones(7, device=targets.device)  # normalized to gridspace gain
# 第二个维度复制nt遍
# ai.shape = (na, nt)，锚框的索引，2个目标，3种锚框，所以共6个元素
ai = torch.arange(na, device=targets.device).float().view(na, 1).repeat(1, nt)
# targets.shape = (na, nt, 7)（3，2，7）给每个目标加上锚框索引
targets = torch.cat((targets.repeat(na, 1, 1), ai[:, :, None]), 2)

此处的na=3,nt=2;

gain=tensor([1., 1., 1., 1., 1., 1., 1.], device='cuda:0')

ai=tensor([ [0., 0.],[1., 1.],[2., 2.] ], device='cuda:0')

targets=tensor([  [  [0.00000, 0.00000, 0.55510, 0.47639, 0.33808, 0.09116, 0.00000],
                              [1.00000, 0.00000, 0.56098, 0.48167, 0.74626, 0.32569, 0.00000]],

                           [  [0.00000, 0.00000, 0.55510, 0.47639, 0.33808, 0.09116, 1.00000],
                              [1.00000, 0.00000, 0.56098, 0.48167, 0.74626, 0.32569, 1.00000]],

                           [  [0.00000, 0.00000, 0.55510, 0.47639, 0.33808, 0.09116, 2.00000],
                              [1.00000, 0.00000, 0.56098, 0.48167, 0.74626, 0.32569, 2.00000]]])

此处为了更好的看targets的数值，去掉了tensor最后的, device='cuda:0'（下文其他地方也是）

g = 0.5  # bias
# off偏移量
off = torch.tensor([[0, 0],[1, 0], [0, 1], [-1, 0], [0, -1],  # j,k,l,m# [1, 1], [1, -1], [-1, 1], [-1, -1],  # jk,jm,lk,lm], device=targets.device).float() * g  # offsets

这一步就是定义偏移量和偏置

for i in range(self.nl):#self.nl为预测层也就是检测头的数量，anchor匹配需要逐层进行# 获取当前的锚框尺寸anchors = self.anchors[i]#anchors中为三个只有长和宽的先验框gain[2:6] = torch.tensor(p[i].shape)[[3, 2, 3, 2]]  # xyxy gain# 将xywh映射到当前特征图，即乘以对应的特征图尺寸 # Match targets to anchorst = targets * gain #targets*gain将归一化的box乘以特征图尺度，将box坐标投影到特征图上

self.nl为预测层也就是检测头的数量，yolov5有三个预测层，即self.nl=3。由于i=0时，进入循环后gxy的值为空（我也不知道是什么原因），变量没有值供代码阅读，因此以下均是i=1时的变量值

anchors的初始值是通过K-means聚类得到的

anchors=tensor([  [1.87500, 3.81250],
                             [3.87500, 2.81250],
                             [3.68750, 7.43750]], device='cuda:0')

gain=tensor([ 1.,  1., 40., 40., 40., 40.,  1.], device='cuda:0')

t=tensor([  [   [ 0.00000,  0.00000, 22.20409, 19.05554, 13.52327,  3.64638,  0.00000],
                     [ 1.00000,  0.00000, 22.43921, 19.26677, 29.85052, 13.02770,  0.00000]],

                 [   [ 0.00000,  0.00000, 22.20409, 19.05554, 13.52327,  3.64638,  1.00000],
                     [ 1.00000,  0.00000, 22.43921, 19.26677, 29.85052, 13.02770,  1.00000]],

                 [   [ 0.00000,  0.00000, 22.20409, 19.05554, 13.52327,  3.64638,  2.00000],
                     [ 1.00000,  0.00000, 22.43921, 19.26677, 29.85052, 13.02770,  2.00000]]])

if nt:# Matches# r为目标wh和锚框wh的比值，比值在0.25到4即采用该种锚框预测目标。# 计算标签box和当前层的anchors的宽高比，即:wb/wa,hb/ha。r = t[:, :, 4:6] / anchors[:, None]  # wh ratio# 将比值和预先设置的比例anchor_t对比，符合条件为True，反之Falsej = torch.max(r, 1. / r).max(2)[0] < self.hyp['anchor_t']  # compare# 根据j筛选符合条件的情况# j = wh_iou(anchors, t[:, 4:6]) > model.hyp['iou_t']  # iou(3,n)=wh_iou(anchors(3,2), gwh(n,2))t = t[j]  # filter这一步是什么操作？

进入if循环后，首先求目标框和锚框的宽高比值

r=tensor([  [  [ 7.21241,  0.95643],
                     [15.92028,  3.41710]],

                  [  [ 3.48988,  1.29649],
                     [ 7.70336,  4.63207]],

                  [  [ 3.66733,  0.49027],
                     [ 8.09506,  1.75162]]], device='cuda:0')

此处的torch.max(r, 1. / r)是求r和1./r两个三维tensor中相同位置处的最大值。而后面一个.max(2)应该是等同于torch.max(a,dim)函数，参数dim通常是一个常数，也就是要删除一个维度，此处我对 j = torch.max(r, 1. / r).max(2)[0] < self.hyp['anchor_t'] 进行了分割输出

torch.max(r, 1. / r)=tensor([  [  [ 7.2124,  1.0456],
                                                [15.9203,  3.4171]],

                                             [   [ 3.4899,  1.2965],
                                                 [ 7.7034,  4.6321]],

                                             [   [ 3.6673,  2.0397],
                                                 [ 8.0951,  1.7516]]])

torch.max(r, 1. / r).max(2)=torch.return_types.max(
                                                values=tensor([  [ 7.2124, 15.9203],
                                                                           [ 3.4899,  7.7034],
                                                                           [ 3.6673,  8.0951]]),
                                                indices=tensor([  [0, 0],
                                                                            [0, 0],
                                                                            [0, 0]]))

torch.max(r, 1. / r).max(2)[0]=tensor([  [ 7.2124, 15.9203],
                                                             [ 3.4899,  7.7034],
                                                             [ 3.6673,  8.0951]])

self.hyp['anchor_t']=4.0      anchor_t的值存于data\hyps\hyp.scratch.yaml文件中

j=tensor([  [False, False],
                 [ True, False],
                 [ True, False]], device='cuda:0')

t=t[j]=tensor([  [ 0.0000,  0.0000, 22.2041, 19.0555, 13.5233,  3.6464,  1.0000],
                       [ 0.0000,  0.0000, 22.2041, 19.0555, 13.5233,  3.6464,  2.0000]],device='cuda:0')

这几行的代码就是先求t中宽高与对应anchor中宽高的比值，有两个真实的目标框，有三个不同的anchor，因此之前(targets.repeat(na, 1, 1)就已经将t中的真实目标框变成了三组，分别与三个不同的anchor做除法，最后t中保留下了比值小于4.0的真实目标框。

 

# Offsets
# 得到相对于以左上角为坐标原点的坐标
gxy = t[:, 2:4]  # grid xy
# 得到相对于右下角为坐标原点的坐标
gxi = gain[[2, 3]] - gxy  # inverse
#jk和lm是判断gxy的中心点更偏向哪里
j, k = ((gxy % 1. < g) & (gxy > 1.)).T #g的值为0.5
l, m = ((gxi % 1. < g) & (gxi > 1.)).T

gxy=tensor([  [22.20409, 19.05554],
                      [22.20409, 19.05554]], device='cuda:0')

gxi=tensor([  [17.79591, 20.94446],
                     [17.79591, 20.94446]], device='cuda:0')

 gxy和j、k对应数值的位置关系如图所示，g=0.5

gxy%1<0.5且gxy>1.0均为True，说明gtbox的中心点偏向于相邻上下左右网格中的上网格和左网格

 

 gxy % 1. < g=tensor([  [True, True],
                                     [True, True]], device='cuda:0')

gxy > 1.=tensor([  [True, True],
                             [True, True]], device='cuda:0')

j=torch.tensor([True,True], device='cuda:0')                     

k=torch.tensor([True,True], device='cuda:0')

变量l,m值同理。yolov5中，不仅得到了gtbox中心点所在的网格，还会判断gtbox的中心点更靠近于该网格上下左右四个相邻网格中的哪两个。

j = torch.stack((torch.ones_like(j), j, k, l, m))# yolov5不仅用目标中心点所在的网格预测该目标，还采用了距目标中心点的最近两个网格# 所以有五种情况，网格本身，上下左右，这就是repeat函数第一个参数为5的原因t = t.repeat((5, 1, 1))[j]# 这里将t复制5个，然后使用j来过滤# 第一个t是保留所有的gtbox，因为上一步里面增加了一个全为true的维度，# 第二个t保留了靠近方格左边的gtbox，# 第三个t保留了靠近方格上方的gtbox，# 第四个t保留了靠近方格右边的gtbox，# 第五个t保留了靠近方格下边的gtbox，offsets = (torch.zeros_like(gxy)[None] + off[:, None])[j]

torch.ones_like(j)=tensor([True, True], device='cuda:0')

j=torch.stack((torch.ones_like(j), j, k, l, m))=tensor([  [ True,  True],
                                                                                   [ True,  True],
                                                                                   [ True,  True],
                                                                                   [False, False],
                                                                                   [False, False]], device='cuda:0')

这里将t中保留的一组真实目标框变成了五组，然后根据j的值保留下了三组，分别对应网格本身，网格相邻的上方网格，网格相邻的左侧网格

t.repeat((5, 1, 1))[j]=

tensor([  [ 0.00000,  0.00000, 22.20409, 19.05554, 13.52327,  3.64638,  1.00000],
              [ 0.00000,  0.00000, 22.20409, 19.05554, 13.52327,  3.64638,  2.00000],
              [ 0.00000,  0.00000, 22.20409, 19.05554, 13.52327,  3.64638,  1.00000],
              [ 0.00000,  0.00000, 22.20409, 19.05554, 13.52327,  3.64638,  2.00000],
              [ 0.00000,  0.00000, 22.20409, 19.05554, 13.52327,  3.64638,  1.00000],
              [ 0.00000,  0.00000, 22.20409, 19.05554, 13.52327,  3.64638,  2.00000]])

torch.zeros_like(gxy)=tensor([  [0., 0.],
                                                  [0., 0.]], device='cuda:0')

torch.zeros_like(gxy)[None]=tensor([  [  [0., 0.],
                                                               [0., 0.]]], device='cuda:0')

off[:, None]=tensor([  [  [ 0.0000,  0.0000]],

                                  [  [ 0.5000,  0.0000]],

                                  [  [ 0.0000,  0.5000]],

                                  [  [-0.5000,  0.0000]],

                                  [  [ 0.0000, -0.5000]]], device='cuda:0')

torch.zeros_like(gxy)[None] + off[:, None]=tensor([  [  [ 0.0000,  0.0000],
                                                                                     [ 0.0000,  0.0000]],

                                                                                   [  [ 0.5000,  0.0000],
                                                                                      [ 0.5000,  0.0000]],

                                                                                   [  [ 0.0000,  0.5000],
                                                                                      [ 0.0000,  0.5000]],

                                                                                   [  [-0.5000,  0.0000],
                                                                                      [-0.5000,  0.0000]],

                                                                                   [  [ 0.0000, -0.5000],
                                                                                      [ 0.0000, -0.5000]]], device='cuda:0')

offsets=tensor([  [0.0000, 0.0000],
                           [0.0000, 0.0000],
                           [0.5000, 0.0000],
                           [0.5000, 0.0000],
                           [0.0000, 0.5000],
                           [0.0000, 0.5000]], device='cuda:0')

else:t = targets[0]offsets = 0# Define
b, c = t[:, :2].long().T  # image, class b表示当前bbox属于该batch内第几张图片
gxy = t[:, 2:4]  # grid xy真实目标框的xy坐标
gwh = t[:, 4:6]  # grid wh真实目标框的宽高
gij = (gxy - offsets).long()#.long()为取整
gi, gj = gij.T  # grid xy indices (gi,gj)是我们计算出来的负责预测该gt box的网格的坐标。

b=tensor([0, 0, 0, 0, 0, 0], device='cuda:0')

c=tensor([0, 0, 0, 0, 0, 0], device='cuda:0')

gxy=tensor([  [22.20409, 19.05554],
                      [22.20409, 19.05554],
                      [22.20409, 19.05554],
                      [22.20409, 19.05554],
                      [22.20409, 19.05554],
                      [22.20409, 19.05554]], device='cuda:0')

gwh=tensor([  [13.52327,  3.64638],
                       [13.52327,  3.64638],
                       [13.52327,  3.64638],
                       [13.52327,  3.64638],
                       [13.52327,  3.64638],
                       [13.52327,  3.64638]], device='cuda:0')

gij为计算出来的负责预测的网格坐标，真实目标框中心点所在网格及其相邻上方和左侧网格的坐标

gij=tensor([  [22, 19],
                    [22, 19],
                    [21, 19],
                    [21, 19],
                    [22, 18],
                    [22, 18]], device='cuda:0')

gi=tensor([22, 22, 21, 21, 22, 22], device='cuda:0')

gj=tensor([19, 19, 19, 19, 18, 18], device='cuda:0')

    a = t[:, 6].long()  # anchor indices a表示当前gt box和当前层的第几个anchor匹配上了indices.append((b, a, gj.clamp_(0, gain[3] - 1), gi.clamp_(0, gain[2] - 1))) tbox.append(torch.cat((gxy - gij, gwh), 1))  # gtbox与三个负责预测的网格的坐标偏移量#以及gtbox的宽高anch.append(anchors[a])  # anchorstcls.append(c)  # classreturn tcls, tbox, indices, anch

a表示与该位置真实目标框宽的高比小于4.0（self.hyp['anchor_t']）的anchor编号

a=tensor([1, 2, 1, 2, 1, 2], device='cuda:0')

gain[3] - 1=tensor(39., device='cuda:0')

 gj.clamp_(0, gain[3] - 1)=tensor([19, 19, 19, 19, 18, 18], device='cuda:0')

gain[2] - 1=tensor(39., device='cuda:0')

gi.clamp_(0, gain[2] - 1)=tensor([22, 22, 21, 21, 22, 22], device='cuda:0')

torch.cat((gxy - gij, gwh), 1)=tensor([  [ 0.2041,  0.0555, 13.5233,  3.6464],
                                                            [ 0.2041,  0.0555, 13.5233,  3.6464],
                                                            [ 1.2041,  0.0555, 13.5233,  3.6464],
                                                            [ 1.2041,  0.0555, 13.5233,  3.6464],
                                                            [ 0.2041,  1.0555, 13.5233,  3.6464],
                                                            [ 0.2041,  1.0555, 13.5233,  3.6464]], device='cuda:0')

anchors[a]=tensor([  [3.8750, 2.8125],
                                 [3.6875, 7.4375],
                                 [3.8750, 2.8125],
                                 [3.6875, 7.4375],
                                 [3.8750, 2.8125],
                                 [3.6875, 7.4375]], device='cuda:0')

最后返回四个列表：

class（类别）

tbox（gtbox与三个负责预测的网格的xy坐标偏移量，gtbox的宽高）

indices（b表示当前gtbox属于该batch内第几张图片，a表示gtbox与anchors的对应关系，负责预测的网格纵坐标，负责预测的网格横坐标）

anch（最匹配的anchors）