Fork me on GitHub

YOLOv5

字数统计: 6.3k字   |   阅读时长≈ 26分

YOLOv5

一、输入端分析

Mosaic数据增强

原理分析

YOLOv5采用和YOLOv4一样的Mosaic数据增强。

主要原理：它将一张选定的图片和随机的3张图片进行随机裁剪，再拼接到一张图上作为训练数据。

这样可以丰富图片的背景，而且四张图片拼接在一起变相提高了batch_size，在进行batch normalization（归一化）的时候也会计算四张图片。

这样让YOLOv5对本身batch_size不是很依赖。

img

代码分析

1、主体部分——load_mosaic

1
2
3
4
5
labels4, segments4 = [], []
s = self.img_size #获取图像尺寸
yc, xc = (int(random.uniform(-x, 2 * s + x)) for x in self.mosaic_border)  # mosaic center x, y
#random.uniform随机生成上述范围的实数（即一半图像尺寸到1.5倍图像尺寸）
#这里是随机生成mosaic中心点

先初始化标注列表为空，然后获取图像尺寸s

根据图像尺寸利用random.uniform()随机生成mosaic中心点，范围在（即一半图像尺寸到1.5倍图像尺寸）

1
2
3
4
5
6
indices = [index] + random.choices(self.indices, k=3)  # 3 additional image indices
#随机生成另外3张图片的索引
#random.choices——随机生成3个图片总数内的索引
#然后一起把索引，连同原先选定的图片打包进indices
random.shuffle(indices)
#对这些索引值随机排序

利用random.choices()随机生成另外3张图片的索引，将这4张图片的索引填进indices列表，然后利用random.shuffle()对这些索引值随机排序

1
2
3
for i, index in enumerate(indices): #循环遍历这些图片
        # Load image
        img, _, (h, w) = load_image(self, index)#加载图片和高宽

循环遍历这4张图片，并且调用load_image()函数加载图片和对应高宽

接下来就是如何放置这4张图啦~

1
2
3
4
5
6
7
8
# place img in img4
if i == 0:  # top left（左上角）
    img4 = np.full((s * 2, s * 2, img.shape[2]), 114, dtype=np.uint8)  # base image with 4 tiles
    #先生成背景图
    x1a, y1a, x2a, y2a = max(xc - w, 0), max(yc - h, 0), xc, yc  # xmin, ymin, xmax, ymax (large image)
    #设置大图上的位置（要么原图大小，要么放大）（w，h）或（xc，yc）（新生成的那张大图）
    x1b, y1b, x2b, y2b = w - (x2a - x1a), h - (y2a - y1a), w, h  # xmin, ymin, xmax, ymax (small image)
    #选取小图上的位置（原图）

第一张图片放在左上角

img4首先用np.full()函数填充初始化大图，尺寸是4张图那么大

然后分别设置大图上该图片的位置，以及相应的在原图（即小图）上截取的位置坐标

1
2
3
4
5
6
7
8
9
elif i == 1:  # top right（右上角）
    x1a, y1a, x2a, y2a = xc, max(yc - h, 0), min(xc + w, s * 2), yc
    x1b, y1b, x2b, y2b = 0, h - (y2a - y1a), min(w, x2a - x1a), h
elif i == 2:  # bottom left（左下角）
    x1a, y1a, x2a, y2a = max(xc - w, 0), yc, xc, min(s * 2, yc + h)
    x1b, y1b, x2b, y2b = w - (x2a - x1a), 0, w, min(y2a - y1a, h)
elif i == 3:  # bottom right（右下角）
    x1a, y1a, x2a, y2a = xc, yc, min(xc + w, s * 2), min(s * 2, yc + h)
    x1b, y1b, x2b, y2b = 0, 0, min(w, x2a - x1a), min(y2a - y1a, h)

剩下3张如法炮制

1
2
img4[y1a:y2a, x1a:x2a] = img[y1b:y2b, x1b:x2b]  # img4[ymin:ymax, xmin:xmax]
#大图上贴上对应的小图

大图上贴上小图的对应部分

1
2
3
padw = x1a - x1b
padh = y1a - y1b
#计算小图到大图上时所产生的偏移，用来计算mosaic增强后的标签的位置

计算小图到大图上时所产生的偏移，用来计算mosaic增强后的标签的位置

1
2
3
4
5
6
7
8
9
10
11
# Labels
labels, segments = self.labels[index].copy(), self.segments[index].copy()
#获取标签
if labels.size:
    labels[:, 1:] = xywhn2xyxy(labels[:, 1:], w, h, padw, padh)  # normalized xywh to pixel xyxy format
    #将xywh（百分比那些值）标准化为像素xy格式
    segments = [xyn2xy(x, w, h, padw, padh) for x in segments]
    #转为像素段
labels4.append(labels)
segments4.extend(segments)
#填进列表

对label标注进行初始化操作：

先读取对应图片的label，然后将xywh格式的label标准化为像素xy格式的。

segments转为像素段格式

然后统统填进之前准备的标注列表

1
2
3
4
5
6
# Concat/clip labels
labels4 = np.concatenate(labels4, 0) #完成数组拼接
for x in (labels4[:, 1:], *segments4):
    np.clip(x, 0, 2 * s, out=x)  # clip when using random_perspective()
    #np.clip截取函数，固定值在0到2s内
# img4, labels4 = replicate(img4, labels4)  # replicate

先把label列表进行数组拼接，转化好格式，方便下面的处理，并且把数据截取在0到2倍图片尺寸

1
2
3
4
5
6
7
8
9
10
11
# Augment
#进行mosaic的时候将四张图片整合到一起之后shape为[2*img_size,2*img_size]
#对mosaic整合的图片进行随机旋转、平移、缩放、裁剪，并resize为输入大小img_size
img4, labels4, segments4 = copy_paste(img4, labels4, segments4, p=self.hyp['copy_paste'])
img4, labels4 = random_perspective(img4, labels4, segments4,
                                   degrees=self.hyp['degrees'],
                                   translate=self.hyp['translate'],
                                   scale=self.hyp['scale'],
                                   shear=self.hyp['shear'],
                                   perspective=self.hyp['perspective'],
                                   border=self.mosaic_border)  # border to remove

进行mosaic的时候将四张图片整合到一起之后shape为[2img_size,2img_size]

并且对mosaic整合的图片进行随机旋转、平移、缩放、裁剪，并resize为输入大小img_size

1
return img4, labels4

最后返回处理好的图片和相应的label

2、load_image函数

load_image函数：加载图片并根据设定的输入大小与图片原大小的比例ratio进行resize

首先获取该索引的图片

1
2
3
4
def load_image(self, i):
    #load_image加载图片并根据设定的输入大小与图片原大小的比例ratio进行resize
loads 1 image from dataset index 'i', returns im, original hw, resized hw
    im = self.imgs[i]#获取该索引的图片

判断一下图片是否有缓存，即有没有缩放处理过（这里不太确定这样理解对不对，如果错了麻烦在评论区跟我说一下下，谢谢啦~）

如果没有：

先去对应文件夹中找

如果能找到：加载这张图片

如果找不到：读取这张图的路径，然后报错找不到对应路径的这张图片

读取这张图的原始高宽以及设定resize比例

如果这个比例不等于1，那我们就resize一下进行一个缩放

最后返回这张图片，原始高宽和缩放后的高宽

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
if im is None:  # not cached in ram
    #图片如果没有缓存（就是还没有任何缩放处理过）
    npy = self.img_npy[i] #去文件夹中找
    if npy and npy.exists():  # load npy
        im = np.load(npy) #找到了我们就加载这张图片
    else:  # read image
        path = self.img_files[i] #找不到图片就读取原本这张图的路径
        im = cv2.imread(path)  # BGR
        assert im is not None, f'Image Not Found {path}' #报错找不到这张图
    h0, w0 = im.shape[:2]  # orig hw
    #读取这张图的原始高宽
    r = self.img_size / max(h0, w0)  # ratio 
    #设定resize比例
    if r != 1:  # if sizes are not equal
        im = cv2.resize(im, (int(w0 * r), int(h0 * r)),
                        interpolation=cv2.INTER_AREA if r < 1 and not self.augment else cv2.INTER_LINEAR)#实现缩放
    return im, (h0, w0), im.shape[:2]  # im, hw_original, hw_resized

如果有

那就直接返回这张图片，原始高宽和缩放后的高宽啦~

1
2
else:
    return self.imgs[i], self.img_hw0[i], self.img_hw[i]  # im, hw_original, hw_resized

3、random_perspective()函数（详见代码解析）

随机变换

计算方法：坐标向量和变换矩阵的乘积

首先获得加上边框后的图片高宽

1
2
3
4
5
6
7
8
def random_perspective(im, targets=(), segments=(), degrees=10, translate=.1, scale=.1, shear=10, perspective=0.0,
                       border=(0, 0)):
    # torchvision.transforms.RandomAffine(degrees=(-10, 10), translate=(0.1, 0.1), scale=(0.9, 1.1), shear=(-10, 10))
    # targets = [cls, xyxy]
 
    #图片高宽（加上border边框）
    height = im.shape[0] + border[0] * 2  # shape(h,w,c)
    width = im.shape[1] + border[1] * 2

然后计算中心点

1
2
3
4
5
6
# Center
C = np.eye(3)#生成3*3的对角为1的对角矩阵
#x方向的中心
C[0, 2] = -im.shape[1] / 2  # x translation (pixels)
#y方向的中心
C[1, 2] = -im.shape[0] / 2  # y translation (pixels)

接下来是各种变换（旋转等等）的矩阵准备

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
# Perspective
#透视
P = np.eye(3)#生成3*3的对角为1的对角矩阵
#随机生成x，y方向上的透视值
P[2, 0] = random.uniform(-perspective, perspective)  # x perspective (about y)
P[2, 1] = random.uniform(-perspective, perspective)  # y perspective (about x)
 
# Rotation and Scale
#旋转和缩放
R = np.eye(3)#生成3*3的对角为1的对角矩阵
a = random.uniform(-degrees, degrees)#随机生成范围内的角度
# a += random.choice([-180, -90, 0, 90])  # add 90deg rotations to small rotations
s = random.uniform(1 - scale, 1 + scale) #随机生成缩放比例
# s = 2 ** random.uniform(-scale, scale)
R[:2] = cv2.getRotationMatrix2D(angle=a, center=(0, 0), scale=s)#图片旋转得到仿射变化矩阵赋给R的前两行
 
# Shear
#弯曲角度
S = np.eye(3)#生成3*3的对角为1的对角矩阵
S[0, 1] = math.tan(random.uniform(-shear, shear) * math.pi / 180)  # x shear (deg)
S[1, 0] = math.tan(random.uniform(-shear, shear) * math.pi / 180)  # y shear (deg)
 
# Translation
#转换（放大缩小？)
T = np.eye(3)
T[0, 2] = random.uniform(0.5 - translate, 0.5 + translate) * width  # x translation (pixels)
T[1, 2] = random.uniform(0.5 - translate, 0.5 + translate) * height  # y translation (pixels)

然后是组合旋转矩阵

1
2
3
4
5
6
7
8
9
10
11
12
# Combined rotation matrix
#组合旋转矩阵
M = T @ S @ R @ P @ C  # order of operations (right to left) is IMPORTANT
#通过矩阵乘法组合
if (border[0] != 0) or (border[1] != 0) or (M != np.eye(3)).any():  # image changed
    #没有边框或者没有任何变换
    if perspective:#如果透视
        im = cv2.warpPerspective(im, M, dsize=(width, height), borderValue=(114, 114, 114))
        #cv2.warpPerspective透视变换函数，可保持直线不变形，但是平行线可能不再平行
    else:  # affine
        im = cv2.warpAffine(im, M[:2], dsize=(width, height), borderValue=(114, 114, 114))
        #cv2.warpAffine放射变换函数，可实现旋转，平移，缩放，并且变换后的平行线依旧平行

然后是变换标签的坐标

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
# Transform label coordinates
#变换标签坐标
n = len(targets)#目标个数
if n:#如果有目标
    use_segments = any(x.any() for x in segments)#判断segments是否为空或是否全为0（目标像素段）
    new = np.zeros((n, 4))#初始化信息矩阵，每个目标4个信息xywh
    if use_segments:  # warp segments（变形segments）
        #如果不是空的
        segments = resample_segments(segments)  # upsample
        #上采样
        for i, segment in enumerate(segments):
            xy = np.ones((len(segment), 3))
            xy[:, :2] = segment#前两列是目标中心的像素段
            xy = xy @ M.T  # transform转化
            xy = xy[:, :2] / xy[:, 2:3] if perspective else xy[:, :2]  # perspective rescale or affine
            #透视处理，重新缩放或者仿射
            #xy的最后一列全为1是为了和M.T矩阵相乘时，只会与最后M.T的最后一行相乘，而M.T的最后一行则为P当时设定的透视值
 
            # clip修建
            new[i] = segment2box(xy, width, height)
 
    else:  # warp boxes（变形box）
        xy = np.ones((n * 4, 3))
        xy[:, :2] = targets[:, [1, 2, 3, 4, 1, 4, 3, 2]].reshape(n * 4, 2)  # x1y1, x2y2, x1y2, x2y1
        xy = xy @ M.T  # transform
        xy = (xy[:, :2] / xy[:, 2:3] if perspective else xy[:, :2]).reshape(n, 8)  # perspective rescale or affine
 
        # create new boxes
        x = xy[:, [0, 2, 4, 6]]
        y = xy[:, [1, 3, 5, 7]]
        new = np.concatenate((x.min(1), y.min(1), x.max(1), y.max(1))).reshape(4, n).T
 
        # clip
        #去除进行上面一系列操作后被裁剪过小的框
        new[:, [0, 2]] = new[:, [0, 2]].clip(0, width)
        new[:, [1, 3]] = new[:, [1, 3]].clip(0, height)

最后是计算候选框并返回

1
2
3
4
5
6
    # filter candidates
    i = box_candidates(box1=targets[:, 1:5].T * s, box2=new.T, area_thr=0.01 if use_segments else 0.10)#计算候选框
    targets = targets[i]
    targets[:, 1:5] = new[i]
 
return im, targets

自适应锚框计算

YOLOv5针对不同的数据集，都有初始设定长宽的锚框。在训练过程中，在初始锚框的基础上输出预测框，然后和真实框groundtruth进行比对，即以真实的边框位置相对于预设边框的偏移来计算两者差距，再反向更新，迭代网络参数，继续训练。

Anchor Box的定义：由边框的高宽来描述，这样乍一看会觉得这个Anchor Box不是固定的呀，它能在图片上形成无数个。这里就需要一个中心点了，而这个中心点是由后续网络提取到的Feature Map 的点，所以一个初始Anchor box不需要指定中心位置。

在yolov5s.yaml文件中的初始化为：

1
2
3
4
anchors:
  - [10,13, 16,30, 33,23]  # P3/8
  - [30,61, 62,45, 59,119]  # P4/16
  - [116,90, 156,198, 373,326]  # P5/32

在YOLOv5中这个功能是可选的，如果你觉得它效果不好可以关了它，在训练代码时增加

“–noautoanchor”选项

具体选择在train.py文件中

1
parser.add_argument('--noautoanchor', action='store_true', help='disable AutoAnchor')

自适应图片缩放

img

1、原理分析

通常我们找到的图片尺寸都不一样，但是要进入网络训练时，需要保证图片尺寸一致。

但是如果我们简单的使用resize，就会造成图片的失真，进而影响我们的结果。

因此采取一种更好的方法——letterbox自适应图片缩放技术

注：train过程中并没有用到letterbox自适应图片缩放技术，只有在detect过程中使用。

train所保持的图片尺寸一致是因为它把4张图片的部分组成了一张尺寸一致的大图，因此不需要用到letterbox

letterbox自适应图片缩放技术尽量保持高宽比，缺的用灰边补齐达到固定的尺寸。

接下来我们与代码相结合来具体看看它的原理

2、代码分析

这部分在utils/augmentations.py文件中的letterbox函数

首先获得当前图片高宽，然后保证变换的图片高宽为整数

1
2
3
4
5
6
7
def letterbox(im, new_shape=(640, 640), color=(114, 114, 114), auto=True, scaleFill=False, scaleup=True, stride=32):
    # Resize and pad image while meeting stride-multiple constraints
    shape = im.shape[:2]  # current shape [height, width]
    #获得当前图片的高宽
    if isinstance(new_shape, int):#判断最终图片高宽是否为整数
        new_shape = (new_shape, new_shape)
    #将最终图片高宽以像素段形式存到new_shape里

计算缩放比例，取最小的那个比例，并且我们只缩小不放大

1
2
3
r = min(new_shape[0] / shape[0], new_shape[1] / shape[1])#计算缩放比例
if not scaleup:  # only scale down, do not scale up (for better val mAP)
    r = min(r, 1.0)#这里的操作是只按比例缩小，不放大

然后计算填充的长宽：

首先计算按照比例缩放后的图片高宽

然后以此计算要填充的长度，再与stride相除取余数

其中stride表示模型下采样次数的2的次方,（感受野的问题）在YOLOV5中下采样次数为5，所以为32

最后填充长度减半，因为要分上和下，左和右

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# Compute padding
ratio = r, r  # width, height ratios
new_unpad = int(round(shape[1] * r)), int(round(shape[0] * r))#计算收缩后图片的长宽
dw, dh = new_shape[1] - new_unpad[0], new_shape[0] - new_unpad[1]  # wh padding
#计算需要填充的长宽
if auto:  # minimum rectangle
    dw, dh = np.mod(dw, stride), np.mod(dh, stride)  # wh padding
    #stride表示模型下采样次数的2的次方,（感受野的问题）在YOLOV5中下采样次数为5，所以为32
elif scaleFill:  # stretch
    dw, dh = 0.0, 0.0
    new_unpad = (new_shape[1], new_shape[0])
    ratio = new_shape[1] / shape[1], new_shape[0] / shape[0]  # width, height ratios
 
dw /= 2  # divide padding into 2 sides
dh /= 2
#分半（上下，左右）

变换并返回：

调用resize函数进行变形，然后最终确定上下左右要填充的数（保证是大于等于0的整数）

再调用copyMakeBorder填充

最终返回操作后的图片，缩放比例以及填充的高宽

1
2
3
4
5
6
7
8
9
if shape[::-1] != new_unpad:  # resize
    im = cv2.resize(im, new_unpad, interpolation=cv2.INTER_LINEAR)
    #变形操作
top, bottom = int(round(dh - 0.1)), int(round(dh + 0.1))
left, right = int(round(dw - 0.1)), int(round(dw + 0.1))
#直接让小于1的为0，计算出上下左右分别要填多少（整数）
im = cv2.copyMakeBorder(im, top, bottom, left, right, cv2.BORDER_CONSTANT, value=color)  # add border
#填充
return im, ratio, (dw, dh)

二、整体网络结构图以及总括介绍

网络结构图如下图所示：

img

（其中CBL的标注都是有关输出的）

v5.0版本（下图中的CBL改为CBS）

Backbone

（1）Focus结构

img

Focus结构，在Yolov3&Yolov4中并没有这个结构，其中比较关键是切片操作。

比如右图的切片示意图，443的图像切片后变成2212的特征图。

以Yolov5s的结构为例，原始6086083的图像输入Focus结构，采用切片操作，先变成30430412的特征图，再经过一次32个卷积核的卷积操作，最终变成30430432的特征图。

需要注意的是：Yolov5s的Focus结构最后使用了32个卷积核，而其他三种结构，使用的数量有所增加，先注意下，后面会讲解到四种结构的不同点。

（2）CSP结构

Yolov4网络结构中，借鉴了CSPNet的设计思路，在主干网络中设计了CSP结构。

img

Yolov5与Yolov4不同点在于，Yolov4中只有主干网络使用了CSP结构。

而Yolov5中设计了两种CSP结构，以Yolov5s网络为例，CSP1_X结构应用于Backbone主干网络，另一种CSP2_X结构则应用于Neck中。

img

这里关于CSPNet的内容，也可以查看大白之前的《深入浅出Yolo系列之Yolov3&Yolov4核心基础完整讲解》。

Neck

Yolov5现在的Neck和Yolov4中一样，都采用FPN+PAN的结构，但在Yolov5刚出来时，只使用了FPN结构，后面才增加了PAN结构，此外网络中其他部分也进行了调整。

因此，大白在Yolov5刚提出时，画的很多结构图，又都重新进行了调整。

img

这里关于FPN+PAN的结构，大白在《深入浅出Yolo系列之Yolov3&Yolov4核心基础知识完整讲解》中，讲的很多，大家应该都有理解。

但如上面CSPNet结构中讲到，Yolov5和Yolov4的不同点在于，

Yolov4的Neck结构中，采用的都是普通的卷积操作。而Yolov5的Neck结构中，采用借鉴CSPnet设计的CSP2结构，加强网络特征融合的能力。

img

输出端

（1）Bounding box损失函数

在《深入浅出Yolo系列之Yolov3&Yolov4核心基础知识完整讲解》中，大白详细的讲解了IOU_Loss，以及进化版的GIOU_Loss，DIOU_Loss，以及CIOU_Loss。

Yolov5中采用其中的CIOU_Loss做Bounding box的损失函数。

img

Yolov4中也采用CIOU_Loss作为目标Bounding box的损失。

img

（2）nms非极大值抑制

在目标检测的后处理过程中，针对很多目标框的筛选，通常需要nms操作。

因为CIOU_Loss中包含影响因子v，涉及groudtruth的信息，而测试推理时，是没有groundtruth的。

所以Yolov4在DIOU_Loss的基础上采用DIOU_nms的方式，而Yolov5中采用加权nms的方式。

可以看出，采用DIOU_nms，下方中间箭头的黄色部分，原本被遮挡的摩托车也可以检出。

img

大白在项目中，也采用了DIOU_nms的方式，在同样的参数情况下，将nms中IOU修改成DIOU_nms。对于一些遮挡重叠的目标，确实会有一些改进。

比如下面黄色箭头部分，原本两个人重叠的部分，在参数和普通的IOU_nms一致的情况下，修改成DIOU_nms，可以将两个目标检出。

虽然大多数状态下效果差不多，但在不增加计算成本的情况下，有稍微的改进也是好的。

img

Yolov5四种网络结构的不同点

Yolov5代码中的四种网络，和之前的Yolov3，Yolov4中的cfg文件不同，都是以yaml的形式来呈现。

而且四个文件的内容基本上都是一样的，只有最上方的depth_multiple和width_multiple两个参数不同，很多同学看的一脸懵逼，不知道只通过两个参数是如何控制四种结构的？

四种结构的参数

大白先取出Yolov5代码中，每个网络结构的两个参数：

img

四种结构就是通过上面的两个参数，来进行控制网络的深度和宽度。其中depth_multiple控制网络的深度，width_multiple控制网络的宽度。

Yolov5网络结构

四种结构的yaml文件中，下方的网络架构代码都是一样的。

为了便于讲解，大白将其中的Backbone部分提取出来，讲解如何控制网络的宽度和深度，yaml文件中的Head部分也是同样的原理。

img

在对网络结构进行解析时，yolo.py中下方的这一行代码将四种结构的depth_multiple，width_multiple提取出，赋值给gd，gw。后面主要对这gd，gw这两个参数进行讲解。

img

下面再细致的剖析下，看是如何控制每种结构，深度和宽度的。

Yolov5四种网络的深度

img

（1）不同网络的深度

在上图中，大白画了两种CSP结构，CSP1和CSP2，其中CSP1结构主要应用于Backbone中，CSP2结构主要应用于Neck中。

需要注意的是，四种网络结构中每个CSP结构的深度都是不同的。

a.以yolov5s为例，第一个CSP1中，使用了1个残差组件，因此是CSP1_1。而在Yolov5m中，则增加了网络的深度，在第一个CSP1中，使用了2个残差组件，因此是CSP1_2。

而Yolov5l中，同样的位置，则使用了3个残差组件，Yolov5x中，使用了4个残差组件。

其余的第二个CSP1和第三个CSP1也是同样的原理。

b.在第二种CSP2结构中也是同样的方式，以第一个CSP2结构为例，Yolov5s组件中使用了2×X=2×1=2个卷积，因为Ｘ=1，所以使用了1组卷积，因此是CSP2_1。

而Yolov5m中使用了2组，Yolov5l中使用了3组，Yolov5x中使用了4组。

其他的四个CSP2结构，也是同理。

Yolov5中，网络的不断加深，也在不断增加网络特征提取和特征融合的能力。

（2）控制深度的代码

控制四种网络结构的核心代码是yolo.py中下面的代码，存在两个变量，n和gd。

我们再将n和gd带入计算，看每种网络的变化结果。

img

（3）验证控制深度的有效性

我们选择最小的yolov5s.yaml和中间的yolov5l.yaml两个网络结构，将**gd(depth_multiple)**系数带入，看是否正确。

img

a. yolov5s.yaml

其中depth_multiple=0.33，即gd=0.33，而n则由上面红色框中的信息获得。

以上面网络框图中的第一个CSP1为例，即上面的第一个红色框。n等于第二个数值3。

而gd=0.33，带入（2）中的计算代码，结果n=1。因此第一个CSP1结构内只有1个残差组件，即CSP1_1。

第二个CSP1结构中，n等于第二个数值9，而gd=0.33，带入（2）中计算，结果n=3，因此第二个CSP1结构中有3个残差组件，即CSP1_3。

第三个CSP1结构也是同理，这里不多说。

b. yolov5l.xml

其中depth_multiple=1，即gd=1

和上面的计算方式相同，第一个CSP1结构中，n=3，带入代码中，结果n=3，因此为CSP1_3。

下面第二个CSP1和第三个CSP1结构都是同样的原理。

Yolov5四种网络的宽度

img

（1）不同网络的宽度:

如上图表格中所示，四种yolov5结构在不同阶段的卷积核的数量都是不一样的，因此也直接影响卷积后特征图的第三维度，即厚度，大白这里表示为网络的宽度。

a.以Yolov5s结构为例，第一个Focus结构中，最后卷积操作时，卷积核的数量是32个，因此经过Focus结构，特征图的大小变成304*304*32。

而yolov5m的Focus结构中的卷积操作使用了48个卷积核，因此Focus结构后的特征图变成304*304*48。yolov5l，yolov5x也是同样的原理。

b. 第二个卷积操作时，yolov5s使用了64个卷积核，因此得到的特征图是152*152*64。而yolov5m使用96个特征图，因此得到的特征图是152*152*96。yolov5l，yolov5x也是同理。

c. 后面三个卷积下采样操作也是同样的原理，这样大白不过多讲解。

四种不同结构的卷积核的数量不同，这也直接影响网络中，比如CSP1，CSP2等结构，以及各个普通卷积，卷积操作时的卷积核数量也同步在调整，影响整体网络的计算量。

大家最好可以将结构图和前面第一部分四个网络的特征图链接，对应查看，思路会更加清晰。

当然卷积核的数量越多，特征图的厚度，即宽度越宽，网络提取特征的学习能力也越强。

（2）控制宽度的代码

在yolov5的代码中，控制宽度的核心代码是yolo.py文件里面的这一行：

img

它所调用的子函数make_divisible的功能是：

img

（3）验证控制宽度的有效性

我们还是选择最小的yolov5s和中间的yolov5l两个网络结构，将width_multiple系数带入，看是否正确。

img

a. yolov5s.yaml

其中width_multiple=0.5，即gw=0.5。

img

以第一个卷积下采样为例，即Focus结构中下面的卷积操作。

按照上面Backbone的信息，我们知道Focus中，标准的c2=64，而gw=0.5，代入（2）中的计算公式，最后的结果=32。即Yolov5s的Focus结构中，卷积下采样操作的卷积核数量为32个。

再计算后面的第二个卷积下采样操作，标准c2的值=128，gw=0.5，代入（2）中公式，最后的结果=64，也是正确的。

b. yolov5l.yaml

其中width_multiple=1，即gw=1，而标准的c2=64，代入上面（2）的计算公式中，可以得到Yolov5l的Focus结构中，卷积下采样操作的卷积核的数量为64个，而第二个卷积下采样的卷积核数量是128个。

另外的三个卷积下采样操作，以及yolov5m，yolov5x结构也是同样的计算方式，大白这里不过多解释。

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

计算机小学徒，慢慢成长