本篇文章并没有涉及YOLOv3的训练内容，实际是根据原作者使用 PyTorch 实现基于YOLOv3的目标检测器的源代码，来进一步理解YOLOv3网络模型的输入，结构及输出。

代码地址

YOLOv3的pytorch实现：https://github.com/ayooshkathuria/YOLO_v3_tutorial_from_scratch

模型的输入

YOLOv3采用darknet-53模型，其中并没有传统的池化层，而是采用下采样来进行深层特征的提取，每下采样一次，其宽高则为原来的一半。由于下采样次数为5次，设初始图像大小为[w,h]，最后下采样5次的feature map为[w/32,h/32]。所以原始图片的宽、高应为32的倍数，例如320x320,416x416,480x480等。在源码中作者取得图片大小为416x416，所以对于所有输入图片都会进行预处理。

darknet-53模型

图片的预处理（源码）

在源码中对应与util.py的prep_image和letterbox_image方法，处理图片大小的主要是letterbox_image方法。

def letterbox_image(img, inp_dim):
    """
    将图片按照纵横比进行缩放，将空白部分用(128,128,128)填充,调整图像尺寸
    将缩放后的数据拷贝到画布中心,返回完成缩放
    """
    img_w, img_h = img.shape[1], img.shape[0]
    w, h = inp_dim#inp_diw=416
    new_w = int(img_w * min(w / img_w, h / img_h))
    new_h = int(img_h * min(w / img_w, h / img_h))
    resized_image = cv2.resize(img, (new_w, new_h), interpolation=cv2.INTER_CUBIC)
    canvas = np.full((inp_dim[1], inp_dim[0], 3), 128)
    canvas[(h - new_h) // 2:(h - new_h) // 2 + new_h, (w - new_w) // 2:(w - new_w) // 2 + new_w, :] = resized_image

    return canvas

代码按照长宽比将较长的一边缩放到416，那么较短的一边肯定小于416，将缩放后的图片摆放到画布中心，空白部分用(128,128,128)填充。这样就得到了符合模型输入的416x416大小的图片。

图片预处理实现的主要过程

模型结构

1、多尺度特征融合

YOLOv3为了能够实现对不同大小的物体进行准确的预测，在不同的特征图上进行目标检测。模型对于一张图片，一共在3张feature map进行预测。32倍下采样大小为13x13的feature map更适合于预测大型目标，16倍下采样大小为26x26的feature map更适合于预测中型目标，8倍下采样大小为52x52的feature map更适合于预测小型目标。而一般认为下采样次数少，提取的是图像的浅层特征，所以网络并不是直接将下采样的结果作为最后的feature map。
例如为了得到26x26大小的feature map：
1、网络先是将图片进行4次下采样得到26x26的feature map（下图网络61层的输出），可以看成浅层特征。
2、在对4次下采样的数据进行一次下采样和一次上采样，下采样一次[h,w]变成[h/2,w/2]，而上采样一次[h/2,w/2]变成[h,w]，所以也能得到26x26的feature map（下图红框中的第二个粉框的输出），可以看成深层特征。
3、最后对浅层特征和深层特征进行拼接（对应于下图的红框），得到最终的26x26的feature map，再在该feature map上进行目标检测。
同理，对于52x52的feature map，也是将浅层特征与深层特征进行拼接（对应于下图的橘色框），得到最终的52x52的feature map。

YOLOv3网络结构

在代码中是通过route层来实现特征融合，摘录了Darknet的forward方法中的一段。例如拼接52x52的feature map。在yolov3.cfg文件中有[route]layers = -1, 36，其中36层的输出是图片下采样3次的浅层特征。-1为当前层的前一层输出，是橘色框中的深层特征。

            elif module_type == "route":
                layers = module["layers"]
                layers = [int(a) for a in layers]#[-1,36]

                if (layers[0]) > 0:
                    layers[0] = layers[0] - i
                if len(layers) == 1:
                    x = outputs[i + (layers[0])]
                else:
                    if (layers[1]) > 0:
                        layers[1] = layers[1] - i
                    map1 = outputs[i + layers[0]]#outputs[i-1]
                    map2 = outputs[i + layers[1]]#outputs[36]
                    # 第二个参数设为 1,这是因为我们希望将特征图沿anchor数量的维度级联起来。
                    #将浅层特征和深层特征进行拼接
                    x = torch.cat((map1, map2), 1)

可能有小伙伴还看到[route]layers = -4的情况，该情况为每次feature map检测以后，接下来的网络卷积从当前feature map的前4张开始。也就是对应上图中小狗图片上方有4个框，从下往上数分别为-1,-2,-3,-4。

2、跳跃连接（short connect）

网络模型借鉴了残差网络的跳跃连接，可以保证网络在深层的情况下也能收敛。使用1x1卷积可以大量减少每次卷积的channel，不仅可以减少模型的参数量，而且可以减少计算量，从而加速检测速度。

跳跃连接

源码实现：在yolov3.cfg文件中有[shortcut] from=-3 activation=linear。摘录了Darknet的forward方法中的一段。其中i表示当前层数。由于outputs[i-1]和outputs[i-3]维度相同，所以可以直接相加。

            elif module_type == "shortcut":
                from_ = int(module["from"])#-3
                #i表示当前层数，跳跃连接将前一层和前三层的输出直接相加
                x = outputs[i - 1] + outputs[i + from_]

3、目标检测

anchor box大小的确定

上述内容提到网络模型一共在3张feature map上进行目标检测，但是每张feature map用的anchor box的大小并不一样。在先前的Faster-Rcnn和SSD模型中，anchor box的大小是人为设定的，而YOLOv3中，anchor box大小是采用k-means聚类得到的，在原始图片大小为416x416的情况下，32倍下采样大小为13x13的feature map采用的anchor box大小为(116,90)，(156,198)，(373,326)。16倍下采样大小为26x26的feature map采用的anchor box大小为(30,61)，(62,45)，(59,119)。8倍下采样大小为52x52的feature map采用的anchor box大小为(10,13)，(16,30)，(33,23)。anchor的大小是在yolov3.cfg的[yolo]中设置。
可以看到对于每张feature map都有3个不同比例大小的anchor box。那么一张图片总共能够产生(13x13+26x26+52x52)x3=10647个anchor box。下图中的红框表示feature map上的一个单元格，蓝框表示一个单元格预测的3种不同比例大小的anchor box，黄框为真实框(groundtruth)。可以看到不同feature map适用于不同大小的目标检测。

不同尺寸的feature map
在darknet.py的create_modules方法中用于读取yolov3.cfg中anchor box大小，而yolo检测层的具体实现, 即在特征图上使用锚点预测目标区域和类别, 功能函数在predict_transform中实现，该方法在下文将会讲到。

[yolo]
mask = 6,7,8  #通过mask来选择不同大小的anchors
anchors = 10,13,  16,30,  33,23,  30,61,  62,45,  59,119,  116,90,  156,198,  373,326
classes=80
num=9
jitter=.3
ignore_thresh = .5
truth_thresh = 1
random=1

# Yolo is the detection layer,对不同尺度的feature map进行检测
        elif x["type"] == "yolo":
            mask = x["mask"].split(",")
            mask = [int(x) for x in mask]

            anchors = x["anchors"].split(",")
            anchors = [int(a) for a in anchors]
            anchors = [(anchors[i], anchors[i + 1]) for i in range(0, len(anchors), 2)]
            anchors = [anchors[i] for i in mask]
            # print('index',anchors)
            detection = DetectionLayer(anchors)  # 锚点,检测,位置回归,分类，这个类见predict_transform中
            module.add_module("Detection_{}".format(index), detection)

在feature map上进行目标检测

选取在32倍下采样大小为13x13的feature map上进行检测为例，其余两个大小的feature map其过程与该feature map是相同的。
将经过32倍下采样的feature map输出定义为prediction，其维度为[batch_size,C,H,W]，具体数值为[1,255,13,13]。
由于最终预测输出的维度为85，具体内容为[x,y,h,w,s,cls_1,cls_2,...cls_80]。分别表示相对于原图的x，y，宽，高，预测框中含有目标的置信度，及80个类别分数。因为coco数据集有80种类别。所以输出的维度为5+cls_num=5+80=85。
因此prediction的维度变化为
1、[1,255,13,13]-->[1,85x3,13x13]=[1,255,169]。因为32倍下采样feature map上的一共有13x13=169个单元格
2、[1,255,169]-->[1,169,255]，交换1，2维度
3、[1,169,255]-->[1,169x3,85]=[1,507,85]，因为每个单元格预测3个anchor box，所以feature map上一共有13x13x3=507个anchor box，每个anchor box输出的维度为85。这85维分别是[tx,ty,tw,th,score,cls_1,cls_2,...,cls_80]。

转化公式

4、根据上方公式，将85维中的前4维[tx,ty,tw,th]变成[bx,by,bw,bh]，其中Cx,Cy为当前单元格左上方的坐标。同时将第5维的score(含有目标的置信度)，经过sigmoid函数激活，得到其含有目标的概率。cls_1,cls_2,..,cls_80也要经过sigmoid函数激活得到相应的概率。

最终在13x13的feature map上得到的预测输出为[1,507,85]，同理在26x26的feature map上的预测输出为[1,2028,85],在52x52的feature map上的预测输出为[1,8112,85]。最后将这些预测进行拼接，对于一张图其最终的预测输出为[1,10647,85]。预测实现的具体细节再util.py的predict_transform方法中实现。

def predict_transform(prediction, inp_dim, anchors, num_classes, CUDA=True):
    """
        prediction[batch_size,C,H,W]-->[1,255,13,13]
        inp_dim=416
        anchors=[(116,90)，(156,198)，(373,326)]
        num_classses=80
    """
    batch_size = prediction.size(0)
    # stride表示整个网络的步长，等于原始图像大小除以feature map大小
    stride = inp_dim // prediction.size(2)#416/13=32
    # feature map每条边格子的个数
    grid_size = inp_dim // stride#416/32=13
    # 每个方框属性个数,x,y,h,w,置信度+类别个数
    bbox_attrs = 5 + num_classes
    num_anchors = len(anchors)
    #[1,255,13,13]-->[1,85x3,13x13]=[1,255,169]
    prediction = prediction.view(batch_size, bbox_attrs * num_anchors, grid_size * grid_size)
    #[1,255,169]-->[1,169,255]
    prediction = prediction.transpose(1, 2).contiguous()
    # [batch_size,单元格数量*每个单元格锚框个数,5+类别个数]
    #[1,169,255]-->[1,169x3,85]=[1,507,85]
    prediction = prediction.view(batch_size, grid_size * grid_size * num_anchors, bbox_attrs)
    anchors = [(a[0] / stride, a[1] / stride) for a in anchors]  # anchors在feature map上的大小

    # Sigmoid the  tx, ty. and object confidenccet。tx与ty为预测的坐标偏移值
    prediction[:, :, 0] = torch.sigmoid(prediction[:, :, 0])
    prediction[:, :, 1] = torch.sigmoid(prediction[:, :, 1])
    prediction[:, :, 4] = torch.sigmoid(prediction[:, :, 4])

    # 生成了每个格子的左上角坐标，生成的坐标为grid x grid的二维数组
    # a，b分别对应这个二维矩阵的x,y坐标的数组，a,b的维度与grid维度一样。
    # 每个grid cell的尺寸均为1，故grid范围是[0,12]（假如当前的特征图13*13）
    grid = np.arange(grid_size)
    a, b = np.meshgrid(grid, grid)
    # x_offset即cx,y_offset即cy，表示当前cell左上角坐标
    x_offset = torch.FloatTensor(a).view(-1, 1)
    y_offset = torch.FloatTensor(b).view(-1, 1)

    if CUDA:
        x_offset = x_offset.cuda()
        y_offset = y_offset.cuda()
    # 这里的x_y_offset对应的是最终的feature map中每个格子的左上角坐标，
    # 比如有13个格子，刚x_y_offset的坐标就对应为(0,0),(0,1)…(12,12)
    # .view(-1, 2)将tensor变成两列，unsqueeze(0)在0维上添加了一维。
    x_y_offset = torch.cat((x_offset, y_offset), 1).repeat(1, num_anchors).view(-1, 2).unsqueeze(0)

    prediction[:, :, :2] += x_y_offset  # bx=sigmoid(tx)+cx,by=sigmoid(ty)+cy

    # log space transform height and the width
    anchors = torch.FloatTensor(anchors)

    if CUDA:
        anchors = anchors.cuda()
    # 这里的anchors本来是一个长度为3的list(三个anchors)，然后在0维上(行)进行了grid_size*grid_size个复制，在1维(列)上一次复制(没有变化)，
    # 即对每个格子都得到三个anchor。Unsqueeze(0)的作用是在数组上添加一维，这里是在第0维上添加的。添加grid_size是为了之后的公式bw=pw×e^tw的tw。
    anchors = anchors.repeat(grid_size * grid_size, 1).unsqueeze(0)
    # 对网络预测得到的矩形框的宽高的偏差值进行指数计算，然后乘以anchors里面对应的宽高(这里的anchors里面的宽高是对应最终的feature map尺寸grid_size)，
    # 得到目标的方框的宽高，这里得到的宽高是相对于在feature map的尺寸
    # bw=pw*e^tw,bh=ph*e^th。anchors提供(ph,pw)。prediction为th,tw
    prediction[:, :, 2:4] = torch.exp(prediction[:, :, 2:4]) * anchors
    # 这里得到每个anchor中每个类别的得分。将网络预测的每个得分用sigmoid()函数计算得到
    prediction[:, :, 5: 5 + num_classes] = torch.sigmoid((prediction[:, :, 5: 5 + num_classes]))
    # 将相对于最终feature map的方框坐标和尺寸映射回原始输入图片(416x416)，即将方框的坐标乘以网络的stride即可
    prediction[:, :, :4] *= stride

    return prediction#[1,507,85]

目标检测

对预测的bounding box进行挑选

prediction对于一张图片预测了这么多bounding box，需要从中挑选最合适的几个。
1、预测框的置信度必须大于 objectness 分数阈值，将低于阈值的方框去掉。
2、通过非极大值抑制（NMS）去除重复度较大的框。
3、在80个类别中提取得分最高的那个类的得分max_conf，同时返回这个类对应的序号max_conf_score,
经过一系列操作，得到最终的输出为(ind,x1,y1,x2,y2,s,s_cls,index_cls)，ind 是这个预测框所属图片在这个一组图片中的序号，x1,y1为预测框的左上角坐标，x2,y2为预测框的右下角角坐标，s是这个方框含有目标的置信度,s_cls是这个方框中最有可能的类别的概率得分，index_cls是s_cls对应的这个类别所对应的序号.
上述过程通过util.py的write_results方法实现。

def write_results(prediction, confidence, num_classes, nms_conf=0.4):
    '''
    prediction: 输入的预测shape维度(1,10647, 85)
    confidence:0.5
    num_classes:80
    '''
    #得到预测种含有目标置信度大于confidence的数据
    conf_mask = (prediction[:, :, 4] > confidence).float().unsqueeze(2)
    # conf_mask中置信度大于confidence的方框所对应的含有目标的得分为1
    # 根据numpy的广播原理，它会扩展成与prediction维度一样的tensor，所以含有目标的得分小于confidence的方框所有的属性都会变为0，故如果没有检测任何有效目标,则返回值为0
    prediction = prediction * conf_mask
    '''
    保留预测结果中置信度大于阈值的bbox
    下面开始为nms准备
    '''
    # prediction的前五个数据分别表示 (Cx, Cy, w, h, score)，这里创建一个新的数组，大小与predicton的大小相同
    box_corner = prediction.new(prediction.shape)

    box_corner[:, :, 0] = (prediction[:, :, 0] - prediction[:, :, 2] / 2)  # x1 = Cx - w/2
    box_corner[:, :, 1] = (prediction[:, :, 1] - prediction[:, :, 3] / 2)  # y1 = Cy - h/2
    box_corner[:, :, 2] = (prediction[:, :, 0] + prediction[:, :, 2] / 2)  # x2 = Cx + w/2
    box_corner[:, :, 3] = (prediction[:, :, 1] + prediction[:, :, 3] / 2)  # y2 = Cy + h/2
    prediction[:, :, :4] = box_corner[:, :, :4]

    batch_size = prediction.size(0)

    write = False

    # 对每一张图片得分的预测值进行NMS操作，因为每张图片的目标数量不一样，所以有效得分的方框的数量不一样，
    # 没法将几张图片同时处理，因此一次只能完成一张图的置信度阈值的设置和NMS,不能将所涉及的操作向量化.
    # 所以必须在预测的第一个维度上（batch数量）上遍历每张图片，将得分低于一定分数的去掉，对剩下的方框进行进行NMS
    for ind in range(batch_size):
        # 选择此batch中第ind个图像的预测结果,image_pred对应一张图片中所有方框的坐标(x1,y1,x2,y2)以及得分，
        image_pred = prediction[ind]  #一个二维tensor 维度为10647x85
        # 只关心有最大值的类别分数，prediction[:, 5:]表示每一分类的分数,
        # 返回每一行中所有类别的得分最高的那个类的得分max_conf，同时返回这个类对应的序号max_conf_score
        max_conf, max_conf_score = torch.max(image_pred[:, 5:5 + num_classes], 1)
        # 维度扩展max_conf: shape=(10647,) => (10647,1)添加一个列的维度，max_conf变成二维tensor，尺寸为10647x1
        max_conf = max_conf.float().unsqueeze(1)
        max_conf_score = max_conf_score.float().unsqueeze(1)
        # 我们移除了每一行的这 80 个类别分数，只保留bbox4个坐标以及objectnness分数，转而增加了有最大值的类别分数及索引。
        seq = (image_pred[:, :5], max_conf, max_conf_score)
        # 将每个方框的(x1,y1,x2,y2,s)与得分最高的这个类的分数s_cls(max_conf)和对应类的序号index_cls(max_conf_score)在列维度上连接起来，
        # 即将10647x5,10647x1,10647x1三个tensor 在列维度进行concatenate操作，得到一个10647x7的tensor,(x1,y1,x2,y2,s,s_cls,index_cls)。
        image_pred = torch.cat(seq, 1)  # shape=(10647, 5+1+1=7)
        # image_pred[:,4]是长度为10647的一维tensor,维度为4的列是置信度分数。假设有15个框含有目标的得分非0，返回15x1的tensor
        non_zero_ind = (torch.nonzero(image_pred[:, 4]))  # torch.nonzero返回的是索引
        try:
            image_pred_ = image_pred[non_zero_ind.squeeze(), :].view(-1, 7)
        except:
            continue

        if image_pred_.shape[0] == 0:  # 当没有检测到时目标时，我们使用 continue 来跳过对本图像的循环，即进行下一次循环。
            continue

        # 获取当前图像检测结果中出现的所有类别
        img_classes = unique(image_pred_[:, -1])  # -1 index holds the class index

        for cls in img_classes:

            # 获取含有该类别的预测数据
            cls_mask = image_pred_ * (image_pred_[:, -1] == cls).float().unsqueeze(1)
            class_mask_ind = torch.nonzero(cls_mask[:, -2]).squeeze()
            image_pred_class = image_pred_[class_mask_ind].view(-1, 7)
            # 开始NMS
            # 按置信度对含有该类别的预测框进行从大到小排序，并获取其下标
            # confidence is at the top
            conf_sort_index = torch.sort(image_pred_class[:, 4], descending=True)[1]
            image_pred_class = image_pred_class[conf_sort_index]
            idx = image_pred_class.size(0)  # Number of detections

            for i in range(idx):
                # Get the IOUs of all boxes that come after the one we are looking at
                # in the loop
                try:
                    ious = bbox_iou(image_pred_class[i].unsqueeze(0), image_pred_class[i + 1:])
                except ValueError:
                    '''
                    在for i in range(idx):这个循环中，因为有一些框(在image_pred_class对应一行)会被去掉，image_pred_class行数会减少，
                    这样在后面的循环中，idx序号会超出image_pred_class的行数的范围，出现ValueError错误。
                    所以当抛出这个错误时，则跳出这个循环，因为此时已经没有更多可以去掉的方框了。
                 '''
                    break

                except IndexError:
                    break

                # 选取IOU<阈值的框
                iou_mask = (ious < nms_conf).float().unsqueeze(1)
                image_pred_class[i + 1:] *= iou_mask

                # 保留那些非零的行数据
                non_zero_ind = torch.nonzero(image_pred_class[:, 4]).squeeze()
                image_pred_class = image_pred_class[non_zero_ind].view(-1, 7)
            # new()创建了一个和image_pred_class相同的tensor，tensor行数等于cls这个类别所有的方框经过NMS剩下的方框的个数，
            # 即image_pred_class的行数，列数为1.
            # 再将生成的这个tensor所有元素赋值为这些方框所属图片对应于batch中的序号ind(一张图片有多个类别)，用fill_(ind)实现
            batch_ind = image_pred_class.new(image_pred_class.size(0), 1).fill_(
                ind)  # Repeat the batch_id for as many detections of the class cls in the image
            seq = batch_ind, image_pred_class

            if not write:
                # 将batch_ind, image_pred_class在列维度上进行连接，image_pred_class每一行存储的是(x1,y1,x2,y2,s,s_cls,index_cls)，
                # 现在在第一列增加了一个代表这个行对应方框所属图片在一个batch中的序号ind
                output = torch.cat(seq, 1)
                write = True
            else:
                out = torch.cat(seq, 1)
                output = torch.cat((output, out))

    try:
        return output
    except:
        return 0

在原图中绘制预测结果

在detect.py的write方法中实现。

# x为映射到原始图片中一个方框的属性(ind,x1,y1,x2,y2,s,s_cls,index_cls)，
# results列表保存了所有测试图片，一个元素对应一张图片
def write(x, results):
    c1 = tuple(x[1:3].int())  # c1为方框左上角坐标x1,y1
    c2 = tuple(x[3:5].int())  # c2为方框右下角坐标x2,y2
    img = results[int(x[0])]  # 在results中找到x方框所对应的图片，x[0]为方框所在图片在所有测试图片中的序号
    cls = int(x[-1])
    color = random.choice(colors)
    label = "{0}".format(classes[cls])
    cv2.rectangle(img, c1, c2, color, 1)  # 在图片上画出(x1,y1,x2,y2)矩形，即我们检测到的目标方框
    t_size = cv2.getTextSize(label, cv2.FONT_HERSHEY_PLAIN, 1, 1)[0]  # 得到一个包含目标名字字符的方框的宽高
    c2 = c1[0] + t_size[0] + 3, c1[1] + t_size[1] + 4
    cv2.rectangle(img, c1, c2, color, -1)  # 在图片上画一个实心方框，我们将在方框内放置目标类别名字
    cv2.putText(img, label, (c1[0], c1[1] + t_size[1] + 4), cv2.FONT_HERSHEY_PLAIN, 1, [225, 255, 255], 1);
    return img

程序运行中的问题

我测试代码时发现运行完，检测的结果并没有保存到我的图片目录下，后来发现是因为我在windows下运行的原因，需要修改detect.py的该处代码，因为windows和Linux的分隔符不同，所以图片未能保存。

修改之处

参考文章：

https://blog.csdn.net/qq_34199326/article/details/84072505
https://zhuanlan.zhihu.com/p/49556105