Upload 45 files

.gitattributes

@@ -33,3 +33,13 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+model_farm_midas_v2_qcs6490_qnn2.16_int8_aidlite/cpp/dog.jpg filter=lfs diff=lfs merge=lfs -text
+model_farm_midas_v2_qcs6490_qnn2.16_int8_aidlite/python/dog.jpg filter=lfs diff=lfs merge=lfs -text
+model_farm_midas_v2_qcs6490_qnn2.16_w8a16_aidlite/cpp/dog.jpg filter=lfs diff=lfs merge=lfs -text
+model_farm_midas_v2_qcs6490_qnn2.16_w8a16_aidlite/python/dog.jpg filter=lfs diff=lfs merge=lfs -text
+model_farm_midas_v2_qcs8550_qnn2.16_fp16_aidlite/cpp/dog.jpg filter=lfs diff=lfs merge=lfs -text
+model_farm_midas_v2_qcs8550_qnn2.16_fp16_aidlite/python/dog.jpg filter=lfs diff=lfs merge=lfs -text
+model_farm_midas_v2_qcs8550_qnn2.16_int8_aidlite/cpp/dog.jpg filter=lfs diff=lfs merge=lfs -text
+model_farm_midas_v2_qcs8550_qnn2.16_int8_aidlite/python/dog.jpg filter=lfs diff=lfs merge=lfs -text
+model_farm_midas_v2_qcs8550_qnn2.16_w8a16_aidlite/cpp/dog.jpg filter=lfs diff=lfs merge=lfs -text
+model_farm_midas_v2_qcs8550_qnn2.16_w8a16_aidlite/python/dog.jpg filter=lfs diff=lfs merge=lfs -text

model_farm_midas_v2_qcs6490_qnn2.16_int8_aidlite/README.md

@@ -0,0 +1,56 @@
+## Model Information
+
+### Source model
+- Input shape: 1x3x256x256
+- Number of parameters: 20.33M
+- Model size: 82.17M
+- Output shape: 1x1x256x256
+
+Source model repository: [midas](https://github.com/isl-org/MiDaS/tree/master)
+
+### Converted model
+
+- Precision: INT8
+- Backend: QNN2.16
+- Target Device: FV01 QCS6490
+
+## Inference with AidLite SDK
+
+### SDK installation
+Model Farm uses AidLite SDK as the model inference SDK. For details, please refer to the [AidLite Developer Documentation](https://v2.docs.aidlux.com/en/sdk-api/aidlite-sdk/)
+
+- Install AidLite SDK
+
+```bash
+# Install the appropriate version of the aidlite sdk
+sudo aid-pkg update
+sudo aid-pkg install aidlite-sdk
+# Download the qnn version that matches the above backend. Eg Install QNN2.23 Aidlite: sudo aid-pkg install aidlite-qnn223
+sudo aid-pkg install aidlite-{QNN VERSION}
+```
+
+- Verify AidLite SDK
+
+```bash
+# aidlite sdk c++ check
+python3 -c "import aidlite ; print(aidlite.get_library_version())"
+
+# aidlite sdk python check
+python3 -c "import aidlite ; print(aidlite.get_py_library_version())"
+```
+
+### Run Demo
+#### python
+```bash
+cd model_farm_midas_v2_qcs6490_qnn2.16_int8_aidlite
+python3 python/run_test.py --target_model ./models/midas_v2_w8a8.qnn216.ctx.bin --imgs ./python/dog.jpg  --invoke_nums 10 
+```
+
+#### c++
+```bash
+cd midas_v2/model_farm_midas_v2_qcs6490_qnn2.16_int8_aidlite/cpp
+mkdir build && cd build 
+cmake ..
+make
+./run_test
+```

model_farm_midas_v2_qcs6490_qnn2.16_int8_aidlite/cpp/CMakeLists.txt

@@ -0,0 +1,32 @@
+cmake_minimum_required (VERSION 3.5)
+project("run_test")
+
+find_package(OpenCV REQUIRED)
+
+message(STATUS "oPENCV Library status:")
+message(STATUS ">version:${OpenCV_VERSION}")
+message(STATUS "Include:${OpenCV_INCLUDE_DIRS}")
+
+set(CMAKE_CXX_FLAGS "-Wno-error=deprecated-declarations -Wno-deprecated-declarations")
+
+include_directories(
+    /usr/local/include
+    /usr/include/opencv4
+)
+
+link_directories(
+    /usr/local/lib/
+)
+
+file(GLOB SRC_LISTS 
+    ${CMAKE_CURRENT_SOURCE_DIR}/run_test.cpp  
+)
+
+add_executable(run_test ${SRC_LISTS})
+
+target_link_libraries(run_test
+    aidlite
+	${OpenCV_LIBS}
+    pthread
+    jsoncpp
+)

model_farm_midas_v2_qcs6490_qnn2.16_int8_aidlite/cpp/run_test.cpp

@@ -0,0 +1,392 @@
+#include <iostream>
+#include <fstream>
+#include <opencv2/opencv.hpp>
+#include <aidlux/aidlite/aidlite.hpp>
+#include <vector>
+#include <numeric>
+#include <cmath>
+#include <jsoncpp/json/json.h>
+
+using namespace cv;
+using namespace std;
+using namespace Aidlux::Aidlite;
+
+const int net_w = 256;
+const int net_h = 256;
+
+const std::vector<float> mean_vals = {0.485f, 0.456f, 0.406f};
+const std::vector<float> std_vals = {0.229f, 0.224f, 0.225f};
+
+
+struct Args {
+    std::string target_model = "../../models/midas_v2_w8a8.qnn216.ctx.bin";
+    std::string imgs = "../dog.jpg";
+    int invoke_nums = 10;
+    std::string model_type = "QNN";
+};
+
+
+Args parse_args(int argc, char* argv[]) {
+    Args args;
+    for (int i = 1; i < argc; ++i) {
+        std::string arg = argv[i];
+        if (arg == "--target_model" && i + 1 < argc) {
+            args.target_model = argv[++i];
+        } else if (arg == "--imgs" && i + 1 < argc) {
+            args.imgs = argv[++i];
+        } else if (arg == "--invoke_nums" && i + 1 < argc) {
+            args.invoke_nums = std::stoi(argv[++i]);
+        } else if (arg == "--model_type" && i + 1 < argc) {
+            args.model_type = argv[++i];
+        }
+    }
+    return args;
+}
+
+std::string to_lower(const std::string& str) {
+    std::string lower_str = str;
+    std::transform(lower_str.begin(), lower_str.end(), lower_str.begin(), [](unsigned char c) {
+        return std::tolower(c);
+    });
+    return lower_str;
+}
+
+
+int transpose(float* src, unsigned int* src_dims, unsigned int* tsp_dims, float* dest){
+
+    int current_coordinate[4] = {0, 0, 0, 0};
+    for(int a = 0; a < src_dims[0]; ++a){
+        current_coordinate[0] = a;
+        for(int b = 0; b < src_dims[1]; ++b){
+            current_coordinate[1] = b;
+            for(int c = 0; c < src_dims[2]; ++c){
+                current_coordinate[2] = c;
+                for(int d = 0; d < src_dims[3]; ++d){
+                    current_coordinate[3] = d;
+
+                    int old_index = current_coordinate[0]*src_dims[1]*src_dims[2]*src_dims[3] + 
+                                    current_coordinate[1]*src_dims[2]*src_dims[3] + 
+                                    current_coordinate[2]*src_dims[3] + 
+                                    current_coordinate[3];
+
+                    int new_index = current_coordinate[tsp_dims[0]]*src_dims[tsp_dims[1]]*src_dims[tsp_dims[2]]*src_dims[tsp_dims[3]] + 
+                                    current_coordinate[tsp_dims[1]]*src_dims[tsp_dims[2]]*src_dims[tsp_dims[3]] + 
+                                    current_coordinate[tsp_dims[2]]*src_dims[tsp_dims[3]] + 
+                                    current_coordinate[tsp_dims[3]];
+
+                    dest[new_index] = src[old_index];
+                }
+            }
+        }
+    }
+
+    return EXIT_SUCCESS;
+}
+
+
+// 替代 np.nan_to_num
+void sanitizeDepthMap(cv::Mat& depth) {
+    for (int y = 0; y < depth.rows; ++y) {
+        float* row = depth.ptr<float>(y);
+        for (int x = 0; x < depth.cols; ++x) {
+            float val = row[x];
+            if (!std::isfinite(val)) {
+                row[x] = 0.0f;
+            }
+        }
+    }
+}
+
+// 等效于 Python write_depth
+void write_depth(const std::string& path, const cv::Mat& input_depth, bool grayscale = false, int bits = 1) {
+    CV_Assert(input_depth.type() == CV_32FC1);
+
+    // 拷贝 + 处理非法值
+    cv::Mat depth = input_depth.clone();
+    sanitizeDepthMap(depth);
+
+    double minVal, maxVal;
+    cv::minMaxLoc(depth, &minVal, &maxVal);
+
+    double max_val = (1 << (8 * bits)) - 1;
+    cv::Mat out;
+
+    if (maxVal - minVal > std::numeric_limits<float>::epsilon()) {
+        // 归一化并映射到位深范围
+        out = (depth - minVal) * (max_val / (maxVal - minVal));
+    } else {
+        out = cv::Mat::zeros(depth.size(), CV_32F);
+    }
+
+    if (!grayscale) {
+        out.convertTo(out, CV_8UC1);
+        cv::applyColorMap(out, out, cv::COLORMAP_INFERNO);
+    }
+
+    if (bits == 1) {
+        out.convertTo(out, CV_8U);
+    } else if (bits == 2) {
+        out.convertTo(out, CV_16U);
+    }
+
+    cv::imwrite(path, out);
+}
+
+// 等效于 Python write_pfm
+void write_pfm(const std::string& path, const cv::Mat& image, float scale = 1.0f) {
+    CV_Assert(image.type() == CV_32FC1 || image.type() == CV_32FC3);
+
+    std::ofstream file(path, std::ios::binary);
+    if (!file.is_open()) {
+        std::cerr << "Failed to open file for writing PFM: " << path << std::endl;
+        return;
+    }
+
+    int width = image.cols;
+    int height = image.rows;
+    int channels = image.channels();
+    bool color = (channels == 3);
+
+    file << (color ? "PF" : "Pf") << "\n";
+    file << width << " " << height << "\n";
+
+    // Endianness: negative = little-endian
+    uint16_t endian_test = 0x1;
+    bool is_little_endian = *(reinterpret_cast<uint8_t*>(&endian_test)) == 0x1;
+    if (is_little_endian) {
+        scale = -scale;
+    }
+
+    file << scale << "\n";
+
+    // Flip vertically (OpenCV top-left origin -> PFM bottom-left origin)
+    cv::Mat flipped;
+    cv::flip(image, flipped, 0);
+
+    // Write raw data
+    file.write(reinterpret_cast<const char*>(flipped.data), flipped.total() * channels * sizeof(float));
+    file.close();
+}
+
+
+// ======================= Normalize =======================
+void normalize(cv::Mat& image) {
+    CV_Assert(image.type() == CV_32FC3);
+    int rows = image.rows;
+    int cols = image.cols;
+
+    for (int y = 0; y < rows; ++y) {
+        cv::Vec3f* row = image.ptr<cv::Vec3f>(y);
+        for (int x = 0; x < cols; ++x) {
+            for (int c = 0; c < 3; ++c) {
+                row[x][c] = (row[x][c] - mean_vals[c]) / std_vals[c];
+            }
+        }
+    }
+}
+
+cv::Mat hwc_to_chw(const cv::Mat& image) {
+    std::vector<cv::Mat> channels(3);
+    cv::split(image, channels);
+
+    cv::Mat chw(3, image.rows * image.cols, CV_32F);
+    for (int c = 0; c < 3; ++c) {
+        memcpy(chw.ptr(c), channels[c].data, image.rows * image.cols * sizeof(float));
+    }
+
+    return chw;
+}
+
+
+bool first_execution = true;
+cv::Mat img_process(const cv::Mat image_bgr, cv::Size& org_size_out) {
+    first_execution = false;
+
+    cv::Mat image_rgb;
+    cv::cvtColor(image_bgr, image_rgb, cv::COLOR_BGR2RGB);
+    image_rgb.convertTo(image_rgb, CV_32FC3, 1.0 / 255.0);
+
+    // 2. Save original size
+    org_size_out = image_rgb.size();  // H x W
+
+    // 3. Resize to 256x256 using cubic interpolation
+    cv::resize(image_rgb, image_rgb, cv::Size(net_w, net_h), 0, 0, cv::INTER_CUBIC);
+
+    // 4. Normalize using mean/std
+    normalize(image_rgb);
+
+    // 5. Convert HWC to CHW
+    cv::Mat chw = hwc_to_chw(image_rgb);
+
+    // 6. Add batch dimension: [1, C, H, W] → reshape to 1x3xHxW style float array
+    cv::Mat input_tensor(1, 3 * net_h * net_w, CV_32F);
+    memcpy(input_tensor.ptr<float>(), chw.data, 3 * net_h * net_w * sizeof(float));
+
+    std::cout << "Input resized to " << net_w << "x" << net_h << " before entering the encoder" << std::endl;
+
+    return input_tensor;
+}
+
+
+float* matToFloatPtr(const cv::Mat& input_mat, bool normalize = true) {
+    // 检查连续性
+    cv::Mat mat = input_mat;
+    if (!mat.isContinuous()) {
+        mat = mat.clone();
+    }
+
+    // 分配内存
+    int total_pixels = mat.rows * mat.cols;
+    int channels = mat.channels();
+    float* float_data = new float[total_pixels * channels];
+
+    // 根据数据类型转换
+    if (mat.type() == CV_8UC1 || mat.type() == CV_8UC3) {
+        uchar* ptr = mat.ptr<uchar>(0);
+        for (int i = 0; i < total_pixels * channels; ++i) {
+            float_data[i] = normalize ? (static_cast<float>(ptr[i]) / 255.0f) : ptr[i];
+        }
+    } else if (mat.type() == CV_32FC1 || mat.type() == CV_32FC3) {
+        float* ptr = mat.ptr<float>(0);
+        std::memcpy(float_data, ptr, total_pixels * channels * sizeof(float));
+    } else {
+        delete[] float_data;
+        return nullptr; // 不支持的类型
+    }
+
+    return float_data;
+}
+
+
+int invoke(const Args& args) {
+    std::cout << "Start main ... ... Model Path: " << args.target_model << "\n"
+              << "Image Path: " << args.imgs << "\n"
+              << "Inference Nums: " << args.invoke_nums << "\n"
+              << "Model Type: " << args.model_type << "\n";
+    Model* model = Model::create_instance(args.target_model);
+    if(model == nullptr){
+        printf("Create model failed !\n");
+        return EXIT_FAILURE;
+    }
+    Config* config = Config::create_instance();
+    if(config == nullptr){
+        printf("Create config failed !\n");
+        return EXIT_FAILURE;
+    }
+    config->implement_type = ImplementType::TYPE_LOCAL;
+    std::string model_type_lower = to_lower(args.model_type);
+    if (model_type_lower == "qnn"){
+        config->framework_type = FrameworkType::TYPE_QNN;
+    } else if (model_type_lower == "snpe2" || model_type_lower == "snpe") {
+        config->framework_type = FrameworkType::TYPE_SNPE2;
+    }
+    config->accelerate_type = AccelerateType::TYPE_DSP;
+    config->is_quantify_model = 1;
+
+    unsigned int model_h = 256;
+    unsigned int model_w = 256;
+    std::vector<std::vector<uint32_t>> input_shapes = {{1,model_h,model_w,3}};
+    std::vector<std::vector<uint32_t>> output_shapes = {{1,model_h,model_w,1}};
+    model->set_model_properties(input_shapes, Aidlux::Aidlite::DataType::TYPE_FLOAT32, output_shapes, Aidlux::Aidlite::DataType::TYPE_FLOAT32);
+    std::unique_ptr<Interpreter> fast_interpreter = InterpreterBuilder::build_interpretper_from_model_and_config(model, config);
+    if(fast_interpreter == nullptr){
+        printf("build_interpretper_from_model_and_config failed !\n");
+        return EXIT_FAILURE;
+    }
+    int result = fast_interpreter->init();
+    if(result != EXIT_SUCCESS){
+        printf("interpreter->init() failed !\n");
+        return EXIT_FAILURE;
+    }
+    // load model
+    fast_interpreter->load_model();
+    if(result != EXIT_SUCCESS){
+        printf("interpreter->load_model() failed !\n");
+        return EXIT_FAILURE;
+    }
+    printf("detect model load success!\n");
+
+    cv::Mat frame = cv::imread(args.imgs);
+    if (frame.empty()) {
+        printf("detect image load failed!\n");
+        return 1;
+    }
+    printf("img_src cols: %d, img_src rows: %d\n", frame.cols, frame.rows);
+    cv::Mat input_data;
+    cv::Mat frame_clone = frame.clone();
+    int h = frame_clone.rows;
+    int w = frame_clone.cols;
+    cv::Size org_size(w, h);
+    cv::Size org_size0(256, 256);
+
+    cv::Mat input_tensor = img_process(frame_clone, org_size0);
+    float* float_data = matToFloatPtr(input_tensor);
+    unsigned int src_dims[4] = {1, 3, 256, 256};
+    unsigned int tsp_dims[4] = {0,2,3,1};
+    unsigned int stride_data_num = 1*256*256*3;
+    float* format_data = new float[stride_data_num];
+    transpose(float_data, src_dims, tsp_dims, format_data);
+    cv::Mat origin_buffer(3,256*256, CV_32F, format_data);
+
+    float *outdata0 = nullptr;
+    std::vector<float> invoke_time;
+    for (int i = 0; i < args.invoke_nums; ++i) {
+        result = fast_interpreter->set_input_tensor(0, origin_buffer.data);
+        if(result != EXIT_SUCCESS){
+            printf("interpreter->set_input_tensor() failed !\n");
+            return EXIT_FAILURE;
+        }
+        auto t1 = std::chrono::high_resolution_clock::now();
+        result = fast_interpreter->invoke();
+        auto t2 = std::chrono::high_resolution_clock::now();
+        std::chrono::duration<double> cost_time = t2 - t1;
+        invoke_time.push_back(cost_time.count() * 1000);
+        if(result != EXIT_SUCCESS){
+            printf("interpreter->invoke() failed !\n");
+            return EXIT_FAILURE;
+        }
+        uint32_t out_data_0 = 0;
+        result = fast_interpreter->get_output_tensor(0, (void**)&outdata0, &out_data_0);
+        if(result != EXIT_SUCCESS){
+            printf("interpreter->get_output_tensor() 1 failed !\n");
+            return EXIT_FAILURE;
+        }
+
+    }
+
+    float max_invoke_time = *std::max_element(invoke_time.begin(), invoke_time.end());
+    float min_invoke_time = *std::min_element(invoke_time.begin(), invoke_time.end());
+    float mean_invoke_time = std::accumulate(invoke_time.begin(), invoke_time.end(), 0.0f) / args.invoke_nums;
+    float var_invoketime = 0.0f;
+    for (auto time : invoke_time) {
+        var_invoketime += (time - mean_invoke_time) * (time - mean_invoke_time);
+    }
+    var_invoketime /= args.invoke_nums;
+    printf("=======================================\n");
+    printf("QNN inference %d times :\n --mean_invoke_time is %f \n --max_invoke_time is %f \n --min_invoke_time is %f \n --var_invoketime is %f\n", 
+        args.invoke_nums, mean_invoke_time, max_invoke_time, min_invoke_time, var_invoketime);
+    printf("=======================================\n");
+
+    //  post process
+    cv::Mat out_buffer(1,256*256, CV_32F, outdata0);
+     cv::Mat prediction_2d(256, 256, CV_32F, (void*)out_buffer.ptr<float>());
+    cv::Mat resized;
+    cv::resize(prediction_2d, resized, org_size, 0, 0, cv::INTER_CUBIC);
+
+    // 保存为图像
+    write_depth("depth_output.jpg", resized, false, 1);
+
+    // 保存为 PFM
+    write_pfm("depth_output.pfm", resized);
+
+
+
+    fast_interpreter->destory();
+    return 0;
+}
+
+
+int main(int argc, char* argv[]) {
+    Args args = parse_args(argc, argv);
+    return invoke(args);
+}

model_farm_midas_v2_qcs6490_qnn2.16_int8_aidlite/models/midas_v2_w8a8.qnn216.ctx.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1abbd2fc95f87af48b1b609368d9dbaac7136a3aeb8a9c791ea3907da79550f8
+size 27611136

model_farm_midas_v2_qcs6490_qnn2.16_int8_aidlite/python/run_test.py

@@ -0,0 +1,111 @@
+import numpy as np
+import torch
+import cv2
+import os
+from  utils import write_pfm,write_depth,img_process
+import aidlite
+import time
+import argparse
+
+def out_process(prediction,target_size):
+    prediction = torch.nn.functional.interpolate(
+            prediction,
+            size=target_size,
+            mode="bicubic",
+            align_corners=False,
+        )
+    prediction = prediction.squeeze().detach().numpy()
+    return prediction
+
+class run_qnn:
+    def __init__(self,qnn_path):
+        super().__init__()
+        self.model = aidlite.Model.create_instance(qnn_path)
+        if self.model is None:
+            print("Create model failed !")
+            return
+
+        self.config = aidlite.Config.create_instance()
+        if self.config is None:
+            print("build_interpretper_from_model_and_config failed !")
+            return
+
+        self.config.implement_type = aidlite.ImplementType.TYPE_LOCAL
+        self.config.framework_type = aidlite.FrameworkType.TYPE_QNN
+        self.config.accelerate_type = aidlite.AccelerateType.TYPE_DSP
+        # self.config.accelerate_type = aidlite.AccelerateType.TYPE_CPU
+        self.config.is_quantify_model = 1
+        
+        self.interpreter = aidlite.InterpreterBuilder.build_interpretper_from_model_and_config(self.model, self.config)
+        if self.interpreter is None:
+            print("build_interpretper_from_model_and_config failed !")
+            return
+        input_shapes = [[1,256,256,3]]
+        output_shapes = [[1,256,256,1]]
+        self.model.set_model_properties(input_shapes, aidlite.DataType.TYPE_FLOAT32,
+                                output_shapes, aidlite.DataType.TYPE_FLOAT32)
+
+        if self.interpreter is None:
+            print("build_interpretper_from_model_and_config failed !")
+        result = self.interpreter.init()
+        if result != 0:
+            print(f"interpreter init failed !")
+        result = self.interpreter.load_model()
+        if result != 0:
+            print("interpreter load model failed !")
+   
+        print(" model load success!")
+
+    def __call__(self, input,invoke_nums):
+        self.interpreter.set_input_tensor(0,input)
+        invoke_time=[]
+        for i in range(invoke_nums):
+            result = self.interpreter.set_input_tensor(0, input.data)
+            if result != 0:
+                print("interpreter set_input_tensor() failed")
+            t1=time.time()
+            result = self.interpreter.invoke()
+            cost_time = (time.time()-t1)*1000
+            invoke_time.append(cost_time)
+
+        max_invoke_time = max(invoke_time)
+        min_invoke_time = min(invoke_time)
+        mean_invoke_time = sum(invoke_time)/invoke_nums
+        var_invoketime=np.var(invoke_time)
+        print("====================================")
+        print(f"QNN  invoke time:\n --mean_invoke_time is {mean_invoke_time} \n --max_invoke_time is {max_invoke_time} \n --min_invoke_time is {min_invoke_time} \n --var_invoketime is {var_invoketime}")
+        print("====================================")
+        features_0 = self.interpreter.get_output_tensor(0).reshape(1,256,256,1).transpose(0,3,1,2)
+        return features_0
+
+
+
+def run(args):
+    img_path = args.imgs
+    qnn_path = args.target_model
+    invoke_num=args.invoke_nums
+    print("Start processing...")
+    img_input,org_size = img_process(img_path)
+
+    qnn_model =run_qnn(qnn_path)
+    prediction_qnn = qnn_model(img_input.numpy().transpose(0,2,3,1),invoke_num)
+    prediction_qnn = torch.tensor(prediction_qnn)
+    qnn_process = out_process(prediction_qnn,org_size)
+
+    write_depth("./python/results.jpg", qnn_process, grayscale=False, bits=1)
+    write_pfm("./python/results.pfm", qnn_process.astype(np.float32))
+    print("Finished")
+
+def parser_args():
+    parser = argparse.ArgumentParser(description="Run model benchmarks")
+    parser.add_argument('--target_model',type=str,default='./models/midas_v2_w8a8.qnn216.ctx.bin',help="Inference model path")
+    parser.add_argument('--imgs',type=str,default='./python/dog.jpg',help="Predict images path")
+    parser.add_argument('--invoke_nums',type=int,default=10,help="Inference nums")
+    parser.add_argument('--model_type',type=str,default='QNN',help="Run backend")
+    args = parser.parse_args()
+    return args
+
+
+if __name__ =="__main__":
+    args = parser_args()
+    run(args)

model_farm_midas_v2_qcs6490_qnn2.16_int8_aidlite/python/transforms.py

@@ -0,0 +1,234 @@
+import numpy as np
+import cv2
+import math
+
+
+def apply_min_size(sample, size, image_interpolation_method=cv2.INTER_AREA):
+    """Rezise the sample to ensure the given size. Keeps aspect ratio.
+
+    Args:
+        sample (dict): sample
+        size (tuple): image size
+
+    Returns:
+        tuple: new size
+    """
+    shape = list(sample["disparity"].shape)
+
+    if shape[0] >= size[0] and shape[1] >= size[1]:
+        return sample
+
+    scale = [0, 0]
+    scale[0] = size[0] / shape[0]
+    scale[1] = size[1] / shape[1]
+
+    scale = max(scale)
+
+    shape[0] = math.ceil(scale * shape[0])
+    shape[1] = math.ceil(scale * shape[1])
+
+    # resize
+    sample["image"] = cv2.resize(
+        sample["image"], tuple(shape[::-1]), interpolation=image_interpolation_method
+    )
+
+    sample["disparity"] = cv2.resize(
+        sample["disparity"], tuple(shape[::-1]), interpolation=cv2.INTER_NEAREST
+    )
+    sample["mask"] = cv2.resize(
+        sample["mask"].astype(np.float32),
+        tuple(shape[::-1]),
+        interpolation=cv2.INTER_NEAREST,
+    )
+    sample["mask"] = sample["mask"].astype(bool)
+
+    return tuple(shape)
+
+
+class Resize(object):
+    """Resize sample to given size (width, height).
+    """
+
+    def __init__(
+        self,
+        width,
+        height,
+        resize_target=True,
+        keep_aspect_ratio=False,
+        ensure_multiple_of=1,
+        resize_method="lower_bound",
+        image_interpolation_method=cv2.INTER_AREA,
+    ):
+        """Init.
+
+        Args:
+            width (int): desired output width
+            height (int): desired output height
+            resize_target (bool, optional):
+                True: Resize the full sample (image, mask, target).
+                False: Resize image only.
+                Defaults to True.
+            keep_aspect_ratio (bool, optional):
+                True: Keep the aspect ratio of the input sample.
+                Output sample might not have the given width and height, and
+                resize behaviour depends on the parameter 'resize_method'.
+                Defaults to False.
+            ensure_multiple_of (int, optional):
+                Output width and height is constrained to be multiple of this parameter.
+                Defaults to 1.
+            resize_method (str, optional):
+                "lower_bound": Output will be at least as large as the given size.
+                "upper_bound": Output will be at max as large as the given size. (Output size might be smaller than given size.)
+                "minimal": Scale as least as possible.  (Output size might be smaller than given size.)
+                Defaults to "lower_bound".
+        """
+        self.__width = width
+        self.__height = height
+
+        self.__resize_target = resize_target
+        self.__keep_aspect_ratio = keep_aspect_ratio
+        self.__multiple_of = ensure_multiple_of
+        self.__resize_method = resize_method
+        self.__image_interpolation_method = image_interpolation_method
+
+    def constrain_to_multiple_of(self, x, min_val=0, max_val=None):
+        y = (np.round(x / self.__multiple_of) * self.__multiple_of).astype(int)
+
+        if max_val is not None and y > max_val:
+            y = (np.floor(x / self.__multiple_of) * self.__multiple_of).astype(int)
+
+        if y < min_val:
+            y = (np.ceil(x / self.__multiple_of) * self.__multiple_of).astype(int)
+
+        return y
+
+    def get_size(self, width, height):
+        # determine new height and width
+        scale_height = self.__height / height
+        scale_width = self.__width / width
+
+        if self.__keep_aspect_ratio:
+            if self.__resize_method == "lower_bound":
+                # scale such that output size is lower bound
+                if scale_width > scale_height:
+                    # fit width
+                    scale_height = scale_width
+                else:
+                    # fit height
+                    scale_width = scale_height
+            elif self.__resize_method == "upper_bound":
+                # scale such that output size is upper bound
+                if scale_width < scale_height:
+                    # fit width
+                    scale_height = scale_width
+                else:
+                    # fit height
+                    scale_width = scale_height
+            elif self.__resize_method == "minimal":
+                # scale as least as possbile
+                if abs(1 - scale_width) < abs(1 - scale_height):
+                    # fit width
+                    scale_height = scale_width
+                else:
+                    # fit height
+                    scale_width = scale_height
+            else:
+                raise ValueError(
+                    f"resize_method {self.__resize_method} not implemented"
+                )
+
+        if self.__resize_method == "lower_bound":
+            new_height = self.constrain_to_multiple_of(
+                scale_height * height, min_val=self.__height
+            )
+            new_width = self.constrain_to_multiple_of(
+                scale_width * width, min_val=self.__width
+            )
+        elif self.__resize_method == "upper_bound":
+            new_height = self.constrain_to_multiple_of(
+                scale_height * height, max_val=self.__height
+            )
+            new_width = self.constrain_to_multiple_of(
+                scale_width * width, max_val=self.__width
+            )
+        elif self.__resize_method == "minimal":
+            new_height = self.constrain_to_multiple_of(scale_height * height)
+            new_width = self.constrain_to_multiple_of(scale_width * width)
+        else:
+            raise ValueError(f"resize_method {self.__resize_method} not implemented")
+
+        return (new_width, new_height)
+
+    def __call__(self, sample):
+        width, height = self.get_size(
+            sample["image"].shape[1], sample["image"].shape[0]
+        )
+
+        # resize sample
+        sample["image"] = cv2.resize(
+            sample["image"],
+            (width, height),
+            interpolation=self.__image_interpolation_method,
+        )
+
+        if self.__resize_target:
+            if "disparity" in sample:
+                sample["disparity"] = cv2.resize(
+                    sample["disparity"],
+                    (width, height),
+                    interpolation=cv2.INTER_NEAREST,
+                )
+
+            if "depth" in sample:
+                sample["depth"] = cv2.resize(
+                    sample["depth"], (width, height), interpolation=cv2.INTER_NEAREST
+                )
+
+            sample["mask"] = cv2.resize(
+                sample["mask"].astype(np.float32),
+                (width, height),
+                interpolation=cv2.INTER_NEAREST,
+            )
+            sample["mask"] = sample["mask"].astype(bool)
+
+        return sample
+
+
+class NormalizeImage(object):
+    """Normlize image by given mean and std.
+    """
+
+    def __init__(self, mean, std):
+        self.__mean = mean
+        self.__std = std
+
+    def __call__(self, sample):
+        sample["image"] = (sample["image"] - self.__mean) / self.__std
+
+        return sample
+
+
+class PrepareForNet(object):
+    """Prepare sample for usage as network input.
+    """
+
+    def __init__(self):
+        pass
+
+    def __call__(self, sample):
+        image = np.transpose(sample["image"], (2, 0, 1))
+        sample["image"] = np.ascontiguousarray(image).astype(np.float32)
+
+        if "mask" in sample:
+            sample["mask"] = sample["mask"].astype(np.float32)
+            sample["mask"] = np.ascontiguousarray(sample["mask"])
+
+        if "disparity" in sample:
+            disparity = sample["disparity"].astype(np.float32)
+            sample["disparity"] = np.ascontiguousarray(disparity)
+
+        if "depth" in sample:
+            depth = sample["depth"].astype(np.float32)
+            sample["depth"] = np.ascontiguousarray(depth)
+
+        return sample

model_farm_midas_v2_qcs6490_qnn2.16_int8_aidlite/python/utils.py

@@ -0,0 +1,104 @@
+import numpy as np
+import torch
+import cv2
+import os
+
+from transforms import Resize, NormalizeImage, PrepareForNet
+
+from torchvision.transforms import Compose
+import sys
+first_execution = True
+def img_process(img_path):
+    global first_execution
+    first_execution = False
+    net_w, net_h = 256, 256
+    resize_mode = "upper_bound"
+    normalization = NormalizeImage(
+        mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]
+    )
+    transform = Compose(
+        [
+            Resize(
+                net_w,
+                net_h,
+                resize_target=None,
+                keep_aspect_ratio=False,
+                ensure_multiple_of=32,
+                resize_method=resize_mode,
+                image_interpolation_method=cv2.INTER_CUBIC,
+            ),
+            normalization,
+            PrepareForNet(),
+        ]
+    )
+    # image = utils.read_image(img_path)  # in [0, 1]
+    image = cv2.imread(img_path)
+    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) / 255.0
+    org_size=  image.shape[:2]
+    image = transform({"image": image})["image"]
+    sample = torch.from_numpy(image).to("cpu").unsqueeze(0)
+    height, width = sample.shape[2:]
+    print(f"Input resized to {width}x{height} before entering the encoder")
+
+    return sample,org_size
+
+
+
+def write_depth(path, depth, grayscale=False, bits=1):
+    if not grayscale:
+        bits = 1
+
+    if not np.isfinite(depth).all():
+        depth=np.nan_to_num(depth, nan=0.0, posinf=0.0, neginf=0.0)
+        print("WARNING: Non-finite depth values present")
+
+    depth_min = depth.min()
+    depth_max = depth.max()
+
+    max_val = (2**(8*bits))-1
+
+    if depth_max - depth_min > np.finfo("float").eps:
+        out = max_val * (depth - depth_min) / (depth_max - depth_min)
+    else:
+        out = np.zeros(depth.shape, dtype=depth.dtype)
+
+    # print("out :",out.shape,out)
+    if not grayscale:
+        out = cv2.applyColorMap(np.uint8(out), cv2.COLORMAP_INFERNO)
+
+    if bits == 1:
+        cv2.imwrite(path , out.astype("uint8"))
+    elif bits == 2:
+        cv2.imwrite(path , out.astype("uint16"))
+
+    return
+
+def write_pfm(path, image, scale=1):
+    with open(path, "wb") as file:
+        color = None
+
+        if image.dtype.name != "float32":
+            raise Exception("Image dtype must be float32.")
+
+        image = np.flipud(image)
+
+        if len(image.shape) == 3 and image.shape[2] == 3:  # color image
+            color = True
+        elif (
+            len(image.shape) == 2 or len(image.shape) == 3 and image.shape[2] == 1
+        ):  # greyscale
+            color = False
+        else:
+            raise Exception("Image must have H x W x 3, H x W x 1 or H x W dimensions.")
+
+        file.write("PF\n" if color else "Pf\n".encode())
+        file.write("%d %d\n".encode() % (image.shape[1], image.shape[0]))
+
+        endian = image.dtype.byteorder
+
+        if endian == "<" or endian == "=" and sys.byteorder == "little":
+            scale = -scale
+
+        file.write("%f\n".encode() % scale)
+
+        image.tofile(file)

model_farm_midas_v2_qcs6490_qnn2.16_w8a16_aidlite/README.md

@@ -0,0 +1,56 @@
+## Model Information
+
+### Source model
+- Input shape: 1x3x256x256
+- Number of parameters: 20.33M
+- Model size: 82.17M
+- Output shape: 1x1x256x256
+
+Source model repository: [midas](https://github.com/isl-org/MiDaS/tree/master)
+
+### Converted model
+
+- Precision: INT8
+- Backend: QNN2.16
+- Target Device: FV01 QCS6490
+
+## Inference with AidLite SDK
+
+### SDK installation
+Model Farm uses AidLite SDK as the model inference SDK. For details, please refer to the [AidLite Developer Documentation](https://v2.docs.aidlux.com/en/sdk-api/aidlite-sdk/)
+
+- Install AidLite SDK
+
+```bash
+# Install the appropriate version of the aidlite sdk
+sudo aid-pkg update
+sudo aid-pkg install aidlite-sdk
+# Download the qnn version that matches the above backend. Eg Install QNN2.23 Aidlite: sudo aid-pkg install aidlite-qnn223
+sudo aid-pkg install aidlite-{QNN VERSION}
+```
+
+- Verify AidLite SDK
+
+```bash
+# aidlite sdk c++ check
+python3 -c "import aidlite ; print(aidlite.get_library_version())"
+
+# aidlite sdk python check
+python3 -c "import aidlite ; print(aidlite.get_py_library_version())"
+```
+
+### Run Demo
+#### python
+```bash
+cd model_farm_midas_v2_qcs6490_qnn2.16_w8a16_aidlite
+python3 python/run_test.py --target_model ./models/midas_v2_w8a16.qnn216.ctx.bin --imgs ./python/dog.jpg  --invoke_nums 10 
+```
+
+#### c++
+```bash
+cd midas_v2/model_farm_midas_v2_qcs6490_qnn2.16_w8a16_aidlite/cpp
+mkdir build && cd build 
+cmake ..
+make
+./run_test
+```

model_farm_midas_v2_qcs6490_qnn2.16_w8a16_aidlite/cpp/CMakeLists.txt

@@ -0,0 +1,32 @@
+cmake_minimum_required (VERSION 3.5)
+project("run_test")
+
+find_package(OpenCV REQUIRED)
+
+message(STATUS "oPENCV Library status:")
+message(STATUS ">version:${OpenCV_VERSION}")
+message(STATUS "Include:${OpenCV_INCLUDE_DIRS}")
+
+set(CMAKE_CXX_FLAGS "-Wno-error=deprecated-declarations -Wno-deprecated-declarations")
+
+include_directories(
+    /usr/local/include
+    /usr/include/opencv4
+)
+
+link_directories(
+    /usr/local/lib/
+)
+
+file(GLOB SRC_LISTS 
+    ${CMAKE_CURRENT_SOURCE_DIR}/run_test.cpp  
+)
+
+add_executable(run_test ${SRC_LISTS})
+
+target_link_libraries(run_test
+    aidlite
+	${OpenCV_LIBS}
+    pthread
+    jsoncpp
+)

model_farm_midas_v2_qcs6490_qnn2.16_w8a16_aidlite/cpp/run_test.cpp

@@ -0,0 +1,392 @@
+#include <iostream>
+#include <fstream>
+#include <opencv2/opencv.hpp>
+#include <aidlux/aidlite/aidlite.hpp>
+#include <vector>
+#include <numeric>
+#include <cmath>
+#include <jsoncpp/json/json.h>
+
+using namespace cv;
+using namespace std;
+using namespace Aidlux::Aidlite;
+
+const int net_w = 256;
+const int net_h = 256;
+
+const std::vector<float> mean_vals = {0.485f, 0.456f, 0.406f};
+const std::vector<float> std_vals = {0.229f, 0.224f, 0.225f};
+
+
+struct Args {
+    std::string target_model = "../../models/midas_v2_w8a16.qnn216.ctx.bin";
+    std::string imgs = "../dog.jpg";
+    int invoke_nums = 10;
+    std::string model_type = "QNN";
+};
+
+
+Args parse_args(int argc, char* argv[]) {
+    Args args;
+    for (int i = 1; i < argc; ++i) {
+        std::string arg = argv[i];
+        if (arg == "--target_model" && i + 1 < argc) {
+            args.target_model = argv[++i];
+        } else if (arg == "--imgs" && i + 1 < argc) {
+            args.imgs = argv[++i];
+        } else if (arg == "--invoke_nums" && i + 1 < argc) {
+            args.invoke_nums = std::stoi(argv[++i]);
+        } else if (arg == "--model_type" && i + 1 < argc) {
+            args.model_type = argv[++i];
+        }
+    }
+    return args;
+}
+
+std::string to_lower(const std::string& str) {
+    std::string lower_str = str;
+    std::transform(lower_str.begin(), lower_str.end(), lower_str.begin(), [](unsigned char c) {
+        return std::tolower(c);
+    });
+    return lower_str;
+}
+
+
+int transpose(float* src, unsigned int* src_dims, unsigned int* tsp_dims, float* dest){
+
+    int current_coordinate[4] = {0, 0, 0, 0};
+    for(int a = 0; a < src_dims[0]; ++a){
+        current_coordinate[0] = a;
+        for(int b = 0; b < src_dims[1]; ++b){
+            current_coordinate[1] = b;
+            for(int c = 0; c < src_dims[2]; ++c){
+                current_coordinate[2] = c;
+                for(int d = 0; d < src_dims[3]; ++d){
+                    current_coordinate[3] = d;
+
+                    int old_index = current_coordinate[0]*src_dims[1]*src_dims[2]*src_dims[3] + 
+                                    current_coordinate[1]*src_dims[2]*src_dims[3] + 
+                                    current_coordinate[2]*src_dims[3] + 
+                                    current_coordinate[3];
+
+                    int new_index = current_coordinate[tsp_dims[0]]*src_dims[tsp_dims[1]]*src_dims[tsp_dims[2]]*src_dims[tsp_dims[3]] + 
+                                    current_coordinate[tsp_dims[1]]*src_dims[tsp_dims[2]]*src_dims[tsp_dims[3]] + 
+                                    current_coordinate[tsp_dims[2]]*src_dims[tsp_dims[3]] + 
+                                    current_coordinate[tsp_dims[3]];
+
+                    dest[new_index] = src[old_index];
+                }
+            }
+        }
+    }
+
+    return EXIT_SUCCESS;
+}
+
+
+// 替代 np.nan_to_num
+void sanitizeDepthMap(cv::Mat& depth) {
+    for (int y = 0; y < depth.rows; ++y) {
+        float* row = depth.ptr<float>(y);
+        for (int x = 0; x < depth.cols; ++x) {
+            float val = row[x];
+            if (!std::isfinite(val)) {
+                row[x] = 0.0f;
+            }
+        }
+    }
+}
+
+// 等效于 Python write_depth
+void write_depth(const std::string& path, const cv::Mat& input_depth, bool grayscale = false, int bits = 1) {
+    CV_Assert(input_depth.type() == CV_32FC1);
+
+    // 拷贝 + 处理非法值
+    cv::Mat depth = input_depth.clone();
+    sanitizeDepthMap(depth);
+
+    double minVal, maxVal;
+    cv::minMaxLoc(depth, &minVal, &maxVal);
+
+    double max_val = (1 << (8 * bits)) - 1;
+    cv::Mat out;
+
+    if (maxVal - minVal > std::numeric_limits<float>::epsilon()) {
+        // 归一化并映射到位深范围
+        out = (depth - minVal) * (max_val / (maxVal - minVal));
+    } else {
+        out = cv::Mat::zeros(depth.size(), CV_32F);
+    }
+
+    if (!grayscale) {
+        out.convertTo(out, CV_8UC1);
+        cv::applyColorMap(out, out, cv::COLORMAP_INFERNO);
+    }
+
+    if (bits == 1) {
+        out.convertTo(out, CV_8U);
+    } else if (bits == 2) {
+        out.convertTo(out, CV_16U);
+    }
+
+    cv::imwrite(path, out);
+}
+
+// 等效于 Python write_pfm
+void write_pfm(const std::string& path, const cv::Mat& image, float scale = 1.0f) {
+    CV_Assert(image.type() == CV_32FC1 || image.type() == CV_32FC3);
+
+    std::ofstream file(path, std::ios::binary);
+    if (!file.is_open()) {
+        std::cerr << "Failed to open file for writing PFM: " << path << std::endl;
+        return;
+    }
+
+    int width = image.cols;
+    int height = image.rows;
+    int channels = image.channels();
+    bool color = (channels == 3);
+
+    file << (color ? "PF" : "Pf") << "\n";
+    file << width << " " << height << "\n";
+
+    // Endianness: negative = little-endian
+    uint16_t endian_test = 0x1;
+    bool is_little_endian = *(reinterpret_cast<uint8_t*>(&endian_test)) == 0x1;
+    if (is_little_endian) {
+        scale = -scale;
+    }
+
+    file << scale << "\n";
+
+    // Flip vertically (OpenCV top-left origin -> PFM bottom-left origin)
+    cv::Mat flipped;
+    cv::flip(image, flipped, 0);
+
+    // Write raw data
+    file.write(reinterpret_cast<const char*>(flipped.data), flipped.total() * channels * sizeof(float));
+    file.close();
+}
+
+
+// ======================= Normalize =======================
+void normalize(cv::Mat& image) {
+    CV_Assert(image.type() == CV_32FC3);
+    int rows = image.rows;
+    int cols = image.cols;
+
+    for (int y = 0; y < rows; ++y) {
+        cv::Vec3f* row = image.ptr<cv::Vec3f>(y);
+        for (int x = 0; x < cols; ++x) {
+            for (int c = 0; c < 3; ++c) {
+                row[x][c] = (row[x][c] - mean_vals[c]) / std_vals[c];
+            }
+        }
+    }
+}
+
+cv::Mat hwc_to_chw(const cv::Mat& image) {
+    std::vector<cv::Mat> channels(3);
+    cv::split(image, channels);
+
+    cv::Mat chw(3, image.rows * image.cols, CV_32F);
+    for (int c = 0; c < 3; ++c) {
+        memcpy(chw.ptr(c), channels[c].data, image.rows * image.cols * sizeof(float));
+    }
+
+    return chw;
+}
+
+
+bool first_execution = true;
+cv::Mat img_process(const cv::Mat image_bgr, cv::Size& org_size_out) {
+    first_execution = false;
+
+    cv::Mat image_rgb;
+    cv::cvtColor(image_bgr, image_rgb, cv::COLOR_BGR2RGB);
+    image_rgb.convertTo(image_rgb, CV_32FC3, 1.0 / 255.0);
+
+    // 2. Save original size
+    org_size_out = image_rgb.size();  // H x W
+
+    // 3. Resize to 256x256 using cubic interpolation
+    cv::resize(image_rgb, image_rgb, cv::Size(net_w, net_h), 0, 0, cv::INTER_CUBIC);
+
+    // 4. Normalize using mean/std
+    normalize(image_rgb);
+
+    // 5. Convert HWC to CHW
+    cv::Mat chw = hwc_to_chw(image_rgb);
+
+    // 6. Add batch dimension: [1, C, H, W] → reshape to 1x3xHxW style float array
+    cv::Mat input_tensor(1, 3 * net_h * net_w, CV_32F);
+    memcpy(input_tensor.ptr<float>(), chw.data, 3 * net_h * net_w * sizeof(float));
+
+    std::cout << "Input resized to " << net_w << "x" << net_h << " before entering the encoder" << std::endl;
+
+    return input_tensor;
+}
+
+
+float* matToFloatPtr(const cv::Mat& input_mat, bool normalize = true) {
+    // 检查连续性
+    cv::Mat mat = input_mat;
+    if (!mat.isContinuous()) {
+        mat = mat.clone();
+    }
+
+    // 分配内存
+    int total_pixels = mat.rows * mat.cols;
+    int channels = mat.channels();
+    float* float_data = new float[total_pixels * channels];
+
+    // 根据数据类型转换
+    if (mat.type() == CV_8UC1 || mat.type() == CV_8UC3) {
+        uchar* ptr = mat.ptr<uchar>(0);
+        for (int i = 0; i < total_pixels * channels; ++i) {
+            float_data[i] = normalize ? (static_cast<float>(ptr[i]) / 255.0f) : ptr[i];
+        }
+    } else if (mat.type() == CV_32FC1 || mat.type() == CV_32FC3) {
+        float* ptr = mat.ptr<float>(0);
+        std::memcpy(float_data, ptr, total_pixels * channels * sizeof(float));
+    } else {
+        delete[] float_data;
+        return nullptr; // 不支持的类型
+    }
+
+    return float_data;
+}
+
+
+int invoke(const Args& args) {
+    std::cout << "Start main ... ... Model Path: " << args.target_model << "\n"
+              << "Image Path: " << args.imgs << "\n"
+              << "Inference Nums: " << args.invoke_nums << "\n"
+              << "Model Type: " << args.model_type << "\n";
+    Model* model = Model::create_instance(args.target_model);
+    if(model == nullptr){
+        printf("Create model failed !\n");
+        return EXIT_FAILURE;
+    }
+    Config* config = Config::create_instance();
+    if(config == nullptr){
+        printf("Create config failed !\n");
+        return EXIT_FAILURE;
+    }
+    config->implement_type = ImplementType::TYPE_LOCAL;
+    std::string model_type_lower = to_lower(args.model_type);
+    if (model_type_lower == "qnn"){
+        config->framework_type = FrameworkType::TYPE_QNN;
+    } else if (model_type_lower == "snpe2" || model_type_lower == "snpe") {
+        config->framework_type = FrameworkType::TYPE_SNPE2;
+    }
+    config->accelerate_type = AccelerateType::TYPE_DSP;
+    config->is_quantify_model = 1;
+
+    unsigned int model_h = 256;
+    unsigned int model_w = 256;
+    std::vector<std::vector<uint32_t>> input_shapes = {{1,model_h,model_w,3}};
+    std::vector<std::vector<uint32_t>> output_shapes = {{1,model_h,model_w,1}};
+    model->set_model_properties(input_shapes, Aidlux::Aidlite::DataType::TYPE_FLOAT32, output_shapes, Aidlux::Aidlite::DataType::TYPE_FLOAT32);
+    std::unique_ptr<Interpreter> fast_interpreter = InterpreterBuilder::build_interpretper_from_model_and_config(model, config);
+    if(fast_interpreter == nullptr){
+        printf("build_interpretper_from_model_and_config failed !\n");
+        return EXIT_FAILURE;
+    }
+    int result = fast_interpreter->init();
+    if(result != EXIT_SUCCESS){
+        printf("interpreter->init() failed !\n");
+        return EXIT_FAILURE;
+    }
+    // load model
+    fast_interpreter->load_model();
+    if(result != EXIT_SUCCESS){
+        printf("interpreter->load_model() failed !\n");
+        return EXIT_FAILURE;
+    }
+    printf("detect model load success!\n");
+
+    cv::Mat frame = cv::imread(args.imgs);
+    if (frame.empty()) {
+        printf("detect image load failed!\n");
+        return 1;
+    }
+    printf("img_src cols: %d, img_src rows: %d\n", frame.cols, frame.rows);
+    cv::Mat input_data;
+    cv::Mat frame_clone = frame.clone();
+    int h = frame_clone.rows;
+    int w = frame_clone.cols;
+    cv::Size org_size(w, h);
+    cv::Size org_size0(256, 256);
+
+    cv::Mat input_tensor = img_process(frame_clone, org_size0);
+    float* float_data = matToFloatPtr(input_tensor);
+    unsigned int src_dims[4] = {1, 3, 256, 256};
+    unsigned int tsp_dims[4] = {0,2,3,1};
+    unsigned int stride_data_num = 1*256*256*3;
+    float* format_data = new float[stride_data_num];
+    transpose(float_data, src_dims, tsp_dims, format_data);
+    cv::Mat origin_buffer(3,256*256, CV_32F, format_data);
+
+    float *outdata0 = nullptr;
+    std::vector<float> invoke_time;
+    for (int i = 0; i < args.invoke_nums; ++i) {
+        result = fast_interpreter->set_input_tensor(0, origin_buffer.data);
+        if(result != EXIT_SUCCESS){
+            printf("interpreter->set_input_tensor() failed !\n");
+            return EXIT_FAILURE;
+        }
+        auto t1 = std::chrono::high_resolution_clock::now();
+        result = fast_interpreter->invoke();
+        auto t2 = std::chrono::high_resolution_clock::now();
+        std::chrono::duration<double> cost_time = t2 - t1;
+        invoke_time.push_back(cost_time.count() * 1000);
+        if(result != EXIT_SUCCESS){
+            printf("interpreter->invoke() failed !\n");
+            return EXIT_FAILURE;
+        }
+        uint32_t out_data_0 = 0;
+        result = fast_interpreter->get_output_tensor(0, (void**)&outdata0, &out_data_0);
+        if(result != EXIT_SUCCESS){
+            printf("interpreter->get_output_tensor() 1 failed !\n");
+            return EXIT_FAILURE;
+        }
+
+    }
+
+    float max_invoke_time = *std::max_element(invoke_time.begin(), invoke_time.end());
+    float min_invoke_time = *std::min_element(invoke_time.begin(), invoke_time.end());
+    float mean_invoke_time = std::accumulate(invoke_time.begin(), invoke_time.end(), 0.0f) / args.invoke_nums;
+    float var_invoketime = 0.0f;
+    for (auto time : invoke_time) {
+        var_invoketime += (time - mean_invoke_time) * (time - mean_invoke_time);
+    }
+    var_invoketime /= args.invoke_nums;
+    printf("=======================================\n");
+    printf("QNN inference %d times :\n --mean_invoke_time is %f \n --max_invoke_time is %f \n --min_invoke_time is %f \n --var_invoketime is %f\n", 
+        args.invoke_nums, mean_invoke_time, max_invoke_time, min_invoke_time, var_invoketime);
+    printf("=======================================\n");
+
+    //  post process
+    cv::Mat out_buffer(1,256*256, CV_32F, outdata0);
+     cv::Mat prediction_2d(256, 256, CV_32F, (void*)out_buffer.ptr<float>());
+    cv::Mat resized;
+    cv::resize(prediction_2d, resized, org_size, 0, 0, cv::INTER_CUBIC);
+
+    // 保存为图像
+    write_depth("depth_output.jpg", resized, false, 1);
+
+    // 保存为 PFM
+    write_pfm("depth_output.pfm", resized);
+
+
+
+    fast_interpreter->destory();
+    return 0;
+}
+
+
+int main(int argc, char* argv[]) {
+    Args args = parse_args(argc, argv);
+    return invoke(args);
+}

model_farm_midas_v2_qcs6490_qnn2.16_w8a16_aidlite/models/midas_v2_w8a16.qnn216.ctx.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cc4f6a5cdfb55ede7cfde5298734fc33221d440fe410b726bc9fdaca2ff6a667
+size 27836416

model_farm_midas_v2_qcs6490_qnn2.16_w8a16_aidlite/python/run_test.py

@@ -0,0 +1,111 @@
+import numpy as np
+import torch
+import cv2
+import os
+from  utils import write_pfm,write_depth,img_process
+import aidlite
+import time
+import argparse
+
+def out_process(prediction,target_size):
+    prediction = torch.nn.functional.interpolate(
+            prediction,
+            size=target_size,
+            mode="bicubic",
+            align_corners=False,
+        )
+    prediction = prediction.squeeze().detach().numpy()
+    return prediction
+
+class run_qnn:
+    def __init__(self,qnn_path):
+        super().__init__()
+        self.model = aidlite.Model.create_instance(qnn_path)
+        if self.model is None:
+            print("Create model failed !")
+            return
+
+        self.config = aidlite.Config.create_instance()
+        if self.config is None:
+            print("build_interpretper_from_model_and_config failed !")
+            return
+
+        self.config.implement_type = aidlite.ImplementType.TYPE_LOCAL
+        self.config.framework_type = aidlite.FrameworkType.TYPE_QNN
+        self.config.accelerate_type = aidlite.AccelerateType.TYPE_DSP
+        # self.config.accelerate_type = aidlite.AccelerateType.TYPE_CPU
+        self.config.is_quantify_model = 1
+        
+        self.interpreter = aidlite.InterpreterBuilder.build_interpretper_from_model_and_config(self.model, self.config)
+        if self.interpreter is None:
+            print("build_interpretper_from_model_and_config failed !")
+            return
+        input_shapes = [[1,256,256,3]]
+        output_shapes = [[1,256,256,1]]
+        self.model.set_model_properties(input_shapes, aidlite.DataType.TYPE_FLOAT32,
+                                output_shapes, aidlite.DataType.TYPE_FLOAT32)
+
+        if self.interpreter is None:
+            print("build_interpretper_from_model_and_config failed !")
+        result = self.interpreter.init()
+        if result != 0:
+            print(f"interpreter init failed !")
+        result = self.interpreter.load_model()
+        if result != 0:
+            print("interpreter load model failed !")
+   
+        print(" model load success!")
+
+    def __call__(self, input,invoke_nums):
+        self.interpreter.set_input_tensor(0,input)
+        invoke_time=[]
+        for i in range(invoke_nums):
+            result = self.interpreter.set_input_tensor(0, input.data)
+            if result != 0:
+                print("interpreter set_input_tensor() failed")
+            t1=time.time()
+            result = self.interpreter.invoke()
+            cost_time = (time.time()-t1)*1000
+            invoke_time.append(cost_time)
+
+        max_invoke_time = max(invoke_time)
+        min_invoke_time = min(invoke_time)
+        mean_invoke_time = sum(invoke_time)/invoke_nums
+        var_invoketime=np.var(invoke_time)
+        print("====================================")
+        print(f"QNN  invoke time:\n --mean_invoke_time is {mean_invoke_time} \n --max_invoke_time is {max_invoke_time} \n --min_invoke_time is {min_invoke_time} \n --var_invoketime is {var_invoketime}")
+        print("====================================")
+        features_0 = self.interpreter.get_output_tensor(0).reshape(1,256,256,1).transpose(0,3,1,2)
+        return features_0
+
+
+
+def run(args):
+    img_path = args.imgs
+    qnn_path = args.target_model
+    invoke_num=args.invoke_nums
+    print("Start processing...")
+    img_input,org_size = img_process(img_path)
+
+    qnn_model =run_qnn(qnn_path)
+    prediction_qnn = qnn_model(img_input.numpy().transpose(0,2,3,1),invoke_num)
+    prediction_qnn = torch.tensor(prediction_qnn)
+    qnn_process = out_process(prediction_qnn,org_size)
+
+    write_depth("./python/results.jpg", qnn_process, grayscale=False, bits=1)
+    write_pfm("./python/results.pfm", qnn_process.astype(np.float32))
+    print("Finished")
+
+def parser_args():
+    parser = argparse.ArgumentParser(description="Run model benchmarks")
+    parser.add_argument('--target_model',type=str,default='./models/midas_v2_w8a16.qnn216.ctx.bin',help="Inference model path")
+    parser.add_argument('--imgs',type=str,default='./python/dog.jpg',help="Predict images path")
+    parser.add_argument('--invoke_nums',type=int,default=10,help="Inference nums")
+    parser.add_argument('--model_type',type=str,default='QNN',help="Run backend")
+    args = parser.parse_args()
+    return args
+
+
+if __name__ =="__main__":
+    args = parser_args()
+    run(args)

model_farm_midas_v2_qcs6490_qnn2.16_w8a16_aidlite/python/transforms.py

@@ -0,0 +1,234 @@
+import numpy as np
+import cv2
+import math
+
+
+def apply_min_size(sample, size, image_interpolation_method=cv2.INTER_AREA):
+    """Rezise the sample to ensure the given size. Keeps aspect ratio.
+
+    Args:
+        sample (dict): sample
+        size (tuple): image size
+
+    Returns:
+        tuple: new size
+    """
+    shape = list(sample["disparity"].shape)
+
+    if shape[0] >= size[0] and shape[1] >= size[1]:
+        return sample
+
+    scale = [0, 0]
+    scale[0] = size[0] / shape[0]
+    scale[1] = size[1] / shape[1]
+
+    scale = max(scale)
+
+    shape[0] = math.ceil(scale * shape[0])
+    shape[1] = math.ceil(scale * shape[1])
+
+    # resize
+    sample["image"] = cv2.resize(
+        sample["image"], tuple(shape[::-1]), interpolation=image_interpolation_method
+    )
+
+    sample["disparity"] = cv2.resize(
+        sample["disparity"], tuple(shape[::-1]), interpolation=cv2.INTER_NEAREST
+    )
+    sample["mask"] = cv2.resize(
+        sample["mask"].astype(np.float32),
+        tuple(shape[::-1]),
+        interpolation=cv2.INTER_NEAREST,
+    )
+    sample["mask"] = sample["mask"].astype(bool)
+
+    return tuple(shape)
+
+
+class Resize(object):
+    """Resize sample to given size (width, height).
+    """
+
+    def __init__(
+        self,
+        width,
+        height,
+        resize_target=True,
+        keep_aspect_ratio=False,
+        ensure_multiple_of=1,
+        resize_method="lower_bound",
+        image_interpolation_method=cv2.INTER_AREA,
+    ):
+        """Init.
+
+        Args:
+            width (int): desired output width
+            height (int): desired output height
+            resize_target (bool, optional):
+                True: Resize the full sample (image, mask, target).
+                False: Resize image only.
+                Defaults to True.
+            keep_aspect_ratio (bool, optional):
+                True: Keep the aspect ratio of the input sample.
+                Output sample might not have the given width and height, and
+                resize behaviour depends on the parameter 'resize_method'.
+                Defaults to False.
+            ensure_multiple_of (int, optional):
+                Output width and height is constrained to be multiple of this parameter.
+                Defaults to 1.
+            resize_method (str, optional):
+                "lower_bound": Output will be at least as large as the given size.
+                "upper_bound": Output will be at max as large as the given size. (Output size might be smaller than given size.)
+                "minimal": Scale as least as possible.  (Output size might be smaller than given size.)
+                Defaults to "lower_bound".
+        """
+        self.__width = width
+        self.__height = height
+
+        self.__resize_target = resize_target
+        self.__keep_aspect_ratio = keep_aspect_ratio
+        self.__multiple_of = ensure_multiple_of
+        self.__resize_method = resize_method
+        self.__image_interpolation_method = image_interpolation_method
+
+    def constrain_to_multiple_of(self, x, min_val=0, max_val=None):
+        y = (np.round(x / self.__multiple_of) * self.__multiple_of).astype(int)
+
+        if max_val is not None and y > max_val:
+            y = (np.floor(x / self.__multiple_of) * self.__multiple_of).astype(int)
+
+        if y < min_val:
+            y = (np.ceil(x / self.__multiple_of) * self.__multiple_of).astype(int)
+
+        return y
+
+    def get_size(self, width, height):
+        # determine new height and width
+        scale_height = self.__height / height
+        scale_width = self.__width / width
+
+        if self.__keep_aspect_ratio:
+            if self.__resize_method == "lower_bound":
+                # scale such that output size is lower bound
+                if scale_width > scale_height:
+                    # fit width
+                    scale_height = scale_width
+                else:
+                    # fit height
+                    scale_width = scale_height
+            elif self.__resize_method == "upper_bound":
+                # scale such that output size is upper bound
+                if scale_width < scale_height:
+                    # fit width
+                    scale_height = scale_width
+                else:
+                    # fit height
+                    scale_width = scale_height
+            elif self.__resize_method == "minimal":
+                # scale as least as possbile
+                if abs(1 - scale_width) < abs(1 - scale_height):
+                    # fit width
+                    scale_height = scale_width
+                else:
+                    # fit height
+                    scale_width = scale_height
+            else:
+                raise ValueError(
+                    f"resize_method {self.__resize_method} not implemented"
+                )
+
+        if self.__resize_method == "lower_bound":
+            new_height = self.constrain_to_multiple_of(
+                scale_height * height, min_val=self.__height
+            )
+            new_width = self.constrain_to_multiple_of(
+                scale_width * width, min_val=self.__width
+            )
+        elif self.__resize_method == "upper_bound":
+            new_height = self.constrain_to_multiple_of(
+                scale_height * height, max_val=self.__height
+            )
+            new_width = self.constrain_to_multiple_of(
+                scale_width * width, max_val=self.__width
+            )
+        elif self.__resize_method == "minimal":
+            new_height = self.constrain_to_multiple_of(scale_height * height)
+            new_width = self.constrain_to_multiple_of(scale_width * width)
+        else:
+            raise ValueError(f"resize_method {self.__resize_method} not implemented")
+
+        return (new_width, new_height)
+
+    def __call__(self, sample):
+        width, height = self.get_size(
+            sample["image"].shape[1], sample["image"].shape[0]
+        )
+
+        # resize sample
+        sample["image"] = cv2.resize(
+            sample["image"],
+            (width, height),
+            interpolation=self.__image_interpolation_method,
+        )
+
+        if self.__resize_target:
+            if "disparity" in sample:
+                sample["disparity"] = cv2.resize(
+                    sample["disparity"],
+                    (width, height),
+                    interpolation=cv2.INTER_NEAREST,
+                )
+
+            if "depth" in sample:
+                sample["depth"] = cv2.resize(
+                    sample["depth"], (width, height), interpolation=cv2.INTER_NEAREST
+                )
+
+            sample["mask"] = cv2.resize(
+                sample["mask"].astype(np.float32),
+                (width, height),
+                interpolation=cv2.INTER_NEAREST,
+            )
+            sample["mask"] = sample["mask"].astype(bool)
+
+        return sample
+
+
+class NormalizeImage(object):
+    """Normlize image by given mean and std.
+    """
+
+    def __init__(self, mean, std):
+        self.__mean = mean
+        self.__std = std
+
+    def __call__(self, sample):
+        sample["image"] = (sample["image"] - self.__mean) / self.__std
+
+        return sample
+
+
+class PrepareForNet(object):
+    """Prepare sample for usage as network input.
+    """
+
+    def __init__(self):
+        pass
+
+    def __call__(self, sample):
+        image = np.transpose(sample["image"], (2, 0, 1))
+        sample["image"] = np.ascontiguousarray(image).astype(np.float32)
+
+        if "mask" in sample:
+            sample["mask"] = sample["mask"].astype(np.float32)
+            sample["mask"] = np.ascontiguousarray(sample["mask"])
+
+        if "disparity" in sample:
+            disparity = sample["disparity"].astype(np.float32)
+            sample["disparity"] = np.ascontiguousarray(disparity)
+
+        if "depth" in sample:
+            depth = sample["depth"].astype(np.float32)
+            sample["depth"] = np.ascontiguousarray(depth)
+
+        return sample

model_farm_midas_v2_qcs6490_qnn2.16_w8a16_aidlite/python/utils.py

@@ -0,0 +1,104 @@
+import numpy as np
+import torch
+import cv2
+import os
+
+from transforms import Resize, NormalizeImage, PrepareForNet
+
+from torchvision.transforms import Compose
+import sys
+first_execution = True
+def img_process(img_path):
+    global first_execution
+    first_execution = False
+    net_w, net_h = 256, 256
+    resize_mode = "upper_bound"
+    normalization = NormalizeImage(
+        mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]
+    )
+    transform = Compose(
+        [
+            Resize(
+                net_w,
+                net_h,
+                resize_target=None,
+                keep_aspect_ratio=False,
+                ensure_multiple_of=32,
+                resize_method=resize_mode,
+                image_interpolation_method=cv2.INTER_CUBIC,
+            ),
+            normalization,
+            PrepareForNet(),
+        ]
+    )
+    # image = utils.read_image(img_path)  # in [0, 1]
+    image = cv2.imread(img_path)
+    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) / 255.0
+    org_size=  image.shape[:2]
+    image = transform({"image": image})["image"]
+    sample = torch.from_numpy(image).to("cpu").unsqueeze(0)
+    height, width = sample.shape[2:]
+    print(f"Input resized to {width}x{height} before entering the encoder")
+
+    return sample,org_size
+
+
+
+def write_depth(path, depth, grayscale=False, bits=1):
+    if not grayscale:
+        bits = 1
+
+    if not np.isfinite(depth).all():
+        depth=np.nan_to_num(depth, nan=0.0, posinf=0.0, neginf=0.0)
+        print("WARNING: Non-finite depth values present")
+
+    depth_min = depth.min()
+    depth_max = depth.max()
+
+    max_val = (2**(8*bits))-1
+
+    if depth_max - depth_min > np.finfo("float").eps:
+        out = max_val * (depth - depth_min) / (depth_max - depth_min)
+    else:
+        out = np.zeros(depth.shape, dtype=depth.dtype)
+
+    # print("out :",out.shape,out)
+    if not grayscale:
+        out = cv2.applyColorMap(np.uint8(out), cv2.COLORMAP_INFERNO)
+
+    if bits == 1:
+        cv2.imwrite(path , out.astype("uint8"))
+    elif bits == 2:
+        cv2.imwrite(path , out.astype("uint16"))
+
+    return
+
+def write_pfm(path, image, scale=1):
+    with open(path, "wb") as file:
+        color = None
+
+        if image.dtype.name != "float32":
+            raise Exception("Image dtype must be float32.")
+
+        image = np.flipud(image)
+
+        if len(image.shape) == 3 and image.shape[2] == 3:  # color image
+            color = True
+        elif (
+            len(image.shape) == 2 or len(image.shape) == 3 and image.shape[2] == 1
+        ):  # greyscale
+            color = False
+        else:
+            raise Exception("Image must have H x W x 3, H x W x 1 or H x W dimensions.")
+
+        file.write("PF\n" if color else "Pf\n".encode())
+        file.write("%d %d\n".encode() % (image.shape[1], image.shape[0]))
+
+        endian = image.dtype.byteorder
+
+        if endian == "<" or endian == "=" and sys.byteorder == "little":
+            scale = -scale
+
+        file.write("%f\n".encode() % scale)
+
+        image.tofile(file)

model_farm_midas_v2_qcs8550_qnn2.16_fp16_aidlite/README.md

@@ -0,0 +1,56 @@
+## Model Information
+
+### Source model
+- Input shape: 1x3x256x256
+- Number of parameters: 20.33M
+- Model size: 82.17M
+- Output shape: 1x1x256x256
+
+Source model repository: [midas](https://github.com/isl-org/MiDaS/tree/master)
+
+### Converted model
+
+- Precision: FP16
+- Backend: QNN2.16
+- Target Device: SNM972 QCS8550
+
+## Inference with AidLite SDK
+
+### SDK installation
+Model Farm uses AidLite SDK as the model inference SDK. For details, please refer to the [AidLite Developer Documentation](https://v2.docs.aidlux.com/en/sdk-api/aidlite-sdk/)
+
+- Install AidLite SDK
+
+```bash
+# Install the appropriate version of the aidlite sdk
+sudo aid-pkg update
+sudo aid-pkg install aidlite-sdk
+# Download the qnn version that matches the above backend. Eg Install QNN2.23 Aidlite: sudo aid-pkg install aidlite-qnn223
+sudo aid-pkg install aidlite-{QNN VERSION}
+```
+
+- Verify AidLite SDK
+
+```bash
+# aidlite sdk c++ check
+python3 -c "import aidlite ; print(aidlite.get_library_version())"
+
+# aidlite sdk python check
+python3 -c "import aidlite ; print(aidlite.get_py_library_version())"
+```
+
+### Run Demo
+#### python
+```bash
+cd model_farm_midas_v2_qcs8550_qnn2.16_fp16_aidlite
+python3 python/run_test.py --target_model ./models/midas_v2_fp16.qnn216.ctx.bin --imgs ./python/dog.jpg  --invoke_nums 10 
+```
+
+#### c++
+```bash
+cd midas_v2/model_farm_midas_v2_qcs8550_qnn2.16_fp16_aidlite/cpp
+mkdir build && cd build 
+cmake ..
+make
+./run_test
+```

model_farm_midas_v2_qcs8550_qnn2.16_fp16_aidlite/cpp/CMakeLists.txt

@@ -0,0 +1,32 @@
+cmake_minimum_required (VERSION 3.5)
+project("run_test")
+
+find_package(OpenCV REQUIRED)
+
+message(STATUS "oPENCV Library status:")
+message(STATUS ">version:${OpenCV_VERSION}")
+message(STATUS "Include:${OpenCV_INCLUDE_DIRS}")
+
+set(CMAKE_CXX_FLAGS "-Wno-error=deprecated-declarations -Wno-deprecated-declarations")
+
+include_directories(
+    /usr/local/include
+    /usr/include/opencv4
+)
+
+link_directories(
+    /usr/local/lib/
+)
+
+file(GLOB SRC_LISTS 
+    ${CMAKE_CURRENT_SOURCE_DIR}/run_test.cpp  
+)
+
+add_executable(run_test ${SRC_LISTS})
+
+target_link_libraries(run_test
+    aidlite
+	${OpenCV_LIBS}
+    pthread
+    jsoncpp
+)

model_farm_midas_v2_qcs8550_qnn2.16_fp16_aidlite/cpp/run_test.cpp

@@ -0,0 +1,392 @@
+#include <iostream>
+#include <fstream>
+#include <opencv2/opencv.hpp>
+#include <aidlux/aidlite/aidlite.hpp>
+#include <vector>
+#include <numeric>
+#include <cmath>
+#include <jsoncpp/json/json.h>
+
+using namespace cv;
+using namespace std;
+using namespace Aidlux::Aidlite;
+
+const int net_w = 256;
+const int net_h = 256;
+
+const std::vector<float> mean_vals = {0.485f, 0.456f, 0.406f};
+const std::vector<float> std_vals = {0.229f, 0.224f, 0.225f};
+
+
+struct Args {
+    std::string target_model = "../../models/midas_v2_fp16.qnn216.ctx.bin";
+    std::string imgs = "../dog.jpg";
+    int invoke_nums = 10;
+    std::string model_type = "QNN";
+};
+
+
+Args parse_args(int argc, char* argv[]) {
+    Args args;
+    for (int i = 1; i < argc; ++i) {
+        std::string arg = argv[i];
+        if (arg == "--target_model" && i + 1 < argc) {
+            args.target_model = argv[++i];
+        } else if (arg == "--imgs" && i + 1 < argc) {
+            args.imgs = argv[++i];
+        } else if (arg == "--invoke_nums" && i + 1 < argc) {
+            args.invoke_nums = std::stoi(argv[++i]);
+        } else if (arg == "--model_type" && i + 1 < argc) {
+            args.model_type = argv[++i];
+        }
+    }
+    return args;
+}
+
+std::string to_lower(const std::string& str) {
+    std::string lower_str = str;
+    std::transform(lower_str.begin(), lower_str.end(), lower_str.begin(), [](unsigned char c) {
+        return std::tolower(c);
+    });
+    return lower_str;
+}
+
+
+int transpose(float* src, unsigned int* src_dims, unsigned int* tsp_dims, float* dest){
+
+    int current_coordinate[4] = {0, 0, 0, 0};
+    for(int a = 0; a < src_dims[0]; ++a){
+        current_coordinate[0] = a;
+        for(int b = 0; b < src_dims[1]; ++b){
+            current_coordinate[1] = b;
+            for(int c = 0; c < src_dims[2]; ++c){
+                current_coordinate[2] = c;
+                for(int d = 0; d < src_dims[3]; ++d){
+                    current_coordinate[3] = d;
+
+                    int old_index = current_coordinate[0]*src_dims[1]*src_dims[2]*src_dims[3] + 
+                                    current_coordinate[1]*src_dims[2]*src_dims[3] + 
+                                    current_coordinate[2]*src_dims[3] + 
+                                    current_coordinate[3];
+
+                    int new_index = current_coordinate[tsp_dims[0]]*src_dims[tsp_dims[1]]*src_dims[tsp_dims[2]]*src_dims[tsp_dims[3]] + 
+                                    current_coordinate[tsp_dims[1]]*src_dims[tsp_dims[2]]*src_dims[tsp_dims[3]] + 
+                                    current_coordinate[tsp_dims[2]]*src_dims[tsp_dims[3]] + 
+                                    current_coordinate[tsp_dims[3]];
+
+                    dest[new_index] = src[old_index];
+                }
+            }
+        }
+    }
+
+    return EXIT_SUCCESS;
+}
+
+
+// 替代 np.nan_to_num
+void sanitizeDepthMap(cv::Mat& depth) {
+    for (int y = 0; y < depth.rows; ++y) {
+        float* row = depth.ptr<float>(y);
+        for (int x = 0; x < depth.cols; ++x) {
+            float val = row[x];
+            if (!std::isfinite(val)) {
+                row[x] = 0.0f;
+            }
+        }
+    }
+}
+
+// 等效于 Python write_depth
+void write_depth(const std::string& path, const cv::Mat& input_depth, bool grayscale = false, int bits = 1) {
+    CV_Assert(input_depth.type() == CV_32FC1);
+
+    // 拷贝 + 处理非法值
+    cv::Mat depth = input_depth.clone();
+    sanitizeDepthMap(depth);
+
+    double minVal, maxVal;
+    cv::minMaxLoc(depth, &minVal, &maxVal);
+
+    double max_val = (1 << (8 * bits)) - 1;
+    cv::Mat out;
+
+    if (maxVal - minVal > std::numeric_limits<float>::epsilon()) {
+        // 归一化并映射到位深范围
+        out = (depth - minVal) * (max_val / (maxVal - minVal));
+    } else {
+        out = cv::Mat::zeros(depth.size(), CV_32F);
+    }
+
+    if (!grayscale) {
+        out.convertTo(out, CV_8UC1);
+        cv::applyColorMap(out, out, cv::COLORMAP_INFERNO);
+    }
+
+    if (bits == 1) {
+        out.convertTo(out, CV_8U);
+    } else if (bits == 2) {
+        out.convertTo(out, CV_16U);
+    }
+
+    cv::imwrite(path, out);
+}
+
+// 等效于 Python write_pfm
+void write_pfm(const std::string& path, const cv::Mat& image, float scale = 1.0f) {
+    CV_Assert(image.type() == CV_32FC1 || image.type() == CV_32FC3);
+
+    std::ofstream file(path, std::ios::binary);
+    if (!file.is_open()) {
+        std::cerr << "Failed to open file for writing PFM: " << path << std::endl;
+        return;
+    }
+
+    int width = image.cols;
+    int height = image.rows;
+    int channels = image.channels();
+    bool color = (channels == 3);
+
+    file << (color ? "PF" : "Pf") << "\n";
+    file << width << " " << height << "\n";
+
+    // Endianness: negative = little-endian
+    uint16_t endian_test = 0x1;
+    bool is_little_endian = *(reinterpret_cast<uint8_t*>(&endian_test)) == 0x1;
+    if (is_little_endian) {
+        scale = -scale;
+    }
+
+    file << scale << "\n";
+
+    // Flip vertically (OpenCV top-left origin -> PFM bottom-left origin)
+    cv::Mat flipped;
+    cv::flip(image, flipped, 0);
+
+    // Write raw data
+    file.write(reinterpret_cast<const char*>(flipped.data), flipped.total() * channels * sizeof(float));
+    file.close();
+}
+
+
+// ======================= Normalize =======================
+void normalize(cv::Mat& image) {
+    CV_Assert(image.type() == CV_32FC3);
+    int rows = image.rows;
+    int cols = image.cols;
+
+    for (int y = 0; y < rows; ++y) {
+        cv::Vec3f* row = image.ptr<cv::Vec3f>(y);
+        for (int x = 0; x < cols; ++x) {
+            for (int c = 0; c < 3; ++c) {
+                row[x][c] = (row[x][c] - mean_vals[c]) / std_vals[c];
+            }
+        }
+    }
+}
+
+cv::Mat hwc_to_chw(const cv::Mat& image) {
+    std::vector<cv::Mat> channels(3);
+    cv::split(image, channels);
+
+    cv::Mat chw(3, image.rows * image.cols, CV_32F);
+    for (int c = 0; c < 3; ++c) {
+        memcpy(chw.ptr(c), channels[c].data, image.rows * image.cols * sizeof(float));
+    }
+
+    return chw;
+}
+
+
+bool first_execution = true;
+cv::Mat img_process(const cv::Mat image_bgr, cv::Size& org_size_out) {
+    first_execution = false;
+
+    cv::Mat image_rgb;
+    cv::cvtColor(image_bgr, image_rgb, cv::COLOR_BGR2RGB);
+    image_rgb.convertTo(image_rgb, CV_32FC3, 1.0 / 255.0);
+
+    // 2. Save original size
+    org_size_out = image_rgb.size();  // H x W
+
+    // 3. Resize to 256x256 using cubic interpolation
+    cv::resize(image_rgb, image_rgb, cv::Size(net_w, net_h), 0, 0, cv::INTER_CUBIC);
+
+    // 4. Normalize using mean/std
+    normalize(image_rgb);
+
+    // 5. Convert HWC to CHW
+    cv::Mat chw = hwc_to_chw(image_rgb);
+
+    // 6. Add batch dimension: [1, C, H, W] → reshape to 1x3xHxW style float array
+    cv::Mat input_tensor(1, 3 * net_h * net_w, CV_32F);
+    memcpy(input_tensor.ptr<float>(), chw.data, 3 * net_h * net_w * sizeof(float));
+
+    std::cout << "Input resized to " << net_w << "x" << net_h << " before entering the encoder" << std::endl;
+
+    return input_tensor;
+}
+
+
+float* matToFloatPtr(const cv::Mat& input_mat, bool normalize = true) {
+    // 检查连续性
+    cv::Mat mat = input_mat;
+    if (!mat.isContinuous()) {
+        mat = mat.clone();
+    }
+
+    // 分配内存
+    int total_pixels = mat.rows * mat.cols;
+    int channels = mat.channels();
+    float* float_data = new float[total_pixels * channels];
+
+    // 根据数据类型转换
+    if (mat.type() == CV_8UC1 || mat.type() == CV_8UC3) {
+        uchar* ptr = mat.ptr<uchar>(0);
+        for (int i = 0; i < total_pixels * channels; ++i) {
+            float_data[i] = normalize ? (static_cast<float>(ptr[i]) / 255.0f) : ptr[i];
+        }
+    } else if (mat.type() == CV_32FC1 || mat.type() == CV_32FC3) {
+        float* ptr = mat.ptr<float>(0);
+        std::memcpy(float_data, ptr, total_pixels * channels * sizeof(float));
+    } else {
+        delete[] float_data;
+        return nullptr; // 不支持的类型
+    }
+
+    return float_data;
+}
+
+
+int invoke(const Args& args) {
+    std::cout << "Start main ... ... Model Path: " << args.target_model << "\n"
+              << "Image Path: " << args.imgs << "\n"
+              << "Inference Nums: " << args.invoke_nums << "\n"
+              << "Model Type: " << args.model_type << "\n";
+    Model* model = Model::create_instance(args.target_model);
+    if(model == nullptr){
+        printf("Create model failed !\n");
+        return EXIT_FAILURE;
+    }
+    Config* config = Config::create_instance();
+    if(config == nullptr){
+        printf("Create config failed !\n");
+        return EXIT_FAILURE;
+    }
+    config->implement_type = ImplementType::TYPE_LOCAL;
+    std::string model_type_lower = to_lower(args.model_type);
+    if (model_type_lower == "qnn"){
+        config->framework_type = FrameworkType::TYPE_QNN;
+    } else if (model_type_lower == "snpe2" || model_type_lower == "snpe") {
+        config->framework_type = FrameworkType::TYPE_SNPE2;
+    }
+    config->accelerate_type = AccelerateType::TYPE_DSP;
+    config->is_quantify_model = 1;
+
+    unsigned int model_h = 256;
+    unsigned int model_w = 256;
+    std::vector<std::vector<uint32_t>> input_shapes = {{1,model_h,model_w,3}};
+    std::vector<std::vector<uint32_t>> output_shapes = {{1,model_h,model_w,1}};
+    model->set_model_properties(input_shapes, Aidlux::Aidlite::DataType::TYPE_FLOAT32, output_shapes, Aidlux::Aidlite::DataType::TYPE_FLOAT32);
+    std::unique_ptr<Interpreter> fast_interpreter = InterpreterBuilder::build_interpretper_from_model_and_config(model, config);
+    if(fast_interpreter == nullptr){
+        printf("build_interpretper_from_model_and_config failed !\n");
+        return EXIT_FAILURE;
+    }
+    int result = fast_interpreter->init();
+    if(result != EXIT_SUCCESS){
+        printf("interpreter->init() failed !\n");
+        return EXIT_FAILURE;
+    }
+    // load model
+    fast_interpreter->load_model();
+    if(result != EXIT_SUCCESS){
+        printf("interpreter->load_model() failed !\n");
+        return EXIT_FAILURE;
+    }
+    printf("detect model load success!\n");
+
+    cv::Mat frame = cv::imread(args.imgs);
+    if (frame.empty()) {
+        printf("detect image load failed!\n");
+        return 1;
+    }
+    printf("img_src cols: %d, img_src rows: %d\n", frame.cols, frame.rows);
+    cv::Mat input_data;
+    cv::Mat frame_clone = frame.clone();
+    int h = frame_clone.rows;
+    int w = frame_clone.cols;
+    cv::Size org_size(w, h);
+    cv::Size org_size0(256, 256);
+
+    cv::Mat input_tensor = img_process(frame_clone, org_size0);
+    float* float_data = matToFloatPtr(input_tensor);
+    unsigned int src_dims[4] = {1, 3, 256, 256};
+    unsigned int tsp_dims[4] = {0,2,3,1};
+    unsigned int stride_data_num = 1*256*256*3;
+    float* format_data = new float[stride_data_num];
+    transpose(float_data, src_dims, tsp_dims, format_data);
+    cv::Mat origin_buffer(3,256*256, CV_32F, format_data);
+
+    float *outdata0 = nullptr;
+    std::vector<float> invoke_time;
+    for (int i = 0; i < args.invoke_nums; ++i) {
+        result = fast_interpreter->set_input_tensor(0, origin_buffer.data);
+        if(result != EXIT_SUCCESS){
+            printf("interpreter->set_input_tensor() failed !\n");
+            return EXIT_FAILURE;
+        }
+        auto t1 = std::chrono::high_resolution_clock::now();
+        result = fast_interpreter->invoke();
+        auto t2 = std::chrono::high_resolution_clock::now();
+        std::chrono::duration<double> cost_time = t2 - t1;
+        invoke_time.push_back(cost_time.count() * 1000);
+        if(result != EXIT_SUCCESS){
+            printf("interpreter->invoke() failed !\n");
+            return EXIT_FAILURE;
+        }
+        uint32_t out_data_0 = 0;
+        result = fast_interpreter->get_output_tensor(0, (void**)&outdata0, &out_data_0);
+        if(result != EXIT_SUCCESS){
+            printf("interpreter->get_output_tensor() 1 failed !\n");
+            return EXIT_FAILURE;
+        }
+
+    }
+
+    float max_invoke_time = *std::max_element(invoke_time.begin(), invoke_time.end());
+    float min_invoke_time = *std::min_element(invoke_time.begin(), invoke_time.end());
+    float mean_invoke_time = std::accumulate(invoke_time.begin(), invoke_time.end(), 0.0f) / args.invoke_nums;
+    float var_invoketime = 0.0f;
+    for (auto time : invoke_time) {
+        var_invoketime += (time - mean_invoke_time) * (time - mean_invoke_time);
+    }
+    var_invoketime /= args.invoke_nums;
+    printf("=======================================\n");
+    printf("QNN inference %d times :\n --mean_invoke_time is %f \n --max_invoke_time is %f \n --min_invoke_time is %f \n --var_invoketime is %f\n", 
+        args.invoke_nums, mean_invoke_time, max_invoke_time, min_invoke_time, var_invoketime);
+    printf("=======================================\n");
+
+    //  post process
+    cv::Mat out_buffer(1,256*256, CV_32F, outdata0);
+     cv::Mat prediction_2d(256, 256, CV_32F, (void*)out_buffer.ptr<float>());
+    cv::Mat resized;
+    cv::resize(prediction_2d, resized, org_size, 0, 0, cv::INTER_CUBIC);
+
+    // 保存为图像
+    write_depth("depth_output.jpg", resized, false, 1);
+
+    // 保存为 PFM
+    write_pfm("depth_output.pfm", resized);
+
+
+
+    fast_interpreter->destory();
+    return 0;
+}
+
+
+int main(int argc, char* argv[]) {
+    Args args = parse_args(argc, argv);
+    return invoke(args);
+}

model_farm_midas_v2_qcs8550_qnn2.16_fp16_aidlite/models/midas_v2_fp16.qnn216.ctx.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:02f972176f66995cd0e7e3da5cab3467911acd2ccf0f64612d2755a7884798cc
+size 37268200

model_farm_midas_v2_qcs8550_qnn2.16_fp16_aidlite/python/run_test.py

@@ -0,0 +1,111 @@
+import numpy as np
+import torch
+import cv2
+import os
+from  utils import write_pfm,write_depth,img_process
+import aidlite
+import time
+import argparse
+
+def out_process(prediction,target_size):
+    prediction = torch.nn.functional.interpolate(
+            prediction,
+            size=target_size,
+            mode="bicubic",
+            align_corners=False,
+        )
+    prediction = prediction.squeeze().detach().numpy()
+    return prediction
+
+class run_qnn:
+    def __init__(self,qnn_path):
+        super().__init__()
+        self.model = aidlite.Model.create_instance(qnn_path)
+        if self.model is None:
+            print("Create model failed !")
+            return
+
+        self.config = aidlite.Config.create_instance()
+        if self.config is None:
+            print("build_interpretper_from_model_and_config failed !")
+            return
+
+        self.config.implement_type = aidlite.ImplementType.TYPE_LOCAL
+        self.config.framework_type = aidlite.FrameworkType.TYPE_QNN
+        self.config.accelerate_type = aidlite.AccelerateType.TYPE_DSP
+        # self.config.accelerate_type = aidlite.AccelerateType.TYPE_CPU
+        self.config.is_quantify_model = 1
+        
+        self.interpreter = aidlite.InterpreterBuilder.build_interpretper_from_model_and_config(self.model, self.config)
+        if self.interpreter is None:
+            print("build_interpretper_from_model_and_config failed !")
+            return
+        input_shapes = [[1,256,256,3]]
+        output_shapes = [[1,256,256,1]]
+        self.model.set_model_properties(input_shapes, aidlite.DataType.TYPE_FLOAT32,
+                                output_shapes, aidlite.DataType.TYPE_FLOAT32)
+
+        if self.interpreter is None:
+            print("build_interpretper_from_model_and_config failed !")
+        result = self.interpreter.init()
+        if result != 0:
+            print(f"interpreter init failed !")
+        result = self.interpreter.load_model()
+        if result != 0:
+            print("interpreter load model failed !")
+   
+        print(" model load success!")
+
+    def __call__(self, input,invoke_nums):
+        self.interpreter.set_input_tensor(0,input)
+        invoke_time=[]
+        for i in range(invoke_nums):
+            result = self.interpreter.set_input_tensor(0, input.data)
+            if result != 0:
+                print("interpreter set_input_tensor() failed")
+            t1=time.time()
+            result = self.interpreter.invoke()
+            cost_time = (time.time()-t1)*1000
+            invoke_time.append(cost_time)
+
+        max_invoke_time = max(invoke_time)
+        min_invoke_time = min(invoke_time)
+        mean_invoke_time = sum(invoke_time)/invoke_nums
+        var_invoketime=np.var(invoke_time)
+        print("====================================")
+        print(f"QNN  invoke time:\n --mean_invoke_time is {mean_invoke_time} \n --max_invoke_time is {max_invoke_time} \n --min_invoke_time is {min_invoke_time} \n --var_invoketime is {var_invoketime}")
+        print("====================================")
+        features_0 = self.interpreter.get_output_tensor(0).reshape(1,256,256,1).transpose(0,3,1,2)
+        return features_0
+
+
+
+def run(args):
+    img_path = args.imgs
+    qnn_path = args.target_model
+    invoke_num=args.invoke_nums
+    print("Start processing...")
+    img_input,org_size = img_process(img_path)
+
+    qnn_model =run_qnn(qnn_path)
+    prediction_qnn = qnn_model(img_input.numpy().transpose(0,2,3,1),invoke_num)
+    prediction_qnn = torch.tensor(prediction_qnn)
+    qnn_process = out_process(prediction_qnn,org_size)
+
+    write_depth("./python/results.jpg", qnn_process, grayscale=False, bits=1)
+    write_pfm("./python/results.pfm", qnn_process.astype(np.float32))
+    print("Finished")
+
+def parser_args():
+    parser = argparse.ArgumentParser(description="Run model benchmarks")
+    parser.add_argument('--target_model',type=str,default='./models/midas_v2_fp16.qnn216.ctx.bin',help="Inference model path")
+    parser.add_argument('--imgs',type=str,default='./python/dog.jpg',help="Predict images path")
+    parser.add_argument('--invoke_nums',type=int,default=10,help="Inference nums")
+    parser.add_argument('--model_type',type=str,default='QNN',help="Run backend")
+    args = parser.parse_args()
+    return args
+
+
+if __name__ =="__main__":
+    args = parser_args()
+    run(args)

model_farm_midas_v2_qcs8550_qnn2.16_fp16_aidlite/python/transforms.py

@@ -0,0 +1,234 @@
+import numpy as np
+import cv2
+import math
+
+
+def apply_min_size(sample, size, image_interpolation_method=cv2.INTER_AREA):
+    """Rezise the sample to ensure the given size. Keeps aspect ratio.
+
+    Args:
+        sample (dict): sample
+        size (tuple): image size
+
+    Returns:
+        tuple: new size
+    """
+    shape = list(sample["disparity"].shape)
+
+    if shape[0] >= size[0] and shape[1] >= size[1]:
+        return sample
+
+    scale = [0, 0]
+    scale[0] = size[0] / shape[0]
+    scale[1] = size[1] / shape[1]
+
+    scale = max(scale)
+
+    shape[0] = math.ceil(scale * shape[0])
+    shape[1] = math.ceil(scale * shape[1])
+
+    # resize
+    sample["image"] = cv2.resize(
+        sample["image"], tuple(shape[::-1]), interpolation=image_interpolation_method
+    )
+
+    sample["disparity"] = cv2.resize(
+        sample["disparity"], tuple(shape[::-1]), interpolation=cv2.INTER_NEAREST
+    )
+    sample["mask"] = cv2.resize(
+        sample["mask"].astype(np.float32),
+        tuple(shape[::-1]),
+        interpolation=cv2.INTER_NEAREST,
+    )
+    sample["mask"] = sample["mask"].astype(bool)
+
+    return tuple(shape)
+
+
+class Resize(object):
+    """Resize sample to given size (width, height).
+    """
+
+    def __init__(
+        self,
+        width,
+        height,
+        resize_target=True,
+        keep_aspect_ratio=False,
+        ensure_multiple_of=1,
+        resize_method="lower_bound",
+        image_interpolation_method=cv2.INTER_AREA,
+    ):
+        """Init.
+
+        Args:
+            width (int): desired output width
+            height (int): desired output height
+            resize_target (bool, optional):
+                True: Resize the full sample (image, mask, target).
+                False: Resize image only.
+                Defaults to True.
+            keep_aspect_ratio (bool, optional):
+                True: Keep the aspect ratio of the input sample.
+                Output sample might not have the given width and height, and
+                resize behaviour depends on the parameter 'resize_method'.
+                Defaults to False.
+            ensure_multiple_of (int, optional):
+                Output width and height is constrained to be multiple of this parameter.
+                Defaults to 1.
+            resize_method (str, optional):
+                "lower_bound": Output will be at least as large as the given size.
+                "upper_bound": Output will be at max as large as the given size. (Output size might be smaller than given size.)
+                "minimal": Scale as least as possible.  (Output size might be smaller than given size.)
+                Defaults to "lower_bound".
+        """
+        self.__width = width
+        self.__height = height
+
+        self.__resize_target = resize_target
+        self.__keep_aspect_ratio = keep_aspect_ratio
+        self.__multiple_of = ensure_multiple_of
+        self.__resize_method = resize_method
+        self.__image_interpolation_method = image_interpolation_method
+
+    def constrain_to_multiple_of(self, x, min_val=0, max_val=None):
+        y = (np.round(x / self.__multiple_of) * self.__multiple_of).astype(int)
+
+        if max_val is not None and y > max_val:
+            y = (np.floor(x / self.__multiple_of) * self.__multiple_of).astype(int)
+
+        if y < min_val:
+            y = (np.ceil(x / self.__multiple_of) * self.__multiple_of).astype(int)
+
+        return y
+
+    def get_size(self, width, height):
+        # determine new height and width
+        scale_height = self.__height / height
+        scale_width = self.__width / width
+
+        if self.__keep_aspect_ratio:
+            if self.__resize_method == "lower_bound":
+                # scale such that output size is lower bound
+                if scale_width > scale_height:
+                    # fit width
+                    scale_height = scale_width
+                else:
+                    # fit height
+                    scale_width = scale_height
+            elif self.__resize_method == "upper_bound":
+                # scale such that output size is upper bound
+                if scale_width < scale_height:
+                    # fit width
+                    scale_height = scale_width
+                else:
+                    # fit height
+                    scale_width = scale_height
+            elif self.__resize_method == "minimal":
+                # scale as least as possbile
+                if abs(1 - scale_width) < abs(1 - scale_height):
+                    # fit width
+                    scale_height = scale_width
+                else:
+                    # fit height
+                    scale_width = scale_height
+            else:
+                raise ValueError(
+                    f"resize_method {self.__resize_method} not implemented"
+                )
+
+        if self.__resize_method == "lower_bound":
+            new_height = self.constrain_to_multiple_of(
+                scale_height * height, min_val=self.__height
+            )
+            new_width = self.constrain_to_multiple_of(
+                scale_width * width, min_val=self.__width
+            )
+        elif self.__resize_method == "upper_bound":
+            new_height = self.constrain_to_multiple_of(
+                scale_height * height, max_val=self.__height
+            )
+            new_width = self.constrain_to_multiple_of(
+                scale_width * width, max_val=self.__width
+            )
+        elif self.__resize_method == "minimal":
+            new_height = self.constrain_to_multiple_of(scale_height * height)
+            new_width = self.constrain_to_multiple_of(scale_width * width)
+        else:
+            raise ValueError(f"resize_method {self.__resize_method} not implemented")
+
+        return (new_width, new_height)
+
+    def __call__(self, sample):
+        width, height = self.get_size(
+            sample["image"].shape[1], sample["image"].shape[0]
+        )
+
+        # resize sample
+        sample["image"] = cv2.resize(
+            sample["image"],
+            (width, height),
+            interpolation=self.__image_interpolation_method,
+        )
+
+        if self.__resize_target:
+            if "disparity" in sample:
+                sample["disparity"] = cv2.resize(
+                    sample["disparity"],
+                    (width, height),
+                    interpolation=cv2.INTER_NEAREST,
+                )
+
+            if "depth" in sample:
+                sample["depth"] = cv2.resize(
+                    sample["depth"], (width, height), interpolation=cv2.INTER_NEAREST
+                )
+
+            sample["mask"] = cv2.resize(
+                sample["mask"].astype(np.float32),
+                (width, height),
+                interpolation=cv2.INTER_NEAREST,
+            )
+            sample["mask"] = sample["mask"].astype(bool)
+
+        return sample
+
+
+class NormalizeImage(object):
+    """Normlize image by given mean and std.
+    """
+
+    def __init__(self, mean, std):
+        self.__mean = mean
+        self.__std = std
+
+    def __call__(self, sample):
+        sample["image"] = (sample["image"] - self.__mean) / self.__std
+
+        return sample
+
+
+class PrepareForNet(object):
+    """Prepare sample for usage as network input.
+    """
+
+    def __init__(self):
+        pass
+
+    def __call__(self, sample):
+        image = np.transpose(sample["image"], (2, 0, 1))
+        sample["image"] = np.ascontiguousarray(image).astype(np.float32)
+
+        if "mask" in sample:
+            sample["mask"] = sample["mask"].astype(np.float32)
+            sample["mask"] = np.ascontiguousarray(sample["mask"])
+
+        if "disparity" in sample:
+            disparity = sample["disparity"].astype(np.float32)
+            sample["disparity"] = np.ascontiguousarray(disparity)
+
+        if "depth" in sample:
+            depth = sample["depth"].astype(np.float32)
+            sample["depth"] = np.ascontiguousarray(depth)
+
+        return sample

model_farm_midas_v2_qcs8550_qnn2.16_fp16_aidlite/python/utils.py

@@ -0,0 +1,104 @@
+import numpy as np
+import torch
+import cv2
+import os
+
+from transforms import Resize, NormalizeImage, PrepareForNet
+
+from torchvision.transforms import Compose
+import sys
+first_execution = True
+def img_process(img_path):
+    global first_execution
+    first_execution = False
+    net_w, net_h = 256, 256
+    resize_mode = "upper_bound"
+    normalization = NormalizeImage(
+        mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]
+    )
+    transform = Compose(
+        [
+            Resize(
+                net_w,
+                net_h,
+                resize_target=None,
+                keep_aspect_ratio=False,
+                ensure_multiple_of=32,
+                resize_method=resize_mode,
+                image_interpolation_method=cv2.INTER_CUBIC,
+            ),
+            normalization,
+            PrepareForNet(),
+        ]
+    )
+    # image = utils.read_image(img_path)  # in [0, 1]
+    image = cv2.imread(img_path)
+    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) / 255.0
+    org_size=  image.shape[:2]
+    image = transform({"image": image})["image"]
+    sample = torch.from_numpy(image).to("cpu").unsqueeze(0)
+    height, width = sample.shape[2:]
+    print(f"Input resized to {width}x{height} before entering the encoder")
+
+    return sample,org_size
+
+
+
+def write_depth(path, depth, grayscale=False, bits=1):
+    if not grayscale:
+        bits = 1
+
+    if not np.isfinite(depth).all():
+        depth=np.nan_to_num(depth, nan=0.0, posinf=0.0, neginf=0.0)
+        print("WARNING: Non-finite depth values present")
+
+    depth_min = depth.min()
+    depth_max = depth.max()
+
+    max_val = (2**(8*bits))-1
+
+    if depth_max - depth_min > np.finfo("float").eps:
+        out = max_val * (depth - depth_min) / (depth_max - depth_min)
+    else:
+        out = np.zeros(depth.shape, dtype=depth.dtype)
+
+    # print("out :",out.shape,out)
+    if not grayscale:
+        out = cv2.applyColorMap(np.uint8(out), cv2.COLORMAP_INFERNO)
+
+    if bits == 1:
+        cv2.imwrite(path , out.astype("uint8"))
+    elif bits == 2:
+        cv2.imwrite(path , out.astype("uint16"))
+
+    return
+
+def write_pfm(path, image, scale=1):
+    with open(path, "wb") as file:
+        color = None
+
+        if image.dtype.name != "float32":
+            raise Exception("Image dtype must be float32.")
+
+        image = np.flipud(image)
+
+        if len(image.shape) == 3 and image.shape[2] == 3:  # color image
+            color = True
+        elif (
+            len(image.shape) == 2 or len(image.shape) == 3 and image.shape[2] == 1
+        ):  # greyscale
+            color = False
+        else:
+            raise Exception("Image must have H x W x 3, H x W x 1 or H x W dimensions.")
+
+        file.write("PF\n" if color else "Pf\n".encode())
+        file.write("%d %d\n".encode() % (image.shape[1], image.shape[0]))
+
+        endian = image.dtype.byteorder
+
+        if endian == "<" or endian == "=" and sys.byteorder == "little":
+            scale = -scale
+
+        file.write("%f\n".encode() % scale)
+
+        image.tofile(file)

model_farm_midas_v2_qcs8550_qnn2.16_int8_aidlite/README.md

@@ -0,0 +1,56 @@
+## Model Information
+
+### Source model
+- Input shape: 1x3x256x256
+- Number of parameters: 20.33M
+- Model size: 82.17M
+- Output shape: 1x1x256x256
+
+Source model repository: [midas](https://github.com/isl-org/MiDaS/tree/master)
+
+### Converted model
+
+- Precision: INT8
+- Backend: QNN2.16
+- Target Device: SNM972 QCS8550
+
+## Inference with AidLite SDK
+
+### SDK installation
+Model Farm uses AidLite SDK as the model inference SDK. For details, please refer to the [AidLite Developer Documentation](https://v2.docs.aidlux.com/en/sdk-api/aidlite-sdk/)
+
+- Install AidLite SDK
+
+```bash
+# Install the appropriate version of the aidlite sdk
+sudo aid-pkg update
+sudo aid-pkg install aidlite-sdk
+# Download the qnn version that matches the above backend. Eg Install QNN2.23 Aidlite: sudo aid-pkg install aidlite-qnn223
+sudo aid-pkg install aidlite-{QNN VERSION}
+```
+
+- Verify AidLite SDK
+
+```bash
+# aidlite sdk c++ check
+python3 -c "import aidlite ; print(aidlite.get_library_version())"
+
+# aidlite sdk python check
+python3 -c "import aidlite ; print(aidlite.get_py_library_version())"
+```
+
+### Run Demo
+#### python
+```bash
+cd model_farm_midas_v2_qcs8550_qnn2.16_int8_aidlite
+python3 python/run_test.py --target_model ./models/midas_v2_w8a8.qnn216.ctx.bin --imgs ./python/dog.jpg  --invoke_nums 10 
+```
+
+#### c++
+```bash
+cd midas_v2/model_farm_midas_v2_qcs8550_qnn2.16_int8_aidlite/cpp
+mkdir build && cd build 
+cmake ..
+make
+./run_test
+```

model_farm_midas_v2_qcs8550_qnn2.16_int8_aidlite/cpp/CMakeLists.txt

@@ -0,0 +1,32 @@
+cmake_minimum_required (VERSION 3.5)
+project("run_test")
+
+find_package(OpenCV REQUIRED)
+
+message(STATUS "oPENCV Library status:")
+message(STATUS ">version:${OpenCV_VERSION}")
+message(STATUS "Include:${OpenCV_INCLUDE_DIRS}")
+
+set(CMAKE_CXX_FLAGS "-Wno-error=deprecated-declarations -Wno-deprecated-declarations")
+
+include_directories(
+    /usr/local/include
+    /usr/include/opencv4
+)
+
+link_directories(
+    /usr/local/lib/
+)
+
+file(GLOB SRC_LISTS 
+    ${CMAKE_CURRENT_SOURCE_DIR}/run_test.cpp  
+)
+
+add_executable(run_test ${SRC_LISTS})
+
+target_link_libraries(run_test
+    aidlite
+	${OpenCV_LIBS}
+    pthread
+    jsoncpp
+)

model_farm_midas_v2_qcs8550_qnn2.16_int8_aidlite/cpp/run_test.cpp

@@ -0,0 +1,392 @@
+#include <iostream>
+#include <fstream>
+#include <opencv2/opencv.hpp>
+#include <aidlux/aidlite/aidlite.hpp>
+#include <vector>
+#include <numeric>
+#include <cmath>
+#include <jsoncpp/json/json.h>
+
+using namespace cv;
+using namespace std;
+using namespace Aidlux::Aidlite;
+
+const int net_w = 256;
+const int net_h = 256;
+
+const std::vector<float> mean_vals = {0.485f, 0.456f, 0.406f};
+const std::vector<float> std_vals = {0.229f, 0.224f, 0.225f};
+
+
+struct Args {
+    std::string target_model = "../../models/midas_v2_w8a8.qnn216.ctx.bin";
+    std::string imgs = "../dog.jpg";
+    int invoke_nums = 10;
+    std::string model_type = "QNN";
+};
+
+
+Args parse_args(int argc, char* argv[]) {
+    Args args;
+    for (int i = 1; i < argc; ++i) {
+        std::string arg = argv[i];
+        if (arg == "--target_model" && i + 1 < argc) {
+            args.target_model = argv[++i];
+        } else if (arg == "--imgs" && i + 1 < argc) {
+            args.imgs = argv[++i];
+        } else if (arg == "--invoke_nums" && i + 1 < argc) {
+            args.invoke_nums = std::stoi(argv[++i]);
+        } else if (arg == "--model_type" && i + 1 < argc) {
+            args.model_type = argv[++i];
+        }
+    }
+    return args;
+}
+
+std::string to_lower(const std::string& str) {
+    std::string lower_str = str;
+    std::transform(lower_str.begin(), lower_str.end(), lower_str.begin(), [](unsigned char c) {
+        return std::tolower(c);
+    });
+    return lower_str;
+}
+
+
+int transpose(float* src, unsigned int* src_dims, unsigned int* tsp_dims, float* dest){
+
+    int current_coordinate[4] = {0, 0, 0, 0};
+    for(int a = 0; a < src_dims[0]; ++a){
+        current_coordinate[0] = a;
+        for(int b = 0; b < src_dims[1]; ++b){
+            current_coordinate[1] = b;
+            for(int c = 0; c < src_dims[2]; ++c){
+                current_coordinate[2] = c;
+                for(int d = 0; d < src_dims[3]; ++d){
+                    current_coordinate[3] = d;
+
+                    int old_index = current_coordinate[0]*src_dims[1]*src_dims[2]*src_dims[3] + 
+                                    current_coordinate[1]*src_dims[2]*src_dims[3] + 
+                                    current_coordinate[2]*src_dims[3] + 
+                                    current_coordinate[3];
+
+                    int new_index = current_coordinate[tsp_dims[0]]*src_dims[tsp_dims[1]]*src_dims[tsp_dims[2]]*src_dims[tsp_dims[3]] + 
+                                    current_coordinate[tsp_dims[1]]*src_dims[tsp_dims[2]]*src_dims[tsp_dims[3]] + 
+                                    current_coordinate[tsp_dims[2]]*src_dims[tsp_dims[3]] + 
+                                    current_coordinate[tsp_dims[3]];
+
+                    dest[new_index] = src[old_index];
+                }
+            }
+        }
+    }
+
+    return EXIT_SUCCESS;
+}
+
+
+// 替代 np.nan_to_num
+void sanitizeDepthMap(cv::Mat& depth) {
+    for (int y = 0; y < depth.rows; ++y) {
+        float* row = depth.ptr<float>(y);
+        for (int x = 0; x < depth.cols; ++x) {
+            float val = row[x];
+            if (!std::isfinite(val)) {
+                row[x] = 0.0f;
+            }
+        }
+    }
+}
+
+// 等效于 Python write_depth
+void write_depth(const std::string& path, const cv::Mat& input_depth, bool grayscale = false, int bits = 1) {
+    CV_Assert(input_depth.type() == CV_32FC1);
+
+    // 拷贝 + 处理非法值
+    cv::Mat depth = input_depth.clone();
+    sanitizeDepthMap(depth);
+
+    double minVal, maxVal;
+    cv::minMaxLoc(depth, &minVal, &maxVal);
+
+    double max_val = (1 << (8 * bits)) - 1;
+    cv::Mat out;
+
+    if (maxVal - minVal > std::numeric_limits<float>::epsilon()) {
+        // 归一化并映射到位深范围
+        out = (depth - minVal) * (max_val / (maxVal - minVal));
+    } else {
+        out = cv::Mat::zeros(depth.size(), CV_32F);
+    }
+
+    if (!grayscale) {
+        out.convertTo(out, CV_8UC1);
+        cv::applyColorMap(out, out, cv::COLORMAP_INFERNO);
+    }
+
+    if (bits == 1) {
+        out.convertTo(out, CV_8U);
+    } else if (bits == 2) {
+        out.convertTo(out, CV_16U);
+    }
+
+    cv::imwrite(path, out);
+}
+
+// 等效于 Python write_pfm
+void write_pfm(const std::string& path, const cv::Mat& image, float scale = 1.0f) {
+    CV_Assert(image.type() == CV_32FC1 || image.type() == CV_32FC3);
+
+    std::ofstream file(path, std::ios::binary);
+    if (!file.is_open()) {
+        std::cerr << "Failed to open file for writing PFM: " << path << std::endl;
+        return;
+    }
+
+    int width = image.cols;
+    int height = image.rows;
+    int channels = image.channels();
+    bool color = (channels == 3);
+
+    file << (color ? "PF" : "Pf") << "\n";
+    file << width << " " << height << "\n";
+
+    // Endianness: negative = little-endian
+    uint16_t endian_test = 0x1;
+    bool is_little_endian = *(reinterpret_cast<uint8_t*>(&endian_test)) == 0x1;
+    if (is_little_endian) {
+        scale = -scale;
+    }
+
+    file << scale << "\n";
+
+    // Flip vertically (OpenCV top-left origin -> PFM bottom-left origin)
+    cv::Mat flipped;
+    cv::flip(image, flipped, 0);
+
+    // Write raw data
+    file.write(reinterpret_cast<const char*>(flipped.data), flipped.total() * channels * sizeof(float));
+    file.close();
+}
+
+
+// ======================= Normalize =======================
+void normalize(cv::Mat& image) {
+    CV_Assert(image.type() == CV_32FC3);
+    int rows = image.rows;
+    int cols = image.cols;
+
+    for (int y = 0; y < rows; ++y) {
+        cv::Vec3f* row = image.ptr<cv::Vec3f>(y);
+        for (int x = 0; x < cols; ++x) {
+            for (int c = 0; c < 3; ++c) {
+                row[x][c] = (row[x][c] - mean_vals[c]) / std_vals[c];
+            }
+        }
+    }
+}
+
+cv::Mat hwc_to_chw(const cv::Mat& image) {
+    std::vector<cv::Mat> channels(3);
+    cv::split(image, channels);
+
+    cv::Mat chw(3, image.rows * image.cols, CV_32F);
+    for (int c = 0; c < 3; ++c) {
+        memcpy(chw.ptr(c), channels[c].data, image.rows * image.cols * sizeof(float));
+    }
+
+    return chw;
+}
+
+
+bool first_execution = true;
+cv::Mat img_process(const cv::Mat image_bgr, cv::Size& org_size_out) {
+    first_execution = false;
+
+    cv::Mat image_rgb;
+    cv::cvtColor(image_bgr, image_rgb, cv::COLOR_BGR2RGB);
+    image_rgb.convertTo(image_rgb, CV_32FC3, 1.0 / 255.0);
+
+    // 2. Save original size
+    org_size_out = image_rgb.size();  // H x W
+
+    // 3. Resize to 256x256 using cubic interpolation
+    cv::resize(image_rgb, image_rgb, cv::Size(net_w, net_h), 0, 0, cv::INTER_CUBIC);
+
+    // 4. Normalize using mean/std
+    normalize(image_rgb);
+
+    // 5. Convert HWC to CHW
+    cv::Mat chw = hwc_to_chw(image_rgb);
+
+    // 6. Add batch dimension: [1, C, H, W] → reshape to 1x3xHxW style float array
+    cv::Mat input_tensor(1, 3 * net_h * net_w, CV_32F);
+    memcpy(input_tensor.ptr<float>(), chw.data, 3 * net_h * net_w * sizeof(float));
+
+    std::cout << "Input resized to " << net_w << "x" << net_h << " before entering the encoder" << std::endl;
+
+    return input_tensor;
+}
+
+
+float* matToFloatPtr(const cv::Mat& input_mat, bool normalize = true) {
+    // 检查连续性
+    cv::Mat mat = input_mat;
+    if (!mat.isContinuous()) {
+        mat = mat.clone();
+    }
+
+    // 分配内存
+    int total_pixels = mat.rows * mat.cols;
+    int channels = mat.channels();
+    float* float_data = new float[total_pixels * channels];
+
+    // 根据数据类型转换
+    if (mat.type() == CV_8UC1 || mat.type() == CV_8UC3) {
+        uchar* ptr = mat.ptr<uchar>(0);
+        for (int i = 0; i < total_pixels * channels; ++i) {
+            float_data[i] = normalize ? (static_cast<float>(ptr[i]) / 255.0f) : ptr[i];
+        }
+    } else if (mat.type() == CV_32FC1 || mat.type() == CV_32FC3) {
+        float* ptr = mat.ptr<float>(0);
+        std::memcpy(float_data, ptr, total_pixels * channels * sizeof(float));
+    } else {
+        delete[] float_data;
+        return nullptr; // 不支持的类型
+    }
+
+    return float_data;
+}
+
+
+int invoke(const Args& args) {
+    std::cout << "Start main ... ... Model Path: " << args.target_model << "\n"
+              << "Image Path: " << args.imgs << "\n"
+              << "Inference Nums: " << args.invoke_nums << "\n"
+              << "Model Type: " << args.model_type << "\n";
+    Model* model = Model::create_instance(args.target_model);
+    if(model == nullptr){
+        printf("Create model failed !\n");
+        return EXIT_FAILURE;
+    }
+    Config* config = Config::create_instance();
+    if(config == nullptr){
+        printf("Create config failed !\n");
+        return EXIT_FAILURE;
+    }
+    config->implement_type = ImplementType::TYPE_LOCAL;
+    std::string model_type_lower = to_lower(args.model_type);
+    if (model_type_lower == "qnn"){
+        config->framework_type = FrameworkType::TYPE_QNN;
+    } else if (model_type_lower == "snpe2" || model_type_lower == "snpe") {
+        config->framework_type = FrameworkType::TYPE_SNPE2;
+    }
+    config->accelerate_type = AccelerateType::TYPE_DSP;
+    config->is_quantify_model = 1;
+
+    unsigned int model_h = 256;
+    unsigned int model_w = 256;
+    std::vector<std::vector<uint32_t>> input_shapes = {{1,model_h,model_w,3}};
+    std::vector<std::vector<uint32_t>> output_shapes = {{1,model_h,model_w,1}};
+    model->set_model_properties(input_shapes, Aidlux::Aidlite::DataType::TYPE_FLOAT32, output_shapes, Aidlux::Aidlite::DataType::TYPE_FLOAT32);
+    std::unique_ptr<Interpreter> fast_interpreter = InterpreterBuilder::build_interpretper_from_model_and_config(model, config);
+    if(fast_interpreter == nullptr){
+        printf("build_interpretper_from_model_and_config failed !\n");
+        return EXIT_FAILURE;
+    }
+    int result = fast_interpreter->init();
+    if(result != EXIT_SUCCESS){
+        printf("interpreter->init() failed !\n");
+        return EXIT_FAILURE;
+    }
+    // load model
+    fast_interpreter->load_model();
+    if(result != EXIT_SUCCESS){
+        printf("interpreter->load_model() failed !\n");
+        return EXIT_FAILURE;
+    }
+    printf("detect model load success!\n");
+
+    cv::Mat frame = cv::imread(args.imgs);
+    if (frame.empty()) {
+        printf("detect image load failed!\n");
+        return 1;
+    }
+    printf("img_src cols: %d, img_src rows: %d\n", frame.cols, frame.rows);
+    cv::Mat input_data;
+    cv::Mat frame_clone = frame.clone();
+    int h = frame_clone.rows;
+    int w = frame_clone.cols;
+    cv::Size org_size(w, h);
+    cv::Size org_size0(256, 256);
+
+    cv::Mat input_tensor = img_process(frame_clone, org_size0);
+    float* float_data = matToFloatPtr(input_tensor);
+    unsigned int src_dims[4] = {1, 3, 256, 256};
+    unsigned int tsp_dims[4] = {0,2,3,1};
+    unsigned int stride_data_num = 1*256*256*3;
+    float* format_data = new float[stride_data_num];
+    transpose(float_data, src_dims, tsp_dims, format_data);
+    cv::Mat origin_buffer(3,256*256, CV_32F, format_data);
+
+    float *outdata0 = nullptr;
+    std::vector<float> invoke_time;
+    for (int i = 0; i < args.invoke_nums; ++i) {
+        result = fast_interpreter->set_input_tensor(0, origin_buffer.data);
+        if(result != EXIT_SUCCESS){
+            printf("interpreter->set_input_tensor() failed !\n");
+            return EXIT_FAILURE;
+        }
+        auto t1 = std::chrono::high_resolution_clock::now();
+        result = fast_interpreter->invoke();
+        auto t2 = std::chrono::high_resolution_clock::now();
+        std::chrono::duration<double> cost_time = t2 - t1;
+        invoke_time.push_back(cost_time.count() * 1000);
+        if(result != EXIT_SUCCESS){
+            printf("interpreter->invoke() failed !\n");
+            return EXIT_FAILURE;
+        }
+        uint32_t out_data_0 = 0;
+        result = fast_interpreter->get_output_tensor(0, (void**)&outdata0, &out_data_0);
+        if(result != EXIT_SUCCESS){
+            printf("interpreter->get_output_tensor() 1 failed !\n");
+            return EXIT_FAILURE;
+        }
+
+    }
+
+    float max_invoke_time = *std::max_element(invoke_time.begin(), invoke_time.end());
+    float min_invoke_time = *std::min_element(invoke_time.begin(), invoke_time.end());
+    float mean_invoke_time = std::accumulate(invoke_time.begin(), invoke_time.end(), 0.0f) / args.invoke_nums;
+    float var_invoketime = 0.0f;
+    for (auto time : invoke_time) {
+        var_invoketime += (time - mean_invoke_time) * (time - mean_invoke_time);
+    }
+    var_invoketime /= args.invoke_nums;
+    printf("=======================================\n");
+    printf("QNN inference %d times :\n --mean_invoke_time is %f \n --max_invoke_time is %f \n --min_invoke_time is %f \n --var_invoketime is %f\n", 
+        args.invoke_nums, mean_invoke_time, max_invoke_time, min_invoke_time, var_invoketime);
+    printf("=======================================\n");
+
+    //  post process
+    cv::Mat out_buffer(1,256*256, CV_32F, outdata0);
+     cv::Mat prediction_2d(256, 256, CV_32F, (void*)out_buffer.ptr<float>());
+    cv::Mat resized;
+    cv::resize(prediction_2d, resized, org_size, 0, 0, cv::INTER_CUBIC);
+
+    // 保存为图像
+    write_depth("depth_output.jpg", resized, false, 1);
+
+    // 保存为 PFM
+    write_pfm("depth_output.pfm", resized);
+
+
+
+    fast_interpreter->destory();
+    return 0;
+}
+
+
+int main(int argc, char* argv[]) {
+    Args args = parse_args(argc, argv);
+    return invoke(args);
+}

model_farm_midas_v2_qcs8550_qnn2.16_int8_aidlite/models/midas_v2_w8a8.qnn216.ctx.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d583ca678b740c8075b7f829e4d01ecbcfccf7fc498d549b365508d686d89982
+size 18853888

model_farm_midas_v2_qcs8550_qnn2.16_int8_aidlite/python/run_test.py

@@ -0,0 +1,111 @@
+import numpy as np
+import torch
+import cv2
+import os
+from  utils import write_pfm,write_depth,img_process
+import aidlite
+import time
+import argparse
+
+def out_process(prediction,target_size):
+    prediction = torch.nn.functional.interpolate(
+            prediction,
+            size=target_size,
+            mode="bicubic",
+            align_corners=False,
+        )
+    prediction = prediction.squeeze().detach().numpy()
+    return prediction
+
+class run_qnn:
+    def __init__(self,qnn_path):
+        super().__init__()
+        self.model = aidlite.Model.create_instance(qnn_path)
+        if self.model is None:
+            print("Create model failed !")
+            return
+
+        self.config = aidlite.Config.create_instance()
+        if self.config is None:
+            print("build_interpretper_from_model_and_config failed !")
+            return
+
+        self.config.implement_type = aidlite.ImplementType.TYPE_LOCAL
+        self.config.framework_type = aidlite.FrameworkType.TYPE_QNN
+        self.config.accelerate_type = aidlite.AccelerateType.TYPE_DSP
+        # self.config.accelerate_type = aidlite.AccelerateType.TYPE_CPU
+        self.config.is_quantify_model = 1
+        
+        self.interpreter = aidlite.InterpreterBuilder.build_interpretper_from_model_and_config(self.model, self.config)
+        if self.interpreter is None:
+            print("build_interpretper_from_model_and_config failed !")
+            return
+        input_shapes = [[1,256,256,3]]
+        output_shapes = [[1,256,256,1]]
+        self.model.set_model_properties(input_shapes, aidlite.DataType.TYPE_FLOAT32,
+                                output_shapes, aidlite.DataType.TYPE_FLOAT32)
+
+        if self.interpreter is None:
+            print("build_interpretper_from_model_and_config failed !")
+        result = self.interpreter.init()
+        if result != 0:
+            print(f"interpreter init failed !")
+        result = self.interpreter.load_model()
+        if result != 0:
+            print("interpreter load model failed !")
+   
+        print(" model load success!")
+
+    def __call__(self, input,invoke_nums):
+        self.interpreter.set_input_tensor(0,input)
+        invoke_time=[]
+        for i in range(invoke_nums):
+            result = self.interpreter.set_input_tensor(0, input.data)
+            if result != 0:
+                print("interpreter set_input_tensor() failed")
+            t1=time.time()
+            result = self.interpreter.invoke()
+            cost_time = (time.time()-t1)*1000
+            invoke_time.append(cost_time)
+
+        max_invoke_time = max(invoke_time)
+        min_invoke_time = min(invoke_time)
+        mean_invoke_time = sum(invoke_time)/invoke_nums
+        var_invoketime=np.var(invoke_time)
+        print("====================================")
+        print(f"QNN  invoke time:\n --mean_invoke_time is {mean_invoke_time} \n --max_invoke_time is {max_invoke_time} \n --min_invoke_time is {min_invoke_time} \n --var_invoketime is {var_invoketime}")
+        print("====================================")
+        features_0 = self.interpreter.get_output_tensor(0).reshape(1,256,256,1).transpose(0,3,1,2)
+        return features_0
+
+
+
+def run(args):
+    img_path = args.imgs
+    qnn_path = args.target_model
+    invoke_num=args.invoke_nums
+    print("Start processing...")
+    img_input,org_size = img_process(img_path)
+
+    qnn_model =run_qnn(qnn_path)
+    prediction_qnn = qnn_model(img_input.numpy().transpose(0,2,3,1),invoke_num)
+    prediction_qnn = torch.tensor(prediction_qnn)
+    qnn_process = out_process(prediction_qnn,org_size)
+
+    write_depth("./python/results.jpg", qnn_process, grayscale=False, bits=1)
+    write_pfm("./python/results.pfm", qnn_process.astype(np.float32))
+    print("Finished")
+
+def parser_args():
+    parser = argparse.ArgumentParser(description="Run model benchmarks")
+    parser.add_argument('--target_model',type=str,default='./models/midas_v2_w8a8.qnn216.ctx.bin',help="Inference model path")
+    parser.add_argument('--imgs',type=str,default='./python/dog.jpg',help="Predict images path")
+    parser.add_argument('--invoke_nums',type=int,default=10,help="Inference nums")
+    parser.add_argument('--model_type',type=str,default='QNN',help="Run backend")
+    args = parser.parse_args()
+    return args
+
+
+if __name__ =="__main__":
+    args = parser_args()
+    run(args)

model_farm_midas_v2_qcs8550_qnn2.16_int8_aidlite/python/transforms.py

@@ -0,0 +1,234 @@
+import numpy as np
+import cv2
+import math
+
+
+def apply_min_size(sample, size, image_interpolation_method=cv2.INTER_AREA):
+    """Rezise the sample to ensure the given size. Keeps aspect ratio.
+
+    Args:
+        sample (dict): sample
+        size (tuple): image size
+
+    Returns:
+        tuple: new size
+    """
+    shape = list(sample["disparity"].shape)
+
+    if shape[0] >= size[0] and shape[1] >= size[1]:
+        return sample
+
+    scale = [0, 0]
+    scale[0] = size[0] / shape[0]
+    scale[1] = size[1] / shape[1]
+
+    scale = max(scale)
+
+    shape[0] = math.ceil(scale * shape[0])
+    shape[1] = math.ceil(scale * shape[1])
+
+    # resize
+    sample["image"] = cv2.resize(
+        sample["image"], tuple(shape[::-1]), interpolation=image_interpolation_method
+    )
+
+    sample["disparity"] = cv2.resize(
+        sample["disparity"], tuple(shape[::-1]), interpolation=cv2.INTER_NEAREST
+    )
+    sample["mask"] = cv2.resize(
+        sample["mask"].astype(np.float32),
+        tuple(shape[::-1]),
+        interpolation=cv2.INTER_NEAREST,
+    )
+    sample["mask"] = sample["mask"].astype(bool)
+
+    return tuple(shape)
+
+
+class Resize(object):
+    """Resize sample to given size (width, height).
+    """
+
+    def __init__(
+        self,
+        width,
+        height,
+        resize_target=True,
+        keep_aspect_ratio=False,
+        ensure_multiple_of=1,
+        resize_method="lower_bound",
+        image_interpolation_method=cv2.INTER_AREA,
+    ):
+        """Init.
+
+        Args:
+            width (int): desired output width
+            height (int): desired output height
+            resize_target (bool, optional):
+                True: Resize the full sample (image, mask, target).
+                False: Resize image only.
+                Defaults to True.
+            keep_aspect_ratio (bool, optional):
+                True: Keep the aspect ratio of the input sample.
+                Output sample might not have the given width and height, and
+                resize behaviour depends on the parameter 'resize_method'.
+                Defaults to False.
+            ensure_multiple_of (int, optional):
+                Output width and height is constrained to be multiple of this parameter.
+                Defaults to 1.
+            resize_method (str, optional):
+                "lower_bound": Output will be at least as large as the given size.
+                "upper_bound": Output will be at max as large as the given size. (Output size might be smaller than given size.)
+                "minimal": Scale as least as possible.  (Output size might be smaller than given size.)
+                Defaults to "lower_bound".
+        """
+        self.__width = width
+        self.__height = height
+
+        self.__resize_target = resize_target
+        self.__keep_aspect_ratio = keep_aspect_ratio
+        self.__multiple_of = ensure_multiple_of
+        self.__resize_method = resize_method
+        self.__image_interpolation_method = image_interpolation_method
+
+    def constrain_to_multiple_of(self, x, min_val=0, max_val=None):
+        y = (np.round(x / self.__multiple_of) * self.__multiple_of).astype(int)
+
+        if max_val is not None and y > max_val:
+            y = (np.floor(x / self.__multiple_of) * self.__multiple_of).astype(int)
+
+        if y < min_val:
+            y = (np.ceil(x / self.__multiple_of) * self.__multiple_of).astype(int)
+
+        return y
+
+    def get_size(self, width, height):
+        # determine new height and width
+        scale_height = self.__height / height
+        scale_width = self.__width / width
+
+        if self.__keep_aspect_ratio:
+            if self.__resize_method == "lower_bound":
+                # scale such that output size is lower bound
+                if scale_width > scale_height:
+                    # fit width
+                    scale_height = scale_width
+                else:
+                    # fit height
+                    scale_width = scale_height
+            elif self.__resize_method == "upper_bound":
+                # scale such that output size is upper bound
+                if scale_width < scale_height:
+                    # fit width
+                    scale_height = scale_width
+                else:
+                    # fit height
+                    scale_width = scale_height
+            elif self.__resize_method == "minimal":
+                # scale as least as possbile
+                if abs(1 - scale_width) < abs(1 - scale_height):
+                    # fit width
+                    scale_height = scale_width
+                else:
+                    # fit height
+                    scale_width = scale_height
+            else:
+                raise ValueError(
+                    f"resize_method {self.__resize_method} not implemented"
+                )
+
+        if self.__resize_method == "lower_bound":
+            new_height = self.constrain_to_multiple_of(
+                scale_height * height, min_val=self.__height
+            )
+            new_width = self.constrain_to_multiple_of(
+                scale_width * width, min_val=self.__width
+            )
+        elif self.__resize_method == "upper_bound":
+            new_height = self.constrain_to_multiple_of(
+                scale_height * height, max_val=self.__height
+            )
+            new_width = self.constrain_to_multiple_of(
+                scale_width * width, max_val=self.__width
+            )
+        elif self.__resize_method == "minimal":
+            new_height = self.constrain_to_multiple_of(scale_height * height)
+            new_width = self.constrain_to_multiple_of(scale_width * width)
+        else:
+            raise ValueError(f"resize_method {self.__resize_method} not implemented")
+
+        return (new_width, new_height)
+
+    def __call__(self, sample):
+        width, height = self.get_size(
+            sample["image"].shape[1], sample["image"].shape[0]
+        )
+
+        # resize sample
+        sample["image"] = cv2.resize(
+            sample["image"],
+            (width, height),
+            interpolation=self.__image_interpolation_method,
+        )
+
+        if self.__resize_target:
+            if "disparity" in sample:
+                sample["disparity"] = cv2.resize(
+                    sample["disparity"],
+                    (width, height),
+                    interpolation=cv2.INTER_NEAREST,
+                )
+
+            if "depth" in sample:
+                sample["depth"] = cv2.resize(
+                    sample["depth"], (width, height), interpolation=cv2.INTER_NEAREST
+                )
+
+            sample["mask"] = cv2.resize(
+                sample["mask"].astype(np.float32),
+                (width, height),
+                interpolation=cv2.INTER_NEAREST,
+            )
+            sample["mask"] = sample["mask"].astype(bool)
+
+        return sample
+
+
+class NormalizeImage(object):
+    """Normlize image by given mean and std.
+    """
+
+    def __init__(self, mean, std):
+        self.__mean = mean
+        self.__std = std
+
+    def __call__(self, sample):
+        sample["image"] = (sample["image"] - self.__mean) / self.__std
+
+        return sample
+
+
+class PrepareForNet(object):
+    """Prepare sample for usage as network input.
+    """
+
+    def __init__(self):
+        pass
+
+    def __call__(self, sample):
+        image = np.transpose(sample["image"], (2, 0, 1))
+        sample["image"] = np.ascontiguousarray(image).astype(np.float32)
+
+        if "mask" in sample:
+            sample["mask"] = sample["mask"].astype(np.float32)
+            sample["mask"] = np.ascontiguousarray(sample["mask"])
+
+        if "disparity" in sample:
+            disparity = sample["disparity"].astype(np.float32)
+            sample["disparity"] = np.ascontiguousarray(disparity)
+
+        if "depth" in sample:
+            depth = sample["depth"].astype(np.float32)
+            sample["depth"] = np.ascontiguousarray(depth)
+
+        return sample

model_farm_midas_v2_qcs8550_qnn2.16_int8_aidlite/python/utils.py

@@ -0,0 +1,104 @@
+import numpy as np
+import torch
+import cv2
+import os
+
+from transforms import Resize, NormalizeImage, PrepareForNet
+
+from torchvision.transforms import Compose
+import sys
+first_execution = True
+def img_process(img_path):
+    global first_execution
+    first_execution = False
+    net_w, net_h = 256, 256
+    resize_mode = "upper_bound"
+    normalization = NormalizeImage(
+        mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]
+    )
+    transform = Compose(
+        [
+            Resize(
+                net_w,
+                net_h,
+                resize_target=None,
+                keep_aspect_ratio=False,
+                ensure_multiple_of=32,
+                resize_method=resize_mode,
+                image_interpolation_method=cv2.INTER_CUBIC,
+            ),
+            normalization,
+            PrepareForNet(),
+        ]
+    )
+    # image = utils.read_image(img_path)  # in [0, 1]
+    image = cv2.imread(img_path)
+    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) / 255.0
+    org_size=  image.shape[:2]
+    image = transform({"image": image})["image"]
+    sample = torch.from_numpy(image).to("cpu").unsqueeze(0)
+    height, width = sample.shape[2:]
+    print(f"Input resized to {width}x{height} before entering the encoder")
+
+    return sample,org_size
+
+
+
+def write_depth(path, depth, grayscale=False, bits=1):
+    if not grayscale:
+        bits = 1
+
+    if not np.isfinite(depth).all():
+        depth=np.nan_to_num(depth, nan=0.0, posinf=0.0, neginf=0.0)
+        print("WARNING: Non-finite depth values present")
+
+    depth_min = depth.min()
+    depth_max = depth.max()
+
+    max_val = (2**(8*bits))-1
+
+    if depth_max - depth_min > np.finfo("float").eps:
+        out = max_val * (depth - depth_min) / (depth_max - depth_min)
+    else:
+        out = np.zeros(depth.shape, dtype=depth.dtype)
+
+    # print("out :",out.shape,out)
+    if not grayscale:
+        out = cv2.applyColorMap(np.uint8(out), cv2.COLORMAP_INFERNO)
+
+    if bits == 1:
+        cv2.imwrite(path , out.astype("uint8"))
+    elif bits == 2:
+        cv2.imwrite(path , out.astype("uint16"))
+
+    return
+
+def write_pfm(path, image, scale=1):
+    with open(path, "wb") as file:
+        color = None
+
+        if image.dtype.name != "float32":
+            raise Exception("Image dtype must be float32.")
+
+        image = np.flipud(image)
+
+        if len(image.shape) == 3 and image.shape[2] == 3:  # color image
+            color = True
+        elif (
+            len(image.shape) == 2 or len(image.shape) == 3 and image.shape[2] == 1
+        ):  # greyscale
+            color = False
+        else:
+            raise Exception("Image must have H x W x 3, H x W x 1 or H x W dimensions.")
+
+        file.write("PF\n" if color else "Pf\n".encode())
+        file.write("%d %d\n".encode() % (image.shape[1], image.shape[0]))
+
+        endian = image.dtype.byteorder
+
+        if endian == "<" or endian == "=" and sys.byteorder == "little":
+            scale = -scale
+
+        file.write("%f\n".encode() % scale)
+
+        image.tofile(file)

model_farm_midas_v2_qcs8550_qnn2.16_w8a16_aidlite/README.md

@@ -0,0 +1,57 @@
+## Model Information
+
+### Source model
+- Input shape: 1x3x256x256
+- Number of parameters: 20.33M
+- Model size: 82.17M
+- Output shape: 1x1x256x256
+
+Source model repository: [midas](https://github.com/isl-org/MiDaS/tree/master)
+
+### Converted model
+
+- Precision: INT8
+- Backend: QNN2.16
+- Target Device: SNM972 QCS8550
+
+## Inference with AidLite SDK
+
+### SDK installation
+Model Farm uses AidLite SDK as the model inference SDK. For details, please refer to the [AidLite Developer Documentation](https://v2.docs.aidlux.com/en/sdk-api/aidlite-sdk/)
+
+- Install AidLite SDK
+
+```bash
+# Install the appropriate version of the aidlite sdk
+sudo aid-pkg update
+sudo aid-pkg install aidlite-sdk
+# Download the qnn version that matches the above backend. Eg Install QNN2.23 Aidlite: sudo aid-pkg install aidlite-qnn223
+sudo aid-pkg install aidlite-{QNN VERSION}
+```
+
+- Verify AidLite SDK
+
+```bash
+# aidlite sdk c++ check
+python3 -c "import aidlite ; print(aidlite.get_library_version())"
+
+# aidlite sdk python check, Aidlux_Aidlite version <=2.1.0
+python3 -c "import aidlite ; print(aidlite.get_py_library_version())"
+```
+
+### Run Demo
+#### python
+```bash
+cd model_farm_midas_v2_qcs8550_qnn2.16_w8a16_aidlite
+python3 python/run_test.py --target_model ./models/midas_v2_w8a16.qnn216.ctx.bin --imgs ./python/dog.jpg  --invoke_nums 10 
+```
+
+
+#### c++
+```bash
+cd midas_v2/model_farm_midas_v2_qcs8550_qnn2.16_w8a16_aidlite/cpp
+mkdir build && cd build 
+cmake ..
+make
+./run_test
+```

model_farm_midas_v2_qcs8550_qnn2.16_w8a16_aidlite/cpp/CMakeLists.txt

@@ -0,0 +1,32 @@
+cmake_minimum_required (VERSION 3.5)
+project("run_test")
+
+find_package(OpenCV REQUIRED)
+
+message(STATUS "oPENCV Library status:")
+message(STATUS ">version:${OpenCV_VERSION}")
+message(STATUS "Include:${OpenCV_INCLUDE_DIRS}")
+
+set(CMAKE_CXX_FLAGS "-Wno-error=deprecated-declarations -Wno-deprecated-declarations")
+
+include_directories(
+    /usr/local/include
+    /usr/include/opencv4
+)
+
+link_directories(
+    /usr/local/lib/
+)
+
+file(GLOB SRC_LISTS 
+    ${CMAKE_CURRENT_SOURCE_DIR}/run_test.cpp  
+)
+
+add_executable(run_test ${SRC_LISTS})
+
+target_link_libraries(run_test
+    aidlite
+	${OpenCV_LIBS}
+    pthread
+    jsoncpp
+)

model_farm_midas_v2_qcs8550_qnn2.16_w8a16_aidlite/cpp/run_test.cpp

@@ -0,0 +1,392 @@
+#include <iostream>
+#include <fstream>
+#include <opencv2/opencv.hpp>
+#include <aidlux/aidlite/aidlite.hpp>
+#include <vector>
+#include <numeric>
+#include <cmath>
+#include <jsoncpp/json/json.h>
+
+using namespace cv;
+using namespace std;
+using namespace Aidlux::Aidlite;
+
+const int net_w = 256;
+const int net_h = 256;
+
+const std::vector<float> mean_vals = {0.485f, 0.456f, 0.406f};
+const std::vector<float> std_vals = {0.229f, 0.224f, 0.225f};
+
+
+struct Args {
+    std::string target_model = "../../models/midas_v2_w8a16.qnn216.ctx.bin";
+    std::string imgs = "../dog.jpg";
+    int invoke_nums = 10;
+    std::string model_type = "QNN";
+};
+
+
+Args parse_args(int argc, char* argv[]) {
+    Args args;
+    for (int i = 1; i < argc; ++i) {
+        std::string arg = argv[i];
+        if (arg == "--target_model" && i + 1 < argc) {
+            args.target_model = argv[++i];
+        } else if (arg == "--imgs" && i + 1 < argc) {
+            args.imgs = argv[++i];
+        } else if (arg == "--invoke_nums" && i + 1 < argc) {
+            args.invoke_nums = std::stoi(argv[++i]);
+        } else if (arg == "--model_type" && i + 1 < argc) {
+            args.model_type = argv[++i];
+        }
+    }
+    return args;
+}
+
+std::string to_lower(const std::string& str) {
+    std::string lower_str = str;
+    std::transform(lower_str.begin(), lower_str.end(), lower_str.begin(), [](unsigned char c) {
+        return std::tolower(c);
+    });
+    return lower_str;
+}
+
+
+int transpose(float* src, unsigned int* src_dims, unsigned int* tsp_dims, float* dest){
+
+    int current_coordinate[4] = {0, 0, 0, 0};
+    for(int a = 0; a < src_dims[0]; ++a){
+        current_coordinate[0] = a;
+        for(int b = 0; b < src_dims[1]; ++b){
+            current_coordinate[1] = b;
+            for(int c = 0; c < src_dims[2]; ++c){
+                current_coordinate[2] = c;
+                for(int d = 0; d < src_dims[3]; ++d){
+                    current_coordinate[3] = d;
+
+                    int old_index = current_coordinate[0]*src_dims[1]*src_dims[2]*src_dims[3] + 
+                                    current_coordinate[1]*src_dims[2]*src_dims[3] + 
+                                    current_coordinate[2]*src_dims[3] + 
+                                    current_coordinate[3];
+
+                    int new_index = current_coordinate[tsp_dims[0]]*src_dims[tsp_dims[1]]*src_dims[tsp_dims[2]]*src_dims[tsp_dims[3]] + 
+                                    current_coordinate[tsp_dims[1]]*src_dims[tsp_dims[2]]*src_dims[tsp_dims[3]] + 
+                                    current_coordinate[tsp_dims[2]]*src_dims[tsp_dims[3]] + 
+                                    current_coordinate[tsp_dims[3]];
+
+                    dest[new_index] = src[old_index];
+                }
+            }
+        }
+    }
+
+    return EXIT_SUCCESS;
+}
+
+
+// 替代 np.nan_to_num
+void sanitizeDepthMap(cv::Mat& depth) {
+    for (int y = 0; y < depth.rows; ++y) {
+        float* row = depth.ptr<float>(y);
+        for (int x = 0; x < depth.cols; ++x) {
+            float val = row[x];
+            if (!std::isfinite(val)) {
+                row[x] = 0.0f;
+            }
+        }
+    }
+}
+
+// 等效于 Python write_depth
+void write_depth(const std::string& path, const cv::Mat& input_depth, bool grayscale = false, int bits = 1) {
+    CV_Assert(input_depth.type() == CV_32FC1);
+
+    // 拷贝 + 处理非法值
+    cv::Mat depth = input_depth.clone();
+    sanitizeDepthMap(depth);
+
+    double minVal, maxVal;
+    cv::minMaxLoc(depth, &minVal, &maxVal);
+
+    double max_val = (1 << (8 * bits)) - 1;
+    cv::Mat out;
+
+    if (maxVal - minVal > std::numeric_limits<float>::epsilon()) {
+        // 归一化并映射到位深范围
+        out = (depth - minVal) * (max_val / (maxVal - minVal));
+    } else {
+        out = cv::Mat::zeros(depth.size(), CV_32F);
+    }
+
+    if (!grayscale) {
+        out.convertTo(out, CV_8UC1);
+        cv::applyColorMap(out, out, cv::COLORMAP_INFERNO);
+    }
+
+    if (bits == 1) {
+        out.convertTo(out, CV_8U);
+    } else if (bits == 2) {
+        out.convertTo(out, CV_16U);
+    }
+
+    cv::imwrite(path, out);
+}
+
+// 等效于 Python write_pfm
+void write_pfm(const std::string& path, const cv::Mat& image, float scale = 1.0f) {
+    CV_Assert(image.type() == CV_32FC1 || image.type() == CV_32FC3);
+
+    std::ofstream file(path, std::ios::binary);
+    if (!file.is_open()) {
+        std::cerr << "Failed to open file for writing PFM: " << path << std::endl;
+        return;
+    }
+
+    int width = image.cols;
+    int height = image.rows;
+    int channels = image.channels();
+    bool color = (channels == 3);
+
+    file << (color ? "PF" : "Pf") << "\n";
+    file << width << " " << height << "\n";
+
+    // Endianness: negative = little-endian
+    uint16_t endian_test = 0x1;
+    bool is_little_endian = *(reinterpret_cast<uint8_t*>(&endian_test)) == 0x1;
+    if (is_little_endian) {
+        scale = -scale;
+    }
+
+    file << scale << "\n";
+
+    // Flip vertically (OpenCV top-left origin -> PFM bottom-left origin)
+    cv::Mat flipped;
+    cv::flip(image, flipped, 0);
+
+    // Write raw data
+    file.write(reinterpret_cast<const char*>(flipped.data), flipped.total() * channels * sizeof(float));
+    file.close();
+}
+
+
+// ======================= Normalize =======================
+void normalize(cv::Mat& image) {
+    CV_Assert(image.type() == CV_32FC3);
+    int rows = image.rows;
+    int cols = image.cols;
+
+    for (int y = 0; y < rows; ++y) {
+        cv::Vec3f* row = image.ptr<cv::Vec3f>(y);
+        for (int x = 0; x < cols; ++x) {
+            for (int c = 0; c < 3; ++c) {
+                row[x][c] = (row[x][c] - mean_vals[c]) / std_vals[c];
+            }
+        }
+    }
+}
+
+cv::Mat hwc_to_chw(const cv::Mat& image) {
+    std::vector<cv::Mat> channels(3);
+    cv::split(image, channels);
+
+    cv::Mat chw(3, image.rows * image.cols, CV_32F);
+    for (int c = 0; c < 3; ++c) {
+        memcpy(chw.ptr(c), channels[c].data, image.rows * image.cols * sizeof(float));
+    }
+
+    return chw;
+}
+
+
+bool first_execution = true;
+cv::Mat img_process(const cv::Mat image_bgr, cv::Size& org_size_out) {
+    first_execution = false;
+
+    cv::Mat image_rgb;
+    cv::cvtColor(image_bgr, image_rgb, cv::COLOR_BGR2RGB);
+    image_rgb.convertTo(image_rgb, CV_32FC3, 1.0 / 255.0);
+
+    // 2. Save original size
+    org_size_out = image_rgb.size();  // H x W
+
+    // 3. Resize to 256x256 using cubic interpolation
+    cv::resize(image_rgb, image_rgb, cv::Size(net_w, net_h), 0, 0, cv::INTER_CUBIC);
+
+    // 4. Normalize using mean/std
+    normalize(image_rgb);
+
+    // 5. Convert HWC to CHW
+    cv::Mat chw = hwc_to_chw(image_rgb);
+
+    // 6. Add batch dimension: [1, C, H, W] → reshape to 1x3xHxW style float array
+    cv::Mat input_tensor(1, 3 * net_h * net_w, CV_32F);
+    memcpy(input_tensor.ptr<float>(), chw.data, 3 * net_h * net_w * sizeof(float));
+
+    std::cout << "Input resized to " << net_w << "x" << net_h << " before entering the encoder" << std::endl;
+
+    return input_tensor;
+}
+
+
+float* matToFloatPtr(const cv::Mat& input_mat, bool normalize = true) {
+    // 检查连续性
+    cv::Mat mat = input_mat;
+    if (!mat.isContinuous()) {
+        mat = mat.clone();
+    }
+
+    // 分配内存
+    int total_pixels = mat.rows * mat.cols;
+    int channels = mat.channels();
+    float* float_data = new float[total_pixels * channels];
+
+    // 根据数据类型转换
+    if (mat.type() == CV_8UC1 || mat.type() == CV_8UC3) {
+        uchar* ptr = mat.ptr<uchar>(0);
+        for (int i = 0; i < total_pixels * channels; ++i) {
+            float_data[i] = normalize ? (static_cast<float>(ptr[i]) / 255.0f) : ptr[i];
+        }
+    } else if (mat.type() == CV_32FC1 || mat.type() == CV_32FC3) {
+        float* ptr = mat.ptr<float>(0);
+        std::memcpy(float_data, ptr, total_pixels * channels * sizeof(float));
+    } else {
+        delete[] float_data;
+        return nullptr; // 不支持的类型
+    }
+
+    return float_data;
+}
+
+
+int invoke(const Args& args) {
+    std::cout << "Start main ... ... Model Path: " << args.target_model << "\n"
+              << "Image Path: " << args.imgs << "\n"
+              << "Inference Nums: " << args.invoke_nums << "\n"
+              << "Model Type: " << args.model_type << "\n";
+    Model* model = Model::create_instance(args.target_model);
+    if(model == nullptr){
+        printf("Create model failed !\n");
+        return EXIT_FAILURE;
+    }
+    Config* config = Config::create_instance();
+    if(config == nullptr){
+        printf("Create config failed !\n");
+        return EXIT_FAILURE;
+    }
+    config->implement_type = ImplementType::TYPE_LOCAL;
+    std::string model_type_lower = to_lower(args.model_type);
+    if (model_type_lower == "qnn"){
+        config->framework_type = FrameworkType::TYPE_QNN;
+    } else if (model_type_lower == "snpe2" || model_type_lower == "snpe") {
+        config->framework_type = FrameworkType::TYPE_SNPE2;
+    }
+    config->accelerate_type = AccelerateType::TYPE_DSP;
+    config->is_quantify_model = 1;
+
+    unsigned int model_h = 256;
+    unsigned int model_w = 256;
+    std::vector<std::vector<uint32_t>> input_shapes = {{1,model_h,model_w,3}};
+    std::vector<std::vector<uint32_t>> output_shapes = {{1,model_h,model_w,1}};
+    model->set_model_properties(input_shapes, Aidlux::Aidlite::DataType::TYPE_FLOAT32, output_shapes, Aidlux::Aidlite::DataType::TYPE_FLOAT32);
+    std::unique_ptr<Interpreter> fast_interpreter = InterpreterBuilder::build_interpretper_from_model_and_config(model, config);
+    if(fast_interpreter == nullptr){
+        printf("build_interpretper_from_model_and_config failed !\n");
+        return EXIT_FAILURE;
+    }
+    int result = fast_interpreter->init();
+    if(result != EXIT_SUCCESS){
+        printf("interpreter->init() failed !\n");
+        return EXIT_FAILURE;
+    }
+    // load model
+    fast_interpreter->load_model();
+    if(result != EXIT_SUCCESS){
+        printf("interpreter->load_model() failed !\n");
+        return EXIT_FAILURE;
+    }
+    printf("detect model load success!\n");
+
+    cv::Mat frame = cv::imread(args.imgs);
+    if (frame.empty()) {
+        printf("detect image load failed!\n");
+        return 1;
+    }
+    printf("img_src cols: %d, img_src rows: %d\n", frame.cols, frame.rows);
+    cv::Mat input_data;
+    cv::Mat frame_clone = frame.clone();
+    int h = frame_clone.rows;
+    int w = frame_clone.cols;
+    cv::Size org_size(w, h);
+    cv::Size org_size0(256, 256);
+
+    cv::Mat input_tensor = img_process(frame_clone, org_size0);
+    float* float_data = matToFloatPtr(input_tensor);
+    unsigned int src_dims[4] = {1, 3, 256, 256};
+    unsigned int tsp_dims[4] = {0,2,3,1};
+    unsigned int stride_data_num = 1*256*256*3;
+    float* format_data = new float[stride_data_num];
+    transpose(float_data, src_dims, tsp_dims, format_data);
+    cv::Mat origin_buffer(3,256*256, CV_32F, format_data);
+
+    float *outdata0 = nullptr;
+    std::vector<float> invoke_time;
+    for (int i = 0; i < args.invoke_nums; ++i) {
+        result = fast_interpreter->set_input_tensor(0, origin_buffer.data);
+        if(result != EXIT_SUCCESS){
+            printf("interpreter->set_input_tensor() failed !\n");
+            return EXIT_FAILURE;
+        }
+        auto t1 = std::chrono::high_resolution_clock::now();
+        result = fast_interpreter->invoke();
+        auto t2 = std::chrono::high_resolution_clock::now();
+        std::chrono::duration<double> cost_time = t2 - t1;
+        invoke_time.push_back(cost_time.count() * 1000);
+        if(result != EXIT_SUCCESS){
+            printf("interpreter->invoke() failed !\n");
+            return EXIT_FAILURE;
+        }
+        uint32_t out_data_0 = 0;
+        result = fast_interpreter->get_output_tensor(0, (void**)&outdata0, &out_data_0);
+        if(result != EXIT_SUCCESS){
+            printf("interpreter->get_output_tensor() 1 failed !\n");
+            return EXIT_FAILURE;
+        }
+
+    }
+
+    float max_invoke_time = *std::max_element(invoke_time.begin(), invoke_time.end());
+    float min_invoke_time = *std::min_element(invoke_time.begin(), invoke_time.end());
+    float mean_invoke_time = std::accumulate(invoke_time.begin(), invoke_time.end(), 0.0f) / args.invoke_nums;
+    float var_invoketime = 0.0f;
+    for (auto time : invoke_time) {
+        var_invoketime += (time - mean_invoke_time) * (time - mean_invoke_time);
+    }
+    var_invoketime /= args.invoke_nums;
+    printf("=======================================\n");
+    printf("QNN inference %d times :\n --mean_invoke_time is %f \n --max_invoke_time is %f \n --min_invoke_time is %f \n --var_invoketime is %f\n", 
+        args.invoke_nums, mean_invoke_time, max_invoke_time, min_invoke_time, var_invoketime);
+    printf("=======================================\n");
+
+    //  post process
+    cv::Mat out_buffer(1,256*256, CV_32F, outdata0);
+     cv::Mat prediction_2d(256, 256, CV_32F, (void*)out_buffer.ptr<float>());
+    cv::Mat resized;
+    cv::resize(prediction_2d, resized, org_size, 0, 0, cv::INTER_CUBIC);
+
+    // 保存为图像
+    write_depth("depth_output.jpg", resized, false, 1);
+
+    // 保存为 PFM
+    write_pfm("depth_output.pfm", resized);
+
+
+
+    fast_interpreter->destory();
+    return 0;
+}
+
+
+int main(int argc, char* argv[]) {
+    Args args = parse_args(argc, argv);
+    return invoke(args);
+}

model_farm_midas_v2_qcs8550_qnn2.16_w8a16_aidlite/models/midas_v2_w8a16.qnn216.ctx.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0e26a9e1f7c7879c958086c295514e488ca9ecb7debab782a75158afd76982fd
+size 19263488

model_farm_midas_v2_qcs8550_qnn2.16_w8a16_aidlite/python/run_test.py

@@ -0,0 +1,111 @@
+import numpy as np
+import torch
+import cv2
+import os
+from  utils import write_pfm,write_depth,img_process
+import aidlite
+import time
+import argparse
+
+def out_process(prediction,target_size):
+    prediction = torch.nn.functional.interpolate(
+            prediction,
+            size=target_size,
+            mode="bicubic",
+            align_corners=False,
+        )
+    prediction = prediction.squeeze().detach().numpy()
+    return prediction
+
+class run_qnn:
+    def __init__(self,qnn_path):
+        super().__init__()
+        self.model = aidlite.Model.create_instance(qnn_path)
+        if self.model is None:
+            print("Create model failed !")
+            return
+
+        self.config = aidlite.Config.create_instance()
+        if self.config is None:
+            print("build_interpretper_from_model_and_config failed !")
+            return
+
+        self.config.implement_type = aidlite.ImplementType.TYPE_LOCAL
+        self.config.framework_type = aidlite.FrameworkType.TYPE_QNN
+        self.config.accelerate_type = aidlite.AccelerateType.TYPE_DSP
+        # self.config.accelerate_type = aidlite.AccelerateType.TYPE_CPU
+        self.config.is_quantify_model = 1
+        
+        self.interpreter = aidlite.InterpreterBuilder.build_interpretper_from_model_and_config(self.model, self.config)
+        if self.interpreter is None:
+            print("build_interpretper_from_model_and_config failed !")
+            return
+        input_shapes = [[1,256,256,3]]
+        output_shapes = [[1,256,256,1]]
+        self.model.set_model_properties(input_shapes, aidlite.DataType.TYPE_FLOAT32,
+                                output_shapes, aidlite.DataType.TYPE_FLOAT32)
+
+        if self.interpreter is None:
+            print("build_interpretper_from_model_and_config failed !")
+        result = self.interpreter.init()
+        if result != 0:
+            print(f"interpreter init failed !")
+        result = self.interpreter.load_model()
+        if result != 0:
+            print("interpreter load model failed !")
+   
+        print(" model load success!")
+
+    def __call__(self, input,invoke_nums):
+        self.interpreter.set_input_tensor(0,input)
+        invoke_time=[]
+        for i in range(invoke_nums):
+            result = self.interpreter.set_input_tensor(0, input.data)
+            if result != 0:
+                print("interpreter set_input_tensor() failed")
+            t1=time.time()
+            result = self.interpreter.invoke()
+            cost_time = (time.time()-t1)*1000
+            invoke_time.append(cost_time)
+
+        max_invoke_time = max(invoke_time)
+        min_invoke_time = min(invoke_time)
+        mean_invoke_time = sum(invoke_time)/invoke_nums
+        var_invoketime=np.var(invoke_time)
+        print("====================================")
+        print(f"QNN  invoke time:\n --mean_invoke_time is {mean_invoke_time} \n --max_invoke_time is {max_invoke_time} \n --min_invoke_time is {min_invoke_time} \n --var_invoketime is {var_invoketime}")
+        print("====================================")
+        features_0 = self.interpreter.get_output_tensor(0).reshape(1,256,256,1).transpose(0,3,1,2)
+        return features_0
+
+
+
+def run(args):
+    img_path = args.imgs
+    qnn_path = args.target_model
+    invoke_num=args.invoke_nums
+    print("Start processing...")
+    img_input,org_size = img_process(img_path)
+
+    qnn_model =run_qnn(qnn_path)
+    prediction_qnn = qnn_model(img_input.numpy().transpose(0,2,3,1),invoke_num)
+    prediction_qnn = torch.tensor(prediction_qnn)
+    qnn_process = out_process(prediction_qnn,org_size)
+
+    write_depth("./python/results.jpg", qnn_process, grayscale=False, bits=1)
+    write_pfm("./python/results.pfm", qnn_process.astype(np.float32))
+    print("Finished")
+
+def parser_args():
+    parser = argparse.ArgumentParser(description="Run model benchmarks")
+    parser.add_argument('--target_model',type=str,default='./models/midas_v2_w8a16.qnn216.ctx.bin',help="Inference model path")
+    parser.add_argument('--imgs',type=str,default='./python/dog.jpg',help="Predict images path")
+    parser.add_argument('--invoke_nums',type=int,default=10,help="Inference nums")
+    parser.add_argument('--model_type',type=str,default='QNN',help="Run backend")
+    args = parser.parse_args()
+    return args
+
+
+if __name__ =="__main__":
+    args = parser_args()
+    run(args)

model_farm_midas_v2_qcs8550_qnn2.16_w8a16_aidlite/python/transforms.py

@@ -0,0 +1,234 @@
+import numpy as np
+import cv2
+import math
+
+
+def apply_min_size(sample, size, image_interpolation_method=cv2.INTER_AREA):
+    """Rezise the sample to ensure the given size. Keeps aspect ratio.
+
+    Args:
+        sample (dict): sample
+        size (tuple): image size
+
+    Returns:
+        tuple: new size
+    """
+    shape = list(sample["disparity"].shape)
+
+    if shape[0] >= size[0] and shape[1] >= size[1]:
+        return sample
+
+    scale = [0, 0]
+    scale[0] = size[0] / shape[0]
+    scale[1] = size[1] / shape[1]
+
+    scale = max(scale)
+
+    shape[0] = math.ceil(scale * shape[0])
+    shape[1] = math.ceil(scale * shape[1])
+
+    # resize
+    sample["image"] = cv2.resize(
+        sample["image"], tuple(shape[::-1]), interpolation=image_interpolation_method
+    )
+
+    sample["disparity"] = cv2.resize(
+        sample["disparity"], tuple(shape[::-1]), interpolation=cv2.INTER_NEAREST
+    )
+    sample["mask"] = cv2.resize(
+        sample["mask"].astype(np.float32),
+        tuple(shape[::-1]),
+        interpolation=cv2.INTER_NEAREST,
+    )
+    sample["mask"] = sample["mask"].astype(bool)
+
+    return tuple(shape)
+
+
+class Resize(object):
+    """Resize sample to given size (width, height).
+    """
+
+    def __init__(
+        self,
+        width,
+        height,
+        resize_target=True,
+        keep_aspect_ratio=False,
+        ensure_multiple_of=1,
+        resize_method="lower_bound",
+        image_interpolation_method=cv2.INTER_AREA,
+    ):
+        """Init.
+
+        Args:
+            width (int): desired output width
+            height (int): desired output height
+            resize_target (bool, optional):
+                True: Resize the full sample (image, mask, target).
+                False: Resize image only.
+                Defaults to True.
+            keep_aspect_ratio (bool, optional):
+                True: Keep the aspect ratio of the input sample.
+                Output sample might not have the given width and height, and
+                resize behaviour depends on the parameter 'resize_method'.
+                Defaults to False.
+            ensure_multiple_of (int, optional):
+                Output width and height is constrained to be multiple of this parameter.
+                Defaults to 1.
+            resize_method (str, optional):
+                "lower_bound": Output will be at least as large as the given size.
+                "upper_bound": Output will be at max as large as the given size. (Output size might be smaller than given size.)
+                "minimal": Scale as least as possible.  (Output size might be smaller than given size.)
+                Defaults to "lower_bound".
+        """
+        self.__width = width
+        self.__height = height
+
+        self.__resize_target = resize_target
+        self.__keep_aspect_ratio = keep_aspect_ratio
+        self.__multiple_of = ensure_multiple_of
+        self.__resize_method = resize_method
+        self.__image_interpolation_method = image_interpolation_method
+
+    def constrain_to_multiple_of(self, x, min_val=0, max_val=None):
+        y = (np.round(x / self.__multiple_of) * self.__multiple_of).astype(int)
+
+        if max_val is not None and y > max_val:
+            y = (np.floor(x / self.__multiple_of) * self.__multiple_of).astype(int)
+
+        if y < min_val:
+            y = (np.ceil(x / self.__multiple_of) * self.__multiple_of).astype(int)
+
+        return y
+
+    def get_size(self, width, height):
+        # determine new height and width
+        scale_height = self.__height / height
+        scale_width = self.__width / width
+
+        if self.__keep_aspect_ratio:
+            if self.__resize_method == "lower_bound":
+                # scale such that output size is lower bound
+                if scale_width > scale_height:
+                    # fit width
+                    scale_height = scale_width
+                else:
+                    # fit height
+                    scale_width = scale_height
+            elif self.__resize_method == "upper_bound":
+                # scale such that output size is upper bound
+                if scale_width < scale_height:
+                    # fit width
+                    scale_height = scale_width
+                else:
+                    # fit height
+                    scale_width = scale_height
+            elif self.__resize_method == "minimal":
+                # scale as least as possbile
+                if abs(1 - scale_width) < abs(1 - scale_height):
+                    # fit width
+                    scale_height = scale_width
+                else:
+                    # fit height
+                    scale_width = scale_height
+            else:
+                raise ValueError(
+                    f"resize_method {self.__resize_method} not implemented"
+                )
+
+        if self.__resize_method == "lower_bound":
+            new_height = self.constrain_to_multiple_of(
+                scale_height * height, min_val=self.__height
+            )
+            new_width = self.constrain_to_multiple_of(
+                scale_width * width, min_val=self.__width
+            )
+        elif self.__resize_method == "upper_bound":
+            new_height = self.constrain_to_multiple_of(
+                scale_height * height, max_val=self.__height
+            )
+            new_width = self.constrain_to_multiple_of(
+                scale_width * width, max_val=self.__width
+            )
+        elif self.__resize_method == "minimal":
+            new_height = self.constrain_to_multiple_of(scale_height * height)
+            new_width = self.constrain_to_multiple_of(scale_width * width)
+        else:
+            raise ValueError(f"resize_method {self.__resize_method} not implemented")
+
+        return (new_width, new_height)
+
+    def __call__(self, sample):
+        width, height = self.get_size(
+            sample["image"].shape[1], sample["image"].shape[0]
+        )
+
+        # resize sample
+        sample["image"] = cv2.resize(
+            sample["image"],
+            (width, height),
+            interpolation=self.__image_interpolation_method,
+        )
+
+        if self.__resize_target:
+            if "disparity" in sample:
+                sample["disparity"] = cv2.resize(
+                    sample["disparity"],
+                    (width, height),
+                    interpolation=cv2.INTER_NEAREST,
+                )
+
+            if "depth" in sample:
+                sample["depth"] = cv2.resize(
+                    sample["depth"], (width, height), interpolation=cv2.INTER_NEAREST
+                )
+
+            sample["mask"] = cv2.resize(
+                sample["mask"].astype(np.float32),
+                (width, height),
+                interpolation=cv2.INTER_NEAREST,
+            )
+            sample["mask"] = sample["mask"].astype(bool)
+
+        return sample
+
+
+class NormalizeImage(object):
+    """Normlize image by given mean and std.
+    """
+
+    def __init__(self, mean, std):
+        self.__mean = mean
+        self.__std = std
+
+    def __call__(self, sample):
+        sample["image"] = (sample["image"] - self.__mean) / self.__std
+
+        return sample
+
+
+class PrepareForNet(object):
+    """Prepare sample for usage as network input.
+    """
+
+    def __init__(self):
+        pass
+
+    def __call__(self, sample):
+        image = np.transpose(sample["image"], (2, 0, 1))
+        sample["image"] = np.ascontiguousarray(image).astype(np.float32)
+
+        if "mask" in sample:
+            sample["mask"] = sample["mask"].astype(np.float32)
+            sample["mask"] = np.ascontiguousarray(sample["mask"])
+
+        if "disparity" in sample:
+            disparity = sample["disparity"].astype(np.float32)
+            sample["disparity"] = np.ascontiguousarray(disparity)
+
+        if "depth" in sample:
+            depth = sample["depth"].astype(np.float32)
+            sample["depth"] = np.ascontiguousarray(depth)
+
+        return sample

model_farm_midas_v2_qcs8550_qnn2.16_w8a16_aidlite/python/utils.py

@@ -0,0 +1,104 @@
+import numpy as np
+import torch
+import cv2
+import os
+
+from transforms import Resize, NormalizeImage, PrepareForNet
+
+from torchvision.transforms import Compose
+import sys
+first_execution = True
+def img_process(img_path):
+    global first_execution
+    first_execution = False
+    net_w, net_h = 256, 256
+    resize_mode = "upper_bound"
+    normalization = NormalizeImage(
+        mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]
+    )
+    transform = Compose(
+        [
+            Resize(
+                net_w,
+                net_h,
+                resize_target=None,
+                keep_aspect_ratio=False,
+                ensure_multiple_of=32,
+                resize_method=resize_mode,
+                image_interpolation_method=cv2.INTER_CUBIC,
+            ),
+            normalization,
+            PrepareForNet(),
+        ]
+    )
+    # image = utils.read_image(img_path)  # in [0, 1]
+    image = cv2.imread(img_path)
+    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) / 255.0
+    org_size=  image.shape[:2]
+    image = transform({"image": image})["image"]
+    sample = torch.from_numpy(image).to("cpu").unsqueeze(0)
+    height, width = sample.shape[2:]
+    print(f"Input resized to {width}x{height} before entering the encoder")
+
+    return sample,org_size
+
+
+
+def write_depth(path, depth, grayscale=False, bits=1):
+    if not grayscale:
+        bits = 1
+
+    if not np.isfinite(depth).all():
+        depth=np.nan_to_num(depth, nan=0.0, posinf=0.0, neginf=0.0)
+        print("WARNING: Non-finite depth values present")
+
+    depth_min = depth.min()
+    depth_max = depth.max()
+
+    max_val = (2**(8*bits))-1
+
+    if depth_max - depth_min > np.finfo("float").eps:
+        out = max_val * (depth - depth_min) / (depth_max - depth_min)
+    else:
+        out = np.zeros(depth.shape, dtype=depth.dtype)
+
+    # print("out :",out.shape,out)
+    if not grayscale:
+        out = cv2.applyColorMap(np.uint8(out), cv2.COLORMAP_INFERNO)
+
+    if bits == 1:
+        cv2.imwrite(path , out.astype("uint8"))
+    elif bits == 2:
+        cv2.imwrite(path , out.astype("uint16"))
+
+    return
+
+def write_pfm(path, image, scale=1):
+    with open(path, "wb") as file:
+        color = None
+
+        if image.dtype.name != "float32":
+            raise Exception("Image dtype must be float32.")
+
+        image = np.flipud(image)
+
+        if len(image.shape) == 3 and image.shape[2] == 3:  # color image
+            color = True
+        elif (
+            len(image.shape) == 2 or len(image.shape) == 3 and image.shape[2] == 1
+        ):  # greyscale
+            color = False
+        else:
+            raise Exception("Image must have H x W x 3, H x W x 1 or H x W dimensions.")
+
+        file.write("PF\n" if color else "Pf\n".encode())
+        file.write("%d %d\n".encode() % (image.shape[1], image.shape[0]))
+
+        endian = image.dtype.byteorder
+
+        if endian == "<" or endian == "=" and sys.byteorder == "little":
+            scale = -scale
+
+        file.write("%f\n".encode() % scale)
+
+        image.tofile(file)