• YOLO V7源码解析

    1.命令行参数介绍

    YOLO v7参数与YOLO v5差不多，我就直接将YOLO v5命令行参数搬过来了，偷个懒 

    1. --weights:初始权重
    2.     --cfg:模型配置文件
    3.     --data:数据配置文件
    4.     --hyp:学习率等超参数文件
    5.     --epochs:迭代次数
    6.     -imgsz：图像大小
    7.     --rect：长方形训练策略，不resize成正方形,使用灰条进行图片填充,防止图片失真
    8.     --resume:恢复最近的培训,从last.pt开始
    9.     --nosave:只保存最后的检查点
    10.     --noval：仅在最后一次epochs进行验证
    11.     --noautoanchor：禁用AutoAnchor
    12.     --noplots：不保存打印文件
    13.     --evolve：为x个epochs进化超参数
    14.     --bucket:上传操作,这个参数是 yolov5 作者将一些东西放在谷歌云盘，可以进行下载
    15.     --cache:在ram或硬盘中缓存数据
    16.     --image-weights:测试过程中，图像的那些测试地方不太好，对这些不太好的地方加权重
    17.     --single-cls：单类别标签置0 
    18.     --device：gpu设置  
    19.     --multi-scale:改变img大小+/-50%,能够被32整除
    20.     --optimizer:学习率优化器
    21.     --sync-bn：使用SyncBatchNorm，仅在DDP模式中支持，跨gpu时使用
    22.     --workers:最大 dataloader 的线程数 (per RANK in DDP mode)
    23.     --project：保存文件的地址
    24.     --name：保存日志文件的名称
    25.     --exist-ok:对项目名字是否进行覆盖
    26.     --quad:在dataloader时采用什么样的方式读取我们的数据,1280的大图像可以指定
    27.     --cos-lr:余弦学习率调度
    28.     --label-smoothing：
    29.     --patience：经过多少个epoch损失不再下降，就停止迭代
    30.     --freeze：迁移学习，冻结训练
    31.     --save-period：每x个周期保存一个检查点（如果＜1，则禁用）
    32.     --seed：随机种子
    33.     --local_rank：gpu编号
    34.     --entity:可视化访问信息
    35.     --quad:
    36.     四元数据加载器是我们认为的一个实验性功能，它可能允许在较低 --img 尺寸下进行更高 --img 尺寸训练的一些好处。
    37.     此四元整理功能会将批次从 16x3x640x640 重塑为 4x3x1280x1280，这不会产生太大影响 本身，因为它只是重新排列批次中的马赛克，
    38.     但有趣的是允许批次中的某些图像放大 2 倍（每个四边形中的 4 个马赛克中的一个放大 2 倍，其他 3 个马赛克被删除）

    2.训练策略 

    ema：移动平均法,在更新参数的时候我们希望更平稳一些,考虑的步骤更多一些。公式为:v_{t}=\beta v_{t-1}+(1-\beta)v_{t-1},当系数为\beta时，相当于考虑1/(1-\beta )步更新的梯度，YOLO v7默认\beta

    为0.999，相当于考虑1000步更新的梯度

    3.网络结构

    E-ELAN：

     如下图所示，配置文件的部分就是E-ELAN模块，有四条路径，分别经过1个卷积、1个卷积、3个卷积和5个卷积，其中有3条路径共享了特征图。最后，对四条路径的特征图进行拼接。经过E-ELAN后，相较于输入，特征图通道数加倍。        

      

     

     MPCONV：

            对于MPconv,也分为两条路径，一条经过Maxpooling层，另一条路径经过卷积进行下采样，可以理解为综合考虑卷积和池化的下采样结果，以提升性能。最后，对特征图进行拼接。

    SPPCSPC：

            YOLO v7还是采用了SPP的思想，首先对特征图经过3次卷积，然后分别经过5*5,9*9,13*13的池化，需要注意的是，将5*5与9*9最大池化的特征图进行ADD操作，与13*13和原特征图进行拼接，经过不同kenel_size的池化，实现了对不同感受野的特征融合。然后再经过2次卷积，与经过一次卷积的特征图进行拼接。

    代码如下: 

    1. class SPPCSPC(nn.Module):
    2.     # CSP https://github.com/WongKinYiu/CrossStagePartialNetworks
    3.     def __init__(self, c1, c2, n=1, shortcut=False, g=1, e=0.5, k=(5, 9, 13)):
    4.         super(SPPCSPC, self).__init__()
    5.         c_ = int(2 * c2 * e)  # hidden channels
    6.         self.cv1 = Conv(c1, c_, 1, 1)
    7.         self.cv2 = Conv(c1, c_, 1, 1)
    8.         self.cv3 = Conv(c_, c_, 3, 1)
    9.         self.cv4 = Conv(c_, c_, 1, 1)
    10.         self.m = nn.ModuleList([nn.MaxPool2d(kernel_size=x, stride=1, padding=x // 2) for x in k])
    11.         self.cv5 = Conv(4 * c_, c_, 1, 1)
    12.         self.cv6 = Conv(c_, c_, 3, 1)
    13.         self.cv7 = Conv(2 * c_, c2, 1, 1)
    14.  
    15.     def forward(self, x):
    16.         x1 = self.cv4(self.cv3(self.cv1(x)))
    17.         y1 = self.cv6(self.cv5(torch.cat([x1] + [m(x1) for m in self.m], 1)))
    18.         y2 = self.cv2(x)
    19.         return self.cv7(torch.cat((y1, y2), dim=1))

    PAN：

             yolo v7还是采用了YOLO v5的PAN，经过SPPCSPC层后的特征图不断进行上采样，并与低层信息进行融合，实现了低层信息和高层信息的特征融合，然后进行下采样，与低层进行特征融合，实现了高层信息与低层信息的特征融合。

    HEAD:

            head部分首先经过一层repconv，由3条路径组成，1层1*1的卷积、1层3*3的卷积和1层BN层。 经过repconv后，经过输出层输出结果

    代码如下:

    1. class RepConv(nn.Module):
    2.     # Represented convolution
    3.     # https://arxiv.org/abs/2101.03697
    4.  
    5.     def __init__(self, c1, c2, k=3, s=1, p=None, g=1, act=True, deploy=False):
    6.         super(RepConv, self).__init__()
    7.  
    8.         self.deploy = deploy
    9.         self.groups = g
    10.         self.in_channels = c1
    11.         self.out_channels = c2
    12.  
    13.         assert k == 3
    14.         assert autopad(k, p) == 1
    15.  
    16.         padding_11 = autopad(k, p) - k // 2
    17.  
    18.         self.act = nn.SiLU() if act is True else (act if isinstance(act, nn.Module) else nn.Identity())
    19.  
    20.         if deploy:
    21.             self.rbr_reparam = nn.Conv2d(c1, c2, k, s, autopad(k, p), groups=g, bias=True)
    22.  
    23.         else:
    24.             self.rbr_identity = (nn.BatchNorm2d(num_features=c1) if c2 == c1 and s == 1 else None)
    25.  
    26.             self.rbr_dense = nn.Sequential(
    27.                 nn.Conv2d(c1, c2, k, s, autopad(k, p), groups=g, bias=False),
    28.                 nn.BatchNorm2d(num_features=c2),
    29.             )
    30.  
    31.             self.rbr_1x1 = nn.Sequential(
    32.                 nn.Conv2d( c1, c2, 1, s, padding_11, groups=g, bias=False),
    33.                 nn.BatchNorm2d(num_features=c2),
    34.             )
    35.  
    36.     def forward(self, inputs):
    37.         if hasattr(self, "rbr_reparam"):
    38.             return self.act(self.rbr_reparam(inputs))
    39.  
    40.         if self.rbr_identity is None:
    41.             id_out = 0
    42.         else:
    43.             id_out = self.rbr_identity(inputs)
    44.  
    45.         return self.act(self.rbr_dense(inputs) + self.rbr_1x1(inputs) + id_out)
    46.     
    47.     def get_equivalent_kernel_bias(self):
    48.         kernel3x3, bias3x3 = self._fuse_bn_tensor(self.rbr_dense)
    49.         kernel1x1, bias1x1 = self._fuse_bn_tensor(self.rbr_1x1)
    50.         kernelid, biasid = self._fuse_bn_tensor(self.rbr_identity)
    51.         return (
    52.             kernel3x3 + self._pad_1x1_to_3x3_tensor(kernel1x1) + kernelid,
    53.             bias3x3 + bias1x1 + biasid,
    54.         )
    55.  
    56.     def _pad_1x1_to_3x3_tensor(self, kernel1x1):
    57.         if kernel1x1 is None:
    58.             return 0
    59.         else:
    60.             return nn.functional.pad(kernel1x1, [1, 1, 1, 1])
    61.  
    62.     def _fuse_bn_tensor(self, branch):
    63.         if branch is None:
    64.             return 0, 0
    65.         if isinstance(branch, nn.Sequential):
    66.             kernel = branch[0].weight
    67.             running_mean = branch[1].running_mean
    68.             running_var = branch[1].running_var
    69.             gamma = branch[1].weight
    70.             beta = branch[1].bias
    71.             eps = branch[1].eps
    72.         else:
    73.             assert isinstance(branch, nn.BatchNorm2d)
    74.             if not hasattr(self, "id_tensor"):
    75.                 input_dim = self.in_channels // self.groups
    76.                 kernel_value = np.zeros(
    77.                     (self.in_channels, input_dim, 3, 3), dtype=np.float32
    78.                 )
    79.                 for i in range(self.in_channels):
    80.                     kernel_value[i, i % input_dim, 1, 1] = 1
    81.                 self.id_tensor = torch.from_numpy(kernel_value).to(branch.weight.device)
    82.             kernel = self.id_tensor
    83.             running_mean = branch.running_mean
    84.             running_var = branch.running_var
    85.             gamma = branch.weight
    86.             beta = branch.bias
    87.             eps = branch.eps
    88.         std = (running_var + eps).sqrt()
    89.         t = (gamma / std).reshape(-1, 1, 1, 1)
    90.         return kernel * t, beta - running_mean * gamma / std
    91.  
    92.     def repvgg_convert(self):
    93.         kernel, bias = self.get_equivalent_kernel_bias()
    94.         return (
    95.             kernel.detach().cpu().numpy(),
    96.             bias.detach().cpu().numpy(),
    97.         )
    98.  
    99.     def fuse_conv_bn(self, conv, bn):
    100.  
    101.         std = (bn.running_var + bn.eps).sqrt()
    102.         bias = bn.bias - bn.running_mean * bn.weight / std
    103.  
    104.         t = (bn.weight / std).reshape(-1, 1, 1, 1)
    105.         weights = conv.weight * t
    106.  
    107.         bn = nn.Identity()
    108.         conv = nn.Conv2d(in_channels = conv.in_channels,
    109.                               out_channels = conv.out_channels,
    110.                               kernel_size = conv.kernel_size,
    111.                               stride=conv.stride,
    112.                               padding = conv.padding,
    113.                               dilation = conv.dilation,
    114.                               groups = conv.groups,
    115.                               bias = True,
    116.                               padding_mode = conv.padding_mode)
    117.  
    118.         conv.weight = torch.nn.Parameter(weights)
    119.         conv.bias = torch.nn.Parameter(bias)
    120.         return conv
    121.  
    122.     def fuse_repvgg_block(self):    
    123.         if self.deploy:
    124.             return
    125.         print(f"RepConv.fuse_repvgg_block")
    126.                 
    127.         self.rbr_dense = self.fuse_conv_bn(self.rbr_dense[0], self.rbr_dense[1])
    128.         
    129.         self.rbr_1x1 = self.fuse_conv_bn(self.rbr_1x1[0], self.rbr_1x1[1])
    130.         rbr_1x1_bias = self.rbr_1x1.bias
    131.         weight_1x1_expanded = torch.nn.functional.pad(self.rbr_1x1.weight, [1, 1, 1, 1])
    132.         
    133.         # Fuse self.rbr_identity
    134.         if (isinstance(self.rbr_identity, nn.BatchNorm2d) or isinstance(self.rbr_identity, nn.modules.batchnorm.SyncBatchNorm)):
    135.             # print(f"fuse: rbr_identity == BatchNorm2d or SyncBatchNorm")
    136.             identity_conv_1x1 = nn.Conv2d(
    137.                     in_channels=self.in_channels,
    138.                     out_channels=self.out_channels,
    139.                     kernel_size=1,
    140.                     stride=1,
    141.                     padding=0,
    142.                     groups=self.groups, 
    143.                     bias=False)
    144.             identity_conv_1x1.weight.data = identity_conv_1x1.weight.data.to(self.rbr_1x1.weight.data.device)
    145.             identity_conv_1x1.weight.data = identity_conv_1x1.weight.data.squeeze().squeeze()
    146.             # print(f" identity_conv_1x1.weight = {identity_conv_1x1.weight.shape}")
    147.             identity_conv_1x1.weight.data.fill_(0.0)
    148.             identity_conv_1x1.weight.data.fill_diagonal_(1.0)
    149.             identity_conv_1x1.weight.data = identity_conv_1x1.weight.data.unsqueeze(2).unsqueeze(3)
    150.             # print(f" identity_conv_1x1.weight = {identity_conv_1x1.weight.shape}")
    151.  
    152.             identity_conv_1x1 = self.fuse_conv_bn(identity_conv_1x1, self.rbr_identity)
    153.             bias_identity_expanded = identity_conv_1x1.bias
    154.             weight_identity_expanded = torch.nn.functional.pad(identity_conv_1x1.weight, [1, 1, 1, 1])            
    155.         else:
    156.             # print(f"fuse: rbr_identity != BatchNorm2d, rbr_identity = {self.rbr_identity}")
    157.             bias_identity_expanded = torch.nn.Parameter( torch.zeros_like(rbr_1x1_bias) )
    158.             weight_identity_expanded = torch.nn.Parameter( torch.zeros_like(weight_1x1_expanded) )            
    159.         
    160.  
    161.         #print(f"self.rbr_1x1.weight = {self.rbr_1x1.weight.shape}, ")
    162.         #print(f"weight_1x1_expanded = {weight_1x1_expanded.shape}, ")
    163.         #print(f"self.rbr_dense.weight = {self.rbr_dense.weight.shape}, ")
    164.  
    165.         self.rbr_dense.weight = torch.nn.Parameter(self.rbr_dense.weight + weight_1x1_expanded + weight_identity_expanded)
    166.         self.rbr_dense.bias = torch.nn.Parameter(self.rbr_dense.bias + rbr_1x1_bias + bias_identity_expanded)
    167.                 
    168.         self.rbr_reparam = self.rbr_dense
    169.         self.deploy = True
    170.  
    171.         if self.rbr_identity is not None:
    172.             del self.rbr_identity
    173.             self.rbr_identity = None
    174.  
    175.         if self.rbr_1x1 is not None:
    176.             del self.rbr_1x1
    177.             self.rbr_1x1 = None
    178.  
    179.         if self.rbr_dense is not None:
    180.             del self.rbr_dense
    181.             self.rbr_dense = None

    输出层： 

            对于输出层，YOLO v7采用了yoloR的思想，首先对于经过repconv的特征图，经过ImplicitA层，我个人的理解是，ImplicitA相当于就是各个通道一个偏置项，以丰富各个通道所提取的信息，同时这个偏置项是可以学习的。经过ImplicitA后的特征馈送到输出层中，将输出的结果ImplicitM层，ImplicitM层我的理解是他对输出结果进行了放缩，能够更好的进行回归框的预测。

    1. class ImplicitA(nn.Module):
    2.     def __init__(self, channel, mean=0., std=.02):
    3.         super(ImplicitA, self).__init__()
    4.         self.channel = channel
    5.         self.mean = mean
    6.         self.std = std
    7.         self.implicit = nn.Parameter(torch.zeros(1, channel, 1, 1))
    8.         nn.init.normal_(self.implicit, mean=self.mean, std=self.std)
    9.  
    10.     def forward(self, x):
    11.         return self.implicit + x
    12.     
    13.  
    14. class ImplicitM(nn.Module):
    15.     def __init__(self, channel, mean=1., std=.02):
    16.         super(ImplicitM, self).__init__()
    17.         self.channel = channel
    18.         self.mean = mean
    19.         self.std = std
    20.         self.implicit = nn.Parameter(torch.ones(1, channel, 1, 1))
    21.         nn.init.normal_(self.implicit, mean=self.mean, std=self.std)
    22.  
    23.     def forward(self, x):
    24.         return self.implicit * x

     4.损失函数

            损失函数的输入有3个部分，第一个是预测值，第二个是标签，第三个是图像img

            预测值即为上面模型的输出，而对于标签target， 维度为物体数量*6，对于第二个维度，第一列为标签的索引，第二列为物体所属类别，而后面四列为物体检测框。

    候选框的偏移

            首先,对target进行变换，让target包含anchor的索引，此时target维度为

     number of anchors,number of targets,7，最后一个维度7的组成为:batch索引,类别,x,y,w,h,anchor索引。

            对于偏移，偏移的思想是应对正负样本不均衡的问题，通常来说，负样本远远多于正样本。因此，通过偏移，可以构建更多的正样本。对于样本的中心点，只要目标的中心点偏移后位于附近的网格，也认为这个目标属于这个网格，对应的锚框的区域为正样本

            具体过程为:

    •  输入target标签为相对坐标,将x,y,w,h映射到特征图上
    • 计算锚框与真实框的宽高比,筛选出宽高比在1/r~r(默认为4),其他相差太大的锚框全部，去除,这样可以保证回归结果
    • 分别以左上角为原点和右下角为原点得到中心点的坐标
    • 对于每一个网格,选出中心点离网格中心点左、上小于0.5的target,并且不能是边界，例如：当中心点距离网格左边的距离小于0.5时，中心点左移0.5，此时，该网格左边的网格对应的锚框也为正样本。

    通过，偏移，增加了正样本的数量，返回整数作为中心点所在网格的索引，最终得到存储batch_indices, anchor_indices, grid indices的索引矩阵和对应的anchors

    代码如下: 

    1.  def find_3_positive(self, p, targets):
    2.         # Build targets for compute_loss(), input targets(image,class,x,y,w,h)
    3.         na, nt = self.na, targets.shape[0]  # number of anchors, targets
    4.         indices, anch = [], []
    5.         gain = torch.ones(7, device=targets.device).long()  # normalized to gridspace gain
    6.         #---------------------------------------------------------------------------------#
    7.         # number of anchors,number of targets
    8.         # 表示哪个target属于哪个anchor
    9.         #---------------------------------------------------------------------------------#
    10.         ai = torch.arange(na, device=targets.device).float().view(na, 1).repeat(1, nt)  # same as .repeat_interleave(nt)
    11.         # ---------------------------------------------------------------------------------#
    12.         # number of anchors,number of targets,7
    13.         # 最后一个维度7的组成为:batch索引,类别,x,y,w,h,anchor索引
    14.         # ---------------------------------------------------------------------------------#
    15.         targets = torch.cat((targets.repeat(na, 1, 1), ai[:, :, None]), 2)  # append anchor indices
    16.  
    17.         # ---------------------------------------------------------------------------------#
    18.         # 对于样本的中心点，只要目标的中心点偏移后位于附近的网格，也认为这个目标属于这个网格，对应的锚框的区域为正样本
    19.         # ---------------------------------------------------------------------------------#
    20.         g = 0.5  # bias
    21.         off = torch.tensor([[0, 0],
    22.                             [1, 0], [0, 1], [-1, 0], [0, -1],  # j,k,l,m
    23.                             # [1, 1], [1, -1], [-1, 1], [-1, -1],  # jk,jm,lk,lm
    24.                             ], device=targets.device).float() * g  # offsets
    25.  
    26.         for i in range(self.nl):
    27.             anchors = self.anchors[i]
    28.             # 特征图的h,w
    29.             gain[2:6] = torch.tensor(p[i].shape)[[3, 2, 3, 2]]  # xyxy gain
    30.  
    31.             # Match targets to anchors
    32.             # target标签为相对坐标,将x,y,w,h映射到特征图上
    33.             t = targets * gain
    34.             if nt:
    35.                 # Matches
    36.                 # 计算锚框与真实框的宽高比,筛选出宽高比在1/r~r(默认为4),其他相差太大的锚框全部
    37.                 # 去除,这样可以保证回归结果
    38.                 r = t[:, :, 4:6] / anchors[:, None]  # wh ratio
    39.                 j = torch.max(r, 1. / r).max(2)[0] < self.hyp['anchor_t']  # compare
    40.                 # j = wh_iou(anchors, t[:, 4:6]) > model.hyp['iou_t']  # iou(3,n)=wh_iou(anchors(3,2), gwh(n,2))
    41.                 t = t[j]  # filter 去除相差太大的锚框
    42.  
    43.                 # Offsets 偏移操作
    44.                 # 到左上角的距离,相当于就是以左上角为原点
    45.                 gxy = t[:, 2:4]  # grid xy
    46.                 # 到右下角的距离,相当于就是以右下角为原点
    47.                 gxi = gain[[2, 3]] - gxy  # inverse
    48.                 # 对于每一个网格,选出中心点离网格中心点左上角小于0.5的target,并且不能是边界
    49.                 # 例如:有两个真实框,需要判断,第一个物体是否满足要求,第二个物体是否满足要求,
    50.                 # 将所得的的矩阵转置,j代表在H维度是否满足要求,k代表在w维度是否满足要求
    51.                 j, k = ((gxy % 1. < g) & (gxy > 1.)).T
    52.                 # 对于每一个网格,选出中心点离网格中心点右下角小于0.5的target,并且不能是边界
    53.                 l, m = ((gxi % 1. < g) & (gxi > 1.)).T
    54.                 # 对应于上面的五个偏移
    55.                 j = torch.stack((torch.ones_like(j), j, k, l, m))
    56.                 # target重复五次对应于五个偏移,然后判断能否进行偏移,比如,到网格左边的距离小于0.5,就向左进行偏移,
    57.                 # 需要注意的是,上面给的+1,但是下面操作是减,因此到网格左边的距离小于0.5,就向左进行偏移
    58.                 t = t.repeat((5, 1, 1))[j]
    59.                 offsets = (torch.zeros_like(gxy)[None] + off[:, None])[j]
    60.             else:
    61.                 t = targets[0]
    62.                 offsets = 0
    63.  
    64.             # Define batch_indice,class
    65.             b, c = t[:, :2].long().T  # image, class
    66.             gxy = t[:, 2:4]  # grid xy
    67.             gwh = t[:, 4:6]  # grid wh
    68.             # 执行偏移操作
    69.             gij = (gxy - offsets).long()
    70.             gi, gj = gij.T  # grid xy indices
    71.  
    72.             # Append
    73.             a = t[:, 6].long()  # anchor indices
    74.             indices.append((b, a, gj.clamp_(0, gain[3] - 1), gi.clamp_(0, gain[2] - 1)))  # image, anchor, grid indices
    75.             anch.append(anchors[a])  # anchors
    76.  
    77.         return indices, anch

    候选框的筛选分析:

            yolo v7的候选框的筛选跟YOLO v5和YOLO X均不相同，对于上面候选框的偏移，我们最终得到了9个锚框，然后分别计算这9个锚框的类别损失和IOU损失之和。

            具体过程为: 首先对候选框进行初筛，取出初筛的索引及对应的预测结果,计算出对应的x,y和w,h。需要注意的是，计算过程与初赛过程相对应。对于x,y的计算,若x,y分别为相对于网格的距离,范围为0~1,经过偏移后,x,y的取值范围为-0.5~1.5。对w和h也进行限制,初筛的时候,我们将宽高比大于4的都去掉了,因此，预测的范围也为0-4。然后计算预测框和真实框的iou，取出iou损失中最小的topk，如果多于10个候选框,取10个,少于10个候选框,全部取。然后 对topk的iou进行累加操作,最后取[iou之和]个候选框,相当于iou很小的候选框统统不要,最小为1个，其目的去除iou很小的候选框。并计算出iou损失，和分类损失进行加权,根据加权的结果筛选出对应的候选框。如果出现多个真实框匹配到了同一候选框的情况,此时对应的anchor_matching_gt > 1。比较哪一个真实框跟这个候选框的损失最小，损失最小的真实框匹配上该候选框,其他地方置为0。最后对信息进行汇总,返回batch索引,anchor索引，网格索引,对应的真实标签信息和锚框，并按照输出层进行统计。

     代码如下:

    1.  def build_targets(self, p, targets, imgs):
    2.         
    3.         #indices, anch = self.find_positive(p, targets)
    4.         indices, anch = self.find_3_positive(p, targets)
    5.         #indices, anch = self.find_4_positive(p, targets)
    6.         #indices, anch = self.find_5_positive(p, targets)
    7.         #indices, anch = self.find_9_positive(p, targets)
    8.  
    9.         matching_bs = [[] for pp in p]
    10.         matching_as = [[] for pp in p]
    11.         matching_gjs = [[] for pp in p]
    12.         matching_gis = [[] for pp in p]
    13.         matching_targets = [[] for pp in p]
    14.         matching_anchs = [[] for pp in p]
    15.         
    16.         nl = len(p)    
    17.     
    18.         for batch_idx in range(p[0].shape[0]):
    19.             # 取出batch对应的target
    20.             b_idx = targets[:, 0]==batch_idx
    21.             this_target = targets[b_idx]
    22.             if this_target.shape[0] == 0:
    23.                 continue
    24.  
    25.             # 取出对应的真实框,转换为x1,y1,x2,y2
    26.             txywh = this_target[:, 2:6] * imgs[batch_idx].shape[1]
    27.             txyxy = xywh2xyxy(txywh)
    28.  
    29.             pxyxys = []
    30.             p_cls = []
    31.             p_obj = []
    32.             from_which_layer = []
    33.             all_b = []
    34.             all_a = []
    35.             all_gj = []
    36.             all_gi = []
    37.             all_anch = []
    38.             
    39.             for i, pi in enumerate(p):
    40.  
    41.                 # 有时候index会为空,代表某一层没有对应的锚框
    42.                 # b代表batch_index,a代表anchor_indices,
    43.                 # gj,gi代表网格索引
    44.                 b, a, gj, gi = indices[i]
    45.                 idx = (b == batch_idx)
    46.                 b, a, gj, gi = b[idx], a[idx], gj[idx], gi[idx]                
    47.                 all_b.append(b)
    48.                 all_a.append(a)
    49.                 all_gj.append(gj)
    50.                 all_gi.append(gi)
    51.                 all_anch.append(anch[i][idx])
    52.                 # size为初筛后的候选框数量,值为输出层的索引
    53.                 from_which_layer.append(torch.ones(size=(len(b),)) * i) # 来自哪个输出层
    54.                 
    55.                 fg_pred = pi[b, a, gj, gi]   # 对应网格的预测结果
    56.                 p_obj.append(fg_pred[:, 4:5])
    57.                 p_cls.append(fg_pred[:, 5:])
    58.                 
    59.                 grid = torch.stack([gi, gj], dim=1) # 网格坐标
    60.                 # 与候选框的偏移相对应,若x,y分别为相对于网格的距离,范围为0~1,经过偏移后,x,y的取值范围为-0.5~1.5
    61.                 # 而下面的预测结果经过sigmoid后的范围为0~1,最终计算的范围为-0.5~1.5
    62.                 pxy = (fg_pred[:, :2].sigmoid() * 2. - 0.5 + grid) * self.stride[i] #/ 8.
    63.                 #pxy = (fg_pred[:, :2].sigmoid() * 3. - 1. + grid) * self.stride[i]
    64.                 # 对w和h也进行限制,初筛的时候,我们将宽高比大于4的都去掉了,因此，预测的范围也为0-4
    65.                 pwh = (fg_pred[:, 2:4].sigmoid() * 2) ** 2 * anch[i][idx] * self.stride[i] #/ 8.
    66.                 pxywh = torch.cat([pxy, pwh], dim=-1)
    67.                 pxyxy = xywh2xyxy(pxywh)    # 转换为x,y,w,h
    68.                 pxyxys.append(pxyxy)
    69.             
    70.             pxyxys = torch.cat(pxyxys, dim=0)
    71.             if pxyxys.shape[0] == 0:
    72.                 continue
    73.             # 对三层的结果进行汇总,可能有些层结果为空
    74.             p_obj = torch.cat(p_obj, dim=0)
    75.             p_cls = torch.cat(p_cls, dim=0)
    76.             from_which_layer = torch.cat(from_which_layer, dim=0)
    77.             all_b = torch.cat(all_b, dim=0)
    78.             all_a = torch.cat(all_a, dim=0)
    79.             all_gj = torch.cat(all_gj, dim=0)
    80.             all_gi = torch.cat(all_gi, dim=0)
    81.             all_anch = torch.cat(all_anch, dim=0)
    82.  
    83.             # 计算ciou损失
    84.             pair_wise_iou = box_iou(txyxy, pxyxys)
    85.  
    86.             pair_wise_iou_loss = -torch.log(pair_wise_iou + 1e-8)
    87.  
    88.             # 取出iou损失中最小的topk，如果多于10个候选框,取10个,少于10个候选框,全部取
    89.             top_k, _ = torch.topk(pair_wise_iou, min(10, pair_wise_iou.shape[1]), dim=1)
    90.             # 对iou进行累加操作,最后取[iou之和]个候选框,相当于iou很小的候选框统统不要,最小为1个
    91.             dynamic_ks = torch.clamp(top_k.sum(1).int(), min=1)
    92.  
    93.             # 将类别转换为one_hot编码格式
    94.             gt_cls_per_image = (
    95.                 F.one_hot(this_target[:, 1].to(torch.int64), self.nc)
    96.                 .float()
    97.                 .unsqueeze(1)
    98.                 .repeat(1, pxyxys.shape[0], 1)
    99.             )
    100.  
    101.             # 真实框目标的个数
    102.             num_gt = this_target.shape[0]
    103.             # 预测概率:p_obj*p_cls
    104.             cls_preds_ = (
    105.                 p_cls.float().unsqueeze(0).repeat(num_gt, 1, 1).sigmoid_()
    106.                 * p_obj.unsqueeze(0).repeat(num_gt, 1, 1).sigmoid_()
    107.             )
    108.  
    109.             y = cls_preds_.sqrt_()
    110.             pair_wise_cls_loss = F.binary_cross_entropy_with_logits(
    111.                torch.log(y/(1-y)) , gt_cls_per_image, reduction="none"
    112.             ).sum(-1)
    113.             del cls_preds_
    114.  
    115.             # 总损失:cls_loss+iou_loss
    116.             cost = (
    117.                 pair_wise_cls_loss
    118.                 + 3.0 * pair_wise_iou_loss
    119.             )
    120.  
    121.             matching_matrix = torch.zeros_like(cost)
    122.             # 取出损失最小的候选框的索引
    123.             for gt_idx in range(num_gt):
    124.                 _, pos_idx = torch.topk(
    125.                     cost[gt_idx], k=dynamic_ks[gt_idx].item(), largest=False
    126.                 )
    127.                 matching_matrix[gt_idx][pos_idx] = 1.0
    128.  
    129.             del top_k, dynamic_ks
    130.             # 竖着加
    131.             anchor_matching_gt = matching_matrix.sum(0)
    132.             # 处理多个真实框匹配到了同一候选框的情况,此时对应的anchor_matching_gt > 1
    133.             if (anchor_matching_gt > 1).sum() > 0:
    134.                 # 比较哪一个真实框跟这个候选框的损失最小
    135.                 _, cost_argmin = torch.min(cost[:, anchor_matching_gt > 1], dim=0)
    136.                 matching_matrix[:, anchor_matching_gt > 1] *= 0.0
    137.                 # 损失最小的真实框匹配上该候选框,其他地方置为0
    138.                 matching_matrix[cost_argmin, anchor_matching_gt > 1] = 1.0
    139.             # 正样本索引
    140.             fg_mask_inboxes = matching_matrix.sum(0) > 0.0
    141.             # 正样本对应真实框的索引
    142.             matched_gt_inds = matching_matrix[:, fg_mask_inboxes].argmax(0)
    143.  
    144.             # 汇总
    145.             from_which_layer = from_which_layer[fg_mask_inboxes]
    146.             all_b = all_b[fg_mask_inboxes]
    147.             all_a = all_a[fg_mask_inboxes]
    148.             all_gj = all_gj[fg_mask_inboxes]
    149.             all_gi = all_gi[fg_mask_inboxes]
    150.             all_anch = all_anch[fg_mask_inboxes]
    151.  
    152.             # 真实框
    153.             this_target = this_target[matched_gt_inds]
    154.  
    155.             # 按照三个输出层合并信息
    156.             for i in range(nl):
    157.                 layer_idx = from_which_layer == i
    158.                 matching_bs[i].append(all_b[layer_idx])
    159.                 matching_as[i].append(all_a[layer_idx])
    160.                 matching_gjs[i].append(all_gj[layer_idx])
    161.                 matching_gis[i].append(all_gi[layer_idx])
    162.                 matching_targets[i].append(this_target[layer_idx])
    163.                 matching_anchs[i].append(all_anch[layer_idx])
    164.  
    165.         # 按照输出层,汇总整个batch的信息
    166.         for i in range(nl):
    167.             if matching_targets[i] != []:
    168.                 matching_bs[i] = torch.cat(matching_bs[i], dim=0)
    169.                 matching_as[i] = torch.cat(matching_as[i], dim=0)
    170.                 matching_gjs[i] = torch.cat(matching_gjs[i], dim=0)
    171.                 matching_gis[i] = torch.cat(matching_gis[i], dim=0)
    172.                 matching_targets[i] = torch.cat(matching_targets[i], dim=0)
    173.                 matching_anchs[i] = torch.cat(matching_anchs[i], dim=0)
    174.             else:
    175.                 matching_bs[i] = torch.tensor([], device='cuda:0', dtype=torch.int64)
    176.                 matching_as[i] = torch.tensor([], device='cuda:0', dtype=torch.int64)
    177.                 matching_gjs[i] = torch.tensor([], device='cuda:0', dtype=torch.int64)
    178.                 matching_gis[i] = torch.tensor([], device='cuda:0', dtype=torch.int64)
    179.                 matching_targets[i] = torch.tensor([], device='cuda:0', dtype=torch.int64)
    180.                 matching_anchs[i] = torch.tensor([], device='cuda:0', dtype=torch.int64)
    181.  
    182.         return matching_bs, matching_as, matching_gjs, matching_gis, matching_targets, matching_anchs

    损失函数:

            损失函数与YOLO v5 r6.1版本并无变化，主要包含分类损失、存在物体置信度损失以及边界框回归损失。分类损失和置信度损失均使用交叉熵损失。回归损失使用C-IOU损失。 

    辅助头网络结构:

        当添加辅助输出时，网络结构的输入为1280*1280,第一层需要对图片进行下采样，作者考虑到节省参数，第一层下采样采取间隔采样的做法。     

    代码如下:

    1. class ReOrg(nn.Module):
    2.     def __init__(self):
    3.         super(ReOrg, self).__init__()
    4.  
    5.     def forward(self, x):  # x(b,c,w,h) -> y(b,4c,w/2,h/2)
    6.         return torch.cat([x[..., ::2, ::2], x[..., 1::2, ::2], x[..., ::2, 1::2], x[..., 1::2, 1::2]], 1)

            对于辅助输出,一共有八层，对于辅助输出,在损失函数的处理上有所区别，在标签分配上，辅助输出的偏移量为1，因此一共有5个网格，另外，在候选框的初步筛选上，辅助头的top_k为20。这一系列的处理，能够提升辅助头输出的召回率。因此，辅助头更加关注召回率。在损失函数上，辅助头的损失计算用0.25进行缩放。

     

    模型的重参数化: 

            卷积和bn的重参数化:bn层的公式如图所示,可以变换为wx+b的形式

     

                     因此，可以得到bn层w和b的权重矩阵。

     

            将卷积公式带入其中，最终得到融合的权重矩阵和偏差的计算公式。 

     

     

     对于1*1和3*3卷积的参数化，将1*1的卷积核周围用0填充和3*3的卷积核相加

     

     

     

  • 相关阅读:
    华为FreeBuds Pro 2通话降噪怎么样？实测对比结果！
    android 9 OTA到android11弹出密码框
    uni-app之使用App.vue全局文件的教学
    springboot系列(二十七):如何实现word携带图片导出？这你得会|超级详细，建议收藏
    黑马C++ 02 核心3 —— 类和对象__对象的初始化和清理(重难点)
    【小白专用】微信小程序个人中心、我的界面（示例一）23.11.04
    MySQL 中的事务理解
    【Swift 60秒】48 - Creating basic closures
    指导与管理项目执行
    全新UI简洁又不失美观的短视频去水印微信小程序
  • 原文地址：https://blog.csdn.net/qq_52053775/article/details/127637735