基于python部署训练环境，训练的文字识别模型在C++源码部署加入该模型文件后不适用，报异常关于Paddle_inference的问题

[zhaocanglong]

请提供下述完整信息以便快速定位问题/Please provide the following information to quickly locate the problem

• 系统环境/System Environment：Windows 11

• 版本号/Version：2.6 PaddleOCR：python训练的模型不能在C++源码中调用，编译器会引发异常
  以下方法中根据输出判断是在std::cout << "predictor_ start:" << input_names.size() << std::endl;后就发生异常
  void CRNNRecognizer::Run(std::vectorcv::Mat img_list,
  std::vectorstd::string &rec_texts,
  std::vector &rec_text_scores,
  std::vector &times) {
  std::chrono::duration preprocess_diff =
  std::chrono::steady_clock::now() - std::chrono::steady_clock::now();
  std::chrono::duration inference_diff =
  std::chrono::steady_clock::now() - std::chrono::steady_clock::now();
  std::chrono::duration postprocess_diff =
  std::chrono::steady_clock::now() - std::chrono::steady_clock::now();

  int img_num = img_list.size();
  std::vector width_list;
  for (int i = 0; i < img_num; i++) {
  width_list.push_back(float(img_list[i].cols) / img_list[i].rows);
  }
  std::cout << "indices" << std::endl;
  std::vector indices = Utility::argsort(width_list);
  std::cout << "indices end:" << indices.size() << std::endl;
  for (int beg_img_no = 0; beg_img_no < img_num;
  beg_img_no += this->rec_batch_num_) {
  auto preprocess_start = std::chrono::steady_clock::now();
  int end_img_no = std::min(img_num, beg_img_no + this->rec_batch_num_);
  int batch_num = end_img_no - beg_img_no;
  int imgH = this->rec_image_shape_[1];
  int imgW = this->rec_image_shape_[2];
  float max_wh_ratio = imgW * 1.0 / imgH;
  for (int ino = beg_img_no; ino < end_img_no; ino++) {
  int h = img_list[indices[ino]].rows;
  int w = img_list[indices[ino]].cols;
  float wh_ratio = w * 1.0 / h;
  max_wh_ratio = std::max(max_wh_ratio, wh_ratio);
  }

  int batch_width = imgW;
  std::vectorcv::Mat norm_img_batch;
  for (int ino = beg_img_no; ino < end_img_no; ino++) {
  cv::Mat srcimg;
  img_list[indices[ino]].copyTo(srcimg);
  cv::Mat resize_img;
  std::cout << "resize_op_ start" << std::endl;
  this->resize_op_.Run(srcimg, resize_img, max_wh_ratio,
  this->use_tensorrt_, this->rec_image_shape_);
  std::cout << "resize_op_ end" << std::endl;
  std::cout << "normalize_op_ start" << std::endl;
  this->normalize_op_.Run(&resize_img, this->mean_, this->scale_,
  this->is_scale_);
  std::cout << "normalize_op_ end" << std::endl;
  norm_img_batch.push_back(resize_img);
  batch_width = std::max(resize_img.cols, batch_width);
  }

  std::vector input(batch_num * 3 * imgH * batch_width, 0.0f);
  std::cout << "permute_op_ start" << std::endl;
  this->permute_op_.Run(norm_img_batch, input.data());
  std::cout << "permute_op_ end" << std::endl;
  auto preprocess_end = std::chrono::steady_clock::now();
  preprocess_diff += preprocess_end - preprocess_start;
  // Inference.
  auto input_names = this->predictor_->GetInputNames();
  std::cout << "permute_op_ start" << input_names.size() << std::endl;
  auto input_t = this->predictor_->GetInputHandle(input_names[0]);
  input_t->Reshape({batch_num, 3, imgH, batch_width});
  auto inference_start = std::chrono::steady_clock::now();
  input_t->CopyFromCpu(input.data());
  std::cout << "predictor_ start:" << input_names.size() << std::endl;
  this->predictor_->Run();
  std::cout << "predictor_ end:" << input_names.size() << std::endl;
  std::vector predict_batch;
  auto output_names = this->predictor_->GetOutputNames();
  auto output_t = this->predictor_->GetOutputHandle(output_names[0]);
  auto predict_shape = output_t->shape();

  int out_num = std::accumulate(predict_shape.begin(), predict_shape.end(), 1,
  std::multiplies());
  predict_batch.resize(out_num);
  // predict_batch is the result of Last FC with softmax
  output_t->CopyToCpu(predict_batch.data());
  auto inference_end = std::chrono::steady_clock::now();
  inference_diff += inference_end - inference_start;
  // ctc decode
  auto postprocess_start = std::chrono::steady_clock::now();
  for (int m = 0; m < predict_shape[0]; m++) {
  std::string str_res;
  int argmax_idx;
  int last_index = 0;
  float score = 0.f;
  int count = 0;
  float max_value = 0.0f;

  for (int n = 0; n < predict_shape[1]; n++) {
    // get idx
    argmax_idx = int(Utility::argmax(
        &predict_batch[(m * predict_shape[1] + n) * predict_shape[2]],
        &predict_batch[(m * predict_shape[1] + n + 1) * predict_shape[2]]));
    // get score
    max_value = float(*std::max_element(
        &predict_batch[(m * predict_shape[1] + n) * predict_shape[2]],
        &predict_batch[(m * predict_shape[1] + n + 1) * predict_shape[2]]));
  
    if (argmax_idx > 0 && (!(n > 0 && argmax_idx == last_index))) {
      score += max_value;
      count += 1;
      str_res += label_list_[argmax_idx];
    }
    last_index = argmax_idx;
  }
  score /= count;
  if (std::isnan(score)) {
    continue;
  }
  rec_texts[indices[beg_img_no + m]] = str_res;
  rec_text_scores[indices[beg_img_no + m]] = score;
  

  }
  auto postprocess_end = std::chrono::steady_clock::now();
  postprocess_diff += postprocess_end - postprocess_start;
  }
  times.push_back(double(preprocess_diff.count() * 1000));
  times.push_back(double(inference_diff.count() * 1000));
  times.push_back(double(postprocess_diff.count() * 1000));
  }

[Sunting78]

您好，希望能给出更多的信息，使用了哪个模型，加入的该模型文件具体是什么，抛出了什么异常等。便于问题定位。可以参考下面的文档核对操作是否正确：https://github.com/PaddlePaddle/PaddleOCR/blob/release/2.7/deploy/cpp_infer/readme_ch.md

[changdazhou]

建议直接使用FD的cpp部署试试哈

[zhaocanglong]

`// Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include <gflags/gflags.h>

// common args
DEFINE_bool(use_gpu, false, "Infering with GPU or CPU.");
DEFINE_bool(use_tensorrt, false, "Whether use tensorrt.");
DEFINE_int32(gpu_id, 0, "Device id of GPU to execute.");
DEFINE_int32(gpu_mem, 4000, "GPU id when infering with GPU.");
DEFINE_int32(cpu_threads, 10, "Num of threads with CPU.");
DEFINE_bool(enable_mkldnn, true, "Whether use mkldnn with CPU.");
DEFINE_string(precision, "fp32", "Precision be one of fp32/fp16/int8");
DEFINE_bool(benchmark, false, "Whether use benchmark.");
DEFINE_string(output, "./output/", "Save benchmark log path.");
DEFINE_string(image_dir, "./11.jpg", "Dir of input image.");
DEFINE_string(
type, "ocr",
"Perform ocr or structure, the value is selected in ['ocr','structure'].");
// detection related
DEFINE_string(det_model_dir, "./models/ch_PP-OCRv3_det_infer", "Path of det inference model.");
DEFINE_string(limit_type, "max", "limit_type of input image.");
DEFINE_int32(limit_side_len, 960, "limit_side_len of input image.");
DEFINE_double(det_db_thresh, 0.3, "Threshold of det_db_thresh.");
DEFINE_double(det_db_box_thresh, 0.6, "Threshold of det_db_box_thresh.");
DEFINE_double(det_db_unclip_ratio, 1.5, "Threshold of det_db_unclip_ratio.");
DEFINE_bool(use_dilation, false, "Whether use the dilation on output map.");
DEFINE_string(det_db_score_mode, "slow", "Whether use polygon score.");
DEFINE_bool(visualize, true, "Whether show the detection results.");
// classification related
DEFINE_bool(use_angle_cls, false, "Whether use use_angle_cls.");
DEFINE_string(cls_model_dir, "", "Path of cls inference model.");
DEFINE_double(cls_thresh, 0.9, "Threshold of cls_thresh.");
DEFINE_int32(cls_batch_num, 1, "cls_batch_num.");
// recognition related
DEFINE_string(rec_model_dir, "./models/ch_PP-OCRv3_rec_infer", "Path of rec inference model.");
DEFINE_int32(rec_batch_num, 6, "rec_batch_num.");
DEFINE_string(rec_char_dict_path, "./ppocr_keys_v1.txt",
"Path of dictionary.");
DEFINE_int32(rec_img_h, 32, "rec image height");
DEFINE_int32(rec_img_w, 320, "rec image width");

// layout model related
DEFINE_string(layout_model_dir, "", "Path of table layout inference model.");
DEFINE_string(layout_dict_path,
"./layout_table_dict.txt",
"Path of dictionary.");
DEFINE_double(layout_score_threshold, 0.5, "Threshold of score.");
DEFINE_double(layout_nms_threshold, 0.5, "Threshold of nms.");
// structure model related
DEFINE_string(table_model_dir, "", "Path of table struture inference model.");
DEFINE_int32(table_max_len, 488, "max len size of input image.");
DEFINE_int32(table_batch_num, 1, "table_batch_num.");
DEFINE_bool(merge_no_span_structure, true,
"Whether merge and to ");
DEFINE_string(table_char_dict_path,
"./table_structure_dict_ch.txt",
"Path of dictionary.");

// ocr forward related
DEFINE_bool(det, true, "Whether use det in forward.");
DEFINE_bool(rec, true, "Whether use rec in forward.");
DEFINE_bool(cls, false, "Whether use cls in forward.");
DEFINE_bool(table, false, "Whether use table structure in forward.");
DEFINE_bool(layout, false, "Whether use layout analysis in forward."); // Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "opencv2/core.hpp"
#include "opencv2/imgcodecs.hpp"
#include "opencv2/imgproc.hpp"
#include
#include

#include <include/args.h>
#include <include/paddleocr.h>
#include <include/paddlestructure.h>

using namespace PaddleOCR;

void check_params() {
if (FLAGS_det) {
if (FLAGS_det_model_dir.empty() || FLAGS_image_dir.empty()) {
std::cout << "Usage[det]: ./ppocr "
"--det_model_dir=/PATH/TO/DET_INFERENCE_MODEL/ "
<< "--image_dir=/PATH/TO/INPUT/IMAGE/" << std::endl;
exit(1);
}
}
if (FLAGS_rec) {
std::cout
<< "In PP-OCRv3, rec_image_shape parameter defaults to '3, 48, 320',"
"if you are using recognition model with PP-OCRv2 or an older "
"version, "
"please set --rec_image_shape='3,32,320"
<< std::endl;
if (FLAGS_rec_model_dir.empty() || FLAGS_image_dir.empty()) {
std::cout << "Usage[rec]: ./ppocr "
"--rec_model_dir=/PATH/TO/REC_INFERENCE_MODEL/ "
<< "--image_dir=/PATH/TO/INPUT/IMAGE/" << std::endl;
exit(1);
}
}
if (FLAGS_cls && FLAGS_use_angle_cls) {
if (FLAGS_cls_model_dir.empty() || FLAGS_image_dir.empty()) {
std::cout << "Usage[cls]: ./ppocr "
<< "--cls_model_dir=/PATH/TO/REC_INFERENCE_MODEL/ "
<< "--image_dir=/PATH/TO/INPUT/IMAGE/" << std::endl;
exit(1);
}
}
if (FLAGS_table) {
if (FLAGS_table_model_dir.empty() || FLAGS_det_model_dir.empty() ||
FLAGS_rec_model_dir.empty() || FLAGS_image_dir.empty()) {
std::cout << "Usage[table]: ./ppocr "
<< "--det_model_dir=/PATH/TO/DET_INFERENCE_MODEL/ "
<< "--rec_model_dir=/PATH/TO/REC_INFERENCE_MODEL/ "
<< "--table_model_dir=/PATH/TO/TABLE_INFERENCE_MODEL/ "
<< "--image_dir=/PATH/TO/INPUT/IMAGE/" << std::endl;
exit(1);
}
}
if (FLAGS_layout) {
if (FLAGS_layout_model_dir.empty() || FLAGS_image_dir.empty()) {
std::cout << "Usage[layout]: ./ppocr "
<< "--layout_model_dir=/PATH/TO/LAYOUT_INFERENCE_MODEL/ "
<< "--image_dir=/PATH/TO/INPUT/IMAGE/" << std::endl;
exit(1);
}
}
if (FLAGS_precision != "fp32" && FLAGS_precision != "fp16" &&
FLAGS_precision != "int8") {
std::cout << "precison should be 'fp32'(default), 'fp16' or 'int8'. "
<< std::endl;
exit(1);
}
}

std::string ocr(std::vectorcv::String &cv_all_img_names) {
PPOCR ocr;

if (FLAGS_benchmark) {
ocr.reset_timer();
}

std::vectorcv::Mat img_list;
std::vectorcv::String img_names;
for (int i = 0; i < cv_all_img_names.size(); ++i) {
cv::Mat img = cv::imread(cv_all_img_names[i], cv::IMREAD_COLOR);
if (!img.data) {
std::cerr << "[ERROR] image read failed! image path: "
<< cv_all_img_names[i] << std::endl;
continue;
}
img_list.push_back(img);
img_names.push_back(cv_all_img_names[i]);
}

std::vectorstd::vector ocr_results =
ocr.ocr(img_list, FLAGS_det, FLAGS_rec, FLAGS_cls);
std::string res_str = "";
for (int i = 0; i < img_names.size(); ++i) {
std::cout << "predict img: " << cv_all_img_names[i] << std::endl;

Utility::print_result(ocr_results[i], res_str);
//Utility::print_result(ocr_results[i]);
if (FLAGS_visualize && FLAGS_det) {
std::string file_name = Utility::basename(img_names[i]);
cv::Mat srcimg = img_list[i];
Utility::VisualizeBboxes(srcimg, ocr_results[i],
FLAGS_output + "/" + file_name);
}
}
if (FLAGS_benchmark) {
ocr.benchmark_log(cv_all_img_names.size());
}
return res_str;
}

void structure(std::vectorcv::String &cv_all_img_names) {
PaddleOCR::PaddleStructure engine;

if (FLAGS_benchmark) {
engine.reset_timer();
}

for (int i = 0; i < cv_all_img_names.size(); i++) {
std::cout << "predict img: " << cv_all_img_names[i] << std::endl;
cv::Mat img = cv::imread(cv_all_img_names[i], cv::IMREAD_COLOR);
if (!img.data) {
std::cerr << "[ERROR] image read failed! image path: "
<< cv_all_img_names[i] << std::endl;
continue;
}

std::vector structure_results = engine.structure(
img, FLAGS_layout, FLAGS_table, FLAGS_det && FLAGS_rec);

for (int j = 0; j < structure_results.size(); j++) {
std::cout << j << "\ttype: " << structure_results[j].type
<< ", region: [";
std::cout << structure_results[j].box[0] << ","
<< structure_results[j].box[1] << ","
<< structure_results[j].box[2] << ","
<< structure_results[j].box[3] << "], score: ";
std::cout << structure_results[j].confidence << ", res: ";

if (structure_results[j].type == "table") {
std::cout << structure_results[j].html << std::endl;
if (structure_results[j].cell_box.size() > 0 && FLAGS_visualize) {
std::string file_name = Utility::basename(cv_all_img_names[i]);

  Utility::VisualizeBboxes(img, structure_results[j],
                           FLAGS_output + "/" + std::to_string(j) +
                               "_" + file_name);
}

} else {
std::cout << "count of ocr result is : "
<< structure_results[j].text_res.size() << std::endl;
if (structure_results[j].text_res.size() > 0) {
std::cout << "********** print ocr result "
<< "" << std::endl;
Utility::print_result(structure_results[j].text_res);
std::cout << " end print ocr result "
<< "**********" << std::endl;
}
}
}
}
if (FLAGS_benchmark) {
engine.benchmark_log(cv_all_img_names.size());
}
}

int main(int argc, char argv) {
// Parsing command-line
/ google::ParseCommandLineFlags(&argc, &argv, true);/
check_params();

if (!Utility::PathExists(FLAGS_image_dir)) {
std::cerr << "[ERROR] image path not exist! image_dir: " << FLAGS_image_dir
<< std::endl;
exit(1);
}

std::vectorcv::String cv_all_img_names;
cv::glob(FLAGS_image_dir, cv_all_img_names);
std::cout << "total images num: " << cv_all_img_names.size() << std::endl;

if (!Utility::PathExists(FLAGS_output)) {
Utility::CreateDir(FLAGS_output);
}
static std::string res = "";
if (FLAGS_type == "ocr") {
res = ocr(cv_all_img_names);
} else if (FLAGS_type == "structure") {
structure(cv_all_img_names);
} else {
std::cout << "only value in ['ocr','structure'] is supported" << std::endl;
}
std::cout << res << std::endl;
}
`
以上为源码
以下是vs执行后的异常

以下是使用的模型以及字符集
ch_PP-OCRv3_rec_infer.zip是训练的模型
ch_PP-OCRv3_rec_infer.zip
这个是官网下载的PP_OCRv3轻量模型
ch_PP-OCRv3_det_infer.zip
字符集
ppocr_keys_v1.txt

[zhaocanglong]

使用python的是可以的，paddleocr2.6版本中提供的训练模型的方法去做的，验证后是可以的。这个是Windows GPU版本的，实际上运用模型的采用C++源码部署的，windows cpu版本。

[changdazhou]

现在报错的是GPU版本的还是CPU版本呢，如果是CPU版本，是因为CPU版本不稳定导致的

[zhaocanglong]

采用gpu是为了训练模型的，但是，实际运用的是在cpu版本上。出问题的是在cpu 发自我的iPhone

…

------------------ 原始邮件 ------------------ 发件人: changdazhou ***@***.***&gt; 发送时间: 2024年2月23日 14:29 收件人: PaddlePaddle/PaddleOCR ***@***.***&gt; 抄送: zhaocanglong ***@***.***&gt;, Author ***@***.***&gt; 主题: Re: [PaddlePaddle/PaddleOCR] 基于python部署训练环境，训练的文字识别模型在C++源码部署加入该模型文件后不适用，报异常关于Paddle_inference的问题 (Issue #11612) 现在报错的是GPU版本的还是CPU版本呢，如果是CPU版本，是因为CPU版本不稳定导致的 — Reply to this email directly, view it on GitHub, or unsubscribe. You are receiving this because you authored the thread.Message ID: ***@***.***&gt;

[Charles-Lau]

same issue，paddleocr_release_2.6对应对的通过降低paddle_inference的版本为2.2.2可以解决，realease_2.7对应的2.3的版本