rv1126移植并部署自写手写数字识别模型

news2024/7/6 0:08:39

首先搭建好rknntoolkit以及rknpu环境

-->

MNIST->https://github.com/warren-wzw/MNIST-pytorch.git

大致流程

 

生成rknn文件-----------------------------------------------------------------------------------------

1：进入docker

docker run -t -i --privileged -v /dev/bus/usb:/de/bus/usb  \

-v /home/wzw/rk_npu_sdk/rknn-toolkit-master-v1.7.3:/rknn_toolkit rknn-toolkit:1.7.3 /bin/bash

2：进入/rknn_toolkit/examples/onnx，复制一个resnet50v2并命名为MNIST

3：准备以下文件

4：代码

import os
import urllib
import traceback
import time
import sys
import numpy as np
import cv2
from rknn.api import RKNN

ONNX_MODEL = 'model.onnx'
RKNN_MODEL = 'model.rknn'

if __name__ == '__main__':

    # Create RKNN object
    rknn = RKNN()

    # pre-process config
    print('--> Config model')
    rknn.config(target_platform=["rv1126"])
    print('done')

    # Load ONNX model
    print('--> Loading model')
    ret = rknn.load_onnx(model=ONNX_MODEL,
                         inputs=['input.1'],
                         input_size_list=[[1,28,28]],
                         outputs=['25'])
    if ret != 0:
        print('Load model failed!')
        exit(ret)
    print('done')

    # Build model
    print('--> Building model')
    ret = rknn.build(do_quantization=False)
    if ret != 0:
        print('Build model failed!')
        exit(ret)
    print('done')

    # Export RKNN model
    print('--> Export RKNN model')
    ret = rknn.export_rknn(RKNN_MODEL)
    if ret != 0:
        print('Export resnet50v2.rknn failed!')
        exit(ret)
    print('done')

    # Set inputs
    with open("./data/MNIST/raw/train-images-idx3-ubyte","rb") as f:
        file=f.read()
        num=100
        i = 16+784*num
        image1 = [int(str(item).encode('ascii'),16) for item in file[i:i+784]]
        input_data = np.array(image1,dtype=np.float32).reshape(1,1,28,28)
    #save the image
    image1_np = np.array(image1,dtype=np.uint8).reshape(28,28,1)
    file_name = "test.jpg"
    cv2.imwrite(file_name,image1_np)

    # init runtime environment
    print('--> Init runtime environment')
    ret = rknn.init_runtime()
    if ret != 0:
        print('Init runtime environment failed')
        exit(ret)
    print('done')

    # Inference
    print('--> Running model')
    outputs = rknn.inference(inputs=input_data)
    x = outputs[0]
    output = np.exp(x)/np.sum(np.exp(x))
    outputs = np.argmax([output])
    print("----------outputs----------",outputs)
    print('done')

    rknn.release()

 

5：python test.py

生成rknn文件

rknpu------------------------------------------------------------------------------------------------

复制一个mobilenet并命名为MNIST目录结构为：

将toolkit生成的rknn模型文件拷贝至model

build.sh

#!/bin/bash

set -e

# for rk1808 aarch64
# GCC_COMPILER=${RK1808_TOOL_CHAIN}/bin/aarch64-linux-gnu

# for rk1806 armhf
# GCC_COMPILER=~/opts/gcc-linaro-6.3.1-2017.05-x86_64_arm-linux-gnueabihf/bin/arm-linux-gnueabihf

# for rv1109/rv1126 armhf
GCC_COMPILER=/opt/atk-dlrv1126-toolchain/bin/arm-linux-gnueabihf

ROOT_PWD=$( cd "$( dirname $0 )" && cd -P "$( dirname "$SOURCE" )" && pwd )

# build rockx
BUILD_DIR=${ROOT_PWD}/build

if [[ ! -d "${BUILD_DIR}" ]]; then
  mkdir -p ${BUILD_DIR}
fi

cd ${BUILD_DIR}
cmake .. \
    -DCMAKE_C_COMPILER=${GCC_COMPILER}-gcc \
    -DCMAKE_CXX_COMPILER=${GCC_COMPILER}-g++
make -j4
make install

main.cc

/*-------------------------------------------
                Includes
-------------------------------------------*/
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <fstream>
#include <iostream>
#include <sys/time.h>

#define STB_IMAGE_IMPLEMENTATION
#include "stb/stb_image.h"
#define STB_IMAGE_RESIZE_IMPLEMENTATION
#include <stb/stb_image_resize.h>

#include "rknn_api.h"

using namespace std;

const int MODEL_IN_WIDTH = 28;
const int MODEL_IN_HEIGHT = 28;
const int MODEL_CHANNEL = 1;
int ret =0;
int loop_count = 1000;

/*-------------------------------------------
                  Functions
-------------------------------------------*/
static inline int64_t getCurrentTimeUs()
{
    struct timeval tv;
    gettimeofday(&tv, NULL);
    return tv.tv_sec * 1000000 + tv.tv_usec;
}

static void printRKNNTensor(rknn_tensor_attr *attr)
{
    printf("index=%d name=%s n_dims=%d dims=[%d %d %d %d] n_elems=%d size=%d fmt=%d type=%d qnt_type=%d fl=%d zp=%d scale=%f\n",
           attr->index, attr->name, attr->n_dims, attr->dims[3], attr->dims[2], attr->dims[1], attr->dims[0],
           attr->n_elems, attr->size, 0, attr->type, attr->qnt_type, attr->fl, attr->zp, attr->scale);
}

static unsigned char *load_model(const char *filename, int *model_size)
{
    FILE *fp = fopen(filename, "rb");
    if (fp == nullptr)
    {
        printf("fopen %s fail!\n", filename);
        return NULL;
    }
    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))
    {
        printf("fread %s fail!\n", filename);
        free(model);
        return NULL;
    }
    *model_size = model_len;
    if (fp)
    {
        fclose(fp);
    }
    return model;
}

void Load_data(int num,unsigned char * input_image)
{
    int j=16+784*num;
    FILE *file = fopen("./model/data/MNIST/raw/train-images-idx3-ubyte", "rb");
    if (file == NULL) {
        printf("can't open the file!\n");
    }
    fseek(file,j,SEEK_SET);
    fread(input_image,sizeof(char),784,file);
    /* for(int i=0;i<MODEL_IN_WIDTH;i++){
        for(int j=0;j<MODEL_IN_WIDTH;j++){
            printf("%4d",input_image[i*28+j]);
        }
        printf("\n");
    } */
    fclose(file);
}

void Array_change(float input_aray[][MODEL_CHANNEL][MODEL_IN_WIDTH][MODEL_IN_HEIGHT],unsigned char *input_image)
{
   int index=0;
    for (int i = 0; i < 1; i++) {
        for (int j = 0; j < MODEL_CHANNEL; j++) {
            for (int k = 0; k < MODEL_IN_HEIGHT; k++) {
                for (int l = 0; l < MODEL_IN_WIDTH; l++) {
                    input_aray[i][j][k][l] = (float)input_image[index++];
                    //printf("%d ", input_aray[i][j][k][l]);
                    if(input_aray[i][j][k][l]==0){
                        //printf(" ");
                    }
                }
                //printf("\n");
            }
        }
         //printf("\n");
    } 
}

void Bubble_sort(float *buffer)
{
    float temp=0;
    for(int i = 0; i < 10; i++){
        for(int j=0;j<10-i-1;j++){
            if(buffer[j]>buffer[j+1]){
                temp=buffer[j];
                buffer[j]=buffer[j+1];
                buffer[j+1]=temp;
            }
        }
    }
}

void get_tensor_message(rknn_context ctx,rknn_tensor_attr *attrs,uint32_t num,int io)
{
    for (int i = 0; i < num; i++) {
        attrs[i].index = i;
        if(io==1){
        ret = rknn_query(ctx, RKNN_QUERY_INPUT_ATTR, &(attrs[i]), sizeof(rknn_tensor_attr));
        }
        else{
            ret = rknn_query(ctx, RKNN_QUERY_OUTPUT_ATTR, &(attrs[i]), sizeof(rknn_tensor_attr));
        }
        if (ret != RKNN_SUCC) {
            printf("rknn_query fail! ret=%d\n", ret);
        }
        printRKNNTensor(&(attrs[i]));
    }
}
void print_Array(int num,float *buffer)
{
    for(int i =0;i<num;i++){
        printf("%f\n",buffer[i]);
    }
}
/*-------------------------------------------
                  Main Function
-------------------------------------------*/
int main(int argc, char **argv)
{
    rknn_context ctx;
    int model_len = 0;
    unsigned char *model;
    int num=-1;
    int64_t time[1000]={};
    int64_t sum=0;

    const char *model_path = "./model/model.rknn";

    // Load RKNN Model
    model = load_model(model_path, &model_len);

    ret = rknn_init(&ctx, model, model_len, 0);
    if (ret < 0)
    {
        printf("rknn_init fail! ret=%d\n", ret);
        return -1;
    }

    // Get Model Input Output Info
    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);

    printf("input tensors:\n");
    rknn_tensor_attr input_attrs[io_num.n_input];
    memset(input_attrs, 0, sizeof(input_attrs));
    get_tensor_message(ctx,input_attrs,io_num.n_input,1);

    printf("output tensors:\n");
    rknn_tensor_attr output_attrs[io_num.n_output];
    memset(output_attrs, 0, sizeof(output_attrs));
    get_tensor_message(ctx,output_attrs,io_num.n_output,0);

    for(int i=0;i<loop_count;i++){
        printf("------------------------loop %d\n",i);
        // Load image
        unsigned char input_image[784]={};
        float input_aray[1][MODEL_CHANNEL][MODEL_IN_HEIGHT][MODEL_IN_WIDTH]={};
        num++;
        Load_data(num,input_image);
        Array_change(input_aray,input_image);
        // Set Input Data
        rknn_input inputs[1];
        memset(inputs, 0, sizeof(inputs));
        inputs[0].index = 0;
        inputs[0].type = RKNN_TENSOR_FLOAT32;
        inputs[0].size = input_attrs[0].size;
        inputs[0].fmt = RKNN_TENSOR_NCHW;
        inputs[0].buf = input_aray;

        ret = rknn_inputs_set(ctx, io_num.n_input, inputs);
        if (ret < 0)
        {
            printf("rknn_input_set fail! ret=%d\n", ret);
            return -1;
        }

        // Run
        printf("rknn_run\n");
        int64_t start_us = getCurrentTimeUs();
        ret = rknn_run(ctx, nullptr);
        if (ret < 0){
            printf("rknn_run fail! ret=%d\n", ret);
            return -1;
        }
        time[i] = getCurrentTimeUs() - start_us;
        sum=sum+time[i];
        printf(": Elapse Time = %.2fms sum %.2f", time[i] / 1000.f,sum / 1000.f);

        // Get Output
        rknn_output outputs[1];
        memset(outputs, 0, sizeof(outputs));
        outputs[0].want_float = 1;
        ret = rknn_outputs_get(ctx, 1, outputs, NULL);
        if (ret < 0)
        {
            printf("rknn_outputs_get fail! ret=%d\n", ret);
            return -1;
        }
        //postprocess
        float *buffer = (float *)outputs[0].buf;
        float buffer_copy[]={};
        for(int i=0;i<10;i++){
            buffer_copy[i]=buffer[i];      
        }
        Bubble_sort(buffer);
       /*  printf("buffer is \n");
        print_Array(10,buffer);
        printf("\nbuffer_copy is \n");
        print_Array(10,buffer_copy); */
        for(int i =0;i<10;i++){
            if(buffer_copy[i]==buffer[9]){
                printf("----------the pic value is %d \n",i);
            }
        }
        // Release rknn_outputs
        rknn_outputs_release(ctx, 1, outputs);
    }
    
    
    printf("--------- loop time : %d average time is %.2f ms\n",loop_count,(sum / 1000.f)/loop_count);

    // Release
    if (ctx >= 0)
    {
        rknn_destroy(ctx);
    }
    if (model)
    {
        free(model);
    }
    return 0;
}

打印结果

fp16

uint8

 

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/849318.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【工具插件类教学】电脑端移动端缩放大图自适应Simple Zoom

【工具插件类教学】电脑端移动端缩放大图自适应Simple Zoom

目录 简介 1.创建Canvas并设置 2.使用预制体Zoom 3.商店地址 简介 特点: •易于使用和高度可定制。 •支持鼠标(桌面)和触摸(移动)。 •指定最小和最大缩放的限制。 •缩放指针(鼠标/手指)或屏幕上预定义的自定义位置。 •变焦时使用夹紧/弹性变焦类型。 •定义缩…
阅读更多...
【科研人 学生党】AI辅助学术论文阅读

【科研人 学生党】AI辅助学术论文阅读

【适合于学生党和科研人】写文章往往需要找到好的研究点和方向&#xff0c;但是这并不是一件容易的事情&#xff0c;往往需要阅读大量的文献&#xff0c;阅读文献是一个耗时耗力的过程&#xff0c;而且你阅读了也不一定能提取出重要观点和信息。因此&#xff0c;借助GPT帮我们提…
阅读更多...
深入理解 this

深入理解 this

文章目录 1. 理解 this2. 为了进一步理解 this,我们再看一个案例3. this 的注意事项和使用细节 1. 理解 this 什么是 this&#xff1f; java虚拟机会给每一个对象分配 this&#xff0c;代表当前对象&#xff0c;坦白的讲&#xff0c;要明白 this不是件容易的事&#xff0c;打一…
阅读更多...
容器安全的常见风险与防护实践

容器安全的常见风险与防护实践

运行在云平台上的容器产品&#xff0c;因为具备一个完整的可移植应用程序环境&#xff0c;能够帮助用户轻松地完成对应用程序的开关控制&#xff0c;提升应用程序的敏捷性&#xff0c;同时节约企业的IT建设成本。在巨大优势作用下&#xff0c;容器产品的采用率在2021年达到了新…
阅读更多...
爬虫来介绍ChromeF12 谷歌开发者工具 -Network

爬虫来介绍ChromeF12 谷歌开发者工具 -Network

了解网页基础(HTML、CSS、JavaScript) 了解HTTP基本原理 了解JSON格式 了解Ajax请求 了解爬虫基本原理 (一)、Chrome开发者工具面板概述 Elements 查找网页源代码HTML中的任一元素,手动修改任一元素的属性和样式且能实时在浏览器里面得到反馈。 比如我们在Event Listener…
阅读更多...
UML-A 卷-知识考卷

UML-A 卷-知识考卷

UML-A 卷-知识考卷 UML有多少种图&#xff0c;请列出每种图的名字&#xff1a; 常用的几种UML图&#xff1a; 类图&#xff08;Class Diagram&#xff09;&#xff1a;类图是描述类、接口、关联关系和继承关系的图形化表示。它展示了系统中各个类之间的静态结构和关系。时序…
阅读更多...
WEB集群——负载均衡集群

WEB集群——负载均衡集群

目录 一、 LVS-DR 群集。 1、LVS-DR工作原理 2、LVS-DR模式的特点 3、部署LVS-DR集群 3.1 配置负载调度器&#xff08;192.168.186.100&#xff09; 3.2 第一台web节点服务器&#xff08;192.168.186.103&#xff09; 3.3 第二台web节点服务器&#xff08;192.168.186.…
阅读更多...
高温老化房软件使用教程

高温老化房软件使用教程

高温老化炉软件通常具有以下几个模块&#xff1a; 1. 参数设置模块&#xff1a;该模块用于设置高温老化炉的相关参数&#xff0c;包括温度、时间、压力等。用户可以通过输入框、滑动条或下拉菜单等方式设定参数&#xff0c;并将参数发送给高温老化炉。 2. 监控模块&#xff1a;…
阅读更多...
认识http的方法、Header、状态码以及简单实现一个http的业务逻辑

认识http的方法、Header、状态码以及简单实现一个http的业务逻辑

文章目录 http的方法http状态码http重定向http常见Header实现简单业务逻辑Protocol.hppUtil.hppServer.hppServer.cc 效果 http的方法 方法说明支持的HTTP版本GET获取资源1.0/1.1POST传输实体主体1.0/1.1PUT传输文件1.0/1.1HEAD获得报文首部1.0/1.1DELETE删除文件1.0/1.1OPTIO…
阅读更多...
Centos7.6安装mysql8.0.20

Centos7.6安装mysql8.0.20

安装前 1.安装mysql前&#xff0c;需将系统自带的mariadb卸载。 [rootk8s01 ~]#  rpm ‐qa|grep mariadbmariadb‐libs.x86_643[rootk8s01 ~]#  rpm ‐e ‐‐nodeps mariadb‐libs.x86_643[rootk8s01 ~]#  rpm ‐qa|grep mariadb 2. 下载mysql8.0.20 [rootk8s-01…
阅读更多...
【王树森】深度强化学习(DRL)课程笔记：P1 基本概念（含gym安装）

【王树森】深度强化学习(DRL)课程笔记：P1 基本概念（含gym安装）

课程信息 课程主讲&#xff1a;王树森&#xff08;史蒂文斯理工学院计算机科学系的终身制助理教授&#xff09; 课程内容&#xff1a;基本概念、价值学习、策略学习、Actor-Critic方法、AlphaGo、Monte Carlo (蒙特卡洛) 课程资料&#xff1a;https://github.com/wangshusen/D…
阅读更多...
【MATLAB第66期】#源码分享 | 基于MATLAB的PAWN全局敏感性分析模型（有条件参数和无条件参数）

【MATLAB第66期】#源码分享 | 基于MATLAB的PAWN全局敏感性分析模型（有条件参数和无条件参数）

【MATLAB第66期】#源码分享 | 基于MATLAB的PAWN全局敏感性分析模型&#xff08;有条件参数和无条件参数&#xff09; 文献参考 Pianosi, F., Wagener, T., 2015. A simple and efficient method for global sensitivity analysis based on cumulative distribution functions.…
阅读更多...
python多线程及协程

python多线程及协程

目录 进程和线程 串行和并行 多线程编程 Thread类 创建线程参数 具体案例 继承Thread类 具体案例 线程池 具体案例 协程 协程的使用 协程函数写法 调用多个协程函数 main函数的写法 案例 进程和线程 进程&#xff1a;就是一个程序&#xff0c;运行在系统之上…
阅读更多...
[每日习题]年终奖（动态规划） 迷宫问题（DFS+回溯）——牛客习题

[每日习题]年终奖（动态规划） 迷宫问题（DFS+回溯）——牛客习题

hello,大家好&#xff0c;这里是bang___bang_&#xff0c;本篇记录2道牛客习题&#xff0c;年终奖&#xff08;简单&#xff09;&#xff0c;迷宫问题&#xff08;中等&#xff09;&#xff0c;如有需要&#xff0c;希望能有所帮助&#xff01; 目录 1️⃣年终奖 2️⃣迷宫问…
阅读更多...
Linux学习-1

Linux学习-1

Linux学习-1 1.文件系统的常识 本文主要引用鸟哥的Linux私房菜 1.1 常见的标识介绍 > [-][rwx][r-x][r--] > 1 234 567 890 1 为&#xff1a;代表这个文件名为目录或文件&#xff0c;本例中为文件&#xff08;-&#xff09;&#xff1b; 234为&#xff1a;拥有者的权限…
阅读更多...
MongoDB数据库操作及操作命令

MongoDB数据库操作及操作命令

目录 一、基础概念 二、安装mongod 三、命令交互数据库 &#xff08;1&#xff09;数据库命令 &#xff08;2&#xff09;集合命令 &#xff08;3&#xff09;文档命令 四、Mongoose &#xff08;1&#xff09;增加一条数据 &#xff08;2&#xff09;插入多个数据 &am…
阅读更多...
React实现关键字高亮

React实现关键字高亮

先看效果&#xff1a; 实现很简单通过以下这个函数&#xff1a; highLight (text, keyword ) > {return text.split(keyword).flatMap(str > [<span style{{ color: red, fontWeight: bold }}>{keyword}</span>, str]).slice(1);}展示某段文本时调用该函数…
阅读更多...
【从零开始学习JAVA | 第四十二篇】初学网络编程

【从零开始学习JAVA | 第四十二篇】初学网络编程

目录 前言&#xff1a; 什么是网络编程&#xff1a; 网络编程的应用场景&#xff1a; 常见的软件架构&#xff1a; CS架构&#xff1a; BS架构&#xff1a; 网络编程三要素&#xff1a;​ 总结&#xff1a; 前言&#xff1a; 当今互联网已经渗透到我们日常生活的方方面…
阅读更多...
【MongoDB】万字长文，命令与代码一一对应SpringBoot整合MongoDB之MongoTemplate

【MongoDB】万字长文，命令与代码一一对应SpringBoot整合MongoDB之MongoTemplate

目录 一、导入依赖与配置信息 二、导入测试数据创建实体类 三、插入数据 1、Insert默认集合插入 2、Insert指定集合插入 3、Insert批量插入数据 4、save默认集合插入 5、save指定集合插入 6、insert与save的区别 四、修改数据 1、修改符合条件的第一条数据 2、全…
阅读更多...
单例模式-java实现

单例模式-java实现

介绍 单例模式的意图&#xff1a;保证某个类在系统中有且仅有一个实例。 我们可以看到下面的类图&#xff1a;一般的单例的实现&#xff0c;是属性中保持着一个自己的私有静态实例引用&#xff0c;还有一个私有的构造方法&#xff0c;然后再开放一个静态的获取实例的方法给外界…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023