OpenVINO2021.4+YOLOX目标检测模型部署测试

ゞ浴缸里的玫瑰 2022-08-31 15:30 279阅读 0赞

前面写过一篇文章介绍了YOLOX目标检测模型，知道它是基于Pytroch而且类似与YOLOv5目标检测模型，文章链接：

[比YOLOv5还厉害的YOLOX来了，官方支持OpenVINO推理][YOLOv5_YOLOX_OpenVINO]

本文基于YOLOX的ONNX模型分别测试了YOLOX-Small与YOLOX-Tiny版本的模型。**硬件配置与软件版本：**

Win10 64位

CPU CORE i7 8thVS2017OpenVINO2021.4

模型说明

两个模型的输入与输出格式分别如下：

![图片][deaa8ea699bf1d6828ce2fbf739f97c5.png]

以YOLOX small版本为例，解释输出的内容是什么，看模型的输出图示如下：

![图片][bc3a786a69403f80b06a66b84017f1c4.png]

![图片][d9d8734760f39882350b31f01e4d6c04.png]

有三个输出层，分别是8倍、16倍、32倍的降采样，输出的8400计算方法为：

80x80+40x40+20x20 = 6400+1600+400=8400

分别对应640的8倍、16倍、32倍的降采样大小。85的前四个是**cx、cy、w、h大小**，第五个是**object预测得分**，后面80个是COCO类别。

看到这里就知道它跟YOLOv5的解析极其类似。然后它对图象的预测要求如下：

输入通道顺序：RGB、类型浮点数0~1之间输入的均值：0.485f, 0.456f, 0.406f输入的归一化方差：0.229f, 0.224f, 0.225f

代码实现部分

首先需要加载模型，从github上下载好对应的模型ONNX格式文件之后，首先通过IECore来加载YOLOX模型，代码如下：

std::cout << "YOLOX Demo" << std::endl;
    Core ie;
    std::vector<std::string> availableDevices = ie.GetAvailableDevices();
    for (int i = 0; i < availableDevices.size(); i++) {
        printf("supported device name : %s \n", availableDevices[i].c_str());
    }
    
    //  加载检测模型
    auto network = ie.ReadNetwork("D:/yolox.onnx");

设置模型的输入与输出，这里需要注意，**输入设置为FP32**，读取输入与输出层名称，代码如下：

// 请求网络输入与输出信息
    InferenceEngine::InputsDataMap input_info(network.getInputsInfo());
    InferenceEngine::OutputsDataMap output_info(network.getOutputsInfo());
    // 设置输入格式
    std::string input_name = "";
    for (auto &item : input_info) {
        auto input_data = item.second;
        input_name = item.first;
        input_data->setPrecision(Precision::FP32);
        input_data->setLayout(Layout::NCHW);
    }
    printf("get it \n");
    
    // 设置输出格式
    std::string output_name = "";
    for (auto &item : output_info) {
        auto output_data = item.second;
        output_name = item.first;
        std::cout <<"output name: "<< item.first << std::endl;
        output_data->setPrecision(Precision::FP32);
    }

下面就是生成三个输出层的grid，每个grid上的每个点的坐标信息，后面解析输出数据的时候需要根据index来取每个grid对应的数据

// 生成三个输出层的grid与anchor信息
    std::vector<int> strides = { 8, 16, 32 };
    std::vector<GridAndStride> grid_strides;
    generate_grids_and_stride(IMG_W, strides, grid_strides);

其中generate\_grids\_and\_stride是我借鉴了官方的代码，这部分我感觉是可以省去的，可以从index中直接计算的，也许这样会更快点，暂时我就借用了，该方法的代码如下：

const float IMG_W = 640.0f;
    struct GridAndStride
    {
        int gh;
        int gw;
        int stride;
    };
    
    void generate_grids_and_stride(int target_size, std::vector<int>& strides, std::vector<GridAndStride>& grid_strides)
    {
        for (auto stride : strides)
        {
            int num_grid = target_size / stride;
            for (int g1 = 0; g1 < num_grid; g1++)
            {
                for (int g0 = 0; g0 < num_grid; g0++)
                {
                    GridAndStride gs;
                    gs.gh = g0;
                    gs.gw = g1;
                    gs.stride = stride;
                    grid_strides.push_back(gs);
                }
            }
        }
    }

下面就很容易啦，创建推理请求，开始执行推理，推理的解析部分，代码如下：

// 开始推理处理 - 支持图象与视频
    cv::Mat image = cv::imread("D:/zidane.jpg");
    inferAndOutput(image, grid_strides, input_name, output_name, infer_request);

其中inferAndOutput是我的推理与解析输出结果的方法，该方法首先得到输出，然后根据index来从grid\_strides里面查询对应grid的对应位置信息，原来官方的方法比较比较啰嗦，代码不够简洁，我稍微改动了一下，借助OpenVINO中OpenCV自带的NMS函数功能，重新整理一下，改成现在的方法，发现可以降低代码量，提升可读性，该方法的代码如下：

void inferAndOutput(cv::Mat &image, std::vector<GridAndStride> &grid_strides, std::string &input_name, std::string &output_name, InferRequest &infer_request) {
        int64 start = cv::getTickCount();
        Blob::Ptr imgBlob = infer_request.GetBlob(input_name);
        float sx = static_cast<float>(image.cols) / IMG_W;
        float sy = static_cast<float>(image.rows) / IMG_W;
    
        // 推理
        blobFromImage(image, imgBlob);
        infer_request.Infer();
        const Blob::Ptr output_blob = infer_request.GetBlob(output_name);
    
        const float* outblob = static_cast<PrecisionTrait<Precision::FP32>::value_type*>(output_blob->buffer());
        const SizeVector outputDims = output_blob->getTensorDesc().getDims();
        const int num_anchors = grid_strides.size();
        const int num_class = 80;
    
        // 处理解析输出结果
        std::vector<cv::Rect> boxes;
        std::vector<int> classIds;
        std::vector<float> confidences;
    
        for (int anchor_idx = 0; anchor_idx < num_anchors; anchor_idx++)
        {
            const int grid0 = grid_strides[anchor_idx].gh; // H
            const int grid1 = grid_strides[anchor_idx].gw; // W
            const int stride = grid_strides[anchor_idx].stride; // stride
            const int basic_pos = anchor_idx * 85;
            float x_center = (outblob[basic_pos + 0] + grid0) * stride * sx;
            float y_center = (outblob[basic_pos + 1] + grid1) * stride * sy;
            float w = exp(outblob[basic_pos + 2]) * stride * sx;
            float h = exp(outblob[basic_pos + 3]) * stride * sy;
            float x0 = x_center - w * 0.5f;
            float y0 = y_center - h * 0.5f;
    
            float box_objectness = outblob[basic_pos + 4];
            for (int class_idx = 0; class_idx < num_class; class_idx++)
            {
                float box_cls_score = outblob[basic_pos + 5 + class_idx];
                float box_prob = box_objectness * box_cls_score;
                if (box_prob > 0.25)
                {
                    cv::Rect rect;
                    rect.x = x0;
                    rect.y = y0;
                    rect.width = w;
                    rect.height = h;
    
                    classIds.push_back(class_idx);
                    confidences.push_back((float)box_prob);
                    boxes.push_back(rect);
                }
    
            } // class loop
        }
    
        std::vector<int> indices;
        cv::dnn::NMSBoxes(boxes, confidences, 0.25, 0.5, indices);
        for (size_t i = 0; i < indices.size(); ++i)
        {
            int idx = indices[i];
            cv::Rect box = boxes[idx];
            rectangle(image, box, cv::Scalar(140, 199, 0), 4, 8, 0);
        }
        float fps = cv::getTickFrequency() / (cv::getTickCount() - start);
        float time = (cv::getTickCount() - start) / cv::getTickFrequency();
    
        std::ostringstream ss;
        ss << "FPS : " << fps << " detection time: " << time * 1000 << " ms";
        cv::putText(image, ss.str(), cv::Point(20, 50), 0, 1.0, cv::Scalar(0, 0, 255), 2);
    
        cv::imshow("OpenVINO2021.4+YOLOX Demo@JiaZhiGang", image);
    }

运行与测试

首先用YOLOv5的一张测试图象测试一下，基于YOLOX的samll版本模型运行结果如下：

![图片][763e496049990481f7d306588db2cf20.png]

跟YOLOV5 small版本测试结果完成一致，毫无违和感！

**视频测试(YOLOX Small版本模型)运行结果如下：**

![图片][05b7f4053596e7cf13e68b22a8bc1614.png]

感觉没有YOLOv5的small版本推理速度快(在我的机器上)！还需进一步优化输出解析代码。

**视频测试(YOLOX Tiny版本模型)运行结果如下：**

![图片][3cff95b284c0f432b151abac1eafff52.png]

CPU果然可以30+ FPS的。

[YOLOv5_YOLOX_OpenVINO]: http://mp.weixin.qq.com/s?__biz=MzA4MDExMDEyMw==&mid=2247494063&idx=1&sn=0f8c6f30ee1b7ccca2ec6dbff75dc260&chksm=9fab9eeba8dc17fdf43c1c19a8ae48049ef638d5cd8708bdf9712a67bf6a378fcfc85ca41039&scene=21#wechat_redirect
[deaa8ea699bf1d6828ce2fbf739f97c5.png]: /images/20220829/52e8b862c4bd432b946cda8246b2fec5.png
[bc3a786a69403f80b06a66b84017f1c4.png]: /images/20220829/3569e553e0f848eaa8b1536738fcf8b1.png
[d9d8734760f39882350b31f01e4d6c04.png]: /images/20220829/9ad246512c6948368c3b92f04b8876b8.png
[763e496049990481f7d306588db2cf20.png]: /images/20220829/6200bf3a2da749d1b1caafa5c0892855.png
[05b7f4053596e7cf13e68b22a8bc1614.png]: /images/20220829/aaae341ca8be46bf9ad5cec4fe46aeff.png
[3cff95b284c0f432b151abac1eafff52.png]: /images/20220829/c5622f01d047419993407dc68b24b7d1.png