PaddleOCR 3.x CPU inference allocates ~43 GB RAM (OOM kill) with German/Latin model

[JoeRu]

Environment

• PaddleOCR version: 3.4.1
• PaddlePaddle version: 3.3.1
• Python: 3.12
• OS: Ubuntu 24.04 (Docker container)
• Device: CPU only (enable_mkldnn=False)

What happens

Calling PaddleOCR(lang='german', enable_mkldnn=False).predict(image_path) on a scanned document image causes the process to allocate ~43 GB of anonymous RSS and be killed by the Linux OOM killer.

Kernel log:

Out of memory: Killed process 132564 (uvicorn) total-vm:51828452kB, anon-rss:43528356kB, file-rss:1536kB

This happens on every real inference call. The process had successfully downloaded the model files (latin_PP-OCRv5_mobile_rec) and completed TIFF→PNG conversion before the OOM kill occurred during predict().

Reproduction

from PIL import Image
import tempfile, pathlib
from paddleocr import PaddleOCR

with tempfile.TemporaryDirectory() as d:
    p = pathlib.Path(d) / "test.png"
    Image.new("RGB", (800, 1000), (255, 255, 255)).save(str(p))
    ocr = PaddleOCR(lang="german", enable_mkldnn=False)
    result = ocr.predict(str(p))  # OOM kill here

Notes

• The same model instantiation without predict() does not cause the issue (memory stays reasonable until inference starts)
• enable_mkldnn=False was required because the default enable_mkldnn=True raised NotImplementedError: ConvertPirAttribute2RuntimeAttribute not support [pir::ArrayAttribute<pir::DoubleAttribute>] on this CPU
• PaddleOCR 2.x used ~1–2 GB for the same task; the ~43 GB usage in 3.x appears to be a regression
• Tested with both lang='german' and lang='en' — both trigger the OOM

Expected behaviour

Memory usage during CPU inference should be in the range of 1–4 GB, consistent with PaddleOCR 2.x behaviour.

[hoobnn]

I couldn't reproduce the issue. Please provide more detailed information.

[liuwake]

Provide information about the CPU and other hardware, as well as the release version of the host system and software information such as glic, which may assist in reproducing the bug.

[JoeRu]

Thanks for the quick response. Here is the detailed hardware and software information, plus an updated reproduction script that now pinpoints the trigger condition.

Hardware & Software

Field	Value
CPU	AMD EPYC Processor (with IBPB), 12 logical cores (virtualised / hypervisor)
CPU flags	fpu, sse2, avx, avx2, sha_ni — no AVX-512; enable_mkldnn=True not usable (raises NotImplementedError)
RAM	47 GiB total, 4 GiB swap
OS	Ubuntu 24.04.4 LTS (Noble)
Kernel	6.8.0-110-generic
glibc	Ubuntu GLIBC 2.39-0ubuntu8.7
Python	3.12.3 (CPython, GCC 13.3.0)
PaddlePaddle	3.3.1
PaddleOCR	3.4.1

The process runs inside an Ubuntu 24.04 Docker container on a bare-metal host (no GPU).

Root-cause narrowed: image size is the trigger

After further testing, the OOM is image-size dependent:

Image size	DPI equivalent	predict() result	Peak RSS
1240 × 1754 px	A4 @ 150 dpi	✅ completes in ~3 min	0.80 GiB
2480 × 3508 px	A4 @ 300 dpi	❌ OOM kill	~43 GiB (kernel log)

A 300 dpi A4 scan is the standard output of a typical flatbed scanner. So every real-world scan at full resolution triggers the kill.

The OOM does not occur with the blank 8 × 8 warmup image used during Docker build — models appear cached/compiled after that, but the larger inference path is only triggered at full resolution.

Updated reproduction script

The script below accepts --dpi 150 (safe, completes) or --dpi 300 (triggers OOM). It also monitors RSS in a background thread so the peak is captured even if the OOM killer fires before predict() returns.

"""
Reproduction for PaddleOCR #17955 — OOM on CPU inference at 300 dpi (A4)
Usage: python3 repro_oom.py [--dpi 150|300]
  --dpi 150  safe path  (~0.8 GiB, completes)
  --dpi 300  triggers OOM kill (~43 GiB RSS) — default
"""
import argparse, platform, subprocess, sys, threading, time
from pathlib import Path

def _run(cmd):
    try: return subprocess.check_output(cmd, shell=True, text=True, stderr=subprocess.DEVNULL).strip()
    except: return "n/a"

def print_sysinfo():
    print("=" * 60)
    print(f"Python     : {sys.version}")
    print(f"OS         : {_run('lsb_release -ds')} / {platform.release()}")
    print(f"glibc      : {_run('ldd --version | head -1')}")
    print(f"CPU        :{_run(\"grep 'model name' /proc/cpuinfo | head -1 | cut -d: -f2\")}")
    print(f"Cores      : {_run('nproc')}")
    mem_kb = _run("grep MemTotal /proc/meminfo | awk '{print $2}'")
    print(f"RAM        : {round(int(mem_kb)/1024/1024,1) if mem_kb.isdigit() else 'n/a'} GiB")
    import paddle;    print(f"PaddlePaddle: {paddle.__version__}")
    import paddleocr; print(f"PaddleOCR   : {paddleocr.__version__}")
    print("=" * 60)

class MemMonitor(threading.Thread):
    def __init__(self):
        super().__init__(daemon=True)
        self.peak_kb = 0
        self._quit = threading.Event()
    def run(self):
        while not self._quit.wait(0.5):
            try:
                for line in Path("/proc/self/status").read_text().splitlines():
                    if line.startswith("VmRSS:"):
                        self.peak_kb = max(self.peak_kb, int(line.split()[1])); break
            except: pass
    def stop(self):
        self._quit.set(); self.join(2); return self.peak_kb

DPI_SIZES = {150: (1240, 1754), 300: (2480, 3508)}

parser = argparse.ArgumentParser()
parser.add_argument("--dpi", type=int, choices=[150, 300], default=300)
args = parser.parse_args()
w, h = DPI_SIZES[args.dpi]

print_sysinfo()
print(f"\nImage: A4 @ {args.dpi} dpi = {w}x{h} px")
if args.dpi == 300:
    print("WARNING: expected to OOM-kill on systems with < 48 GiB RAM\n")

import tempfile
from PIL import Image, ImageDraw
from paddleocr import PaddleOCR

img = Image.new("RGB", (w, h), (255, 255, 255))
draw = ImageDraw.Draw(img)
block = ("Rechnung Nr. 2024-0042  Datum: 15. Januar 2024\n"
         "Absender: Musterfirma GmbH, Musterstraße 1, 12345 Musterstadt\n"
         "Pos  Beschreibung    Menge   Preis\n"
         "  1  Beratung          8 h   120,00 EUR\n"
         "Gesamt: 1.201,90 EUR   IBAN: DE12 3456 7890 1234 5678 90\n")
y = 60
while y < h - 100:
    draw.multiline_text((60, y), block, fill=(0, 0, 0), spacing=4); y += 120

with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as f:
    p = Path(f.name)
img.save(str(p)); del img, draw
print(f"Saved: {p}  ({p.stat().st_size//1024} kB)")

m = MemMonitor(); m.start()
try:
    ocr = PaddleOCR(lang="german", enable_mkldnn=False)
    print("Calling predict() ...")
    t = time.time()
    res = ocr.predict(str(p), use_textline_orientation=True)
    print(f"predict() done in {time.time()-t:.1f}s, {len(res[0].get('rec_texts',[]))} lines")
except Exception as e:
    print(f"Exception: {e}")
finally:
    print(f"Peak RSS: {m.stop():,} kB  ({m.stop()/1024/1024:.2f} GiB)")
    p.unlink(missing_ok=True)

Observed result at 300 dpi

Process killed by the OOM killer — no Python exception, kernel SIGKILL:

Out of memory: Killed process 132564 (uvicorn) total-vm:51828452kB, anon-rss:43528356kB, file-rss:1536kB

The monitor thread does not get to print peak RSS because the kill is instant.

Note on enable_mkldnn

The default enable_mkldnn=True is not viable on this CPU — it raises:

NotImplementedError: ConvertPirAttribute2RuntimeAttribute not support [pir::ArrayAttribute<pir::DoubleAttribute>]

So enable_mkldnn=False is required, ruling out oneDNN as a factor in the memory issue.