#AI挑战营终点站#RV1106手写数字识别部署

天空中

#AI挑战营终点站#RV1106手写数字识别部署 [复制链接]

<i class="pstatus"> 本帖最后由 天空中 于 2024-5-25 18:09 编辑 </i>

# RV1106数字识别

## 简述

利用 RKMPI 库实现摄像头图像捕获、预处理、硬件编码，结合 opencv-mobile 进行图像处理， rtsp 推流，使用 VLC 软件拉取并观察图像。

### 实现效果

* RKNN数字识别并标注

<ignore_js_op>

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

</p>

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

</ignore_js_op>

## 操作流程

RKMPI获取图像 -> 使用 opencv-mobile 进行捕获 ->opencv-mobile 进行图像预处理框选数字 -> RKNN推理->结果反回

## 涉及函数库简述

### opencv-mobile

在嵌入式系统中opencv中很多模块无法使用如：opencv_gapi，opencv_videoio等模块，所以需要精简openncv。

opencv-mobile，一款体积仅有官方 1/10 的精简 OpenCV 库，并已经适配rv1106已支持 luckfox-pico MIPI CSI 摄像头和 rk-aiq/rga 硬件加速

[github库地址](https://github.com/nihui/opencv-mobile)

### RKNN模型转换并部署

RKNN-Toolkit2 工具在 PC 平台上提供 C 或 Python 接口，简化模型的部署和运行。用户可以通过该工具轻松完成以下功能：模型转换、量化、推理、性能和内存评估、量化精度分析以及模型加密。RKNN-Toolkit2的环境及安装在以前的文章中有详细讲述此文章不在赘述

## 代码讲解

感谢 [knv](https://home.eeworld.com.cn/space-uid-1362174.html) 的代码分享，提供了思路和优化手段。

本代码参考文章[RKMPI 实例使用指南 | LUCKFOX WIKI](https://wiki.luckfox.com/zh/Luckfox-Pico/RKMPI-example#6-opencv-mobile-标注推流帧数实例)

### 将RKMPI获取的图像转化为opencv Mat型

```c++
void *data = RK_MPI_MB_Handle2VirAddr(stVpssFrame.stVFrame.pMbBlk); //获取MPI数据帧对应内存缓冲块虚拟地址	
cv::Mat frame(height,width,CV_8UC3, data);//转化为opencv Mat型为后序图像预处理做准备
```

### 图像预处理

```c++
cv::Mat frame64;
cv::cvtColor(frame, frame64, cv::COLOR_BGR2GRAY); //将彩色图转为灰度图
//图形二值化，此处没有使用固定阈值而是使用大津法做动态阈值处理增加了在不同光源下识别数字的稳定性
//使用THRESH_BINARY_INV模式将大于阈值的像素设为0小于阈值设为255这样就不用在进行像素反转的操作
cv::threshold(frame64, frame64, 100, 255, cv::THRESH_BINARY_INV | cv::THRESH_OTSU); 
```

#### 寻找数字的轮廓并框选

```c++
// 查找轮廓，声明变量来存储轮廓
std::vector<std::vector<cv::Point>>contours;
std::vector<cv::Vec4i> hierarchy;
cv::findContours(frame64, contours, hierarchy, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_NONE, cv::Point());
//声明变量来存储框选出来的矩形
cv::Rect rect;
int out_num = 10;
for (int i = 0; i < contours.size(); i++)
{
    rect = cv::boundingRect(contours<i>); //在寻找的轮廓中拟合矩形
    //通过矩形的长度宽度和长宽比筛出错误的矩形
    if (rect.width < 100 && rect.width > 10 && (rect.height/rect.width)>1 && rect.height <200)
    {
        //在矩形原有的基础上增加10个像素大小
        rect.x = std::max(0, rect.x - 10);
        rect.y = std::max(0, rect.y - 10);
        rect.width = std::min(720 - rect.x, rect.width + 20);
        rect.height = std::min(480 - rect.y, rect.height + 20);
        //在原图像上画出矩形
        cv::rectangle(frame, rect, cv::Scalar(0,0,255), 2);
        //将矩形所在区域的像素提取出来
        cv::Mat roi = frame64(rect);
        //将图片大小调整为28x28
        cv::resize(roi, roi, cv::Size(28,28), 0, 0, cv::INTER_LINEAR);
        //将图像的虚拟地址复制到张量中
        memcpy(rknn_app_ctx.input_mems[0]->virt_addr, roi.data, 28*28*1);
        //运行模型
        inference_NUM_model(&rknn_app_ctx, out_num);
    }
}

```

本代码没有对图像进行滤波操作，因为经过测试滤波操作在光线稳定的情况下并不会影响数字的识别率并且滤波操作会遍历整张图像降低帧率所以舍去滤波操作。
## 模型初始化部分和模型推理部分使用RKNN零拷贝 API
注：rv1106/rv1103仅支持零拷贝 API
RKNN零拷贝API是Rockchip神经网络处理库（RKNN, Rockchip Neural Network）提供的一组功能，旨在优化数据传输效率，减少内存复制操作，从而提高基于Rockchip平台的深度学习应用的性能。在传统的内存操作中，数据在不同内存区域或不同进程间传递时，经常需要进行数据的复制，这一过程会消耗时间和系统资源。而零拷贝技术则尽量避免这些不必要的复制操作。
### 模型初始化

```c++
//rknn上下文结构体变量
typedef struct {
    // RKNN运行上下文，由rknn_init函数初始化后获得，是执行模型推理的核心句柄。
    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[1];
    // 输出内存块指针数组，这里假设模型有3个输出，用于接收模型推理的结果数据。
    rknn_tensor_mem* output_mems[3];
    // 模型输入通道数，对于图像处理任务，这通常指的是色彩通道数（如RGB图像的通道数为3）。
    int model_channel;
    // 模型输入宽度，单位通常是像素。
    int model_width;
    // 模型输入高度，单位通常是像素。
    int model_height;
    // 表示模型是否进行了量化处理。量化模型通常用于加速推理并减少内存占用。
    bool is_quant;
} rknn_app_context_t;

```

```c++
rknn_app_context_t rknn_app_ctx;	// rknn结构体变量
int ret;
const char *model_path = "./model/111.rknn"; //模型地址
memset(&rknn_app_ctx, 0, sizeof(rknn_app_context_t));	//初始化结构体
init_retinaface_model(model_path, &rknn_app_ctx);	//模型初始化函数
printf("init rknn model success!\n");
```

```c++
/**
 * 初始化RKNN模型的函数
 *
 * @param model_path 模型文件的路径
 * @param app_ctx 应用上下文结构体指针，用于存储模型上下文及输入输出相关信息
 * @return 成功返回0，失败返回-1
 */
int init_retinaface_model(const char *model_path, rknn_app_context_t *app_ctx)
{
    int ret;
    rknn_context ctx = 0; // RKNN模型运行上下文

// 使用rknn_init函数初始化模型，传入模型路径
    ret = rknn_init(&ctx, (char *)model_path, 0, 0, NULL);
    if (ret < 0)
    {
        printf("rknn_init fail! ret=%d\n", ret);
        return -1;
    }

// 查询模型的输入输出数量
    rknn_input_output_num io_num;
    ret = rknn_query(ctx, 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);

// 分别获取并打印输入和输出张量的详细信息
    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(ctx, RKNN_QUERY_NATIVE_INPUT_ATTR, &(input_attrs<i>), sizeof(rknn_tensor_attr));
        if (ret != RKNN_SUCC) return -1;
        dump_tensor_attr(&(input_attrs<i>)); // 打印输入张量属性
    }

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(ctx, RKNN_QUERY_NATIVE_NHWC_OUTPUT_ATTR, &(output_attrs<i>), sizeof(rknn_tensor_attr));
        if (ret != RKNN_SUCC) return -1;
        dump_tensor_attr(&(output_attrs<i>)); // 打印输出张量属性
    }

// 设置输入张量属性，并为输入分配内存
    input_attrs[0].type = RKNN_TENSOR_UINT8;
    input_attrs[0].fmt = RKNN_TENSOR_NHWC;
    printf("input_attrs[0].size_with_stride=%d\n", input_attrs[0].size_with_stride);
    app_ctx->input_mems[0] = rknn_create_mem(ctx, input_attrs[0].size_with_stride);
    ret = rknn_set_io_mem(ctx, app_ctx->input_mems[0], &input_attrs[0]);

// 为输出张量分配内存并设置内存属性
    for (uint32_t i = 0; i < io_num.n_output; ++i) {
        app_ctx->output_mems<i> = rknn_create_mem(ctx, output_attrs<i>.size_with_stride);
        printf("output mem [%d] = %d \n",i ,output_attrs<i>.size_with_stride);
        ret = rknn_set_io_mem(ctx, app_ctx->output_mems<i>, &output_attrs<i>);
        if (ret < 0) return -1;
    }

// 将模型上下文和其他相关信息保存到app_ctx中
    app_ctx->rknn_ctx = ctx;
    app_ctx->is_quant = (output_attrs[0].qnt_type == RKNN_TENSOR_QNT_AFFINE_ASYMMETRIC);
    app_ctx->io_num = io_num;

// 分配内存并复制输入输出属性到app_ctx中
    app_ctx->input_attrs = (rknn_tensor_attr *)malloc(io_num.n_input * sizeof(rknn_tensor_attr));
    memcpy(app_ctx->input_attrs, input_attrs, io_num.n_input * sizeof(rknn_tensor_attr));
    app_ctx->output_attrs = (rknn_tensor_attr *)malloc(io_num.n_output * sizeof(rknn_tensor_attr));
    memcpy(app_ctx->output_attrs, output_attrs, io_num.n_output * sizeof(rknn_tensor_attr));

// 根据输入格式确定模型的尺寸信息
    if (input_attrs[0].fmt == RKNN_TENSOR_NCHW) 
    {
        printf("model is NCHW input fmt\n");
        app_ctx->model_channel = input_attrs[0].dims[1];
        app_ctx->model_height  = input_attrs[0].dims[2];
        app_ctx->model_width   = input_attrs[0].dims[3];
    } else 
    {
        printf("model is NHWC input fmt\n");
        app_ctx->model_height  = input_attrs[0].dims[1];
        app_ctx->model_width   = input_attrs[0].dims[2];
        app_ctx->model_channel = input_attrs[0].dims[3];
    }

printf("model input height=%d, width=%d, channel=%d\n",
           app_ctx->model_height, app_ctx->model_width, app_ctx->model_channel);

return 0; // 成功返回
}
```

### 模型推理函数

```c++
/**
 * 执行模型推理并处理输出结果的函数
 *
 * @param app_ctx 指向RKNN应用上下文的指针，包含了模型运行所需的全部资源和参数
 * @param out_num 引用参数，推理后最可能的类别序号将被保存于此
 * @return 成功返回0，失败返回-1
 */
int inference_NUM_model(rknn_app_context_t *app_ctx, int &out_num)
{
    int ret = 0;
    float probability = 0;
    // 使用rknn_run函数执行模型推理
    ret = rknn_run(app_ctx->rknn_ctx, NULL);
    if (ret < 0)
    {
        printf("rknn run error %d\n", ret);
        return -1;
    }
    // 获取模型输出数据的指针
    int8_t* output_data = (int8_t*)(app_ctx->output_mems[0]->virt_addr);
    // 创建一个数组用于存放反量化后的输出值
    float dequantized_values[10];
    // 对输出数据进行反量化处理
    for (int i = 0; i < 10; ++i) 
    {
        dequantized_values<i> = (output_data<i> - (float)(-4)) * 0.122913;
    }
    // 应用softmax函数使输出值转换为概率
    applySoftmax(dequantized_values, 10);
    for (int i = 0; i < 10; ++i) 
    {
        
        printf("Class %d: Probability = %.5f\n", i, dequantized_values<i>);
        // 如果当前类别的概率大于0.5，则检查是否大于已找到的最大概率
        if(dequantized_values<i> > 0.5)
        {
            // 更新最大概率和对应的类别序号
            if(probability < dequantized_values<i>)
            {
                probability = dequantized_values<i>;
                out_num = i;
            }
        }
    }
    return ret; 
}
```

### 输出值转换为概率

```c++
void applySoftmax(float* data, int size) 
{
    // 寻找数组中的最大值，用于数值稳定化softmax计算
    float max_val = data[0];
    for (int i = 1; i < size; ++i) {
        if (data<i> > max_val) {
            max_val = data<i>;
        }
    }

// 计算每个元素exp(xi - max_val)的值并累加，用于归一化
    float sum_exp = 0;
    for (int i = 0; i < size; ++i) {
        data<i> = exp(data<i> - max_val); // 对每个值减去最大值后进行指数运算，防止因指数运算导致的下溢出
        sum_exp += data<i>; // 累加所有指数值，用于后续的归一化
    }

// 归一化步骤，将所有exp值转换为概率分布（所有概率之和为1）
    for (int i = 0; i < size; ++i) {
        data<i> /= sum_exp; // 每个元素除以总和，得到概率值
    }
}
```

## 代码运行效果
<div id="player_68fd412d539aec90db007434d4d9208e0" class="localvideo-box"></div><div class="localvideo-title">VLC media player 2024-05-25 16-54-12_Trim_Trim</div><br/>

## 结果分析
本模型只对数字6，0，7这种特征较为明显的数字有较好的识别率，分析应该是神经网络的框架太简单，训练时只使用了三层卷积（具体训练代码看前面的文章）。可以将神经网络框架换为MobileNetv3这种成熟结构（仅为猜想并未实践）。
## 代码分享
链接：https://pan.baidu.com/s/1aSX1x_t9iWn5hv4Raj2_ow?pwd=ihrk 
提取码：ihrk

nmg

是写了图像滤波代码吗？要是好布置上去可以展示一下

“滤波操作会遍历整张图像降低帧率”，这个会有什么影响？

luyism

将图像的数据复制到张量内存空间的时候是要求16字节对齐的，28字节一行的图像数据直接整个拷贝到里面不满足这个条件，可能是这个原因影响了识别效果

天空中

luyism 发表于 2024-5-26 13:32 将图像的数据复制到张量内存空间的时候是要求16字节对齐的，28字节一行的图像数据直接整个拷贝到里面不满足 ...

好的我修改一下，感谢感谢

#AI挑战营终点站#RV1106手写数字识别部署 [复制链接]

最新回复

点评

浏览过的版块