mnn_onnx

# -*- coding: utf-8 -*-
from __future__ import print_function

import os
import time

import numpy as np
import MNN
import cv2
import onnxruntime
import torch
from pyzbar import pyzbar
from torchvision import transforms
from skimage import io, transform


def normPRED(d):
    ma = torch.max(d)
    mi = torch.min(d)

    dn = (d-mi)/(ma-mi)

    return dn

def onnx_mnn(dir_path):
    onnx_path = "./enet_mnn_2.onnx"
    mnn_path = "./enet_mnn_2.mnn"
    session = onnxruntime.InferenceSession(onnx_path)

    interpreter = MNN.Interpreter(mnn_path)
    mnn_session = interpreter.createSession()
    input_tensor = interpreter.getSessionInput(mnn_session)

    g = os.walk(dir_path)
    img_files = ['%s/%s' % (i[0], j) for i in g for j in i[-1] if
                 j.endswith('jpg')]

    for index, file in enumerate(img_files):
        image = cv2.imread(file)

        # image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
        image = image[:, 10:(320 - 10)]
        image = cv2.resize(image, (288, 32))
        cv2.imshow("image", image)
        cv2.waitKey(1)

        image = np.float32(image)
        tmpImg = np.zeros((image.shape[0], image.shape[1], 3),dtype=np.float32)
        image = image / np.max(image)

        tmpImg[:, :, 0] = (image[:, :, 0] - 0.485) / 0.229
        tmpImg[:, :, 1] = (image[:, :, 1] - 0.456) / 0.224
        tmpImg[:, :, 2] = (image[:, :, 2] - 0.406) / 0.225

        tmpImg = tmpImg.transpose((2, 0, 1))

        TestData = tmpImg[np.newaxis, :, :, :]
        start = time.time()
        inname = [input.name for input in session.get_inputs()][0]
        outname = [output.name for output in session.get_outputs()]

        datas = session.run(outname, {inname: TestData})

        print("onnx", datas[:20])

        inputs = tmpImg.reshape(1,3, 32, 288)
        start = time.time()

        tmp_input = MNN.Tensor((1, 3, 32, 288), MNN.Halide_Type_Float, inputs, MNN.Tensor_DimensionType_Caffe)
        # construct tensor from np.ndarray
        input_tensor.copyFrom(tmp_input)
        interpreter.runSession(mnn_session)
        output_tensor = interpreter.getSessionOutput(mnn_session)
        # print("output belong to class: {}".format(np.argmax(output_tensor.getData())))
        datas = output_tensor.getData()
        print("mnn",datas[:20])




def cls_eval(model_path="./pelee_mask_0806.mnn",dir_path=r"d:\data\mask_test"):

    interpreter = MNN.Interpreter(model_path)
    session = interpreter.createSession()
    input_tensor = interpreter.getSessionInput(session)

    g = os.walk(dir_path)
    img_files = ['%s/%s' % (i[0], j) for i in g for j in i[-1] if
                 j.endswith('jpg')]


    for index, file in enumerate(img_files):
        image = cv2.imread(file)

        # image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
        image = image[:, 10:(320 - 10)]
        image=cv2.resize(image,(288,32))
        cv2.imshow("image",image)
        cv2.waitKey(1)
        image = np.float32(image)
        tmpImg = np.zeros((image.shape[0], image.shape[1], 3))
        image = image / np.max(image)

        tmpImg[:, :, 0] = (image[:, :, 0] - 0.485) / 0.229
        tmpImg[:, :, 1] = (image[:, :, 1] - 0.456) / 0.224
        tmpImg[:, :, 2] = (image[:, :, 2] - 0.406) / 0.225

        inputs = tmpImg.transpose((2, 0, 1))

        inputs=inputs.reshape(1, 3, 32, 288)
        start = time.time()

        tmp_input = MNN.Tensor((1, 3, 32, 288), MNN.Halide_Type_Float,inputs, MNN.Tensor_DimensionType_Caffe)
        # construct tensor from np.ndarray
        input_tensor.copyFrom(tmp_input)
        interpreter.runSession(session)
        output_tensor = interpreter.getSessionOutput(session)
        # print("output belong to class: {}".format(np.argmax(output_tensor.getData())))
        datas=output_tensor.getData()

        data_len=len(datas)

        new_data=[]
        for i in range(data_len//4):
            new_data.append(datas[i*4])
        pic=np.zeros((32,288))
        print("time",time.time()-start)
        for i in range(32):
            for j in range(288):
                pic[i,j]=new_data[i*288+j]
        print("time2", time.time() - start)

        d1=pic.reshape(1,32,288)

        pred = normPRED(torch.from_numpy(d1))

        # save results to test_results folder
        predict = pred.squeeze()
        predict_np = predict.data.numpy()

        res_img = cv2.resize(predict_np * 255, (image.shape[1], image.shape[0]))
        # res_img = np.clip(res_img, 0, 255)
        res_img = np.expand_dims(res_img, 2).astype(np.uint8)
        bar_result = pyzbar.decode(res_img)
        if bar_result:
            for result in bar_result:
                if len(result.data.decode("utf-8")) > 16:
                    print(bar_result)
                    bar_str = result.data.decode("utf-8")
                print("bar ok", len(bar_str), bar_str[:4], bar_str[4:8], bar_str[8:12], bar_str[12:], "net time",
                      time.time() - start)
        else:
            print("-----time-----", time.time() - start)

        # image_show = cv2.cvtColor(res_img, cv2.COLOR_BGR2RGB)
        cv2.imshow("asfd",res_img)
        cv2.waitKey()

if __name__ == "__main__":
    dir_path=r"D:\project\bar_code\jacke121-U-2-Net-master_rgb\unet_dense_small"
    # cls_eval("./enet_14_2_28_d.mnn",dir_path)

    onnx_mnn(dir_path)

赵芳mnn c++推理示例：

#include "dan.h"
#include "ZFutil.h"
#include "Interpreter.hpp"
#include "MNN/Tensor.hpp"
#include "cvheadpose.h"

using namespace MNN;

DAN::DAN() {
	initialized_ = false;
}

DAN::~DAN()
{
	net->releaseModel();
	net->releaseSession(session);

	delete nhwc_Tensor;
	nhwc_Tensor = nullptr;
}


int DAN::Init(char* fileBuffer, int lenModel, float arr_meanImg[112][112], float arr_stdDevImg[112][112], float arr_initlandmark[106][2]) {

	// create interpreter
	net = std::shared_ptr<MNN::Interpreter>(MNN::Interpreter::createFromBuffer((void*)fileBuffer, lenModel));
	//net = MNN::Interpreter::createFromBuffer((void*)fileBuffer, lenModel);

	//config 
	MNN::ScheduleConfig config;
	config.type = MNN_FORWARD_AUTO;
	config.numThread = 1;
	//config backend
	MNN::BackendConfig backendConfig;
	backendConfig.precision = MNN::BackendConfig::Precision_Normal;
	backendConfig.power = MNN::BackendConfig::Power_High;
	config.backendConfig = &backendConfig;

	session = net->createSession(config);

	std::vector<int> dims{ 1,112,112,1 };
	nhwc_Tensor = MNN::Tensor::create<float>(dims, NULL, MNN::Tensor::TENSORFLOW);

	// load initlandmark_0
	cv::Point2f init_tmp;
	for (int i = 0; i < 106; i++) {
		init_tmp.x = arr_initlandmark[i][0];
		init_tmp.y = arr_initlandmark[i][1];
		initlandmark_0.push_back(init_tmp);
	}
	// load meanImg
	meanImg = cv::Mat(112, 112, CV_32FC1, arr_meanImg);
	// load stdDevImg
	stdDevImg = cv::Mat(112, 112, CV_32FC1, arr_stdDevImg);

	//kalman 初始化
	int n = 2; // Number of states
	int m = 1; // Number of measurements

	Eigen::MatrixXd A(n, n); // System dynamics matrix
	Eigen::MatrixXd H(m, n); // Measurement matrix
	Eigen::MatrixXd Q(n, n); // Process noise covariance
	Eigen::MatrixXd R(m, m); // Measurement noise covariance
	Eigen::MatrixXd P(n, n); // Estimate error covariance

	A << 1, 1, 0, 1;
	H << 1, 1;
	// Reasonable covariance matrices
	Q << .1, .0, .0, .1;
	R << .1;
	P << .0, .0, .0, .0;

	for (int r = 0; r < 212; ++r)
	{
		kf.push_back(KalmanFilter1(A, H, Q, R, P));
	}

	initialized_ = true;
	return 0;
}




void DAN::Detect(int flag, const cv::Mat *pImg, const cv::Rect &bbox_, cv::Mat &init_matrix, cv::Mat &init_trans, vector<cv::Point> &init_landmarks_out, vector<cv::Point> &landmarks_out) {
	landmarks_out.clear();
	cv::Rect bbox;

	if (bbox_.area() == 0) {
		return;
	}

	bbox = bbox_;
	vector<cv::Point2f> initlandmarks_1 = ZF::bestFitRect(initlandmark_0, bbox);
	forward(flag, pImg, initlandmarks_1, init_matrix, init_trans, init_landmarks_out, landmarks_out);
}


void DAN::forward(int flag, const cv::Mat *pImg, vector<cv::Point2f> &initlandmarks_1, cv::Mat &init_matrix, cv::Mat &init_trans, vector<cv::Point> &init_landmarks_out, vector<cv::Point> &landmarks_out) {

	if (frame_index < 2)
		frame_index++;
	// use gray scale image to approximate channel-wise average
	cv::Mat channelwise_avg;
	cv::cvtColor(*pImg, channelwise_avg, cv::COLOR_BGR2GRAY);
	channelwise_avg.convertTo(channelwise_avg, CV_32FC1);

	auto tuple = ZF::cropResizeRotate(channelwise_avg, initlandmark_0, initlandmarks_1);
	cv::Mat &inputImg = get<0>(tuple);
	init_matrix = get<1>(tuple);
	init_trans = get<2>(tuple);
	inputImg -= meanImg;
	inputImg /= stdDevImg;

	//  
	auto nhwc_data = nhwc_Tensor->host<float>();
	auto nhwc_size = nhwc_Tensor->size();
	::memcpy(nhwc_data, inputImg.data, nhwc_size);

	auto input_tensor = net->getSessionInput(session, nullptr);
	/*auto shape =  input_tensor->shape();
	shape[0] = 1;
	net->resizeTensor(input_tensor, shape);
	net->resizeSession(session);*/

	input_tensor->copyFromHostTensor(nhwc_Tensor);


	/*ImageProcess::Config config_img;
	config_img.sourceFormat = BGR;
	config_img.destFormat   = RGB;
	std::shared_ptr<ImageProcess> pretreat(ImageProcess::create(config_img));
	pretreat->convert((uint8_t*)inputImg.data, 112, 112, inputImg.step[0] , input_tensor);*/

	net->runSession(session);

	//get output
	MNN::Tensor* output = net->getSessionOutput(session, nullptr);
	MNN::Tensor output_host(output, output->getDimensionType());
	output->copyToHostTensor(&output_host);

	auto landmark_out_mnn = output_host.host<float>();

	float landmark_out_array[212]{};
	for (int i = 0; i < 212; i++) {
		landmark_out_array[i] = landmark_out_mnn[i];
	}

	// post-process
	cv::Mat landmark_out = cv::Mat(212, 1, CV_32FC1, landmark_out_array);
	landmark_out = landmark_out.reshape(0, 106);

	//init_landmarks_out
	init_landmarks_out.clear();
	for (int r = 0; r < landmark_out.rows; r++) {
		init_landmarks_out.emplace_back(static_cast<int>(landmark_out.at<float>(r, 0)), static_cast<int>(landmark_out.at<float>(r, 1)));
	}

	for (int i = 0; i < 106; i++) {
		landmark_out.at<float>(i, 0) -= init_trans.at<float>(0, 0);
		landmark_out.at<float>(i, 1) -= init_trans.at<float>(0, 1);
	}

	landmark_out = landmark_out * init_matrix.inv();
	if (flag == 0)
	{
		landmarks_out.clear();
		for (int j = 0; j < landmark_out.rows; j++) {
			landmarks_out.emplace_back(static_cast<int>(landmark_out.at<float>(j, 0)),
				static_cast<int>(landmark_out.at<float>(j, 1)));
		}
	}
	if (flag == 1)
	{
		if (frame_index <= 1)
		{
			landmarks_out.clear();
			for (int j = 0; j < landmark_out.rows; j++) {
				landmarks_out.emplace_back(static_cast<int>(landmark_out.at<float>(j, 0)),
					static_cast<int>(landmark_out.at<float>(j, 1)));
			}
			Eigen::VectorXd x0(2);
			for (int i = 0; i < 106; ++i)
			{
				x0 << landmarks_out[i].x, .0;
				kf[2 * i].init(x0);
				x0 << landmarks_out[i].y, .0;
				kf[2 * i + 1].init(x0);
			}

		}
		else
		{
			vector<cv::Point> landmark_out_vec;
			landmark_out_vec.clear();

			for (int i = 0; i < landmark_out.rows; i++) {
				landmark_out_vec.emplace_back(static_cast<int>(landmark_out.at<float>(i, 0)),
					static_cast<int>(landmark_out.at<float>(i, 1)));
			}
			//------------------------------------------------  
			landmarks_out.clear();
			Eigen::VectorXd y(1);
			for (unsigned int j = 0; j < landmark_out_vec.size(); ++j)
			{
				y << landmark_out_vec[j].x;
				kf[2 * j].update(y);

				y << landmark_out_vec[j].y;
				kf[2 * j + 1].update(y);
				landmarks_out.push_back(Point(kf[2 * j].state().transpose()[0], kf[2 * j + 1].state().transpose()[0]));
			}
		}

		//------------------------------------------------
	}

}