从零开始实现yolox三：模型推理

按照正常顺序，应该是先讲训练，再讲测试，但模型的训练过程中，每训练完一个epoch都会做一次测试，训练的时候包括标签分配、损失函数计算，测试的时候包括损失函数计算、输出值解码、非极大值抑制、mAP的计算等，这几部分是目标检测任务中最难的，程序非常复杂。如果先讲训练的话，势必要一块讲测试，这么多内容一篇博客很难讲完，因此我这里先介绍模型的推理，即导入预训练模型在指定图片上做预测，在这个过程中，包括了输出解码、非极大值抑制、在原始图片上绘制目标框等，这样的话，讲训练的时候，内容就会少一些。

1 输出解码

从刚刚的显示结果可以看到三个yolo检测头的输出形状（shape），现在要将这些检测头的输出转化为图片中目标的类型、目标的位置参数（边框中心点坐标和高宽）、目标的置信度等信息。

在yolox_from_scratch/utils中增加一个名为utils_bbox.py的文件

在该文件中加上下面的代码：

import torch


def decode_outputs(outputs, input_shape):
    """

    Args:
        outputs:列表，里面的元素分别为各个检测头的输出
        input_shape:列表或元组，里面的两个元素分别为模型输入图片的高宽，如[640, 640]

    Returns:

    """

    """以下代码的注释，都是假设只有三个检测头，要检测的类别数是80，input_shape为[640, 640]的情况下的结果"""
    grids = []
    strides = []
    hw = [x.shape[-2:] for x in outputs]    # 三个检测头输出结果的高宽
    outputs = torch.cat([x.flatten(start_dim=2) for x in outputs], dim=2).permute(0, 2, 1)
    # [x.flatten(start_dim=2) for x in outputs]每次获得的x都是4个维度，
    # 第一个x的维度为torch.Size([batch_size, 85, 80, 80])
    # x.flatten(start_dim=2) 表示从2号维度开始打平，打平后的维度为torch.Size([batch_size, 85, 6400])
    # 列表推导式获得的列表中，有三个张量，维度分别为(batch_size, 85, 6400)、(batch_size, 85, 1600)、(batch_size, 85, 400)
    # torch.cat将列表中的三个张量按指定维度（dim=2）拼接进行拼接，得到的张量维度为torch.Size([batch_size, 85, 8400])
    # .permute(0, 2, 1)表示调整维度顺序，得到的张量维度为torch.Size([batch_size, 8400, 85])
    # 最后的outputs的shape变为torch.Size([batch_size, 8400, 85])

    outputs[:, :, 4:] = torch.sigmoid(outputs[:, :, 4:])
    # 最后一个维度，前面4个数是中心点坐标和高宽，从第5个数是执行都，后面是各个类别的概率，
    # 这里使用sigmoid函数将置信度和各个类别的概率压缩到0-1之间

    for h, w in hw:
        """循环中代码的注释时在第一轮循环时的结果，第一次循环，h和w是第一个特征图（dark3）的高宽，它们都是80
        第二轮循环h和w是40，第三轮循环h和w是20"""
        # 根据特征层生成网格点
        grid_y, grid_x = torch.meshgrid([torch.arange(h), torch.arange(w)])
        # grid_y和grid_x的维度都是torch.Size([80, 80])

        grid = torch.stack((grid_x, grid_y), 2).view(1, -1, 2)
        # shape为torch.Size([1, 6400, 2])，最后一个维度是2，为网格点的横纵坐标，而6400表示当前特征层的网格点数量
        # torch.stack((grid_x, grid_y), 2)对张量进行扩维拼接，返回的shape为torch.Size([80, 80, 2])
        # 关于torch.stack的用法，可以看这篇博客：https://blog.csdn.net/Teeyohuang/article/details/80362756/

        shape = grid.shape[:2]      # shape为torch.Size([1, 6400])

        grids.append(grid)
        strides.append(torch.full((shape[0], shape[1], 1), input_shape[0] / h))
        # input_shape[0]/h 获得当前特征图（检测头对应的特征图）高h方向的步长，这个步长也是宽w方向上的步长
        # 因为因为输入图片和检测头输出的特征图，在高和宽两个方向上的缩放比例是一样的，所以步长也是一样
        # torch.full((shape[0], shape[1], 1), input_shape[0]/h是由步长填充而成的张量

    # 将网格点堆叠到一起
    grids = torch.cat(grids, dim=1).type(outputs.type())        # torch.cat是让张量按照指定维度拼接，但得到的新张量维度数不会变
    # grides的维度为(1, 8400, 2),中间的8400表示8400个特征点

    strides = torch.cat(strides, dim=1).type(outputs.type())    # .type(outputs.type())指定张量的类型
    # strides的维度为(1, 8400, 1)

    # 根据网格点进行解码
    outputs[..., :2] = (outputs[..., :2] + grids) * strides     # 解码得到中心点的坐标
    # 因为outputs[..., :2]是在0-1之间，而且其表示的中心点坐标是相对于网格点进行归一化后的，现在要将其转变成相对于整张图片
    outputs[..., 2:4] = torch.exp(outputs[..., 2:4]) * strides  # 解码得到预测框的高宽

    # 归一化（相对于图片大小）
    outputs[..., [0, 2]] = outputs[..., [0, 2]] / input_shape[1]
    outputs[..., [1, 3]] = outputs[..., [1, 3]] / input_shape[0]

    # 返回的outputs的维度为(batch_size, 8400, 85)
    return outputs

在yolox_from_scratch下新建一个名为decode_test.py的测试脚本，

decode_test.py的内容如下：

import torch

from utils.utils import load_model
from nets.yolo import YoloBody
from utils.utils_bbox import decode_outputs

if __name__ == '__main__':
    """模型的导入"""
    # 模型路径
    model_path = "model_data/yolox_s.pth"
    # 新建模型
    model = YoloBody(80, 's')  # 's'表示新建的为yolox_s模型
    # 导入模型权重
    load_model(model, model_path, 'cpu')

    """生成模拟数据"""
    image_data = torch.rand(8, 3, 640, 640)

    """将图片（模拟数据）输入到模型中"""
    outputs = model(image_data)

    """对输出进行解码"""
    input_shape = (640, 640)
    outputs = decode_outputs(outputs, input_shape)
    print(outputs.shape)
    print(outputs)

输出如下：

OK，说明解码成功！

2 对预测框进行筛选（置信度过滤和非极大值抑制）

一张640x640的图片输入到模型，会有8400个预测框，图片中不可能有那么目标，即便有，也无法绘制出来，我们需要对预测框进行筛选。筛选共分为两轮，第一轮是把置信度（目标置信度）低的预测框给过滤掉，第二轮是NMS，由于第一轮比较简单，并且两轮都需要遍历图片，所以我们把两轮写到同一个函数中。

在yolox_from_scratch\utils\utils_bbox.py中增加一个函数：

def non_max_suppression(prediction, conf_thres=0.5, nms_thres=0.4):
    """
    使用置信度过滤和非极大值抑制
    Args:
        prediction: 模型的预测结果（经过解码后的数据），
                如果要预测80个类别，那么prediction的维度为torch.Size([batch_size, num_anchors, 85])
        conf_thres: 置信度阈值
        nms_thres: NMS阈值

    Returns:一个列表，其元素个数为batch_size，每个元组都是torch张量，对应每张图片经过两轮筛选后的结果，
            如果图片中存在目标，那么对应的元素维度为(num_objs, 7)，
                    7列的内容分别为：x1, y1, x2, y2, obj_conf, class_conf, class_pred，
            其中坐标为归一化后的数值，如果图片中不存在目标，那么对应的元素为None

    """

    # 将解码结果的中心点坐标和宽高转换成左上角和右下角的坐标
    box_corner = prediction.new(prediction.shape)
    box_corner[:, :, 0] = prediction[:, :, 0] - prediction[:, :, 2] / 2
    box_corner[:, :, 1] = prediction[:, :, 1] - prediction[:, :, 3] / 2
    box_corner[:, :, 2] = prediction[:, :, 0] + prediction[:, :, 2] / 2
    box_corner[:, :, 3] = prediction[:, :, 1] + prediction[:, :, 3] / 2
    prediction[:, :, :4] = box_corner[:, :, :4]

    output = [None for _ in range(len(prediction))]     # len(prediction))是batch_size，即图片数量
    for image_i, image_pred in enumerate(prediction):
        """第一轮过滤"""
        # 利用目标置信度（即对应的预测框存在要检测的目标的概率）做第一轮过滤
        image_pred = image_pred[image_pred[:, 4] >= conf_thres]

        # 如果当前图片中，所有目标的置信度都小于阈值，那么就进行下一轮循环，检测下一张图片
        if not image_pred.size(0):
            continue

        # 目标置信度乘以各个类别的概率，并对结果取最大值，获得各个预测框的score
        score = image_pred[:, 4] * image_pred[:, 5:].max(1)[0]
        # image_pred[:, 4]是置信度，image_pred[:, 5:].max(1)[0]是各个类别的概率最大值

        # 将image_pred中的预测框按score从大到小排序
        image_pred = image_pred[(-score).argsort()]
        # argsort()是将(-score)中的元素从小到大排序，返回排序后索引
        # 将(-score)中的元素从小到大排序，实际上是对score从大到小排序
        # 将排序后的索引放入image_pred中作为索引，实际上是对本张图片中预测出来的目标，按score从大到小排序

        # 获得第一轮过滤后的各个预测框的类别概率最大值及其索引
        class_confs, class_preds = image_pred[:, 5:].max(1, keepdim=True)
        # class_confs 类别概率最大值，class_preds 预测类别在80个类别中的索引

        # 将各个目标框的上下角点坐标、目标置信度、类别置信度、类别索引串起来
        detections = torch.cat((image_pred[:, :5], class_confs.float(), class_preds.float()), 1)
        # 经过上条命令之后，detections的维度为(number_pred, 7)
        # 7列的内容分别为：x1, y1, x2, y2, obj_conf, class_conf, class_pred

        """第二轮过滤"""
        keep_boxes = []     # 用来存储符合要求的目标框
        while detections.size(0):   # 如果detections中还有目标
            """以下标注是执行第一轮循环时的标注，后面几轮以此类推"""

            # 获得与第一个box（最大score对应的box）具有高重叠的预测框的布尔索引
            from utils.utils import bbox_iou
            large_overlap = bbox_iou(detections[0, :4].unsqueeze(0), detections[:, :4]) > nms_thres
            # bbox_iou(detections[0, :4].unsqueeze(0), detections[:, :4])返回值的维度为(num_objects, )
            # bbox_iou的返回值与非极大值抑制的阈值相比较，获得布尔索引
            # 即剩下的边框中，只有detection[0]的iou大于nms_thres的，才抑制，即认为这些边框与detection[0]检测的是同一个目标

            # 获得与第一个box相同类别的预测框的索引
            label_match = detections[0, -1] == detections[:, -1]
            # 布尔索引，获得所有与detection[0]相同类别的对象的索引

            # 获得需要抑制的预测框的布尔索引
            invalid = large_overlap & label_match   # &是位运算符，两个布尔索引进行位运算
            # 经过第一轮筛选后的剩余预测框，如果同时满足和第一个box有高重叠、类别相同这两个条件，那么就该被抑制
            # 这些应该被抑制的边框，其对应的索引即为无效索引

            # 获得被抑制预测框的置信度
            weights = detections[invalid, 4:5]

            # 加权获得最后的预测框坐标
            detections[0, :4] = (weights * detections[invalid, :4]).sum(0) / weights.sum()
            # 上面的命令是将当前边框，和被抑制的边框进行加权，
            # 类似于好几个边框都检测到了同一张人脸，将这几个边框的左上角点横坐标x进行加权（按照置信度加权），
            # 获得最后边框的x，对左上角点的纵坐标y，以及右下角点的横纵坐标也进行加权处理
            # 其他的obj_conf, class_conf, class_pred则使用当前box的

            keep_boxes += [detections[0]]       # 将第一个box加入到 keep_boxes 中
            detections = detections[~invalid]   # 去掉无效的预测框，更新detections

        if keep_boxes:                          # 如果keep_boxes不是空列表
            output[image_i] = torch.stack(keep_boxes)   # 将目标堆叠，然后加入到列表
            # 假设NMS之后，第i张图中有num_obj个目标，那么torch.stack(keep_boxes)的结果是就是一个(num_obj, 7)的张量，没有图片索引

        # 如果keep_boxes为空列表，那么output[image_i]则未被赋值，保留原来的值（原来的为None）
    return output

这里使用了一个名为bbox_iou的函数，它是用来求边框之间的IOU，具体看如下代码，将下面的函数加入到文件yolox_from_scratch\utils\utils.py中：

def bbox_iou(box1, box2, x1y1x2y2=True):
    """
    Returns the IoU of two bounding boxes
    Args:
        box1: 维度为(num_objects, 4)
        box2: 维度为(num_objects, 4)
        x1y1x2y2: 表示输入的目标框是否为上下角点坐标

    Returns:

    """

    # 获得边框左上角点和右下角点的坐标
    if not x1y1x2y2:
        # Transform from center and width to exact coordinates
        b1_x1, b1_x2 = box1[:, 0] - box1[:, 2] / 2, box1[:, 0] + box1[:, 2] / 2
        b1_y1, b1_y2 = box1[:, 1] - box1[:, 3] / 2, box1[:, 1] + box1[:, 3] / 2
        b2_x1, b2_x2 = box2[:, 0] - box2[:, 2] / 2, box2[:, 0] + box2[:, 2] / 2
        b2_y1, b2_y2 = box2[:, 1] - box2[:, 3] / 2, box2[:, 1] + box2[:, 3] / 2
    else:
        # Get the coordinates of bounding boxes
        b1_x1, b1_y1, b1_x2, b1_y2 = box1[:, 0], box1[:, 1], box1[:, 2], box1[:, 3]
        b2_x1, b2_y1, b2_x2, b2_y2 = box2[:, 0], box2[:, 1], box2[:, 2], box2[:, 3]

    # get the corrdinates of the intersection rectangle
    # 计算真实框与预测框的交集矩形的左上角点和右下角点的坐标
    inter_rect_x1 = torch.max(b1_x1, b2_x1)
    inter_rect_y1 = torch.max(b1_y1, b2_y1)
    inter_rect_x2 = torch.min(b1_x2, b2_x2)
    inter_rect_y2 = torch.min(b1_y2, b2_y2)

    # Intersection area交集面积
    inter_area = torch.clamp(inter_rect_x2 - inter_rect_x1 + 1, min=0) * torch.clamp(
        inter_rect_y2 - inter_rect_y1 + 1, min=0
    )
    # torch.clamp是上下限控制函数，这里使用这个函数，是因为真实框与目标框可能不存在交集
    # 那么inter_rect_x2-inter_rect_x1+1 或者 inter_rect_y2 - inter_rect_y1+1 就是负的
    # TODO 这里inter_rect_x2-inter_rect_x1+1，后面为什么要加1，有评论说是计算交集像素值
    # TODO 这里inter_rect_x2是相对于特征层的位置，这里不再深究，就先把问题放在这里

    # Union Area
    b1_area = (b1_x2 - b1_x1 + 1) * (b1_y2 - b1_y1 + 1)     # box1的面积
    b2_area = (b2_x2 - b2_x1 + 1) * (b2_y2 - b2_y1 + 1)     # box2的面积

    iou = inter_area / (b1_area + b2_area - inter_area + 1e-16)     # 计算交并比

    return iou

现在我们可以写一个测试脚本，来测试一下NMS。
在yolox_from_scratch下新建一个名为nms_test.py的文件

在nms_test.py中加入下面的程序：

import torch

from utils.utils import load_model
from nets.yolo import YoloBody
from utils.utils_bbox import decode_outputs, non_max_suppression

if __name__ == '__main__':
    """模型的导入"""
    # 模型路径
    model_path = "model_data/yolox_s.pth"
    # 新建模型
    model = YoloBody(80, 's')  # 's'表示新建的为yolox_s模型
    # 导入模型权重
    load_model(model, model_path, 'cpu')

    """生成模拟数据"""
    torch.manual_seed(0)
    image_data = torch.rand(8, 3, 640, 640)

    """将图片（模拟数据）输入到模型中"""
    outputs = model(image_data)

    """对输出进行解码"""
    input_shape = (640, 640)
    outputs = decode_outputs(outputs, input_shape)

    """置信度过滤和NMS"""
    result = non_max_suppression(outputs)

    for item in result:
        print(item)

为了能复现，我设置了pytorch随机种子，输出如下：

C:\Users\mzrs_wjh\Anaconda3\python.exe C:/yolox_from_scratch/nms_test.py
None
None
None
tensor([[0.5037, 0.0206, 0.5893, 0.1807, 0.7317, 0.7699, 0.0000]],
       grad_fn=<StackBackward>)
None
None
tensor([[0.7942, 0.0025, 0.8371, 0.1032, 0.7394, 0.7584, 0.0000],
        [0.4932, 0.4831, 0.6837, 0.7926, 0.6119, 0.7408, 0.0000]],
       grad_fn=<StackBackward>)
None

我们可以看到，模拟数据有8张图片，但只有两张图片中检测到了目标，其中一张图片中有一个目标，另一张图有两个目标

3 将预测框绘制在图片中

之前为了方便，一直使用模拟数据，现在我们来开始使用真实图片。
在yolox_from_scratch下新建一个名为img的文件夹，并将下面这张图片放入

现在的项目结构如下：

上述图片的像素是600*399，不能直接输入到模型中，因为输入图片必须是正方形，而且边长必须是32的倍数。

（1）对输入图片进行调整（letterbox及缩放）

这里调整到指定大小，不是直接暴力缩放，而是要高宽等比缩放，那么需要先使用letterbox算法，即在上下或者左右添加灰条，添加上灰条后再进行缩放。

在C:\yolox_from_scratch\utils\utils.py中，添加下面的函数：

def resize_image(image, size, letterbox_image):
    """
        对输入图像进行resize
    Args:
        image:PIL.Image.open的返回值，RGB三通道图像
        size:目标尺寸
        letterbox_image: bool 是否进行letterbox变换

    Returns:指定尺寸的图像

    """
    from PIL import Image
    iw, ih = image.size
    w, h = size
    if letterbox_image:
        scale = min(w/iw, h/ih)     # 获得长边对应的高宽比
        nw = int(iw*scale)          # 新的宽
        nh = int(ih*scale)          # 新的高

        image = image.resize((nw, nh), Image.BICUBIC)           # 调整原图的大小
        new_image = Image.new('RGB', size, (128, 128, 128))     # 生成画布
        new_image.paste(image, ((w-nw)//2, (h-nh)//2))          # 将调整后的图像放入画布中
    else:
        new_image = image.resize((w, h), Image.BICUBIC)
    return new_image

我们可以写一段测试代码

from PIL import Image
from utils.utils import resize_image

file_path = r"C:\yolox_from_scratch\img\person_and_dog.jpeg"

# 打开图片
img = Image.open(file_path)

# 缩放并进行letterbox转化
letterbox_img = resize_image(img, (640, 640), True)

print(letterbox_img.size)

输出

(640, 640)

（2）将边框绘制在图片中

这部分不难，但却非常琐碎，也花了我最多的时间

先将字体文件simhei.ttf和coco类名文件下载下来，复制到yolox_from_scratch/model_data中，结果如下：

类名文件的下载链接：https://github.com/pjreddie/darknet/blob/master/data/coco.names

将下面这段代码是绘制边框的函数，将其复制到yolox_from_scratch\utils\utils_bbox.py中

def draw_boxes(image, outputs, font_file, class_names, colors_list=[]):
    """
    在图片上画框
    Args:
        image: 要画框的图片，PIL.Image.open的返回值
        outputs: 一个列表，NMS后的结果，其中的坐标为归一化后的坐标
        font_file:字体文件路径
        class_names:类名列表
        colors_list:颜色列表

    Returns:

    """
    # 根据图片的宽，动态调整字体大小
    font_size = np.floor(3e-2 * image.size[1] + 0.5).astype('int32')
    font = ImageFont.truetype(font=font_file, size=font_size)  # 创建字体对象，包括字体和字号
    draw = ImageDraw.Draw(image)                # 将letterbox_img作为画布

    for output in outputs:                      # ouput是每张图片的检测结果，当然这里batch_size为1就是了
        if output is not None:
            for obj in output:                  # 一张图片可能有多个目标，obj就是其中之一
                """从obj中获得信息"""
                box = obj[:4] * 640             # 将归一化后的坐标转化为输入图片（letterbox_img）中的坐标
                cls_index = int(obj[6])         # 类别索引
                score = obj[4] * obj[5]         # score，可以理解为类别置信度
                x1, y1, x2, y2 = map(int, box)          # 转化为整数
                pred_class = class_names[cls_index]     # 目标类别名称
                color = 'red'                           # TODO 具体使用时，还得改成colors_list[cls_index]

                """组建要显示的文字信息"""
                label = ' {} {:.2f}'.format(pred_class, score)
                print(label, x1, y1, x2, y2)

                """获得文字的尺寸"""
                label_size = draw.textsize(label, font)
                label = label.encode('utf-8')

                """防止文字背景框在上边缘越界"""
                if y1 - label_size[1] >= 0:
                    text_origin = np.array([x1, y1 - label_size[1]])
                else:
                    # 如果越界，则将文字信息写在边框内部
                    text_origin = np.array([x1, y1 + 1])

                """绘制边框"""
                thickness = 2               # 边框厚度
                for i in range(thickness):  # 根据厚度确定循环的执行次数
                    draw.rectangle([x1 + i, y1 + i, x2 - i, y2 - i], outline=color)  # colors[cls_index]

                """绘制文字框"""
                draw.rectangle([tuple(text_origin), tuple(text_origin + label_size)], fill=color)   # 背景
                draw.text(text_origin, str(label, 'UTF-8'), fill=(0, 0, 0), font=font)              # 文字
            del draw

    return image

好的，现在我们来写一个测试脚本，新建一个名为draw_box_test.py的脚本

将下面这段代码写入：

from PIL import Image, ImageFont

import numpy as np
import torch

from nets.yolo import YoloBody
from utils.utils_bbox import decode_outputs, non_max_suppression, draw_boxes
from utils.utils import preprocess_input, resize_image, load_model


"""图片导入及预处理"""
file_path = r"C:\Users\mzrs_wjh\Desktop\01\person_and_dog.jpeg"    # 图片路径
img = Image.open(file_path)                             # 打开图片
letterbox_img = resize_image(img, (640, 640), True)     # 缩放并进行letterbox转化

# 使用ImageNet的均值和方差对图片进行归一化
img_data = preprocess_input(np.array(letterbox_img, dtype='float32'))
img_data = np.transpose(img_data, (2, 0, 1))            # 调整图片的维度
img_data = np.expand_dims(img_data, 0)                  # 添加batch_size维度
images = torch.from_numpy(img_data)                     # 将图片数据转化为torch张量

"""模型导入与推理"""
model_path = "model_data/yolox_s.pth"       # 模型路径
class_path = "model_data/coco.names"        # 类名文件
font_path = "model_data/simhei.ttf"         # 字体文件

"""获得类名列表"""
with open(class_path, 'r') as f:
    class_names = f.read().split("\n")[:-1]         # 最后一个去掉，是因最后一个字符是空格

"""建立模型对象并导入权重"""
model = YoloBody(80, 's')                   # 新建模型,'s'表示新建的为yolox_s模型
load_model(model, model_path, 'cpu')        # 导入模型权重

with torch.no_grad():
    outputs = model(images)                         # 模型推理
    outputs = decode_outputs(outputs, [640, 640])   # 输出解码
    outputs = non_max_suppression(outputs)          # NMS
    letterbox_img = draw_boxes(letterbox_img, outputs, font_file=font_path, class_names=class_names)    # 画框
    # 这里之所以用letterbox，是因为我们获得的预测框，坐标是在letterbox_ima上的

letterbox_img.show()

控制台输出：

 person 0.92 44 112 280 435
 dog 0.73 260 136 559 437

屏幕显示：

好的，除了边框颜色之外，基本达到目的。

（3）对输出边框进行调整

我们刚刚是在letterbox后的图片中画框的，如果我们想在原图中画框，只需要把上下角点坐标转化一下即可。
我们先建一个图像保存的文件夹，名为img_out

然后在yolox_from_scratch\utils\utils_bbox.py中加入下面的函数：

def yolo_correct_boxes(outputs, input_shape, image_shape, is_letterbox):
    """

    Args:
        outputs: 一个列表，NMS后的输出，详见non_max_suppression的函数文档
        input_shape:输入图片尺寸，列表或数组
        image_shape:图片原尺寸，列表或数组
        is_letterbox:布尔值，是否对原图进行过letterbox处理

    Returns:

    """
    if is_letterbox:
        for output in outputs:  # output是单张图片中检测到的目标
            if output is not None:
                # 输入图像与真实图像比例
                scale = np.min(np.array(input_shape) / np.array(image_shape))
                # 左右、上下的灰条宽度
                offset = (np.array(input_shape)-np.array(image_shape) * scale)/input_shape / 2.

                # 将letterbox中的坐标转化为原图像中的坐标（归一化后的坐标）
                output[:, 0] = (output[:, 0] - offset[0]) / scale
                output[:, 1] = (output[:, 1] - offset[1]) / scale
                output[:, 2] = (output[:, 2] - offset[0]) / scale
                output[:, 3] = (output[:, 3] - offset[1]) / scale

接下来在yolox_from_scratch中新建一个名为draw_box_test2.py的脚本，

将下列代码写入：

from PIL import Image, ImageFont

import numpy as np
import torch

from nets.yolo import YoloBody
from utils.utils import cvtColor, preprocess_input, resize_image, load_model
from utils.utils_bbox import decode_outputs, non_max_suppression, draw_boxes, yolo_correct_boxes

"""图片导入及预处理"""
file_path = r"C:\Users\mzrs_wjh\Desktop\01\person_and_dog.jpeg"    # 图片路径
img = Image.open(file_path)                             # 打开图片
img = cvtColor(img)                                     # 使用cvtColor，这样即便是灰度图，也能检测
letterbox_img = resize_image(img, (640, 640), True)     # 缩放并进行letterbox转化

# 使用ImageNet的均值和方差对图片进行归一化
img_data = preprocess_input(np.array(letterbox_img, dtype='float32'))
img_data = np.transpose(img_data, (2, 0, 1))            # 调整图片的维度
img_data = np.expand_dims(img_data, 0)                  # 添加batch_size维度
images = torch.from_numpy(img_data)                     # 将图片数据转化为torch张量

"""模型导入与推理"""
model_path = "model_data/yolox_s.pth"       # 模型路径
class_path = "model_data/coco.names"        # 类名文件
font_path = "model_data/simhei.ttf"         # 字体文件

"""获得类名列表"""
with open(class_path, 'r') as f:
    class_names = f.read().split("\n")[:-1]         # 最后一个去掉，是因最后一个字符是空格

"""建立模型对象并导入权重"""
model = YoloBody(80, 's')                   # 新建模型,'s'表示新建的为yolox_s模型
load_model(model, model_path, 'cpu')        # 导入模型权重

with torch.no_grad():
    outputs = model(images)                         # 模型推理
    outputs = decode_outputs(outputs, [640, 640])   # 输出解码
    outputs = non_max_suppression(outputs)          # NMS
    yolo_correct_boxes(outputs, (640, 640), img.size, True)                         # 坐标变换
    img = draw_boxes(img, outputs, font_file=font_path, class_names=class_names)    # 画框
    # 这里之所以用letterbox，是因为我们获得的预测框，坐标是在letterbox_ima上的

img.show()

"""图像保存"""
img_name = file_path.split('\\')[-1]
img.save(r'img_out/' + img_name)

控制台输出：

 person 0.92 43 115 272 436
 dog 0.73 270 139 560 438

图像显示：

将上述图像关闭之后，会在img_out文件夹下看到这张图片：

好的，模型推理的工作完成！