下面是函数 find_3_positive的详细解析。
本博客bs为2，即batch_size=2,采用的数据集不同于coco的85类，我们采用10类。
函数find_3_positive的参数解析：
参数p为模型输出的预测值，有3层，size=[(bs,3,20,20,15),(bs,3,40,40,15)，(bs,3,80,80,85)], targets的size=(nt, 6)为(标注的数量，6)，如右边所示6的含义(nt, image_index + cls_id + x,y,w,h)
def find_3_positive(self, p, targets)
#######na为anchors的数量，nt为标注的数量，例 na=3，nt=156
na, nt = self.na, targets.shape[0]
indices, anch = [], []
#######归一化网格空间(normalized to gridspace gain)
gain = torch.ones(7, device=targets.device).long()
#######得到维度(3，156)，即（na，nt），ai具体样子[[0,0...,0],[1,1..,1],[2,2...,2]]。
ai = torch.arange(na, device=targets.device).float().view(na, 1).repeat(1, nt)
########按照第二个维度进行堆叠，这里向最后一个维度添加了anchor索引，得到的targets维度(3,156,7)，(nt, image_index + cls_id + bbox + anchor_index)。这里使用repeat函数使输入进来的targets（156，6）重复了na=3次。
targets = torch.cat((targets.repeat(na, 1, 1), ai[:, :, None]), 2)
g = 0.5
########这里使用的是五个点，yolov7采用的是预测框的中心点落入那个grid里，使用该grid和周围的上下左右总共五个中的三个grid的anchor框来进行回归。主要看中心点的x落在左上角还是右下角。需要注意的是在这个函数里面是针对周围五个grid，而后面的函数可知，每一个中心点只能利用相邻的两个grid。
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 #0ff维度（5，2）
for i in range(self.nl):
anchors = self.anchors[i] # anchors的维度(3,2)
#######这里当i=0的时候将gain的[2:6]对应的位置换位80(第一层特征层大小)。p[0].shape = 2,3,80,80,15,根据下标索引得到[80,80,80,80]
gain[2:6] = torch.tensor(p[i].shape)[[3, 2, 3, 2]]
#######由于标签是0-1之间，所以对应位置乘以特征图尺寸。形状还是(na,nt, image_index + cls_id + bbox + anchor_index),例如(3,156，7)
t = targets * gain
if nt:
#######用gt框的wh除anchor的wh，结果的维度r=(na,nt,wh)，例如(3,156,2)。
r = t[:, :, 4:6] / anchors[:, None] # wh的比率。
#######这里hyp['anchor_t']=4，j是为了筛选比值大于4的，即正样本为：预测框wh/anchor wh<4.0的，同时比较r和1/r选择最大。j的维度为(na,nt),例如(3,156)。
j = torch.max(r, 1. / r).max(2)[0] < self.hyp['anchor_t']
# 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] # 从3*156个gt框过滤出220个gt框（filter_nt,image_index + cls_id + bbox + anchor_index）。例如过滤出220个gt框(220,7)。
#######筛选得到gt框的xy，维度为（filter_nt,xy）,例如(220,2)
gxy = t[:, 2:4] # grid xy
#######用对应特征层尺度减去经过筛选得到gt框的xy，比如用80去减。这里得到维度为：(220,2)。
gxi = gain[[2, 3]] - gxy # inverse
#######把相对于各个网格左上角x<0.5,y<0.5和相对于右下角的x<0.5,y<0.5的框提取出来，也就是j,k,l,m。这里.T就是转置。这里
j, k = ((gxy % 1. < g) & (gxy > 1.)).T
l, m = ((gxi % 1. < g) & (gxi > 1.)).T
#######这里j经过堆叠之后维度(5,filter_nt)。这里的例子(5,220)
j = torch.stack((torch.ones_like(j), j, k, l, m))
t = t.repeat((5, 1, 1))[j] #和上面的过滤220框一样。从（5，220，7）过滤出（657，7）个gt框（相比于上面多了457个gt框，这得益与扩充），而位置索引（5，220）。这里要注意的是首先使用repeat函数使目标扩充五倍，先使用ones_like（j）将五个维度中的第一个维度全部索引出来，那就是220个框，加上j，k，l，m四个维度索引，理应2*220=440个框，总共能筛选660个框，但由于计算问题，掉了13个gt框，这里有待改进。这里将再次筛选的gt框数量计为final_filter_nt，于是得到t的维度(final_filter_nt,image_index + cls_id + bbox + anchor_index)。
#######得到中心点掉入某gird，该网格相对于周围五个框的偏移量。
offsets = (torch.zeros_like(gxy)[None] + off[:, None])[j]
else:
t = targets[0]
offsets = 0
#######得到image_index(batch_size为2的话就是0或者1) 和 cls_id。两个维度都是(final_filter_nt)。例如维度(648,)。这里.long()可以取整。
b, c = t[:, :2].long().T # image, class
#######得到gt框中心点xy坐标。两个维度都是(final_filter_nt，xy)。例如我的例子中维度为(645,2)。
gxy = t[:, 2:4] # grid xy （648，2）
#######同理
gwh = t[:, 4:6] # grid wh （648，2）
#######用xy坐标减去offset，这样做的目的是将本grid的坐标点，分别映射到周围五个grid的对应位置。这里.long是取整，得到各个网格坐标。
gij = (gxy - offsets).long()
#######将最后一个维度的xy拆散，并且利用转置，将x和y进行分开。
gi, gj = gij.T # grid xy indices
# Append index（4，645）image class ，y , x
#######得到anchor_index(这里是0，1，2)，维度(final_filter_nt)，例如(648,)。
a = t[:, 6].long() # anchor indices
#######将b(image_index)和a(anchor_index),还有gj(表示y)和gi(表示x)进行堆叠。这里clamp_(0, gain[3] - 1)函数表示将输入input张量每个元素的值压缩到区间 [min,max](这里就是(0,79))，并返回结果到一个新张量,由于函数加了_,所以在旧张量上面进行修改，不用返回一个新张量。返回后的维度为：(image_index+anchor_index+yx(grid),final_filter_nt)。本例为(4,648,)。
indices.append((b, a, gj.clamp_(0, gain[3] - 1), gi.clamp_(0, gain[2] - 1)))
#######对anchors(形状为（na,2）)，以a（表现为anchor_index,他表示每个gt框的anchor索引）为索引，找到每个gt框所对应的anchor。最后输出维度为：（final_filter_nt,anchors）,例如(645,2)。
anch.append(anchors[a]) # anchors
########对上述最后两步的 indices（image_index+anchor_index+yx(grid),final_filter_nt）和anch（final_filter_nt,anchors）进行返回。
return indices, anch
def build_targets(self, p, targets, imgs): #indices, anch = self.find_positive(p, targets) ###上述函数的返回值。indices为（image_index+anchor_index+yx,final_filter_nt）和anch（final_filter_nt,anchors），这里yx是grid网格的坐标。 indices, anch = self.find_3_positive(p, targets) #indices, anch = self.find_4_positive(p, targets) #indices, anch = self.find_5_positive(p, targets) #indices, anch = self.find_9_positive(p, targets) matching_bs = [[] for pp in p] matching_as = [[] for pp in p] matching_gjs = [[] for pp in p] matching_gis = [[] for pp in p] matching_targets = [[] for pp in p] matching_anchs = [[] for pp in p] nl = len(p) # nl（number layer）= 3，预测特征层的层数。 ###这里batch_size=2，所以batch_idx的范围为0，1。 for batch_idx in range(p[0].shape[0]): ###判断是否image_index是否为0,返回维度(gt,),例如 (156,)。 b_idx = targets[:, 0]==batch_idx ###根据b_idx进行筛选，得到图片0(这里batch_size=2,就图片0和1)的目标框数量，图片0的维度是（也就是this_target），(gt,image_index+class+bbox)，这里是（93，6），那么后面图片1就是（63，6）。 this_target = targets[b_idx] #(93,6) ###判断该图片是不是没有目标框 if this_target.shape[0] == 0: continue ###这里对gt框的xywh都乘以80来得到，gt框的xywh。 txywh = this_target[:, 2:6] * imgs[batch_idx].shape[1] ###通过函数xywh2xyxy，得到gt框左上角和右下角的xy。 txyxy = xywh2xyxy(txywh) pxyxys = [] p_cls = [] p_obj = [] from_which_layer = [] all_b = [] all_a = [] all_gj = [] all_gi = [] all_anch = [] ###预测层p的维度为:(batch_size,3,80,80,15),(batch_size,3,40,40,15),(batch_size,3,20,20,15)。 for i, pi in enumerate(p): ###将函数的返回值进行赋值b，a,gj,gi的维度(645,) b, a, gj, gi = indices[i] ###这里的b也就是image_index，如果是图片0就True，否则False。得到维度为(648,)。 idx = (b == batch_idx) ###筛选得到图片0里面的b，a，gj，gi值，也就是image_index,anchor_index,和x，y他们四个维度，他们都是（273，）。 b, a, gj, gi = b[idx], a[idx], gj[idx], gi[idx] all_b.append(b) all_a.append(a) all_gj.append(gj) all_gi.append(gi) ###对anchor框进行筛选，得到（273，2）个ancho框。这也是图片0所对应的anchor数量。 all_anch.append(anch[i][idx]) from_which_layer.append(torch.ones(size=(len(b),)) * i) ###将find_3_positive函数粗筛选后的[b,a,gj,gi]与预测层结果对应的点进行匹配。原本有640个预测点，有273个点被索引出，需要注意的是这里是图片0的。 fg_pred = pi[b, a, gj, gi] p_obj.append(fg_pred[:, 4:5]) #得到obj的预测值 p_cls.append(fg_pred[:, 5:]) #得到cls的预测值 ###将gi和gj在第一维度进行堆叠，这里gi和gj分别是x和y，得到有gt框中心点分别落在那个位置，最后得到的维度(273,2)，这里也是图片0里面gt框的中心点。 grid = torch.stack([gi, gj], dim=1) ###通过下面的公式得到预测层里的预测框的xy。 pxy = (fg_pred[:, :2].sigmoid() * 2. - 0.5 + grid) * self.stride[i] #pxy = (fg_pred[:, :2].sigmoid() * 3. - 1. + grid) * self.stride[i] ###通过下面的公式得到预测层里的预测框的xy。这里维度为(273,2) pwh = (fg_pred[:, 2:4].sigmoid() * 2) ** 2 * anch[i][idx] * self.stride[i] #/ 8. 预测的wh值 ####将xywh值进行堆叠，他的维度变化为(273,4)。 pxywh = torch.cat([pxy, pwh], dim=-1) ####将wywh转换成，预测框左上角和右下角坐标。 pxyxy = xywh2xyxy(pxywh) pxyxys.append(pxyxy)###将本张图片的所有正样本合并。shape=（P，4） pxyxys = torch.cat(pxyxys, dim=0) if pxyxys.shape[0] == 0: continue p_obj = torch.cat(p_obj, dim=0) p_cls = torch.cat(p_cls, dim=0) from_which_layer = torch.cat(from_which_layer, dim=0) all_b = torch.cat(all_b, dim=0) all_a = torch.cat(all_a, dim=0) all_gj = torch.cat(all_gj, dim=0) all_gi = torch.cat(all_gi, dim=0) all_anch = torch.cat(all_anch, dim=0
本文转载自: https://blog.csdn.net/clhmliu/article/details/128025315
版权归原作者 clhmliu 所有， 如有侵权，请联系我们删除。
版权归原作者 clhmliu 所有， 如有侵权，请联系我们删除。