YOLOv1——v5学习笔记

转载链接

一、前言

YOLO系列是one-stage且是基于深度学习的回归方法，而R-CNN、Fast-RCNN、Faster-RCNN等是two-stage且是基于深度学习的分类方法。

YOLO官网：https://github.com/pjreddie/darknet

1.1 YOLO vs Faster R-CNN

1、统一网络：YOLO没有显示求取region proposal的过程。Faster R-CNN中尽管RPN与fast rcnn共享卷积层，但是在模型训练过程中，需要反复训练RPN网络和fast rcnn网络。相对于R-CNN系列的"看两眼"(候选框提取与分类)，YOLO只需要Look Once.

2、YOLO统一为一个回归问题，而Faster R-CNN将检测结果分为两部分求解：物体类别（分类问题）、物体位置即bounding box（回归问题）。

二、YOLOv1

论文地址：https://arxiv.org/abs/1506.02640

官方代码：https://github.com/pjreddie/darknet

YOLOv1的核心思想：

• YOLOv1的核心思想就是利用整张图作为网络的输入，直接在输出层回归bounding box的位置和bounding box所属的类别。
• Faster RCNN中也直接用整张图作为输入，但是Faster-RCNN整体还是采用了RCNN那种 proposal+classifier的思想，只不过是将提取proposal的步骤放在CNN中实现了,而YOLOv1则采用直接回归的思路。

2.1、实现方法

• 将一幅图像分成SxS个网格(grid cell)，如果某个object的中心落在这个网格中，则这个网格就负责预测这个object。

• 每个网格要预测B个bounding box，每个bounding box除了要回归自身的位置之外，还要附带预测一个confidence值。这个confidence代表了所预测的box中含有object的置信度和这个box预测的有多准两重信息，其值是这样计算的：

        该表达式含义：如果有object落在一个grid cell里，则第一项取1，否则取0。 第二项是预测的bounding box和实际的groundtruth之间的IoU值。 

• 每个bounding box要预测(x, y, w, h)和confidence共5个值，每个网格还要预测一个类别信息，记为C类。则SxS个网格，每个网格要预测B个bounding box还要预测C个categories。输出就是S x S x (5*B+C)的一个tensor。

       注意：class信息是针对每个网格的，confidence信息是针对每个bounding box的。

举例说明：

在PASCAL VOC中，图像输入为448x448像素，取S=7，B=2，一共有20个类别(C=20)。则输出就是7x7x(2x5+20)的一个tensor。整个网络结构如下图所示：

• 在test的时候，每个网格预测的class信息和bounding box预测的confidence信息相乘，就得到每个bounding box的class-specific confidence score，得到每个box的class-specific confidence score以后，设置阈值，滤掉得分低的boxes，对保留的boxes进行NMS处理，就得到最终的检测结果。

       该表达式含义：等式左边第一项就是每个网格预测的类别信息，第二三项就是每个bounding box预测的confidence。这个乘积即encode了预测的box属于某一类的概率，也有该box准确度的信息。 

注意：

1. 由于输出层为全连接层，因此在检测时，YOLOv1模型的输入只支持与训练图像相同的输入分辨率。
2. 虽然每个格子可以预测B个bounding box，但是最终只选择IOU最高的bounding box作为物体检测输出，即每个格子最多只预测出一个物体。当物体占画面比例较小，如图像中包含畜群或鸟群时，每个格子包含多个物体，但却只能检测出其中一个。

简单的概括就是：

• 给个一个输入图像，首先将图像划分成7*7的网格；
• 对于每个网格，我们都预测2个边框（包括每个边框是目标的置信度以及每个边框区域在多个类别上的概率）；
• 根据上一步可以预测出7*7*2个目标窗口，然后根据阈值去除可能性比较低的目标窗口，最后NMS去除冗余窗口即可。

2.2、损失函数

每个grid有30维，这30维中，8维是回归box的坐标，2维是box的confidence，还有20维是类别。其中坐标的x,y用对应网格的offset归一化到0-1之间，w,h用图像的width和height归一化到0-1之间。在实现中，最主要的就是怎么设计损失函数，让这个三个方面得到很好的平衡。作者简单粗暴的全部采用了sum-squared error loss来做这件事。

这种做法存在以下几个问题：

• 第一，8维的localization error和20维的classification error同等重要显然是不合理的；
• 第二，如果一个网格中没有object（一幅图中这种网格很多），那么就会将这些网格中的box的confidence push到0，相比于较少的有object的网格，这种做法是overpowering的，这会导致网络不稳定甚至发散。

解决方法：

• 更重视8维的坐标预测，给这些损失前面赋予更大的loss weight；
• 对没有object的box的confidence loss，赋予小的loss weight；
• 有object的box的confidence loss和类别的loss的loss weight正常取1。

YOLOv1在对不同大小的box预测中，相比于大box预测偏一点，小box预测偏一点肯定更不能被忍受的。而sum-square error loss中对同样的偏移loss是一样。为了缓和这个问题，作者用了一个比较取巧的办法，就是将box的width和height取平方根代替原本的height和width。这个参考下面的图很容易理解，小box的横轴值较小，发生偏移时，反应到y轴上相比大box要大。(也是个近似逼近方式)

一个网格预测多个box，希望每个box predictor专门负责预测某个object。具体做法就是看当前预测的box与ground truth box中哪个IoU大，就负责哪个。这种做法称作box predictor的specialization。

在YOLOv1的损失函数中：

• 只有当某个网格中有object的时候才对classification error进行惩罚。
• 只有当某个box predictor对某个ground truth box负责的时候，才会对box的coordinate error进行惩罚，而对哪个ground truth box负责就看其预测值和ground truth box的IoU是不是在那个cell的所有box中最大。

注：

• YOLOv1方法模型训练依赖于物体识别标注数据，因此，对于非常规的物体形状或比例，YOLOv1的检测效果并不理想。
• YOLOv1采用了多个下采样层，网络学到的物体特征并不精细，因此也会影响检测效果。
• YOLOv1的loss函数中，大物体IOU误差和小物体IOU误差对网络训练中loss贡献值接近（虽然采用求平方根方式，但没有根本解决问题）。因此，对于小物体，小的IOU误差也会对网络优化过程造成很大的影响，从而降低了物体检测的定位准确性。

YOLO的缺点

• YOLO对相互靠的很近的物体和很小的群体检测效果不好，这是因为一个网格中只预测了两个框，并且只属于一类；
• 同一类物体出现的新的不常见的长宽比和其他情况时，泛化能力偏弱；
• 由于损失函数的问题，定位误差是影响检测效果的主要原因。尤其是大小物体的处理上，还有待加强。

三、YOLOv2

论文地址：https://arxiv.org/abs/1612.08242

官方代码：http://pjreddie.com/darknet/yolo/

3.1 YOLOv2介绍

YOLOv2相对v1版本，在继续保持处理速度的基础上，从预测更准确（Better），速度更快（Faster），识别对象更多（Stronger）这三个方面进行了改进。其中识别更多对象也就是扩展到能够检测9000种不同对象，称之为YOLO9000。

文章提出了一种新的训练方法–联合训练算法，这种算法可以把这两种的数据集混合到一起。使用一种分层的观点对物体进行分类，用巨量的分类数据集数据来扩充检测数据集，从而把两种不同的数据集混合起来。联合训练算法的基本思路就是：同时在检测数据集和分类数据集上训练物体检测器（Object Detectors ），用检测数据集的数据学习物体的准确位置，用分类数据集的数据来增加分类的类别量、提升健壮性。

YOLO9000就是使用联合训练算法训练出来的，他拥有9000类的分类信息，这些分类信息学习自ImageNet分类数据集，而物体位置检测则学习自COCO检测数据集。

YOLOv1有很多缺点，作者希望改进的方向是:改善recall，提升定位的准确度，同时保持分类的准确度。目前计算机视觉的趋势是更大更深的网络，更好的性能表现通常依赖于训练更大的网络或者把多种model综合到一起，但是YOLOv2则着力于简化网络。具体的改进见下表：

3.2 YOLOv2的改进点

3.2.1 Batch Normalization

批量归一化有助于解决反向传播过程中的梯度消失和梯度爆炸问题，降低对一些超参数（比如学习率、网络参数的大小范围、激活函数的选择）的敏感性，并且每个batch分别进行归一化的时候，起到了一定的正则化效果（YOLOv2不再使用dropout），从而能够获得更好的收敛速度和收敛效果。

使用Batch Normalization对网络进行优化，让网络提高了收敛性，同时还消除了对其他形式的正则化（regularization）的依赖。通过对YOLOv2的每一个卷积层增加Batch Normalization，最终使得mAP提高了2%，同时还使model正则化。使用Batch Normalization可以从model中去掉Dropout，而不会产生过拟合。

关于批规一化的更多信息可以参考：Batch Normalization原理与实战

3.2.2 High resolution classifier

用于图像分类的训练样本很多，而标注了边框的用于训练目标检测的样本相比而言就少了很多，因为标注边框的人工成本比较高。所以目标检测模型通常都先用图像分类样本训练卷积层，提取图像特征，但这引出另一个问题，就是图像分类样本的分辨率不是很高。所以YOLOv1使用ImageNet的图像分类样本采用 224*224 作为输入，来训练CNN卷积层。然后在训练目标检测时，检测用的图像样本采用更高分辨率的 448*448 像素图像作为输入，但这样不一致的输入分辨率肯定会对模型性能有一定影响。

所以YOLOv2在采用 224*224 图像进行分类模型预训练后，再采用 448*448 高分辨率样本对分类模型进行微调（10个epoch），使网络特征逐渐适应 448*448 的分辨率。然后再使用 448*448 的检测样本进行训练，缓解了分辨率突然切换造成的影响，最终通过使用高分辨率，mAP提升了4%。

3.2.3 Convolution with anchor boxes

YOLOv1包含有全连接层，从而能直接预测Bounding Boxes的坐标值。Faster R-CNN算法只用卷积层与Region Proposal Network来预测Anchor Box的偏移值与置信度，而不是直接预测坐标值，YOLOv2作者发现通过预测偏移量而不是坐标值能够简化问题，让神经网络学习起来更容易。

借鉴Faster RCNN的做法，YOLOv2也尝试采用先验框（anchor）。在每个grid预先设定一组不同大小和宽高比的边框，来覆盖整个图像的不同位置和多种尺度，这些先验框作为预定义的候选区在神经网络中将检测其中是否存在对象，以及微调边框的位置。

之前YOLOv1并没有采用先验框，并且每个grid只预测两个bounding box，也就是整个图像只有98个bounding box。YOLOv2如果每个grid采用9个先验框，总共有13*13*9=1521个先验框。所以最终YOLOv2去掉了全连接层，使用Anchor Boxes来预测 Bounding Boxes。作者去掉了网络中一个Pooling层，这让卷积层的输出能有更高的分辨率，同时对网络结构进行收缩让其运行在416*416而不是448*448。

由于图片中的物体都倾向于出现在图片的中心位置，特别是那种比较大的物体，所以有一个单独位于物体中心的位置用于预测这些物体。YOLOv2的卷积层采用32这个值来下采样图片，所以通过选择416*416用作输入尺寸最终能输出一个13*13的Feature Map。使用Anchor Box会让精确度稍微下降，但用了它能让YOLOv2能预测出大于一千个框，同时recall达到88%，mAP达到69.2%。

3.2.4 Dimension clusters

之前Anchor Box的尺寸是手动选择的，所以尺寸还有优化的余地。YOLOv2尝试统计出更符合样本中对象尺寸的先验框，这样就可以减少网络微调先验框到实际位置的难度。YOLOv2的做法是对训练集中标注的边框进行K-means聚类分析，以寻找尽可能匹配样本的边框尺寸。如果我们用标准的欧式距离的k-means，尺寸大的框比小框产生更多的错误。因为我们的目的是提高IOU分数，这依赖于Box的大小，所以距离度量的使用：

 其中，centroid是聚类时被选作中心的边框，box就是其它边框，d就是两者间的“距离”，IOU越大，“距离”越近。YOLOv2给出的聚类分析结果如下图所示，通过分析实验结果（Figure 2），在model复杂性与high recall之间权衡之后，选择聚类分类数K=5。

Table1是说明用K-means选择Anchor Boxes时，当Cluster IOU选择值为5时，AVG IOU的值是61，这个值要比不用聚类的方法的60.9要高。选择值为9的时候，AVG IOU更有显著提高。总之就是说明用聚类的方法是有效果的。

3.2.5 Direct location prediction 

用Anchor Box的方法，会让model变得不稳定，尤其是在最开始几次迭代的时候。大多数不稳定因素产生自预测Box的(x,y)位置的时候。按照之前YOLOv1的方法，网络不会预测偏移量，而是根据YOLOv1中的网格单元的位置来直接预测坐标，这就让Ground Truth的值介于0到1之间。而为了让网络的结果能落在这一范围内，网络使用一个 Logistic Activation来对于网络预测结果进行限制，让结果介于0到1之间。 网络在每一个网格单元中预测出5个Bounding Boxes，每个Bounding Boxes有五个坐标值tx，ty，tw，th，t0，他们的关系见下图。假设一个网格单元对于图片左上角的偏移量是cx，cy，Bounding Boxes Prior的宽度和高度是pw，ph，那么预测的结果见下图右面的公式：

3.2.6 Fine-Grained Features 

目标检测面临的一个问题是图像中的需要检测的目标会有大有小，输入图像经过多层网络提取特征，最后输出的特征图中（比如YOLOv2中输入416*416经过卷积网络下采样最后输出是13*13），较小的对象可能特征已经不明显甚至被忽略掉了。为了更好的检测出一些比较小的对象，最后输出的特征图需要保留一些更细节的信息。于是YOLOv2引入一种称为passthrough层的方法在特征图中保留一些细节信息。具体来说，就是在最后一个pooling之前，特征图的大小是26*26*512，将其1拆4，直接传递（passthrough）到pooling后（并且又经过一组卷积）的特征图，两者叠加到一起作为输出的特征图。

 具体怎样将1个特征图拆成4个特征图，见下图，图中示例的是1个4*4拆成4个2*2，因为深度不变，所以没有画出来。

3.2.7 Multi-ScaleTraining

作者希望YOLOv2能健壮的运行于不同尺寸的图片之上，所以把这一想法用于训练model中。区别于之前的补全图片的尺寸的方法，YOLOv2每迭代几次都会改变网络参数。每10个Batch，网络会随机地选择一个新的图片尺寸，由于使用了下采样参数是32，所以不同的尺寸大小也选择为32的倍数{320，352…..608}，最小320*320，最大608*608，网络会自动改变尺寸，并继续训练的过程。这一政策让网络在不同的输入尺寸上都能达到一个很好的预测效果，同一网络能在不同分辨率上进行检测。当输入图片尺寸比较小的时候跑的比较快，输入图片尺寸比较大的时候精度高，所以你可以在YOLOv2的速度和精度上进行权衡。

3.3 YOLOv2 Faster

YOLOv1的backbone使用的是GoogleLeNet，速度比VGG-16快，YOLOv1完成一次前向过程只用8.52 billion 运算，而VGG-16要30.69billion，但是YOLOv1精度稍低于VGG-16。

3.3.1 Draknet19

YOLOv2基于一个新的分类model，有点类似与VGG。YOLOv2使用3*3filter，每次Pooling之后都增加一倍Channels的数量。YOLOv2使用Global Average Pooling，使用Batch Normilazation来让训练更稳定，加速收敛，使model规范化。最终的model–Darknet19，有19个卷积层和5个maxpooling层，处理一张图片只需要5.58 billion次运算，在ImageNet上达到72.9%top-1精确度，91.2%top-5精确度。

 

3.3.2 Training for classification

网络训练在 ImageNet 1000类分类数据集上训练了160epochs，使用随机梯度下降，初始学习率为0.1， polynomial rate decay with a power of 4, weight decay of 0.0005 and momentum of 0.9 。训练期间使用标准的数据扩大方法：随机裁剪、旋转、变换颜色（hue）、变换饱和度（saturation）， 变换曝光度（exposure shifts）。在训练时，把整个网络在更大的448*448分辨率上Fine Turnning 10个 epoches，初始学习率设置为0.001，这种网络达到达到76.5%top-1精确度，93.3%top-5精确度。

3.3.3 Training for detection

网络去掉了最后一个卷积层，而加上了三个3*3卷积层，每个卷积层有1024个Filters，每个卷积层紧接着一个1*1卷积层。对于VOC数据，网络预测出每个网格单元预测五个Bounding Boxes，每个Bounding Boxes预测5个坐标和20类，所以一共125个Filters，增加了Passthough层来获取前面层的细粒度信息，网络训练了160epoches，初始学习率0.001，数据扩大方法相同，对COCO与VOC数据集的训练对策相同。

四、YOLOv3

论文地址：https://pjreddie.com/media/files/papers/YOLOv3.pdf 

网络结构

从这里盗了张图，这张图很好的总结了YOLOv3的结构，让我们对YOLO有更加直观的理解。

DBL: 代码中的Darknetconv2d_BN_Leaky，是YOLOv3的基本组件，就是卷积+BN+Leaky relu。
resn：n代表数字，有res1，res2, … ,res8等等，表示这个res_block里含有多少个res_unit。不懂resnet请戳这儿
concat：张量拼接；将darknet中间层和后面的某一层的上采样进行拼接。拼接的操作和残差层add的操作是不一样的，拼接会扩充张量的维度，而add只是直接相加不会导致张量维度的改变。

Backbone：darknet-53

为了达到更好的分类效果，作者自己设计训练了darknet-53，在ImageNet数据集上实验发现这个darknet-53，的确很强，相对于ResNet-152和ResNet-101，darknet-53不仅在分类精度上差不多，计算速度还比ResNet-152和ResNet-101强多了，网络层数也比他们少，测试结果如图所示。

darknet-53的网络结构如下图所示。YOLOv3使用了darknet-53的前面的52层（没有全连接层），YOLOv3这个网络是一个全卷积网络，大量使用残差的跳层连接，并且为了降低池化带来的梯度负面效果，作者直接摒弃了POOLing，用conv的stride来实现降采样。在这个网络结构中，使用的是步长为2的卷积来进行降采样。

为了加强算法对小目标检测的精确度，YOLOv3中采用类似FPN的upsample和融合做法（最后融合了3个scale，其他两个scale的大小分别是26×26和52×52），在多个scale的feature map上做检测。

作者在3条预测支路采用的也是全卷积的结构，其中最后一个卷积层的卷积核个数是255，是针对COCO数据集的80类：3*(80+4+1)=255，3表示一个grid cell包含3个bounding box，4表示框的4个坐标信息，1表示objectness score。

output 

所谓的多尺度就是来自这3条预测之路，y1,y2和y3的深度都是255，边长的规律是13:26:52。YOLOv3设定的是每个网格单元预测3个box，所以每个box需要有(x, y, w, h, confidence)五个基本参数，然后还要有80个类别的概率。所以3×(5 + 80) = 255，这个255就是这么来的。

下面我们具体看看y1,y2,y3是如何而来的。
网络中作者进行了三次检测，分别是在32倍降采样，16倍降采样，8倍降采样时进行检测，这样在多尺度的feature map上检测跟SSD有点像。在网络中使用up-sample（上采样）的原因:网络越深的特征表达效果越好，比如在进行16倍降采样检测，如果直接使用第四次下采样的特征来检测，这样就使用了浅层特征，这样效果一般并不好。如果想使用32倍降采样后的特征，但深层特征的大小太小，因此YOLOv3使用了步长为2的up-sample（上采样），把32倍降采样得到的feature map的大小提升一倍，也就成了16倍降采样后的维度。同理8倍采样也是对16倍降采样的特征进行步长为2的上采样，这样就可以使用深层特征进行detection。

作者通过上采样将深层特征提取，其维度是与将要融合的特征层维度相同的（channel不同）。如下图所示，85层将13×13×256的特征上采样得到26×26×256，再将其与61层的特征拼接起来得到26×26×768。为了得到channel255，还需要进行一系列的3×3，1×1卷积操作，这样既可以提高非线性程度增加泛化性能提高网络精度，又能减少参数提高实时性。52×52×255的特征也是类似的过程。

 

Bounding Box

YOLOv3的Bounding Box由YOLOv2又做出了更好的改进。在YOLOv2和YOLOv3中，都采用了对图像中的object采用k-means聚类。feature map中的每一个cell都会预测3个边界框（bounding box） ，每个bounding box都会预测三个东西：（1）每个框的位置（4个值，中心坐标tx和ty，框的高度bh和宽度bw），（2）一个objectness prediction ，（3）N个类别，coco数据集80类，voc20类。

三次检测，每次对应的感受野不同，32倍降采样的感受野最大，适合检测大的目标，所以在输入为416×416时，每个cell的三个anchor box为(116 ,90); (156 ,198); (373 ,326)。16倍适合一般大小的物体，anchor box为(30,61); (62,45); (59,119)。8倍的感受野最小，适合检测小目标，因此anchor box为(10,13); (16,30); (33,23)。所以当输入为416×416时，实际总共有（52×52+26×26+13×13）×3=10647个proposal box。

 感受一下9种先验框的尺寸，下图中蓝色框为聚类得到的先验框。黄色框式ground truth，红框是对象中心点所在的网格。

这里注意bounding box 与anchor box的区别：
Bounding box它输出的是框的位置（中心坐标与宽高），confidence以及N个类别。anchor box只是一个尺度即只有宽高。

LOSS Function

YOLOv3重要改变之一：No more softmaxing the classes。YOLOv3现在对图像中检测到的对象执行多标签分类。

logistic回归用于对anchor包围的部分进行一个目标性评分(objectness score)，即这块位置是目标的可能性有多大。这一步是在predict之前进行的，可以去掉不必要anchor，可以减少计算量。

如果模板框不是最佳的即使它超过我们设定的阈值，我们还是不会对它进行predict。不同于Faster R-CNN的是，YOLOv3只会对1个prior进行操作，也就是那个最佳prior。而logistic回归就是用来从9个anchor priors中找到objectness score(目标存在可能性得分)最高的那一个。logistic回归就是用曲线对prior相对于 objectness score映射关系的线性建模。

  
    
    
    
    

     
     
     
     

    
      
      
      
      

     
       
       
       
       

    
      
      
      
      
    
      
      
      
      

     
       
       
       
       

        
        
        
        
      	lxy, lwh, lcls, lconf = ft([
      0]), ft([
      0]), ft([
      0]), ft([
      0])
     
       
       
       
       
    
      
      
      
      
     
     
     
     

    
      
      
      
      

     
       
       
       
       

    
      
      
      
      
    
      
      
      
      

     
       
       
       
       

        
        
        
        
          txy, twh, tcls, indices = build_targets(model, targets)
      #在13 26 52维度中找到大于iou阈值最适合的anchor box 作为targets
     
       
       
       
       
    
      
      
      
      
     
     
     
     

    
      
      
      
      

     
       
       
       
       

    
      
      
      
      
    
      
      
      
      

     
       
       
       
       
    
      #txy[维度(0:2),(x,y)] twh[维度(0:2),(w,h)] indices=[0,anchor索引，gi，gj]
     
       
       
       
       
    
      
      
      
      
     
     
     
     

    
      
      
      
      

     
       
       
       
       

    
      
      
      
      
    
      
      
      
      

     
       
       
       
       
 
     
       
       
       
       
    
      
      
      
      
     
     
     
     

    
      
      
      
      

     
       
       
       
       

    
      
      
      
      
    
      
      
      
      

     
       
       
       
       
    
      # Define criteria
     
       
       
       
       
    
      
      
      
      
     
     
     
     

    
      
      
      
      

     
       
       
       
       

    
      
      
      
      
    
      
      
      
      

     
       
       
       
       

        
        
        
        
          MSE = nn.MSELoss()
     
       
       
       
       
    
      
      
      
      
     
     
     
     

    
      
      
      
      

     
       
       
       
       

    
      
      
      
      
    
      
      
      
      

     
       
       
       
       

        
        
        
        
          CE = nn.CrossEntropyLoss()
     
       
       
       
       
    
      
      
      
      
     
     
     
     

    
      
      
      
      

     
       
       
       
       

    
      
      
      
      
    
      
      
      
      

     
       
       
       
       

        
        
        
        
          BCE = nn.BCEWithLogitsLoss()
     
       
       
       
       
    
      
      
      
      
     
     
     
     

    
      
      
      
      

     
       
       
       
       

    
      
      
      
      
    
      
      
      
      

     
       
       
       
       
 
     
       
       
       
       
    
      
      
      
      
     
     
     
     

    
      
      
      
      

     
       
       
       
       

    
      
      
      
      
    
      
      
      
      

     
       
       
       
       
    
      # Compute losses
     
       
       
       
       
    
      
      
      
      
     
     
     
     

    
      
      
      
      

     
       
       
       
       

    
      
      
      
      
    
      
      
      
      

     
       
       
       
       

        
        
        
        
          h = model.hyp  
      # hyperparameters
     
       
       
       
       
    
      
      
      
      
     
     
     
     

    
      
      
      
      

     
       
       
       
       

    
      
      
      
      
    
      
      
      
      

     
       
       
       
       

        
        
        
        
          bs = p[
      0].shape[
      0]  
      # batch size
     
       
       
       
       
    
      
      
      
      
     
     
     
     

    
      
      
      
      

     
       
       
       
       

    
      
      
      
      
    
      
      
      
      

     
       
       
       
       

        
        
        
        
          k = h[
      'k'] * bs  
      # loss gain
     
       
       
       
       
    
      
      
      
      
     
     
     
     

    
      
      
      
      

     
       
       
       
       

    
      
      
      
      
    
      
      
      
      

     
       
       
       
       
    
      for i, pi0 
      in 
      enumerate(p):  
      # layer i predictions, i
     
       
       
       
       
    
      
      
      
      
     
     
     
     

    
      
      
      
      

     
       
       
       
       

    
      
      
      
      
    
      
      
      
      

     
       
       
       
       

        
        
        
        
              b, a, gj, gi = indices[i]  
      # image, anchor, gridx, gridy
     
       
       
       
       
    
      
      
      
      
     
     
     
     

    
      
      
      
      

     
       
       
       
       

    
      
      
      
      
    
      
      
      
      

     
       
       
       
       

        
        
        
        
              tconf = torch.zeros_like(pi0[..., 
      0])  
      # conf
     
       
       
       
       
    
      
      
      
      
     
     
     
     

    
      
      
      
      

     
       
       
       
       

    
      
      
      
      
    
      
      
      
      

     
       
       
       
       
 
     
       
       
       
       
    
      
      
      
      
     
     
     
     

    
      
      
      
      

     
       
       
       
       

    
      
      
      
      
    
      
      
      
      

     
       
       
       
       
 
     
       
       
       
       
    
      
      
      
      
     
     
     
     

    
      
      
      
      

     
       
       
       
       

    
      
      
      
      
    
      
      
      
      

     
       
       
       
       
        
      # Compute losses
     
       
       
       
       
    
      
      
      
      
     
     
     
     

    
      
      
      
      

     
       
       
       
       

    
      
      
      
      
    
      
      
      
      

     
       
       
       
       
        
      if 
      len(b):  
      # number of targets
     
       
       
       
       
    
      
      
      
      
     
     
     
     

    
      
      
      
      

     
       
       
       
       

    
      
      
      
      
    
      
      
      
      

     
       
       
       
       

        
        
        
        
                  pi = pi0[b, a, gj, gi]  
      # predictions closest to anchors 找到p中与targets对应的数据lxy
     
       
       
       
       
    
      
      
      
      
     
     
     
     

    
      
      
      
      

     
       
       
       
       

    
      
      
      
      
    
      
      
      
      

     
       
       
       
       

        
        
        
        
                  tconf[b, a, gj, gi] = 
      1  
      # conf
     
       
       
       
       
    
      
      
      
      
     
     
     
     

    
      
      
      
      

     
       
       
       
       

    
      
      
      
      
    
      
      
      
      

     
       
       
       
       
            
      # pi[..., 2:4] = torch.sigmoid(pi[..., 2:4])  # wh power loss (uncomment)
     
       
       
       
       
    
      
      
      
      
     
     
     
     

    
      
      
      
      

     
       
       
       
       

    
      
      
      
      
    
      
      
      
      

     
       
       
       
       
 
     
       
       
       
       
    
      
      
      
      
     
     
     
     

    
      
      
      
      

     
       
       
       
       

    
      
      
      
      
    
      
      
      
      

     
       
       
       
       

        
        
        
        
                  lxy += (k * h[
      'xy']) * MSE(torch.sigmoid(pi[..., 
      0:
      2]),txy[i])  
      # xy loss
     
       
       
       
       
    
      
      
      
      
     
     
     
     

    
      
      
      
      

     
       
       
       
       

    
      
      
      
      
    
      
      
      
      

     
       
       
       
       

        
        
        
        
                  lwh += (k * h[
      'wh']) * MSE(pi[..., 
      2:
      4], twh[i])  
      # wh yolo loss
     
       
       
       
       
    
      
      
      
      
     
     
     
     

    
      
      
      
      

     
       
       
       
       

    
      
      
      
      
    
      
      
      
      

     
       
       
       
       

        
        
        
        
                  lcls += (k * h[
      'cls']) * CE(pi[..., 
      5:], tcls[i])  
      # class_conf loss
     
       
       
       
       
    
      
      
      
      
     
     
     
     

    
      
      
      
      

     
       
       
       
       

    
      
      
      
      
    
      
      
      
      

     
       
       
       
       
 
     
       
       
       
       
    
      
      
      
      
     
     
     
     

    
      
      
      
      

     
       
       
       
       

    
      
      
      
      
    
      
      
      
      

     
       
       
       
       
        
      # pos_weight = ft([gp[i] / min(gp) * 4.])
     
       
       
       
       
    
      
      
      
      
     
     
     
     

    
      
      
      
      

     
       
       
       
       

    
      
      
      
      
    
      
      
      
      

     
       
       
       
       
        
      # BCE = nn.BCEWithLogitsLoss(pos_weight=pos_weight)
     
       
       
       
       
    
      
      
      
      
     
     
     
     

    
      
      
      
      

     
       
       
       
       

    
      
      
      
      
    
      
      
      
      

     
       
       
       
       

        
        
        
        
              lconf += (k * h[
      'conf']) * BCE(pi0[..., 
      4], tconf)  
      # obj_conf loss
     
       
       
       
       
    
      
      
      
      
     
     
     
     

    
      
      
      
      

     
       
       
       
       

    
      
      
      
      
    
      
      
      
      

     
       
       
       
       

        
        
        
        
          loss = lxy + lwh + lconf + lcls
     
       
       
       
       
    
      
      
      
      
     
     
     
     

    
      
      
      
      

     
       
       
       
       

    
      
      
      
      
    
      
      
      
      

     
       
       
       
       
 
     
       
       
       
       
    
      
      
      
      
    
    
    
    
  
    
    
    
    

以上是一段pytorch框架描述的YOLOv3的loss_function代码。忽略恒定系数不看，以下我想着重说几点：

• 首先，YOLOv3要先build target，因为我们知道正样本是label与anchor box iou大于0.5的组成，所以我们根据label找到对应的anchor box。如何找出label中存放着[image,class,x(归一化),y,w(归一化),h],我们可以用这些坐标在对应13×13 Or 26×26 or 52×52的map中分别于9个anchor算出iou，找到符合要求的，把索引与位置记录好。用记录好的索引位置找到predict的anchor box。
• xywh是由均方差来计算loss的，其中预测的xy进行sigmoid来与lable xy求差，label xy是grid cell中心点坐标，其值在0-1之间，所以predict出的xy要sigmoid。
• 分类用的多类别交叉熵，置信度用的二分类交叉熵。只有正样本才参与class，xywh的loss计算，负样本只参与置信度loss。

 

五、YOLOv4

YOLOv4: Optimal Speed and Accuracy of Object Detection

论文：https://arxiv.org/abs/2004.10934

代码：https://github.com/AlexeyAB/darknet

YOLOv4其实是一个结合了大量前人研究技术，加以组合并进行适当创新的算法，实现了速度和精度的完美平衡。可以说有许多技巧可以提高卷积神经网络(CNN)的准确性，但是某些技巧仅适合在某些模型上运行，或者仅在某些问题上运行，或者仅在小型数据集上运行；我们来码一码这篇文章里作者都用了哪些调优手段：加权残差连接(WRC),跨阶段部分连接(CSP),跨小批量标准化(CmBN),自对抗训练(SAT),Mish激活,马赛克数据增强,CmBN,DropBlock正则化,CIoU Loss等等。经过一系列的堆料，终于实现了目前最优的实验结果：43.5％的AP(在Tesla V100上，MS COCO数据集的实时速度约为65FPS)。

 

5.1、YOLOv4框架原理

先直接上YOLOv4的整体原理图(来源网络)如下：

5.1.1  CSPDarknet53

我们前面知道在YOLOv3中，特征提取网络使用的是Darknet53，而在YOLOv4中，对Darknet53做了一点改进，借鉴了CSPNet，CSPNet全称是Cross Stage Partial Networks，也就是跨阶段局部网络。CSPNet解决了其他大型卷积神经网络框架Backbone中网络优化的梯度信息重复问题，将梯度的变化从头到尾地集成到特征图中，因此减少了模型的参数量和FLOPS数值，既保证了推理速度和准确率，又减小了模型尺寸。如下图：

CSPNet实际上是基于Densnet的思想，复制基础层的特征映射图，通过dense block发送副本到下一个阶段，从而将基础层的特征映射图分离出来。这样可以有效缓解梯度消失问题(通过非常深的网络很难去反推丢失信号) ，支持特征传播，鼓励网络重用特征，从而减少网络参数数量。CSPNet思想可以和ResNet、ResNeXt和DenseNet结合，目前主要有CSPResNext50 和CSPDarknet53两种改造Backbone网络。

考虑到几方面的平衡：输入网络分辨率/卷积层数量/参数数量/输出维度。一个模型的分类效果好不见得其检测效果就好，想要检测效果好需要以下几点：

• 更大的网络输入分辨率——用于检测小目标
• 更深的网络层——能够覆盖更大面积的感受野
• 更多的参数——更好的检测同一图像内不同size的目标

这样最终的CSPDarknet53结构就如下图：

CSPNet论文： https://arxiv.org/pdf/1911.11929v1.pdf

为了增大感受野，作者还使用了SPP-block，使用PANet代替FPN进行参数聚合以适用于不同level的目标检测。

 5.1.2 SPP结构

SPP-Net结构我们之前也有学过，SPP-Net全称Spatial Pyramid Pooling Networks，当时主要是用来解决不同尺寸的特征图如何进入全连接层的，直接看下图，下图中对任意尺寸的特征图直接进行固定尺寸的池化，来得到固定数量的特征。

如上图，以3个尺寸的池化为例，对特征图进行一个最大值池化，即一张特征图得取其最大值，得到1*d(d是特征图的维度)个特征；对特征图进行网格划分为2x2的网格，然后对每个网格进行最大值池化，那么得到4*d个特征；同样，对特征图进行网格划分为4x4个网格，对每个网格进行最大值池化，得到16*d个特征。 接着将每个池化得到的特征合起来即得到固定长度的特征个数（特征图的维度是固定的），接着就可以输入到全连接层中进行训练网络了。用到这里是为了增加感受野。

5.1.3 PAN结构

YOLOv4使用PANet(Path Aggregation Network)代替FPN进行参数聚合以适用于不同level的目标检测, PANet论文中融合的时候使用的方法是Addition，YOLOv4算法将融合的方法由加法改为Concatenation。如下图：

5.2 BackBone训练策略

这里我们主要从数据增强，DropBlock正则化，类标签平滑方面来学习下BackBone训练策略。

5.2.1 数据增强
1、CutMix

YOLOv4选择用CutMix的增强方式，CutMix的处理方式也比较简单，同样也是对一对图片做操作，简单讲就是随机生成一个裁剪框Box,裁剪掉A图的相应位置，然后用B图片相应位置的ROI放到A图中被裁剪的区域形成新的样本，ground truth标签会根据patch的面积按比例进行调整，比如0.6像狗，0.4像猫，计算损失时同样采用加权求和的方式进行求解。这里借CutMix的地方顺带说下几种类似的增强方式：

上图是CutMix论文中作者对几种增强方式做的对比，结果显而易见，CutMix的增强方式在三个数据集上的表现都是最优的。其中Mixup是直接求和两张图，如同附身，鬼影一样，模型很难学到准确的特征图响应分布。Cutout是直接去除图像的一个区域，这迫使模型在进行分类时不能对特定的特征过于自信。然而，图像的一部分充满了无用的信息，这是一种浪费。在CutMix中，将图像的一部分剪切并粘贴到另一个图像上,使得模型更容易区分异类。

CutMix论文： https://arxiv.org/pdf/1905.04899v2.pdf

2、Mosaic

Yolov4的Mosaic数据增强是参考CutMix数据增强，理论上类似。区别在于Mosaic是一种将4张训练图像合并成一张进行训练的数据增强方法(而不是CutMix中的2张)。这增强了对正常背景(context)之外的对象的检测，丰富检测物体的背景。此外，每个小批包含一个大的变化图像(4倍)，因此，减少了估计均值和方差的时需要大mini-batch的要求，降低了训练成本。如下图：

 5.2.2 DropBlock正则化

正则化技术有助于避免数据科学专业人员面临的最常见的问题，即过拟合。对于正则化，已经提出了几种方法，如L1和L2正则化、Dropout、Early Stopping和数据增强。这里YOLOv4用了DropBlock正则化的方法。

DropBlock方法的引入是为了克服Dropout随机丢弃特征的主要缺点，Dropout被证明是全连接网络的有效策略，但在特征空间相关的卷积层中效果不佳。DropBlock技术在称为块的相邻相关区域中丢弃特征。这样既可以实现生成更简单模型的目的，又可以在每次训练迭代中引入学习部分网络权值的概念，对权值矩阵进行补偿，从而减少过拟合。如下图：

DropBlock论文中作者最终在ImageNet分类任务上，使用Resnet-50结构，将精度提升1.6%个点，在COCO检测任务上，精度提升1.6%个点。

DropBlock论文： https://arxiv.org/pdf/1810.12890.pdf

5.2.3 DropBlock正则化

对于分类问题，特别是多分类问题，常常把向量转换成one-hot-vector，而one-hot带来的问题： 对于损失函数，我们需要用预测概率去拟合真实概率，而拟合one-hot的真实概率函数会带来两个问题：

• 无法保证模型的泛化能力，容易造成过拟合；
• 全概率和0概率鼓励所属类别和其他类别之间的差距尽可能加大，而由梯度有界可知，这种情况很难适应。会造成模型过于相信预测的类别。

对预测有100%的信心可能表明模型是在记忆数据，而不是在学习。标签平滑调整预测的目标上限为一个较低的值，比如0.9。它将使用这个值而不是1.0来计算损失。这个概念缓解了过度拟合。说白了，这个平滑就是一定程度缩小label中min和max的差距，label平滑可以减小过拟合。所以，适当调整label，让两端的极值往中间凑凑，可以增加泛化性能。

5.3 BackBone推理策略

5.3.1 Mish激活函数

对激活函数的研究一直没有停止过，ReLU还是统治着深度学习的激活函数，不过，这种情况有可能会被Mish改变。Mish是另一个与ReLU和Swish非常相似的激活函数。正如论文所宣称的那样，Mish可以在不同数据集的许多深度网络中胜过它们。公式如下：

                                                                                                    

Mish是一个平滑的曲线，平滑的激活函数允许更好的信息深入神经网络，从而得到更好的准确性和泛化；在负值的时候并不是完全截断，允许比较小的负梯度流入。实验中，随着层深的增加，ReLU激活函数精度迅速下降，而Mish激活函数在训练稳定性、平均准确率(1%-2.8%)、峰值准确率(1.2% - 3.6%)等方面都有全面的提高。如下图：

Mish论文： https://arxiv.org/pdf/1908.08681.pdf

5.3.2 MiWRC策略

MiWRC是Multi-input weighted residual connections的简称， 在BiFPN中，提出了用MiWRC来执行标尺度级重加权，添加不同尺度的特征映射。我们已经讨论了FPN和PAN作为例子。下面的图(d)显示了另一种被称为BiFPN的neck设计，根据BiFPN的论文，该设计具有更好的准确性和效率权衡。
 

上图中 (a)FPN引入自顶向下的路径，将多尺度特征从3级融合到7级(P3-P7)；(b)PANET在FPN之上增加一个额外的自下而上的路径；(c)NAS-FPN使用神经网络搜索找到一个不规则的特征拓扑网络，然后重复应用同一块拓扑结构；(d)是这里的BiFPN，具有更好的准确性和效率权衡。将该neck放到整个整个网络的连接中如下图：

上图采用EfficientNet作为骨干网络，BiFPN作为特征网络，共享class/box预测网络。 基于不同的资源约束，BiFPN层和类/盒网层都被重复多次。

BiFPN论文： https://arxiv.org/pdf/1911.09070.pdf

5.4 检测头训练策略

5.4.1 CIoU-loss

损失函数给出了如何调整权重以降低loss。所以在我们做出错误预测的情况下，我们期望它能给我们指明前进的方向。但如果使用IoU，考虑两个预测都不与ground truth重叠，那么IoU损失函数不能告诉哪一个是更好的，或者哪个更接近ground truth。这里顺带看下常用的几种loss的形式，如下：

1、经典IoU loss：

IoU算法是使用最广泛的算法，大部分的检测算法都是使用的这个算法。

可以看到IOU的loss其实很简单，主要是交集/并集，但其实也存在两个问题。 

问题1：即状态1的情况，当预测框和目标框不相交时，IOU=0，无法反应两个框距离的远近，此时损失函数不可导，IOU_Loss无法优化两个框不相交的情况。

问题2：即状态2和状态3的情况，当两个预测框大小相同，两个IOU也相同，IOU_Loss无法区分两者相交情况的不同。

因此2019年出现了GIOU_Loss来进行改进。

2、GIoU：Generalized IoU

GIoU考虑到，当检测框和真实框没有出现重叠的时候IoU的loss都是一样的，因此GIoU就加入了C检测框（C检测框是包含了检测框和真实框的最小矩形框），这样就可以解决检测框和真实框没有重叠的问题。其中，C是指能包含predict box和Ground Truth box的最小box。

可以看到上图GIOU_Loss中，增加了相交尺度的衡量方式，缓解了单纯IOU_Loss时的尴尬。但为什么仅仅说缓解呢？因为还存在一种不足：

问题：状态1、2、3都是预测框在目标框内部且预测框大小一致的情况，这时预测框和目标框的差集都是相同的，因此这三种状态的GIOU值也都是相同的，这时GIOU退化成了IOU，无法区分相对位置关系。
基于这个问题，2020年的AAAI又提出了DIOU_Loss。

3、DIoU：Distance IoU

好的目标框回归函数应该考虑三个重要几何因素：重叠面积、中心点距离，长宽比。针对IOU和GIOU存在的问题，作者从两个方面进行考虑

(1)：如何最小化预测框和目标框之间的归一化距离？

(2)：如何在预测框和目标框重叠时，回归的更准确？

针对第一个问题，提出了DIOU_Loss（Distance_IOU_Loss）

DIOU_Loss考虑了重叠面积和中心点距离，当目标框包裹预测框的时候，直接度量2个框的距离，因此DIOU_Loss收敛的更快。

但就像前面好的目标框回归函数所说的，没有考虑到长宽比。

比如上面三种情况，目标框包裹预测框，本来DIOU_Loss可以起作用。但预测框的中心点的位置都是一样的，因此按照DIOU_Loss的计算公式，三者的值都是相同的。

针对这个问题，又提出了CIOU_Loss，不对不说，科学总是在解决问题中，不断进步！！

4、CIOU_Loss

CIOU_Loss和DIOU_Loss前面的公式都是一样的，不过在此基础上还增加了一个影响因子，将预测框和目标框的长宽比都考虑了进去。

 其中v是衡量长宽比一致性的参数，我们也可以定义为：

这样CIOU_Loss就将目标框回归函数应该考虑三个重要几何因素：重叠面积、中心点距离，长宽比全都考虑进去了。

再来综合的看下各个Loss函数的不同点：

IOU_Loss：主要考虑检测框和目标框重叠面积。

GIOU_Loss：在IOU的基础上，解决边界框不重合时的问题。

DIOU_Loss：在IOU和GIOU的基础上，考虑边界框中心点距离的信息。

CIOU_Loss：在DIOU的基础上，考虑边界框宽高比的尺度信息。

YOLOv4中采用了CIOU_Loss的回归方式，使得预测框回归的速度和精度更高一些。

5.4.2 CmBN策略

BN就是仅仅利用当前迭代时刻信息进行norm，而CBN在计算当前时刻统计量时候会考虑前k个时刻统计量，从而实现扩大batch size操作。同时作者指出CBN操作不会引入比较大的内存开销，训练速度不会影响很多，但是训练时候会慢一些，比GN还慢。

CmBN是CBN的改进版本，其把大batch内部的4个mini batch当做一个整体，对外隔离。CBN在第t时刻，也会考虑前3个时刻的统计量进行汇合，而CmBN操作不会，不再滑动cross,其仅仅在mini batch内部进行汇合操作，保持BN一个batch更新一次可训练参数。

BN：无论每个batch被分割为多少个mini batch，其算法就是在每个mini batch前向传播后统计当前的BN数据（即每个神经元的期望和方差）并进行Nomalization，BN数据与其他mini batch的数据无关。CBN：每次iteration中的BN数据是其之前n次数据和当前数据的和（对非当前batch统计的数据进行了补偿再参与计算），用该累加值对当前的batch进行Nomalization。好处在于每个batch可以设置较小的size。CmBN：只在每个Batch内部使用CBN的方法，个人理解如果每个Batch被分割为一个mini batch，则其效果与BN一致；若分割为多个mini batch，则与CBN类似，只是把mini batch当作batch进行计算，其区别在于权重更新时间点不同，同一个batch内权重参数一样，因此计算不需要进行补偿。

5.4.3 自对抗训练(SAT)

SAT为一种新型数据增强方式。在第一阶段，神经网络改变原始图像而不是网络权值。通过这种方式，神经网络对其自身进行一种对抗式的攻击，改变原始图像，制造图像上没有目标的假象。在第二阶段，训练神经网络对修改后的图像进行正常的目标检测。

Self-Adversarial Training是在一定程度上抵抗对抗攻击的数据增强技术。CNN计算出Loss, 然后通过反向传播改变图片信息，形成图片上没有目标的假象，然后对修改后的图像进行正常的目标检测。需要注意的是在SAT的反向传播的过程中，是不需要改变网络权值的。 使用对抗生成可以改善学习的决策边界中的薄弱环节，提高模型的鲁棒性。因此这种数据增强方式被越来越多的对象检测框架运用。

5.4.4 消除网格敏感度

对于和 的情况，我们需要分别具有很大的负值和正值。但我们可以将与一个比例因子(>1.0)相乘，从而更轻松地实现这一目标

5.4.5 余弦模拟退火

余弦调度会根据一个余弦函数来调整学习率。首先，较大的学习率会以较慢的速度减小。然后在中途时，学习的减小速度会变快，最后学习率的减小速度又会变得很慢。

这张图展示了学习率衰减的方式（下图中还应用了学习率预热）及其对mAP的影响。可能看起来并不明显，这种新的调度方法的进展更为稳定，而不是在停滞一段时间后又取得进展。

余弦模拟退火论文： https://arxiv.org/pdf/1608.03983.pdf 

5.5 检测头推理策略

5.5.1 SAM模块

注意力机制在DL设计中被广泛采用。在SAM中，最大值池化和平均池化分别用于输入feature map，创建两组feature map。结果被输入到一个卷积层，接着是一个Sigmoid函数来创建空间注意力。

 将空间注意掩模应用于输入特征，输出精细的特征图。

 在YOLOv4中，使用修改后的SAM而不应用最大值池化和平均池化。

在YOLOv4中，FPN概念逐渐被实现/替换为经过修改的SPP、PAN和PAN。

5.5.2 DIoU-NMS 

NMS过滤掉预测相同对象的其他边界框，并保留具有最高可信度的边界框。

 DIoU(前面讨论过的) 被用作非最大值抑制(NMS)的一个因素。该方法在抑制冗余框的同时，采用IoU和两个边界盒中心点之间的距离。这使得它在有遮挡的情况下更加健壮。

六、YOLOv5

YOLOv4出现之后不久，YOLOv5横空出世。YOLOv5在YOLOv4算法的基础上做了进一步的改进，检测性能得到进一步的提升。虽然YOLOv5算法并没有与YOLOv4算法进行性能比较与分析，但是YOLOv5在COCO数据集上面的测试效果还是挺不错的。大家对YOLOv5算法的创新性半信半疑，有的人对其持肯定态度，有的人对其持否定态度。在我看来，YOLOv5检测算法中还是存在很多可以学习的地方，虽然这些改进思路看来比较简单或者创新点不足，但是它们确定可以提升检测算法的性能。其实工业界往往更喜欢使用这些方法，而不是利用一个超级复杂的算法来获得较高的检测精度。

6.1 YOLOv5算法简介

YOLOv5是一种单阶段目标检测算法，该算法在YOLOv4的基础上添加了一些新的改进思路，使其速度与精度都得到了极大的性能提升。主要的改进思路如下所示：

• 输入端：在模型训练阶段，提出了一些改进思路，主要包括Mosaic数据增强、自适应锚框计算、自适应图片缩放；
• 基准网络：融合其它检测算法中的一些新思路，主要包括：Focus结构与CSP结构；
• Neck网络：目标检测网络在BackBone与最后的Head输出层之间往往会插入一些层，Yolov5中添加了FPN+PAN结构；
• Head输出层：输出层的锚框机制与YOLOv4相同，主要改进的是训练时的损失函数GIOU_Loss，以及预测框筛选的DIOU_nms。

6.2 YOLOv5算法详解

6.2.1 YOLOv5网络架构

上图展示了YOLOv5目标检测算法的整体框图。对于一个目标检测算法而言，我们通常可以将其划分为4个通用的模块，具体包括：输入端、基准网络、Neck网络与Head输出端，对应于上图中的4个红色模块。YOLOv5算法具有4个版本，具体包括：YOLOv5s、YOLOv5m、YOLOv5l、YOLOv5x四种，本文重点讲解YOLOv5s，其它的版本都在该版本的基础上对网络进行加深与加宽。

• 输入端-输入端表示输入的图片。该网络的输入图像大小为608*608，该阶段通常包含一个图像预处理阶段，即将输入图像缩放到网络的输入大小，并进行归一化等操作。在网络训练阶段，YOLOv5使用Mosaic数据增强操作提升模型的训练速度和网络的精度；并提出了一种自适应锚框计算与自适应图片缩放方法。
• 基准网络-基准网络通常是一些性能优异的分类器种的网络，该模块用来提取一些通用的特征表示。YOLOv5中不仅使用了CSPDarknet53结构，而且使用了Focus结构作为基准网络。
• Neck网络-Neck网络通常位于基准网络和头网络的中间位置，利用它可以进一步提升特征的多样性及鲁棒性。虽然YOLOv5同样用到了SPP模块、FPN+PAN模块，但是实现的细节有些不同。
• Head输出端-Head用来完成目标检测结果的输出。针对不同的检测算法，输出端的分支个数不尽相同，通常包含一个分类分支和一个回归分支。YOLOv4利用GIOU_Loss来代替Smooth L1 Loss函数，从而进一步提升算法的检测精度。

6.2.2 YOLOv5基础组件

• CBL-CBL模块由Conv+BN+Leaky_relu激活函数组成，如上图中的模块1所示。
• Res unit-借鉴ResNet网络中的残差结构，用来构建深层网络，CBM是残差模块中的子模块，如上图中的模块2所示。
• CSP1_X-借鉴CSPNet网络结构，该模块由CBL模块、Res unint模块以及卷积层、Concate组成而成，如上图中的模块3所示。
• CSP2_X-借鉴CSPNet网络结构，该模块由卷积层和X个Res unint模块Concate组成而成，如上图中的模块4所示。
• Focus-如上图中的模块5所示，Focus结构首先将多个slice结果Concat起来，然后将其送入CBL模块中。
• SPP-采用1×1、5×5、9×9和13×13的最大池化方式，进行多尺度特征融合，如上图中的模块6所示。

6.2.3  输入端细节详解

• Mosaic数据增强-YOLOv5中在训练模型阶段仍然使用了Mosaic数据增强方法，该算法是在CutMix数据增强方法的基础上改进而来的。CutMix仅仅利用了两张图片进行拼接，而Mosaic数据增强方法则采用了4张图片，并且按照随机缩放、随机裁剪和随机排布的方式进行拼接而成，具体的效果如下图所示。这种增强方法可以将几张图片组合成一张，这样不仅可以丰富数据集的同时极大的提升网络的训练速度，而且可以降低模型的内存需求。

• 自适应锚框计算-在YOLOv5系列算法中，针对不同的数据集，都需要设定特定长宽的锚点框。在网络训练阶段，模型在初始锚点框的基础上输出对应的预测框，计算其与GT框之间的差距，并执行反向更新操作，从而更新整个网络的参数，因此设定初始锚点框也是比较关键的一环。在YOLOv3和YOLOv4检测算法中，训练不同的数据集时，都是通过单独的程序运行来获得初始锚点框。YOLOv5中将此功能嵌入到代码中，每次训练时，根据数据集的名称自适应的计算出最佳的锚点框，用户可以根据自己的需求将功能关闭或者打开，具体的指令为parser.add_argument(’–noautoanchor’, action=‘store_ true’, help=‘disable autoanchor check’)，如果需要打开，只需要在训练代码时增加–noautoanch or选项即可。
• 自适应图片缩放-针对不同的目标检测算法而言，我们通常需要执行图片缩放操作，即将原始的输入图片缩放到一个固定的尺寸，再将其送入检测网络中。YOLO系列算法中常用的尺寸包括416*416，608 *608等尺寸。原始的缩放方法存在着一些问题，由于在实际的使用中的很多图片的长宽比不同，因此缩放填充之后，两端的黑边大小都不相同，然而如果填充的过多，则会存在大量的信息冗余，从而影响整个算法的推理速度。为了进一步提升YOLOv5算法的推理速度，该算法提出一种方法能够自适应的添加最少的黑边到缩放之后的图片中。

6.2.4  基准网络细节详解

• Focus结构-该结构的主要思想是通过slice操作来对输入图片进行裁剪。如下图所示，原始输入图片大小为608*608*3，经过Slice与Concat操作之后输出一个304*304*12的特征映射；接着经过一个通道个数为32的Conv层（该通道个数仅仅针对的是YOLOv5s结构，其它结构会有相应的变化），输出一个304*304*32大小的特征映射。

• CSP结构-YOLOv4网络结构中，借鉴了CSPNet的设计思路，仅仅在主干网络中设计了CSP结构。而YOLOv5中设计了两种CSP结构，以YOLOv5s网络为例，CSP1_X结构应用于Backbone主干网络中，另一种CSP2_X结构则应用于Neck网络中。CSP1_X与CSP2_X模块的实现细节如3.1所示。

6.2.5 Neck网络细节详解

• FPN+PAN-YOLOv5的Neck网络仍然使用了FPN+PAN结构，但是在它的基础上做了一些改进操作，YOLOv4的Neck结构中，采用的都是普通的卷积操作。而YOLOv5的Neck网络中，采用借鉴CSPnet设计的CSP2结构，从而加强网络特征融合能力。下图展示了YOLOv4与YOLOv5的Neck网络的具体细节，通过比较我们可以发现：（1）灰色区域表示第1个不同点，YOLOv5不仅利用CSP2_\1结构代替部分CBL模块，而且去掉了下方的CBL模块；（2）绿色区域表示第2个不同点，YOLOv5不仅将Concat操作之后的CBL模块更换为CSP2_1模块，而且更换了另外一个CBL模块的位置；（3）蓝色区域表示第3个不同点，YOLOv5中将原始的CBL模块更换为CSP2_1模块。

 

参考文献：

https://blog.csdn.net/leviopku/article/details/82660381

https://blog.csdn.net/x454045816/article/details/109759989

https://blog.csdn.net/x454045816/article/details/109759989

https://zhuanlan.zhihu.com/p/172121380

https://zhuanlan.zhihu.com/p/143747206?from=timeline

https://blog.csdn.net/App_12062011/article/details/77554288

https://zhuanlan.zhihu.com/p/161083602