基于征程6 C++模型推理快速上手 & 代码解读

最新推荐文章于 2024-10-04 22:43:57 发布
最新推荐文章于 2024-10-04 22:43:57 发布
阅读量991 收藏 22
点赞数 7
文章标签： c++ java 开发语言 自动驾驶 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/agorachenyun/article/details/142613166
版权

1. 前言

在完成模型的转换编译后，会得到可以在开发板上部署的 hbm 模型，hbm（Horizon BPU Model）可以使用地平线推理库 UCP（ BPU SDK API）进行推理。

horizon_j6_open_explorer 发布物的 samples/ucp_tutorial/dnn/basic_samples/ 路径下有很多的示例，本文会使用 samples/ucp_tutorial/dnn/basic_samples/code/00_quick_start/resnet_rgb 示例，这个示例会运行 resnet50_224x224_rgb.hbm 分类模型，读取一张 jpg 图片，进行一次模型推理，在后处理中计算得到 Top5 的分类结果。

开发者在编写板端部署代码前，需要先熟悉地平线提供的板端部署 API，这部分可以查看工具链手册的模型推理 API 概览，这个章节主要介绍了模型推理相关的 API、数据、结构体、排布及对齐规则等，可以在 Horizon 开发板上利用 API 完成模型的加载与释放，模型信息的获取，以及模型的推理等操作。建议一边阅读示例代码，一边翻看用户手册进行学习。

2. 程序结构

通过一张图展示代码 main 函数的十个主要步骤，虚线箭头表示该步骤相关的接口/函数，底色为绿色的函数，具体实现在 main 函数之外。

在这里插入图片描述

3. 代码解读

快速上手代码在 OE 开发包的路径为：

samples/ucp_tutorial/dnn/basic_samples/code/00_quick_start/resnet_rgb/src/main.cc

3.1 预定义结构

定义字符串，代表 板端/X86 仿真 运行脚本 run_resnet_rgb.sh 的命令行参数定义，即需要解析的输入参数，包括模型文件路径、图片文件路径，以及分类结果 TopK 的参数设置，这里的 TopK 默认是 Top5。

DEFINE_string(model_file, EMPTY, "model file path");
DEFINE_string(image_file, EMPTY, "Test image path");
DEFINE_int32(top_k, 5, "Top k classes, 5 by default");

定义一些用于日志打印的宏，方便在代码中输出调试信息（Debug）、信息日志（Info）、错误信息（Error）、警告信息（Warning）等，每个日志信息都与一个模块名称关联。通过定义不同级别的日志宏，开发者可以轻松在代码中插入日志，方便调试和排错，同时还可以附带模块名称来区分不同的日志来源。

#define MOUDULE_NAME "DNN_BASIC_SAMPLE"
#define LOGD(err_msg, ...) HFLOGM_D(MOUDULE_NAME, err_msg, ##
__VA_ARGS__
)
#define LOGI(err_msg, ...) HFLOGM_I(MOUDULE_NAME, err_msg, ##
__VA_ARGS__
)
#define LOGE(err_msg, ...) HFLOGM_E(MOUDULE_NAME, err_msg, ##
__VA_ARGS__
)
#define LOGW(err_msg, ...) HFLOGM_W(MOUDULE_NAME, err_msg, ##__VA_ARGS__)

定义 HB_CHECK_SUCCESS（value， errmsg）这个宏，用于判断函数是否成功执行，参数 value 处填写执行的具体函数，函数返回值为 0 代表成功执行，执行失败则会返回错误码并在终端打印显示，用户可根据错误码对照工具链手册的《错误码》章节查看报错原因，也可以使用 hbDNNGetErrorDesc 接口打印错误原因。

#define HB_CHECK_SUCCESS(value, errmsg)             \
  do {                                              \
    /
*value can be call of function*
/               \
    auto ret_code = value;                          \
    if (ret_code != 0) {                            \
      LOGE("{}, error code: {}", errmsg, ret_code); \
      return ret_code;                              \
    }                                               \
  } while (0);

#define HB_CHECK_SUCCESS（value， errmsg）: 宏定义，value 和 errmsg 是宏的参数， do-while ：保证至少执行一次循环体，与 while 循环（先判断条件）的主要区别在于，do-while 先执行，后判断条件。用来保证宏展开时的语法安全性。 auto ret_code = value;： 宏的第一步是执行 value，并将结果赋值给变量 ret_code。 if (ret_code != 0）: 在 C/C++ 编程中，通常 0 表示成功，而非零值表示失败或错误。

Classificaton 结构体主要定义了三个变量，分别是分类序号 id，分类得分 score，以及类别名 class_name，会在后处理计算 TopK 的时候使用，友元函数重载的>运算符是为了配合 TopK 计算中优先级队列的优先级设置，后文分析 TopK 代码的时候会进行详细介绍。

typedef struct Classification {
  int id;                  // 分类的ID号
  float score;             // 分类的得分
  const char *class_name;  // 分类的名称, 字符串指针
  // 默认构造函数，初始化成员变量
  // 将 class_name 指针初始化为 0（即 nullptr），表示默认没有类别名称。
  // 默认构造函数会在创建 Classification 对象但不传递任何参数时自动调用。
  Classification() : id(0), score(0.0), class_name(0) {}
  // 带参数的构造函数，初始化成员变量
  Classification(int id, float score, const char *class_name)
      : id(id), score(score), class_name(class_name) {}
  // 重载 > 运算符，用于比较两个Classification对象的分数
  // 如果 lhs（左操作数）的 score 大于 rhs（右操作数）的 score，则返回 true，否则返回 false。
  // 这样可以直接使用 > 来比较两个 Classification 对象
  friend bool operator>(const Classification &lhs, const Classification &rhs) {
    return (lhs.score > rhs.score);
  }
  // 析构函数（无特殊功能，但可以避免潜在的警告）
  ~Classification() {}
} Classification;

3.2 解析命令行参数、初始化日志

  // Parsing command line arguments
  gflags::SetUsageMessage(argv[0]);
  gflags::ParseCommandLineFlags(&argc, &argv, true);
  std::cout << gflags::GetArgv() << std::endl;
  // Init logging
  hobot::hlog::HobotLog::Instance()->SetLogLevel(
      "DNN_BASIC_SAMPLE", hobot::hlog::LogLevel::log_info);

3.3 获取模型句柄

加载模型相关变量定义

  hbDNNPackedHandle_t packed_dnn_handle;
  hbDNNHandle_t dnn_handle;
  const char **model_name_list;
  auto modelFileName = FLAGS_model_file.c_str();
  int model_count = 0;

hbDNNPackedHandle_t packed_dnn_handle:hbDNNPackedHandle_t 是一个数据结构，表示打包的模型句柄，packed_dnn_handle 是这个句柄的变量名。用于加载和管理模型的句柄，通过该句柄可以访问和操作多个模型。

hbDNNHandle_t dnn_handle:hbDNNHandle_t 是单个模型的句柄，表示一个具体的模型。

const char **model_name_list:指向字符指针的指针，表示一个字符串数组，用于存储模型的名称列表。通过这个列表可以获取打包模型中的所有模型名称。

auto modelFileName = FLAGS_model_file.c_str();:

  • 使用 auto 自动推导变量类型，modelFileName 是一个 const char*，表示模型文件名。
  • FLAGS_model_file 是通过命令行参数传入的模型文件的路径，c_str（） 将 FLAGS_model_file 转换为 C 风格的字符串（const char*），方便后续调用 C 库函数。

int model_count = 0;表示模型的数量，初始值为 0。在加载打包模型时，可以通过模型计数来进行遍历和操作。

这里涉及到了“pack”打包的概念，做个解释：工具链支持将多个转换后 hbm 模型整合成一个文件，如果 hbDNNInitializeFromFiles 接口解析的是没有打包的单个模型，那么 packed_dnn_handle 指向的就是那一个模型，如果该接口解析的是打包了之后的整合模型，那么 packed_dnn_handle 会指向打包的多个模型，model_name_list 列表会包含所有的模型，model_count 为所有模型的总数。

  // Step1: get model handle
  {
    HB_CHECK_SUCCESS(hbDNNInitializeFromFiles(&packed_dnn_handle, &modelFileName, 1),
        "hbDNNInitializeFromFiles failed");
    HB_CHECK_SUCCESS(hbDNNGetModelNameList(&model_name_list, &model_count,
                                           packed_dnn_handle),
                     "hbDNNGetModelNameList failed");
    HB_CHECK_SUCCESS(
        hbDNNGetModelHandle(&dnn_handle, packed_dnn_handle, model_name_list[0]),
        "hbDNNGetModelHandle failed");
  }

hbDNNInitializeFromFiles：表示从指定的模型文件中加载模型

  • &packed_dnn_handle: 这是一个指向打包模型句柄的指针，hbDNNInitializeFromFiles 会通过它返回打包模型的句柄。
  • &modelFileName: 这是一个指向模型文件名的指针，告诉函数要加载哪个模型文件。
  • 1: 模型文件的数量。这里传入的是一个模型文件，因此数量是 1。

hbDNNGetModelNameList: 用于获取已经加载的模型的名称列表和模型的数量。

  • &model_name_list: 指向模型名称列表的指针，函数通过它返回模型的名称。
  • &model_count: 指向模型数量的指针，函数会通过它返回模型的数量。
  • packed_dnn_handle: 之前 hbDNNInitializeFromFiles 函数返回的打包模型句柄，用于标识加载的模型。

hbDNNGetModelHandle: 用于获取特定模型的句柄。

  • &dnn_handle: 指向模型句柄的指针，函数通过它返回该模型的句柄。
  • packed_dnn_handle: 这是已经初始化的打包模型的句柄。
  • model_name_list[0]: 这是从之前获取的模型名称列表中选择的第一个模型名称，用来从打包模型中指定要获取句柄的模型。

3.4 准备输入输出 tensor

声明用于存储输入和输出张量的变量，以及用于记录输入和输出数量的计数器

  std::vector<hbDNNTensor> input_tensors;  std::vector<hbDNNTensor> output_tensors;
  int input_count = 0;    // 用于记录输入张量的数量
  int output_count = 0;    // 用于记录输出张量的数量

std::vector input_tensors;

  • 这是一个用于存储输入张量的动态数组。
  • std::vector 是 C++ 的标准容器，可以动态调整大小。它能够存储多个 hbDNNTensor 对象，这里的 hbDNNTensor 是 地平线 dnn 库中表示张量（Tensor）的数据结构。
  • 在 DNN 推理过程中，输入张量用于存储输入数据，比如图片或者其他数据形式，供模型处理。

std::vector output_tensors;

  • 同样是一个 std::vector 容器，不过它是用于存储输出张量的。
  • 输出张量用于存储 DNN 推理之后的结果，比如分类的概率、目标检测的框坐标等。

为模型推理准备输入和输出张量。通过 hbDNNGetInputCount 获取输入输出的数量，通过 resize 调整张量数组的大小，最终调用函数 prepare_tensor 来进一步准备这些张量。

  // Step2: prepare input and output tensor
  {
    HB_CHECK_SUCCESS(hbDNNGetInputCount(&input_count, dnn_handle),
                     "hbDNNGetInputCount failed");
    HB_CHECK_SUCCESS(hbDNNGetOutputCount(&output_count, dnn_handle),
                     "hbDNNGetOutputCount failed");
    input_tensors.resize(input_count);
    output_tensors.resize(output_count);
    prepare_tensor(input_tensors.data(), output_tensors.data(), dnn_handle);
  }

hbDNNGetInputCount: 用于获取模型的输入张量数量。

  • &input_count: 一个指向 int 类型的指针，用于存储输入张量的数量。
  • dnn_handle: 模型的句柄，在前面的步骤中已经获取到了。

hbDNNGetOutputCount: 用于获取模型的输出张量数量。 input_tensors.resize 和 output_tensors.resize：这两行代码通过 resize 函数调整 input_tensors 和 output_tensors 动态数组的大小，使它们分别能够容纳 input_count 个输入张量和 output_count 个输出张量。

prepare_tensor: 用于进一步准备输入和输出张量。

  • input_tensors.data（）: 获取 input_tensors 中底层数组的指针，传递给函数以便操作。
  • output_tensors.data（）: 获取 output_tensors 中底层数组的指针。
  • dnn_handle: 模型的句柄，用于根据模型的需求准备张量。

其中，prepare_tensor 函数的主要作用有 3 点：

  1. 为输入和输出张量分配所需的内存。
  2. 获取每个张量的属性，如内存大小和名称。
  3. 初始化张量内存，为后续的推理过程做准备。

如果模型有多个输入输出，则每个输入输出都会分配一次内存空间。

hbDNNGetInputTensorProperties 和 hbDNNGetOutputTensorProperties 用于从模型中解析输入输出张量的属性。

input_memSize 和 output_memSize 表示某个输入/输出张量的 shape 对齐后的字节大小。

prepare_tensor 具体代码如下：

int prepare_tensor(hbDNNTensor *input_tensor, hbDNNTensor *output_tensor,                   hbDNNHandle_t dnn_handle) {  int input_count = 0;  int output_count = 0;  hbDNNGetInputCount(&input_count, dnn_handle);  hbDNNGetOutputCount(&output_count, dnn_handle);  /** Tips:   * For input memory size:   * *   input_memSize = input[i].properties.alignedByteSize   * For output memory size:   * *   output_memSize = output[i].properties.alignedByteSize   */  hbDNNTensor *input = input_tensor;  // 模型有多个输入输出，则每个输入输出都会分配一次内存空间  for (int i = 0; i < input_count; i++) {    HB_CHECK_SUCCESS(        hbDNNGetInputTensorProperties(&input[i].properties, dnn_handle, i),        "hbDNNGetInputTensorProperties failed");    int input_memSize = input[i].properties.alignedByteSize;    HB_CHECK_SUCCESS(hbUCPMallocCached(&input[i].sysMem, input_memSize, 0),                     "hbUCPMallocCached failed");    // Show how to get input name    const char *input_name;    HB_CHECK_SUCCESS(hbDNNGetInputName(&input_name, dnn_handle, i),                     "hbDNNGetInputName failed");    LOGI("input[{}] name is {}", i, input_name);  }  hbDNNTensor *output = output_tensor;  for (int i = 0; i < output_count; i++) {    HB_CHECK_SUCCESS(        hbDNNGetOutputTensorProperties(&output[i].properties, dnn_handle, i),        "hbDNNGetOutputTensorProperties failed");    int output_memSize = output[i].properties.alignedByteSize;    HB_CHECK_SUCCESS(hbUCPMallocCached(&output[i].sysMem, output_memSize, 0),                     "hbUCPMallocCached failed");    // Show how to get output name    const char *output_name;    HB_CHECK_SUCCESS(hbDNNGetOutputName(&output_name, dnn_handle, i),                     "hbDNNGetOutputName failed");    LOGI("output[{}] name is {}", i, output_name);  }  return 0;}

int prepare_tensor(hbDNNTensor *input_tensor, hbDNNTensor *output_tensor,
                   hbDNNHandle_t dnn_handle) {
  int input_count = 0;
  int output_count = 0;
  hbDNNGetInputCount(&input_count, dnn_handle);
  hbDNNGetOutputCount(&output_count, dnn_handle);
  
  /** Tips:
  * For input memory size:
  * *   input_memSize = input[i].properties.alignedByteSize
  * For output memory size:
  * *   output_memSize = output[i].properties.alignedByteSize
  */
hbDNNTensor *input = input_tensor;
// 模型有多个输入输出，则每个输入输出都会分配一次内存空间
for (int i = 0; i < input_count; i++) {
HB_CHECK_SUCCESS(
hbDNNGetInputTensorProperties(&input[i].properties, dnn_handle, i),
"hbDNNGetInputTensorProperties failed");
int input_memSize = input[i].properties.alignedByteSize;
HB_CHECK_SUCCESS(hbUCPMallocCached(&input[i].sysMem, input_memSize, 0),
            "hbUCPMallocCached failed");
    // Show how to get input name
    const char *input_name;
    HB_CHECK_SUCCESS(hbDNNGetInputName(&input_name, dnn_handle, i),
                     "hbDNNGetInputName failed");
    LOGI("input[{}] name is {}", i, input_name);
  }
  hbDNNTensor *output = output_tensor;
  for (int i = 0; i < output_count; i++) {
    HB_CHECK_SUCCESS(
        hbDNNGetOutputTensorProperties(&output[i].properties, dnn_handle, i),
        "hbDNNGetOutputTensorProperties failed");
    int output_memSize = output[i].properties.alignedByteSize;
    HB_CHECK_SUCCESS(hbUCPMallocCached(&output[i].sysMem, output_memSize, 0),
                     "hbUCPMallocCached failed");
    // Show how to get output name
    const char *output_name;
    HB_CHECK_SUCCESS(hbDNNGetOutputName(&output_name, dnn_handle, i),
                     "hbDNNGetOutputName failed");
    LOGI("output[{}] name is {}", i, output_name);
  }
  return 0;
}

首先使用 hbDNNGetInputCount（） 和 hbDNNGetOutputCount（） 来获取模型的输入和输出张量的数量，这两步在前面已经介绍过，是重复的，一般已经提前知道输入输出张量的数量。

接下来，代码遍历每个输入张量，通过 hbDNNGetInputTensorProperties（） 获取每个输入张量的属性，包括 alignedByteSize，即为该张量所需的内存大小。然后通过 hbUCPMallocCached（） 为每个输入张量分配内存。

输出张量的处理过程与输入类似，首先使用 hbDNNGetOutputTensorProperties（） 获取每个输出张量的属性，并分配内存。

3.5 将输入数据置入输入 tensor

将 rgb 图像数据存放到输入张量对应的内存空间中

  // Step3: set input data to input tensor
  {
    // read a single picture for input_tensor[0], for multi_input model, you
    // should set other input data according to model input properties.
    HB_CHECK_SUCCESS(
        read_image_2_tensor_as_rgb(FLAGS_image_file, input_tensors.data()),
        "read_image_2_tensor_as_rgb failed");
    LOGI("read image to tensor as ``rgb`` success");
  }

调用函数 read_image_2_tensor_as_rgb，从指定的图片文件（FLAGS_image_file）中读取图像数据，并将其以 RGB 格式存储到输入张量（input_tensors[0]）中。输入张量 input_tensors.data（）是指向 input_tensors 容器的指针，指向模型的第一个输入张量 input_tensors[0]，对于多输入模型，除了 input_tensors[0]，还需要根据模型的其他输入属性，分别读取和设置其他输入数据

read_image_2_tensor_as_rgb 是将一张图片读取并转换为适合推理的 RGB 图像张量，同时为模型输入数据做好预处理，包括调整图像大小、格式转换、填充等。

/** You can define  to prepare your data **/
int32_t read_image_2_tensor_as_rgb(std::string &image_file,
                                   hbDNNTensor *input_tensor) {
  hbDNNTensor *input = input_tensor;
  auto &properties = input->properties;
  int tensor_id = 0;
  // NHWC , the ``struct`` of resnet50 input shape is NHWC
  int input_h = properties.validShape.dimensionSize[1];
  int input_w = properties.validShape.dimensionSize[2];
  // 使用 OpenCV 的 cv::imread 函数读取输入图像文件。图像被读取为 BGR 格式（OpenCV 默认），随后会转换为 RGB 格式。
  cv::Mat bgr_mat = cv::imread(image_file, ``cv::IMREAD_COLOR``);
  if (bgr_mat.empty()) {
    LOGE("image ``file`` not exist!");
    return -1;
  }
  // convert to rgb format
  cv::Mat rgb_mat;
  cv::cvtColor(bgr_mat, rgb_mat, CV_BGR2RGB);
  // resize 调整图像大小
  cv::Mat resize_rgb_mat;
  resize_rgb_mat.create(input_h, input_w, rgb_mat.type());
  cv::resize(rgb_mat, resize_rgb_mat, resize_rgb_mat.size(), 0, 0);
  /** Tips:
    * For featuremap input, the user may need to preprocess the input data externally and add padding to the input data.
  **/
  // copy rgb data
  auto data = input->sysMem.virAddr;
  // resize_rgb_mat.ptr<uint8_t>() 返回指向调整大小后的图像数据的指针
  uint8_t *rgb_data = resize_rgb_mat.ptr<uint8_t>();  auto &valid_shape = properties.validShape;
  auto &stride = properties.stride;
  // U8
  uint32_t elementSize = 1;
  std::vector<uint32_t> dims;
  for (size_t idx{0U}; idx < valid_shape.numDimensions; idx++) {
    dims.emplace_back(static_cast<uint32_t>(valid_shape.dimensionSize[idx]));
  }
  // 调用 add_padding 将图像数据按照模型的输入形状和步幅信息填充到张量中。
  HB_CHECK_SUCCESS(add_padding(data, rgb_data, dims.size(), dims.data(), stride,
                               elementSize),
                   "hbDNNAddPaddingWithStride failed!")
  // TODO(@horizon.ai): The currently provided resnet50 model input is S8, which will be removed after the integrated compilation outputs the U8 model.
  // 模型当前输入是 S8 类型（有符号 8 位整数），但输入的图像数据是 U8 类型（无符号 8 位整数）。
  // 需要将无符号的数据转为有符号数据，具体做法是将每个 uint8_t 值减去 128。
  uint8_t *data_u8{reinterpret_cast<uint8_t *>(data)};
  int8_t *data_s8{reinterpret_cast<int8_t *>(data)};
  for (size_t idx{0U}; idx < properties.alignedByteSize; idx++) {
    data_s8[idx] = data_u8[idx] - 128;
  }
  // 在完成数据写入后，调用 hbUCPMemFlush 函数来清理系统缓存，确保数据在后续操作中是一致的。
  hbUCPMemFlush(&input->sysMem, HB_SYS_MEM_CACHE_CLEAN);
  return 0;
}

add_padding，主要功能是给输入张量添加填充（padding）。它通过递归的方式，在每个维度上计算填充后的张量，并将数据从输入内存复制到输出内存。

// get_prod_size模板函数用来计算给定维度数组的总元素数。
// 它接收一个维度数组 dim 和维度数量 dim_num，并返回数组中所有元素的乘积。
// 例如，若 dim 是 [3, 4, 5]，则乘积为 3 * 4 * 5 = 60
template <typename T>
int32_t get_prod_size(T const *dim, uint32_t dim_num) {
  int32_t size{1};
  for (uint32_t idx{0}; idx < dim_num; idx++) {
    size *= dim[idx];
  }
  return size;
}
// add_padding_core 递归函数用来将输入张量中的数据复制到输出张量中，确保数据按照给定的 stride（步长）进行对齐。
// 它根据 dim_num 的值递归处理张量的各个维度，逐层添加填充。详情见下方解读
void add_padding_core(void *output_ptr, const void *input_ptr, uint32_t dim_num,
                      const uint32_t *dim, const int64_t *stride,
                      uint32_t element_size) {
  if (dim_num == 1) {
    memcpy(output_ptr, input_ptr, element_size * dim[0]);
    return;
  }
  char const *in_ptr{reinterpret_cast<char const *>(input_ptr)};
  char *out_ptr{reinterpret_cast<char *>(output_ptr)};
  for (int32_t idx{0U}; idx < dim[0]; idx++) {
    auto size{get_prod_size(dim + 1, dim_num - 1) * element_size};
    char const *input{in_ptr + idx * size};
    void *output{out_ptr + stride[0] * idx};
    add_padding_core(output, input, dim_num - 1, dim + 1, stride + 1,
                     element_size);
  }
}
// 外部接口函数，调用 add_padding_core 函数来执行实际的填充操作。详情见下方解读
int32_t add_padding(void *output, const void *input, uint32_t dim_num,
                    const uint32_t *dim, const int64_t *stride,
                    uint32_t element_size) {
  add_padding_core(output, input, dim_num, dim, stride, element_size);
  return 0;
}

add_padding_core 参数：

  • output_ptr：填充后的输出数据指针。
  • input_ptr：原始输入数据指针。
  • dim_num：剩余的维度数量。
  • dim：当前维度数组。
  • stride：步长，用来计算输出数据的对齐方式。
  • element_size：每个元素的字节大小。

add_padding_core 递归处理：

  • 当 dim_num == 1 时，意味着已经到达最低维度（最小元素），这时直接通过 memcpy 复制数据。
  • 否则，循环遍历该维度的每个元素，递归调用 add_padding_core 处理下一维度的数据。

add_padding_core 函数会根据给定的 stride 值，将数据进行正确的对齐和填充。

add_padding 参数：

  • output：输出数据指针，指向填充后的张量。
  • input：输入数据指针，指向原始张量。
  • dim_num：维度数量。
  • dim：维度数组，表示输入张量的大小。
  • stride：步长数组，用来确定每一维度的内存对齐方式。
  • element_size：单个元素的字节大小。

3.6 执行推理

hbUCPTaskHandle_t task_handle{nullptr}：创建任务句柄 task_handle，用于管理一次推理任务的生命周期，此为异步执行的创建句柄方式。

hbUCPSchedParam 是调度参数结构体，通过 HB_UCP_INITIALIZE_SCHED_PARAM（&ctrl_param）宏定义初始化参数，backend 重新给了 HB_UCP_BPU_CORE_ANY，ctrl_param.backend = HB_UCP_BPU_CORE_ANY 指定任务可以在任意可用的 BPU（Brain Processing Unit）核上执行。hbUCPSubmitTask 函数提交 UCP 任务至调度器。最后调用 hbUCPWaitTaskDone 函数，等待任务完成。其中，0 表示不设定超时时间，一直等待任务完成。

  hbUCPTaskHandle_t task_handle{nullptr};     // 异步执行
  hbDNNTensor *output = output_tensors.data();
  // Step4: run inference
  {
    // generate task handle
    HB_CHECK_SUCCESS(
        hbDNNInferV2(&task_handle, output, input_tensors.data(), dnn_handle),
        "hbDNNInferV2 failed");
    // submit task
    hbUCPSchedParam ctrl_param;
    HB_UCP_INITIALIZE_SCHED_PARAM(&ctrl_param);
    ctrl_param.backend = HB_UCP_BPU_CORE_ANY;
    HB_CHECK_SUCCESS(hbUCPSubmitTask(task_handle, &ctrl_param),
                     "hbUCPSubmitTask failed");
    ``// wait`` task done
    HB_CHECK_SUCCESS(hbUCPWaitTaskDone(task_handle, 0),
                     "hbUCPWaitTaskDone failed");
  }

关于 hbDNNInferV2 的解读如下：

int32_t hbDNNInferV2(hbUCPTaskHandle_t *taskHandle,

hbDNNTensor *output,

hbDNNTensor const *input,

hbDNNHandle_t dnnHandle);

参数解读：

  • [out] taskHandle 任务句柄指针。
  • [in/out] output 推理任务的输出。
  • [in] input 推理任务的输入。
  • [in] dnnHandle DNN 句柄指针。

关于同步与异步执行，task_handle 如何配置，解释如下：

  1. 如果 taskHandle 置为 nullptr，则会自动创建同步任务，接口返回即推理完成。
  2. 如果 *taskHandle 置为 nullptr，则会自动创建异步任务，接口返回的 taskHandle 可用于后续阻塞或回调。
  3. 如果 *taskHandle 非空，并且指向之前已经创建但未提交的任务，则会自动创建新任务并添加进来。最多支持同时存在 32 个模型任务。

#define HB_UCP_INITIALIZE_SCHED_PARAM(param) { (param)->priority = HB_UCP_PRIORITY_LOWEST; (param)->deviceId = 0; (param)->customId = 0; (param)->backend = HB_UCP_CORE_ANY; }

int32_t hbUCPSubmitTask(hbUCPTaskHandle_t taskHandle, hbUCPSchedParam *schedParam); 提交 UCP 任务至调度器。 参数解读：

  • [in] taskHandle 任务句柄指针。
  • [in] schedParam 任务调度参数。

int32_t hbUCPWaitTaskDone(hbUCPTaskHandle_t taskHandle, int32_t timeout); 参数解读：

  • [in] taskHandle 任务句柄指针。
  • [in] timeout 超时配置（单位：毫秒）。

3.7 后处理

对推理的输出进行后处理，具体步骤包括：

  1. 刷新输出张量数据缓存：使用 hbUCPMemFlush 将输出张量从内存中刷到 CPU 缓存，以确保数据正确地被 CPU 读取。这个操作特别重要。
  2. 获取 Top-k 结果：函数 get_topk_result 根据模型的输出数据，从推理结果中提取前 k 个分类结果并存储到 top_k_cls 变量中。 FLAGS_top_k 用来指定提取多少个最高概率的分类结果。
  3. 打印 Top-k 结果：通过 LOGI 打印前 k 个分类结果的 id，方便观察推理结果。
   // Step5: do postprocess with output data
  std::vector<Classification> top_k_cls;
  {
    // make sure CPU read data from DDR before using output tensor data
    for (int i = 0; i < output_count; i++) {
      hbUCPMemFlush(&output_tensors[i].sysMem, HB_SYS_MEM_CACHE_INVALIDATE);
    }
    get_topk_result(output, top_k_cls, FLAGS_top_k);
    for (int i = 0; i < FLAGS_top_k; i++) {
      LOGI("TOP {} result id: {}", i, top_k_cls[i].id);
    }
  }

在 get_topk_result 函数中，模型输出的 Top-k 结果通过一个优先队列（小顶堆）来实现，从而快速获取最高的 k 个分类分数。具体操作步骤如下：

  1. 处理输出张量数据：

  • tensor->sysMem.virAddr 是一个指向输出数据的指针，通过 reinterpret_cast<float *> 将其转换为浮点类型指针，假设输出类型为 float。这一步通常需要根据模型的输出数据类型进行相应的类型转换。

  • quantiType 用于判断输出是否为量化数据。如果 quanti_type 不是 NONE，则需要对输出数据进行反量化处理，但在此例中，量化类型为 NONE，无需反量化。

    2.构建优先队列：

  • 使用 C++ 标准库的 std::priority_queue 来存储前 top_k 个分类结果。由于优先队列默认是大顶堆，这里通过 std::greater 使其变为小顶堆，以便始终保留最高的 k 个分数。

  • 每次迭代时将当前分类结果（Classification 对象，包含类别索引、分数等信息）压入队列。如果队列中元素超过 top_k，则移除分数最低的元素。

    3.生成结果：

  • 当所有分类分数遍历完成后，优先队列中保留了最高的 k 个分数。随后将其逆序插入 top_k_cls，因为优先队列在移出时顺序是从小到大的。

void get_topk_result(hbDNNTensor *tensor,
                     std::vector<Classification> &top_k_cls, int top_k) {
  std::priority_queue<Classification, std::vector<Classification>,
                      std::greater<Classification>>
      queue;
  // The type reinterpret_cast should be determined according to the output type
  // For example: HB_DNN_TENSOR_TYPE_F32 is float
  // // 将 tensor 数据强制转换为 float 指针
  auto data = reinterpret_cast<float *>(tensor->sysMem.virAddr);
  auto quanti_type{tensor->properties.quantiType};
  // For example model, quantiType is NONE and no dequantize processing is required.
  // 检查是否需要反量化
  // 如果模型量化类型不是 NONE，可以根据需要实现对应的反量化处理逻辑
  if (quanti_type != hbDNNQuantiType::NONE) {
    LOGE("quanti_type is not NONE, and the output needs to be dequantized!");
  }
  // 1000 classification score values
  // 模型输出的分类得分数量，这里假设为1000
  int tensor_len = 1000;
  for (auto i = 0; i < tensor_len; i++) {
    float score = data[i];
    queue.push(Classification(i, score, ""));
    // 保证队列中最多只保存 top_k 个元素
    if (queue.size() > top_k) {
      queue.pop();
    }
  }
  // 从优先队列中取出结果
  while (!queue.empty()) {
    top_k_cls.emplace_back(queue.top());
    queue.pop();
  }
  // 倒序排列
  std::reverse(top_k_cls.begin(), top_k_cls.end());
}

3.8 释放资源

最后，进行资源的释放操作，确保在完成推理任务后清理分配的内存和任务句柄。

依次释放任务句柄，释放输入/输出申请的内存空间，释放模型句柄。

  // Step6: release resources
  {
    // release task handle
    HB_CHECK_SUCCESS(hbUCPReleaseTask(task_handle), "hbUCPReleaseTask failed");
    // free input mem
    for (int i = 0; i < input_count; i++) {
      HB_CHECK_SUCCESS(hbUCPFree(&(input_tensors[i].sysMem)),
                       "hbUCPFree failed");
    }
    // free output mem
    for (int i = 0; i < output_count; i++) {
      HB_CHECK_SUCCESS(hbUCPFree(&(output_tensors[i].sysMem)),
                       "hbUCPFree failed");
    }
    // release model
    HB_CHECK_SUCCESS(hbDNNRelease(packed_dnn_handle), "hbDNNRelease failed");
  }


/ Step6: release resources
  {
    // release task handle
    HB_CHECK_SUCCESS(hbUCPReleaseTask(task_handle), "hbUCPReleaseTask failed");
    // free input mem
    for (int i = 0; i < input_count; i++) {
      HB_CHECK_SUCCESS(hbUCPFree(&(input_tensors[i].sysMem)),
                       "hbUCPFree failed");
    }
    // free output mem
    for (int i = 0; i < output_count; i++) {
      HB_CHECK_SUCCESS(hbUCPFree(&(output_tensors[i].sysMem)),
                       "hbUCPFree failed");
    }
    // release model
    HB_CHECK_SUCCESS(hbDNNRelease(packed_dnn_handle), "hbDNNRelease failed");
  }

到这里，整个快速上手的代码就解读完成了。

地平线开发者
关注
LLaMA模型系统解读
herosunly的博客
05-22 11万+
本文介绍核心内容为LLaMA模型系统解读，希望对学习和使用大模型的同学们有所帮助。 文章目录 1. 前言 2. LLaMA的核心目标和成功诀窍 2.1 核心目标 2.2 成功诀窍一 2.3 成功诀窍二 2.4 成功诀窍三 3. 常见误区 3.1 误区一 3.2 误区二 3.3 误区三 3.4 误区四
C++常用软件分析工具从入门到精通案例集锦汇总
dvlinker的技术专栏
06-26 11万+
C++软件分析工具案例分析集锦！根据近几年C++软件异常排查的项目实践，详细地讲述如何使用PE工具、Dependency Walker、GDIView、Process Explorer、Process Monitor、API Monitor、Clumsy、DebugDiag、Windbg、IDA Pro等常用分析工具，以及如何使用这些工具去巧妙地分析和解决日常工作中遇到的问题，有很强的实战参考价值！
推荐文章：C++环境下，利用OnnxRuntime轻松部署YOLOv8，实现高效目标检测
gitblog_09713的博客
09-06 582
推荐文章：C++环境下，利用OnnxRuntime轻松部署YOLOv8，实现高效目标检测 OnnxRuntime部署Yolov8模型.zip项目地址:https://gitcode.com/open-source-toolkit/ec142 在追求高效、便捷的技术应用时代，深度学习模型的快速部署成为了开发者关注的焦点。今天，我们为您隆重介绍一个宝藏级开源项目——C++ OnnxRuntime部署...
YOLO系列（v1~v3）的学习及YOLO-Fastest在海思平台的部署（上）
Turix附属空间[已停用]
06-21 4259
文章目录声明前言本文的目标和前期准备1 YOLO主线系列通读与了解1.1 YOLOv11.1.1 YOLOv1网络算法（1）网络是如何定义一个目标的（2）理解损失函数（3）算法是如何嵌入到网络结构中的1.1.2 Darknet（pjreddie版）源码编译和示例运行1.1.3 网络结构1.1.4 源码实现中的网络输出1.2 YOLOv21.2.1 YOLOv2网络算法（1）在YOLOv1基础上做的改动（2）锚框（Anchor Boxes）、直接位置预测和维度聚类（Dimension Clusters）（3）
编程新手导论
wangluozhangleilei的专栏
06-07 3万+
第二部分 导论，这一部分主要是关于编程的导论， (要懂得一点思想具备一点常识)《设计，编码，，与软工》（编程与思想）这一章解释了三种思想，原语，抽象，组合，，和软件开发的二个重要过程，，软件工程的相关概念，是编程入门的关键 (要懂得一点领域内的数学)《数学与算法》（编程与数学）计算机整个就是架构在数学上的，跟计算机平台实现，算法设计，，架构密切相关，，真正要深入编程，，，对数学的学习是必须的，
编程新手导论（转载）
szu030606的专栏
01-22 1万+
第二部分 导论，这一部分主要是关于编程的导论， (要懂得一点思想具备一点常识)《设计，编码，，与软工》（编程与思想）这一章解释了三种思想，原语，抽象，组合，，和软件开发的二个重要过程，，软件工程的相关概念，是编程入门的关键 (要懂得一点领域内的数学)《数学与算法》（编程与数学）计算机整个就是架构在数学上的，跟计算机平台实现，算法设计，，架构密切相关，，真正要深入编程，，，对数学的学习是必须的，
Deep Learning with Python 读书笔记6.26 I 什么是深度学习
nyist_yangguang的博客
06-26 772
我感觉这样记录，对于我来说挺好的。因为我看两端对齐的语句容易走神，这样记录阅读的话，就很少出现之前的情况。 我写的初衷，也是自己来看，所以感觉写的不好的，请保留下意见，谢谢。 代码缩进情况，字体重复情况，因为我能看懂，就没改。 里面的每一个字我都看过，加粗 括号 下划线 等均是我的笔记。 前　　言 你拿起这本书的时候，可能已经知道深度学习近年来在人工智能领域所取得的非凡进展。 在图像识别和语音转录的任务上，五年前的模型还几乎无法使用，如今的模型的表现已经超越 ...
重要知识结构-持续更新中
09-28 760
1：随机过程 随机过程主要有应用随机过程和理论概率两种课程.前者比较常见与工科,后者主要集中在数学系或者统计系.几本经典的教材： （1）：Adventures in stochastic processes 最好的应用随机过程的书， 没有之一。Resnick 很成功地在揭示概率本质的前提下来讨论随机过程， 美国一些顶尖的IE系(比如Gatech 和 Stanford)都...
数学最重要 ：一个经济博士的总结（常春藤）Ph.D
栖客
11-07 9340
转载自： 【一、数学背景和学习总结】 一，序     一转眼来美国读这个Econ 的PHD已经两年了，从刚来时的懵懵懂懂与对这边PHD生活的新奇感到现在的每周7天只能休息一个晚上的Extremely Exhausted（个人时间安排不好，每学期选课老是贪多，还有可能就是我太笨了），从刚来时去开个银行账户因为英语不好都差点没开成到这个学期其中三门课做了四堂Prese
上期CTP_API_C++可实盘的源代码(更新).rar
06-05
上期CTP API C++ 源代码 单合约版 下载文件名AutoTrader_ctp_c++源代码.rar 填入经纪公司代码，实盘帐号，密码即可完成行情接收，指标计算，实盘下单连续开平仓。 功能简要介绍如下： 自动保存订阅合约TICK数据到\...
yolov5 利用c++进行模型推理部署详解(openvino,tensoRT)
@bangbang的博客
12-04 2053
本文以yolov5为例，讲解模型的部署过程，包括:模型导出为onnx, 部署框架选择、预处理、后处理及NMS。本文讲解的部署也同样适用于其他yolo系列以及基于anchor based的目标检测网络。
C++软件调试与异常排查从入门到精通系列文章汇总
热门推荐
dvlinker的技术专栏
06-29 18万+
根据近几年排查软件异常的实践与经验，系统地讲解了C++软件异常常见原因与常用排查方法，以图文并茂的方式给出具体的分析实例，带领大家逐步掌握C++软件异常排查的相关技术与要领。
【C++算法】9.双指针_四数之和
hlyd520的博客
10-04 294
后面的步骤类似，就不多赘述了。解法一：排序+暴力枚举+利用。双指针遇到合适的数继续往后走。解法二：排序+双指针。不满足循环条件，跳出。
【C语言内存管理】第三章 堆内存管理
09-29 437
总结，堆内存管理在C语言中占有重要地位，掌握好动态内存分配函数的使用方法及其管理策略，对于编写高效、稳定的程序具有重要意义。在C语言中，堆内存管理是较为灵活的内存管理方式之一，它允许程序在运行时根据需求动态分配和释放内存，与静态分配相比更为灵活。下面我们对堆内存管理进行详细讲解。内存泄漏是指程序无法再访问某块内存，但该内存未被释放，导致内存浪费。内存碎片化是指堆内存中由于频繁的分配和释放而产生很多小而分散的内存块。通过合理使用动态内存分配和释放，程序员可以有效管理内存，保持程序稳定可靠。
C语言中的日志机制：打造全面强大的日志系统
极客代码
09-30 409
构建一个全面强大的日志机制对于软件开发至关重要。通过上述示例，你应该已经了解了如何在C语言中实现日志记录的不同方面。这种能力对于调试程序、监控应用程序状态和维护系统的稳定性非常有帮助。在软件开发中，良好的日志记录机制对于调试、监控程序状态和维护系统的稳定性至关重要。本文将介绍如何在C语言中构建一个全面强大的日志系统，并提供一些示例代码。实现日志文件的自动旋转，以便管理日志文件的大小。定义日志级别的宏，便于管理和调整日志输出。使用定义好的日志宏来记录日志。实现日志配置的读取和设置。1. 日志的基本概念。
C++：图的最短路径问题
han2205277149的博客
10-04 625
最短路径问题是图的一个比较典型的应用问题。例如，给定某公路网的n个城市以及这些城市之间相通公路的距离，能否找到城市A到城市B之间一条距离最近的通路呢？如果将城市用顶点表示城市间的公路用边表示，公路的长度作为边的权值，这个问题就归结为在网图中求顶点A和顶点B的最短路径。
C++之多态篇(超详细版)
最新发布
2302_79795375的博客
10-04 425
public:cout
C++的类型转换
2401_83427936的博客
09-27 1709
在自定义类型中重载string，这里涉及到文件的写入，string的str转c_str,弄成char类型才能插入直接重载int和bool的，就支持A转int值和bool了。这里加explcit不影响转换，更支持了与其他的相反，不加explcit，A不能转double，只能转int，加了就可以了。放宽了标准C++为了加强类型转换的可视性，引入了四种命名的强制类型转换操作符：static_cast用于非多态类型的转换（静态转换），编译器隐式执行的任何类型转换都可用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值