Upload 32 files

.gitattributes

@@ -33,3 +33,11 @@ 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_yolov8s_seg_qsc6490_qnn2.16_int8_aidlite/cpp/bus.jpg filter=lfs diff=lfs merge=lfs -text
+model_farm_yolov8s_seg_qsc6490_qnn2.16_int8_aidlite/python/bus.jpg filter=lfs diff=lfs merge=lfs -text
+model_farm_yolov8s_seg_qsc8550_qnn2.16_fp16_aidlite/cpp/bus.jpg filter=lfs diff=lfs merge=lfs -text
+model_farm_yolov8s_seg_qsc8550_qnn2.16_fp16_aidlite/python/bus.jpg filter=lfs diff=lfs merge=lfs -text
+model_farm_yolov8s_seg_qsc8550_qnn2.16_int16_aidlite/cpp/bus.jpg filter=lfs diff=lfs merge=lfs -text
+model_farm_yolov8s_seg_qsc8550_qnn2.16_int16_aidlite/python/bus.jpg filter=lfs diff=lfs merge=lfs -text
+model_farm_yolov8s_seg_qsc8550_qnn2.16_int8_aidlite/cpp/bus.jpg filter=lfs diff=lfs merge=lfs -text
+model_farm_yolov8s_seg_qsc8550_qnn2.16_int8_aidlite/python/bus.jpg filter=lfs diff=lfs merge=lfs -text

model_farm_yolov8s_seg_qsc6490_qnn2.16_int8_aidlite/README.md

@@ -0,0 +1,56 @@
+## Model Information
+## Source model
+- Input shape: 640x640
+- Number of parameters: 11.27M
+- Model size: 45.22M
+- Output shape: 1x32x160x160, 1x116x8400
+
+Source model repository: [yolov8](https://github.com/ultralytics/ultralytics)
+
+### 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 yolov8s_seg/model_farm_yolov8s_seg_qsc6490_qnn2.16_int8_aidlite
+python3 ./python/run_test.py --target_model ./models/cutoff_yolov8s-seg_w8a8.qnn216.ctx.bin --imgs ./python/bus.jpg  --invoke_nums 10
+```
+
+#### cpp
+```bash
+cd yolov8s_seg/model_farm_yolov5s_qcs6490_qnn2.16_int8_aidlite/cpp
+mkdir build && cd build 
+cmake ..
+make
+./run_test
+```
+

model_farm_yolov8s_seg_qsc6490_qnn2.16_int8_aidlite/cpp/CMakeLists.txt

@@ -0,0 +1,31 @@
+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
+)

model_farm_yolov8s_seg_qsc6490_qnn2.16_int8_aidlite/cpp/run_test.cpp

@@ -0,0 +1,485 @@
+#include <iostream>
+#include <string>
+#include <algorithm>
+#include <cctype>
+#include <cstring> // 用于 memcpy
+#include <opencv2/opencv.hpp>
+#include <aidlux/aidlite/aidlite.hpp>
+#include <vector>
+#include <numeric>
+
+const float INPUT_WIDTH = 640.0;
+const float INPUT_HEIGHT = 640.0;
+const float SCORE_THRESHOLD = 0.25;
+const float NMS_THRESHOLD = 0.45;
+const float CONFIDENCE_THRESHOLD = 0.25;
+const uint32_t size = 640;
+const uint32_t out_size = 8400;
+
+const int FONT_FACE = cv::FONT_HERSHEY_SIMPLEX;
+cv::Scalar WHITE = cv::Scalar(255,255,255);
+
+const float FONT_SCALE = 0.75;
+const int THICKNESS = 1;
+
+const std::vector<std::string> class_list = {
+    "person", "bicycle", "car", "motorcycle", "airplane", "bus", "train",
+    "truck", "boat", "traffic light", "fire hydrant", "stop sign", "parking meter",
+    "bench", "bird", "cat", "dog", "horse", "sheep", "cow", "elephant", "bear",
+    "zebra", "giraffe", "backpack", "umbrella", "handbag", "tie", "suitcase",
+    "frisbee", "skis", "snowboard", "sports ball", "kite", "baseball bat",
+    "baseball glove", "skateboard", "surfboard", "tennis racket", "bottle",
+    "wine glass", "cup", "fork", "knife", "spoon", "bowl", "banana", "apple",
+    "sandwich", "orange", "broccoli", "carrot", "hot dog", "pizza", "donut",
+    "cake", "chair", "couch", "potted plant", "bed", "dining table", "toilet",
+    "TV", "laptop", "mouse", "remote", "keyboard", "cell phone", "microwave",
+    "oven", "toaster", "sink", "refrigerator", "book", "clock", "vase",
+    "scissors", "teddy bear", "hair drier", "toothbrush"
+};
+
+using namespace cv;
+using namespace std;
+using namespace Aidlux::Aidlite;
+
+struct Args {
+    std::string target_model = "../../models/cutoff_yolov8s-seg_w8a8.qnn216.ctx.bin";
+    std::string imgs = "../bus.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;
+}
+
+// concatenate_3(80_class_data, 4_pos_data , 32_canc_data, 1, 8400, 80, 4,32, qnn_concat);
+void concatenate_3(float* qnn_trans_data, float* qnn_mul_data, float* qnn_canc_data, int batch, int num_elements, int trans_dim, int mul_dim, int canc_dim,std::vector<float>& output) {
+    // int out_dim = trans_dim + mul_dim + canc_dim + 1; //117
+    int out_dim = trans_dim + mul_dim + canc_dim; //116
+    output.resize(batch * num_elements * out_dim); 
+    for (int i = 0; i < batch * num_elements; ++i) {
+        std::memcpy(&output[i * out_dim], &qnn_mul_data[i * mul_dim], mul_dim * sizeof(float));
+        std::memcpy(&output[i * out_dim + mul_dim], &qnn_trans_data[i * trans_dim], trans_dim * sizeof(float));
+        std::memcpy(&output[i * out_dim + mul_dim + trans_dim], &qnn_canc_data[i * canc_dim], canc_dim * sizeof(float));
+    }
+}
+
+// 4*8400
+void transformData(const float* input, float* output, int C, int N) {
+    for (int c = 0; c < C; ++c) {
+        for (int n = 0; n < N; ++n) {
+            output[n * C + c] = input[c * N + n];
+        }
+    }
+}
+
+double img_process(cv::Mat frame, cv::Mat &img_input, int size) {
+    cv::Mat img_processed = frame.clone();
+    int height = img_processed.rows;
+    int width = img_processed.cols;
+    int length = std::max(height, width);
+    double scala = static_cast<double>(length) / size;
+    
+    cv::Mat image = cv::Mat::zeros(cv::Size(length, length), CV_8UC3);
+    img_processed.copyTo(image(cv::Rect(0, 0, width, height)));
+    
+    cv::cvtColor(image, img_input, cv::COLOR_BGR2RGB);
+    cv::resize(img_input, img_input, cv::Size(size, size));
+    
+    cv::Mat mean_data = cv::Mat::zeros(img_input.size(), CV_32FC3);
+    cv::Mat std_data(img_input.size(), CV_32FC3, cv::Scalar(255, 255, 255));
+    img_input.convertTo(img_input, CV_32FC3);
+    img_input = (img_input - mean_data) / std_data;
+    return scala;
+}
+
+
+cv::Scalar generate_colors(int i, bool bgr = false) {
+    static const std::vector<std::string> hex_colors = {
+        "FF3838", "FF9D97", "FF701F", "FFB21D", "CFD231", "48F90A",
+        "92CC17", "3DDB86", "1A9334", "00D4BB", "2C99A8", "00C2FF",
+        "344593", "6473FF", "0018EC", "8438FF", "520085", "CB38FF",
+        "FF95C8", "FF37C7"
+    };
+
+    int num = hex_colors.size();
+    std::string hex = hex_colors[i % num];
+
+    int r = std::stoi(hex.substr(0, 2), nullptr, 16);
+    int g = std::stoi(hex.substr(2, 2), nullptr, 16);
+    int b = std::stoi(hex.substr(4, 2), nullptr, 16);
+
+    if (bgr)
+        return cv::Scalar(b, g, r);
+    else
+        return cv::Scalar(r, g, b);
+}
+
+float sigmoid_function(float a)
+{
+    float b = 1. / (1. + exp(-a));
+    return b;
+}
+
+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;
+}
+
+
+void draw_label(cv::Mat& input_image, std::string label, int left, int top, cv::Scalar color)
+{
+    int baseLine;
+    cv::Size label_size = cv::getTextSize(label, FONT_FACE, FONT_SCALE, THICKNESS, &baseLine);
+    int y = top - label_size.height - baseLine;
+    if (y < 0) {
+        y = top ;
+    }
+    cv::Point tlc(left, y);
+    cv::Point brc(left + label_size.width, y + label_size.height + baseLine);
+    rectangle(input_image, tlc, brc, color, cv::FILLED);
+    putText(input_image, label, cv::Point(left, y + label_size.height), FONT_FACE, FONT_SCALE, WHITE, THICKNESS);
+}
+
+
+cv::Mat post_process(cv::Mat &frame, std::vector<float> &outputs, const std::vector<std::string> &class_name, 
+    const double ratio, float* protos_data, float* qnn_canc)
+{
+    cv::Mat input_image = frame.clone();
+    // Initialize vectors to hold respective outputs while unwrapping detections.
+    std::vector<int> class_ids;
+    std::vector<float> confidences;
+    std::vector<cv::Rect> boxes;
+    std::vector<cv::Mat> masks;
+    std::vector<float> class_scores;
+    cv::RNG rng;
+    cv::Mat masked_img;
+
+    unsigned int src_dims[4] = {1, 32,160,160};
+    unsigned int tsp_dims[4] = {0,3,1,2};
+    unsigned int stride_data_num = 1*32*160*160;
+    float* format_data = new float[stride_data_num];
+    transpose(protos_data, src_dims, tsp_dims, format_data);
+    cv::Mat proto_buffer(32, 160*160, CV_32F, format_data);
+    std::cout << "proto_buffer 维度: " << proto_buffer.rows << "x" << proto_buffer.cols << std::endl;
+
+    for (int i = 0; i < outputs.size(); i+=116)
+    {
+        auto start = outputs.begin() + i + 4;
+        auto end = outputs.begin() + i + 84;
+        float max_val = *std::max_element(start, end);
+        float confidence = max_val;
+        if (confidence >= CONFIDENCE_THRESHOLD)
+        {
+            auto start = outputs.begin() + i + 4;
+            auto end = outputs.begin() + i + 84;
+            std::vector<float> middle_data;
+            middle_data.assign(start, end);
+            // Create a 1x80 Mat and store class scores of 80 classes.
+            cv::Mat scores(1, class_name.size(), CV_32FC1, middle_data.data());
+            cv::Point class_id;
+            double max_class_score;
+            
+            // For multi-label, check each class score
+            for (int c = 0; c < class_name.size(); c++) {
+                float class_score = scores.at<float>(0, c);
+                // If class score is above threshold, consider this class for the box
+                if (class_score > SCORE_THRESHOLD) {
+                    std::vector<float> last32_data;
+                    auto st_32= outputs.begin() + i + 84;
+                    auto ed_32 = outputs.begin() + i + 116;
+                    last32_data.assign(st_32, ed_32);
+                    cv::Mat mask(1, 32, CV_32FC1, last32_data.data());
+                    // Store class ID and confidence in the pre-defined respective vectors.
+                    confidences.push_back(confidence * class_score);  // Multiply with confidence
+                    class_ids.push_back(c);  // class index
+                    // Center and box dimension.
+                    float cx = outputs[i];
+                    float cy = outputs[i+1];
+                    float w = outputs[i+2];
+                    float h = outputs[i+3];
+
+                    int left = int((cx - 0.5 * w) * ratio);
+                    int top = int((cy - 0.48 * h) * ratio);
+                    int width = int(w * ratio);
+                    int height = int(h * ratio);
+
+                    // Store good detections in the boxes vector.
+                    boxes.push_back(cv::Rect(left, top, width, height));
+                    masks.push_back(mask);
+                }
+            }
+        }
+    }
+
+    std::cout << "boxes.size(): " << boxes.size() << ",confidences.size():" << confidences.size() << std::endl; 
+
+    // Perform Non Maximum Suppression and draw predictions.
+    std::vector<int> indices;
+    cv::dnn::NMSBoxes(boxes, confidences, SCORE_THRESHOLD, NMS_THRESHOLD, indices);
+    printf("Detected {%ld} targets.\n", indices.size());
+    cv::Mat rgb_mask = cv::Mat::zeros(input_image.size(), input_image.type());
+    
+    // Loop over NMS results and draw bounding boxes
+    for (int i = 0; i < indices.size(); i++)
+    {
+        int idx = indices[i];
+        cv::Rect box = boxes[idx];
+        cv::Scalar color = generate_colors(class_ids[idx]);
+
+        int x1 = std::max(0, box.x);
+        int y1 = std::max(0, box.y);
+        int x2 = std::max(0, box.br().x);
+        int y2 = std::max(0, box.br().y);
+        cv::Mat ms = masks[idx];
+        // 维度验证
+        if (ms.cols != proto_buffer.rows) {
+            cerr << "维度不匹配: mask.cols=" << ms.cols 
+                 << ", proto_buffer.rows=" << proto_buffer.rows << endl;
+            continue;
+        }
+        cv::Mat m = ms * proto_buffer;
+        for (int col = 0; col < m.cols; col++) {
+            m.at<float>(0, col) = sigmoid_function(m.at<float>(0, col));
+        }
+        cv::Mat m1 = m.reshape(1, 160); // 1x25600 -> 160x160
+
+        float ratio2 = 160.0/640.0;
+        int mx1 = std::max(0, int((x1 * ratio2)));
+        int mx2 = std::max(0, int((x2 * ratio2)));
+        int my1 = std::max(0, int((y1 * ratio2)));
+        int my2 = std::max(0, int((y2 * ratio2)));
+        cv::Mat mask_roi = m1(cv::Range(my1, my2), cv::Range(mx1, mx2));
+        cv::Mat rm, det_mask;
+        cv::resize(mask_roi, rm, cv::Size(x2 - x1, y2 - y1));
+        for (int r = 0; r < rm.rows; r++) {
+            for (int c = 0; c < rm.cols; c++) {
+                float pv = rm.at<float>(r, c);
+                if (pv > 0.5) {
+                    rm.at<float>(r, c) = 1.0;
+                }
+                else {
+                    rm.at<float>(r, c) = 0.0;
+                }
+            }
+        }
+        rm = rm * rng.uniform(0, 255);
+        rm.convertTo(det_mask, CV_8UC1);
+        if ((y1 + det_mask.rows) >= input_image.rows) {
+            y2 = input_image.rows - 1;
+        }
+        if ((x1 + det_mask.cols) >= input_image.cols) {
+            x2 = input_image.cols - 1;
+        }
+
+        cv::Mat mask = cv::Mat::zeros(cv::Size(input_image.cols, input_image.rows), CV_8UC1);
+        det_mask(cv::Range(0, y2 - y1), cv::Range(0, x2 - x1)).copyTo(mask(cv::Range(y1, y2), cv::Range(x1, x2)));
+        add(rgb_mask, cv::Scalar(rng.uniform(0, 255), rng.uniform(0, 255), rng.uniform(0, 255)), rgb_mask, mask);
+        if (input_image.size() != rgb_mask.size()) {
+            cv::resize(rgb_mask, rgb_mask, input_image.size());
+        }
+
+        cv::rectangle(input_image, boxes[idx], color, 2, 8);
+        std::string label = cv::format("%.2f", confidences[idx]);
+        label = class_name[class_ids[idx]] + ":" + label;
+        cv::putText(input_image, label, cv::Point(boxes[idx].tl().x, boxes[idx].tl().y - 10), cv::FONT_HERSHEY_SIMPLEX, .5, color);
+        cv::addWeighted(input_image, 0.5, rgb_mask, 0.5, 0, masked_img);
+
+    }
+    printf("Processing finished.\n");
+    return masked_img;
+}
+
+
+
+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_QNN216;
+    } 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;
+
+    std::vector<std::vector<uint32_t>> input_shapes = {{1, size, size, 3}};
+    std::vector<std::vector<uint32_t>> output_shapes = {{1,32,8400},{1,4,8400},{1,80,8400},{1,160, 160,32}};
+    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_img;
+    double scale = img_process(frame, input_img, size);
+    if (input_img.empty()) {
+        printf("detect input_img load failed!\n");
+        return 1;
+    }
+
+    float *qnn_seg_data = nullptr;
+    float *qnn_trans_data = nullptr;
+    float *qnn_mul_data = nullptr;
+    float *qnn_canc_data = nullptr;
+
+    std::vector<float> invoke_time;
+    for (int i = 0; i < args.invoke_nums; ++i) {
+        result = fast_interpreter->set_input_tensor(0, input_img.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_1 = 0;
+        result = fast_interpreter->get_output_tensor(1, (void**)&qnn_canc_data, &out_data_1);
+        if(result != EXIT_SUCCESS){
+            printf("interpreter->get_output_tensor() 1 failed !\n");
+            return EXIT_FAILURE;
+        }
+
+        uint32_t out_data_4 = 0;
+        result = fast_interpreter->get_output_tensor(2, (void**)&qnn_trans_data, &out_data_4);
+        if(result != EXIT_SUCCESS){
+            printf("interpreter->get_output_tensor() 2 failed !\n");
+            return EXIT_FAILURE;
+        }
+
+        uint32_t out_data_2 = 0;
+        result = fast_interpreter->get_output_tensor(0, (void**)&qnn_seg_data, &out_data_2);
+        if(result != EXIT_SUCCESS){
+            printf("interpreter->get_output_tensor() 2 failed !\n");
+            return EXIT_FAILURE;
+        }
+
+        uint32_t out_data_80 = 0;
+        result = fast_interpreter->get_output_tensor(3, (void**)&qnn_mul_data, &out_data_80);
+        if(result != EXIT_SUCCESS){
+            printf("interpreter->get_output_tensor() 2 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");
+
+    float* pos_data = new float[4 * out_size];
+    float* class_data = new float[80 * out_size];
+    float* canc_data = new float[32 * out_size];
+    transformData(qnn_trans_data, pos_data, 4, out_size);
+    transformData(qnn_mul_data, class_data, 80, out_size);
+    transformData(qnn_canc_data, canc_data, 32, out_size);
+    
+    // post process
+    std::vector<float> qnn_concat;
+    concatenate_3(class_data, pos_data, canc_data , 1, out_size, 80, 4, 32, qnn_concat);
+    cv::Mat img = post_process(frame, qnn_concat, class_list, scale, qnn_seg_data, qnn_canc_data);
+    cv::imwrite("./results.png", img);
+    fast_interpreter->destory();
+    return 0;
+}
+
+
+int main(int argc, char* argv[]) {
+    Args args = parse_args(argc, argv);
+    return invoke(args);
+}

model_farm_yolov8s_seg_qsc6490_qnn2.16_int8_aidlite/models/cutoff_yolov8s-seg_w8a8.qnn216.ctx.bin

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

model_farm_yolov8s_seg_qsc6490_qnn2.16_int8_aidlite/python/run_test.py

@@ -0,0 +1,134 @@
+import numpy as np
+import cv2
+import aidlite
+from utils import eqprocess, xywh2xyxy, NMS, process_mask, masks2segments, draw_detect_res
+import os
+import time
+import argparse
+import onnxruntime
+
+# 定义相似度函数
+def get_acc(onnx_out,other_out):
+    cosine_similarity=np.dot(np.array(onnx_out),np.array(other_out))/(np.linalg.norm(np.array(onnx_out)) * np.linalg.norm(np.array(other_out)))
+    return cosine_similarity
+
+
+class qnn_predict(object):
+    def __init__(self,args) -> None:
+        # aidlite.set_log_level(aidlite.LogLevel.INFO)
+        # aidlite.log_to_stderr()
+        # print(f"Aidlite library version : {aidlite.get_library_version()}")
+        # print(f"Aidlite python library version : {aidlite.get_py_library_version()}")
+        config = aidlite.Config.create_instance()
+        if config is None:
+            print("Create model failed !")
+        config.implement_type = aidlite.ImplementType.TYPE_LOCAL
+        config.framework_type = aidlite.FrameworkType.TYPE_QNN
+        config.accelerate_type = aidlite.AccelerateType.TYPE_DSP
+        config.is_quantify_model = 1
+
+        model = aidlite.Model.create_instance(args.target_model)
+        if model is None:
+            print("Create model failed !")
+
+        self.conf = args.conf_thres
+        self.iou=args.iou_thres
+        self.width = args.width
+        self.height = args.height
+        self.class_num = args.class_num
+        self.input_shape = [[1,self.height,self.width,3]]
+        self.blocks = int(self.height * self.width * ( 1 / 64 + 1 / 256 + 1 / 1024))
+        self.maskw = int(self.width / 4)
+        self.maskh = int(self.height / 4)
+        self.output_shape = [[1,32,self.blocks],[1,4,self.blocks],[1,self.class_num,self.blocks],[1,self.maskh, self.maskw,32]]
+        
+        model.set_model_properties(self.input_shape, aidlite.DataType.TYPE_FLOAT32, self.output_shape, aidlite.DataType.TYPE_FLOAT32)
+        self.interpreter = aidlite.InterpreterBuilder.build_interpretper_from_model_and_config(model, config)
+        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("detect model load success!")
+
+    def pretreat_img(self,frame): 
+        img, scale = eqprocess(frame, self.height, self.width)
+        img = img / 255
+        img = img.astype(np.float32)
+        return img,scale
+    
+    def qnn_run(self, orig_imgs,args):
+        input_img_f,scale=self.pretreat_img(orig_imgs)  # 图片resize HWC
+        input_img = np.expand_dims(input_img_f, 0)
+      
+        invoke_time=[]
+        for i in range(args.invoke_nums):
+            self.interpreter.set_input_tensor(0, input_img.data)
+            t0 = time.time()
+            self.interpreter.invoke()
+            t1 = time.time()
+            cost_time=(t1-t0)*1000
+            invoke_time.append(cost_time)
+
+            input0_data = self.interpreter.get_output_tensor(2).reshape(1,4,self.blocks)
+            input1_data = self.interpreter.get_output_tensor(3).reshape(1,self.class_num,self.blocks)
+            input2_data = self.interpreter.get_output_tensor(1).reshape(1,32,self.blocks)
+            protos = self.interpreter.get_output_tensor(0).reshape(1,self.maskh, self.maskw,32).transpose(0,3,1,2)
+
+            boxes = np.concatenate([input0_data, input1_data, input2_data], axis = 1)
+            x = boxes.transpose(0,2,1)
+            x = x[np.amax(x[..., 4:-32], axis=-1) > self.conf]
+            if len(x) < 1:
+                return None, None
+        
+            x = np.c_[x[..., :4], np.amax(x[..., 4:-32], axis=-1), np.argmax(x[..., 4:-32], axis=-1), x[..., -32:]]
+            
+            x[:, :4] = xywh2xyxy(x[:, :4])
+            index = NMS(x[:, :4], x[:, 4], self.iou)
+            out_boxes = x[index]
+            out_boxes[..., :4] = out_boxes[..., :4] * scale
+            
+            masks = process_mask(protos[0], out_boxes[:, -32:], out_boxes[:, :4], orig_imgs.shape)
+            segments = masks2segments(masks)
+           
+        ## time 统计
+        max_invoke_time = max(invoke_time)
+        min_invoke_time = min(invoke_time)
+        mean_invoke_time = sum(invoke_time)/args.invoke_nums
+        var_invoketime=np.var(invoke_time)
+        print("========================================")
+        print(f"QNN inference {args.invoke_nums} times :\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("========================================")
+
+        return out_boxes, segments
+       
+
+def parser_args():
+    parser = argparse.ArgumentParser(description="Run model benchmarks")
+    parser.add_argument('--target_model',type=str,default='/home/aidlux/modelfarm/yolov8s_seg/model_farm_yolov8s_seg_qsc6490_qnn2.16_int8_aidlite/models/cutoff_yolov8s-seg_w8a8.qnn216.ctx.bin',help="inference model path")
+    parser.add_argument('--imgs',type=str,default='/home/aidlux/modelfarm/yolov8s_seg/model_farm_yolov8s_seg_qsc6490_qnn2.16_int8_aidlite/python/bus.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")
+    parser.add_argument('--width',type=int,default=640,help="Model input size")
+    parser.add_argument('--height',type=int,default=640,help="Model input size")
+    parser.add_argument('--conf_thres',type=float,default=0.45,help="confidence threshold for filtering the annotations")
+    parser.add_argument('--iou_thres',type=float,default=0.45,help="Iou threshold for filtering the annotations")
+    parser.add_argument('--class_num',type=int,default=80,help="Iou threshold for filtering the annotations")
+    args = parser.parse_args()
+    return args
+
+def main(args):
+    model = qnn_predict(args)
+    frame = cv2.imread(args.imgs)
+    qnn_out_boxes, qnn_segments = model.qnn_run(frame,args)
+    result = draw_detect_res(frame, qnn_out_boxes, qnn_segments)
+    cv2.imwrite("./bus_result.jpg", result)
+
+if __name__ == "__main__":
+    args = parser_args()
+    main(args)
+
+

model_farm_yolov8s_seg_qsc6490_qnn2.16_int8_aidlite/python/utils.py

@@ -0,0 +1,124 @@
+import numpy as np
+import cv2
+
+CLASSES = ("person", "bicycle", "car", "motorbike ", "aeroplane ", "bus ", "train", "truck ", "boat", "traffic light",
+           "fire hydrant", "stop sign ", "parking meter", "bench", "bird", "cat", "dog ", "horse ", "sheep", "cow", "elephant",
+           "bear", "zebra ", "giraffe", "backpack", "umbrella", "handbag", "tie", "suitcase", "frisbee", "skis", "snowboard", "sports ball", "kite",
+           "baseball bat", "baseball glove", "skateboard", "surfboard", "tennis racket", "bottle", "wine glass", "cup", "fork", "knife ",
+           "spoon", "bowl", "banana", "apple", "sandwich", "orange", "broccoli", "carrot", "hot dog", "pizza ", "donut", "cake", "chair", "sofa",
+           "pottedplant", "bed", "diningtable", "toilet ", "tvmonitor", "laptop	", "mouse	", "remote ", "keyboard ", "cell phone", "microwave ",
+           "oven ", "toaster", "sink", "refrigerator ", "book", "clock", "vase", "scissors ", "teddy bear ", "hair drier", "toothbrush ")
+           
+def eqprocess(image, size1, size2):
+    h,w,_ = image.shape
+    mask = np.zeros((size1,size2,3),dtype=np.float32)
+    scale1 = h /size1
+    scale2 = w / size2
+    if scale1 > scale2:
+        scale = scale1
+    else:
+        scale = scale2
+    img = cv2.resize(image,(int(w / scale),int(h / scale)))
+    mask[:int(h / scale),:int(w / scale),:] = img
+    return mask, scale
+
+def xywh2xyxy(x):
+    '''
+    Box (center x, center y, width, height) to (x1, y1, x2, y2)
+    '''
+    y = np.copy(x)
+    y[:, 0] = x[:, 0] - x[:, 2] / 2  # top left x
+    y[:, 1] = x[:, 1] - x[:, 3] / 2  # top left y
+    y[:, 2] = x[:, 0] + x[:, 2] / 2  # bottom right x
+    y[:, 3] = x[:, 1] + x[:, 3] / 2  # bottom right y
+    return y
+
+def xyxy2xywh(box):
+    '''
+    Box (left_top x, left_top y, right_bottom x, right_bottom y) to (left_top x, left_top y, width, height)
+    '''
+    box[:, 2:] = box[:, 2:] - box[:, :2]
+    return box
+
+def NMS(dets, scores, thresh):
+    '''
+    单类NMS算法
+    dets.shape = (N, 5), (left_top x, left_top y, right_bottom x, right_bottom y, Scores)
+    '''
+    x1 = dets[:,0]
+    y1 = dets[:,1]
+    x2 = dets[:,2]
+    y2 = dets[:,3]
+    areas = (y2-y1+1) * (x2-x1+1)
+    keep = []
+    index = scores.argsort()[::-1]
+    while index.size >0:
+        i = index[0]       # every time the first is the biggst, and add it directly
+        keep.append(i)
+        x11 = np.maximum(x1[i], x1[index[1:]])    # calculate the points of overlap 
+        y11 = np.maximum(y1[i], y1[index[1:]])
+        x22 = np.minimum(x2[i], x2[index[1:]])
+        y22 = np.minimum(y2[i], y2[index[1:]])
+        w = np.maximum(0, x22-x11+1)    # the weights of overlap
+        h = np.maximum(0, y22-y11+1)    # the height of overlap
+        overlaps = w*h
+        ious = overlaps / (areas[i]+areas[index[1:]] - overlaps)
+        idx = np.where(ious<=thresh)[0]
+        index = index[idx+1]   # because index start from 1
+ 
+    return keep
+
+def draw_detect_res(img, det_pred, segments):
+    '''
+    检测结果绘制
+    '''
+    if det_pred is None:
+        return img
+
+    img = img.astype(np.uint8)
+    im_canvas = img.copy()
+    color_step = int(255/len(CLASSES))
+    for i in range(len(det_pred)):
+        x1, y1, x2, y2 = [int(t) for t in det_pred[i][:4]]
+        cls_id = int(det_pred[i][5])
+        cv2.putText(img, f'{CLASSES[cls_id]}', (x1, y1-6), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1)
+        cv2.rectangle(img, (x1, y1), (x2, y2), (0, int(cls_id*color_step), int(255-cls_id*color_step)),thickness = 2)
+        if len(segments[i]) > 0:
+            cv2.polylines(img, np.int32([segments[i]]), True, (0, int(cls_id*color_step), int(255-cls_id*color_step)), 2)
+            cv2.fillPoly(img, np.int32([segments[i]]), (0, int(cls_id*color_step), int(255-cls_id*color_step)))
+    img = cv2.addWeighted(im_canvas, 0.3, img, 0.7, 0)
+    return img
+
+def scale_mask(masks, im0_shape):
+    masks = cv2.resize(masks, (im0_shape[1], im0_shape[0]),
+                        interpolation=cv2.INTER_LINEAR)
+    if len(masks.shape) == 2:
+        masks = masks[:, :, None]
+    return masks
+
+def crop_mask(masks, boxes):
+    n, h, w = masks.shape
+    x1, y1, x2, y2 = np.split(boxes[:, :, None], 4, 1)
+    r = np.arange(w, dtype=x1.dtype)[None, None, :]
+    c = np.arange(h, dtype=x1.dtype)[None, :, None]
+    return masks * ((r >= x1) * (r < x2) * (c >= y1) * (c < y2))
+
+def process_mask(protos, masks_in, bboxes, im0_shape):
+    c, mh, mw = protos.shape
+    masks = np.matmul(masks_in, protos.reshape((c, -1))).reshape((-1, mh, mw)).transpose(1, 2, 0)  # HWN
+    masks = np.ascontiguousarray(masks)
+    masks = scale_mask(masks, im0_shape)  # re-scale mask from P3 shape to original input image shape
+    masks = np.einsum('HWN -> NHW', masks)  # HWN -> NHW
+    masks = crop_mask(masks, bboxes)
+    return np.greater(masks, 0.5)
+
+def masks2segments(masks):
+    segments = []
+    for x in masks.astype('uint8'):
+        c = cv2.findContours(x, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)[0]  # CHAIN_APPROX_SIMPLE
+        if c:
+            c = np.array(c[np.array([len(x) for x in c]).argmax()]).reshape(-1, 2)
+        else:
+            c = np.zeros((0, 2))  # no segments found
+        segments.append(c.astype('float32'))
+    return segments

model_farm_yolov8s_seg_qsc8550_qnn2.16_fp16_aidlite/README.md

@@ -0,0 +1,56 @@
+## Model Information
+## Source model
+- Input shape: 640x640
+- Number of parameters: 11.27M
+- Model size: 45.22M
+- Output shape: 1x32x160x160, 1x116x8400
+
+Source model repository: [yolov8](https://github.com/ultralytics/ultralytics)
+
+### 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 yolov8s_seg/model_farm_yolov8s_seg_qsc8550_qnn2.16_fp16_aidlite
+python3 ./python/run_test.py --target_model ./models/cutoff_yolov8s-seg_fp16.qnn216.ctx.bin --imgs ./python/bus.jpg  --invoke_nums 10
+```
+
+#### cpp
+```bash
+cd yolov8s_seg/model_farm_yolov8s_seg_qsc8550_qnn2.16_fp16_aidlite/cpp
+mkdir build && cd build 
+cmake ..
+make
+./run_test
+```
+

model_farm_yolov8s_seg_qsc8550_qnn2.16_fp16_aidlite/cpp/CMakeLists.txt

@@ -0,0 +1,31 @@
+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
+)

model_farm_yolov8s_seg_qsc8550_qnn2.16_fp16_aidlite/cpp/run_test.cpp

@@ -0,0 +1,484 @@
+#include <iostream>
+#include <string>
+#include <algorithm>
+#include <cctype>
+#include <cstring> // 用于 memcpy
+#include <opencv2/opencv.hpp>
+#include <aidlux/aidlite/aidlite.hpp>
+#include <vector>
+#include <numeric>
+
+const float INPUT_WIDTH = 640.0;
+const float INPUT_HEIGHT = 640.0;
+const float SCORE_THRESHOLD = 0.25;
+const float NMS_THRESHOLD = 0.45;
+const float CONFIDENCE_THRESHOLD = 0.25;
+const int out_size = 8400;
+
+const int FONT_FACE = cv::FONT_HERSHEY_SIMPLEX;
+cv::Scalar WHITE = cv::Scalar(255,255,255);
+
+const float FONT_SCALE = 0.75;
+const int THICKNESS = 1;
+
+const std::vector<std::string> class_list = {
+    "person", "bicycle", "car", "motorcycle", "airplane", "bus", "train",
+    "truck", "boat", "traffic light", "fire hydrant", "stop sign", "parking meter",
+    "bench", "bird", "cat", "dog", "horse", "sheep", "cow", "elephant", "bear",
+    "zebra", "giraffe", "backpack", "umbrella", "handbag", "tie", "suitcase",
+    "frisbee", "skis", "snowboard", "sports ball", "kite", "baseball bat",
+    "baseball glove", "skateboard", "surfboard", "tennis racket", "bottle",
+    "wine glass", "cup", "fork", "knife", "spoon", "bowl", "banana", "apple",
+    "sandwich", "orange", "broccoli", "carrot", "hot dog", "pizza", "donut",
+    "cake", "chair", "couch", "potted plant", "bed", "dining table", "toilet",
+    "TV", "laptop", "mouse", "remote", "keyboard", "cell phone", "microwave",
+    "oven", "toaster", "sink", "refrigerator", "book", "clock", "vase",
+    "scissors", "teddy bear", "hair drier", "toothbrush"
+};
+
+using namespace cv;
+using namespace std;
+using namespace Aidlux::Aidlite;
+
+struct Args {
+    std::string target_model = "../../models/cutoff_yolov8s-seg_fp16.qnn216.ctx.bin";
+    std::string imgs = "../bus.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;
+}
+
+// concatenate_3(80_class_data, 4_pos_data , 32_canc_data, 1, 8400, 80, 4,32, qnn_concat);
+void concatenate_3(float* qnn_trans_data, float* qnn_mul_data, float* qnn_canc_data, int batch, int num_elements, int trans_dim, int mul_dim, int canc_dim,std::vector<float>& output) {
+    // int out_dim = trans_dim + mul_dim + canc_dim + 1; //117
+    int out_dim = trans_dim + mul_dim + canc_dim; //116
+    output.resize(batch * num_elements * out_dim); 
+    for (int i = 0; i < batch * num_elements; ++i) {
+        std::memcpy(&output[i * out_dim], &qnn_mul_data[i * mul_dim], mul_dim * sizeof(float));
+        std::memcpy(&output[i * out_dim + mul_dim], &qnn_trans_data[i * trans_dim], trans_dim * sizeof(float));
+        std::memcpy(&output[i * out_dim + mul_dim + trans_dim], &qnn_canc_data[i * canc_dim], canc_dim * sizeof(float));
+    }
+}
+
+// 4*8400
+void transformData(const float* input, float* output, int C, int N) {
+    for (int c = 0; c < C; ++c) {
+        for (int n = 0; n < N; ++n) {
+            output[n * C + c] = input[c * N + n];
+        }
+    }
+}
+
+double img_process(cv::Mat frame, cv::Mat &img_input, int size) {
+    cv::Mat img_processed = frame.clone();
+    int height = img_processed.rows;
+    int width = img_processed.cols;
+    int length = std::max(height, width);
+    double scala = static_cast<double>(length) / size;
+    
+    cv::Mat image = cv::Mat::zeros(cv::Size(length, length), CV_8UC3);
+    img_processed.copyTo(image(cv::Rect(0, 0, width, height)));
+    
+    cv::cvtColor(image, img_input, cv::COLOR_BGR2RGB);
+    cv::resize(img_input, img_input, cv::Size(size, size));
+    
+    cv::Mat mean_data = cv::Mat::zeros(img_input.size(), CV_32FC3);
+    cv::Mat std_data(img_input.size(), CV_32FC3, cv::Scalar(255, 255, 255));
+    img_input.convertTo(img_input, CV_32FC3);
+    img_input = (img_input - mean_data) / std_data;
+    return scala;
+}
+
+
+cv::Scalar generate_colors(int i, bool bgr = false) {
+    static const std::vector<std::string> hex_colors = {
+        "FF3838", "FF9D97", "FF701F", "FFB21D", "CFD231", "48F90A",
+        "92CC17", "3DDB86", "1A9334", "00D4BB", "2C99A8", "00C2FF",
+        "344593", "6473FF", "0018EC", "8438FF", "520085", "CB38FF",
+        "FF95C8", "FF37C7"
+    };
+
+    int num = hex_colors.size();
+    std::string hex = hex_colors[i % num];
+
+    int r = std::stoi(hex.substr(0, 2), nullptr, 16);
+    int g = std::stoi(hex.substr(2, 2), nullptr, 16);
+    int b = std::stoi(hex.substr(4, 2), nullptr, 16);
+
+    if (bgr)
+        return cv::Scalar(b, g, r);
+    else
+        return cv::Scalar(r, g, b);
+}
+
+float sigmoid_function(float a)
+{
+    float b = 1. / (1. + exp(-a));
+    return b;
+}
+
+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;
+}
+
+
+void draw_label(cv::Mat& input_image, std::string label, int left, int top, cv::Scalar color)
+{
+    int baseLine;
+    cv::Size label_size = cv::getTextSize(label, FONT_FACE, FONT_SCALE, THICKNESS, &baseLine);
+    int y = top - label_size.height - baseLine;
+    if (y < 0) {
+        y = top ;
+    }
+    cv::Point tlc(left, y);
+    cv::Point brc(left + label_size.width, y + label_size.height + baseLine);
+    rectangle(input_image, tlc, brc, color, cv::FILLED);
+    putText(input_image, label, cv::Point(left, y + label_size.height), FONT_FACE, FONT_SCALE, WHITE, THICKNESS);
+}
+
+
+cv::Mat post_process(cv::Mat &frame, std::vector<float> &outputs, const std::vector<std::string> &class_name, 
+    const double ratio, float* protos_data, float* qnn_canc)
+{
+    cv::Mat input_image = frame.clone();
+    // Initialize vectors to hold respective outputs while unwrapping detections.
+    std::vector<int> class_ids;
+    std::vector<float> confidences;
+    std::vector<cv::Rect> boxes;
+    std::vector<cv::Mat> masks;
+    std::vector<float> class_scores;
+    cv::RNG rng;
+    cv::Mat masked_img;
+
+    unsigned int src_dims[4] = {1, 32,160,160};
+    unsigned int tsp_dims[4] = {0,3,1,2};
+    unsigned int stride_data_num = 1*32*160*160;
+    float* format_data = new float[stride_data_num];
+    transpose(protos_data, src_dims, tsp_dims, format_data);
+    cv::Mat proto_buffer(32, 160*160, CV_32F, format_data);
+    std::cout << "proto_buffer 维度: " << proto_buffer.rows << "x" << proto_buffer.cols << std::endl;
+
+    for (int i = 0; i < outputs.size(); i+=116)
+    {
+        auto start = outputs.begin() + i + 4;
+        auto end = outputs.begin() + i + 84;
+        float max_val = *std::max_element(start, end);
+        float confidence = max_val;
+        if (confidence >= CONFIDENCE_THRESHOLD)
+        {
+            auto start = outputs.begin() + i + 4;
+            auto end = outputs.begin() + i + 84;
+            std::vector<float> middle_data;
+            middle_data.assign(start, end);
+            // Create a 1x80 Mat and store class scores of 80 classes.
+            cv::Mat scores(1, class_name.size(), CV_32FC1, middle_data.data());
+            cv::Point class_id;
+            double max_class_score;
+            
+            // For multi-label, check each class score
+            for (int c = 0; c < class_name.size(); c++) {
+                float class_score = scores.at<float>(0, c);
+                // If class score is above threshold, consider this class for the box
+                if (class_score > SCORE_THRESHOLD) {
+                    std::vector<float> last32_data;
+                    auto st_32= outputs.begin() + i + 84;
+                    auto ed_32 = outputs.begin() + i + 116;
+                    last32_data.assign(st_32, ed_32);
+                    cv::Mat mask(1, 32, CV_32FC1, last32_data.data());
+                    // Store class ID and confidence in the pre-defined respective vectors.
+                    confidences.push_back(confidence * class_score);  // Multiply with confidence
+                    class_ids.push_back(c);  // class index
+                    // Center and box dimension.
+                    float cx = outputs[i];
+                    float cy = outputs[i+1];
+                    float w = outputs[i+2];
+                    float h = outputs[i+3];
+
+                    int left = int((cx - 0.5 * w) * ratio);
+                    int top = int((cy - 0.48 * h) * ratio);
+                    int width = int(w * ratio);
+                    int height = int(h * ratio);
+
+                    // Store good detections in the boxes vector.
+                    boxes.push_back(cv::Rect(left, top, width, height));
+                    masks.push_back(mask);
+                }
+            }
+        }
+    }
+
+    std::cout << "boxes.size(): " << boxes.size() << ",confidences.size():" << confidences.size() << std::endl; 
+
+    // Perform Non Maximum Suppression and draw predictions.
+    std::vector<int> indices;
+    cv::dnn::NMSBoxes(boxes, confidences, SCORE_THRESHOLD, NMS_THRESHOLD, indices);
+    printf("Detected {%ld} targets.\n", indices.size());
+    cv::Mat rgb_mask = cv::Mat::zeros(input_image.size(), input_image.type());
+    
+    // Loop over NMS results and draw bounding boxes
+    for (int i = 0; i < indices.size(); i++)
+    {
+        int idx = indices[i];
+        cv::Rect box = boxes[idx];
+        cv::Scalar color = generate_colors(class_ids[idx]);
+
+        int x1 = std::max(0, box.x);
+        int y1 = std::max(0, box.y);
+        int x2 = std::max(0, box.br().x);
+        int y2 = std::max(0, box.br().y);
+        cv::Mat ms = masks[idx];
+        // 维度验证
+        if (ms.cols != proto_buffer.rows) {
+            cerr << "维度不匹配: mask.cols=" << ms.cols 
+                 << ", proto_buffer.rows=" << proto_buffer.rows << endl;
+            continue;
+        }
+        cv::Mat m = ms * proto_buffer;
+        for (int col = 0; col < m.cols; col++) {
+            m.at<float>(0, col) = sigmoid_function(m.at<float>(0, col));
+        }
+        cv::Mat m1 = m.reshape(1, 160); // 1x25600 -> 160x160
+
+        float ratio2 = 160.0/640.0;
+        int mx1 = std::max(0, int((x1 * ratio2)));
+        int mx2 = std::max(0, int((x2 * ratio2)));
+        int my1 = std::max(0, int((y1 * ratio2)));
+        int my2 = std::max(0, int((y2 * ratio2)));
+        cv::Mat mask_roi = m1(cv::Range(my1, my2), cv::Range(mx1, mx2));
+        cv::Mat rm, det_mask;
+        cv::resize(mask_roi, rm, cv::Size(x2 - x1, y2 - y1));
+        for (int r = 0; r < rm.rows; r++) {
+            for (int c = 0; c < rm.cols; c++) {
+                float pv = rm.at<float>(r, c);
+                if (pv > 0.5) {
+                    rm.at<float>(r, c) = 1.0;
+                }
+                else {
+                    rm.at<float>(r, c) = 0.0;
+                }
+            }
+        }
+        rm = rm * rng.uniform(0, 255);
+        rm.convertTo(det_mask, CV_8UC1);
+        if ((y1 + det_mask.rows) >= input_image.rows) {
+            y2 = input_image.rows - 1;
+        }
+        if ((x1 + det_mask.cols) >= input_image.cols) {
+            x2 = input_image.cols - 1;
+        }
+
+        cv::Mat mask = cv::Mat::zeros(cv::Size(input_image.cols, input_image.rows), CV_8UC1);
+        det_mask(cv::Range(0, y2 - y1), cv::Range(0, x2 - x1)).copyTo(mask(cv::Range(y1, y2), cv::Range(x1, x2)));
+        add(rgb_mask, cv::Scalar(rng.uniform(0, 255), rng.uniform(0, 255), rng.uniform(0, 255)), rgb_mask, mask);
+        if (input_image.size() != rgb_mask.size()) {
+            cv::resize(rgb_mask, rgb_mask, input_image.size());
+        }
+
+        cv::rectangle(input_image, boxes[idx], color, 2, 8);
+        std::string label = cv::format("%.2f", confidences[idx]);
+        label = class_name[class_ids[idx]] + ":" + label;
+        cv::putText(input_image, label, cv::Point(boxes[idx].tl().x, boxes[idx].tl().y - 10), cv::FONT_HERSHEY_SIMPLEX, .5, color);
+        cv::addWeighted(input_image, 0.5, rgb_mask, 0.5, 0, masked_img);
+
+    }
+    printf("Processing finished.\n");
+    return masked_img;
+}
+
+
+
+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;
+
+    std::vector<std::vector<uint32_t>> input_shapes = {{1, 640, 640, 3}};
+    std::vector<std::vector<uint32_t>> output_shapes = {{1,32,8400},{1,4,8400},{1,80,8400},{1,160, 160,32}};
+    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_img;
+    double scale = img_process(frame, input_img, 640);
+    if (input_img.empty()) {
+        printf("detect input_img load failed!\n");
+        return 1;
+    }
+
+    float *qnn_seg_data = nullptr;
+    float *qnn_trans_data = nullptr;
+    float *qnn_mul_data = nullptr;
+    float *qnn_canc_data = nullptr;
+
+    std::vector<float> invoke_time;
+    for (int i = 0; i < args.invoke_nums; ++i) {
+        result = fast_interpreter->set_input_tensor(0, input_img.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_1 = 0;
+        result = fast_interpreter->get_output_tensor(1, (void**)&qnn_canc_data, &out_data_1);
+        if(result != EXIT_SUCCESS){
+            printf("interpreter->get_output_tensor() 1 failed !\n");
+            return EXIT_FAILURE;
+        }
+
+        uint32_t out_data_4 = 0;
+        result = fast_interpreter->get_output_tensor(2, (void**)&qnn_trans_data, &out_data_4);
+        if(result != EXIT_SUCCESS){
+            printf("interpreter->get_output_tensor() 2 failed !\n");
+            return EXIT_FAILURE;
+        }
+
+        uint32_t out_data_2 = 0;
+        result = fast_interpreter->get_output_tensor(0, (void**)&qnn_seg_data, &out_data_2);
+        if(result != EXIT_SUCCESS){
+            printf("interpreter->get_output_tensor() 2 failed !\n");
+            return EXIT_FAILURE;
+        }
+
+        uint32_t out_data_80 = 0;
+        result = fast_interpreter->get_output_tensor(3, (void**)&qnn_mul_data, &out_data_80);
+        if(result != EXIT_SUCCESS){
+            printf("interpreter->get_output_tensor() 2 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");
+
+    float* pos_data = new float[4 * out_size];
+    float* class_data = new float[80 * out_size];
+    float* canc_data = new float[32 * out_size];
+    transformData(qnn_trans_data, pos_data, 4, out_size);
+    transformData(qnn_mul_data, class_data, 80, out_size);
+    transformData(qnn_canc_data, canc_data, 32, out_size);
+    
+    // post process
+    std::vector<float> qnn_concat;
+    concatenate_3(class_data, pos_data, canc_data , 1, out_size, 80, 4, 32, qnn_concat);
+    cv::Mat img = post_process(frame, qnn_concat, class_list, scale, qnn_seg_data, qnn_canc_data);
+    cv::imwrite("./results.png", img);
+    fast_interpreter->destory();
+    return 0;
+}
+
+
+int main(int argc, char* argv[]) {
+    Args args = parse_args(argc, argv);
+    return invoke(args);
+}

model_farm_yolov8s_seg_qsc8550_qnn2.16_fp16_aidlite/models/cutoff_yolov8s-seg_fp16.qnn216.ctx.bin

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

model_farm_yolov8s_seg_qsc8550_qnn2.16_fp16_aidlite/python/run_test.py

@@ -0,0 +1,134 @@
+import numpy as np
+import cv2
+import aidlite
+from utils import eqprocess, xywh2xyxy, NMS, process_mask, masks2segments, draw_detect_res
+import os
+import time
+import argparse
+import onnxruntime
+
+# 定义相似度函数
+def get_acc(onnx_out,other_out):
+    cosine_similarity=np.dot(np.array(onnx_out),np.array(other_out))/(np.linalg.norm(np.array(onnx_out)) * np.linalg.norm(np.array(other_out)))
+    return cosine_similarity
+
+
+class qnn_predict(object):
+    def __init__(self,args) -> None:
+        # aidlite.set_log_level(aidlite.LogLevel.INFO)
+        # aidlite.log_to_stderr()
+        # print(f"Aidlite library version : {aidlite.get_library_version()}")
+        # print(f"Aidlite python library version : {aidlite.get_py_library_version()}")
+        config = aidlite.Config.create_instance()
+        if config is None:
+            print("Create model failed !")
+        config.implement_type = aidlite.ImplementType.TYPE_LOCAL
+        config.framework_type = aidlite.FrameworkType.TYPE_QNN
+        config.accelerate_type = aidlite.AccelerateType.TYPE_DSP
+        config.is_quantify_model = 1
+
+        model = aidlite.Model.create_instance(args.target_model)
+        if model is None:
+            print("Create model failed !")
+
+        self.conf = args.conf_thres
+        self.iou=args.iou_thres
+        self.width = args.width
+        self.height = args.height
+        self.class_num = args.class_num
+        self.input_shape = [[1,self.height,self.width,3]]
+        self.blocks = int(self.height * self.width * ( 1 / 64 + 1 / 256 + 1 / 1024))
+        self.maskw = int(self.width / 4)
+        self.maskh = int(self.height / 4)
+        self.output_shape = [[1,32,self.blocks],[1,4,self.blocks],[1,self.class_num,self.blocks],[1,self.maskh, self.maskw,32]]
+        
+        model.set_model_properties(self.input_shape, aidlite.DataType.TYPE_FLOAT32, self.output_shape, aidlite.DataType.TYPE_FLOAT32)
+        self.interpreter = aidlite.InterpreterBuilder.build_interpretper_from_model_and_config(model, config)
+        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("detect model load success!")
+
+    def pretreat_img(self,frame): 
+        img, scale = eqprocess(frame, self.height, self.width)
+        img = img / 255
+        img = img.astype(np.float32)
+        return img,scale
+    
+    def qnn_run(self, orig_imgs,args):
+        input_img_f,scale=self.pretreat_img(orig_imgs)  # 图片resize HWC
+        input_img = np.expand_dims(input_img_f, 0)
+      
+        invoke_time=[]
+        for i in range(args.invoke_nums):
+            self.interpreter.set_input_tensor(0, input_img.data)
+            t0 = time.time()
+            self.interpreter.invoke()
+            t1 = time.time()
+            cost_time=(t1-t0)*1000
+            invoke_time.append(cost_time)
+
+            input0_data = self.interpreter.get_output_tensor(2).reshape(1,4,self.blocks)
+            input1_data = self.interpreter.get_output_tensor(3).reshape(1,self.class_num,self.blocks)
+            input2_data = self.interpreter.get_output_tensor(1).reshape(1,32,self.blocks)
+            protos = self.interpreter.get_output_tensor(0).reshape(1,self.maskh, self.maskw,32).transpose(0,3,1,2)
+
+            boxes = np.concatenate([input0_data, input1_data, input2_data], axis = 1)
+            x = boxes.transpose(0,2,1)
+            x = x[np.amax(x[..., 4:-32], axis=-1) > self.conf]
+            if len(x) < 1:
+                return None, None
+        
+            x = np.c_[x[..., :4], np.amax(x[..., 4:-32], axis=-1), np.argmax(x[..., 4:-32], axis=-1), x[..., -32:]]
+            
+            x[:, :4] = xywh2xyxy(x[:, :4])
+            index = NMS(x[:, :4], x[:, 4], self.iou)
+            out_boxes = x[index]
+            out_boxes[..., :4] = out_boxes[..., :4] * scale
+            
+            masks = process_mask(protos[0], out_boxes[:, -32:], out_boxes[:, :4], orig_imgs.shape)
+            segments = masks2segments(masks)
+           
+        ## time 统计
+        max_invoke_time = max(invoke_time)
+        min_invoke_time = min(invoke_time)
+        mean_invoke_time = sum(invoke_time)/args.invoke_nums
+        var_invoketime=np.var(invoke_time)
+        print("========================================")
+        print(f"QNN inference {args.invoke_nums} times :\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("========================================")
+
+        return out_boxes, segments
+       
+
+def parser_args():
+    parser = argparse.ArgumentParser(description="Run model benchmarks")
+    parser.add_argument('--target_model',type=str,default='./models/cutoff_yolov8s-seg_fp16.qnn216.ctx.bin',help="inference model path")
+    parser.add_argument('--imgs',type=str,default='./python/bus.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")
+    parser.add_argument('--width',type=int,default=640,help="Model input size")
+    parser.add_argument('--height',type=int,default=640,help="Model input size")
+    parser.add_argument('--conf_thres',type=float,default=0.45,help="confidence threshold for filtering the annotations")
+    parser.add_argument('--iou_thres',type=float,default=0.45,help="Iou threshold for filtering the annotations")
+    parser.add_argument('--class_num',type=int,default=80,help="Iou threshold for filtering the annotations")
+    args = parser.parse_args()
+    return args
+
+def main(args):
+    model = qnn_predict(args)
+    frame = cv2.imread(args.imgs)
+    qnn_out_boxes, qnn_segments = model.qnn_run(frame,args)
+    result = draw_detect_res(frame, qnn_out_boxes, qnn_segments)
+    cv2.imwrite("./python/bus_result.jpg", result)
+
+if __name__ == "__main__":
+    args = parser_args()
+    main(args)
+
+

model_farm_yolov8s_seg_qsc8550_qnn2.16_fp16_aidlite/python/utils.py

@@ -0,0 +1,124 @@
+import numpy as np
+import cv2
+
+CLASSES = ("person", "bicycle", "car", "motorbike ", "aeroplane ", "bus ", "train", "truck ", "boat", "traffic light",
+           "fire hydrant", "stop sign ", "parking meter", "bench", "bird", "cat", "dog ", "horse ", "sheep", "cow", "elephant",
+           "bear", "zebra ", "giraffe", "backpack", "umbrella", "handbag", "tie", "suitcase", "frisbee", "skis", "snowboard", "sports ball", "kite",
+           "baseball bat", "baseball glove", "skateboard", "surfboard", "tennis racket", "bottle", "wine glass", "cup", "fork", "knife ",
+           "spoon", "bowl", "banana", "apple", "sandwich", "orange", "broccoli", "carrot", "hot dog", "pizza ", "donut", "cake", "chair", "sofa",
+           "pottedplant", "bed", "diningtable", "toilet ", "tvmonitor", "laptop	", "mouse	", "remote ", "keyboard ", "cell phone", "microwave ",
+           "oven ", "toaster", "sink", "refrigerator ", "book", "clock", "vase", "scissors ", "teddy bear ", "hair drier", "toothbrush ")
+           
+def eqprocess(image, size1, size2):
+    h,w,_ = image.shape
+    mask = np.zeros((size1,size2,3),dtype=np.float32)
+    scale1 = h /size1
+    scale2 = w / size2
+    if scale1 > scale2:
+        scale = scale1
+    else:
+        scale = scale2
+    img = cv2.resize(image,(int(w / scale),int(h / scale)))
+    mask[:int(h / scale),:int(w / scale),:] = img
+    return mask, scale
+
+def xywh2xyxy(x):
+    '''
+    Box (center x, center y, width, height) to (x1, y1, x2, y2)
+    '''
+    y = np.copy(x)
+    y[:, 0] = x[:, 0] - x[:, 2] / 2  # top left x
+    y[:, 1] = x[:, 1] - x[:, 3] / 2  # top left y
+    y[:, 2] = x[:, 0] + x[:, 2] / 2  # bottom right x
+    y[:, 3] = x[:, 1] + x[:, 3] / 2  # bottom right y
+    return y
+
+def xyxy2xywh(box):
+    '''
+    Box (left_top x, left_top y, right_bottom x, right_bottom y) to (left_top x, left_top y, width, height)
+    '''
+    box[:, 2:] = box[:, 2:] - box[:, :2]
+    return box
+
+def NMS(dets, scores, thresh):
+    '''
+    单类NMS算法
+    dets.shape = (N, 5), (left_top x, left_top y, right_bottom x, right_bottom y, Scores)
+    '''
+    x1 = dets[:,0]
+    y1 = dets[:,1]
+    x2 = dets[:,2]
+    y2 = dets[:,3]
+    areas = (y2-y1+1) * (x2-x1+1)
+    keep = []
+    index = scores.argsort()[::-1]
+    while index.size >0:
+        i = index[0]       # every time the first is the biggst, and add it directly
+        keep.append(i)
+        x11 = np.maximum(x1[i], x1[index[1:]])    # calculate the points of overlap 
+        y11 = np.maximum(y1[i], y1[index[1:]])
+        x22 = np.minimum(x2[i], x2[index[1:]])
+        y22 = np.minimum(y2[i], y2[index[1:]])
+        w = np.maximum(0, x22-x11+1)    # the weights of overlap
+        h = np.maximum(0, y22-y11+1)    # the height of overlap
+        overlaps = w*h
+        ious = overlaps / (areas[i]+areas[index[1:]] - overlaps)
+        idx = np.where(ious<=thresh)[0]
+        index = index[idx+1]   # because index start from 1
+ 
+    return keep
+
+def draw_detect_res(img, det_pred, segments):
+    '''
+    检测结果绘制
+    '''
+    if det_pred is None:
+        return img
+
+    img = img.astype(np.uint8)
+    im_canvas = img.copy()
+    color_step = int(255/len(CLASSES))
+    for i in range(len(det_pred)):
+        x1, y1, x2, y2 = [int(t) for t in det_pred[i][:4]]
+        cls_id = int(det_pred[i][5])
+        cv2.putText(img, f'{CLASSES[cls_id]}', (x1, y1-6), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1)
+        cv2.rectangle(img, (x1, y1), (x2, y2), (0, int(cls_id*color_step), int(255-cls_id*color_step)),thickness = 2)
+        if len(segments[i]) > 0:
+            cv2.polylines(img, np.int32([segments[i]]), True, (0, int(cls_id*color_step), int(255-cls_id*color_step)), 2)
+            cv2.fillPoly(img, np.int32([segments[i]]), (0, int(cls_id*color_step), int(255-cls_id*color_step)))
+    img = cv2.addWeighted(im_canvas, 0.3, img, 0.7, 0)
+    return img
+
+def scale_mask(masks, im0_shape):
+    masks = cv2.resize(masks, (im0_shape[1], im0_shape[0]),
+                        interpolation=cv2.INTER_LINEAR)
+    if len(masks.shape) == 2:
+        masks = masks[:, :, None]
+    return masks
+
+def crop_mask(masks, boxes):
+    n, h, w = masks.shape
+    x1, y1, x2, y2 = np.split(boxes[:, :, None], 4, 1)
+    r = np.arange(w, dtype=x1.dtype)[None, None, :]
+    c = np.arange(h, dtype=x1.dtype)[None, :, None]
+    return masks * ((r >= x1) * (r < x2) * (c >= y1) * (c < y2))
+
+def process_mask(protos, masks_in, bboxes, im0_shape):
+    c, mh, mw = protos.shape
+    masks = np.matmul(masks_in, protos.reshape((c, -1))).reshape((-1, mh, mw)).transpose(1, 2, 0)  # HWN
+    masks = np.ascontiguousarray(masks)
+    masks = scale_mask(masks, im0_shape)  # re-scale mask from P3 shape to original input image shape
+    masks = np.einsum('HWN -> NHW', masks)  # HWN -> NHW
+    masks = crop_mask(masks, bboxes)
+    return np.greater(masks, 0.5)
+
+def masks2segments(masks):
+    segments = []
+    for x in masks.astype('uint8'):
+        c = cv2.findContours(x, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)[0]  # CHAIN_APPROX_SIMPLE
+        if c:
+            c = np.array(c[np.array([len(x) for x in c]).argmax()]).reshape(-1, 2)
+        else:
+            c = np.zeros((0, 2))  # no segments found
+        segments.append(c.astype('float32'))
+    return segments

model_farm_yolov8s_seg_qsc8550_qnn2.16_int16_aidlite/README.md

@@ -0,0 +1,56 @@
+## Model Information
+## Source model
+- Input shape: 640x640
+- Number of parameters: 11.27M
+- Model size: 45.22M
+- Output shape: 1x32x160x160, 1x116x8400
+
+Source model repository: [yolov8](https://github.com/ultralytics/ultralytics)
+
+### Converted model
+
+- Precision: W8A16
+- 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 yolov8s_seg/model_farm_yolov8s_seg_qsc8550_qnn2.16_int16_aidlite
+python3 ./python/run_test.py --target_model ./models/cutoff_yolov8s-seg_w8a16.qnn216.ctx.bin --imgs ./python/bus.jpg  --invoke_nums 10
+```
+
+#### cpp
+```bash
+cd yolov8s_seg/model_farm_yolov8s_seg_qsc8550_qnn2.16_int16_aidlite/cpp
+mkdir build && cd build 
+cmake ..
+make
+./run_test
+```
+

model_farm_yolov8s_seg_qsc8550_qnn2.16_int16_aidlite/cpp/CMakeLists.txt

@@ -0,0 +1,31 @@
+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
+)

model_farm_yolov8s_seg_qsc8550_qnn2.16_int16_aidlite/cpp/run_test.cpp

@@ -0,0 +1,484 @@
+#include <iostream>
+#include <string>
+#include <algorithm>
+#include <cctype>
+#include <cstring> // 用于 memcpy
+#include <opencv2/opencv.hpp>
+#include <aidlux/aidlite/aidlite.hpp>
+#include <vector>
+#include <numeric>
+
+const float INPUT_WIDTH = 640.0;
+const float INPUT_HEIGHT = 640.0;
+const float SCORE_THRESHOLD = 0.25;
+const float NMS_THRESHOLD = 0.45;
+const float CONFIDENCE_THRESHOLD = 0.25;
+const uint32_t out_size = 8400;
+
+const int FONT_FACE = cv::FONT_HERSHEY_SIMPLEX;
+cv::Scalar WHITE = cv::Scalar(255,255,255);
+
+const float FONT_SCALE = 0.75;
+const int THICKNESS = 1;
+
+const std::vector<std::string> class_list = {
+    "person", "bicycle", "car", "motorcycle", "airplane", "bus", "train",
+    "truck", "boat", "traffic light", "fire hydrant", "stop sign", "parking meter",
+    "bench", "bird", "cat", "dog", "horse", "sheep", "cow", "elephant", "bear",
+    "zebra", "giraffe", "backpack", "umbrella", "handbag", "tie", "suitcase",
+    "frisbee", "skis", "snowboard", "sports ball", "kite", "baseball bat",
+    "baseball glove", "skateboard", "surfboard", "tennis racket", "bottle",
+    "wine glass", "cup", "fork", "knife", "spoon", "bowl", "banana", "apple",
+    "sandwich", "orange", "broccoli", "carrot", "hot dog", "pizza", "donut",
+    "cake", "chair", "couch", "potted plant", "bed", "dining table", "toilet",
+    "TV", "laptop", "mouse", "remote", "keyboard", "cell phone", "microwave",
+    "oven", "toaster", "sink", "refrigerator", "book", "clock", "vase",
+    "scissors", "teddy bear", "hair drier", "toothbrush"
+};
+
+using namespace cv;
+using namespace std;
+using namespace Aidlux::Aidlite;
+
+struct Args {
+    std::string target_model = "../../models/cutoff_yolov8s-seg_w8a16.qnn216.ctx.bin";
+    std::string imgs = "../bus.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;
+}
+
+// concatenate_3(80_class_data, 4_pos_data , 32_canc_data, 1, 8400, 80, 4,32, qnn_concat);
+void concatenate_3(float* qnn_trans_data, float* qnn_mul_data, float* qnn_canc_data, int batch, int num_elements, int trans_dim, int mul_dim, int canc_dim,std::vector<float>& output) {
+    // int out_dim = trans_dim + mul_dim + canc_dim + 1; //117
+    int out_dim = trans_dim + mul_dim + canc_dim; //116
+    output.resize(batch * num_elements * out_dim); 
+    for (int i = 0; i < batch * num_elements; ++i) {
+        std::memcpy(&output[i * out_dim], &qnn_mul_data[i * mul_dim], mul_dim * sizeof(float));
+        std::memcpy(&output[i * out_dim + mul_dim], &qnn_trans_data[i * trans_dim], trans_dim * sizeof(float));
+        std::memcpy(&output[i * out_dim + mul_dim + trans_dim], &qnn_canc_data[i * canc_dim], canc_dim * sizeof(float));
+    }
+}
+
+// 4*8400
+void transformData(const float* input, float* output, int C, int N) {
+    for (int c = 0; c < C; ++c) {
+        for (int n = 0; n < N; ++n) {
+            output[n * C + c] = input[c * N + n];
+        }
+    }
+}
+
+double img_process(cv::Mat frame, cv::Mat &img_input, int size) {
+    cv::Mat img_processed = frame.clone();
+    int height = img_processed.rows;
+    int width = img_processed.cols;
+    int length = std::max(height, width);
+    double scala = static_cast<double>(length) / size;
+    
+    cv::Mat image = cv::Mat::zeros(cv::Size(length, length), CV_8UC3);
+    img_processed.copyTo(image(cv::Rect(0, 0, width, height)));
+    
+    cv::cvtColor(image, img_input, cv::COLOR_BGR2RGB);
+    cv::resize(img_input, img_input, cv::Size(size, size));
+    
+    cv::Mat mean_data = cv::Mat::zeros(img_input.size(), CV_32FC3);
+    cv::Mat std_data(img_input.size(), CV_32FC3, cv::Scalar(255, 255, 255));
+    img_input.convertTo(img_input, CV_32FC3);
+    img_input = (img_input - mean_data) / std_data;
+    return scala;
+}
+
+
+cv::Scalar generate_colors(int i, bool bgr = false) {
+    static const std::vector<std::string> hex_colors = {
+        "FF3838", "FF9D97", "FF701F", "FFB21D", "CFD231", "48F90A",
+        "92CC17", "3DDB86", "1A9334", "00D4BB", "2C99A8", "00C2FF",
+        "344593", "6473FF", "0018EC", "8438FF", "520085", "CB38FF",
+        "FF95C8", "FF37C7"
+    };
+
+    int num = hex_colors.size();
+    std::string hex = hex_colors[i % num];
+
+    int r = std::stoi(hex.substr(0, 2), nullptr, 16);
+    int g = std::stoi(hex.substr(2, 2), nullptr, 16);
+    int b = std::stoi(hex.substr(4, 2), nullptr, 16);
+
+    if (bgr)
+        return cv::Scalar(b, g, r);
+    else
+        return cv::Scalar(r, g, b);
+}
+
+float sigmoid_function(float a)
+{
+    float b = 1. / (1. + exp(-a));
+    return b;
+}
+
+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;
+}
+
+
+void draw_label(cv::Mat& input_image, std::string label, int left, int top, cv::Scalar color)
+{
+    int baseLine;
+    cv::Size label_size = cv::getTextSize(label, FONT_FACE, FONT_SCALE, THICKNESS, &baseLine);
+    int y = top - label_size.height - baseLine;
+    if (y < 0) {
+        y = top ;
+    }
+    cv::Point tlc(left, y);
+    cv::Point brc(left + label_size.width, y + label_size.height + baseLine);
+    rectangle(input_image, tlc, brc, color, cv::FILLED);
+    putText(input_image, label, cv::Point(left, y + label_size.height), FONT_FACE, FONT_SCALE, WHITE, THICKNESS);
+}
+
+
+cv::Mat post_process(cv::Mat &frame, std::vector<float> &outputs, const std::vector<std::string> &class_name, 
+    const double ratio, float* protos_data, float* qnn_canc)
+{
+    cv::Mat input_image = frame.clone();
+    // Initialize vectors to hold respective outputs while unwrapping detections.
+    std::vector<int> class_ids;
+    std::vector<float> confidences;
+    std::vector<cv::Rect> boxes;
+    std::vector<cv::Mat> masks;
+    std::vector<float> class_scores;
+    cv::RNG rng;
+    cv::Mat masked_img;
+
+    unsigned int src_dims[4] = {1, 32,160,160};
+    unsigned int tsp_dims[4] = {0,3,1,2};
+    unsigned int stride_data_num = 1*32*160*160;
+    float* format_data = new float[stride_data_num];
+    transpose(protos_data, src_dims, tsp_dims, format_data);
+    cv::Mat proto_buffer(32, 160*160, CV_32F, format_data);
+    std::cout << "proto_buffer 维度: " << proto_buffer.rows << "x" << proto_buffer.cols << std::endl;
+
+    for (int i = 0; i < outputs.size(); i+=116)
+    {
+        auto start = outputs.begin() + i + 4;
+        auto end = outputs.begin() + i + 84;
+        float max_val = *std::max_element(start, end);
+        float confidence = max_val;
+        if (confidence >= CONFIDENCE_THRESHOLD)
+        {
+            auto start = outputs.begin() + i + 4;
+            auto end = outputs.begin() + i + 84;
+            std::vector<float> middle_data;
+            middle_data.assign(start, end);
+            // Create a 1x80 Mat and store class scores of 80 classes.
+            cv::Mat scores(1, class_name.size(), CV_32FC1, middle_data.data());
+            cv::Point class_id;
+            double max_class_score;
+            
+            // For multi-label, check each class score
+            for (int c = 0; c < class_name.size(); c++) {
+                float class_score = scores.at<float>(0, c);
+                // If class score is above threshold, consider this class for the box
+                if (class_score > SCORE_THRESHOLD) {
+                    std::vector<float> last32_data;
+                    auto st_32= outputs.begin() + i + 84;
+                    auto ed_32 = outputs.begin() + i + 116;
+                    last32_data.assign(st_32, ed_32);
+                    cv::Mat mask(1, 32, CV_32FC1, last32_data.data());
+                    // Store class ID and confidence in the pre-defined respective vectors.
+                    confidences.push_back(confidence * class_score);  // Multiply with confidence
+                    class_ids.push_back(c);  // class index
+                    // Center and box dimension.
+                    float cx = outputs[i];
+                    float cy = outputs[i+1];
+                    float w = outputs[i+2];
+                    float h = outputs[i+3];
+
+                    int left = int((cx - 0.5 * w) * ratio);
+                    int top = int((cy - 0.48 * h) * ratio);
+                    int width = int(w * ratio);
+                    int height = int(h * ratio);
+
+                    // Store good detections in the boxes vector.
+                    boxes.push_back(cv::Rect(left, top, width, height));
+                    masks.push_back(mask);
+                }
+            }
+        }
+    }
+
+    std::cout << "boxes.size(): " << boxes.size() << ",confidences.size():" << confidences.size() << std::endl; 
+
+    // Perform Non Maximum Suppression and draw predictions.
+    std::vector<int> indices;
+    cv::dnn::NMSBoxes(boxes, confidences, SCORE_THRESHOLD, NMS_THRESHOLD, indices);
+    printf("Detected {%ld} targets.\n", indices.size());
+    cv::Mat rgb_mask = cv::Mat::zeros(input_image.size(), input_image.type());
+    
+    // Loop over NMS results and draw bounding boxes
+    for (int i = 0; i < indices.size(); i++)
+    {
+        int idx = indices[i];
+        cv::Rect box = boxes[idx];
+        cv::Scalar color = generate_colors(class_ids[idx]);
+
+        int x1 = std::max(0, box.x);
+        int y1 = std::max(0, box.y);
+        int x2 = std::max(0, box.br().x);
+        int y2 = std::max(0, box.br().y);
+        cv::Mat ms = masks[idx];
+        // 维度验证
+        if (ms.cols != proto_buffer.rows) {
+            cerr << "维度不匹配: mask.cols=" << ms.cols 
+                 << ", proto_buffer.rows=" << proto_buffer.rows << endl;
+            continue;
+        }
+        cv::Mat m = ms * proto_buffer;
+        for (int col = 0; col < m.cols; col++) {
+            m.at<float>(0, col) = sigmoid_function(m.at<float>(0, col));
+        }
+        cv::Mat m1 = m.reshape(1, 160); // 1x25600 -> 160x160
+
+        float ratio2 = 160.0/640.0;
+        int mx1 = std::max(0, int((x1 * ratio2)));
+        int mx2 = std::max(0, int((x2 * ratio2)));
+        int my1 = std::max(0, int((y1 * ratio2)));
+        int my2 = std::max(0, int((y2 * ratio2)));
+        cv::Mat mask_roi = m1(cv::Range(my1, my2), cv::Range(mx1, mx2));
+        cv::Mat rm, det_mask;
+        cv::resize(mask_roi, rm, cv::Size(x2 - x1, y2 - y1));
+        for (int r = 0; r < rm.rows; r++) {
+            for (int c = 0; c < rm.cols; c++) {
+                float pv = rm.at<float>(r, c);
+                if (pv > 0.5) {
+                    rm.at<float>(r, c) = 1.0;
+                }
+                else {
+                    rm.at<float>(r, c) = 0.0;
+                }
+            }
+        }
+        rm = rm * rng.uniform(0, 255);
+        rm.convertTo(det_mask, CV_8UC1);
+        if ((y1 + det_mask.rows) >= input_image.rows) {
+            y2 = input_image.rows - 1;
+        }
+        if ((x1 + det_mask.cols) >= input_image.cols) {
+            x2 = input_image.cols - 1;
+        }
+
+        cv::Mat mask = cv::Mat::zeros(cv::Size(input_image.cols, input_image.rows), CV_8UC1);
+        det_mask(cv::Range(0, y2 - y1), cv::Range(0, x2 - x1)).copyTo(mask(cv::Range(y1, y2), cv::Range(x1, x2)));
+        add(rgb_mask, cv::Scalar(rng.uniform(0, 255), rng.uniform(0, 255), rng.uniform(0, 255)), rgb_mask, mask);
+        if (input_image.size() != rgb_mask.size()) {
+            cv::resize(rgb_mask, rgb_mask, input_image.size());
+        }
+
+        cv::rectangle(input_image, boxes[idx], color, 2, 8);
+        std::string label = cv::format("%.2f", confidences[idx]);
+        label = class_name[class_ids[idx]] + ":" + label;
+        cv::putText(input_image, label, cv::Point(boxes[idx].tl().x, boxes[idx].tl().y - 10), cv::FONT_HERSHEY_SIMPLEX, .5, color);
+        cv::addWeighted(input_image, 0.5, rgb_mask, 0.5, 0, masked_img);
+
+    }
+    printf("Processing finished.\n");
+    return masked_img;
+}
+
+
+
+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_QNN216;
+    } 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;
+
+    std::vector<std::vector<uint32_t>> input_shapes = {{1, 640, 640, 3}};
+    std::vector<std::vector<uint32_t>> output_shapes = {{1,32,8400},{1,4,8400},{1,80,8400},{1,160, 160,32}};
+    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_img;
+    double scale = img_process(frame, input_img, 640);
+    if (input_img.empty()) {
+        printf("detect input_img load failed!\n");
+        return 1;
+    }
+
+    float *qnn_seg_data = nullptr;
+    float *qnn_trans_data = nullptr;
+    float *qnn_mul_data = nullptr;
+    float *qnn_canc_data = nullptr;
+
+    std::vector<float> invoke_time;
+    for (int i = 0; i < args.invoke_nums; ++i) {
+        result = fast_interpreter->set_input_tensor(0, input_img.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_1 = 0;
+        result = fast_interpreter->get_output_tensor(1, (void**)&qnn_canc_data, &out_data_1);
+        if(result != EXIT_SUCCESS){
+            printf("interpreter->get_output_tensor() 1 failed !\n");
+            return EXIT_FAILURE;
+        }
+
+        uint32_t out_data_4 = 0;
+        result = fast_interpreter->get_output_tensor(2, (void**)&qnn_trans_data, &out_data_4);
+        if(result != EXIT_SUCCESS){
+            printf("interpreter->get_output_tensor() 2 failed !\n");
+            return EXIT_FAILURE;
+        }
+
+        uint32_t out_data_2 = 0;
+        result = fast_interpreter->get_output_tensor(0, (void**)&qnn_seg_data, &out_data_2);
+        if(result != EXIT_SUCCESS){
+            printf("interpreter->get_output_tensor() 2 failed !\n");
+            return EXIT_FAILURE;
+        }
+
+        uint32_t out_data_80 = 0;
+        result = fast_interpreter->get_output_tensor(3, (void**)&qnn_mul_data, &out_data_80);
+        if(result != EXIT_SUCCESS){
+            printf("interpreter->get_output_tensor() 2 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");
+
+    float* pos_data = new float[4 * out_size];
+    float* class_data = new float[80 * out_size];
+    float* canc_data = new float[32 * out_size];
+    transformData(qnn_trans_data, pos_data, 4, out_size);
+    transformData(qnn_mul_data, class_data, 80, out_size);
+    transformData(qnn_canc_data, canc_data, 32, out_size);
+    
+    // post process
+    std::vector<float> qnn_concat;
+    concatenate_3(class_data, pos_data, canc_data , 1, out_size, 80, 4, 32, qnn_concat);
+    cv::Mat img = post_process(frame, qnn_concat, class_list, scale, qnn_seg_data, qnn_canc_data);
+    cv::imwrite("./results.png", img);
+    fast_interpreter->destory();
+    return 0;
+}
+
+
+int main(int argc, char* argv[]) {
+    Args args = parse_args(argc, argv);
+    return invoke(args);
+}

model_farm_yolov8s_seg_qsc8550_qnn2.16_int16_aidlite/models/cutoff_yolov8s-seg_w8a16.qnn216.ctx.bin

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

model_farm_yolov8s_seg_qsc8550_qnn2.16_int16_aidlite/python/run_test.py

@@ -0,0 +1,134 @@
+import numpy as np
+import cv2
+import aidlite
+from utils import eqprocess, xywh2xyxy, NMS, process_mask, masks2segments, draw_detect_res
+import os
+import time
+import argparse
+import onnxruntime
+
+# 定义相似度函数
+def get_acc(onnx_out,other_out):
+    cosine_similarity=np.dot(np.array(onnx_out),np.array(other_out))/(np.linalg.norm(np.array(onnx_out)) * np.linalg.norm(np.array(other_out)))
+    return cosine_similarity
+
+
+class qnn_predict(object):
+    def __init__(self,args) -> None:
+        # aidlite.set_log_level(aidlite.LogLevel.INFO)
+        # aidlite.log_to_stderr()
+        # print(f"Aidlite library version : {aidlite.get_library_version()}")
+        # print(f"Aidlite python library version : {aidlite.get_py_library_version()}")
+        config = aidlite.Config.create_instance()
+        if config is None:
+            print("Create model failed !")
+        config.implement_type = aidlite.ImplementType.TYPE_LOCAL
+        config.framework_type = aidlite.FrameworkType.TYPE_QNN
+        config.accelerate_type = aidlite.AccelerateType.TYPE_DSP
+        config.is_quantify_model = 1
+
+        model = aidlite.Model.create_instance(args.target_model)
+        if model is None:
+            print("Create model failed !")
+
+        self.conf = args.conf_thres
+        self.iou=args.iou_thres
+        self.width = args.width
+        self.height = args.height
+        self.class_num = args.class_num
+        self.input_shape = [[1,self.height,self.width,3]]
+        self.blocks = int(self.height * self.width * ( 1 / 64 + 1 / 256 + 1 / 1024))
+        self.maskw = int(self.width / 4)
+        self.maskh = int(self.height / 4)
+        self.output_shape = [[1,32,self.blocks],[1,4,self.blocks],[1,self.class_num,self.blocks],[1,self.maskh, self.maskw,32]]
+        
+        model.set_model_properties(self.input_shape, aidlite.DataType.TYPE_FLOAT32, self.output_shape, aidlite.DataType.TYPE_FLOAT32)
+        self.interpreter = aidlite.InterpreterBuilder.build_interpretper_from_model_and_config(model, config)
+        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("detect model load success!")
+
+    def pretreat_img(self,frame): 
+        img, scale = eqprocess(frame, self.height, self.width)
+        img = img / 255
+        img = img.astype(np.float32)
+        return img,scale
+    
+    def qnn_run(self, orig_imgs,args):
+        input_img_f,scale=self.pretreat_img(orig_imgs)  # 图片resize HWC
+        input_img = np.expand_dims(input_img_f, 0)
+      
+        invoke_time=[]
+        for i in range(args.invoke_nums):
+            self.interpreter.set_input_tensor(0, input_img.data)
+            t0 = time.time()
+            self.interpreter.invoke()
+            t1 = time.time()
+            cost_time=(t1-t0)*1000
+            invoke_time.append(cost_time)
+
+            input0_data = self.interpreter.get_output_tensor(2).reshape(1,4,self.blocks)
+            input1_data = self.interpreter.get_output_tensor(3).reshape(1,self.class_num,self.blocks)
+            input2_data = self.interpreter.get_output_tensor(1).reshape(1,32,self.blocks)
+            protos = self.interpreter.get_output_tensor(0).reshape(1,self.maskh, self.maskw,32).transpose(0,3,1,2)
+
+            boxes = np.concatenate([input0_data, input1_data, input2_data], axis = 1)
+            x = boxes.transpose(0,2,1)
+            x = x[np.amax(x[..., 4:-32], axis=-1) > self.conf]
+            if len(x) < 1:
+                return None, None
+        
+            x = np.c_[x[..., :4], np.amax(x[..., 4:-32], axis=-1), np.argmax(x[..., 4:-32], axis=-1), x[..., -32:]]
+            
+            x[:, :4] = xywh2xyxy(x[:, :4])
+            index = NMS(x[:, :4], x[:, 4], self.iou)
+            out_boxes = x[index]
+            out_boxes[..., :4] = out_boxes[..., :4] * scale
+            
+            masks = process_mask(protos[0], out_boxes[:, -32:], out_boxes[:, :4], orig_imgs.shape)
+            segments = masks2segments(masks)
+           
+        ## time 统计
+        max_invoke_time = max(invoke_time)
+        min_invoke_time = min(invoke_time)
+        mean_invoke_time = sum(invoke_time)/args.invoke_nums
+        var_invoketime=np.var(invoke_time)
+        print("========================================")
+        print(f"QNN inference {args.invoke_nums} times :\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("========================================")
+
+        return out_boxes, segments
+       
+
+def parser_args():
+    parser = argparse.ArgumentParser(description="Run model benchmarks")
+    parser.add_argument('--target_model',type=str,default='./models/cutoff_yolov8s-seg_w8a16.qnn216.ctx.bin',help="inference model path")
+    parser.add_argument('--imgs',type=str,default='./python/bus.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")
+    parser.add_argument('--width',type=int,default=640,help="Model input size")
+    parser.add_argument('--height',type=int,default=640,help="Model input size")
+    parser.add_argument('--conf_thres',type=float,default=0.45,help="confidence threshold for filtering the annotations")
+    parser.add_argument('--iou_thres',type=float,default=0.45,help="Iou threshold for filtering the annotations")
+    parser.add_argument('--class_num',type=int,default=80,help="Iou threshold for filtering the annotations")
+    args = parser.parse_args()
+    return args
+
+def main(args):
+    model = qnn_predict(args)
+    frame = cv2.imread(args.imgs)
+    qnn_out_boxes, qnn_segments = model.qnn_run(frame,args)
+    result = draw_detect_res(frame, qnn_out_boxes, qnn_segments)
+    cv2.imwrite("./python/bus_result.jpg", result)
+
+if __name__ == "__main__":
+    args = parser_args()
+    main(args)
+
+

model_farm_yolov8s_seg_qsc8550_qnn2.16_int16_aidlite/python/utils.py

@@ -0,0 +1,124 @@
+import numpy as np
+import cv2
+
+CLASSES = ("person", "bicycle", "car", "motorbike ", "aeroplane ", "bus ", "train", "truck ", "boat", "traffic light",
+           "fire hydrant", "stop sign ", "parking meter", "bench", "bird", "cat", "dog ", "horse ", "sheep", "cow", "elephant",
+           "bear", "zebra ", "giraffe", "backpack", "umbrella", "handbag", "tie", "suitcase", "frisbee", "skis", "snowboard", "sports ball", "kite",
+           "baseball bat", "baseball glove", "skateboard", "surfboard", "tennis racket", "bottle", "wine glass", "cup", "fork", "knife ",
+           "spoon", "bowl", "banana", "apple", "sandwich", "orange", "broccoli", "carrot", "hot dog", "pizza ", "donut", "cake", "chair", "sofa",
+           "pottedplant", "bed", "diningtable", "toilet ", "tvmonitor", "laptop	", "mouse	", "remote ", "keyboard ", "cell phone", "microwave ",
+           "oven ", "toaster", "sink", "refrigerator ", "book", "clock", "vase", "scissors ", "teddy bear ", "hair drier", "toothbrush ")
+           
+def eqprocess(image, size1, size2):
+    h,w,_ = image.shape
+    mask = np.zeros((size1,size2,3),dtype=np.float32)
+    scale1 = h /size1
+    scale2 = w / size2
+    if scale1 > scale2:
+        scale = scale1
+    else:
+        scale = scale2
+    img = cv2.resize(image,(int(w / scale),int(h / scale)))
+    mask[:int(h / scale),:int(w / scale),:] = img
+    return mask, scale
+
+def xywh2xyxy(x):
+    '''
+    Box (center x, center y, width, height) to (x1, y1, x2, y2)
+    '''
+    y = np.copy(x)
+    y[:, 0] = x[:, 0] - x[:, 2] / 2  # top left x
+    y[:, 1] = x[:, 1] - x[:, 3] / 2  # top left y
+    y[:, 2] = x[:, 0] + x[:, 2] / 2  # bottom right x
+    y[:, 3] = x[:, 1] + x[:, 3] / 2  # bottom right y
+    return y
+
+def xyxy2xywh(box):
+    '''
+    Box (left_top x, left_top y, right_bottom x, right_bottom y) to (left_top x, left_top y, width, height)
+    '''
+    box[:, 2:] = box[:, 2:] - box[:, :2]
+    return box
+
+def NMS(dets, scores, thresh):
+    '''
+    单类NMS算法
+    dets.shape = (N, 5), (left_top x, left_top y, right_bottom x, right_bottom y, Scores)
+    '''
+    x1 = dets[:,0]
+    y1 = dets[:,1]
+    x2 = dets[:,2]
+    y2 = dets[:,3]
+    areas = (y2-y1+1) * (x2-x1+1)
+    keep = []
+    index = scores.argsort()[::-1]
+    while index.size >0:
+        i = index[0]       # every time the first is the biggst, and add it directly
+        keep.append(i)
+        x11 = np.maximum(x1[i], x1[index[1:]])    # calculate the points of overlap 
+        y11 = np.maximum(y1[i], y1[index[1:]])
+        x22 = np.minimum(x2[i], x2[index[1:]])
+        y22 = np.minimum(y2[i], y2[index[1:]])
+        w = np.maximum(0, x22-x11+1)    # the weights of overlap
+        h = np.maximum(0, y22-y11+1)    # the height of overlap
+        overlaps = w*h
+        ious = overlaps / (areas[i]+areas[index[1:]] - overlaps)
+        idx = np.where(ious<=thresh)[0]
+        index = index[idx+1]   # because index start from 1
+ 
+    return keep
+
+def draw_detect_res(img, det_pred, segments):
+    '''
+    检测结果绘制
+    '''
+    if det_pred is None:
+        return img
+
+    img = img.astype(np.uint8)
+    im_canvas = img.copy()
+    color_step = int(255/len(CLASSES))
+    for i in range(len(det_pred)):
+        x1, y1, x2, y2 = [int(t) for t in det_pred[i][:4]]
+        cls_id = int(det_pred[i][5])
+        cv2.putText(img, f'{CLASSES[cls_id]}', (x1, y1-6), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1)
+        cv2.rectangle(img, (x1, y1), (x2, y2), (0, int(cls_id*color_step), int(255-cls_id*color_step)),thickness = 2)
+        if len(segments[i]) > 0:
+            cv2.polylines(img, np.int32([segments[i]]), True, (0, int(cls_id*color_step), int(255-cls_id*color_step)), 2)
+            cv2.fillPoly(img, np.int32([segments[i]]), (0, int(cls_id*color_step), int(255-cls_id*color_step)))
+    img = cv2.addWeighted(im_canvas, 0.3, img, 0.7, 0)
+    return img
+
+def scale_mask(masks, im0_shape):
+    masks = cv2.resize(masks, (im0_shape[1], im0_shape[0]),
+                        interpolation=cv2.INTER_LINEAR)
+    if len(masks.shape) == 2:
+        masks = masks[:, :, None]
+    return masks
+
+def crop_mask(masks, boxes):
+    n, h, w = masks.shape
+    x1, y1, x2, y2 = np.split(boxes[:, :, None], 4, 1)
+    r = np.arange(w, dtype=x1.dtype)[None, None, :]
+    c = np.arange(h, dtype=x1.dtype)[None, :, None]
+    return masks * ((r >= x1) * (r < x2) * (c >= y1) * (c < y2))
+
+def process_mask(protos, masks_in, bboxes, im0_shape):
+    c, mh, mw = protos.shape
+    masks = np.matmul(masks_in, protos.reshape((c, -1))).reshape((-1, mh, mw)).transpose(1, 2, 0)  # HWN
+    masks = np.ascontiguousarray(masks)
+    masks = scale_mask(masks, im0_shape)  # re-scale mask from P3 shape to original input image shape
+    masks = np.einsum('HWN -> NHW', masks)  # HWN -> NHW
+    masks = crop_mask(masks, bboxes)
+    return np.greater(masks, 0.5)
+
+def masks2segments(masks):
+    segments = []
+    for x in masks.astype('uint8'):
+        c = cv2.findContours(x, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)[0]  # CHAIN_APPROX_SIMPLE
+        if c:
+            c = np.array(c[np.array([len(x) for x in c]).argmax()]).reshape(-1, 2)
+        else:
+            c = np.zeros((0, 2))  # no segments found
+        segments.append(c.astype('float32'))
+    return segments

model_farm_yolov8s_seg_qsc8550_qnn2.16_int8_aidlite/README.md

@@ -0,0 +1,56 @@
+## Model Information
+## Source model
+- Input shape: 640x640
+- Number of parameters: 11.27M
+- Model size: 45.22M
+- Output shape: 1x32x160x160, 1x116x8400
+
+Source model repository: [yolov8](https://github.com/ultralytics/ultralytics)
+
+### 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 yolov8s_seg/model_farm_yolov8s_seg_qsc8550_qnn2.16_int8_aidlite
+python3 ./python/run_test.py --target_model ./models/cutoff_yolov8s-seg_w8a8.qnn216.ctx.bin --imgs ./python/bus.jpg  --invoke_nums 10
+```
+
+#### cpp
+```bash
+cd yolov8s_seg/model_farm_yolov8s_seg_qsc8550_qnn2.16_int8_aidlite/cpp
+mkdir build && cd build 
+cmake ..
+make
+./run_test
+```
+

model_farm_yolov8s_seg_qsc8550_qnn2.16_int8_aidlite/cpp/CMakeLists.txt

@@ -0,0 +1,31 @@
+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
+)

model_farm_yolov8s_seg_qsc8550_qnn2.16_int8_aidlite/cpp/run_test.cpp

@@ -0,0 +1,484 @@
+#include <iostream>
+#include <string>
+#include <algorithm>
+#include <cctype>
+#include <cstring> // 用于 memcpy
+#include <opencv2/opencv.hpp>
+#include <aidlux/aidlite/aidlite.hpp>
+#include <vector>
+#include <numeric>
+
+const float INPUT_WIDTH = 640.0;
+const float INPUT_HEIGHT = 640.0;
+const float SCORE_THRESHOLD = 0.25;
+const float NMS_THRESHOLD = 0.45;
+const float CONFIDENCE_THRESHOLD = 0.25;
+const uint32_t out_size = 8400;
+
+const int FONT_FACE = cv::FONT_HERSHEY_SIMPLEX;
+cv::Scalar WHITE = cv::Scalar(255,255,255);
+
+const float FONT_SCALE = 0.75;
+const int THICKNESS = 1;
+
+const std::vector<std::string> class_list = {
+    "person", "bicycle", "car", "motorcycle", "airplane", "bus", "train",
+    "truck", "boat", "traffic light", "fire hydrant", "stop sign", "parking meter",
+    "bench", "bird", "cat", "dog", "horse", "sheep", "cow", "elephant", "bear",
+    "zebra", "giraffe", "backpack", "umbrella", "handbag", "tie", "suitcase",
+    "frisbee", "skis", "snowboard", "sports ball", "kite", "baseball bat",
+    "baseball glove", "skateboard", "surfboard", "tennis racket", "bottle",
+    "wine glass", "cup", "fork", "knife", "spoon", "bowl", "banana", "apple",
+    "sandwich", "orange", "broccoli", "carrot", "hot dog", "pizza", "donut",
+    "cake", "chair", "couch", "potted plant", "bed", "dining table", "toilet",
+    "TV", "laptop", "mouse", "remote", "keyboard", "cell phone", "microwave",
+    "oven", "toaster", "sink", "refrigerator", "book", "clock", "vase",
+    "scissors", "teddy bear", "hair drier", "toothbrush"
+};
+
+using namespace cv;
+using namespace std;
+using namespace Aidlux::Aidlite;
+
+struct Args {
+    std::string target_model = "../../models/cutoff_yolov8s-seg_w8a8.qnn216.ctx.bin";
+    std::string imgs = "../bus.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;
+}
+
+// concatenate_3(80_class_data, 4_pos_data , 32_canc_data, 1, 8400, 80, 4,32, qnn_concat);
+void concatenate_3(float* qnn_trans_data, float* qnn_mul_data, float* qnn_canc_data, int batch, int num_elements, int trans_dim, int mul_dim, int canc_dim,std::vector<float>& output) {
+    // int out_dim = trans_dim + mul_dim + canc_dim + 1; //117
+    int out_dim = trans_dim + mul_dim + canc_dim; //116
+    output.resize(batch * num_elements * out_dim); 
+    for (int i = 0; i < batch * num_elements; ++i) {
+        std::memcpy(&output[i * out_dim], &qnn_mul_data[i * mul_dim], mul_dim * sizeof(float));
+        std::memcpy(&output[i * out_dim + mul_dim], &qnn_trans_data[i * trans_dim], trans_dim * sizeof(float));
+        std::memcpy(&output[i * out_dim + mul_dim + trans_dim], &qnn_canc_data[i * canc_dim], canc_dim * sizeof(float));
+    }
+}
+
+// 4*8400
+void transformData(const float* input, float* output, int C, int N) {
+    for (int c = 0; c < C; ++c) {
+        for (int n = 0; n < N; ++n) {
+            output[n * C + c] = input[c * N + n];
+        }
+    }
+}
+
+double img_process(cv::Mat frame, cv::Mat &img_input, int size) {
+    cv::Mat img_processed = frame.clone();
+    int height = img_processed.rows;
+    int width = img_processed.cols;
+    int length = std::max(height, width);
+    double scala = static_cast<double>(length) / size;
+    
+    cv::Mat image = cv::Mat::zeros(cv::Size(length, length), CV_8UC3);
+    img_processed.copyTo(image(cv::Rect(0, 0, width, height)));
+    
+    cv::cvtColor(image, img_input, cv::COLOR_BGR2RGB);
+    cv::resize(img_input, img_input, cv::Size(size, size));
+    
+    cv::Mat mean_data = cv::Mat::zeros(img_input.size(), CV_32FC3);
+    cv::Mat std_data(img_input.size(), CV_32FC3, cv::Scalar(255, 255, 255));
+    img_input.convertTo(img_input, CV_32FC3);
+    img_input = (img_input - mean_data) / std_data;
+    return scala;
+}
+
+
+cv::Scalar generate_colors(int i, bool bgr = false) {
+    static const std::vector<std::string> hex_colors = {
+        "FF3838", "FF9D97", "FF701F", "FFB21D", "CFD231", "48F90A",
+        "92CC17", "3DDB86", "1A9334", "00D4BB", "2C99A8", "00C2FF",
+        "344593", "6473FF", "0018EC", "8438FF", "520085", "CB38FF",
+        "FF95C8", "FF37C7"
+    };
+
+    int num = hex_colors.size();
+    std::string hex = hex_colors[i % num];
+
+    int r = std::stoi(hex.substr(0, 2), nullptr, 16);
+    int g = std::stoi(hex.substr(2, 2), nullptr, 16);
+    int b = std::stoi(hex.substr(4, 2), nullptr, 16);
+
+    if (bgr)
+        return cv::Scalar(b, g, r);
+    else
+        return cv::Scalar(r, g, b);
+}
+
+float sigmoid_function(float a)
+{
+    float b = 1. / (1. + exp(-a));
+    return b;
+}
+
+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;
+}
+
+
+void draw_label(cv::Mat& input_image, std::string label, int left, int top, cv::Scalar color)
+{
+    int baseLine;
+    cv::Size label_size = cv::getTextSize(label, FONT_FACE, FONT_SCALE, THICKNESS, &baseLine);
+    int y = top - label_size.height - baseLine;
+    if (y < 0) {
+        y = top ;
+    }
+    cv::Point tlc(left, y);
+    cv::Point brc(left + label_size.width, y + label_size.height + baseLine);
+    rectangle(input_image, tlc, brc, color, cv::FILLED);
+    putText(input_image, label, cv::Point(left, y + label_size.height), FONT_FACE, FONT_SCALE, WHITE, THICKNESS);
+}
+
+
+cv::Mat post_process(cv::Mat &frame, std::vector<float> &outputs, const std::vector<std::string> &class_name, 
+    const double ratio, float* protos_data, float* qnn_canc)
+{
+    cv::Mat input_image = frame.clone();
+    // Initialize vectors to hold respective outputs while unwrapping detections.
+    std::vector<int> class_ids;
+    std::vector<float> confidences;
+    std::vector<cv::Rect> boxes;
+    std::vector<cv::Mat> masks;
+    std::vector<float> class_scores;
+    cv::RNG rng;
+    cv::Mat masked_img;
+
+    unsigned int src_dims[4] = {1, 32,160,160};
+    unsigned int tsp_dims[4] = {0,3,1,2};
+    unsigned int stride_data_num = 1*32*160*160;
+    float* format_data = new float[stride_data_num];
+    transpose(protos_data, src_dims, tsp_dims, format_data);
+    cv::Mat proto_buffer(32, 160*160, CV_32F, format_data);
+    std::cout << "proto_buffer 维度: " << proto_buffer.rows << "x" << proto_buffer.cols << std::endl;
+
+    for (int i = 0; i < outputs.size(); i+=116)
+    {
+        auto start = outputs.begin() + i + 4;
+        auto end = outputs.begin() + i + 84;
+        float max_val = *std::max_element(start, end);
+        float confidence = max_val;
+        if (confidence >= CONFIDENCE_THRESHOLD)
+        {
+            auto start = outputs.begin() + i + 4;
+            auto end = outputs.begin() + i + 84;
+            std::vector<float> middle_data;
+            middle_data.assign(start, end);
+            // Create a 1x80 Mat and store class scores of 80 classes.
+            cv::Mat scores(1, class_name.size(), CV_32FC1, middle_data.data());
+            cv::Point class_id;
+            double max_class_score;
+            
+            // For multi-label, check each class score
+            for (int c = 0; c < class_name.size(); c++) {
+                float class_score = scores.at<float>(0, c);
+                // If class score is above threshold, consider this class for the box
+                if (class_score > SCORE_THRESHOLD) {
+                    std::vector<float> last32_data;
+                    auto st_32= outputs.begin() + i + 84;
+                    auto ed_32 = outputs.begin() + i + 116;
+                    last32_data.assign(st_32, ed_32);
+                    cv::Mat mask(1, 32, CV_32FC1, last32_data.data());
+                    // Store class ID and confidence in the pre-defined respective vectors.
+                    confidences.push_back(confidence * class_score);  // Multiply with confidence
+                    class_ids.push_back(c);  // class index
+                    // Center and box dimension.
+                    float cx = outputs[i];
+                    float cy = outputs[i+1];
+                    float w = outputs[i+2];
+                    float h = outputs[i+3];
+
+                    int left = int((cx - 0.5 * w) * ratio);
+                    int top = int((cy - 0.5 * h) * ratio);
+                    int width = int(w * ratio);
+                    int height = int(h * ratio);
+
+                    // Store good detections in the boxes vector.
+                    boxes.push_back(cv::Rect(left, top, width, height));
+                    masks.push_back(mask);
+                }
+            }
+        }
+    }
+
+    std::cout << "boxes.size(): " << boxes.size() << ",confidences.size():" << confidences.size() << std::endl; 
+
+    // Perform Non Maximum Suppression and draw predictions.
+    std::vector<int> indices;
+    cv::dnn::NMSBoxes(boxes, confidences, SCORE_THRESHOLD, NMS_THRESHOLD, indices);
+    printf("Detected {%ld} targets.\n", indices.size());
+    cv::Mat rgb_mask = cv::Mat::zeros(input_image.size(), input_image.type());
+    
+    // Loop over NMS results and draw bounding boxes
+    for (int i = 0; i < indices.size(); i++)
+    {
+        int idx = indices[i];
+        cv::Rect box = boxes[idx];
+        cv::Scalar color = generate_colors(class_ids[idx]);
+
+        int x1 = std::max(0, box.x);
+        int y1 = std::max(0, box.y);
+        int x2 = std::max(0, box.br().x);
+        int y2 = std::max(0, box.br().y);
+        cv::Mat ms = masks[idx];
+        // 维度验证
+        if (ms.cols != proto_buffer.rows) {
+            cerr << "维度不匹配: mask.cols=" << ms.cols 
+                 << ", proto_buffer.rows=" << proto_buffer.rows << endl;
+            continue;
+        }
+        cv::Mat m = ms * proto_buffer;
+        for (int col = 0; col < m.cols; col++) {
+            m.at<float>(0, col) = sigmoid_function(m.at<float>(0, col));
+        }
+        cv::Mat m1 = m.reshape(1, 160); // 1x25600 -> 160x160
+
+        float ratio2 = 160.0/640.0;
+        int mx1 = std::max(0, int((x1 * ratio2)));
+        int mx2 = std::max(0, int((x2 * ratio2)));
+        int my1 = std::max(0, int((y1 * ratio2)));
+        int my2 = std::max(0, int((y2 * ratio2)));
+        cv::Mat mask_roi = m1(cv::Range(my1, my2), cv::Range(mx1, mx2));
+        cv::Mat rm, det_mask;
+        cv::resize(mask_roi, rm, cv::Size(x2 - x1, y2 - y1));
+        for (int r = 0; r < rm.rows; r++) {
+            for (int c = 0; c < rm.cols; c++) {
+                float pv = rm.at<float>(r, c);
+                if (pv > 0.5) {
+                    rm.at<float>(r, c) = 1.0;
+                }
+                else {
+                    rm.at<float>(r, c) = 0.0;
+                }
+            }
+        }
+        rm = rm * rng.uniform(0, 255);
+        rm.convertTo(det_mask, CV_8UC1);
+        if ((y1 + det_mask.rows) >= input_image.rows) {
+            y2 = input_image.rows - 1;
+        }
+        if ((x1 + det_mask.cols) >= input_image.cols) {
+            x2 = input_image.cols - 1;
+        }
+
+        cv::Mat mask = cv::Mat::zeros(cv::Size(input_image.cols, input_image.rows), CV_8UC1);
+        det_mask(cv::Range(0, y2 - y1), cv::Range(0, x2 - x1)).copyTo(mask(cv::Range(y1, y2), cv::Range(x1, x2)));
+        add(rgb_mask, cv::Scalar(rng.uniform(0, 255), rng.uniform(0, 255), rng.uniform(0, 255)), rgb_mask, mask);
+        if (input_image.size() != rgb_mask.size()) {
+            cv::resize(rgb_mask, rgb_mask, input_image.size());
+        }
+
+        cv::rectangle(input_image, boxes[idx], color, 2, 8);
+        std::string label = cv::format("%.2f", confidences[idx]);
+        label = class_name[class_ids[idx]] + ":" + label;
+        cv::putText(input_image, label, cv::Point(boxes[idx].tl().x, boxes[idx].tl().y - 10), cv::FONT_HERSHEY_SIMPLEX, .5, color);
+        cv::addWeighted(input_image, 0.5, rgb_mask, 0.5, 0, masked_img);
+
+    }
+    printf("Processing finished.\n");
+    return masked_img;
+}
+
+
+
+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;
+
+    std::vector<std::vector<uint32_t>> input_shapes = {{1, 640, 640, 3}};
+    std::vector<std::vector<uint32_t>> output_shapes = {{1,32,8400},{1,4,8400},{1,80,8400},{1,160, 160,32}};
+    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_img;
+    double scale = img_process(frame, input_img, 640);
+    if (input_img.empty()) {
+        printf("detect input_img load failed!\n");
+        return 1;
+    }
+
+    float *qnn_seg_data = nullptr;
+    float *qnn_trans_data = nullptr;
+    float *qnn_mul_data = nullptr;
+    float *qnn_canc_data = nullptr;
+
+    std::vector<float> invoke_time;
+    for (int i = 0; i < args.invoke_nums; ++i) {
+        result = fast_interpreter->set_input_tensor(0, input_img.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_1 = 0;
+        result = fast_interpreter->get_output_tensor(1, (void**)&qnn_canc_data, &out_data_1);
+        if(result != EXIT_SUCCESS){
+            printf("interpreter->get_output_tensor() 1 failed !\n");
+            return EXIT_FAILURE;
+        }
+
+        uint32_t out_data_4 = 0;
+        result = fast_interpreter->get_output_tensor(2, (void**)&qnn_trans_data, &out_data_4);
+        if(result != EXIT_SUCCESS){
+            printf("interpreter->get_output_tensor() 2 failed !\n");
+            return EXIT_FAILURE;
+        }
+
+        uint32_t out_data_2 = 0;
+        result = fast_interpreter->get_output_tensor(0, (void**)&qnn_seg_data, &out_data_2);
+        if(result != EXIT_SUCCESS){
+            printf("interpreter->get_output_tensor() 2 failed !\n");
+            return EXIT_FAILURE;
+        }
+
+        uint32_t out_data_80 = 0;
+        result = fast_interpreter->get_output_tensor(3, (void**)&qnn_mul_data, &out_data_80);
+        if(result != EXIT_SUCCESS){
+            printf("interpreter->get_output_tensor() 2 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");
+
+    float* pos_data = new float[4 * out_size];
+    float* class_data = new float[80 * out_size];
+    float* canc_data = new float[32 * out_size];
+    transformData(qnn_trans_data, pos_data, 4, out_size);
+    transformData(qnn_mul_data, class_data, 80, out_size);
+    transformData(qnn_canc_data, canc_data, 32, out_size);
+    
+    // post process
+    std::vector<float> qnn_concat;
+    concatenate_3(class_data, pos_data, canc_data , 1, out_size, 80, 4, 32, qnn_concat);
+    cv::Mat img = post_process(frame, qnn_concat, class_list, scale, qnn_seg_data, qnn_canc_data);
+    cv::imwrite("./results.png", img);
+    fast_interpreter->destory();
+    return 0;
+}
+
+
+int main(int argc, char* argv[]) {
+    Args args = parse_args(argc, argv);
+    return invoke(args);
+}

model_farm_yolov8s_seg_qsc8550_qnn2.16_int8_aidlite/models/cutoff_yolov8s-seg_w8a8.qnn216.ctx.bin

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

model_farm_yolov8s_seg_qsc8550_qnn2.16_int8_aidlite/python/run_test.py

@@ -0,0 +1,134 @@
+import numpy as np
+import cv2
+import aidlite
+from utils import eqprocess, xywh2xyxy, NMS, process_mask, masks2segments, draw_detect_res
+import os
+import time
+import argparse
+import onnxruntime
+
+# 定义相似度函数
+def get_acc(onnx_out,other_out):
+    cosine_similarity=np.dot(np.array(onnx_out),np.array(other_out))/(np.linalg.norm(np.array(onnx_out)) * np.linalg.norm(np.array(other_out)))
+    return cosine_similarity
+
+
+class qnn_predict(object):
+    def __init__(self,args) -> None:
+        # aidlite.set_log_level(aidlite.LogLevel.INFO)
+        # aidlite.log_to_stderr()
+        # print(f"Aidlite library version : {aidlite.get_library_version()}")
+        # print(f"Aidlite python library version : {aidlite.get_py_library_version()}")
+        config = aidlite.Config.create_instance()
+        if config is None:
+            print("Create model failed !")
+        config.implement_type = aidlite.ImplementType.TYPE_LOCAL
+        config.framework_type = aidlite.FrameworkType.TYPE_QNN
+        config.accelerate_type = aidlite.AccelerateType.TYPE_DSP
+        config.is_quantify_model = 1
+
+        model = aidlite.Model.create_instance(args.target_model)
+        if model is None:
+            print("Create model failed !")
+
+        self.conf = args.conf_thres
+        self.iou=args.iou_thres
+        self.width = args.width
+        self.height = args.height
+        self.class_num = args.class_num
+        self.input_shape = [[1,self.height,self.width,3]]
+        self.blocks = int(self.height * self.width * ( 1 / 64 + 1 / 256 + 1 / 1024))
+        self.maskw = int(self.width / 4)
+        self.maskh = int(self.height / 4)
+        self.output_shape = [[1,32,self.blocks],[1,4,self.blocks],[1,self.class_num,self.blocks],[1,self.maskh, self.maskw,32]]
+        
+        model.set_model_properties(self.input_shape, aidlite.DataType.TYPE_FLOAT32, self.output_shape, aidlite.DataType.TYPE_FLOAT32)
+        self.interpreter = aidlite.InterpreterBuilder.build_interpretper_from_model_and_config(model, config)
+        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("detect model load success!")
+
+    def pretreat_img(self,frame): 
+        img, scale = eqprocess(frame, self.height, self.width)
+        img = img / 255
+        img = img.astype(np.float32)
+        return img,scale
+    
+    def qnn_run(self, orig_imgs,args):
+        input_img_f,scale=self.pretreat_img(orig_imgs)  # 图片resize HWC
+        input_img = np.expand_dims(input_img_f, 0)
+      
+        invoke_time=[]
+        for i in range(args.invoke_nums):
+            self.interpreter.set_input_tensor(0, input_img.data)
+            t0 = time.time()
+            self.interpreter.invoke()
+            t1 = time.time()
+            cost_time=(t1-t0)*1000
+            invoke_time.append(cost_time)
+
+            input0_data = self.interpreter.get_output_tensor(2).reshape(1,4,self.blocks)
+            input1_data = self.interpreter.get_output_tensor(3).reshape(1,self.class_num,self.blocks)
+            input2_data = self.interpreter.get_output_tensor(1).reshape(1,32,self.blocks)
+            protos = self.interpreter.get_output_tensor(0).reshape(1,self.maskh, self.maskw,32).transpose(0,3,1,2)
+
+            boxes = np.concatenate([input0_data, input1_data, input2_data], axis = 1)
+            x = boxes.transpose(0,2,1)
+            x = x[np.amax(x[..., 4:-32], axis=-1) > self.conf]
+            if len(x) < 1:
+                return None, None
+        
+            x = np.c_[x[..., :4], np.amax(x[..., 4:-32], axis=-1), np.argmax(x[..., 4:-32], axis=-1), x[..., -32:]]
+            
+            x[:, :4] = xywh2xyxy(x[:, :4])
+            index = NMS(x[:, :4], x[:, 4], self.iou)
+            out_boxes = x[index]
+            out_boxes[..., :4] = out_boxes[..., :4] * scale
+            
+            masks = process_mask(protos[0], out_boxes[:, -32:], out_boxes[:, :4], orig_imgs.shape)
+            segments = masks2segments(masks)
+           
+        ## time 统计
+        max_invoke_time = max(invoke_time)
+        min_invoke_time = min(invoke_time)
+        mean_invoke_time = sum(invoke_time)/args.invoke_nums
+        var_invoketime=np.var(invoke_time)
+        print("========================================")
+        print(f"QNN inference {args.invoke_nums} times :\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("========================================")
+
+        return out_boxes, segments
+       
+
+def parser_args():
+    parser = argparse.ArgumentParser(description="Run model benchmarks")
+    parser.add_argument('--target_model',type=str,default='./models/cutoff_yolov8s-seg_w8a8.qnn216.ctx.bin',help="inference model path")
+    parser.add_argument('--imgs',type=str,default='./python/bus.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")
+    parser.add_argument('--width',type=int,default=640,help="Model input size")
+    parser.add_argument('--height',type=int,default=640,help="Model input size")
+    parser.add_argument('--conf_thres',type=float,default=0.45,help="confidence threshold for filtering the annotations")
+    parser.add_argument('--iou_thres',type=float,default=0.45,help="Iou threshold for filtering the annotations")
+    parser.add_argument('--class_num',type=int,default=80,help="Iou threshold for filtering the annotations")
+    args = parser.parse_args()
+    return args
+
+def main(args):
+    model = qnn_predict(args)
+    frame = cv2.imread(args.imgs)
+    qnn_out_boxes, qnn_segments = model.qnn_run(frame,args)
+    result = draw_detect_res(frame, qnn_out_boxes, qnn_segments)
+    cv2.imwrite("./python/bus_result.jpg", result)
+
+if __name__ == "__main__":
+    args = parser_args()
+    main(args)
+
+

model_farm_yolov8s_seg_qsc8550_qnn2.16_int8_aidlite/python/utils.py

@@ -0,0 +1,124 @@
+import numpy as np
+import cv2
+
+CLASSES = ("person", "bicycle", "car", "motorbike ", "aeroplane ", "bus ", "train", "truck ", "boat", "traffic light",
+           "fire hydrant", "stop sign ", "parking meter", "bench", "bird", "cat", "dog ", "horse ", "sheep", "cow", "elephant",
+           "bear", "zebra ", "giraffe", "backpack", "umbrella", "handbag", "tie", "suitcase", "frisbee", "skis", "snowboard", "sports ball", "kite",
+           "baseball bat", "baseball glove", "skateboard", "surfboard", "tennis racket", "bottle", "wine glass", "cup", "fork", "knife ",
+           "spoon", "bowl", "banana", "apple", "sandwich", "orange", "broccoli", "carrot", "hot dog", "pizza ", "donut", "cake", "chair", "sofa",
+           "pottedplant", "bed", "diningtable", "toilet ", "tvmonitor", "laptop	", "mouse	", "remote ", "keyboard ", "cell phone", "microwave ",
+           "oven ", "toaster", "sink", "refrigerator ", "book", "clock", "vase", "scissors ", "teddy bear ", "hair drier", "toothbrush ")
+           
+def eqprocess(image, size1, size2):
+    h,w,_ = image.shape
+    mask = np.zeros((size1,size2,3),dtype=np.float32)
+    scale1 = h /size1
+    scale2 = w / size2
+    if scale1 > scale2:
+        scale = scale1
+    else:
+        scale = scale2
+    img = cv2.resize(image,(int(w / scale),int(h / scale)))
+    mask[:int(h / scale),:int(w / scale),:] = img
+    return mask, scale
+
+def xywh2xyxy(x):
+    '''
+    Box (center x, center y, width, height) to (x1, y1, x2, y2)
+    '''
+    y = np.copy(x)
+    y[:, 0] = x[:, 0] - x[:, 2] / 2  # top left x
+    y[:, 1] = x[:, 1] - x[:, 3] / 2  # top left y
+    y[:, 2] = x[:, 0] + x[:, 2] / 2  # bottom right x
+    y[:, 3] = x[:, 1] + x[:, 3] / 2  # bottom right y
+    return y
+
+def xyxy2xywh(box):
+    '''
+    Box (left_top x, left_top y, right_bottom x, right_bottom y) to (left_top x, left_top y, width, height)
+    '''
+    box[:, 2:] = box[:, 2:] - box[:, :2]
+    return box
+
+def NMS(dets, scores, thresh):
+    '''
+    单类NMS算法
+    dets.shape = (N, 5), (left_top x, left_top y, right_bottom x, right_bottom y, Scores)
+    '''
+    x1 = dets[:,0]
+    y1 = dets[:,1]
+    x2 = dets[:,2]
+    y2 = dets[:,3]
+    areas = (y2-y1+1) * (x2-x1+1)
+    keep = []
+    index = scores.argsort()[::-1]
+    while index.size >0:
+        i = index[0]       # every time the first is the biggst, and add it directly
+        keep.append(i)
+        x11 = np.maximum(x1[i], x1[index[1:]])    # calculate the points of overlap 
+        y11 = np.maximum(y1[i], y1[index[1:]])
+        x22 = np.minimum(x2[i], x2[index[1:]])
+        y22 = np.minimum(y2[i], y2[index[1:]])
+        w = np.maximum(0, x22-x11+1)    # the weights of overlap
+        h = np.maximum(0, y22-y11+1)    # the height of overlap
+        overlaps = w*h
+        ious = overlaps / (areas[i]+areas[index[1:]] - overlaps)
+        idx = np.where(ious<=thresh)[0]
+        index = index[idx+1]   # because index start from 1
+ 
+    return keep
+
+def draw_detect_res(img, det_pred, segments):
+    '''
+    检测结果绘制
+    '''
+    if det_pred is None:
+        return img
+
+    img = img.astype(np.uint8)
+    im_canvas = img.copy()
+    color_step = int(255/len(CLASSES))
+    for i in range(len(det_pred)):
+        x1, y1, x2, y2 = [int(t) for t in det_pred[i][:4]]
+        cls_id = int(det_pred[i][5])
+        cv2.putText(img, f'{CLASSES[cls_id]}', (x1, y1-6), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1)
+        cv2.rectangle(img, (x1, y1), (x2, y2), (0, int(cls_id*color_step), int(255-cls_id*color_step)),thickness = 2)
+        if len(segments[i]) > 0:
+            cv2.polylines(img, np.int32([segments[i]]), True, (0, int(cls_id*color_step), int(255-cls_id*color_step)), 2)
+            cv2.fillPoly(img, np.int32([segments[i]]), (0, int(cls_id*color_step), int(255-cls_id*color_step)))
+    img = cv2.addWeighted(im_canvas, 0.3, img, 0.7, 0)
+    return img
+
+def scale_mask(masks, im0_shape):
+    masks = cv2.resize(masks, (im0_shape[1], im0_shape[0]),
+                        interpolation=cv2.INTER_LINEAR)
+    if len(masks.shape) == 2:
+        masks = masks[:, :, None]
+    return masks
+
+def crop_mask(masks, boxes):
+    n, h, w = masks.shape
+    x1, y1, x2, y2 = np.split(boxes[:, :, None], 4, 1)
+    r = np.arange(w, dtype=x1.dtype)[None, None, :]
+    c = np.arange(h, dtype=x1.dtype)[None, :, None]
+    return masks * ((r >= x1) * (r < x2) * (c >= y1) * (c < y2))
+
+def process_mask(protos, masks_in, bboxes, im0_shape):
+    c, mh, mw = protos.shape
+    masks = np.matmul(masks_in, protos.reshape((c, -1))).reshape((-1, mh, mw)).transpose(1, 2, 0)  # HWN
+    masks = np.ascontiguousarray(masks)
+    masks = scale_mask(masks, im0_shape)  # re-scale mask from P3 shape to original input image shape
+    masks = np.einsum('HWN -> NHW', masks)  # HWN -> NHW
+    masks = crop_mask(masks, bboxes)
+    return np.greater(masks, 0.5)
+
+def masks2segments(masks):
+    segments = []
+    for x in masks.astype('uint8'):
+        c = cv2.findContours(x, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)[0]  # CHAIN_APPROX_SIMPLE
+        if c:
+            c = np.array(c[np.array([len(x) for x in c]).argmax()]).reshape(-1, 2)
+        else:
+            c = np.zeros((0, 2))  # no segments found
+        segments.append(c.astype('float32'))
+    return segments