yolov10 pr

examples/ax650/CMakeLists.txt

@@ -36,6 +36,7 @@ axera_example(ax_yolov8_pose ax_yolov8_pose_steps.cc)
 axera_example(ax_yolov8_obb ax_yolov8_obb_steps.cc)
 axera_example(ax_yolov9 ax_yolov9_steps.cc)
 axera_example(ax_yolox ax_yolox_steps.cc)
+axera_example(ax_yolov10 ax_yolov10s_steps.cc)
 axera_example(ax_yolo_nas ax_yolo_nas_steps.cc)
 axera_example(ax_yolo_world ax_yolo_world_steps.cc)
 

examples/ax650/ax_yolov10s_steps.cc

@@ -0,0 +1,232 @@
+/*
+* AXERA is pleased to support the open source community by making ax-samples available.
+*
+* Copyright (c) 2024, AXERA Semiconductor Co., Ltd. All rights reserved.
+*
+* Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
+* in compliance with the License. You may obtain a copy of the License at
+*
+* https://opensource.org/licenses/BSD-3-Clause
+*
+* Unless required by applicable law or agreed to in writing, software distributed
+* under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+* CONDITIONS OF ANY KIND, either express or implied. See the License for the
+* specific language governing permissions and limitations under the License.
+*/
+
+/*
+* Author: ejuoy
+*/
+
+#include <cstdio>
+#include <cstring>
+#include <numeric>
+
+#include <opencv2/opencv.hpp>
+#include "base/common.hpp"
+#include "base/detection.hpp"
+#include "middleware/io.hpp"
+
+#include "utilities/args.hpp"
+#include "utilities/cmdline.hpp"
+#include "utilities/file.hpp"
+#include "utilities/timer.hpp"
+
+#include <ax_sys_api.h>
+#include <ax_engine_api.h>
+
+const int DEFAULT_IMG_H = 640;
+const int DEFAULT_IMG_W = 640;
+
+const char* CLASS_NAMES[] = {
+    "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"};
+
+int NUM_CLASS = 80;
+
+const int DEFAULT_LOOP_COUNT = 1;
+
+const float PROB_THRESHOLD = 0.25f;
+
+namespace ax
+{
+    void post_process(AX_ENGINE_IO_INFO_T* io_info, AX_ENGINE_IO_T* io_data, const cv::Mat& mat, int input_w, int input_h, const std::vector<float>& time_costs)
+    {
+        std::vector<detection::Object> proposals;
+        std::vector<detection::Object> objects;
+        for (uint32_t i = 0; i < io_info->nOutputSize; ++i)
+        {
+            auto& output = io_data->pOutputs[i];
+            auto& info = io_info->pOutputs[i];
+            auto ptr = (float*)output.pVirAddr;
+            int32_t stride = (1 << i) * 8;
+            detection::generate_proposals_yolov10(stride, ptr, PROB_THRESHOLD, proposals, input_w, input_h);
+        }
+
+        detection::get_out_bbox(proposals, input_h, input_w, mat.rows, mat.cols);
+        detection::draw_objects(mat, proposals, CLASS_NAMES, "yolov10s_out");
+    }
+
+    bool run_model(const std::string& model, const std::vector<uint8_t>& data, const int& repeat, cv::Mat& mat, int input_h, int input_w)
+    {
+        // 1. init engine
+        AX_ENGINE_NPU_ATTR_T npu_attr;
+        memset(&npu_attr, 0, sizeof(npu_attr));
+        npu_attr.eHardMode = AX_ENGINE_VIRTUAL_NPU_DISABLE;
+        auto ret = AX_ENGINE_Init(&npu_attr);
+        if (0 != ret)
+        {
+            return ret;
+        }
+
+        // 2. load model
+        std::vector<char> model_buffer;
+        if (!utilities::read_file(model, model_buffer))
+        {
+            fprintf(stderr, "Read Run-Joint model(%s) file failed.\n", model.c_str());
+            return false;
+        }
+
+        // 3. create handle
+        AX_ENGINE_HANDLE handle;
+        ret = AX_ENGINE_CreateHandle(&handle, model_buffer.data(), model_buffer.size());
+        SAMPLE_AX_ENGINE_DEAL_HANDLE
+        fprintf(stdout, "Engine creating handle is done.\n");
+
+        // 4. create context
+        ret = AX_ENGINE_CreateContext(handle);
+        SAMPLE_AX_ENGINE_DEAL_HANDLE
+        fprintf(stdout, "Engine creating context is done.\n");
+
+        // 5. set io
+        AX_ENGINE_IO_INFO_T* io_info;
+        ret = AX_ENGINE_GetIOInfo(handle, &io_info);
+        SAMPLE_AX_ENGINE_DEAL_HANDLE
+        fprintf(stdout, "Engine get io info is done. \n");
+
+        // 6. alloc io
+        AX_ENGINE_IO_T io_data;
+        ret = middleware::prepare_io(io_info, &io_data, std::make_pair(AX_ENGINE_ABST_DEFAULT, AX_ENGINE_ABST_CACHED));
+        SAMPLE_AX_ENGINE_DEAL_HANDLE
+        fprintf(stdout, "Engine alloc io is done. \n");
+
+        // 7. insert input
+        ret = middleware::push_input(data, &io_data, io_info);
+        SAMPLE_AX_ENGINE_DEAL_HANDLE_IO
+        fprintf(stdout, "Engine push input is done. \n");
+        fprintf(stdout, "--------------------------------------\n");
+
+        // 8. warn up
+        for (int i = 0; i < 5; ++i)
+        {
+            AX_ENGINE_RunSync(handle, &io_data);
+        }
+
+        // 9. run model
+        std::vector<float> time_costs(repeat, 0);
+        for (int i = 0; i < repeat; ++i)
+        {
+            timer tick;
+            ret = AX_ENGINE_RunSync(handle, &io_data);
+            time_costs[i] = tick.cost();
+            SAMPLE_AX_ENGINE_DEAL_HANDLE_IO
+        }
+
+        // 10. get result
+        post_process(io_info, &io_data, mat, input_w, input_h, time_costs);
+        fprintf(stdout, "--------------------------------------\n");
+
+        middleware::free_io(&io_data);
+        return AX_ENGINE_DestroyHandle(handle);
+    }
+} // namespace ax
+
+int main(int argc, char* argv[])
+{
+    cmdline::parser cmd;
+    cmd.add<std::string>("model", 'm', "joint file(a.k.a. joint model)", true, "");
+    cmd.add<std::string>("image", 'i', "image file", true, "");
+    cmd.add<std::string>("size", 'g', "input_h, input_w", false, std::to_string(DEFAULT_IMG_H) + "," + std::to_string(DEFAULT_IMG_W));
+
+    cmd.add<int>("repeat", 'r', "repeat count", false, DEFAULT_LOOP_COUNT);
+    cmd.parse_check(argc, argv);
+
+    // 0. get app args, can be removed from user's app
+    auto model_file = cmd.get<std::string>("model");
+    auto image_file = cmd.get<std::string>("image");
+
+    auto model_file_flag = utilities::file_exist(model_file);
+    auto image_file_flag = utilities::file_exist(image_file);
+
+    if (!model_file_flag | !image_file_flag)
+    {
+        auto show_error = [](const std::string& kind, const std::string& value) {
+            fprintf(stderr, "Input file %s(%s) is not exist, please check it.\n", kind.c_str(), value.c_str());
+        };
+
+        if (!model_file_flag) { show_error("model", model_file); }
+        if (!image_file_flag) { show_error("image", image_file); }
+
+        return -1;
+    }
+
+    auto input_size_string = cmd.get<std::string>("size");
+
+    std::array<int, 2> input_size = {DEFAULT_IMG_H, DEFAULT_IMG_W};
+
+    auto input_size_flag = utilities::parse_string(input_size_string, input_size);
+
+    if (!input_size_flag)
+    {
+        auto show_error = [](const std::string& kind, const std::string& value) {
+            fprintf(stderr, "Input %s(%s) is not allowed, please check it.\n", kind.c_str(), value.c_str());
+        };
+
+        show_error("size", input_size_string);
+
+        return -1;
+    }
+
+    auto repeat = cmd.get<int>("repeat");
+
+    // 1. print args
+    fprintf(stdout, "--------------------------------------\n");
+    fprintf(stdout, "model file : %s\n", model_file.c_str());
+    fprintf(stdout, "image file : %s\n", image_file.c_str());
+    fprintf(stdout, "img_h, img_w : %d %d\n", input_size[0], input_size[1]);
+    fprintf(stdout, "--------------------------------------\n");
+
+    // 2. read image & resize & transpose
+    std::vector<uint8_t> image(input_size[0] * input_size[1] * 3, 0);
+    cv::Mat mat = cv::imread(image_file);
+    if (mat.empty())
+    {
+        fprintf(stderr, "Read image failed.\n");
+        return -1;
+    }
+    common::get_input_data_letterbox(mat, image, input_size[0], input_size[1]);
+
+    // 3. sys_init
+    AX_SYS_Init();
+
+    // 4. -  engine model  -  can only use AX_ENGINE** inside
+    {
+        // AX_ENGINE_NPUReset(); // todo ??
+        ax::run_model(model_file, image, repeat, mat, input_size[0], input_size[1]);
+
+        // 4.3 engine de init
+        AX_ENGINE_Deinit();
+        // AX_ENGINE_NPUReset();
+    }
+    // 4. -  engine model  -
+
+    AX_SYS_Deinit();
+    return 0;
+}

examples/base/detection.hpp

@@ -3070,4 +3070,54 @@ namespace detection
         }
     } // namespace obb
 
+    static void generate_proposals_yolov10(int stride, const float* feat, float prob_threshold, std::vector<Object>& objects,
+                                         int letterbox_cols, int letterbox_rows, int cls_num = 80)
+    {
+        int feat_w = letterbox_cols / stride;
+        int feat_h = letterbox_rows / stride;
+        auto feat_ptr = feat;
+        float dis[16];
+        for (int h = 0; h <= feat_h - 1; h++)
+        {
+            for (int w = 0; w <= feat_w - 1; w++)
+            {
+                int c_index = 0;
+		float c_score = 0;
+
+                for (int c = 0; c < cls_num; c++)
+                {
+                    float score = feat_ptr[c];
+                    if (score > c_score)
+                    {
+                        c_index = c;
+                        c_score = score;
+                    } 
+                }
+
+                if(c_score >= prob_threshold)
+                {
+                    float x0 = w + 0.5f - mmyolo::fast_softmax(feat_ptr + cls_num  +  0 * 16,dis, 16);
+                    float y0 = h + 0.5f - mmyolo::fast_softmax(feat_ptr + cls_num  +  1 * 16,dis, 16);
+                    float x1 = w + 0.5f + mmyolo::fast_softmax(feat_ptr + cls_num  +  2 * 16,dis, 16);
+                    float y1 = h + 0.5f + mmyolo::fast_softmax(feat_ptr + cls_num  +  3 * 16,dis, 16);
+
+                    x0 *= stride;
+                    y0 *= stride;
+                    x1 *= stride;
+                    y1 *= stride;
+
+                    Object obj;
+                    obj.rect.x = x0;
+                    obj.rect.y = y0;
+                    obj.rect.width = x1 - x0;;
+                    obj.rect.height = y1 - y0;
+                    obj.label = c_index;
+                    obj.prob = c_score;
+                    objects.push_back(obj);
+                }
+                feat_ptr += (cls_num  +  4 * 16);        
+            }
+        }
+    }
+
 } // namespace detection