Need Help with Code Optimization

[rdhanur]

Bismillah, greeting everyone,

My name is Dhanur. I'm a geologist with a non-software engineering background, currently developing a PDF keyword extraction tool in Python using PaddleOCR 3.7 and with assistance from ChatGPT.

I previously had used Tesseract, but then decided to migrate using PaddleOCR. I've been working on this migration for several weeks. The application is seems functioning correctly and processes 537 PDF files, extracting keywords and other information into an Excel table.

However, the program is very slow. The probable bottleneck appears to be repeated predict() calls during OCR. My goal is to reduce the total processing time from hours to around 15 minutes without sacrificing OCR accuracy.

For reference, I'm running on:

• HP EliteBook 840 G11 Laptop
• Windows 11
• Intel Core Ultra 7 165 H (22 CPUs) ~1.4 GHz
• ~32GB RAM
• Python 3.x
• PaddleOCR 3.7

Here's below workflow illustration:

Current Workflow (click to expand)

main()
 │
 │  Find Input folder
 │  Find all PDFs (537)
 │  Create ProcessPoolExecutor
 │  Submit every PDF to workers
 ▼
process_file(PDF)
 │
 │  Main processing function
 ▼
fitz.open(PDF)
 │
 │  Open PDF file
 │
 🟡 Medium
 ▼
for every page
 │
 ▼
page.get_text()
 │
 │  Read searchable/native text
 │
 🟢 Fast
 ▼
Native text?
 │
 ├───────────────┐
 │               │
 │ YES           │ NO
 ▼               ▼
Use Text     page.get_pixmap()
                 │
                 │ Convert PDF page to image
                 │
                 🔴 Slow
                 ▼
        extract_text_paddle()
                 │
                 ▼
         get_ocr_engine()
                 │
                 │ Create or reuse PaddleOCR instance
                 │
                 🟡 Startup cost
                 ▼
      PaddleOCR.predict()
                 │
                 │ OCR inference
                 │
                 🔴🔴 Biggest bottleneck
                 ▼
 OCR text + confidence
                 │
                 ▼
 normalize_ocr_text()
                 │
                 🟢 Fast
                 ▼
find_match_and_snippet()
                 │
                 🟢 Fast
                 ▼
calculate_match_score()
                 │
                 🟢 Fast
                 ▼
extract_usd_values()
                 │
                 🟢 Fast
                 ▼
Build Result Dictionary
                 │
                 ▼
return
                 │
                 ▼
as_completed(futures)
                 │
                 │ Wait until one PDF finishes
                 │
                 🔴 Appears "frozen"
                 ▼
Write Excel
                 │
                 🟢 Fast
                 ▼
Finish

Based on the workflow above, what would you recommend to significantly speed up the processing of hundreds of PDFs with PaddleOCR 3.7 on CPU while maintaining OCR accuracy?

Any suggestions, best practices, or references to official documentation would be greatly appreciated.

Thank you for your time.

[Hannan-10]

A few CPU-specific changes should get you a big chunk of the way from hours down toward your ~15 min target, roughly in order of impact:

1. Switch to the mobile models — PP-OCRv5_mobile_det/_rec are built for CPU-only deployment vs. the GPU-oriented server variants:

from paddleocr import PaddleOCR
ocr = PaddleOCR(
text_detection_model_name="PP-OCRv5_mobile_det",
text_recognition_model_name="PP-OCRv5_mobile_rec",
)
2. Enable MKL-DNN + tune thread count — enable_mkldnn isn't on by default:

ocr = PaddleOCR(..., enable_mkldnn=True, cpu_threads=8) # match physical cores
3. Confirm extra pipeline stages are off — use_doc_orientation_classify, use_doc_unwarping, use_textline_orientation default to False; each one enabled is a full extra model pass per page.

4. Downscale before OCR — try rendering PDF pages at 150 DPI instead of 300; detection cost scales with pixel count.

5. Parallelize across PDFs, not within one process — a single predict() call won't saturate many cores even with cpu_threads cranked up. Use multiprocessing.Pool with each worker holding its own PaddleOCR(cpu_threads=1) instance, splitting your 537 files across ~6-8 workers. This is usually where the multi-hour → minutes jump actually comes from.

Combining #1 + #2 + #5 is what typically turns "hours for 537 PDFs" into "a few minutes."