Technical Overview
en_PP‑OCRv5_mobile_rec is a lightweight English text‑line recognition model that belongs to the PP‑OCRv5 family released by the PaddleOCR team. It takes a cropped image of a single line of text (or a whole image when used inside the full OCR pipeline) and outputs the recognized string together with a confidence score. The model is specifically optimized for mobile‑friendly deployment, offering a good trade‑off between speed, memory footprint, and accuracy.
Key capabilities include:
- High‑precision English OCR with a line‑level accuracy of 85.3 % (character‑level strict scoring).
- Fast inference on both GPU and CPU, thanks to a compact MobileNet‑V3‑based backbone.
- Seamless integration with the PaddleOCR
TextRecognitionAPI and the fullpaddleocr ocrpipeline. - Support for batch inference, result visualisation, and JSON export.
Architecture highlights – The recogniser uses a MobileNet‑V3‑small backbone for feature extraction followed by a lightweight sequence‑model (CTC‑based) head that maps visual features to character probabilities. The model is quantisation‑aware and can be exported to ONNX or TensorRT for further speed gains on edge devices.
Intended use cases – Mobile applications, embedded systems, and low‑power edge servers that need to extract English text from scanned documents, receipts, signage, or natural‑scene images while keeping latency under a few hundred milliseconds per line.
Benchmark Performance
For OCR recognisers the most relevant benchmarks are line‑level accuracy (the percentage of whole text lines that are completely correct) and inference latency. The README reports an accuracy of 85.3 % for en_PP‑OCRv5_mobile_rec, measured with a strict “any character wrong = whole line wrong” rule, which reflects real‑world usability where a single typo can break downstream processing.
Compared with earlier PP‑OCRv5 models (e.g., the larger en_PP‑OCRv5_rec variant) the mobile version sacrifices roughly 2–3 % absolute accuracy in exchange for a dramatically smaller model size and faster CPU inference. This makes it competitive with other mobile‑focused OCR engines such as Tesseract‑LSTM or Google’s ML Kit Text Recognition, while retaining the flexibility of the PaddleOCR ecosystem.
Hardware Requirements
VRAM / GPU memory – The model file is under 30 MB, and a single‑image inference typically consumes ≈ 200 MB of GPU memory on a CUDA‑enabled device (CUDA 11.8 or 12.6). This fits comfortably on most consumer‑grade GPUs (e.g., RTX 3060, 2070) and on many integrated GPUs that expose a few hundred megabytes of VRAM.
Recommended GPU – Any NVIDIA GPU with CUDA 11.8+ (or the corresponding ROCm drivers for AMD) and at least 4 GB VRAM. For batch inference, a 6–8 GB GPU (e.g., RTX 3070) allows processing 8–16 lines simultaneously without memory pressure.
CPU – The model runs on CPU‑only installations (see the paddlepaddle==3.0.0 CPU wheel). Expect a latency of 150–300 ms per line on a modern 8‑core Xeon or Ryzen 7 processor. For real‑time mobile scenarios, a recent ARM‑based SoC (e.g., Snapdragon 8 Gen 2) with the Paddle Lite runtime can achieve sub‑100 ms latency.
Storage – The model checkpoint plus supporting files occupy roughly 30 MB on disk. Adding the PaddleOCR inference package (~ 150 MB) brings the total to under 200 MB, well within the capacity of any modern SSD or even high‑capacity SD cards.
Use Cases
Primary applications – Mobile document scanning, receipt and invoice processing, on‑device translation of street signs, and real‑time subtitle extraction from video frames.
Real‑world examples:
- Scanning business cards on a smartphone and instantly populating a contacts database.
- Reading product labels in a warehouse using a handheld scanner to trigger inventory updates.
- Extracting text from screenshots in a gaming overlay for automated cheat‑detection.
- Assisting visually impaired users by reading printed English text aloud via a wearable device.
Integration possibilities – The model can be called directly through the paddleocr CLI, the Python TextRecognition class, or exported to ONNX/TensorRT for use in C++, Java, or mobile SDKs (iOS/Android). It also plugs into the full PP‑OCRv5 pipeline, allowing you to combine detection, orientation correction, and recognition in a single command.
Training Details
The model was trained by the PaddleOCR team on a large‑scale English text‑line dataset that combines synthetic data (e.g., SynthText) and real‑world scene text collections (ICDAR, COCO‑Text). Training employed the CTC loss with an AdamW optimizer, a learning‑rate schedule that decays cosine‑wise, and mixed‑precision (FP16) to accelerate convergence.
Typical compute requirements:
- ~ 4 GPU‑hours on a single NVIDIA RTX 3090 (24 GB VRAM) for the final checkpoint.
- Batch size of 256 images (each resized to a maximum side length of 64 px for the mobile model).
The checkpoint is released in PaddlePaddle’s static graph format, but the model can be fine‑tuned on domain‑specific data using the same paddleocr training scripts. Users can replace the final classification layer to adapt to custom character sets (e.g., adding symbols or other languages) while retaining the pre‑trained backbone.
Licensing Information
The README lists the license as Apache‑2.0. Although the Hugging Face metadata shows “unknown”, the official PaddleOCR distribution is released under the permissive Apache 2.0 license, which grants:
- Free use for personal, academic, and commercial projects.
- The right to modify, distribute, and create derivative works.
- No royalty or fee requirements.
- Obligation to retain the original copyright notice and a copy of the license in redistributed versions.
Because Apache 2.0 is a permissive license, you can embed the model in proprietary software, host it as a SaaS offering, or ship it on hardware devices without needing to open‑source your own code. Just ensure you include the license file and give appropriate attribution to PaddlePaddle.