调用python脚本转caffe模型为rknn 模型

--> config model
done
--> Loading model
done
--> Building model
W extend res1_3_7 to add will cause accuracy loss, do not extend.
W extend res2_3_14 to add will cause accuracy loss, do not extend.
W extend res2_5_19 to add will cause accuracy loss, do not extend.
W extend res3_3_26 to add will cause accuracy loss, do not extend.
W extend res3_5_31 to add will cause accuracy loss, do not extend.
W extend res3_7_36 to add will cause accuracy loss, do not extend.
W extend res3_9_41 to add will cause accuracy loss, do not extend.
W extend res4_3_48 to add will cause accuracy loss, do not extend.
done
--> Export RKNN model
done


请问这个问题如何解决。

你这问题在哪里？warning很正常的，提示你精度损失而已。

jefferyzhang 发表于 2019-8-18 12:38
你这问题在哪里？warning很正常的，提示你精度损失而已。

精度丢失，导致接下来步骤结果不对

201310404103 发表于 2019-8-19 09:24
精度丢失，导致接下来步骤结果不对

结果不对和结果精度差异这是有明显区别的。
如果是结果不对你应该调试下其他方面。
精度损失一般是0.1111111 和 0.100999 这样的区别。在核对结果时候基本是对的，只是精度不一致而已。

想实现一个图片数据的输入，然后输出一个特征结结果，一下写法对吗？
int DealWithModel(cv::Mat img, vector<float>& V1)
{

        const int img_width = 96;                                                  /*图像尺寸*/
        const int img_height = 112;
        const int img_channels = 3;                                                /*图像量化通道*/
        const int input_index = 0;                                                 // node name "Preprocessor/sub"            

        if (img.cols != img_width || img.rows != img_height)                       /*如果图像的大小和定义的不一样，则进行重新设置大小*/
        {
                cv::resize(img, img, cv::Size(img_width, img_height), (0, 0), (0, 0), cv::INTER_LINEAR);
        }

        FILE* fp = fopen(model_path, "rb");                                        /*加载模型*/
        if (fp == NULL)
        {
                printf("fopen %s fail!\n", model_path);
                return -1;
        }
        fseek(fp, 0, SEEK_END);                                                    /*标记fp从文件头开始到文件末尾*/
        int model_len = ftell(fp);                                                 /*获取fp从头到尾的文件长度*/
        void* model = malloc(model_len);                                           /*动态申请内存*/
        fseek(fp, 0, SEEK_SET);                                                    /*把文件指针指向文件的开始*/
        if (model_len != fread(model, 1, model_len, fp))                           /*读取的长度不等于模型长度，则释放*/
        {
                printf("fread %s fail!\n", model_path);
                free(model);
                return -1;
        }
       
        /*开始推理*/
        rknn_input inputs[1];                                                      /*模型的一个input，用来作为参数传入给 rknn_inputs_set函数*/
        rknn_output outputs[1];                                                    /*模型的一个output，用来作为参数传入给rknn_outputs_get函数*/
        rknn_tensor_attr outputs_attr[1];                                          /*模型的Tenso属性*/

        int ret = 0;                                                               /*返回值*/
        rknn_context ctx = 0;                                                      /*rknn_context对象（unsigned long long类型）*/
        printf("rknn_init.\n");
        ret = rknn_init(&ctx, model, model_len, RKNN_FLAG_PRIOR_MEDIUM);           /*1、初始化rknn_context对象，优先级中*/
        if (ret < 0)
        {
                printf("rknn_init fail! ret=%d\n", ret);
                goto Error;
        }

        printf("rknn query input output num.\n");
        rknn_input_output_num io_num;                                              /*2、获取input和output的个数*/
        ret = rknn_query(ctx, RKNN_QUERY_IN_OUT_NUM, &io_num, sizeof(io_num));
        printf("input number:%d output number:%d\n", io_num.n_input, io_num.n_output);
        if (ret < 0)
        {
                printf("rknn query input output fail! ret=%d\n", ret);
                goto Error;
        }


        printf("rknn query input attrs.\n");
        rknn_tensor_attr input_attrs[1];                                           /*3、获取输入属性，io_num.n_input为输入个数*/
        memset(input_attrs, 0, sizeof(input_attrs));
        int i;
        for (i = 0; i < 1; i++)
        {
                input_attrs[i].index = i;
                ret = rknn_query(ctx, RKNN_QUERY_INPUT_ATTR, &(input_attrs[0]), sizeof(rknn_tensor_attr));
                printf("input data type :%d \n", input_attrs[0].type);
                printf("input data fmt :%d \n", input_attrs[0].fmt);
                if (ret < 0)
                {
                        printf("rknn_query fail! ret=%d\n", ret);
                        goto Error;
                }
        }

        printf("rknn query output attrs.\n");
        rknn_tensor_attr output_attrs[1];                                          /*4、获取输出属性，io_num.n_output为输出个数*/
        memset(output_attrs, 0, sizeof(output_attrs));
        for (i = 0; i < 1; i++)
        {
                output_attrs[i].index = i;
                ret = rknn_query(ctx, RKNN_QUERY_OUTPUT_ATTR, &(output_attrs[0]), sizeof(rknn_tensor_attr));
                printf("output data type :%d \n", output_attrs[0].type);
                if (ret < 0)
                {
                        printf("rknn_query fail! ret=%d\n", ret);
                        goto Error;
                }
        }

        printf("rknn inputs set.\n");
        rknn_input inputs_set[1];                                                  /*5、对输入进行设置*/
        inputs_set[0].index = input_index;                                         /*rknn模型的input node的索引*/
        inputs_set[0].buf = img.data;                                              /*cpu可以访问的buffer指针，一般是指向由Camera产生的图像数据*/
        inputs_set[0].size = img_width * img_height * img_channels;                /*为buffer的大小*/
        inputs_set[0].pass_through = false;                                        /*input数据直通模式选择,FALSE是输入属性于rknn_query查询得到的input属性不一致
                                                                                                                                                                                                          TURE是输入属性于rknn_query查询得到的input属性一致*/
        inputs_set[0].type = RKNN_TENSOR_UINT8;                                    /*为 buffer 的数据类型*/
        inputs_set[0].fmt = RKNN_TENSOR_NHWC;                                      /*数据格式*/
        ret = rknn_inputs_set(ctx, 1, inputs_set);
        if (ret < 0)
        {
                printf("rknn_input_set fail! ret=%d\n", ret);
                goto Error;
        }

        printf("rknn run.\n");
        ret = rknn_run(ctx, NULL);                                                 /*6、进行推理操作*/
        if (ret < 0)
        {
                printf("rknn_run fail! ret=%d\n", ret);
                goto Error;
        }

        printf("rknn get outputs.\n");
        rknn_output outputs_get[1];                                                /*7、获取输出结果*/
        memset(outputs_get, 0, sizeof(outputs_get));
        for (i = 0; i < 1; i++)
        {
                outputs_get[i].want_float = true;                                     /*输出数据格式,TURE为float32,FALSE为原始格式*/
                outputs_get[i].is_prealloc = false;                                   /*内存分配，TURE为程序员分配，FALSE为rknn自动分配*/
        }
        ret = rknn_outputs_get(ctx, io_num.n_output, outputs_get, NULL);

        float* ftype;
        char* sprintfBuf;
        ftype = static_cast<float*>(outputs_get->buf);

        char stringBuf[128];

        FILE* fpout;
        fpout = fopen("outputResult.txt", "w+");
        for (i = 0; i < (outputs_get->size / 4); i++)
        {
                V1.push_back(ftype[i]);
                sprintf(sprintfBuf, "%f\n", ftype[i]);
                fwrite(sprintfBuf, strlen(sprintfBuf), 1, fpout);
        }
        rknn_outputs_release(ctx, 1, outputs_get);                                /*8、释放由 rknn_outputs_get 获取的 outputs*/
        free(model);
Error:
        if (ctx)
        {
                rknn_destroy(ctx);
        }
        if (model)
        {
                free(model);
        }
        if (fp)
        {
                fclose(fp);
        }

        return 0;
}