PaddleOCR api call results on inference model don't make any sense

[Pedro69491]

I have been using PaddleOCR training capabilities in a small dataset of digits, after 25 epochs the accuracy of the model reaches 100%, I then evaluate the model and I get an accuracy of 100% too. The problem is that when I try to test the model on the exact same images I used to eval, I get completely different results, of course Iexported the best weights from the trained recognition model

from PaddleOCR.paddleocr import PaddleOCR

ocr = PaddleOCR(
use_gpu=False,
rec_char_dict_path='./digit_dict.txt',
rec_model_dir="./PaddleOCR/inference/rec_digits", # Path to the saved model
)

result = ocr.ocr(image_path)

notes: digit_dict refers to a small text file containing the numbers from 0 to 9

I tried to use infer_rec.py but the results were no good at all again with data that we already used to validate, not sure what I should do next.

[GreatV]

The issue you're facing, where the inference results of your PaddleOCR-trained model differ significantly from the validation results, is a common issue and often stems from discrepancies between the training and inference configurations. Based on your description and the provided references, here are some potential causes and troubleshooting steps:

---

1. Ensure Consistency Between Training and Inference Configurations

When exporting a trained model for inference, it's crucial that the configurations used during training (e.g., image preprocessing, character dictionary, model architecture) match those used during inference. Specifically:

• Character Dictionary (rec_char_dict_path): Ensure that the digit_dict.txt file used during inference is identical to the one used during training.
• Model Architecture: If you used a specific recognition algorithm (e.g., CRNN, SAR), ensure it is correctly configured during inference.
• Image Shape (rec_image_shape): The input shape of images during inference must match what the model was trained on.

---

2. Verify Model Export Process

The process of converting a trained model to an inference model can sometimes introduce issues. Make sure:

• You use the correct export script (tools/export_model.py) with the appropriate arguments. For example:

  python tools/export_model.py \
      -c configs/rec/digit_rec.yml \
      -o Global.pretrained_model=./output/best_accuracy.pdparams \
         Global.save_inference_dir=./inference/rec_digits/

• The exported model files (inference.pdmodel, inference.pdiparams, inference.pdiparams.info) are correctly saved in the directory you're pointing to during inference.

---

3. Debugging the Inference Results

• Testing with infer_rec.py:
  Use the tools/infer_rec.py script to test the exported model on your validation images. This will help confirm whether the issue lies in the model export process or the PaddleOCR API call:

  python tools/infer_rec.py \
      --image_dir="./path_to_images" \
      --rec_model_dir="./inference/rec_digits" \
      --rec_char_dict_path="./digit_dict.txt" \
      --use_gpu=False

  If the results are correct here, the issue likely lies in how you're using the PaddleOCR Python API.

• Testing Directly with API:
  Ensure you're correctly specifying the model directory and dictionary path in your API call:

  from paddleocr import PaddleOCR
  
  ocr = PaddleOCR(
      use_gpu=False, 
      rec_char_dict_path='./digit_dict.txt',
      rec_model_dir="./inference/rec_digits"
  )
  result = ocr.ocr(image_path, cls=False)
  print(result)

  If infer_rec.py works but the API call fails, there might be an issue with the PaddleOCR version or API usage.

---

4. Preprocessing Differences

Discrepancies in preprocessing during training and inference can significantly impact results. Check:

• Normalization: Ensure the same image normalization parameters (e.g., mean, standard deviation) are used in both training and inference.
• Image Resizing: The input image should be resized to the same dimensions as during training. For example, if your model expects 32x100 input, make sure the images are resized accordingly during inference.

---

5. Evaluate Overfitting or Data Issues

Although your model achieves 100% accuracy on both training and validation datasets, it might still be overfitting. This can happen if:

• The validation set is too similar to the training set.
• The model has memorized the training data rather than learning general features. To test this, evaluate the model on a separate test set that was not seen during training.

---

6. Check PaddleOCR Version Compatibility

Ensure that the PaddleOCR version used during training matches the version used during inference. Changes in the library between versions can lead to unexpected behavior. For example, you're using PaddleOCR version 2.8.1. Confirm that both training and inference use this version.

---

7. Related Discussions

Here are some relevant references from PaddleOCR's GitHub Discussions that might help:

• Discussion on inference discrepancies after model export: Link to Discussion #13973
• Issue with exported model producing incorrect results: Link to Discussion #14088
• Debugging inference model output: Link to Discussion #13958

---

Suggested Next Steps

1. Verify consistency between training and inference configurations.
2. Test the exported model with infer_rec.py to isolate the issue.
3. Double-check the preprocessing steps during inference.
4. If the problem persists, consider re-exporting the model or re-training with a more diverse dataset to reduce overfitting.

By following these steps, you should be able to diagnose and resolve the issue. Let me know if you need further assistance!

---

Response generated by 🤖 feifei-bot | chatgpt-4o-latest

[karanpate1]

I have been using PaddleOCR training capabilities in a small dataset of digits, after 25 epochs the accuracy of the model reaches 100%, I then evaluate the model and I get an accuracy of 100% too. The problem is that when I try to test the model on the exact same images I used to eval, I get completely different results, of course Iexported the best weights from the trained recognition model

from PaddleOCR.paddleocr import PaddleOCR

ocr = PaddleOCR( use_gpu=False, rec_char_dict_path='./digit_dict.txt', rec_model_dir="./PaddleOCR/inference/rec_digits", # Path to the saved model )

result = ocr.ocr(image_path)

notes: digit_dict refers to a small text file containing the numbers from 0 to 9

I tried to use infer_rec.py but the results were no good at all again with data that we already used to validate, not sure what I should do next.

Issue: High Validation Accuracy but Garbage Inference in PP-OCRv5 (Solved)

I fine-tuned PP-OCRv5 on a custom dataset (English alphabets, numerals, and some symbols).

• Training accuracy: 98%
• Validation accuracy: 99%

But when I ran inference (even on images from training/validation sets), the predictions were totally wrong.

I double-checked everything:

• Followed official finetuning + export steps
• Tested with both tools/infer_rec.py and exported inference model
• Same problem: terrible results

At this point, I was stuck because evaluation showed 99% accuracy, but inference was useless.

---

Root Cause

Turns out the problem was due to mismatch in image preprocessing between training and inference.

In my training config PP-OCRv5_mobile_rec.yml:

sampler:
  name: MultiScaleSampler
  scales: [[320, 32], [320, 48], [320, 64]]

So during training, images were dynamically resized to 3 different shapes:

• 3×32×320
• 3×48×320
• 3×64×320

But in my exported inference.yml, the preprocessing looked like this:

PreProcess:
  transform_ops:
  - DecodeImage:
      channel_first: false
      img_mode: BGR
  - MultiLabelEncode:
      gtc_encode: NRTRLabelEncode
  - RecResizeImg:
      image_shape:
      - 3
      - 48
      - 320

Notice the mismatch?

• Training: random multi-scale (32, 48, 64 heights)
• Inference: fixed to 48 height only

That mismatch caused the network to completely fail at inference.

---

✅ Fix

I manually adjusted the inference.yml to try different scales from training.

• With 3×48×320, results were trash.
• With 3×64×320, also trash.
• With 3×32×320, predictions became perfect, matching my training/validation accuracy.

So the fix was:
Set RecResizeImg.image_shape in inference.yml to the same shape(s) used in training.

Final fix:

PreProcess:
  transform_ops:
  - DecodeImage:
      channel_first: false
      img_mode: BGR
  - MultiLabelEncode:
      gtc_encode: NRTRLabelEncode
  - RecResizeImg:
      image_shape:
      - 3
      - 32
      - 320

---

Takeaway

If you’re fine-tuning PP-OCR models with MultiScaleSampler, make sure your inference preprocessing matches your training scales. Otherwise, you’ll see high validation accuracy but garbage results at inference.

---

This should save people from wasting days like I did. 🙃

---

Want me to polish this into a proper GitHub issue comment format (with Markdown headings + code blocks, short and punchy)? Or do you want it more like a blog-style post with more storytelling?