【深度学习】【RKNN】【C++】应用程序编程接口化处理详细教程
【深度学习】【RKNN】【C++】应用程序编程接口化处理详细教程
提示:博主取舍了很多大佬的博文并亲测有效,分享笔记邀大家共同学习讨论
文章目录
- 【深度学习】【RKNN】【C++】应用程序编程接口化处理详细教程
- 前言
- 封装RKNN API
- NNEngine引擎接口
- RKEngine引擎接口以及实现
- 封装前后处理
- 前处理
- 后处理
- 封装自定义类型
- 自定义数据类型
- 自定义错误类型
- 封装辅助功能
- 日志包装器
- 辅助互换函数
- 主函数和CMake配置文件
- 总结
前言
应用程序编程接口(API)是软件工程中的一种常见做法，本博文将RKNPU2推理代码拆分为不同的API，旨在提高代码的可维护性、复用性和模块化。这样做可以让你的应用更加灵活，更容易扩展，并且可以支持并发开发。
这里需要先学习一下【深度学习】【RKNN】【C++】模型转化、环境搭建以及模型部署的详细教程，本博文是其后续补充。
下列是拆分成不同API后的工程结构总览：
AlexNet_API
└── 3rdparty
├── opencv
| ├── opencv-linux-aarch64
└── librknn_api
├── aarch64
| ├── vlibrknnrt.so
├── include
| ├── rknn_api.h
| ├── rknn_matmul_api.h
└── src
├── engine
| ├── engine.h
| ├── rknn_engine.cpp
| ├── rknn_engine.h
├── process
| ├── postprocess.cpp
| ├── postprocess.h
| ├── preprocess.cpp
| ├── preprocess.h
├── types
| ├── datatype.h
| ├── error.h
├── utils
| ├── engine_helper.h
| ├── logging.h
└── weights
├── AlexNet.rknn
└── CMakeLists.txt
封装RKNN API
NNEngine引擎接口
定义NNEngine抽象类：不能实例化，全部使用纯虚函数，只能作为不同板子的基类使用，使得不同的引擎的接口一致，方便使用，也可以隐藏不同引擎的实现细节，方便维护。
engine.h
// 接口定义
// 预处理器指令 用于防止头文件的重复包含
#ifndef RK3566_DEMO_ENGINE_H
#define RK3566_DEMO_ENGINE_H
#include "types/error.h"
#include "types/datatype.h"
#include <vector>
#include <memory>
class NNEngine
{
public:
virtual ~NNEngine(){}; // 析构函数
virtual nn_error_e LoadModelFile(const char *model_file) = 0; // 加载模型文件，=0表示纯虚函数，必须在子类中实现
virtual const std::vector<tensor_attr_s> &GetInputShapes() = 0; // 获取输入张量的形状
virtual const std::vector<tensor_attr_s> &GetOutputShapes() = 0; // 获取输出张量的形状
virtual nn_error_e Run(std::vector<tensor_data_s> &inputs, std::vector<tensor_data_s> &outpus, bool want_float) = 0; // 运行模型
};
std::shared_ptr<NNEngine> CreateRKNNEngine(); // 智能指针类避免内存泄漏 创建RKNN引擎
#endif // RK3566_DEMO_ENGINE_H
RKEngine引擎接口以及实现
rknn_engine.h
继承自NNEngine接口：新增了部分私有变量。
#ifndef RK3566_DEMO_RKNN_ENGINE_H
#define RK3566_DEMO_RKNN_ENGINE_H
#include "engine.h"
#include <vector>
#include <rknn_api.h>
// 实现NNEngine的接口
class RKEngine : public NNEngine
{
public:
RKEngine() : rknn_ctx_(0), ctx_created_(false), input_num_(0), output_num_(0){}; // 构造函数 初始化
~RKEngine() override; // 析构函数
nn_error_e LoadModelFile(const char *model_file) override; // 加载模型文件
const std::vector<tensor_attr_s> &GetInputShapes() override; // 获取输入张量的形状
const std::vector<tensor_attr_s> &GetOutputShapes() override; // 获取输出张量的形状
nn_error_e Run(std::vector<tensor_data_s> &inputs, std::vector<tensor_data_s> &outputs, bool want_float) override; // 运行模型
private:
// rknn context
rknn_context rknn_ctx_; // rknn context
bool ctx_created_; // rknn context是否创建
uint32_t input_num_; // 输入的数量
uint32_t output_num_; // 输出的数量
std::vector<tensor_attr_s> in_shapes_; // 输入张量的形状
std::vector<tensor_attr_s> out_shapes_; // 输出张量的形状
};
#endif // RK3566_DEMO_RKNN_ENGINE_H
rknn_engine.cpp
实现NNEngine：主要为加载模型和推理模型俩个函数。加载模型函数主要将核心流程中的初始化RKNN模型、获取模型输入输出信息部分整合在一起；推理模型函数则将设置输入、执行推理以及获取输出部分整合在一起。
// rknn_engine.h的实现
#include "rknn_engine.h"
#include <string.h>
#include "utils/engine_helper.h"
#include "utils/logging.h"
static const int g_max_io_num = 10; // 最大输入输出张量的数量
/**
* @brief 加载模型文件、初始化rknn context、获取rknn版本信息、获取输入输出张量的信息
* @param model_file 模型文件路径
* @return nn_error_e 错误码
*/
nn_error_e RKEngine::LoadModelFile(const char *model_file)
{
int model_len = 0; // 模型文件大小
auto model = load_model(model_file, &model_len); // 加载模型文件
if (model == nullptr)
{
NN_LOG_ERROR("load model file %s fail!", model_file);
return NN_LOAD_MODEL_FAIL; // 返回错误码：加载模型文件失败
}
int ret = rknn_init(&rknn_ctx_, model, model_len, 0, NULL); // 初始化rknn context
if (ret < 0)
{
NN_LOG_ERROR("rknn_init fail! ret=%d", ret);
return NN_RKNN_INIT_FAIL; // 返回错误码：初始化rknn context失败
}
// 打印初始化成功信息
NN_LOG_INFO("rknn_init success!");
ctx_created_ = true;
// 获取rknn版本信息
rknn_sdk_version version;
ret = rknn_query(rknn_ctx_, RKNN_QUERY_SDK_VERSION, &version, sizeof(rknn_sdk_version));
if (ret < 0)
{
NN_LOG_ERROR("rknn_query fail! ret=%d", ret);
return NN_RKNN_QUERY_FAIL;
}
// 打印rknn版本信息
NN_LOG_INFO("RKNN API version: %s", version.api_version);
NN_LOG_INFO("RKNN Driver version: %s", version.drv_version);
// 获取输入输出个数
rknn_input_output_num io_num;
ret = rknn_query(rknn_ctx_, RKNN_QUERY_IN_OUT_NUM, &io_num, sizeof(io_num));
if (ret != RKNN_SUCC)
{
NN_LOG_ERROR("rknn_query fail! ret=%d", ret);
return NN_RKNN_QUERY_FAIL;
}
NN_LOG_INFO("model input num: %d, output num: %d", io_num.n_input, io_num.n_output);
// 保存输入输出个数
input_num_ = io_num.n_input;
output_num_ = io_num.n_output;
// 输入属性
NN_LOG_INFO("input tensors:");
rknn_tensor_attr input_attrs[io_num.n_input];
memset(input_attrs, 0, sizeof(input_attrs));
for (int i = 0; i < io_num.n_input; i++)
{
input_attrs[i].index = i;
ret = rknn_query(rknn_ctx_, RKNN_QUERY_INPUT_ATTR, &(input_attrs[i]), sizeof(rknn_tensor_attr));
if (ret != RKNN_SUCC)
{
NN_LOG_ERROR("rknn_query fail! ret=%d", ret);
return NN_RKNN_QUERY_FAIL;
}
print_tensor_attr(&(input_attrs[i]));
// set input_shapes_
in_shapes_.push_back(rknn_tensor_attr_convert(input_attrs[i]));
}
// 输出属性
NN_LOG_INFO("output tensors:");
rknn_tensor_attr output_attrs[io_num.n_output];
memset(output_attrs, 0, sizeof(output_attrs));
for (int i = 0; i < io_num.n_output; i++)
{
output_attrs[i].index = i;
ret = rknn_query(rknn_ctx_, RKNN_QUERY_OUTPUT_ATTR, &(output_attrs[i]), sizeof(rknn_tensor_attr));
if (ret != RKNN_SUCC)
{
NN_LOG_ERROR("rknn_query fail! ret=%d", ret);
return NN_RKNN_QUERY_FAIL;
}
print_tensor_attr(&(output_attrs[i]));
// set output_shapes_
out_shapes_.push_back(rknn_tensor_attr_convert(output_attrs[i]));
}
return NN_SUCCESS;
}
// 获取输入张量的形状
const std::vector<tensor_attr_s> &RKEngine::GetInputShapes()
{
return in_shapes_;
}
// 获取输出张量的形状
const std::vector<tensor_attr_s> &RKEngine::GetOutputShapes()
{
return out_shapes_;
}
/**
* @brief 运行模型，获得推理结果
* @param inputs 输入张量
* @param outputs 输出张量
* @param want_float 是否需要float类型的输出
* @return nn_error_e 错误码
*/
nn_error_e RKEngine::Run(std::vector<tensor_data_s> &inputs, std::vector<tensor_data_s> &outputs, bool want_float)
{
// 检查输入输出张量的数量是否匹配
if (inputs.size() != input_num_)
{
NN_LOG_ERROR("inputs num not match! inputs.size()=%ld, input_num_=%d", inputs.size(), input_num_);
return NN_IO_NUM_NOT_MATCH;
}
if (outputs.size() != output_num_)
{
NN_LOG_ERROR("outputs num not match! outputs.size()=%ld, output_num_=%d", outputs.size(), output_num_);
return NN_IO_NUM_NOT_MATCH;
}
// 设置rknn inputs
rknn_input rknn_inputs[g_max_io_num];
for (int i = 0; i < inputs.size(); i++)
{
// 将自定义的tensor_data_s转换为rknn_input
rknn_inputs[i] = tensor_data_to_rknn_input(inputs[i]);
}
int ret = rknn_inputs_set(rknn_ctx_, (uint32_t)inputs.size(), rknn_inputs);
if (ret < 0)
{
NN_LOG_ERROR("rknn_inputs_set fail! ret=%d", ret);
return NN_RKNN_INPUT_SET_FAIL;
}
// 推理
NN_LOG_DEBUG("rknn running...");
ret = rknn_run(rknn_ctx_, nullptr);
if (ret < 0)
{
NN_LOG_ERROR("rknn_run fail! ret=%d", ret);
return NN_RKNN_RUNTIME_ERROR;
}
// 获得输出
rknn_output rknn_outputs[g_max_io_num];
memset(rknn_outputs, 0, sizeof(rknn_outputs));
for (int i = 0; i < output_num_; ++i)
{
rknn_outputs[i].want_float = want_float ? 1 : 0;
}
ret = rknn_outputs_get(rknn_ctx_, output_num_, rknn_outputs, NULL);
if (ret < 0)
{
printf("rknn_outputs_get fail! ret=%d\n", ret);
NN_LOG_ERROR("rknn_outputs_get fail! ret=%d", ret);
return NN_RKNN_OUTPUT_GET_FAIL;
}
NN_LOG_DEBUG("output num: %d", output_num_);
// copy rknn outputs to tensor_data_s
for (int i = 0; i < output_num_; ++i)
{
// 将rknn_output转换为自定义的tensor_data_s
rknn_output_to_tensor_data(rknn_outputs[i], outputs[i]);
NN_LOG_DEBUG("output[%d] size=%d", i, outputs[i].attr.size);
}
return NN_SUCCESS;
}
// 析构函数
RKEngine::~RKEngine()
{
if (ctx_created_)
{
rknn_destroy(rknn_ctx_);
NN_LOG_INFO("rknn context destroyed!");
}
}
// 创建RKNN引擎
std::shared_ptr<NNEngine> CreateRKNNEngine()
{
return std::make_shared<RKEngine>();
}
封装前后处理
前处理
preprocess.h
核心流程中的预处理输入数据：对输入数据进行颜色空间转换，尺寸缩放操作。
// 前处理
#ifndef RK3566_DEMO_PREPROCESS_H
#define RK3566_DEMO_PREPROCESS_H
#include <opencv2/opencv.hpp>
#include "types/datatype.h"
void imgPreprocess(const cv::Mat &img, cv::Mat &img_resized, uint32_t width, uint32_t height);
#endif //RK3566_DEMO_PREPROCESS_H
preprocess.cpp
// 前处理
#include "preprocess.h"
#include "utils/logging.h"
void imgPreprocess(const cv::Mat &img, cv::Mat &img_resized, uint32_t width, uint32_t height)
{
// img has to be 3 channels
if (img.channels() != 3)
{
NN_LOG_ERROR("img has to be 3 channels");
exit(-1);
}
cv::Mat img_rgb;
// bggr to rgb
cv::cvtColor(img, img_rgb, cv::COLOR_BGR2RGB);
// resize img
cv::resize(img_rgb, img_resized, cv::Size(width, height), 0, 0, cv::INTER_LINEAR);
}
后处理
postprocess.h
核心流程中的后处理推理结果：推理完成后，从输出张量中获取结果数据，根据需要对结果进行后处理，以获得最终的预测结果。
// 后处理
#ifndef RK3566_DEMO_POSTPROCESS_H
#define RK3566_DEMO_POSTPROCESS_H
#include <stdint.h>
#include <vector>
#include "opencv2/core/core.hpp"
#include "opencv2/imgcodecs.hpp"
#include "opencv2/imgproc.hpp"
int get_classification(float* pfProb, uint32_t out_w, uint32_t out_h);
#endif //RK3566_DEMO_POSTPROCESS_H
postprocess.cpp
// 后处理
#include <string.h>
#include <stdlib.h>
#include <algorithm>
#include <iostream>
#include "postprocess.h"
#include "utils/logging.h"
int get_classification(float* pfProb, uint32_t out_w, uint32_t out_h) {
// 1x5 获取输出数据并包装成一个cv::Mat对象,为了方便后处理
cv::Mat prob(out_w, out_h, CV_32F, (float*) pfProb);
std::cout << "prob : " << prob << std::endl;
// 后处理推理结果
cv::Point maxL, minL; // 用于存储图像分类中的得分最小值索引和最大值索引(坐标)
double maxv, minv; // 用于存储图像分类中的得分最小值和最大值
cv::minMaxLoc(prob, &minv, &maxv, &minL, &maxL);
int max_index = maxL.x; // 获得最大值的索引,只有一行所以列坐标既为索引
return max_index;
}
封装自定义类型
定义的NNEngine接口，其子类实现了RKNN API封装，同样也可以对未来新增的不同框架API进行封装，为了NNEngine与包括RKNN API在内的不同官方类型进行转化，提升兼容性和可扩展性，因此需要自定义类型。
RKNN API官方类型librknn_api/include/rknn_api.h中。
自定义数据类型
datatype.h
// 自定义定义数据类型
#ifndef RK3566_DEMO_DATATYPE_H
#define RK3566_DEMO_DATATYPE_H
#include <stdint.h>
#include <stdlib.h>
#include "utils/logging.h"
#include "types/error.h"
// 输入数据(张量)的不同通道布局
typedef enum _tensor_layout
{
// N批次batch，C通道数channel，H高度height，W宽度width
NN_TENSORT_LAYOUT_UNKNOWN = 0,
NN_TENSOR_NCHW = 1,
NN_TENSOR_NHWC = 2,
NN_TENSOR_OTHER = 3,
} tensor_layout_e;
// 输入数据(张量)的不同数据类型
typedef enum _tensor_datatype
{
NN_TENSOR_INT8 = 1,
NN_TENSOR_UINT8 = 2,
NN_TENSOR_FLOAT = 3,
NN_TENSOR_FLOAT16 = 4,
} tensor_datatype_e;
// 输入数据(张量)的维度
static const int g_max_num_dims = 4;
// 输入数据(张量)的基本信息
typedef struct
{
uint32_t index; // 存在多个输入数据时的索引
uint32_t n_dims; // 输入数据维度的数量
uint32_t dims[g_max_num_dims]; // 不同维度的大小
uint32_t n_elems; // 输入数据元素的个数
uint32_t size; // 元素的占用空间(字节):元素的个数×每个元素的占用空间
tensor_datatype_e type; // 元素的数据类型,不同类型就和不同占用空间有关
tensor_layout_e layout; // 输入数据的通道布局
int32_t zp; // 非对称仿射量化方法中的零点值
float scale; // 非对称仿射量化方法中的缩放值
} tensor_attr_s;
// 输入数据(张量)的完整内容：输入数据基本信息+输入数据本身
typedef struct
{
tensor_attr_s attr;
void *data;
} tensor_data_s;
// 不同数据类型的占用空间
static size_t nn_tensor_type_to_size(tensor_datatype_e type)
{
switch (type)
{
case NN_TENSOR_INT8:
return sizeof(int8_t);
case NN_TENSOR_UINT8:
return sizeof(uint8_t);
case NN_TENSOR_FLOAT:
return sizeof(float);
case NN_TENSOR_FLOAT16:
return sizeof(uint16_t);
default:
NN_LOG_ERROR("unsupported tensor type");
exit(-1);
}
}
// 设置输入数据的完整内容：整个过程就是将基本信息复制到完整内容中
static void nn_tensor_attr_to_cvimg_input_data(const tensor_attr_s &attr, tensor_data_s &data)
{
if (attr.n_dims != 4)
{
NN_LOG_ERROR("unsupported input dims");
exit(-1);
}
data.attr.n_dims = attr.n_dims;
data.attr.index = 0;
data.attr.type = NN_TENSOR_UINT8; // 在转成rknn模型时候通常会选择量化,因此输入数据类型通常都是UINT8
data.attr.layout = NN_TENSOR_NHWC; // 在转成rknn模型时候通常是NHWC格式
if (attr.layout == NN_TENSOR_NCHW)
{
data.attr.dims[0] = attr.dims[0];
data.attr.dims[1] = attr.dims[2];
data.attr.dims[2] = attr.dims[3];
data.attr.dims[3] = attr.dims[1];
}
else if (attr.layout == NN_TENSOR_NHWC)
{
data.attr.dims[0] = attr.dims[0];
data.attr.dims[1] = attr.dims[1];
data.attr.dims[2] = attr.dims[2];
data.attr.dims[3] = attr.dims[3];
}
else
{
NN_LOG_ERROR("unsupported input layout");
exit(-1);
}
// 计算输入元素个数
data.attr.n_elems = data.attr.dims[0] * data.attr.dims[1] *
data.attr.dims[2] * data.attr.dims[3];
// 计算输入元素的占用空间
data.attr.size = data.attr.n_elems * sizeof(uint8_t);
}
#endif // RK3566_DEMO_DATATYPE_H
自定义错误类型
error.h
// 自定义错误码
#ifndef RK3566_DEMO_ERROR_H
#define RK3566_DEMO_ERROR_H
typedef enum
{
NN_SUCCESS = 0, // 成功
NN_LOAD_MODEL_FAIL = -1, // 加载模型失败
NN_RKNN_INIT_FAIL = -2, // rknn初始化失败
NN_RKNN_QUERY_FAIL = -3, // rknn查询失败
NN_RKNN_INPUT_SET_FAIL = -4, // rknn设置输入数据失败
NN_RKNN_RUNTIME_ERROR = -5, // rknn运行时错误
NN_IO_NUM_NOT_MATCH = -6, // 输入输出数量不匹配
NN_RKNN_OUTPUT_GET_FAIL = -7, // rknn获取输出数据失败
NN_RKNN_INPUT_ATTR_ERROR = -8, // rknn输入数据属性错误
NN_RKNN_OUTPUT_ATTR_ERROR = -9, // rknn输出数据属性错误
NN_RKNN_MODEL_NOT_LOAD = -10, // rknn模型未加载
} nn_error_e;
#endif // RK3566_DEMO_ERROR_H
封装辅助功能
日志包装器
logging.h
宏定义来实现日志记录是一种强大且灵活的方法，它可以帮助开发者更好地控制日志输出，实现代码的灵活性，同时提高代码的性能和可维护性。
rknn_engine.cpp很多信息输出都是用日志记录的形式。
// 日志包装器,便于更换
#ifndef RK3566_DEMO_LOGGING_H
#define RK3566_DEMO_LOGGING_H
#include <stdio.h>
// 日志等级：从低到高
// 0: no log
// 1: error
// 2: error, warning
// 3: error, warning, info
// 4: error, warning, info, debug
static int32_t g_log_level = 4;
// 打印信息日志信息
// #defin 宏定义配合 do...while(0) 结构是常见的编程技巧,用于确保宏定义的行为类似于一个单独的语句
#define NN_LOG_ERROR(...) \
do \
{ \
if (g_log_level >= 1) \
{ \
printf("[NN_ERROR] "); \
printf(__VA_ARGS__); \
printf("\n"); \
} \
} while (0)
#define NN_LOG_WARNING(...) \
do \
{ \
if (g_log_level >= 2) \
{ \
printf("[NN_WARNING] "); \
printf(__VA_ARGS__); \
printf("\n"); \
} \
} while (0)
#define NN_LOG_INFO(...) \
do \
{ \
if (g_log_level >= 3) \
{ \
printf("[NN_INFO] "); \
printf(__VA_ARGS__); \
printf("\n"); \
} \
} while (0)
#define NN_LOG_DEBUG(...) \
do \
{ \
if (g_log_level >= 4) \
{ \
printf("[NN_DEBUG] "); \
printf(__VA_ARGS__); \
printf("\n"); \
} \
} while (0)
#endif // RK3566_DEMO_LOGGING_H
辅助互换函数
engine_helper.h
实现了加载标签和模型文件的辅助函数，以及实现了nn自定义类型和rknn官方类型的互换函数，未来封装更多API后，可扩展nn自定义类型和其他官方类型的互换函数。
// 辅助互换函数
#ifndef RK3566_DEMO_ENGINE_HELPER_H
#define RK3566_DEMO_ENGINE_HELPER_H
#include <fstream>
#include <string.h>
#include <vector>
#include <rknn_api.h>
#include "utils/logging.h"
#include "types/datatype.h"
/**
* @brief 加载标签文件
* @param labels_txt_file 标签文件路径
* @return std::vector<std::string> 输出标签名称
*/
std::vector<std::string> readClassNames(std::string labels_txt_file)
{
std::vector<std::string> classNames;
std::ifstream fp(labels_txt_file);
if (!fp.is_open())
{
printf("could not open file...\n");
exit(-1);
}
std::string name;
while (!fp.eof())
{
std::getline(fp, name);
if (name.length())
classNames.push_back(name);
}
fp.close();
return classNames;
}
/**
* @brief 加载模型文件
* @param filename 模型文件路径
* @param model_size 模型文件大小，会在函数内部赋值
* @return unsigned char* 模型文件数据
*/
static unsigned char *load_model(const char *filename, int *model_size)
{
FILE *fp = fopen(filename, "rb");
if (fp == nullptr)
{
NN_LOG_ERROR("fopen %s fail!", filename);
return nullptr;
}
fseek(fp, 0, SEEK_END);
int model_len = ftell(fp);
unsigned char *model = (unsigned char *)malloc(model_len);
fseek(fp, 0, SEEK_SET);
if (model_len != fread(model, 1, model_len, fp))
{
NN_LOG_ERROR("fread %s fail!", filename);
free(model);
return nullptr;
}
*model_size = model_len;
if (fp)
{
fclose(fp);
}
return model;
}
// 打印模型的输入输出的基本信息
static void print_tensor_attr(rknn_tensor_attr *attr)
{
NN_LOG_INFO(" index=%d, name=%s, n_dims=%d, dims=[%d, %d, %d, %d], n_elems=%d, size=%d, fmt=%s, type=%s, qnt_type=%s, "
"zp=%d, scale=%f",
attr->index, attr->name, attr->n_dims, attr->dims[0], attr->dims[1], attr->dims[2], attr->dims[3],
attr->n_elems, attr->size, get_format_string(attr->fmt), get_type_string(attr->type),
get_qnt_type_string(attr->qnt_type), attr->zp, attr->scale);
}
// 通道布局:nn转换成对应的rknn
static rknn_tensor_format rknn_layout_convert(tensor_layout_e fmt)
{
switch (fmt)
{
case NN_TENSOR_NCHW:
return RKNN_TENSOR_NCHW;
case NN_TENSOR_NHWC:
return RKNN_TENSOR_NHWC;
default:
NN_LOG_ERROR("unsupported nn layout: %d\n", fmt);
// exit program
exit(1);
}
}
// 数据类型:nn转换成对应的rknn
static rknn_tensor_type rknn_type_convert(tensor_datatype_e type)
{
switch (type)
{
case NN_TENSOR_UINT8:
return RKNN_TENSOR_UINT8;
case NN_TENSOR_FLOAT:
return RKNN_TENSOR_FLOAT32;
default:
NN_LOG_ERROR("unsupported nn type: %d\n", type);
// exit program
exit(1);
}
}
// 通道布局:rkknn转化成对应的nn
static tensor_layout_e rknn_layout_convert(rknn_tensor_format fmt)
{
switch (fmt)
{
case RKNN_TENSOR_NCHW:
return NN_TENSOR_NCHW;
case RKNN_TENSOR_NHWC:
return NN_TENSOR_NHWC;
default:
return NN_TENSOR_OTHER;
}
}
// 数据类型:rknn转换成对应的nn
static tensor_datatype_e rknn_type_convert(rknn_tensor_type type)
{
switch (type)
{
case RKNN_TENSOR_UINT8:
return NN_TENSOR_UINT8;
case RKNN_TENSOR_FLOAT32:
return NN_TENSOR_FLOAT;
case RKNN_TENSOR_INT8:
return NN_TENSOR_INT8;
case RKNN_TENSOR_FLOAT16:
return NN_TENSOR_FLOAT16;
default:
NN_LOG_ERROR("unsupported rknn type: %d\n", type);
// exit program
exit(1);
}
}
// 输入数据:rknn官方类型转nn自定义类型
static tensor_attr_s rknn_tensor_attr_convert(const rknn_tensor_attr &attr)
{
tensor_attr_s shape;
shape.n_dims = attr.n_dims;
shape.index = attr.index;
for (int i = 0; i < attr.n_dims; ++i)
{
shape.dims[i] = attr.dims[i];
}
shape.size = attr.size;
shape.n_elems = attr.n_elems;
shape.layout = rknn_layout_convert(attr.fmt);
shape.type = rknn_type_convert(attr.type);
shape.zp = attr.zp;
shape.scale = attr.scale;
return shape;
}
// 输入数据:nn自定义类型转rknn官方类型,为了输入到rknn模型
static rknn_input tensor_data_to_rknn_input(const tensor_data_s &data)
{
rknn_input input;
memset(&input, 0, sizeof(input));
// set default not passthrough
input.index = data.attr.index;
input.type = rknn_type_convert(data.attr.type);
input.size = data.attr.size;
input.fmt = rknn_layout_convert(data.attr.layout);
input.buf = data.data;
return input;
}
// 输出数据:rknn官方类型转nn自定义类型,方便后处理
static void rknn_output_to_tensor_data(const rknn_output &output, tensor_data_s &data)
{
data.attr.index = output.index;
data.attr.size = output.size;
NN_LOG_DEBUG("output size: %d", output.size);
NN_LOG_DEBUG("output want_float: %d", output.want_float);
memcpy(data.data, output.buf, output.size);
}
#endif // RK3566_DEMO_ENGINE_HELPER_H
主函数和CMake配置文件
AlexNet_API.cpp
// 导入相关库
#include <iostream>
#include <opencv2/opencv.hpp>
#include "engine/engine.h"
#include "process/preprocess.h"
#include "process/postprocess.h"
#include "utils/logging.h"
#include "utils/engine_helper.h"
int main(int argc, char **argv)
{
// 模型文件路径
const char *model_file = argv[1];
// 图片文件路径
const char *img_file = argv[2];
std::string labels_txt_file = "src/flower_classes.txt";
std::vector<std::string> labels = readClassNames(labels_txt_file);
// ==================== 1. 加载引擎 ====================
// 使用shared_ptr智能指针创建引擎，类型是接口中定义的NNEngine，但是实际上是RKEngine
std::shared_ptr<NNEngine> engine = CreateRKNNEngine();
// 加载模型文件、初始化rknn context、获取rknn版本信息、获取输入输出张量的信息
engine->LoadModelFile(model_file);
// 获取输入输出张量的形状
auto input_attrs = engine->GetInputShapes();
auto output_attrs = engine->GetOutputShapes();
NN_LOG_INFO("processing input data");
uint32_t n_dims = input_attrs[0].n_dims;
uint32_t batch = input_attrs[0].dims[0]; // 根据输入属性查询输入张量的批次（参考：dims=[1, 224, 224, 3]）
uint32_t in_h = input_attrs[0].dims[1]; // 高度
uint32_t in_w = input_attrs[0].dims[2]; // 宽度
uint32_t channel = input_attrs[0].dims[3]; // 通道
tensor_datatype_e type = input_attrs[0].type; // 数据类型
tensor_layout_e layout = input_attrs[0].layout; // 通道布局
uint32_t bytes = nn_tensor_type_to_size(type); // 数据类型的占用空间
// ==================== 2. 读取、预处理图片 ====================
// 加载图片
cv::Mat orig_img = cv::imread(img_file);
// 预处理 bgr->rgb, resize
cv::Mat img_resized;
imgPreprocess(orig_img, img_resized, in_w, in_h);
// ==================== 3. 设置输入、输出属性 ====================
// 输入数据
tensor_data_s input;
input.attr.n_dims = n_dims;
input.attr.dims[0] = batch;
input.attr.dims[1] = in_h;
input.attr.dims[2] = in_w;
input.attr.dims[3] = channel;
input.attr.size = channel * in_h * in_w;
// input.attr.type = type;
input.attr.type = NN_TENSOR_UINT8;
input.attr.layout = layout;
input.data = malloc(input.attr.size * bytes);
// 将图片数据拷贝到input.data中
memcpy(input.data, img_resized.data, input.attr.size);
// 将input追加到inputs中
std::vector<tensor_data_s> inputs;
inputs.push_back(input);
NN_LOG_DEBUG("done preprocessing input data");
// 输出数据
std::vector<tensor_data_s> outputs;
tensor_data_s output;
output.data = malloc(output_attrs[0].n_elems * sizeof(float));
outputs.push_back(output);
// ==================== 4. 推理 ====================
NN_LOG_INFO("running...");
engine->Run(inputs, outputs, true);
// ==================== 5. 后处理 ====================
uint32_t out_h = output_attrs[0].dims[0]; // 高度
uint32_t out_w = output_attrs[0].dims[1]; // 宽度
float *buffer = (float *)output.data;
int max_index = get_classification(buffer, out_h, out_w);
std::cout << "label id: " << max_index << std::endl;
cv::putText(orig_img, labels[max_index], cv::Point(50, 50), cv::FONT_HERSHEY_SIMPLEX, 1.0, cv::Scalar(0, 0, 255), 2, 8);
cv::imwrite("./output.jpg", orig_img);
return 0;
}
CMakeLists.txt
# 设置最低版本号
cmake_minimum_required(VERSION 3.11 FATAL_ERROR)
# 设置项目名称
project(rk3566-demo VERSION 0.0.1 LANGUAGES CXX)
# 输出系统信息
message(STATUS "System: ${CMAKE_SYSTEM_NAME} ${CMAKE_SYSTEM_VERSION}")
# 设置编译器
set(CMAKE_CXX_STANDARD 14)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
# 设置库架构
# rknn_api 文件夹路径
set(RKNN_API_PATH ${CMAKE_CURRENT_SOURCE_DIR}/librknn_api)
# rknn_api include 路径
set(RKNN_API_INCLUDE_PATH ${RKNN_API_PATH}/include)
# rknn_api lib 路径
set(RKNN_API_LIB_PATH ${RKNN_API_PATH}/aarch64/librknnrt.so)
# 寻找OpenCV库，使用自定义的OpenCV_DIR
set(3RDPARTY_PATH ${CMAKE_CURRENT_SOURCE_DIR}/3rdparty)
set(OpenCV_DIR ${3RDPARTY_PATH}/opencv/opencv-linux-aarch64/share/OpenCV)
find_package(OpenCV 3.4.5 REQUIRED)
# 输出OpenCV信息
message(STATUS " include path: ${OpenCV_INCLUDE_DIRS}")
# 用来搜索头文件的目录
include_directories(
${OpenCV_INCLUDE_DIRS}
${RKNN_API_INCLUDE_PATH}
${CMAKE_CURRENT_SOURCE_DIR}/src
)
# 构建预处理和后处理库
add_library(nn_process SHARED
src/process/preprocess.cpp
src/process/postprocess.cpp
)
# 链接库
target_link_libraries(nn_process
${OpenCV_LIBS}
)
# 构建自定义封装API库
add_library(rknn_engine SHARED
src/engine/rknn_engine.cpp)
# 链接库
target_link_libraries(rknn_engine
${RKNN_API_LIB_PATH}
)
# 测试自定义封装API
add_executable(alexnet_api src/AlexNet_API.cpp)
# 链接库
target_link_libraries(alexnet_api
rknn_engine
nn_process
)
编译和链接，完成推理，查看结果：
# 用于配置 CMake 项目的命令
# -S .: 指定了源代码目录,.当前目录
# -B build: 指定了构建目录,当前目录下创建build子目录
cmake -S . -B build
# 使用先前配置好的构建系统来编译和链接项目
cmake --build build
# 执行推理
./build/alexnet_api ./weights/AlexNet.rknn ./images/sunflowers.jpg
图片依旧正确预测为向日葵：
总结
尽可能简单、详细的介绍了RKNN C++ 应用程序编程接口化处理详细教程。