• 保研笔记八——YOLOV5项目复习

    学习转载自：睿智的目标检测56——Pytorch搭建YoloV5目标检测平台_Bubbliiiing的博客-CSDN博客_睿智yolo 

    Pytorch 搭建自己的YoloV5目标检测平台（Bubbliiiing 源码详解 训练 预测）-主干网络介绍_哔哩哔哩_bilibili

    还有一些视频的学习笔记。

    目录

    YOLOV5结构

    CSPDarknet的五个重要特点

    YOLOv5主干构建

    初始化方法

    focus网络结构——特征提取

    SiLU激活函数

    CSPNet结构

    残差网络

    SPP结构

    FPN加强特征提取网络

     利用YOLO HEAD获得预测结果

     yolov5的解码过程

    预测过程

    非极大抑制

    YOLOV5结构

    整个YoloV5可以分为三个部分，分别是Backbone，FPN以及Yolo Head。

    Backbone：可以被称作YoloV5的主干特征提取网络，根据它的结构以及之前Yolo主干的叫法，我一般叫它CSPDarknet

    • 输入的图片首先会在CSPDarknet里面进行特征提取，提取到的特征可以被称作特征层，是输入图片的特征集合。
    • 在主干部分，我们获取了三个特征层进行下一步网络的构建，这三个特征层我称它为有效特征层。

    FPN：可以被称作YoloV5的加强特征提取网络。

    • 在主干部分获得的三个有效特征层会在这一部分进行特征融合，特征融合的目的是结合不同尺度的特征信息。
    • 在FPN部分，已经获得的有效特征层被用于继续提取特征。
    • 在YoloV5里依然使用到了Panet的结构，我们不仅会对特征进行上采样实现特征融合，还会对特征再次进行下采样实现特征融合。

    Yolo Head：是YoloV5的分类器与回归器。

    • 通过CSPDarknet和FPN，我们已经可以获得三个加强过的有效特征层。每一个特征层都有宽、高和通道数，此时我们可以将特征图看作一个又一个特征点的集合，每一个特征点都有通道数个特征。
    • Yolo Head实际上所做的工作就是对特征点进行判断，判断特征点是否有物体与其对应。与以前版本的Yolo一样，YoloV5所用的解耦头是一起的，也就是分类和回归在一个1X1卷积里实现。

    因此，整个YoloV5网络所作的工作就是 特征提取-特征加强-预测特征点对应的物体情况。

    CSPDarknet的五个重要特点

    1. 残差网络Residual
    2. CSPnet网络结构
    3. Focus网络结构
    4. SiLU激活函数
    5. SPP结构

    YOLOv5主干构建

    初始化方法

    文件位置：nets/CSPdarknet.py

    1.     #初始化
    2.     def __init__(self, base_channels, base_depth, phi, pretrained):
    3.         super().__init__()
    4.         #-----------------------------------------------#
    5.         #   输入图片是640, 640, 3
    6.         #   初始的基本通道base_channels是64
    7.         #-----------------------------------------------#
    8.  
    9.         #-----------------------------------------------#
    10.         #   利用focus网络结构进行特征提取
    11.         #   640, 640, 3 -> 320, 320, 12 -> 320, 320, 64
    12.         #-----------------------------------------------#
    13.         self.stem       = Focus(3, base_channels, k=3)
    14.         
    15.         #-----------------------------------------------#
    16.         #   完成卷积之后，320, 320, 64 -> 160, 160, 128
    17.         #   完成CSPlayer之后，160, 160, 128 -> 160, 160, 128
    18.         #-----------------------------------------------#
    19.         self.dark2 = nn.Sequential(
    20.             # 320, 320, 64 -> 160, 160, 128
    21.             Conv(base_channels, base_channels * 2, 3, 2),
    22.             # 160, 160, 128 -> 160, 160, 128
    23.             C3(base_channels * 2, base_channels * 2, base_depth),
    24.         )
    25.         
    26.         #-----------------------------------------------#
    27.         #   完成卷积之后，160, 160, 128 -> 80, 80, 256
    28.         #   完成CSPlayer之后，80, 80, 256 -> 80, 80, 256
    29.         #                   在这里引出有效特征层80, 80, 256
    30.         #                   进行加强特征提取网络FPN的构建
    31.         #-----------------------------------------------#
    32.         self.dark3 = nn.Sequential(
    33.             Conv(base_channels * 2, base_channels * 4, 3, 2),
    34.             C3(base_channels * 4, base_channels * 4, base_depth * 3),
    35.         )
    36.  
    37.         #-----------------------------------------------#
    38.         #   完成卷积之后，80, 80, 256 -> 40, 40, 512
    39.         #   完成CSPlayer之后，40, 40, 512 -> 40, 40, 512
    40.         #                   在这里引出有效特征层40, 40, 512
    41.         #                   进行加强特征提取网络FPN的构建
    42.         #-----------------------------------------------#
    43.         self.dark4 = nn.Sequential(
    44.             Conv(base_channels * 4, base_channels * 8, 3, 2),
    45.             C3(base_channels * 8, base_channels * 8, base_depth * 3),
    46.         )
    47.         
    48.         #-----------------------------------------------#
    49.         #   完成卷积之后，40, 40, 512 -> 20, 20, 1024
    50.         #   完成SPP之后，20, 20, 1024 -> 20, 20, 1024
    51.         #   完成CSPlayer之后，20, 20, 1024 -> 20, 20, 1024
    52.         #-----------------------------------------------#
    53.         self.dark5 = nn.Sequential(
    54.             Conv(base_channels * 8, base_channels * 16, 3, 2),
    55.             SPP(base_channels * 16, base_channels * 16),
    56.             C3(base_channels * 16, base_channels * 16, base_depth, shortcut=False),
    57.         )
    58.         if pretrained:
    59.             url = {
    60.                 's' : 'https://github.com/bubbliiiing/yolov5-pytorch/releases/download/v1.0/cspdarknet_s_backbone.pth',
    61.                 'm' : 'https://github.com/bubbliiiing/yolov5-pytorch/releases/download/v1.0/cspdarknet_m_backbone.pth',
    62.                 'l' : 'https://github.com/bubbliiiing/yolov5-pytorch/releases/download/v1.0/cspdarknet_l_backbone.pth',
    63.                 'x' : 'https://github.com/bubbliiiing/yolov5-pytorch/releases/download/v1.0/cspdarknet_x_backbone.pth',
    64.             }[phi]
    65.             checkpoint = torch.hub.load_state_dict_from_url(url=url, map_location="cpu", model_dir="./model_data")
    66.             self.load_state_dict(checkpoint, strict=False)
    67.             print("Load weights from ", url.split('/')[-1])

    focus网络结构——特征提取

    首先利用focus网络结构进行特征提取（卷积标准化激活工作在focus中调用）。这个网络结构是在YoloV5里面使用到比较有趣的网络结构，具体操作：

    • 在一张图片中每隔一个像素拿到一个值，这个时候获得了四个独立的特征层
    • 然后将四个独立的特征层进行堆叠，此时宽高信息就集中到了通道信息，输入通道扩充了四倍。
    • 拼接起来的特征层相对于原先的三通道变成了十二个通道
    • 下图很好的展示了Focus结构，一看就能明白。

    1.         #-----------------------------------------------#
    2.         #   输入图片是640, 640, 3
    3.         #   初始的基本通道base_channels是64
    4.         #-----------------------------------------------#
    5.  
    6.         #-----------------------------------------------#
    7.         #   利用focus网络结构进行特征提取
    8.         #   640, 640, 3 -> 320, 320, 12 -> 320, 320, 64
    9.         #-----------------------------------------------#
    10. class Focus(nn.Module):
    11.     def __init__(self, c1, c2, k=1, s=1, p=None, g=1, act=True):  # ch_in, ch_out, kernel, stride, padding, groups
    12.         super(Focus, self).__init__()
    13.         # 卷积+标准化+激活函数
    14.         self.conv = Conv(c1 * 4, c2, k, s, p, g, act)
    15.  
    16.     def forward(self, x):
    17.         # 320, 320, 12 => 320, 320, 64
    18.         # 特征堆叠
    19.         return self.conv(
    20.             # 640, 640, 3 => 320, 320, 12
    21.             torch.cat(
    22.                 [
    23.                     # 切片拼接
    24.                     x[..., ::2, ::2], 
    25.                     x[..., 1::2, ::2], 
    26.                     x[..., ::2, 1::2], 
    27.                     x[..., 1::2, 1::2]
    28.                 ], 1
    29.             )
    30.         )

     以下是调用的卷积标准化激活函数

    1. # 顺便放上卷积标准化激活函数
    2. class Conv(nn.Module):
    3.     def __init__(self, c1, c2, k=1, s=1, p=None, g=1, act=True):
    4.         super(Conv, self).__init__()
    5.         self.conv   = nn.Conv2d(c1, c2, k, s, autopad(k, p), groups=g, bias=False)
    6.         self.bn     = nn.BatchNorm2d(c2, eps=0.001, momentum=0.03)
    7.         self.act    = SiLU() if act is True else (act if isinstance(act, nn.Module) else nn.Identity())
    8.  
    9.     def forward(self, x):
    10.         return self.act(self.bn(self.conv(x)))
    11.  
    12.     def fuseforward(self, x):
    13.         return self.act(self.conv(x))

    SiLU激活函数

    里面使用了SiLU激活函数，SiLU是Sigmoid和ReLU的改进版。SiLU具备无上界有下界、平滑、非单调的特性。SiLU在深层模型上的效果优于 ReLU。可以看做是平滑的ReLU激活函数。

    1. class SiLU(nn.Module):
    2.     @staticmethod
    3.     def forward(x):
    4.         return x * torch.sigmoid(x)

     然后是四层卷积标准化激活和csp layer

    1. #-----------------------------------------------#
    2.         #   完成卷积之后，320, 320, 64 -> 160, 160, 128
    3.         #   完成CSPlayer之后，160, 160, 128 -> 160, 160, 128
    4.         #-----------------------------------------------#
    5.         self.dark2 = nn.Sequential(
    6.             # 320, 320, 64 -> 160, 160, 128
    7.             Conv(base_channels, base_channels * 2, 3, 2),
    8.             # 160, 160, 128 -> 160, 160, 128
    9.             C3(base_channels * 2, base_channels * 2, base_depth),
    10.         )
    11.         
    12.         #-----------------------------------------------#
    13.         #   完成卷积之后，160, 160, 128 -> 80, 80, 256
    14.         #   完成CSPlayer之后，80, 80, 256 -> 80, 80, 256
    15.         #                   在这里引出有效特征层80, 80, 256
    16.         #                   进行加强特征提取网络FPN的构建
    17.         #-----------------------------------------------#
    18.         self.dark3 = nn.Sequential(
    19.             Conv(base_channels * 2, base_channels * 4, 3, 2),
    20.             C3(base_channels * 4, base_channels * 4, base_depth * 3),
    21.         )
    22.  
    23.         #-----------------------------------------------#
    24.         #   完成卷积之后，80, 80, 256 -> 40, 40, 512
    25.         #   完成CSPlayer之后，40, 40, 512 -> 40, 40, 512
    26.         #                   在这里引出有效特征层40, 40, 512
    27.         #                   进行加强特征提取网络FPN的构建
    28.         #-----------------------------------------------#
    29.         self.dark4 = nn.Sequential(
    30.             Conv(base_channels * 4, base_channels * 8, 3, 2),
    31.             C3(base_channels * 8, base_channels * 8, base_depth * 3),
    32.         )
    33.         
    34.         #-----------------------------------------------#
    35.         #   完成卷积之后，40, 40, 512 -> 20, 20, 1024
    36.         #   完成SPP之后，20, 20, 1024 -> 20, 20, 1024
    37.         #   完成CSPlayer之后，20, 20, 1024 -> 20, 20, 1024
    38.         #-----------------------------------------------#
    39.         self.dark5 = nn.Sequential(
    40.             Conv(base_channels * 8, base_channels * 16, 3, 2),
    41.             SPP(base_channels * 16, base_channels * 16),
    42.             C3(base_channels * 16, base_channels * 16, base_depth, shortcut=False),
    43.         )

     里面包括了cspNet结构

    CSPNet结构

    CSPnet结构并不算复杂，就是将原来的残差块的堆叠进行了一个拆分，拆成左右两部分：主干部分继续进行原来的残差块的堆叠；另一部分则像一个残差边一样，经过少量处理直接连接到最后。因此可以认为CSP中存在一个大的残差边。在这里插入图片描述

    1. class C3(nn.Module):
    2.     # CSP Bottleneck with 3 convolutions 主干部分
    3.     def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5):  # ch_in, ch_out, number, shortcut, groups, expansion
    4.         super(C3, self).__init__()
    5.         c_ = int(c2 * e)  # hidden channels
    6.         #通道调整
    7.         self.cv1 = Conv(c1, c_, 1, 1)
    8.         self.cv2 = Conv(c1, c_, 1, 1)
    9.         self.cv3 = Conv(2 * c_, c2, 1)  # act=FReLU(c2)
    10.         # 利用残差结构进行特征提取
    11.         self.m = nn.Sequential(*[Bottleneck(c_, c_, shortcut, g, e=1.0) for _ in range(n)])
    12.         # self.m = nn.Sequential(*[CrossConv(c_, c_, 3, 1, g, 1.0, shortcut) for _ in range(n)])
    13.  
    14.     def forward(self, x):
    15.         # C3是csplayer的结果 分为c2（残差部分，只做少量处理）和c1（主干部分）
    16.         return self.cv3(torch.cat(
    17.             (
    18.                 self.m(self.cv1(x)), 
    19.                 self.cv2(x)
    20.             )
    21.             , dim=1))

    CSPNet结构中包含了残差网络的应用

    残差网络

    CSPDarknet中的残差卷积可以分为两个部分，主干部分是一次1X1的卷积和一次3X3的卷积；残差边部分不做任何处理，直接将主干的输入与输出结合。整个YoloV5的主干部分都由残差卷积构成：

    1. class Bottleneck(nn.Module):
    2.     # Standard bottleneck
    3.     def __init__(self, c1, c2, shortcut=True, g=1, e=0.5):  # ch_in, ch_out, shortcut, groups, expansion
    4.         super(Bottleneck, self).__init__()
    5.         c_ = int(c2 * e)  # hidden channels
    6.         self.cv1 = Conv(c1, c_, 1, 1)
    7.         self.cv2 = Conv(c_, c2, 3, 1, g=g)
    8.         self.add = shortcut and c1 == c2
    9.  
    10.     def forward(self, x):
    11.         return x + self.cv2(self.cv1(x)) if self.add else self.cv2(self.cv1(x))

    残差网络的特点是容易优化，并且能够通过增加相当的深度来提高准确率。其内部的残差块使用了跳跃连接，缓解了在深度神经网络中增加深度带来的梯度消失问题。 

     在dark5中进行了spp结构的构建。

    SPP结构

    通过不同池化核大小的最大池化进行特征提取，提高网络的感受野。在YoloV4中，SPP是用在FPN里面的，在YoloV5中，SPP模块被用在了主干特征提取网络中。

    1. class SPP(nn.Module):
    2.     # Spatial pyramid pooling layer used in YOLOv3-SPP
    3.     def __init__(self, c1, c2, k=(5, 9, 13)):
    4.         super(SPP, self).__init__()
    5.         c_ = c1 // 2  # hidden channels
    6.         self.cv1 = Conv(c1, c_, 1, 1)
    7.         self.cv2 = Conv(c_ * (len(k) + 1), c2, 1, 1)
    8.         #利用不同池化核的最大池化进行特征提取
    9.         self.m = nn.ModuleList([nn.MaxPool2d(kernel_size=x, stride=1, padding=x // 2) for x in k])
    10.  
    11.     def forward(self, x):
    12.         x = self.cv1(x)
    13.         #堆叠池化结果，通过cv2进行通道处理
    14.         return self.cv2(torch.cat([x] + [m(x) for m in self.m], 1))

    经过主干网络，三个有效特征层将被传入FPN加强特征提取网络。

    FPN加强特征提取网络

    总的来说就是，通过卷积+上采样+特征堆叠+CSPLayer特征提取+下采样等方法加强特征，这些方法在init函数中有所规划。过程详见图片。

    文件位置：nets/yolo.py 

    1. import torch
    2. import torch.nn as nn
    3.  
    4. from nets.ConvNext import ConvNeXt_Small, ConvNeXt_Tiny
    5. from nets.CSPdarknet import C3, Conv, CSPDarknet
    6. from nets.Swin_transformer import Swin_transformer_Tiny
    7.  
    8.  
    9. #---------------------------------------------------#
    10. #   yolo_body
    11. #---------------------------------------------------#
    12. class YoloBody(nn.Module):
    13.     def __init__(self, anchors_mask, num_classes, phi, backbone='cspdarknet', pretrained=False, input_shape=[640, 640]):
    14.         super(YoloBody, self).__init__()
    15.         depth_dict          = {'s' : 0.33, 'm' : 0.67, 'l' : 1.00, 'x' : 1.33,}
    16.         width_dict          = {'s' : 0.50, 'm' : 0.75, 'l' : 1.00, 'x' : 1.25,}
    17.         dep_mul, wid_mul    = depth_dict[phi], width_dict[phi]
    18.  
    19.         base_channels       = int(wid_mul * 64)  # 64
    20.         base_depth          = max(round(dep_mul * 3), 1)  # 3
    21.         #-----------------------------------------------#
    22.         #   输入图片是640, 640, 3
    23.         #   初始的基本通道是64
    24.         #-----------------------------------------------#
    25.         self.backbone_name  = backbone
    26.         if backbone == "cspdarknet":
    27.             #---------------------------------------------------#   
    28.             #   生成CSPdarknet53的主干模型
    29.             #   获得三个有效特征层，他们的shape分别是：
    30.             #   80,80,256
    31.             #   40,40,512
    32.             #   20,20,1024
    33.             #---------------------------------------------------#
    34.             self.backbone   = CSPDarknet(base_channels, base_depth, phi, pretrained)
    35.         else:
    36.             #---------------------------------------------------#   
    37.             #   如果输入不为cspdarknet，则调整通道数
    38.             #   使其符合YoloV5的格式
    39.             #---------------------------------------------------#
    40.             self.backbone       = {
    41.                 'convnext_tiny'         : ConvNeXt_Tiny,
    42.                 'convnext_small'        : ConvNeXt_Small,
    43.                 'swin_transfomer_tiny'  : Swin_transformer_Tiny,
    44.             }[backbone](pretrained=pretrained, input_shape=input_shape)
    45.             in_channels         = {
    46.                 'convnext_tiny'         : [192, 384, 768],
    47.                 'convnext_small'        : [192, 384, 768],
    48.                 'swin_transfomer_tiny'  : [192, 384, 768],
    49.             }[backbone]
    50.             feat1_c, feat2_c, feat3_c = in_channels 
    51.             self.conv_1x1_feat1 = Conv(feat1_c, base_channels * 4, 1, 1)
    52.             self.conv_1x1_feat2 = Conv(feat2_c, base_channels * 8, 1, 1)
    53.             self.conv_1x1_feat3 = Conv(feat3_c, base_channels * 16, 1, 1)
    54.             
    55.         self.upsample   = nn.Upsample(scale_factor=2, mode="nearest")
    56.  
    57.         self.conv_for_feat3         = Conv(base_channels * 16, base_channels * 8, 1, 1)
    58.         self.conv3_for_upsample1    = C3(base_channels * 16, base_channels * 8, base_depth, shortcut=False)
    59.  
    60.         self.conv_for_feat2         = Conv(base_channels * 8, base_channels * 4, 1, 1)
    61.         self.conv3_for_upsample2    = C3(base_channels * 8, base_channels * 4, base_depth, shortcut=False)
    62.  
    63.         self.down_sample1           = Conv(base_channels * 4, base_channels * 4, 3, 2)
    64.         self.conv3_for_downsample1  = C3(base_channels * 8, base_channels * 8, base_depth, shortcut=False)
    65.  
    66.         self.down_sample2           = Conv(base_channels * 8, base_channels * 8, 3, 2)
    67.         self.conv3_for_downsample2  = C3(base_channels * 16, base_channels * 16, base_depth, shortcut=False)
    68.  
    69.         # 80, 80, 256 => 80, 80, 3 * (5 + num_classes) => 80, 80, 3 * (4 + 1 + num_classes)
    70.         self.yolo_head_P3 = nn.Conv2d(base_channels * 4, len(anchors_mask[2]) * (5 + num_classes), 1)
    71.         # 40, 40, 512 => 40, 40, 3 * (5 + num_classes) => 40, 40, 3 * (4 + 1 + num_classes)
    72.         self.yolo_head_P4 = nn.Conv2d(base_channels * 8, len(anchors_mask[1]) * (5 + num_classes), 1)
    73.         # 20, 20, 1024 => 20, 20, 3 * (5 + num_classes) => 20, 20, 3 * (4 + 1 + num_classes)
    74.         self.yolo_head_P5 = nn.Conv2d(base_channels * 16, len(anchors_mask[0]) * (5 + num_classes), 1)
    75.  
    76.     def forward(self, x):
    77.         #  backbone
    78.         feat1, feat2, feat3 = self.backbone(x)
    79.         if self.backbone_name != "cspdarknet":
    80.             feat1 = self.conv_1x1_feat1(feat1)
    81.             feat2 = self.conv_1x1_feat2(feat2)
    82.             feat3 = self.conv_1x1_feat3(feat3)
    83.  
    84.         # 20, 20, 1024 -> 20, 20, 512
    85.         P5          = self.conv_for_feat3(feat3)
    86.         # 20, 20, 512 -> 40, 40, 512
    87.         P5_upsample = self.upsample(P5)
    88.         # 40, 40, 512 -> 40, 40, 1024
    89.         P4          = torch.cat([P5_upsample, feat2], 1)
    90.         # 40, 40, 1024 -> 40, 40, 512
    91.         P4          = self.conv3_for_upsample1(P4)
    92.  
    93.         # 40, 40, 512 -> 40, 40, 256
    94.         P4          = self.conv_for_feat2(P4)
    95.         # 40, 40, 256 -> 80, 80, 256
    96.         P4_upsample = self.upsample(P4)
    97.         # 80, 80, 256 cat 80, 80, 256 -> 80, 80, 512
    98.         P3          = torch.cat([P4_upsample, feat1], 1)
    99.         # 80, 80, 512 -> 80, 80, 256
    100.         P3          = self.conv3_for_upsample2(P3)
    101.         
    102.         # 80, 80, 256 -> 40, 40, 256
    103.         P3_downsample = self.down_sample1(P3)
    104.         # 40, 40, 256 cat 40, 40, 256 -> 40, 40, 512
    105.         P4 = torch.cat([P3_downsample, P4], 1)
    106.         # 40, 40, 512 -> 40, 40, 512
    107.         P4 = self.conv3_for_downsample1(P4)
    108.  
    109.         # 40, 40, 512 -> 20, 20, 512
    110.         P4_downsample = self.down_sample2(P4)
    111.         # 20, 20, 512 cat 20, 20, 512 -> 20, 20, 1024
    112.         P5 = torch.cat([P4_downsample, P5], 1)
    113.         # 20, 20, 1024 -> 20, 20, 1024
    114.         P5 = self.conv3_for_downsample2(P5)
    115.  
    116.         #---------------------------------------------------#
    117.         #   第三个特征层
    118.         #   y3=(batch_size,75,80,80)
    119.         #---------------------------------------------------#
    120.         out2 = self.yolo_head_P3(P3)
    121.         #---------------------------------------------------#
    122.         #   第二个特征层
    123.         #   y2=(batch_size,75,40,40)
    124.         #---------------------------------------------------#
    125.         out1 = self.yolo_head_P4(P4)
    126.         #---------------------------------------------------#
    127.         #   第一个特征层
    128.         #   y1=(batch_size,75,20,20)
    129.         #---------------------------------------------------#
    130.         out0 = self.yolo_head_P5(P5)
    131.         return out0, out1, out2
    132.

     利用YOLO HEAD获得预测结果

     利用FPN特征金字塔，我们可以获得三个加强特征，这三个加强特征的shape分别为(20,20,1024)、(40,40,512)、(80,80,256)，然后我们利用这三个shape的特征层传入Yolo Head获得预测结果。

    对于每一个特征层，我们可以获得利用一个卷积调整通道数，最终的通道数和需要区分的种类个数相关，在YoloV5里，每一个特征层上每一个特征点存在3个先验框。

    head非常简单是三个1x1的卷积核，我们只需了解输出通道的含义即可，意思就是预测框的大小和位置，以及框内是否有物体，物体的种类是什么。

    1.         # 80, 80, 256 => 80, 80, 3 * (5 + num_classes) => 80, 80, 3 * (4 + 1 + num_classes)
    2.         #3:每个点包含3个预测框，4:x,y,w,h四个参数，1:物体是否包含在框内，num_classes:物品种类
    3.         self.yolo_head_P3 = nn.Conv2d(base_channels * 4, len(anchors_mask[2]) * (5 + num_classes), 1)
    4.         # 40, 40, 512 => 40, 40, 3 * (5 + num_classes) => 40, 40, 3 * (4 + 1 + num_classes)
    5.         self.yolo_head_P4 = nn.Conv2d(base_channels * 8, len(anchors_mask[1]) * (5 + num_classes), 1)
    6.         # 20, 20, 1024 => 20, 20, 3 * (5 + num_classes) => 20, 20, 3 * (4 + 1 + num_classes)
    7.         self.yolo_head_P5 = nn.Conv2d(base_channels * 16, len(anchors_mask[0]) * (5 + num_classes), 1)

     yolov5的解码过程

    • 文件位置：utils/utils_bbox.py
    • 目的：将预测值的每个特征层调成真实值
    • 输入：input尺寸：batch_size, 3 * (4 + 1 + num_classes), 20, 20
    • 20x20 特征层的步长计算：
      • 输入图片为640x640时
      • input_shape = [640, 640] input_height = 20, input_width = 20 ，640 / 20 = 32
      • stride_h = stride_w = 32
      • 高和宽的步长都是32，相当于压缩成原来的1/32
    • 此时获得相对于特征层大小的scaled_anchors（先验框） 
      anchor_width, anchor_height / stride_h, stride_w
    • 对input进行reshape，以便于更好操作 
      • #   batch_size, 3 * (4 + 1 + num_classes), 20, 20 => 
#   batch_size, 3, 5 + num_classes, 20, 20  => 
#   batch_size, 3, 20, 20, 4 + 1 + num_classes
    • 接着调整先验框的参数 x,y,w,h，并获得置信度
    • 生成网格、
    • 利用预测结果对先验框进行调整 
      #   首先调整先验框的中心，从先验框中心向右下角偏移
#   再调整先验框的宽高。
#   x  0 ~ 1 => 0 ~ 2 => -0.5 ~ 1.5 + grid_x
#   y  0 ~ 1 => 0 ~ 2 => -0.5 ~ 1.5 + grid_y
#   w  0 ~ 1 => 0 ~ 2 => 0 ~ 4 * anchor_w
#   h  0 ~ 1 => 0 ~ 2 => 0 ~ 4 * anchor_h
    • 如图所示，蓝色的点为20x20的特征点，此时我们对左图黑色点的三个先验框进行解码操作演示：
      1、进行中心预测点的计算，利用Regression预测结果前两个序号的内容对特征点的三个先验框中心坐标进行偏移，偏移后是右图红色的三个点；
      2、进行预测框宽高的计算，利用Regression预测结果后两个序号的内容求指数后获得预测框的宽高；
      3、此时获得的预测框就可以绘制在图片上了。
       

     除去这样的解码操作，还有非极大抑制的操作需要进行，防止同一种类的框的堆积。

    1.  #---------------------------------------------------#
    2.     #   将预测值的每个特征层调成真实值
    3.     #---------------------------------------------------#
    4.     def get_anchors_and_decode(input, input_shape, anchors, anchors_mask, num_classes):
    5.         #-----------------------------------------------#
    6.         #   input   batch_size, 3 * (4 + 1 + num_classes), 20, 20
    7.         #-----------------------------------------------#
    8.         batch_size      = input.size(0)
    9.         input_height    = input.size(2)
    10.         input_width     = input.size(3)
    11.  
    12.         #-----------------------------------------------#
    13.         #   输入为640x640时 input_shape = [640, 640]  input_height = 20, input_width = 20
    14.         #   640 / 20 = 32
    15.         #   stride_h = stride_w = 32
    16.         #-----------------------------------------------#
    17.         stride_h = input_shape[0] / input_height
    18.         stride_w = input_shape[1] / input_width
    19.         #-------------------------------------------------#
    20.         #   此时获得的scaled_anchors大小是相对于特征层的
    21.         #   anchor_width, anchor_height / stride_h, stride_w
    22.         #-------------------------------------------------#
    23.         scaled_anchors = [(anchor_width / stride_w, anchor_height / stride_h) for anchor_width, anchor_height in anchors[anchors_mask[2]]]
    24.  
    25.         #-----------------------------------------------#
    26.         #   batch_size, 3 * (4 + 1 + num_classes), 20, 20 => 
    27.         #   batch_size, 3, 5 + num_classes, 20, 20  => 
    28.         #   batch_size, 3, 20, 20, 4 + 1 + num_classes
    29.         #-----------------------------------------------#
    30.         prediction = input.view(batch_size, len(anchors_mask[2]),
    31.                                 num_classes + 5, input_height, input_width).permute(0, 1, 3, 4, 2).contiguous()
    32.  
    33.         #-----------------------------------------------#
    34.         #   先验框的中心位置的调整参数
    35.         #-----------------------------------------------#
    36.         x = torch.sigmoid(prediction[..., 0])  
    37.         y = torch.sigmoid(prediction[..., 1])
    38.         #-----------------------------------------------#
    39.         #   先验框的宽高调整参数
    40.         #-----------------------------------------------#
    41.         w = torch.sigmoid(prediction[..., 2]) 
    42.         h = torch.sigmoid(prediction[..., 3]) 
    43.         #-----------------------------------------------#
    44.         #   获得置信度，是否有物体 0 - 1
    45.         #-----------------------------------------------#
    46.         conf        = torch.sigmoid(prediction[..., 4])
    47.         #-----------------------------------------------#
    48.         #   种类置信度 0 - 1
    49.         #-----------------------------------------------#
    50.         pred_cls    = torch.sigmoid(prediction[..., 5:])
    51.  
    52.         FloatTensor = torch.cuda.FloatTensor if x.is_cuda else torch.FloatTensor
    53.         LongTensor  = torch.cuda.LongTensor if x.is_cuda else torch.LongTensor
    54.  
    55.         #----------------------------------------------------------#
    56.         #   生成网格，先验框中心，网格左上角 
    57.         #   batch_size,3,20,20
    58.         #   range(20)
    59.         #   [
    60.         #       [0, 1, 2, 3 ……, 19], 
    61.         #       [0, 1, 2, 3 ……, 19], 
    62.         #       …… （20次）
    63.         #       [0, 1, 2, 3 ……, 19]
    64.         #   ] * (batch_size * 3)
    65.         #   [batch_size, 3, 20, 20]
    66.         #   
    67.         #   [
    68.         #       [0, 1, 2, 3 ……, 19], 
    69.         #       [0, 1, 2, 3 ……, 19], 
    70.         #       …… （20次）
    71.         #       [0, 1, 2, 3 ……, 19]
    72.         #   ].T * (batch_size * 3)
    73.         #   [batch_size, 3, 20, 20]
    74.         #----------------------------------------------------------#
    75.         grid_x = torch.linspace(0, input_width - 1, input_width).repeat(input_height, 1).repeat(
    76.             batch_size * len(anchors_mask[2]), 1, 1).view(x.shape).type(FloatTensor)
    77.         grid_y = torch.linspace(0, input_height - 1, input_height).repeat(input_width, 1).t().repeat(
    78.             batch_size * len(anchors_mask[2]), 1, 1).view(y.shape).type(FloatTensor)
    79.  
    80.         #----------------------------------------------------------#
    81.         #   按照网格格式生成先验框的宽高
    82.         #   batch_size, 3, 20 * 20 => batch_size, 3, 20, 20
    83.         #   batch_size, 3, 20 * 20 => batch_size, 3, 20, 20
    84.         #----------------------------------------------------------#
    85.         anchor_w = FloatTensor(scaled_anchors).index_select(1, LongTensor([0]))
    86.         anchor_h = FloatTensor(scaled_anchors).index_select(1, LongTensor([1]))
    87.         anchor_w = anchor_w.repeat(batch_size, 1).repeat(1, 1, input_height * input_width).view(w.shape)
    88.         anchor_h = anchor_h.repeat(batch_size, 1).repeat(1, 1, input_height * input_width).view(h.shape)
    89.  
    90.         #----------------------------------------------------------#
    91.         #   利用预测结果对先验框进行调整
    92.         #   首先调整先验框的中心，从先验框中心向右下角偏移
    93.         #   再调整先验框的宽高。
    94.         #   x  0 ~ 1 => 0 ~ 2 => -0.5 ~ 1.5 + grid_x
    95.         #   y  0 ~ 1 => 0 ~ 2 => -0.5 ~ 1.5 + grid_y
    96.         #   w  0 ~ 1 => 0 ~ 2 => 0 ~ 4 * anchor_w
    97.         #   h  0 ~ 1 => 0 ~ 2 => 0 ~ 4 * anchor_h 
    98.         #----------------------------------------------------------#
    99.         pred_boxes          = FloatTensor(prediction[..., :4].shape)
    100.         pred_boxes[..., 0]  = x.data * 2. - 0.5 + grid_x
    101.         pred_boxes[..., 1]  = y.data * 2. - 0.5 + grid_y
    102.         pred_boxes[..., 2]  = (w.data * 2) ** 2 * anchor_w
    103.         pred_boxes[..., 3]  = (h.data * 2) ** 2 * anchor_h

    预测过程

    首先对图像进行一些处理，然后将图像输入网络进行预测，调用上方的解码过程。

    将预测框进行堆叠，进行非极大抑制

    1.     #---------------------------------------------------#
    2.     #   检测图片
    3.     #---------------------------------------------------#
    4.     def detect_image(self, image, crop = False, count = False):
    5.         #---------------------------------------------------#
    6.         #   计算输入图片的高和宽
    7.         #---------------------------------------------------#
    8.         image_shape = np.array(np.shape(image)[0:2])
    9.         #---------------------------------------------------------#
    10.         #   在这里将图像转换成RGB图像，防止灰度图在预测时报错。
    11.         #   代码仅仅支持RGB图像的预测，所有其它类型的图像都会转化成RGB
    12.         #---------------------------------------------------------#
    13.         image       = cvtColor(image)
    14.         #---------------------------------------------------------#
    15.         #   给图像增加灰条，实现不失真的resize
    16.         #   也可以直接resize进行识别
    17.         #---------------------------------------------------------#
    18.         image_data  = resize_image(image, (self.input_shape[1], self.input_shape[0]), self.letterbox_image)
    19.         #---------------------------------------------------------#
    20.         #   添加上batch_size维度
    21.         #---------------------------------------------------------#
    22.         image_data  = np.expand_dims(np.transpose(preprocess_input(np.array(image_data, dtype='float32')), (2, 0, 1)), 0)
    23.         with torch.no_grad():
    24.             images = torch.from_numpy(image_data)
    25.             if self.cuda:
    26.                 images = images.cuda()
    27.             #---------------------------------------------------------#
    28.             #   将图像输入网络当中进行预测！
    29.             #---------------------------------------------------------#
    30.             outputs = self.net(images)
    31.             outputs = self.bbox_util.decode_box(outputs)
    32.             #---------------------------------------------------------#
    33.             #   将预测框进行堆叠，然后进行非极大抑制
    34.             #---------------------------------------------------------#
    35.             results = self.bbox_util.non_max_suppression(torch.cat(outputs, 1), self.num_classes, self.input_shape, 
    36.                         image_shape, self.letterbox_image, conf_thres = self.confidence, nms_thres = self.nms_iou)
    37.                                                     
    38.             if results[0] is None: 
    39.                 return image
    40.  
    41.             top_label   = np.array(results[0][:, 6], dtype = 'int32')
    42.             top_conf    = results[0][:, 4] * results[0][:, 5]
    43.             top_boxes   = results[0][:, :4]

    非极大抑制

    得到最终的预测结果后还要进行得分排序与非极大抑制筛选。

    得分筛选就是筛选出得分满足confidence置信度的预测框。
    非极大抑制就是筛选出一定区域内属于同一种类得分最大的框。

    得分筛选与非极大抑制的过程可以概括如下：
    1、找出该图片中得分大于门限函数的框。在进行重合框筛选前就进行得分的筛选可以大幅度减少框的数量。
    2、对种类进行循环，非极大抑制的作用是筛选出一定区域内属于同一种类得分最大的框，对种类进行循环可以帮助我们对每一个类分别进行非极大抑制。
    3、根据得分对该种类进行从大到小排序。
    4、每次取出得分最大的框，计算其与其它所有预测框的重合程度，重合程度过大的则剔除。

    得分筛选与非极大抑制后的结果就可以用于绘制预测框了。

    下图是经过非极大抑制的。

    下图是未经过非极大抑制的。

    1.     def non_max_suppression(self, prediction, num_classes, input_shape, image_shape, letterbox_image, conf_thres=0.5, nms_thres=0.4):
    2.         #----------------------------------------------------------#
    3.         #   将预测结果的格式转换成左上角右下角的格式。
    4.         #   prediction  [batch_size, num_anchors, 85]
    5.         #----------------------------------------------------------#
    6.         box_corner          = prediction.new(prediction.shape)
    7.         box_corner[:, :, 0] = prediction[:, :, 0] - prediction[:, :, 2] / 2
    8.         box_corner[:, :, 1] = prediction[:, :, 1] - prediction[:, :, 3] / 2
    9.         box_corner[:, :, 2] = prediction[:, :, 0] + prediction[:, :, 2] / 2
    10.         box_corner[:, :, 3] = prediction[:, :, 1] + prediction[:, :, 3] / 2
    11.         prediction[:, :, :4] = box_corner[:, :, :4]
    12.  
    13.         output = [None for _ in range(len(prediction))]
    14.         for i, image_pred in enumerate(prediction):
    15.             #----------------------------------------------------------#
    16.             #   对种类预测部分取max。
    17.             #   class_conf  [num_anchors, 1]    种类置信度
    18.             #   class_pred  [num_anchors, 1]    种类
    19.             #----------------------------------------------------------#
    20.             class_conf, class_pred = torch.max(image_pred[:, 5:5 + num_classes], 1, keepdim=True)
    21.  
    22.             #----------------------------------------------------------#
    23.             #   利用置信度进行第一轮筛选
    24.             #----------------------------------------------------------#
    25.             conf_mask = (image_pred[:, 4] * class_conf[:, 0] >= conf_thres).squeeze()
    26.  
    27.             #----------------------------------------------------------#
    28.             #   根据置信度进行预测结果的筛选
    29.             #----------------------------------------------------------#
    30.             image_pred = image_pred[conf_mask]
    31.             class_conf = class_conf[conf_mask]
    32.             class_pred = class_pred[conf_mask]
    33.             if not image_pred.size(0):
    34.                 continue
    35.             #-------------------------------------------------------------------------#
    36.             #   detections  [num_anchors, 7]
    37.             #   7的内容为：x1, y1, x2, y2, obj_conf, class_conf, class_pred
    38.             #-------------------------------------------------------------------------#
    39.             detections = torch.cat((image_pred[:, :5], class_conf.float(), class_pred.float()), 1)
    40.  
    41.             #------------------------------------------#
    42.             #   获得预测结果中包含的所有种类
    43.             #------------------------------------------#
    44.             unique_labels = detections[:, -1].cpu().unique()
    45.  
    46.             if prediction.is_cuda:
    47.                 unique_labels = unique_labels.cuda()
    48.                 detections = detections.cuda()
    49.  
    50.             for c in unique_labels:
    51.                 #------------------------------------------#
    52.                 #   获得某一类得分筛选后全部的预测结果
    53.                 #------------------------------------------#
    54.                 detections_class = detections[detections[:, -1] == c]
    55.  
    56.                 #------------------------------------------#
    57.                 #   使用官方自带的非极大抑制会速度更快一些！
    58.                 #   筛选出一定区域内，属于同一种类得分最大的框
    59.                 #------------------------------------------#
    60.                 keep = nms(
    61.                     detections_class[:, :4],
    62.                     detections_class[:, 4] * detections_class[:, 5],
    63.                     nms_thres
    64.                 )
    65.                 max_detections = detections_class[keep]
    66.                 
    67.                 # # 按照存在物体的置信度排序
    68.                 # _, conf_sort_index = torch.sort(detections_class[:, 4]*detections_class[:, 5], descending=True)
    69.                 # detections_class = detections_class[conf_sort_index]
    70.                 # # 进行非极大抑制
    71.                 # max_detections = []
    72.                 # while detections_class.size(0):
    73.                 #     # 取出这一类置信度最高的，一步一步往下判断，判断重合程度是否大于nms_thres，如果是则去除掉
    74.                 #     max_detections.append(detections_class[0].unsqueeze(0))
    75.                 #     if len(detections_class) == 1:
    76.                 #         break
    77.                 #     ious = bbox_iou(max_detections[-1], detections_class[1:])
    78.                 #     detections_class = detections_class[1:][ious < nms_thres]
    79.                 # # 堆叠
    80.                 # max_detections = torch.cat(max_detections).data
    81.                 
    82.                 # Add max detections to outputs
    83.                 output[i] = max_detections if output[i] is None else torch.cat((output[i], max_detections))
    84.             
    85.             if output[i] is not None:
    86.                 output[i]           = output[i].cpu().numpy()
    87.                 box_xy, box_wh      = (output[i][:, 0:2] + output[i][:, 2:4])/2, output[i][:, 2:4] - output[i][:, 0:2]
    88.                 output[i][:, :4]    = self.yolo_correct_boxes(box_xy, box_wh, input_shape, image_shape, letterbox_image)
    89.         return output
  • 相关阅读:
    C++STL详解（六）unordered_set&unordered_map介绍
    https和http的区别和优势
    vue3 为什么快, 相对于vue2 做了那些优化
    寄件管理解决教程
    低代码PaaS开发平台
    Smartbi携手某证券公司成功打造数据文化体系
    股票价格预测项目
    Java练习 day6
    Git基本操作
    绘图问题记录
  • 原文地址：https://blog.csdn.net/LarsGyonX/article/details/126349300