Download README.md from fastforks/ppocrv5: direct link, hf CLI and curl.
- Browser
- Download file 7.89 kB
-
https://huggingface.co/fastforks/ppocrv5/resolve/main/README.md
- Command line
-
hf download hf://fastforks/ppocrv5/README.md
-
curl -L -o README.md https://huggingface.co/fastforks/ppocrv5/resolve/main/README.md
library_name: fastforks
pipeline_tag: image-to-text
license: apache-2.0
tags:
- ocr
- text-recognition
- text-detection
- cuda
- pytorch
- fastforks
- fastforks-card
base_model:
- PaddlePaddle/PP-OCRv5_mobile_det
- PaddlePaddle/PP-OCRv5_mobile_rec
- PaddlePaddle/PP-OCRv5_server_det
- PaddlePaddle/PP-OCRv5_server_rec
PP-OCRv5 (server / mobile) (fastforks)
PP-OCRv5 (PaddleOCR 3, Baidu 2025): a DB text detector (PP-HGNetV2 + LKPAN for server, PP-LCNetV3 + RSE-FPN for mobile) finds text lines of any orientation as quads; each line is cut out with a perspective warp and read by a CTC recogniser (PP-HGNetV2 / PP-LCNetV3 with an SVTR neck) over 18 383 characters (simplified and traditional Chinese, English, Japanese, pinyin). Inference as PaddleX's OCR pipeline without the document unwarping and the text-line orientation classifier. The portable module() is the detector with its normalisation.
This repo is the model card only: it holds no weights. fastforks downloads the authors' weights from the links below and checks them against the SHA-256 in the model card. Code: https://github.com/kleinicke/fastforks. Kernels for the kernels backend: https://huggingface.co/fastforks/kernels. Original code: https://github.com/PaddlePaddle/PaddleOCR at dab3fe353790.
Author weight repos: https://huggingface.co/PaddlePaddle/PP-OCRv5_mobile_det, https://huggingface.co/PaddlePaddle/PP-OCRv5_mobile_rec, https://huggingface.co/PaddlePaddle/PP-OCRv5_server_det, https://huggingface.co/PaddlePaddle/PP-OCRv5_server_rec.
Task: ocr. Tier: experimental. Outputs: boxes, texts, scores. Backends: portable.
Input: one RGB image. Output: the text lines in reading order: a quad [N, 4, 2] per line, its text and a confidence [N] (text detector + recogniser; recognisers alone read the whole image as one line).
Variants
Weights are the authors' files (not hosted here). SHA-256 shortened to 12 hex digits; the full hashes are in card.toml.
| variant | weights (author link) | SHA-256 | weights licence | commercial use |
|---|---|---|---|---|
ppocrv5-mobile@1 |
PP-OCRv5_mobile_det/inference.json PP-OCRv5_mobile_det/inference.pdiparams PP-OCRv5_mobile_rec/inference.json PP-OCRv5_mobile_rec/inference.pdiparams PP-OCRv5_mobile_rec/config.json |
05feef1acb00afa1820cb16c24587345250c2460da9087596df1587ae056 |
Apache-2.0 | yes |
ppocrv5-server@1 |
PP-OCRv5_server_det/inference.json PP-OCRv5_server_det/inference.pdiparams PP-OCRv5_server_rec/inference.json PP-OCRv5_server_rec/inference.pdiparams PP-OCRv5_server_rec/config.json |
af5876933d88183146fe9d998e6e12e5d42563853f062a5f6a780e213d7a |
Apache-2.0 | yes |
Licence
Original-code strings, recorded as they are (research-use package; check them before any other use). Code: Apache-2.0. Licence files: LICENSE.
Training data: The PP-OCRv5 technical report describes public and synthetic text data plus Baidu's own data; the exact sets are not listed..
Licence evidence: https://github.com/PaddlePaddle/PaddleOCR/blob/dab3fe35379033fdcb2d0e9572fac0b36c9a9ebf/LICENSE ; https://huggingface.co/PaddlePaddle/PP-OCRv5_server_det
Input size
any H x W >= 32, padded to a multiple of 32
Tested up to (portable, fp16, RTX 5060 Ti 16 GB): ppocrv5-mobile 3000x4000 (1.4 GiB peak allocated, 2.3 reserved); ppocrv5-server 3000x4000 (7.1 GiB peak allocated, 9.8 reserved)
Speed and memory
Ocr, synthetic
| model | input | time (ms): original fp32 | original | portable | peak memory (MiB, allocated / reserved): original | portable |
|---|---|---|---|---|---|---|
ppocrv5-mobile |
1080x1920 | 619 | 418 | 153 | 393 / 1005 | 289 / 448 |
ppocrv5-server |
1080x1920 | β | 762 (fp32) | 277 | 2355 / 2901 | 1357 / 1452 |
Startup and first call
| model | load (s): original | portable | kernels | first call (s): original | portable | kernels |
|---|---|---|---|---|---|---|
ppocrv5-mobile |
1.51 | 0.27 | β | 1.82 | 2.82 | β |
ppocrv5-server |
2.07 | 0.56 | β | 2.03 | 1.87 | β |
torch.compile and TensorRT
| model | input | time: portable | compile | TensorRT fp16 | kernels | preparation: compile (cold first call) | ONNX + engine build | peak MiB (alloc / reserved): portable | compile | kernels | TensorRT (engine + torch) |
|---|---|---|---|---|---|---|---|---|---|---|---|
ppocrv5-mobile |
1080x1920 | 153 ms | 115 ms | 2.68 ms | β | 75.0 s | 156 s | 289 / 448 | 292 / 448 | β | 241 / 268 |
ppocrv5-server |
1080x1920 | 277 ms | 277 ms | 25.1 ms | β | 105 s | 40.6 s | 1357 / 1452 | 958 / 1132 | β | 1131 / 1146 |
Fixed-size cells: time (ms) / peak allocated / peak reserved memory (MiB).
Hardware, protocol and caveats: benchmarks (RTX 5060 Ti 16 GB, sm_120). Original = the original code named above at the precision of portable (fp16, or (fp32) where fp16 is unsupported or not finite); original fp32 = its default fp32 run. Peak memory is the torch allocator's.
Accuracy
Parity with the original code
Every variant is checked against reference outputs of the original code at its pinned commit. CPU, float32: max |diff| <= 0.001 vs the original. GPU, float16 (the default), portable and kernels: mean |diff| <= 0.5 and p99 <= 1.5 (absolute error of the output boxes).
Limitations
- No document orientation / unwarping and no text-line orientation classifier (upside-down lines are read as they are).
- The DB post-processing runs on the CPU (OpenCV-exact geometry); hole contours of the binary map are not boxed (upstream boxes them too; they rarely pass
box_threshold).
Usage
from fastforks import ocr
model = ocr.load("ppocrv5-mobile") # mode="auto": the preferred backend from recorded measurements
result = model("receipt.jpg")
result.texts # the text lines in reading order
result.boxes, result.scores # [N, 4, 2] quads in input pixels, [N] confidences
result.backend # what ran, e.g. Backend(mode='portable', device='cuda:0', dtype='float16')
Install with pip install fastforks (see https://github.com/kleinicke/fastforks). Other variants: ppocrv5-mobile, ppocrv5-server.
Kernels backend
No kernels backend: cuDNN convolutions are the networks; the time outside them is the per-line crop / resize and the CPU box geometry.