#AI挑战营终点站# rv1106数字识别模型部署与性能优化

luyism

#AI挑战营终点站# rv1106数字识别模型部署与性能优化 [复制链接]

<i class="pstatus"> 本帖最后由 luyism 于 2024-5-24 13:29 编辑 </i>

# rv1106数字识别模型部署与性能优化

## 背景说明

### 前情回顾

话接上回，我们已经成功将onnx模型转换了成了rknn格式的模型，不过仔细一查，发现我原来使用的转换模型库为RKNN-Toolkit，但是rv1106开发板仅支持RKNN-Toolkit2，于是又下载安装了相关的库与示例代码，开始研究。

一些相关的库链接如下所示：
  
rknn-toolkit2：https://github.com/airockchip/rknn-toolkit2
  
rknn_model_zoo： https://github.com/airockchip/rknn_model_zoo

详细的使用方法仓库中的文档都已经说明，并且也有许多相关的帖子，我这里就不再赘述与模型转换相关的内容。

### 初步体验

放一下LuckFox Pico Max的实物图：

<ignore_js_op>

<a href="javascript:;" onclick="showWindow(this.id, this.getAttribute('url'), 'get', 0);" id="savephoto_811029" url="home.php?mod=spacecp&ac=album&op=saveforumphoto&aid=811029&handlekey=savephoto_811029">保存到相册</a>

</p>

</div>
<div class="tip_horn"></div>
</div>

</ignore_js_op>

这板子确实小巧精致，不过在运行推理时发热量太大了，于是只好给他堆叠了两个散热片，手指摸上去还是挺热的，长时间使用需要增加其他的散热手段。

但在这个价格与性能来说，算是极具性价比，如此小巧的板子，板载256MB DDR3L，还可以直接运行yolov5，倒是着实惊喜。

## 技术简述

### 技术概要

为了能顺利模型部署到RV1106开发板上，可能涉及到多个方面的技术和工具。下面是一个简单的清单：

**编程语言**：
主要使用Python进行模型转换、推理等操作。
C/C++语言用于编写嵌入式设备上的驱动程序和底层逻辑。

**RKNN-Toolkit2工具链：**
在部署RKNN模型到Rockchip系列嵌入式设备上时，需要详细阅读RKNN-Toolkit2的相关文档和说明，了解工具链的使用方法和限制。
掌握如何使用RKNN-Toolkit2进行模型转换、优化和部署。还得大概知道RKNN-Toolkit2在办卡上部署的基本流程。

**板卡镜像编译与下载：**
从官方渠道下载适用于目标嵌入式设备的操作系统镜像，例如RV1106的Linux镜像。
熟悉如何在开发板上烧写镜像，并进行系统初始化和配置。

**ADB调试工具：**
ADB是一种用于在Android设备和计算机之间进行通信的命令行工具。
在部署模型到嵌入式设备上时，需要使用ADB工具进行文件传输、调试和监控。这次使用下来，感觉还挺方便的，比起使用网络ftp进行文件传输，adb命令更简单，而且还挺自由的

**计算机底层：**
需要了解嵌入式设备的硬件架构和相关技术，例如处理器型号、内存大小、外设接口等。
熟悉嵌入式操作系统的基本原理和使用方法，例如Linux操作系统。

**计算机图像**：
涉及到图像处理、计算机视觉、图像识别、目标检测、语义分割等多个子领域。可能还有一些图像存储方面的内容。

**网络：**
在进行模型部署和调试时，需要确保嵌入式设备与计算机之间可以进行网络通信，以便传输文件、远程调试等操作。

不过这些内容涉及到的方面比较广，一个人很难同时掌握所有相关知识。但只要有热情，一边实践一边学习，总能找到自己的乐趣和成就感。

### 开发板基本使用

关于这块开发板，官方已经做了非常详细的基础教程，包括镜像烧录、网络连接等等，这些内容大家如果不太了解的话可以去官方上手教程仔细查看。

上手教程： https://wiki.luckfox.com/zh/Luckfox-Pico/Luckfox-Pico-quick-start

一开始拿到板子也是跟着官方教程一点点操作，不得不说，教程做的很详细，使用体验极佳，没有出现什么奇奇怪怪的问题。

同时一看官方还有适配的屏幕，直接在淘宝给拿下了一块Pico-LCD-1.3，板子和屏幕便一起到了手里。

先是按照官方的RKNN 推理测试的说明开始修改设备树、同时编译内核，但是这里稍微有点坑，因为官方实验平台使用的是Luckfox-Pico-Plus、Pico-LCD-1.3，但是Luckfox-Pico-Plus和Luckfox-Pico_Max在设备树关于LCD的引脚定义不太相同，导致我排查了许久。

后面发现官方LVGL使用指南使用的是Luckfox Pico Pro/Max 、Pico-LCD-1.3，于是使用它的配置成功编译了内核并烧录到了开发板中，下面是两个示例程序的实际效果图。

<ignore_js_op>

<a href="javascript:;" onclick="showWindow(this.id, this.getAttribute('url'), 'get', 0);" id="savephoto_811030" url="home.php?mod=spacecp&ac=album&op=saveforumphoto&aid=811030&handlekey=savephoto_811030">保存到相册</a>

</p>

</div>
<div class="tip_horn"></div>
</div>

</ignore_js_op>

<ignore_js_op>

<a href="javascript:;" onclick="showWindow(this.id, this.getAttribute('url'), 'get', 0);" id="savephoto_811031" url="home.php?mod=spacecp&ac=album&op=saveforumphoto&aid=811031&handlekey=savephoto_811031">保存到相册</a>

</p>

</div>
<div class="tip_horn"></div>
</div>

</ignore_js_op>

## RKNN 简介

为了能顺利在rv1106上部署我们的模型，我们需要先了解一下在板卡上部署模型的工具链以及部署的基本流程。

### RKNN 工具链介绍

#### RKNN 软件栈整体介绍

RKNN 软件栈可以帮助用户快速的将AI 模型部署到Rockchip 芯片。整体的框架如下：

<ignore_js_op>

<a href="javascript:;" onclick="showWindow(this.id, this.getAttribute('url'), 'get', 0);" id="savephoto_811032" url="home.php?mod=spacecp&ac=album&op=saveforumphoto&aid=811032&handlekey=savephoto_811032">保存到相册</a>

</p>

</div>
<div class="tip_horn"></div>
</div>

</ignore_js_op>

为了使用RKNPU，用户需要首先在计算机上运行RKNN-Toolkit2 工具，将训练好的模型转换为RKNN 格式模型，之后使用RKNN C API 或Python API 在开发板上进行部署。

#### RKNN-Toolkit2

RKNN-Toolkit2 是为用户提供在计算机上进行模型转换、推理和性能评估的开发套件，RKNN-Toolkit2 的主要框图如下：

<ignore_js_op>

<a href="javascript:;" onclick="showWindow(this.id, this.getAttribute('url'), 'get', 0);" id="savephoto_811033" url="home.php?mod=spacecp&ac=album&op=saveforumphoto&aid=811033&handlekey=savephoto_811033">保存到相册</a>

</p>

</div>
<div class="tip_horn"></div>
</div>

</ignore_js_op>

通过该工具提供的Python 接口可以便捷地完成以下功能：
1. 模型转换：支持PyTorch、ONNX、TensorFlow、TensorFlow Lite、Caffe、DarkNet等模型转为RKNN 模型。
2. 量化功能：支持将浮点模型量化为定点模型，并支持混合量化。
3. 模型推理：将RKNN 模型分发到指定的NPU 设备上进行推理并获取推理结果；或在计算机上仿真NPU 运行RKNN 模型并获取推理结果。
4. 性能和内存评估：将RKNN 模型分发到指定NPU 设备上运行，以评估模型在实际设备上运行时的性能和内存占用情况。
5. 量化精度分析：该功能将给出模型量化后每一层推理结果与浮点模型推理结果的余弦距离和欧氏距离，以便于分析量化误差是如何出现的，为提高量化模型的精度提供思路。
6. 模型加密功能：使用指定的加密等级将RKNN 模型整体加密。

#### RKNN Runtime 功能介绍

RKNN Runtime 负责加载RKNN 模型，并调用NPU 驱动实现在NPU 上推理RKNN 模型。推理RKNN 模型时，包括原始数据输入预处理、NPU 运行模型、输出后处理三项流程。根据不同模型输入格式和量化方式，RKNN Runtime 提供通用API 和零拷贝API 两种处理流程。

**通用API 推理**：提供一套简洁、无门槛的推理API，易于使用，流程如图1-3 所示。其中对数据的归一化、量化、数据排布格式转换、反量化等均在CPU 上运行，模型本身的推理在NPU 上运行。

<ignore_js_op>

<a href="javascript:;" onclick="showWindow(this.id, this.getAttribute('url'), 'get', 0);" id="savephoto_811034" url="home.php?mod=spacecp&ac=album&op=saveforumphoto&aid=811034&handlekey=savephoto_811034">保存到相册</a>

</p>

</div>
<div class="tip_horn"></div>
</div>

</ignore_js_op>

**零拷贝API 推理**：流程如图1-4 所示。优化了通用API 的数据处理流程，归一化、量化和模型推理都会在NPU 上运行，NPU 输出的数据排布格式和反量化过程在CPU 或者NPU 上运行。零拷贝API 对于输入数据流程的处理效率会比通用API 高。支持数据在不同的IP 核之间流动，没有数据拷贝，减少CPU 及DDR 带宽消耗。比如通过camera 或者解码出来的数据，支持零拷贝导入到NPU 中使用。

<ignore_js_op>

<a href="javascript:;" onclick="showWindow(this.id, this.getAttribute('url'), 'get', 0);" id="savephoto_811035" url="home.php?mod=spacecp&ac=album&op=saveforumphoto&aid=811035&handlekey=savephoto_811035">保存到相册</a>

</p>

</div>
<div class="tip_horn"></div>
</div>

</ignore_js_op>

当用户输入数据只有虚拟地址时，只能使用通用API 接口；当用户输入数据有物理地址或fd 时，两组接口都可以使用。

### RKNN 开发流程介绍

流程主要分为3 个部分：模型转换、模型评估和板端部署运行。

<ignore_js_op>

<a href="javascript:;" onclick="showWindow(this.id, this.getAttribute('url'), 'get', 0);" id="savephoto_811036" url="home.php?mod=spacecp&ac=album&op=saveforumphoto&aid=811036&handlekey=savephoto_811036">保存到相册</a>

</p>

</div>
<div class="tip_horn"></div>
</div>

</ignore_js_op>

##### 1. 模型转换：
在这一阶段，原始的深度学习模型会被转化为RKNN 格式，以便在RKNPU 平台上进行高效的推理。这一步骤包括：
a. 获取原始模型：获取或训练深度学习模型，通常使用主流框架，如ONNX、PyTorch 或TensorFlow。
b. 模型配置：在RKNN-Toolkit2 中进行必要的配置，如均值、归一化、量化参数和目标平台等。
c. 模型加载：使用适当的加载接口将模型导入RKNN-Toolkit2，根据模型类型选择正确的加载方法。
d. 模型构建：通过rknn.build() 接口构建RKNN 模型，可选择是否进行量化，提高模型部署在硬件上的性能。
e. 模型导出：通过rknn.export_rknn() 接口将RKNN 模型导出为一个文件（.rknn 格式），用于后续部署。

##### 2. 模型评估：
模型评估阶段帮助用户量化和分析模型性能，包括精度、连板推理性能和内存占用等关键指标。评估的主要步骤包括以下操作：
a. 模型连板调试：模型连板调试阶段是通过使用Python 连接RKNPU 平台进行推理并验证模型，这个阶段涵盖了输入数据的前处理和输出结果的后处理，以确保模型在板上运行正确。
b. 精度评估：通过rknn.accuracy_analysis()接口，比较量化模型与浮点模型之间的输出分析量化误差。
c. 性能评估：通过rknn.eval_perf()接口，了解模型在平台上的推理性能，帮助用户进一步优化模型结构加快推理性能。
d. 内存评估：通过rknn.eval_memory()接口，了解模型在板上的内存使用情况，帮助用户进一步优化模型结构最小化内存占用。

##### 3. 板端部署运行：
这个阶段涵盖了模型的实际部署和运行。它通常包括以下步骤：
a. 模型初始化：加载RKNN 模型到RKNPU 平台，准备进行前处理。
b. 模型前处理：加载待推理数据到RKNPU 平台，准备进行推理。
c. 模型推理：执行推理操作，将输入数据传递给模型并获取推理结果。
d. 模型后处理：取出推理结果进行后处理，后处理结果传给应用端。
e. 模型释放：在完成推理流程后，释放模型资源，以便其他任务使用RKNN 模型。

这三个步骤构成了完整的RKNN 开发流程，确保人工智能模型能够成功转换、调试、评估和最终在RKNPU 上高效部署。

### 关键字说明

RKNN 模型：指运行在RKNPU 上的文件，后缀名为.rknn。
连板推理：指通过USB 口连接PC 和开发板，调用RKNN-Toolkit2 的接口运行模型。模型实际运行在开发板的NPU 上。
HIDL：用于指定Android HAL 和其用户之间的接口的一种接口描述语言。
CTS：全名兼容性测试套件，是谷歌提供的一个Andorid 平台自动化测试套件。
VTS：全名供应商测试套件，是谷歌提供的一个Andorid 平台自动化测试套件。
DRM：英文全名Direct Rendering Manager，是一个主流的图形显示框架。
NATIVE_LAYOUT：指对于NPU 运行时而言，通常性能表现最佳的计算机内存排列格式。
tensor：张量，在深度学习中，用它表示高阶数组的数据。
fd：文件描述符，被用来标识一块内存空间。
i8 模型：量化的RKNN 模型，即以8 位有符号整型数据运行的模型。
fp16 模型：非量化的RKNN 模型，即以16 位半精度浮点型数据运行的模型。

## 零拷贝 API

为什么要具体说明这个零拷贝API呢，因为rv1106就只支持这种方式来与模型传输数据，所以了解这个API也是必不可少的，不然后面具体在写代码的时候会存在许多隐形的坑。

在推理 RKNN 模型时，原始数据要经过输入处理、NPU 运行模型、输出处理三大流程。目前根据不同模型输入格式和量化方式，接口内部会存在通用 API 和零拷贝 API 两种处理流程，如下二图所示，两组 API 的主要区别在于，通用接口每次更新帧数据，需要将外部模块分配的数据拷贝到 NPU 运行时的输入内存，而零拷贝流程的接口会直接使用预先分配的内存（包括 NPU 运行时创建的或外部其他框架创建的，比如 DRM 框架），减少了内存拷贝的花销，性能更优，带宽更少。当用户输入数据只有虚拟地址时，只能使用通用 API 接口；当用户输入数据有物理地址或 fd 时，两组接口都可以使用。通用 API和零拷贝 API 不能混合调用。

### 通用 API 的数据处理流程

<ignore_js_op>

<a href="javascript:;" onclick="showWindow(this.id, this.getAttribute('url'), 'get', 0);" id="savephoto_811037" url="home.php?mod=spacecp&ac=album&op=saveforumphoto&aid=811037&handlekey=savephoto_811037">保存到相册</a>

</p>

</div>
<div class="tip_horn"></div>
</div>

</ignore_js_op>

对于数据的归一化、量化、数据排布格式转换、反量化均在 CPU 上运行，模型本身的推理在 NPU 上运行

### 零拷贝 API 数据处理流程

<ignore_js_op>

<a href="javascript:;" onclick="showWindow(this.id, this.getAttribute('url'), 'get', 0);" id="savephoto_811038" url="home.php?mod=spacecp&ac=album&op=saveforumphoto&aid=811038&handlekey=savephoto_811038">保存到相册</a>

</p>

</div>
<div class="tip_horn"></div>
</div>

</ignore_js_op>

优化了通用 API 的数据处理流程，零拷贝 API 归一化、量化和模型推理都会在 NPU 上运行，NPU 输出的数据排布格式和反量化过程在 CPU或者 NPU 上运行。零拷贝 API 对于输入数据流程的处理效率会比通用 API 高。

<ignore_js_op>

<a href="javascript:;" onclick="showWindow(this.id, this.getAttribute('url'), 'get', 0);" id="savephoto_811039" url="home.php?mod=spacecp&ac=album&op=saveforumphoto&aid=811039&handlekey=savephoto_811039">保存到相册</a>

</p>

</div>
<div class="tip_horn"></div>
</div>

</ignore_js_op>

**重要提醒**：这个地方需要注意由于rv1106零拷贝输入要求为宽16字节对齐，但是我们训练的图像大小为28x28x1，输入模型数据大小为1x28x28x1（或者其他排列顺序），他的宽度为28，是不满足16字节对齐的，所以我们在输入数据时要给每行的背后补上4个0，或者空出4位，达到16字节对齐的目的。实际的代码中也有所体现。

### C API 零拷贝整体流程

零拷贝 API 接口使用 rknn_tensor_memory 结构体，需要在推理前创建并设置该结构体，并在推理后读取该结构体中的内存信息。根据用户是否需要自行分配模型的模块内存（输入/输出/权重/中间结果）和内存表示方式（文件描述符/物理地址等）差异，有下列三种典型的零拷贝调用流程。红色部分表示专为零拷贝加入的接口和数据结构，斜体表示接口调用之间传递的数据结构。

其中我们的代码使用的是**输入/输出内存由运行时分配**，所以我们就大概了解一下这种拷贝流程就可以了。

<ignore_js_op>

<a href="javascript:;" onclick="showWindow(this.id, this.getAttribute('url'), 'get', 0);" id="savephoto_811040" url="home.php?mod=spacecp&ac=album&op=saveforumphoto&aid=811040&handlekey=savephoto_811040">保存到相册</a>

</p>

</div>
<div class="tip_horn"></div>
</div>

</ignore_js_op>

输入/输出内存由运行时分配调用的是 rknn_create_mem()接口创建rknn_tensor_memory 结构体，rknn_set_io_mem()设置输入输出 rknn_tensor_memory 结构体。

rknn_create_mem()接口创建的输入/输出内存信息结构体包含了文件描述符成员和物理地址，RGA 的接口使用到 NPU 分配的内存信息， preprocess_rga()表示 RGA 的接口，stream_fd 表示 RGA 的接口输入源的内存数据，postprocess_cpu()表示后处理的 CPU 实现。

我们将数字识别模型实际部署在开发板上就是这样的一个基本流程，其中内存设置和释放只需要在开始和结束时操作就号，中间的循环可以一直给模型传输新的图像进行推理。

## 实际代码详解

这里先感谢 [knv](https://home.eeworld.com.cn/space-uid-1362174.html) 的代码分享，给我解决了挺多之前一直不太理解的问题，我也在他的代码基础上做了进一步的修改和优化。

同时下面的代码也参考了官方yolov5摄像头实时识别和推流的例程，本文的重点在于数字识别模型的部署和优化，所以关于推流的部分不做过多介绍，如果想了解的可以看一下官方介绍页面 https://wiki.luckfox.com/zh/Luckfox-Pico/RKMPI-example 。

本文详细代码链接： https://gitee.com/luyism/luckfox_rtsp_mnist

### 较为重要的自定义结构体

```c
// 定义一个结构体储存预测到的数字和其对应的概率
struct Prediction
{
	int digit;
	float probability;
};

// 定义全局变量简单队列用于存储预测到的数字和其对应的概率
std::vector<Prediction> predictions_queue;

// 定义一个结构体用于存储rknn的上下文
typedef struct {
    rknn_context rknn_ctx;
    rknn_tensor_mem* max_mem;
    rknn_tensor_mem* net_mem;
    rknn_input_output_num io_num;
    rknn_tensor_attr* input_attrs;
    rknn_tensor_attr* output_attrs;
    rknn_tensor_mem* input_mems[3];
    rknn_tensor_mem* output_mems[3];

int model_channel;
    int model_width;
    int model_height;
    
    bool is_quant;
} rknn_app_context_t;
```

在文件开头定义了一个名为rknn_app_context_t的结构体，这里面储存的就是上面说的关于零拷贝API中输入/输出内存由运行时分配要使用的的上下文内容，这样方便了在不同函数之间传递rknn参数。

### 模型初始化

在程序中定义init_mnist_model函数，用于初始化mnist模型，并将初始化参数输入rknn_app_context_t的结构体变量app_mnist_ctx中。

```c
// rknn结构体变量
rknn_app_context_t app_mnist_ctx;
memset(&app_mnist_ctx, 0, sizeof(rknn_app_context_t));
init_mnist_model(model_path, &app_mnist_ctx);

//定义init_mnist_model函数，用于初始化mnist模型
int init_mnist_model(const char *model_path,rknn_app_context_t *app_mnist_ctx)
```

而在模型初始化中又分为几个阶段：

#### 导入模型文件

```c
    unsigned char * model = load_model(model_path, &model_len);
    ret = rknn_init(&ctx_mnist, model, model_len, 0, NULL);
    if (ret < 0)
    {
        printf("rknn_init failed! ret=%d", ret);
        return -1;
    }
```

#### 获取模型及SDK信息

```c
	// 获取SDK版本信息
	rknn_sdk_version sdk_ver;
	ret = rknn_query(ctx_mnist, RKNN_QUERY_SDK_VERSION, &sdk_ver, sizeof(sdk_ver));
	if (ret != RKNN_SUCC)
	{
		printf("rknn_query fail! ret=%d\n", ret);
		return -1;
	}
	printf("rknn_api/rknnrt version: %s, driver version: %s\n", sdk_ver.api_version, sdk_ver.drv_version);

// 获取模型输入输出信息
	rknn_input_output_num io_num;
	ret = rknn_query(ctx_mnist, RKNN_QUERY_IN_OUT_NUM, &io_num, sizeof(io_num));
	if (ret != RKNN_SUCC)
	{
		printf("rknn_query fail! ret=%d\n", ret);
		return -1;
	}
	printf("model input num: %d, output num: %d\n", io_num.n_input, io_num.n_output);

// 打印输入张量
	printf("\ninput tensors:\n");
	rknn_tensor_attr input_attrs[io_num.n_input];
	memset(input_attrs, 0, sizeof(input_attrs));
	for (uint32_t i = 0; i < io_num.n_input; i++)
	{
		input_attrs<i>.index = i;
		// query info
		ret = rknn_query(ctx_mnist, RKNN_QUERY_NATIVE_INPUT_ATTR, &(input_attrs<i>), sizeof(rknn_tensor_attr));
		if (ret < 0)
		{
			printf("rknn_init error! ret=%d\n", ret);
			return -1;
		}
		dump_tensor_attr(&input_attrs<i>);
	}

// 打印输出张量
	printf("\noutput tensors:\n");
	rknn_tensor_attr output_attrs[io_num.n_output];
	memset(output_attrs, 0, sizeof(output_attrs));
	for (uint32_t i = 0; i < io_num.n_output; i++)
	{
		output_attrs<i>.index = i;
		// When using the zero-copy API interface, query the native output tensor attribute
		ret = rknn_query(ctx_mnist, RKNN_QUERY_NATIVE_NHWC_OUTPUT_ATTR, &(output_attrs<i>), sizeof(rknn_tensor_attr));
		if (ret != RKNN_SUCC)
		{
			printf("rknn_query fail! ret=%d\n", ret);
			return -1;
		}
		dump_tensor_attr(&output_attrs<i>);
	}
```

代码主要功能如下：

- 获取SDK版本信息：通过 rknn_query 函数获取RKNN SDK的版本信息，包括API版本和驱动版本，这有助于确保与模型部署相关的API调用与SDK版本兼容性。

- 获取模型输入输出信息：同样使用 rknn_query 函数，获取已加载模型的输入输出张量数量信息，以便正确配置模型的输入输出。

- 打印输入张量信息：遍历模型的输入张量，并通过 rknn_query 查询每个张量的属性，例如张量的索引、形状、数据类型等，并通过 dump_tensor_attr 函数打印这些信息，以便了解模型输入的细节。

- 打印输出张量信息：类似地，遍历模型的输出张量，并查询每个张量的属性，如张量的索引、形状、数据类型等，然后打印这些信息，以便了解模型输出的细节。

打印消息如下所示：

```c
rknn_api/rknnrt version: 1.6.0 (9a7b5d24c@2023-12-13T17:33:10), driver version: 0.8.2
model input num: 1, output num: 1

input tensors:
  index=0, name=x, n_dims=4, dims=[1, 28, 28, 1], n_elems=784, size=784, fmt=NHWC, type=INT8, qnt_type=AFFINE, zp=0, scale=0.007843

output tensors:
  index=0, name=linear_2.tmp_1, n_dims=2, dims=[1, 10, 0, 0], n_elems=10, size=10, fmt=UNDEFINED, type=INT8, qnt_type=AFFINE, zp=-20, scale=0.116076
```

#### 设置输入输出张量内存空间

```c
	// default input type is int8 (normalize and quantize need compute in outside)
	// if set uint8, will fuse normalize and quantize to npu
	input_attrs[0].type = input_type;
	// default fmt is NHWC, npu only support NHWC in zero copy mode
	input_attrs[0].fmt = input_layout;
	printf("input_attrs[0].size_with_stride=%d\n", input_attrs[0].size_with_stride);
	
	// 设置输入张量内存
	ret = rknn_set_io_mem(ctx_mnist, app_mnist_ctx->input_mems[0], &input_attrs[0]);
	if (ret < 0)
	{
		printf("rknn_set_io_mem fail! ret=%d\n", ret);
		return -1;
	}

// 设置输出张量内存
	for (uint32_t i = 0; i < io_num.n_output; ++i)
	{
		app_mnist_ctx->output_mems<i> = rknn_create_mem(ctx_mnist, output_attrs<i>.size_with_stride);
		// printf("output_attrs[%d].size_with_stride=%d\n", i, output_attrs<i>.size_with_stride);
		// set output memory and attribute
		ret = rknn_set_io_mem(ctx_mnist, app_mnist_ctx->output_mems<i>, &output_attrs<i>);
		if (ret < 0)
		{
			printf("rknn_set_io_mem fail! ret=%d\n", ret);
			return -1;
		}
	}

// 将模型的上下文信息存储到app_mnist_ctx中
	app_mnist_ctx->rknn_ctx = ctx_mnist;

// TODO
    if (output_attrs[0].qnt_type == RKNN_TENSOR_QNT_AFFINE_ASYMMETRIC)
    {
        app_mnist_ctx->is_quant = true;
    }
    else
    {
        app_mnist_ctx->is_quant = false;
    }

app_mnist_ctx->io_num = io_num;
    app_mnist_ctx->input_attrs = (rknn_tensor_attr *)malloc(io_num.n_input * sizeof(rknn_tensor_attr));
    memcpy(app_mnist_ctx->input_attrs, input_attrs, io_num.n_input * sizeof(rknn_tensor_attr));
    app_mnist_ctx->output_attrs = (rknn_tensor_attr *)malloc(io_num.n_output * sizeof(rknn_tensor_attr));
    memcpy(app_mnist_ctx->output_attrs, output_attrs, io_num.n_output * sizeof(rknn_tensor_attr));
```

具体功能和作用如下：

- 设置输入张量的类型和布局：根据给定的输入类型和布局，设置输入张量的属性，包括类型和格式。在这里，对输入张量的类型和格式进行了设置，并打印了输入张量的大小（包括填充）。

- 设置输入张量内存：调用 rknn_set_io_mem 函数，将分配好的内存和输入张量的属性关联起来，以便后续模型推理时正确地传递输入数据。

- 设置输出张量内存：遍历所有的输出张量，为每个输出张量分配内存，并调用 rknn_set_io_mem 函数设置输出张量的内存和属性，以便将模型推理结果正确地存储到相应的内存区域中。

- 存储模型上下文信息：将模型的上下文信息存储到应用程序的上下文结构体 app_mnist_ctx 中，以便后续使用。

- 处理量化模型相关信息：通过检查输出张量的量化类型，判断模型是否为量化模型，并将结果存储到上下文结构体中。

- 复制输入输出张量属性：将输入输出张量的属性复制到应用程序上下文结构体中，以便后续使用。

总的来说，这段代码的功能是为RKNN模型的推理准备输入输出张量的内存，并保存相关属性和上下文信息，以便后续使用和处理。

```c
input_attrs[0].size_with_stride=896
model is NHWC input fmt
model input height=28, width=28, channel=1
```

可以看到输入stride=896，并不是28x28，而是28x32，这就是上面我们提到的16字节对齐，在处理输出数据时也需要主要这一点。

### 图像获取与预处理

#### 图像获取

在这里直接使用RK提供的函数，从指定通道获取一帧图像。

```
// get vpss frame
s32Ret = RK_MPI_VPSS_GetChnFrame(0, 0, &stVpssFrame, -1);
if (s32Ret == RK_SUCCESS)
{
	void *data = RK_MPI_MB_Handle2VirAddr(stVpssFrame.stVFrame.pMbBlk);

```

#### 找到数字的轮廓

函数定义如下，其基本逻辑来源于knv，我只是在他的代码基础上加了三个后处理以加强轮廓的稳定性。

```c
// 在图像中找到数字的轮廓，同时减小找到轮廓时的抖动
cv::Rect find_digit_contour(const cv::Mat &image) {
	
	// 预处理图像
    cv::Mat gray, blurred, edged;
    cv::cvtColor(image, gray, cv::COLOR_BGR2GRAY);
    cv::GaussianBlur(gray, blurred, cv::Size(5, 5), 0);
    cv::Canny(blurred, edged, 30, 150);

// 应用形态学操作
    cv::Mat kernel = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(5, 5));
    cv::dilate(edged, edged, kernel);
    cv::erode(edged, edged, kernel);

// 查找轮廓，声明一个变量来存储轮廓
    std::vector<std::vector<cv::Point>> contours;
    cv::findContours(edged, contours, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_SIMPLE);

if (contours.empty()) {
        return cv::Rect();
    }

// 找到最大的轮廓
    auto largest_contour = std::max_element(contours.begin(), contours.end(),
                                            [](const std::vector<cv::Point>& a, const std::vector<cv::Point>& b) {
                                                return cv::contourArea(a) < cv::contourArea(b);
                                            });
	
	//	**轮廓面积过滤**：在找到轮廓之后，可以排除那些面积过小的轮廓。这样可以减少不必要的小轮廓对整体结果的影响。
	if (cv::contourArea(*largest_contour) < 10) {
		return cv::Rect();
	}

// **轮廓形状过滤**：除了面积外，还可以考虑其他形状特征，如轮廓宽高比。这样可以排除一些不规则的轮廓，从而提高准确性。
	cv::Rect bounding_box = cv::boundingRect(*largest_contour);
	float aspect_ratio = static_cast<float>(bounding_box.width) / bounding_box.height;
	if (aspect_ratio < 0.2 || aspect_ratio > 3) {
		return cv::Rect();
	}

// **轮廓稳定性检测**：
	// 通过比较当前帧和之前几帧的轮廓位置来判断轮廓的稳定性。
	// 如果多帧之间的轮廓位置变化较小，则可以认为轮廓比较稳定，不需要进行过多的调整。
	static std::vector<cv::Rect> prev_bounding_boxes;
	if (prev_bounding_boxes.size() > 5) {
		prev_bounding_boxes.erase(prev_bounding_boxes.begin());
	}
	prev_bounding_boxes.push_back(bounding_box);
	if (prev_bounding_boxes.size() == 5) {
		float avg_width = 0.0;
		float avg_height = 0.0;
		for (const auto& box : prev_bounding_boxes) {
			avg_width += box.width;
			avg_height += box.height;
		}
		avg_width /= prev_bounding_boxes.size();
		avg_height /= prev_bounding_boxes.size();
		float width_diff = std::abs(bounding_box.width - avg_width) / avg_width;
		float height_diff = std::abs(bounding_box.height - avg_height) / avg_height;
		if (width_diff > 0.1 || height_diff > 0.1) {
			return cv::Rect();
		}
	}
	// 对图像边框每个方向扩大15个像素
	bounding_box.x = std::max(0, bounding_box.x - 15);
	bounding_box.y = std::max(0, bounding_box.y - 15);
	bounding_box.width = std::min(image.cols - bounding_box.x, bounding_box.width + 30);
	bounding_box.height = std::min(image.rows - bounding_box.y, bounding_box.height + 30);

// 返回最大轮廓的边界框
	return bounding_box;
}
```

代码基本功能如下：

- 预处理图像：将彩色图像转换为灰度图像。对灰度图像进行高斯模糊，以平滑图像并减少噪声。使用Canny边缘检测算法，检测图像边缘。

- 应用形态学操作：使用形态学膨胀和腐蚀操作，进一步改善边缘检测结果。

- 找到最大的轮廓：使用 cv::findContours 函数找到图像中的轮廓，并存储在 contours 中。通过计算轮廓的面积，找到图像中最大的轮廓。

- 轮廓过滤：过滤面积过小的轮廓，排除不必要的小轮廓。通过检查轮廓的宽高比，排除不规则的轮廓。

- 轮廓稳定性检测：通过比较当前帧和之前几帧的轮廓位置，判断轮廓的稳定性。如果多帧之间的轮廓位置变化较小，则认为轮廓比较稳定，不需要过多调整。

- 调整轮廓边界框：对于稳定的轮廓，对其边界框进行扩展，以减小轮廓抖动。

- 返回最大轮廓的边界框：返回最大轮廓的边界框，以便后续数字识别或其他操作使用。

#### 处理轮廓区域图像

当得到图像中的最大轮廓，程序就会将轮廓中的图像进一步处理。

```
// 预处理数字区域
cv::Mat preprocess_digit_region(const cv::Mat ®ion)
{
	// 将图像转换为灰度图像，然后调整大小为28x28，最后将像素值归一化为0到1之间的浮点数
	cv::Mat gray, resized, bitwized, normalized;
	cv::cvtColor(region, gray, cv::COLOR_BGR2GRAY);
	
	// 扩大图像中的数字轮廓，使其更容易识别
	cv::threshold(gray, gray, 0, 255, cv::THRESH_BINARY | cv::THRESH_OTSU);

// 调整图像颜色，将图像颜色中低于127的像素值设置为0，高于200的像素值设置为255
	cv::threshold(gray, gray, 127, 255, cv::THRESH_BINARY_INV);

// 对图像黑白进行反转，黑色变成白色，白色变成黑色
	cv::bitwise_not(gray, bitwized);
	// 手动实现黑白反转
	for (int i = 0; i < bitwized.rows; i++)
	{
		for (int j = 0; j < bitwized.cols; j++)
		{
			bitwized.at<uchar>(i, j) = 255 - bitwized.at<uchar>(i, j);
		}
	}

// 将图片大小调整为28x28，图片形状不发生畸变，过短的部分使用黑色填充
	cv::resize(bitwized, resized, cv::Size(28, 28), 0, 0, cv::INTER_AREA);
	//定义一个局部静态变量，让其只初始化一次，让其在等于200时将图片保存到本目录下
	static int count = 0;
	if (count == 200)
	{
		cv::imwrite("pre.jpg", resized);
	}
	count++;
	printf("count=%d\n", count);

return resized;
}
```

原始的场景如下：

<ignore_js_op>

<a href="javascript:;" onclick="showWindow(this.id, this.getAttribute('url'), 'get', 0);" id="savephoto_811041" url="home.php?mod=spacecp&ac=album&op=saveforumphoto&aid=811041&handlekey=savephoto_811041">保存到相册</a>

</p>

</div>
<div class="tip_horn"></div>
</div>

</ignore_js_op>

经过处理后输出的图像如下所示，在程序中我设定了在第200轮的时候会保存当前处理好的图像在本文件夹下，可以自行查看，这个效果就已经极为接近训练使用的mnist数据集的样式了：

<ignore_js_op>

<a href="javascript:;" onclick="showWindow(this.id, this.getAttribute('url'), 'get', 0);" id="savephoto_811042" url="home.php?mod=spacecp&ac=album&op=saveforumphoto&aid=811042&handlekey=savephoto_811042">保存到相册</a>

</p>

</div>
<div class="tip_horn"></div>
</div>

</ignore_js_op>

### 运行模型

```c
	//****************传入图像至推理内存区******************//
	int width = app_ctx->input_attrs[0].dims[2];
	int stride = app_ctx->input_attrs[0].w_stride;

if (width == stride)
	{
		memcpy(app_ctx->input_mems[0]->virt_addr, frame.data, width * app_ctx->input_attrs[0].dims[1] * app_ctx->input_attrs[0].dims[3]);
	}
	else
	{
		int height = app_ctx->input_attrs[0].dims[1];
		int channel = app_ctx->input_attrs[0].dims[3];
		// copy from src to dst with stride
		uint8_t *src_ptr = frame.data;
		uint8_t *dst_ptr = (uint8_t *)app_ctx->input_mems[0]->virt_addr;
		// width-channel elements
		int src_wc_elems = width * channel;
		int dst_wc_elems = stride * channel;
		for (int h = 0; h < height; ++h)
		{
			memcpy(dst_ptr, src_ptr, src_wc_elems);
			src_ptr += src_wc_elems;
			dst_ptr += dst_wc_elems;
		}
	}

// 运行推理
	ret = rknn_run(app_ctx->rknn_ctx, nullptr);
	if (ret < 0)
	{
		printf("rknn_run failed! %s\n", ret);
		return -1;
	}

```

将图像数据传入到推理内存区，并运行推理，

- 计算输入图像的宽度和步长（stride）：从应用程序的上下文结构体 app_ctx 中获取输入张量的宽度和步长。

- 传输图像数据至推理内存区：如果图像的宽度与步长相同，则直接使用 memcpy 函数将图像数据复制到推理内存区。如果图像的宽度与步长不同，则需要手动将图像数据按照步长进行复制，以确保数据正确地传输到推理内存区。

- 运行推理：调用 rknn_run 函数运行推理，对传入的图像数据进行模型推理操作。

### 后处理阶段

这段代码涉及两个函数，分别用于将量化的INT8数据转换为浮点数，并对模型输出进行归一化，并计算输出的概率分布。

```c
	uint8_t  *output= (uint8_t*)malloc(sizeof(uint8_t) * 10); 
	float *out_fp32 = (float*)malloc(sizeof(float) * 10);

output = (uint8_t *)app_ctx->output_mems[0]->virt_addr;
	output_normalization(&app_ctx->output_attrs[0], output, out_fp32);
```

```c

// 将量化的INT8数据转换为浮点数
// Parameters:
//   qnt: 量化后的整数数据
//   zp: 零点（zero point）值，用于零点偏移（zero-point offset）
//   scale: 缩放因子，用于缩放量化后的整数数据到浮点数范围
// Returns:
//   浮点数，表示经过反量化（dequantization）后的数据
static float deqnt_affine_to_f32(int8_t qnt, int32_t zp, float scale) { return ((float)qnt - (float)zp) * scale; }

// 将模型输出进行归一化，并计算输出的概率分布
// Parameters:
//   output_attrs: 输出张量属性，包含了零点（zero point）值和缩放因子等信息
//   output: 模型输出的数据，以INT8格式存储
//   out_fp32: 存储归一化后的浮点数输出数据
static void output_normalization(rknn_tensor_attr* output_attrs, uint8_t *output, float *out_fp32)
{
    int32_t zp =  output_attrs->zp;
    float scale = output_attrs->scale;

// 将INT8格式的输出数据进行反量化为浮点数，并进行存储
    for(int i = 0; i < 10; i ++)
        out_fp32<i> = deqnt_affine_to_f32(output<i>,zp,scale);

// 计算输出数据的L2范数
    float sum = 0;
    for(int i = 0; i < 10; i++)
        sum += out_fp32<i> * out_fp32<i>;
    
	// 对归一化后的浮点数输出进行归一化处理，确保输出数据的范围在[0,1]之间
	float norm = sqrt(sum);
    for(int i = 0; i < 10; i++)
        out_fp32<i> /= norm; 
	
	// 打印输出数据的值
	printf("\n===================Output data values:===================\n");
	for (int i = 0; i < 10; ++i)
	{
		printf("%f ", out_fp32<i>);
	}
	printf("\n");

// 找出最大概率对应的数字，并记录最大概率及其对应的数字
	float max_prob = -1.0;
	int predicted_digit = -1;
	// 计算最大值的索引
	for (int i = 0; i < 10; ++i)
	{
		if (out_fp32<i> > max_prob)
		{
			max_prob = out_fp32<i>;
			predicted_digit = i;
		}
	}
	// 将预测的数字及其对应的概率记录到队列中
	predictions_queue.push_back({predicted_digit, max_prob});

// 打印预测的数字与其对应的概率
	printf("========Predicted digit: %d, Probability: %.2f========\n\n", predicted_digit, max_prob);
}

```

用于对模型输出进行处理，包括反量化、归一化以及概率计算，并记录预测的数字及其概率。

### 推流显示

将模型推理得到的数字与概率显示打印在画面上：

```c
// 从predictions_queue中获取预测到的数字和其对应的概率
if (!predictions_queue.empty())
{
	Prediction prediction = predictions_queue.back();
	
	cv::rectangle(frame, digit_rect, cv::Scalar(0, 255, 0), 2);
	// 在图像上显示预测结果,显示字号为1，颜色为红色，粗细为2
	cv::putText(frame, std::to_string(prediction.digit), cv::Point(digit_rect.x, digit_rect.y - 10),
				cv::FONT_HERSHEY_SIMPLEX, 1, cv::Scalar(255, 0, 0), 2);
	// 在图像上显示预测概率
	cv::putText(frame, std::to_string(prediction.probability), cv::Point(digit_rect.x+ 30, digit_rect.y - 10),
				cv::FONT_HERSHEY_SIMPLEX, 0.7, cv::Scalar(230, 0, 0), 2);

// 打印预测到的数字和其对应的概率
	// printf("****** Predicted digit: %d, Probability: %.2f ******\n", prediction.digit, prediction.probability);
	// 从predictions_queue中删除最旧的元素
	predictions_queue.pop_back();
}
```

### 内存释放

在程序中定义了一个内存释放函数，用于释放模型的相关内存，包括模型的上下文、输入输出张量内存以及其他相关内存。这段代码用于在模型使用完毕后，释放模型所占用的内存资源，以避免内存泄漏和资源浪费。不过由于程序执行后就进入了死循环，这段代码就一直不会执行到，但是如果只推理有限次数的话就需要用到这个函数主动释放内存。

```c
// 定义内存释放函数，用于释放模型的内存
int release_mnist_model(rknn_app_context_t *app_ctx)
{
    if (app_ctx->rknn_ctx != 0)
    {
        rknn_destroy(app_ctx->rknn_ctx);
        app_ctx->rknn_ctx = 0;
    }
    if (app_ctx->net_mem != NULL)
    {
        printf("destory mem\n");
        rknn_destroy_mem(app_ctx->rknn_ctx, app_ctx->net_mem);
        free(app_ctx->net_mem);
    }
    if (app_ctx->max_mem != NULL)
    {
        printf("destory mem\n");
        rknn_destroy_mem(app_ctx->rknn_ctx, app_ctx->max_mem);
        free(app_ctx->max_mem);
    }
    if (app_ctx->input_attrs != NULL)
    {
        free(app_ctx->input_attrs);
        app_ctx->input_attrs = NULL;
    }
    if (app_ctx->output_attrs != NULL)
    {
        free(app_ctx->output_attrs);
        app_ctx->output_attrs = NULL;
    }
    for (int i = 0; i < app_ctx->io_num.n_input; i++) {
        if (app_ctx->input_mems<i> != NULL) {
            rknn_destroy_mem(app_ctx->rknn_ctx, app_ctx->input_mems<i>);
            free(app_ctx->input_mems<i>);
        }
    }
    for (int i = 0; i < app_ctx->io_num.n_output; i++) {
        if (app_ctx->output_mems<i> != NULL) {
            rknn_destroy_mem(app_ctx->rknn_ctx, app_ctx->output_mems<i>);
            free(app_ctx->output_mems<i>);
        }
    }
    return 0;
}
```

## 编译运行

进入工程文件夹后运行如下命令编译工程。

```

export LUCKFOX_SDK_PATH=<Your Luckfox-pico Sdk Path>

mkdir build

cd build

cmake ..

make && make install

```

将编译生成的工程文件夹 `luckfox_rtsp_mnist_dir` 文件夹上传到 luckfox-pico 上，进入文件夹运行

```

./luckfox_rtsp_mnist ./model/model.rknn

```

使用 vlc 打开网络串流 rtsp://172.32.0.93/live/0（按实际情况修改IP地址拉取图像）

**注意**：运行前请关闭系统默认 rkipc 程序，执行 `RkLunch-stop.sh` 关闭

## 代码运行效果

实际运行效果：

<ignore_js_op>

<a href="javascript:;" onclick="showWindow(this.id, this.getAttribute('url'), 'get', 0);" id="savephoto_811043" url="home.php?mod=spacecp&ac=album&op=saveforumphoto&aid=811043&handlekey=savephoto_811043">保存到相册</a>

</p>

</div>
<div class="tip_horn"></div>
</div>

</ignore_js_op>

对每个数字的识别效果如下，总体而言，模型动态识别的准确率可以达到80%以上，还是比较准确的

<ignore_js_op>

<a href="javascript:;" onclick="showWindow(this.id, this.getAttribute('url'), 'get', 0);" id="savephoto_811044" url="home.php?mod=spacecp&ac=album&op=saveforumphoto&aid=811044&handlekey=savephoto_811044">保存到相册</a>

</p>

</div>
<div class="tip_horn"></div>
</div>

</ignore_js_op>

每个预测数字的置信度也在0.6左右，还是比较高的，而且在视频动态拍摄的场景下，对同一个数字出现不同预测值的情景很少，基本稳定在准确值。

下面是实际运行视频。

<div id="player_09b78af7dd18fe2a0827989babed96200" class="localvideo-box"></div><div class="localvideo-title">数字实时识别</div><br/>

新增了一个现场手写数字的实时识别的视频，实时识别效果如下：

<div id="player_5b84edee283c94a8718d314f17d863491" class="localvideo-box"></div><div class="localvideo-title">手写数字实时识别20240524</div><br/>

关于最后数字9误识别，我认为主要有两个原因：

1、字形：我这种数字9的写法在国内较为常见，但是在mnist数据集中的数字9较为圆润，导致这种字体的数字9会被误识别成为与之相近的数字7.

2、焦距：因为是一只手写字、一只手拍摄，没有一个固定的支架，焦距容易对不上，导致视频模糊，轮廓监测效果下降，输入模型数据质量下降。

可以看到调整9的字形与焦距后就可以正常识别了。

nmg

试试动态拍摄你自己的手写过程？

aramy

这样加装上散热片，感觉SD卡，就没法安装了！

knv

大佬牛皮

wangerxian

厉害了，准备按照大佬的步骤来抄作业~

wangerxian

nmg 发表于 2024-5-24 05:17 试试动态拍摄你自己的手写过程？

大佬发出来了，识别率和刷新率都挺不错的

#AI挑战营终点站# rv1106数字识别模型部署与性能优化 [复制链接]

最新回复

点评