YOLOV5源代码学习之build_targets()函数

2024-01-24 20:12:52

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 anchors
    t = 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，反之False
    j = 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])  # anchors
    tcls.append(c)  # class

return 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）

码农公寓

相关文章