File size: 5,009 Bytes
b9952ac | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 | ---
license: apache-2.0
library_name: litert
pipeline_tag: object-detection
base_model: PaddlePaddle/PP-DocLayoutV3_safetensors
tags:
- litert
- tflite
- fp32
- document-layout-analysis
- reading-order
- paddleocr
---
# PP-DocLayoutV3 for LiteRT
FP32 LiteRT/TFLite export of PP-DocLayoutV3 from the official PaddlePaddle safetensors checkpoint. It predicts 25 document-layout categories, bounding boxes, region masks, and reading order. Host postprocessing converts these raw outputs into page coordinates and polygons. Text recognition is a separate step.
Source checkpoint: [PaddlePaddle/PP-DocLayoutV3_safetensors](https://huggingface.co/PaddlePaddle/PP-DocLayoutV3_safetensors), revision [`e4f489dc536556fc1be02b973ba06756e0d4a2ac`](https://huggingface.co/PaddlePaddle/PP-DocLayoutV3_safetensors/tree/e4f489dc536556fc1be02b973ba06756e0d4a2ac).
## Model file
[PP-DocLayoutV3-fp32.tflite](PP-DocLayoutV3-fp32.tflite) · FP32 · 133.97 MB. The file hash is in [SHA256SUMS](SHA256SUMS).
The TFLite signature is `main`. All input and output tensors are `float32`; shapes are fixed. Image/video decoding, preprocessing, and application postprocessing run on the host.
| Direction | Name | Shape | Meaning |
| --- | --- | --- | --- |
| Input | `pixel_values` | `[1, 3, 800, 800]` | RGB page in [0, 1], NCHW |
| Output | `class_logits` | `[1, 300, 25]` | 300 queries × 25 layout-class logits |
| Output | `boxes_cxcywh` | `[1, 300, 4]` | Normalized center-x, center-y, width, height |
| Output | `order_logits` | `[1, 300, 300]` | Pairwise reading-order logits for 300 queries |
| Output | `mask_logits` | `[1, 300, 200, 200]` | Per-query mask logits at 200 × 200 |
## Preprocessing and outputs
Convert the page to RGB and use the pinned upstream image processor: bicubic resize to **800 × 800**, rescale by `1/255`, and NCHW layout. Its normalization mean is `[0, 0, 0]` and standard deviation is `[1, 1, 1]`. The example uses the source processor for both preprocessing and postprocessing.
Class scores and masks are logits. Boxes use normalized `(center_x, center_y, width, height)` coordinates. Use the upstream postprocessor to filter predictions, produce polygons, rescale to the original page size, and recover reading order. Class names are in [labels.json](labels.json).
## Run on CPU
```bash
pip install ai-edge-litert huggingface_hub numpy pillow "transformers==5.21.0" torch torchvision opencv-python-headless
```
```python
import numpy as np
from huggingface_hub import hf_hub_download
from ai_edge_litert.interpreter import Interpreter
import json
import torch
from pathlib import Path
from PIL import Image
from types import SimpleNamespace
from transformers import AutoImageProcessor
processor = AutoImageProcessor.from_pretrained(
"PaddlePaddle/PP-DocLayoutV3_safetensors",
revision="e4f489dc536556fc1be02b973ba06756e0d4a2ac",
)
image = Image.open("page.jpg").convert("RGB")
pixel_values = processor(images=image, return_tensors="pt")["pixel_values"].numpy()
pixel_values = np.ascontiguousarray(pixel_values, dtype=np.float32)
model_path = hf_hub_download("litert-community/PP-DocLayoutV3", "PP-DocLayoutV3-fp32.tflite")
interpreter = Interpreter(model_path=model_path, num_threads=4)
interpreter.allocate_tensors()
run = interpreter.get_signature_runner("main")
raw = run(pixel_values=pixel_values)
outputs = SimpleNamespace(
logits=torch.from_numpy(raw["class_logits"]),
pred_boxes=torch.from_numpy(raw["boxes_cxcywh"]),
order_logits=torch.from_numpy(raw["order_logits"]),
out_masks=torch.from_numpy(raw["mask_logits"]),
)
result = processor.post_process_object_detection(
outputs, threshold=0.5, target_sizes=[(image.height, image.width)]
)[0]
labels_path = hf_hub_download("litert-community/PP-DocLayoutV3", "labels.json")
labels = json.loads(Path(labels_path).read_text())
for score, label, box, polygon, order in zip(
result["scores"], result["labels"], result["boxes"],
result["polygon_points"], result["order_seq"],
):
print(labels[str(label.item())], float(score), box.tolist(), polygon, int(order))
```
## Source and license
PP-DocLayoutV3 is developed by the PaddleOCR team. See the [PaddleOCR project](https://github.com/PaddlePaddle/PaddleOCR) and [RT-DocLayout paper](https://arxiv.org/abs/2606.23344). The example uses Transformers 5.21.0 for the host image processor; the neural network runs in LiteRT.
This FP32 conversion uses the original pretrained weights with a fixed-shape TFLite interface. License: [Apache 2.0](LICENSE).
## Citation
```bibtex
@misc{cui2026rtdoclayoutrealtimeendtoenddocument,
title={RT-DocLayout: Real-Time End-to-End Document Layout Analysis with Reading Order in the Wild},
author={Cheng Cui and Tingquan Gao and Xueqing Wang and Changda Zhou and Hongen Liu and Ting Sun and Yubo Zhang and Zelun Zhang and Jiaxuan Liu and Manhui Lin and Yue Zhang and Suyin Liang and Yiqing Xiang and Yi Liu},
year={2026},
eprint={2606.23344},
archivePrefix={arXiv},
primaryClass={cs.CV}
}
```
|