【深度学习】Yolov3详解笔记及Pytorch代码

预测部分

网络结构

DBL：图中左下角所示，也就是代码中的Darknetconv2d_BN_leaky，是yolov3基本组件。就是卷积+BN+leaky relu。对于v3来说，BN和leaky relu和卷积组成不可分离部分，共同组成最小组件。
resn：n代表数字，表示这个res_block含有多少个res_unit。这是yolov3的大组件，yolov3借鉴了resnet的残差结构，这种结构容易优化，能够增加网络深度来提升准确率，跳跃链接缓解了深度神经网络增加深度带来的梯度消失问题。res_unit也是由基本组件DBL构成的。
concat：张量拼接。将darknet的中间层和后面的某一层的上采样进行拼接。拼接的操作和残差层的add操作是不一样的，拼接会扩充张量的维度，而add只是直接相加不会导致张量维度的改变。

backbone：Darknet-53

yolov3使用darknet-53的前52层（没有全连接层），yolov3结构里没有池化层和全连接层。前向传播过程中，张量的尺寸变换时通过改变卷积核的步长来实现的stride=(2,2)，这就等于将图像边长缩小了一半（面积缩小到1/4）。

yolov3要经历5次缩小，会将特征图缩小到原输入尺寸的1/32。输入为416x416，输出为13x13。所以通常要求输入图片的32的倍数。

为了加强算法对小目标检测的精确度，yolov3中采用类似FPN(feature pyramid networks)的upsample和融合做法（融合了3个scale，13x13，26x26，52x52），在多个scale的feature map上做检测。

实现代码为：

import torch
import torch.nn as nn
import math
from collections import OrderedDict

# 基本的darknet块，图中的Res_unit
class BasicBlock(nn.Module):
    def __init__(self, inplanes, planes):
        super(BasicBlock, self).__init__()
        self.conv1 = nn.Conv2d(inplanes, planes[0], kernel_size=1,
                               stride=1, padding=0, bias=False)
        self.bn1 = nn.BatchNorm2d(planes[0])
        self.relu1 = nn.LeakyReLU(0.1)
        
        self.conv2 = nn.Conv2d(planes[0], planes[1], kernel_size=3,
                               stride=1, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(planes[1])
        self.relu2 = nn.LeakyReLU(0.1)

    def forward(self, x):
        residual = x

        out = self.conv1(x)
        out = self.bn1(out)
        out = self.relu1(out)

        out = self.conv2(out)
        out = self.bn2(out)
        out = self.relu2(out)

        out += residual
        return out


class DarkNet(nn.Module):
    def __init__(self, layers):
        super(DarkNet, self).__init__()
        self.inplanes = 32
        self.conv1 = nn.Conv2d(3, self.inplanes, kernel_size=3, stride=1, padding=1, bias=False)
        self.bn1 = nn.BatchNorm2d(self.inplanes)
        self.relu1 = nn.LeakyReLU(0.1)

        self.layer1 = self._make_layer([32, 64], layers[0])
        self.layer2 = self._make_layer([64, 128], layers[1])
        self.layer3 = self._make_layer([128, 256], layers[2])
        self.layer4 = self._make_layer([256, 512], layers[3])
        self.layer5 = self._make_layer([512, 1024], layers[4])

        self.layers_out_filters = [64, 128, 256, 512, 1024]

        # 进行权值初始化
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
                m.weight.data.normal_(0, math.sqrt(2. / n))
            elif isinstance(m, nn.BatchNorm2d):
                m.weight.data.fill_(1)
                m.bias.data.zero_()
                
	# 图中的resn
    def _make_layer(self, planes, blocks):
        layers = []
        # 下采样，步长为2，卷积核大小为3
        layers.append(("ds_conv", nn.Conv2d(self.inplanes, planes[1], kernel_size=3,
                                stride=2, padding=1, bias=False)))
        layers.append(("ds_bn", nn.BatchNorm2d(planes[1])))
        layers.append(("ds_relu", nn.LeakyReLU(0.1)))
        
        # 加入darknet模块，res_unit   
        self.inplanes = planes[1]
        for i in range(0, blocks):
            layers.append(("residual_{}".format(i), BasicBlock(self.inplanes, planes)))
        return nn.Sequential(OrderedDict(layers))

    def forward(self, x):
        x = self.conv1(x)
        x = self.bn1(x)
        x = self.relu1(x)

        x = self.layer1(x)
        x = self.layer2(x)
        out3 = self.layer3(x)
        out4 = self.layer4(out3)
        out5 = self.layer5(out4)

        return out3, out4, out5

# Darnet-53整体结构，调用Darknet
def darknet53(pretrained, **kwargs):
    model = DarkNet([1, 2, 8, 8, 4])
    if pretrained:
        if isinstance(pretrained, str):
            model.load_state_dict(torch.load(pretrained))
        else:
            raise Exception("darknet request a pretrained path. got [{}]".format(pretrained))
    return model

output

作者在3条预测支路采用的也是全卷积的结构，其中最后一个卷积层的卷积核个数是255，是针对coco数据集的80类：3x(80+4+1)=255，3表示每个网格单元预测3个box，每个box需要有(x,y,w,h,confidence)五个基本参数，还要有80个类别的概率。

具体来看y1，y2，y3是如何来的
网络中作者进行了3次检测，分别在32倍降采样，16倍降采样，8倍降采样时进行检测，多尺度的feature map上进行预测。
网络中使用upsample（上采样）的原因：网络越深的特征表达越好。比如在进行16倍降采样检测时，如果直接使用第四次下采样的特征来检测，这样就使用了浅层特征，效果一般不好。如果想使用32倍降采样后的特征，但深层特征的大小太小，因此yolov3使用了步长为2的upsample（上采样），吧32倍降采样得到的feature map的大小提升一倍，也就是成了16倍降采样后的维度。同理8倍采样也是对16倍降采样的特征进行步长为2的上采样，这样可以使用深层特征进行检测。

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

13x13x255就是81层得到的特征，没有进行concat。
52x52x255是97层将特征26x26x128上采样到52x52x128，然后融合36层得到的52x52x256，得到52x52x384，后再进行1x1，3x3卷积得到最终channel255。

使用pytorch，它的通道数默认在第一位。输入N张416x416的图片，经过多层计算后，会输出三个shape分别为(N,255,13,13)，(N,255,26,26)，(N,255,52,52)的数据，对应每个图分为13x13，26x26，52x52的网格上3个先验框的位置。

import torch
import torch.nn as nn
from collections import OrderedDict
from nets.darknet import darknet53

def conv2d(filter_in, filter_out, kernel_size):
    pad = (kernel_size - 1) // 2 if kernel_size else 0
    return nn.Sequential(OrderedDict([
        ("conv", nn.Conv2d(