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

最新推荐文章于 2024-05-04 20:29:45 发布
最新推荐文章于 2024-05-04 20:29:45 发布
阅读量3k 收藏 35
点赞数 20
文章标签： 深度学习 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ji_HON/article/details/121181548
版权 
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）

想成为书呆子
关注
  • 20
    点赞
  • 踩
  • 35
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
swift_build_example
03-17
在Swift编程语言中，构建（build）项目是一个至关重要的步骤，它将源代码转换为可执行文件或库。本文将深入探讨"swift_build_example"，一个可能的Swift项目构建示例，以及相关的知识点。 首先，Swift是苹果公司...
build-system
04-17
4. `*.cs`：C#源代码，可能包含了构建过程中的实用函数和逻辑。 5. `tests`目录：可能包含了测试代码，用于验证构建系统的正确性。 6. `.gitignore`：定义了版本控制系统应该忽略的文件和目录。 通过深入理解这些...
【玩转yolov5】之anchor匹配策略(build_targets)分析(1)
05-04 5637
这里我们实际推演一下yolov5训练过程中的anchor匹配策略,为了简化数据和便于理解，设定以下训练参数。 输入分辨率(img-size)：608x608 分类数(num_classes)：2 batchsize：1 网络结构如下图所示: def build_targets(pred, targets, model): """ pred: type(pred) : <class 'list'> """ #p:predict,tar...
【代码解读】超详细，YOLOV5之build_targets函数解读。
Gorgeous_wxd
08-04 6106
超详细，yolov5之build_targets函数解读
备忘：YOLOv5环境配置时遇到的问题
最新发布
LNYbelieve的博客
05-04 353
这是貌似是因为炮哥提供资料中已经存在了“train.cache”文件和"val.cache"文件（我是直接使用的炮哥提供的数据集），所以在自己训练之前要把这俩文件删除。经过搜索资料得知，这是因为numpy版本的问题，将运行终端提示的部分中，含有“np.int”的部分修改为“np.int_”即可解决。将loss.py中最后一个for循环替换为下方代码。学习yolov5，遇到一些环境配置上的问题。第三个是开始训练时出现以下报错。本文只做作者备忘使用。
yolov5代码详解-build_targets(p, targets, model)
a1874738854的博客
01-18 7587
build_target函数是将box标签和anchor进行匹配，其中FPN特征图为三层，分别为降采样8，16，32，代码展示与解释如下： def build_targets(p, targets, model): # Build targets for compute_loss(), input targets(image,class,x,y,w,h) 获取yolov5网络输出 det = model.module.model[-1] if is_parallel(model)
yolov5 build_targets()
Runner的博客
09-28 1565
#这里na为锚框种类数 nt为目标数 这里的na为3，nt也为3 na, nt = self.na, targets.shape[0] # number of anchors, targets #类别 边界盒 索引 锚框 tcls, tbox, indices, anch = [], [], [], [] #利用gain来计算目标在某一个特征图上的位置信息，初始化为1 gain = torch.ones(7, device=targets.device) # normalized to gridspac
DevExpress.Build.targets
weixin_34310785的博客
06-27 93
  1 &lt;Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003"&gt; 2 &lt;UsingTask TaskName="DevExpress.Build.DXGeneratePriConfigurationFiles" AssemblyFile="DevExpress.Build.v14.2...
【玩转yolov5】之anchor匹配策略(build_targets)分析(2)
05-04 3180
接上篇yolov5之anchor匹配策略(build_targets)分析(1) gxy = t[:, 2:4] # grid xy gxi = gain[[2, 3]] - gxy # inverse #这两个条件可以用来选择靠近的两个邻居网格 j, k = ((gxy % 1. < g) & (gxy > 1.)).T l, m = ((gxi % ...
cmake入门操作博客源代码
01-24
通过这篇博客的源代码，你可以学习如何设置一个简单的CMake项目，逐步理解每个命令的作用，以及如何在实际工程中应用这些知识。记住，实践是最好的老师，尝试修改CMakeLists.txt，观察构建结果的变化，以此加深理解...
node.js调用C++函数的方法示例
10-17
然后，使用`node-gyp configure`生成构建文件，再运行`node-gyp build`来编译源代码，生成addon.node文件。在Node.js应用中，你可以通过`require()`来加载这个模块： ```javascript // test.js const addon = ...
MQTT源代码 MQTTTBOX
12-04
MQTTBox #### Developers helper program to create and test MQTT connectivity protocol. Supercharge your MQTT workflow with MQTTBox Apps available on Chrome, Linux, Mac, Web and Windows! Build, test, and document your MQTT connectivity protocol.
cmake_project_example:cmake项目
03-06
在"cmake_project_example"中，`main`很可能是指项目的主源代码文件，通常包含项目的入口点。 CMake的使用步骤通常包括以下几步： 1. **初始化**：在项目根目录下创建`CMakeLists.txt`文件。这个文件会指导CMake...
YOLOv5(7) ComputeLoss和build_targets
weixin_43644477的博客
12-29 532
YOLOv5(7) ComputeLoss和build_targets
yolov5核心代码: anchor匹配策略，compute_loss和build_targets理解
qq_44523137的博客
03-07 5214
yolov5核心代码compute_loss和build_targets理解 本文主要讲述yolov5anchor匹配策略-跨网格预测以及损失函数计算的核心过程理解，网络部分相对容易这里不再赘述。 1. yolov5跨网格匹配策略 yolov5最重要的便是跨网格进行预测，从当前网格的上、下、左、右的四个网格中找到离目标中心点最近的两个网格，再加上当前网格共三个网格进行匹配。增大正样本的数量，加快模型收敛。 j, k = ((gxy % 1. < g) & (gxy > 1.)).T
yolov5中的targets和imgs
Newt_Scamander的博客
01-01 1478
imgs.shape :torch.Size([4, 3, 640, 640]) targets.shape:torch.Size([9, 6]) targets: tensor([[0.00000, 0.00000, 0.33555, 0.46680, 0.03516, 0.02734], [1.00000, 0.00000, 0.46797, 0.54727, 0.03594, 0.02891], [2.00000, 0.00000, 0.64336, 0.55273, 0.06641, 0.02734
yolov5/v7训练报错build target indices.append((b, a, gj.clamp_(0, gain[3] - 1), gi.clamp_(0, gain[2] - 1)
weixin_41012399的博客
11-09 2442
参考：https://blog.csdn.net/weixin_41012767/article/details/125779972。在loss.py文件下修改。
YOLO-V3-SPP 训练时正样本筛选源码解析之build_targets
qq_38109282的博客
08-05 1859
前言 理论详解：YOLO-V3-SPP详细解析 build_targets 讲解形式主要以流程图形式，逐流程详细解读每一行代码 代码以pytorch框架为基础 targets处理整体流程 这里主要介绍了targets的来龙去脉，targets指的是数据集中标注好的GroundTruth的目标信息，，build_target这个函数主要是处理当前批次的所有图片的targets，将当前批次的所有targets经过： 宽高IOU筛选 标注的yolo格式的box信息(xcenter,ycenter,w,h)(x_
yolov5目标的生成及损失函数
weixin_38241876的博客
11-24 3887
def build_targets(p, targets, model): """ :param p:torch.Size([2, 3, 19, 19, 85])*3 :param targets: [目标数,6] :param model: :return: """ # Build targets for compute_loss(), input targets(image,class,x,y,w,h) det = model.mo.
yolov5 中build_targets函数的源码
05-25
以下是 YOLOv5 中 build_targets 函数的源码，该函数用于生成训练时所需的目标标签，其输入是一个包含了所有 Ground Truth 边界框的列表和一个预测的输出张量。它的输出是一个包含了每个预测边界框的目标类别、置信...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值