MNN(二):借助Opencv实现MNN推理

详细见MNN官方文档

---

习惯于Opencv对数据进行预处理,见官方文档中没有涉及Opencv,便抽时间写下此篇.
本文采用caffe训练的分类模型,数据格式为NCHW, 图像格式为BGR.
为了使文章完整,本文绝大多数文字记录部分摘自(PS: 复制\粘贴)MNN官方文档

---

MNN推理主要由以下四个部分组成

一、创建会话

MNN创建会话(Session)主要通过 解释器(Interpreter)创建会话(Session).
使用MNN推理时，有两个层级的抽象，分别是解释器Interpreter和会话Session。Interpreter是模型数据的持有者；Session通过Interpreter创建，是推理数据的持有者。多个推理可以共用同一个模型，即，多个Session可以共用一个Interpreter
函数返回的Session实例是由Interpreter管理，随着Interpreter销毁而释放，一般不需要关注。也可以在不再需要时，调用Interpreter::releaseSession释放，减少内存占用。

const char *pchPath = ".models/DogVsCat.mnn";
/*interpreter 解释器，是模型数据的持有者，我称之为net
  * session 会话，是推理数据的持有者，session通过interpreter创建，多个session可以公用一个interpreter
  * session 和TF的session类似
  * 我们需要通过net创建session1、session2等会话，然后再给session里送入数据，
  * 创建Session 一般而言需要较长耗时，而Session 在多次推理过程中可以重复使用，建议只创建一次多次使用
  * 最后通过net->runSession(session1)执行推理
 */
 std::shared_ptr<Interpreter> net(Interpreter::createFromFile(pchPath));

 // 创建session
 ScheduleConfig config;
 config.type  = MNN_FORWARD_AUTO;
 Session *pSession = net->createSession(config);
 // 获取输入Tensor
 // getSessionInput 用于获取单个输入tensor
 Tensor *ptensorInput = net->getSessionInput(pSession, NULL);
 std::vector<int> vctInputDims = ptensorInput->shape();
 printf("输入Tensor的维度为： ");
 for (size_t i = 0; i < vctInputDims.size(); ++i)
 {
     printf("%d ", vctInputDims[i]);
 }
 printf("\n");

二、使用Opencv进行预处理

数据预处理一般步骤为:

• 1、缩放: 本文缩放到224*224
• 2、减均值、除方差

cv::Mat matBgrImg = cv::imread("/home/hjxu/test.bmp");
cv::Mat matNormImage;
cv::Mat matRzRgbImage, matFloatImage;
int MODEL_INPUT_HEIGHT = 224;
int MODEL_INPUT_WIDTH = 224;
cv::Mat matStd(MODEL_INPUT_HEIGHT, MODEL_INPUT_WIDTH, CV_32FC3, cv::Scalar(255.0f, 255.0f, 255.0f));
cv::resize(matBgrImg, matRzRgbImage, cv::Size(MODEL_INPUT_WIDTH, MODEL_INPUT_HEIGHT));
matRzRgbImage.convertTo(matFloatImage, CV_32FC3);
cv::Mat matMean(MODEL_INPUT_HEIGHT, MODEL_INPUT_WIDTH, CV_32FC3, \
                    cv::Scalar(103.53f, 116.28f, 123.675f)); // 均值

matNormImage = (matFloatImage - matMean) / matStd;

• 3、opencv读取的图像是NHWC的,本文还需要转换成NCHW

std::vector<std::vector<cv::Mat>> nChannels;
std::vector<cv::Mat> rgbChannels(3);
cv::split(matNormImage, rgbChannels);
nChannels.push_back(rgbChannels); //  NHWC  转NCHW
void *pvData = malloc(1 * 3 * MODEL_INPUT_HEIGHT * MODEL_INPUT_WIDTH *sizeof(float));
int nPlaneSize = MODEL_INPUT_HEIGHT * MODEL_INPUT_WIDTH;
for (int c = 0; c < 3; ++c)
{
   cv::Mat matPlane = nChannels[0][c];
   memcpy((float *)(pvData) + c * nPlaneSize,\
        matPlane.data, nPlaneSize * sizeof(float));
}

三、输入数据

Interpreter上提供了两个用于获取输入Tensor的方法：getSessionInput用于获取单个输入tensor，
getSessionInputAll用于获取输入tensor映射。
在只有一个输入tensor时，可以在调用getSessionInput时传入NULL以获取tensor。

这里采用最简洁的输入方式，直接利用host填充数据，但这种方式仅限于CPU后端，其他后端还是需要通过deviceid输入。此外，用这种方式填充数据需要我们自行处理NCHW或者NHWC的数据格式
本文这里，已经将NHWC转成了NCHW了，即 pvData

auto nchwTensor = new Tensor(ptensorInput, Tensor::CAFFE);
::memcpy(nchwTensor->host<float>(), pvData, nPlaneSize * 3 * sizeof(float));
ptensorInput->copyFromHostTensor(nchwTensor);
delete nchwTensor;

四、运行会话,执行推理

MNN中，Interpreter一共提供了三个接口用于运行Session，但一般来说，简易运行就足够满足绝对部分场景。
这里也只介绍简易运行,想了解更复杂的,见官方文档
直接调用 runSession函数

net->runSession(pSession);

五、获取输出

Interpreter上提供了两个用于获取输出Tensor的方法：getSessionOutput用于获取单个输出tensor，
getSessionOutputAll用于获取输出tensor映射。
在只有一个输出tensor时，可以在调用getSessionOutput时传入NULL以获取tensor。

Tensor *pTensorOutput = net->getSessionOutput(pSession, NULL);
// 获取输出维度类型
auto dimType = pTensorOutput->getDimensionType();
if (pTensorOutput->getType().code != halide_type_float) {
    dimType = Tensor::CAFFE;
}
// 创建输出tensor
std::shared_ptr<Tensor> outputUser(new Tensor(pTensorOutput, dimType));
MNN_PRINT("output size:%d\n", outputUser->elementSize());
// 拷贝出去
pTensorOutput->copyToHostTensor(outputUser.get());
auto type = outputUser->getType();

auto size = outputUser->elementSize();
std::vector<std::pair<int, float>> tempValues(size);
if (type.code == halide_type_float) {
    auto values = outputUser->host<float>();
    for (int i = 0; i < size; ++i) {
        tempValues[i] = std::make_pair(i, values[i]);
    }
}
// Find Max
// 排序, 打印
std::sort(tempValues.begin(), tempValues.end(),
          [](std::pair<int, float> a, std::pair<int, float> b) { return a.second > b.second; });

int length = size > 10 ? 10 : size;
for (int i = 0; i < length; ++i) {
    MNN_PRINT("%d, %f\n", tempValues[i].first, tempValues[i].second);
}

六、完整代码

//
// Created by hjxu on 2021/2/2.
//

#include <iostream>
#include <MNN/Interpreter.hpp>

using namespace MNN;

#include "opencv2/opencv.hpp"
int main()
{
    const char *pchPath = "./models/DogVsCat.mnn";
    /*interpreter 解释器，是模型数据的持有者，我称之为net
     * session 会话，是推理数据的持有者，session通过interpreter创建，多个session可以公用一个interpreter
     * session 和TF的session类似
     * 我们需要通过net创建session1、session2等会话，然后再给session里送入数据，
     * 最后通过net->runSession(session)执行推理
    */
    std::shared_ptr<Interpreter> net(Interpreter::createFromFile(pchPath));

    // 创建session
    ScheduleConfig config;
    config.type  = MNN_FORWARD_AUTO;
    Session *pSession = net->createSession(config);
    // 获取输入Tensor
    // getSessionInput 用于获取单个输入tensor
    Tensor *ptensorInput = net->getSessionInput(pSession, NULL);
    std::vector<int> vctInputDims = ptensorInput->shape();
    printf("输入Tensor的维度为： ");
    for (size_t i = 0; i < vctInputDims.size(); ++i)
    {
        printf("%d ", vctInputDims[i]);
    }
    printf("\n");
//    shape[0]   = 1;
    // 重建Tensor的形状，我们这里输入的固定的224*224， 所以可以不需要resize
//    net->resizeTensor(tensorInput, vctInputShape);
//    net->resizeSession(pSession);
    // opencv 读取数据，resize操作，减均值， 除方差，并且转成nchw
    cv::Mat matBgrImg = cv::imread("./test.bmp");
    cv::Mat matNormImage;
    cv::Mat matRzRgbImage, matFloatImage;
    int MODEL_INPUT_HEIGHT = 224;
    int MODEL_INPUT_WIDTH = 224;
    cv::Mat matStd(MODEL_INPUT_HEIGHT, MODEL_INPUT_WIDTH, CV_32FC3, cv::Scalar(255.0f, 255.0f, 255.0f));
    cv::resize(matBgrImg, matRzRgbImage, cv::Size(MODEL_INPUT_WIDTH, MODEL_INPUT_HEIGHT));
    matRzRgbImage.convertTo(matFloatImage, CV_32FC3);
    cv::Mat matMean(MODEL_INPUT_HEIGHT, MODEL_INPUT_WIDTH, CV_32FC3, \
                        cv::Scalar(103.53f, 116.28f, 123.675f)); // 均值

    matNormImage = (matFloatImage - matMean) / matStd;

    std::vector<std::vector<cv::Mat>> nChannels;
    std::vector<cv::Mat> rgbChannels(3);
    cv::split(matNormImage, rgbChannels);
    nChannels.push_back(rgbChannels); //  NHWC  转NCHW
    void *pvData = malloc(1 * 3 * MODEL_INPUT_HEIGHT * MODEL_INPUT_WIDTH *sizeof(float));
    int nPlaneSize = MODEL_INPUT_HEIGHT * MODEL_INPUT_WIDTH;
    for (int c = 0; c < 3; ++c)
    {
        cv::Mat matPlane = nChannels[0][c];
        memcpy((float *)(pvData) + c * nPlaneSize,\
             matPlane.data, nPlaneSize * sizeof(float));
    }

    // 将数据拷贝到Tensor中
    // 这里采用最简洁的输入方式，直接利用host填充数据，但这种方式仅限于CPU后端，其他后端
    // 还是需要通过deviceid输入。此外，用这种方式填充数据需要我们自行处理NCHW或者NHWC的数据格式
    // 本文这里，已经将NHWC转成了NCHW了，即 pvData
//    std::shared_ptr<MNN::CV::ImageProcess> pretreat_data_ = nullptr;
    auto nchwTensor = new Tensor(ptensorInput, Tensor::CAFFE);
    ::memcpy(nchwTensor->host<float>(), pvData, nPlaneSize * 3 * sizeof(float));
    ptensorInput->copyFromHostTensor(nchwTensor);
    delete nchwTensor;

    // 获取输出Tensor
    Tensor *pTensorOutput = net->getSessionOutput(pSession, NULL);

    // 执行推理
    net->runSession(pSession);
    {
        // 获取输出维度类型
        auto dimType = pTensorOutput->getDimensionType();
        if (pTensorOutput->getType().code != halide_type_float) {
            dimType = Tensor::CAFFE;
        }
        // 创建输出tensor
        std::shared_ptr<Tensor> outputUser(new Tensor(pTensorOutput, dimType));
        MNN_PRINT("output size:%d\n", outputUser->elementSize());
        // 拷贝出去
        pTensorOutput->copyToHostTensor(outputUser.get());
        auto type = outputUser->getType();

        auto size = outputUser->elementSize();
        std::vector<std::pair<int, float>> tempValues(size);
        if (type.code == halide_type_float) {
            auto values = outputUser->host<float>();
            for (int i = 0; i < size; ++i) {
                tempValues[i] = std::make_pair(i, values[i]);
            }
        }
        // Find Max
        // 排序, 打印
        std::sort(tempValues.begin(), tempValues.end(),
                  [](std::pair<int, float> a, std::pair<int, float> b) { return a.second > b.second; });

        int length = size > 10 ? 10 : size;
        for (int i = 0; i < length; ++i) {
            MNN_PRINT("%d, %f\n", tempValues[i].first, tempValues[i].second);
        }

    }
    // 释放我们创建的数据内存,这个不是tensor里的
    if (NULL != pvData)
    {
        free (pvData);
        pvData = NULL;
    }
    std::cout << "hello world " << std::endl;
    return 0;
}