YOLOV7学习记录之原理+代码介绍

Posted 2022-12-16 彭祥.

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了YOLOV7学习记录之原理+代码介绍相关的知识，希望对你有一定的参考价值。

博主计划做一个目标检测跟踪项目，考虑使用YOLO系列模型来作为目标检测器，如今YOLO项目已经更新到了YOLOV7版本，因此便来学习一下相关原理，完成相关实验工作。

论文链接：https://arxiv.org/abs/2207.02696

网络结构

YOLOv7是 YOLO 系列最新推出的YOLO 结构，在 5 帧/秒到 160 帧/秒范围内，其速度和精度都超过了大部分已知的目标检测器，在 GPU V100 已知的 30 帧/秒以上的实时目标检测器中，YOLOv7 的准确率最高。根据代码运行环境的不同(边缘 GPU、普通 GPU 和云 GPU)，YOLOv7 设置了三种基本模型，分别称为 YOLOv7-tiny、YOLOv7和 YOLOv7-W6。相比于 YOLO 系列其他网络模型，YOLOv7 的检测思路与YOLOv4、YOLOv5相似，其网络架构如图所示。

更详细的模型结构：

工作流程

YOLOv7 网络主要包含了 Input(输入)、Backbone(骨干网络)、Neck(颈部)、Head(头部)这四个部分。首先，图片经过输入部分数据增强等一系列操作进行预处理后，被送入主干网，主干网部分对处理后的图片提取特征；随后，提取到的特征经过 Neck 模块特征融合处理得到大、中、小三种尺寸的特
征；最终，融合后的特征被送入检测头，经过检测之后输出得到结果。

BackBone

YOLOv7 网络模型的主干网部分主要由卷积、E-ELAN 模块、MPConv 模块以及SPPCSPC 模块构建而成。其中，E-ELAN(Extended-ELAN) 模块，在原始ELAN 的基础上，改变计算块的同时保持原ELAN 的过渡层构，利用 expand、shuffle、merge cardinality 的思想来实现在不破坏原有梯度路径的情况下增强网络学习的能力。SPPCSPC 模块，在一串卷积中加入并行的多次 MaxPool 操作，避免了由于图像处理操作所造成的图像失真等问题，同时解决了卷积神经网络提取到图片重复特征的难题。MPConv 模块中，MaxPool 操作将当前特征层的感受野进行扩张再与正常卷积处理后的特征信息进行融合，提高了网络的泛化性。

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

Neck:FPN+PAN结构

FPN 特征金字塔(Feature Pyramid Network)

PANet结构

FPN与PANet详解
在 Neck 模块，YOLOv7 与 YOLOv5 网络相同，也采用了传统的 PAFPN 结构。FPN是YoloV7的加强特征提取网络，在主干部分获得的三个有效特征层会在这一部分进行特征融合，特征融合的目的是结合不同尺度的特征信息。在FPN部分，已经获得的有效特征层被用于继续提取特征。在YoloV7里依然使用到了Panet的结构，我们不仅会对特征进行上采样实现特征融合，还会对特征再次进行下采样实现特征融合。

Head

检测头部分，本文的基线 YOLOv7 选用了表示大、中、小三种目标尺寸的 IDetect 检测头，RepConv 模块在训练和推理时结构具有一定的区别。具体可以参考RepVGG中的构造，其引入了结构重参数化的思想

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

BackBone(代码实现）

1.多分支堆叠模块（ELAN）

文中起名ELAN，博主觉得叫多分支堆叠模块更好，只是个人理解而已
其结构如下图所示：是不是型如其名
ELAN模块是一个高效的网络结构，它通过控制最短和最长的梯度路径，使网络能够学习到更多的特征，并且具有更强的鲁棒性。
ELAN有两条分支。
第一条分支是经过一个1x1的卷积做通道数的变化。
第二条分支就比较复杂了。它先首先经过一个1x1的卷积模块，做通道数的变化。然后再经过四个3x3的卷积模块，做特征提取。
如图所示，最后把四个特征叠加在一起得到最后的特征提取结果。

这里引入了残次结构的思想，经过多个卷积+批归一化+激活函数堆叠构成。
backbone.py

分支堆叠结合

class Multi_Concat_Block(nn.Module):
    def __init__(self, c1, c2, c3, n=4, e=1, ids=[0]):
        super(Multi_Concat_Block, self).__init__()
        c_ = int(c2 * e)        
        self.ids = ids
        self.cv1 = Conv(c1, c_, 1, 1)
        self.cv2 = Conv(c1, c_, 1, 1)
        self.cv3 = nn.ModuleList(
            [Conv(c_ if i ==0 else c2, c2, 3, 1) for i in range(n)]
        )
        self.cv4 = Conv(c_ * 2 + c2 * (len(ids) - 2), c3, 1, 1)
    def forward(self, x):
        x_1 = self.cv1(x)
        x_2 = self.cv2(x)      
        x_all = [x_1, x_2]
        for i in range(len(self.cv3)):
            x_2 = self.cv3[i](x_2)
            x_all.append(x_2)           
        out = self.cv4(torch.cat([x_all[id] for id in self.ids], 1))
        return out

如此多的堆叠其实也对应了更密集的残差结构，残差网络的特点是容易优化，并且能够通过增加相当的深度来提高准确率。其内部的残差块使用了跳跃连接，缓解了在深度神经网络中增加深度带来的梯度消失问题。

卷积+批归一化+激活函数（CBS模块）

对于CBS模块，我们可以看从图中可以看出它是由一个Conv层，也就是卷积层，一个BN层，也就是Batch normalization层，还有一个Silu层，这是一个激活函数。
silu激活函数是swish激活函数的变体，两者的公式如下所示
silu(x)=x⋅sigmoid(x)
swish(x)=x⋅sigmoid(βx)

从架构图中我们可以看出，CBS模块这里有三种颜色，三种颜色代表它们的卷积核（k）和步长(s)不同。
首先最浅的颜色，也就是第一个CBS模块的颜色，它是一个1x1的卷积，stride(步长为1)。
其次稍浅的颜色，也就是第二个CBS模块的颜色，它是一个3x3的卷积，stride(步长为1)。
最后最深的颜色，也就是第三个CBS模块的颜色，它是一个3x3的卷积，stride(步长为2)。
1x1的卷积主要用来改变通道数。
3x3的卷积，步长为1，主要用来特征提取。
3x3的卷积，步长为2，主要用来下采样。
代码如下：

class Conv(nn.Module):
    def __init__(self, c1, c2, k=1, s=1, p=None, g=1, act=SiLU()):  # ch_in, ch_out, kernel, stride, padding, groups
        super(Conv, self).__init__()
        self.conv   = nn.Conv2d(c1, c2, k, s, autopad(k, p), groups=g, bias=False)
        self.bn     = nn.BatchNorm2d(c2, eps=0.001, momentum=0.03)
        self.act    = nn.LeakyReLU(0.1, inplace=True) if act is True else (act if isinstance(act, nn.Module) else nn.Identity())
    def forward(self, x):
        return self.act(self.bn(self.conv(x)))
    def fuseforward(self, x):
        return self.act(self.conv(x))

2.Transition_Block（完成下采样）

使用创新的过渡模块Transition_Block来进行下采样，在卷积神经网络中，常见的用于下采样的过渡模块是一个卷积核大小为3x3、步长为2x2的卷积或者一个步长为2x2的最大池化。在YoloV7中，作者将两种过渡模块进行了集合，一个过渡模块存在两个分支，如图所示。左分支是一个步长为2x2的最大池化+一个1x1卷积，右分支是一个1x1卷积+一个卷积核大小为3x3、步长为2x2的卷积，两个分支的结果在输出时会进行堆叠。

池化

MP模块有两个分支，作用是进行下采样。
第一条分支先经过一个maxpool，也就是最大池化。最大值化的作用就是下采样，然后再经过一个1x1的卷积进行通道数的改变。
第二条分支先经过一个1x1的卷积，做通道数的变化，然后再经过一个3x3卷积核、步长为2的卷积块，这个卷积块也是用来下采样的。
最后把第一个分支和第二分支的结果加在一起，得到了超级下采样的结果。

class MP(nn.Module):
    def __init__(self, k=2):
        super(MP, self).__init__()
        self.m = nn.MaxPool2d(kernel_size=k, stride=k)
    def forward(self, x):
        return self.m(x)

Transition结合

class Transition_Block(nn.Module):
    def __init__(self, c1, c2):
        super(Transition_Block, self).__init__()
        self.cv1 = Conv(c1, c2, 1, 1)
        self.cv2 = Conv(c1, c2, 1, 1)
        self.cv3 = Conv(c2, c2, 3, 2)     
        self.mp  = MP()
    def forward(self, x):
        x_1 = self.mp(x)
        x_1 = self.cv1(x_1）        
        x_2 = self.cv2(x)
        x_2 = self.cv3(x_2)     
        return torch.cat([x_2, x_1], 1)

其他

激活函数

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

主体代码

class Backbone(nn.Module):
    def __init__(self, transition_channels, block_channels, n, phi, pretrained=False):
        super().__init__()
        #-----------------------------------------------#
        #   输入图片是640, 640, 3
        #-----------------------------------------------#
        ids = 
            'l' : [-1, -3, -5, -6],
            'x' : [-1, -3, -5, -7, -8], 
        [phi]
        self.stem = nn.Sequential(
            Conv(3, transition_channels, 3, 1),
            Conv(transition_channels, transition_channels * 2, 3, 2),
            Conv(transition_channels * 2, transition_channels * 2, 3, 1),
        )
        self.dark2 = nn.Sequential(
            Conv(transition_channels * 2, transition_channels * 4, 3, 2),
            Multi_Concat_Block(transition_channels * 4, block_channels * 2, transition_channels * 8, n=n, ids=ids),
        )
        self.dark3 = nn.Sequential(
            Transition_Block(transition_channels * 8, transition_channels * 4),
            Multi_Concat_Block(transition_channels * 8, block_channels * 4, transition_channels * 16, n=n, ids=ids),
        )
        self.dark4 = nn.Sequential(
            Transition_Block(transition_channels * 16, transition_channels * 8),
            Multi_Concat_Block(transition_channels * 16, block_channels * 8, transition_channels * 32, n=n, ids=ids),
        )
        self.dark5 = nn.Sequential(
            Transition_Block(transition_channels * 32, transition_channels * 16),
            Multi_Concat_Block(transition_channels * 32, block_channels * 8, transition_channels * 32, n=n, ids=ids),
        )      
        if pretrained:
            url = 
                "l" : 'https://github.com/bubbliiiing/yolov7-pytorch/releases/download/v1.0/yolov7_backbone_weights.pth',
                "x" : 'https://github.com/bubbliiiing/yolov7-pytorch/releases/download/v1.0/yolov7_x_backbone_weights.pth',
            [phi]
            checkpoint = torch.hub.load_state_dict_from_url(url=url, map_location="cpu", model_dir="./model_data")
            self.load_state_dict(checkpoint, strict=False)
            print("Load weights from " + url.split('/')[-1])

    def forward(self, x):
        x = self.stem(x)
        x = self.dark2(x)
        #-----------------------------------------------#
        #   dark3的输出为80, 80, 256，是一个有效特征层
        #-----------------------------------------------#
        x = self.dark3(x)
        feat1 = x
        #-----------------------------------------------#
        #   dark4的输出为40, 40, 512，是一个有效特征层
        #-----------------------------------------------#
        x = self.dark4(x)
        feat2 = x
        #-----------------------------------------------#
        #   dark5的输出为20, 20, 1024，是一个有效特征层
        #-----------------------------------------------#
        x = self.dark5(x)
        feat3 = x
        return feat1, feat2, feat3

FPN强特征融合

在特征利用部分，YoloV7提取多特征层进行目标检测，一共提取三个特征层。
三个特征层位于主干部分的不同位置，分别位于中间层，中下层，底层，当输入为(640,640,3)的时候，三个特征层的shape分别为feat1=(80,80,512)、feat2=(40,40,1024)、feat3=(20,20,1024)
在获得三个有效特征层后，我们利用这三个有效特征层进行FPN层的构建，构建方式为（在本博文中，将SPPCSPC结构归于FPN中）：

1.feature3=(20,20,1024)的特征层首先利用SPPCSPC进行特征提取，该结构可以提高YoloV7的感受野，获得P5。
2,对P5先进行1次1X1卷积调整通道，然后进行上采样UmSampling2d后与feature2=(40,40,1024)进行一次卷积后的特征层进行结合，然后使用Multi_Concat_Block进行特征提取获得P4，此时获得的特征层为(40,40,256)。
3.对P4先进行1次1X1卷积调整通道，然后进行上采样UmSampling2d后与feature1=(80,80,512)进行一次卷积后的特征层进行结合，然后使用Multi_Concat_Block进行特征提取获得P3_out，此时获得的特征层为(80,80,128)。
4.P3_out=(80,80,128)的特征层进行一次Transition_Block卷积进行下采样，下采样后与P4堆叠，然后使用Multi_Concat_Block进行特征提取P4_out，此时获得的特征层为(40,40,256)。
5.P4_out=(40,40,256)的特征层进行一次Transition_Block卷积进行下采样，下采样后与P5堆叠，然后使用Multi_Concat_Block进行特征提取P5_out，此时获得的特征层为(20,20,512)。

特征金字塔可以将不同shape的特征层进行特征融合，有利于提取出更好的特征。
yolo.py

SPPCSPC块

class SPPCSPC(nn.Module):
    # CSP https://github.com/WongKinYiu/CrossStagePartialNetworks
    def __init__(self, c1, c2, n=1, shortcut=False, g=1, e=0.5, k=(5, 9, 13)):
        super(SPPCSPC, self).__init__()
        c_ = int(2 * c2 * e)  # hidden channels
        self.cv1 = Conv(c1, c_, 1, 1)
        self.cv2 = Conv(c1, c_, 1, 1)
        self.cv3 = Conv(c_, c_, 3, 1)
        self.cv4 = Conv(c_, c_, 1, 1)
        self.m = nn.ModuleList([nn.MaxPool2d(kernel_size=x, stride=1, padding=x // 2) for x in k])
        self.cv5 = Conv(4 * c_, c_, 1, 1)
        self.cv6 = Conv(c_, c_, 3, 1)
        self.cv7 = Conv(2 * c_, c2, 1, 1)

    def forward(self, x):
        x1 = self.cv4(self.cv3(self.cv1(x)))
        y1 = self.cv6(self.cv5(torch.cat([x1] + [m(x1) for m in self.m], 1)))
        y2 = self.cv2(x)
        return self.cv7(torch.cat((y1, y2), dim=1))

Neck块

class YoloBody(nn.Module):
    def __init__(self, anchors_mask, num_classes, phi, pretrained=False):
        super(YoloBody, self).__init__()
        #-----------------------------------------------#
        #   定义了不同yolov7版本的参数
        #-----------------------------------------------#
        transition_channels = 'l' : 32, 'x' : 40[phi]
        block_channels      = 32
        panet_channels      = 'l' : 32, 'x' : 64[phi]
        e       = 'l' : 2, 'x' : 1[phi]
        n       = 'l' : 4, 'x' : 6[phi]
        ids     = 'l' : [-1, -2, -3, -4, -5, -6], 'x' : [-1, -3, -5, -7, -8][phi]
        conv    = 'l' : RepConv, 'x' : Conv[phi]
        #-----------------------------------------------#
        #   输入图片是640, 640, 3
        #-----------------------------------------------#

        #---------------------------------------------------#   
        #   生成主干模型
        #   获得三个有效特征层，他们的shape分别是：
        #   80, 80, 512
        #   40, 40, 1024
        #   20, 20, 1024
        #---------------------------------------------------#
        self.backbone   = Backbone(transition_channels, block_channels, n, phi, pretrained=pretrained)

        self.upsample   = nn.Upsample(scale_factor=2, mode="nearest")

        self.sppcspc                = SPPCSPC(transition_channels * 32, transition_channels * 16)
        self.conv_for_P5            = Conv(transition_channels * 16, transition_channels * 8)
        self.conv_for_feat2         = Conv(transition_channels * 32, transition_channels * 8)
        self.conv3_for_upsample1    = Multi_Concat_Block(transition_channels * 16, panet_channels * 4, transition_channels * 8, e=e, n=n, ids=ids)

        self.conv_for_P4            = Conv(transition_channels * 8, transition_channels * 4)
        self.conv_for_feat1         = Conv(transition_channels * 16, transition_channels * 4)
        self.conv3_for_upsample2    = Multi_Concat_Block(transition_channels * 8, panet_channels * 2, transition_channels * 4, e=e, n=n, ids=ids)

        self.down_sample1           = Transition_Block(transition_channels * 4, transition_channels * 4)
        self.conv3_for_downsample1  =以上是关于YOLOV7学习记录之原理+代码介绍的主要内容，如果未能解决你的问题，请参考以下文章 
 YOLOV7学习记录之训练过程
 睿智的目标检测60——Pytorch搭建YoloV7目标检测平台
 YOLOV7学习记录之mAP计算
 睿智的目标检测——Pytorch搭建YoloV7-OBB旋转目标检测平台
 Unity学习笔记 之 发射小球碰撞物体的代码记录
 YoloV7实战：手把手教你使用Yolov7进行物体检测（附数据集）