1. Square Inference理论概要

为了说明什么是Rectangular inference（矩形推理），就得先说说什么是 Square Inference（正方形推理）。

YOLOv3下采样了32倍，因此输入网络的长宽需要是32的倍数，最常用的分辨率就是416了。Square Inference就是输入为正方形，具体过程为：求得较长边缩放到416的比例，然后对图片长宽按这个比例缩放，使得较长边达到416再对较短边进行填充使得较短边也达到416。

2. Rectangular inference理论概要

可以看到，上面的图片中存在大量的冗余部分，一个很自然的想法就是，能不能去掉这些填充的部分但是又要满足长宽是32的倍数？

具体过程：将较长边设定为目标尺寸416/512…(必须是32的倍数)，短边按比例缩放，再对短边进行较少填充使短边满足32的倍数。

Padding逻辑：（固定目标size）

确定目标size的宽高比P。新图宽高比大于P，则宽resize到目标尺寸，上下padding黑边；新图宽高比小于P，则高resize到目标尺寸，左右padding黑边。

在yolov3spp中，在训练的时候使用的马赛克mosaic来进行数据增强；Rectangular inference只是在推理阶段来使用，目的是显著的减少推理时间。推理阶段的Rectangular inference主要是通过letterbox函数来实现的。

3. Rectangular inference实现代码

YOLOv3-SPP代码：

def letterbox(img: np.ndarray, new_shape=(416, 416), color=(114, 114, 114),
              auto=True, scale_fill=False, scale_up=True):
    """
    将图片缩放调整到指定大小
    :param img: 原图 hwc=(375,500,3)
    :param new_shape: 缩放后的最长边大小
    :param color: pad的颜色
    :param auto: True 保证缩放后的图片保持原图的比例 即 将原图最长边缩放到指定大小，再将原图较短边按原图比例缩放（不会失真）
                 False 将原图最长边缩放到指定大小，再将原图较短边按原图比例缩放,最后将较短边两边pad操作缩放到最长边大小（不会失真）
    :param scale_fill: True 简单粗暴的将原图resize到指定的大小 相当于就是resize 没有pad操作（失真）
    :param scale_up: True  对于小于new_shape的原图进行缩放,大于的不变
                     False 对于大于new_shape的原图进行缩放,小于的不变
    :return: img: letterbox后的图片 HWC
             ratio: wh ratios
             (dw, dh): w和h的pad
    """
    shape = img.shape[:2]  # 原图大小[h, w] = [375, 500]
    if isinstance(new_shape, int):
        new_shape = (new_shape, new_shape)  # (512, 512)
    # scale ratio (new / old)   1.024
    r = min(new_shape[0] / shape[0], new_shape[1] / shape[1])
    if not scale_up:  # (for better test mAP) scale_up = False 对于大于new_shape（r<1）的原图进行缩放,小于new_shape（r>1）的不变
        r = min(r, 1.0)
    # compute padding
    ratio = r, r  # width, height ratios  (1.024, 1.024)
    new_unpad = int(round(shape[1] * r)), int(round(shape[0] * r))  # wh(512, 384) 保证缩放后图像比例不变
    dw, dh = new_shape[1] - new_unpad[0], new_shape[0] - new_unpad[1]  # wh padding dw=0 dh=128
    if auto:  # minimun rectangle 保证原图比例不变，将图像最大边缩放到指定大小
        # 这里的取余操作可以保证padding后的图片是32的整数倍(416x416)，如果是(512x512)可以保证是64的整数倍
        dw, dh = np.mod(dw, 64), np.mod(dh, 64)  # wh padding dw=0 dh=0
    elif scale_fill:  # stretch 简单粗暴的将图片缩放到指定尺寸
        dw, dh = 0, 0
        new_unpad = new_shape
        ratio = new_shape[0] / shape[1], new_shape[1] / shape[0]  # wh ratios
    dw /= 2  # divide padding into 2 sides 将padding分到上下，左右两侧
    dh /= 2
    # shape:[h, w]  new_unpad:[w, h]
    if shape[::-1] != new_unpad:  # 将原图resize到new_unpad（长边相同，比例相同的新图）
        img = cv2.resize(img, new_unpad, interpolation=cv2.INTER_LINEAR)
    top, bottom = int(round(dh - 0.1)), int(round(dh + 0.1))  # 计算上下两侧的padding
    left, right = int(round(dw - 0.1)), int(round(dw + 0.1))  # 计算左右两侧的padding
    img = cv2.copyMakeBorder(img, top, bottom, left, right, cv2.BORDER_CONSTANT, value=color)  # add border/pad
    return img, ratio, (dw, dh)
# 推理阶段的自定义数据集
class LoadImagesAndLabels(Dataset):  # for training/testing
    def __init__(self,
                 path,   # 指向data/my_train_data.txt路径或data/my_val_data.txt路径
                 # 这里设置的是预处理后输出的图片尺寸
                 # 当为训练集时，设置的是训练过程中(开启多尺度)的最大尺寸
                 # 当为验证集时，设置的是最终使用的网络大小
                 img_size=416,
                 batch_size=16,
                 augment=False,  # 训练集设置为True(augment_hsv)，验证集设置为False
                 hyp=None,  # 超参数字典，其中包含图像增强会使用到的超参数
                 rect=False,  # 是否使用rectangular training
                 cache_images=False,  # 是否缓存图片到内存中
                 single_cls=False, pad=0.0, rank=-1):
    ...
    # Rectangular Training https://github.com/ultralytics/yolov3/issues/232
    # 如果为ture，训练网络时，会使用类似原图像比例的矩形(让最长边为img_size)，而不是img_size x img_size
    # 注意: 开启rect后，mosaic就默认关闭
    if self.rect:
        # Sort by aspect ratio
        s = self.shapes  # wh
        # 计算每个图片的高/宽比
        ar = s[:, 1] / s[:, 0]  # aspect ratio
        # argsort函数返回的是数组值从小到大的索引值
        # 按照高宽比例进行排序，这样后面划分的每个batch中的图像就拥有类似的高宽比
        irect = ar.argsort()
        # 根据排序后的顺序重新设置图像顺序、标签顺序以及shape顺序
        self.img_files = [self.img_files[i] for i in irect]
        self.label_files = [self.label_files[i] for i in irect]
        self.shapes = s[irect]  # wh
        ar = ar[irect]
        # set training image shapes
        # 计算每个batch采用的统一尺度
        # 这部分的代码可能会比较难以理解，但是简单来说就是将较长边设置为指定的尺度大小，然后较短边按比例缩放
        shapes = [[1, 1]] * nb  # nb: number of batches
        for i in range(nb):
            ari = ar[bi == i]  # bi: batch index
            # 获取第i个batch中，最小和最大高宽比
            mini, maxi = ari.min(), ari.max()
            # 如果高/宽小于1(w > h)，将w设为img_size
            if maxi < 1:
                shapes[i] = [maxi, 1]
            # 如果高/宽大于1(w < h)，将h设置为img_size
            elif mini > 1:
                shapes[i] = [1, 1 / mini]
        # 计算每个batch输入网络的shape值(向上设置为32的整数倍)
        self.batch_shapes = np.ceil(np.array(shapes) * img_size / 32. + pad).astype(np.int) * 32
    ...
    # 这里分别命名是为了防止出现rect为False/True时混用导致计算的mAP错误
    # 当rect为True时会对self.images和self.labels进行从新排序
    if rect is True:
        np_labels_path = str(Path(self.label_files[0]).parent) + ".rect.npy"  # saved labels in *.npy file
    else:
        np_labels_path = str(Path(self.label_files[0]).parent) + ".norect.npy"
    ...
    def __getitem__(self, index):
        hyp = self.hyp
        # train: 训练阶段使用mosaic来数据增强
        if self.mosaic:
            # load mosaic
            img, labels = load_mosaic(self, index)
            shapes = None
        # inference：推理阶段使用Rectangular inference加快推理时间
        else:
            # load image
            img, (h0, w0), (h, w) = load_image(self, index)
            # 通过letterbox来对一批比较相近的数据进行填充处理
            shape = self.batch_shapes[self.batch[index]] if self.rect else self.img_size  # final letterboxed shape
            img, ratio, pad = letterbox(img, shape, auto=False, scale_up=self.augment)
            shapes = (h0, w0), ((h / h0, w / w0), pad)  # for COCO mAP rescaling
    ...
    # 对一个batch的数据进行处理，当调用了batch_size次 getitem 函数后才会调用一次这个函数，对batch_size张图片和对应的label进行打包。
    @staticmethod
    def collate_fn(batch):
        """
        :param batch: 里面有batch_size个元组 对应的是调用了batch_size次getitem函数的返回值
        :return: img=[batch_size, 3, 736, 736]
                 label=[target_sums, 6]  6：表示当前target属于哪一张图+class+x+y+w+h
                 path     shapes      index
        """
        # img: 一个tuple 由batch_size个tensor组成 每个tensor表示一张图片
        # label: 一个tuple 由batch_size个tensor组成 每个tensor存放一张图片的所有的target信息
        #        label[6, object_num] 6中的第一个数代表一个batch中的第几张图
        # path: 一个tuple 由4个str组成, 每个str对应一张图片的地址信息
        # index: 一个tuple (index1, index2, index3...) 存放着当前batch中每张图片的index
        img, label, path, shapes, index = zip(*batch)  # transposed
        for i, l in enumerate(label):
            l[:, 0] = i  # add target image index for build_targets()
        # 返回的img=[batch_size, 3, 736, 736]
        #      torch.stack(img, 0): 将batch_size个[3, 736, 736]的矩阵拼成一个[batch_size, 3, 736, 736]
        # label=[target_sums, 6]  6：表示当前target属于哪一张图+class+x+y+w+h
        #      torch.cat(label, 0): 将[n1,6]、[n2,6]、[n3,6]...拼接成[n1+n2+n3+..., 6]
        # 这里之所以拼接的方式不同是因为img拼接的时候它的每个部分的形状是相同的，都是[3, 736, 736]
        # 而我label的每个部分的形状是不一定相同的，每张图的目标个数是不一定相同的（label肯定也希望用stack,更方便,但是不能那样拼）
        # 如果每张图的目标个数是相同的，那我们就可能不需要重写collate_fn函数了
        return torch.stack(img, 0), torch.cat(label, 0), path, shapes, index

既然可以 Rectangular Inference ，很自然又想到训练的时候能不能也这样？但是显然，训练的时候情况就比较复杂了，因为我们是批次训练的，要保证这个batch里面的图片shape是一样的，所以最常见的就是Square training，例如YOLO默认就是图片416x416输入，SSD300x300等等。而Faster RCNN系列、Retinanet就不是固定尺寸的正方形输入，因此一开始Faster RCNN实现往往都是将batch size = 1。而现在有些实现是可以batch size > 1，因为可以取这个batch中的最大的长和宽，然后图片都填充到这个max width和max height。但是这样显然还是比较浪费的，因为如果一个batch中的不同图片wh差距很大，小图片就太吃亏了啊。

所以如果训练的图片尺寸都是相同的或者相近的，那这个就有很大优势了。这就是一个小trick，在YOLOv3spp中实现主要就是优化了一下如何将比例相近的图片放在一个batch，这样显然填充的就更少一些了。这一部分是在自定义数据集中的__init__部分来实现的。作者说是这样做在混合了不同长宽比例的COCO数据集上快了1/3。

这里将batchsize设置为4的推理信息如下所示：

完整输出：

Using cuda device training.
Using 4 dataloader workers
Caching labels (5823 found, 0 missing, 0 empty, 0 duplicate, for 5823 images): 1
Model Summary: 225 layers, 6.26756e+07 parameters, 6.26756e+07 gradients, 117.2 GFLOPS
loading eval info for coco tools.: 100%|██| 5823/5823 [00:00<00:00, 6763.89it/s]
creating index...
index created!
validation...: 100%|████████████████████████| 1456/1456 [02:47<00:00,  8.67it/s]
Accumulating evaluation results...
DONE (t=1.19s).
IoU metric: bbox
 Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.597
 Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.816
 Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.658
 Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.221
 Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.467
 Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.688
 Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.477
 Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.684
 Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.698
 Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.352
 Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.587
 Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.769
 aeroplane      : 0.8407435368970886
 bicycle        : 0.841055733098646
 bird           : 0.8191967600842852
 boat           : 0.6946511199916087
 bottle         : 0.7231628774949694
 bus            : 0.8887323806647173
 car            : 0.8511586393361052
 cat            : 0.9073166258716362
 chair          : 0.699768122727234
 cow            : 0.8731324121446061
 diningtable    : 0.7171696892135374
 dog            : 0.8655392489181959
 horse          : 0.8825577798170706
 motorbike      : 0.9061020838132525
 person         : 0.8901775880333556
 pottedplant    : 0.6108321500054713
 sheep          : 0.8503812741255414
 sofa           : 0.7055372676420307
 train          : 0.9066429729563691
 tvmonitor      : 0.8405858721013346

4. Rectangular inference顺序排序

在yolo的代码中，其实Rectangular inference还结合了其他的tirck。比如说，会统计数据集中所有图像的宽高，来按宽高比进行排序，这样确保了比例类似的图片会在一个batch中，然后对这个batch的图像进行填充到一个相同的维度，再拼接成一起成为一个大的tensor。这样就减少了需要填充处理的时间，因为比例都是类似的，就说明不需要填充太多的，填充所需要的时间也将更少。填充处理是通过letterbox函数来实现的。

不过，需要注意，因为这里yolo是对batch是做了一点处理，也就是将数据是按宽高比来进行排序的，所以在推理阶段的时候不能低数据进行随机采样，我想到了这一点，那么dataloader进行采样的时候参数Shuffle应该为Fasle的，而且def getitem(self, index)中的参数index就是应该是从0开始，对排列好的数据进行顺序采样进行的，查看了代码已经调试了一下，证实了我的想法是正确的。

validation.py

# inference阶段的数据集定义与采集
val_dataset = LoadImagesAndLabels(test_path, parser_data.img_size, batch_size,
                                  hyp=parser_data.hyp,
                                  # 将每个batch的图像调整到合适大小，可减少运算量(并不是512x512标准尺寸)
                                  rect=True)  # 注意到这里是使用了Rectangular inference
val_dataset_loader = torch.utils.data.DataLoader(val_dataset,
                                                 batch_size=batch_size,
                                                 shuffle=False,    # 注意到这里是设置为False的
                                                 num_workers=nw,
                                                 pin_memory=True,
                                                 collate_fn=val_dataset.collate_fn)