[Model] Add PP-DocLayoutV3 Model Support

docs/source/en/_toctree.yml

@@ -1193,6 +1193,8 @@
         title: Pix2Struct
       - local: model_doc/pixtral
         title: Pixtral
+      - local: model_doc/pp_doclayout_v3
+        title: PP-DocLayoutV3
       - local: model_doc/qwen2_5_omni
         title: Qwen2.5-Omni
       - local: model_doc/qwen2_5_vl

docs/source/en/model_doc/pp_doclayout_v3.md

@@ -0,0 +1,149 @@
+<!--Copyright 2026 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+*This model was released on 2026-01-29 and added to Hugging Face Transformers on 2026-01-29.*
+
+# PP-DocLayoutV3
+
+<div class="flex flex-wrap space-x-1">
+<img alt="PyTorch" src="https://img.shields.io/badge/PyTorch-DE3412?style=flat&logo=pytorch&logoColor=white">
+</div>
+
+## Overview
+
+**PP-DocLayoutV3** is a unified and high-efficiency model designed for comprehensive layout analysis. It addresses the challenges of complex physical distortions—such as skewing, curving, and adverse lighting—by integrating instance segmentation and reading order prediction into a single, end-to-end framework.
+
+## Model Architecture
+
+PP-DocLayoutV3 evolves from a traditional detection-based approach to a robust instance segmentation architecture built upon the RT-DETR framework. Instead of simple bounding boxes, it utilizes a mask-based detection head to predict pixel-accurate segments for layout elements. 
+
+Unlike its predecessor, PP-DocLayoutV3 eliminates decoupled stages by embedding a Global Pointer Mechanism directly within the Transformer decoder layers. This allows the model to concurrently output classification labels, precise masks, and logical reading orders in a single forward pass, significantly reducing latency while enhancing parsing precision on complex document layouts.
+
+## Usage
+
+### Single input inference
+
+The example below demonstrates how to generate text with PP-DocLayoutV3 using [`Pipeline`] or the [`AutoModel`].
+
+<hfoptions id="usage">
+<hfoption id="Pipeline">
+
+```py
+import requests
+from PIL import Image
+from transformers import pipeline
+
+image = Image.open(requests.get("https://paddle-model-ecology.bj.bcebos.com/paddlex/imgs/demo_image/layout_demo.jpg", stream=True).raw)
+layout_detector = pipeline("object-detection", model="PaddlePaddle/PP-DocLayoutV3_safetensors")
+results = layout_detector(image)
+for idx, res in enumerate(results):
+    print(f"Order {idx + 1}: {res}")
+```
+
+</hfoption>
+
+<hfoption id="AutoModel">
+
+```py
+import requests
+from PIL import Image
+from transformers import AutoImageProcessor, AutoModelForObjectDetection
+
+model_path = "PaddlePaddle/PP-DocLayoutV3_safetensors"
+model = AutoModelForObjectDetection.from_pretrained(model_path)
+image_processor = AutoImageProcessor.from_pretrained(model_path)
+
+image = Image.open(requests.get("https://paddle-model-ecology.bj.bcebos.com/paddlex/imgs/demo_image/layout_demo.jpg", stream=True).raw)
+inputs = image_processor(images=image, return_tensors="pt")
+
+outputs = model(**inputs)
+results = image_processor.post_process_object_detection(outputs, target_sizes=[image.size[::-1]])
+for result in results:
+    for idx, (score, label_id, box, polygon_points) in enumerate(zip(result["scores"], result["labels"], result["boxes"], result["polygon_points"])):
+        score, label = score.item(), label_id.item()
+        box = [round(i, 2) for i in box.tolist()]
+        print(f"Order {idx + 1}: {model.config.id2label[label]}, score: {score:.2f}, box: {box}, polygon_points: {polygon_points}")
+```
+
+</hfoption>
+</hfoptions>
+
+### Batched inference
+
+PP-DocLayoutV3 also supports batched inference. Here is how you can do it with PP-DocLayoutV3 using [`Pipeline`] or the [`AutoModel`]:
+
+<hfoptions id="usage">
+<hfoption id="Pipeline">
+
+```py
+import requests
+from PIL import Image
+from transformers import pipeline
+
+image = Image.open(requests.get("https://paddle-model-ecology.bj.bcebos.com/paddlex/imgs/demo_image/layout_demo.jpg", stream=True).raw)
+layout_detector = pipeline("object-detection", model="PaddlePaddle/PP-DocLayoutV3_safetensors")
+results = layout_detector([image, image])
+for result in results:
+    print("result:")
+    for idx, res in enumerate(result):
+        print(f"Order {idx + 1}: {res}")
+```
+
+</hfoption>
+
+<hfoption id="AutoModel">
+
+```py
+import requests
+from PIL import Image
+from transformers import AutoImageProcessor, AutoModelForObjectDetection
+
+model_path = "PaddlePaddle/PP-DocLayoutV3_safetensors"
+model = AutoModelForObjectDetection.from_pretrained(model_path)
+image_processor = AutoImageProcessor.from_pretrained(model_path)
+
+image = Image.open(requests.get("https://paddle-model-ecology.bj.bcebos.com/paddlex/imgs/demo_image/layout_demo.jpg", stream=True).raw)
+inputs = image_processor(images=[image, image], return_tensors="pt")
+target_sizes = [image.size[::-1], image.size[::-1]]
+
+outputs = model(**inputs)
+results = image_processor.post_process_object_detection(outputs, target_sizes=target_sizes)
+for result in results:
+    print("result:")
+    for idx, (score, label_id, box, polygon_points) in enumerate(zip(result["scores"], result["labels"], result["boxes"], result["polygon_points"])):
+        score, label = score.item(), label_id.item()
+        box = [round(i, 2) for i in box.tolist()]
+        print(f"Order {idx + 1}: {model.config.id2label[label]}, score: {score:.2f}, box: {box}, polygon_points: {polygon_points}")
+```
+
+</hfoption>
+</hfoptions>
+
+## PPDocLayoutV3ForObjectDetection
+
+[[autodoc]] PPDocLayoutV3ForObjectDetection
+    - forward
+
+## PPDocLayoutV3Model
+
+[[autodoc]] PPDocLayoutV3Model
+
+## PPDocLayoutV3Config
+
+[[autodoc]] PPDocLayoutV3Config
+
+## PPDocLayoutV3ImageProcessorFast
+
+[[autodoc]] PPDocLayoutV3ImageProcessorFast

src/transformers/models/__init__.py

@@ -306,6 +306,7 @@
     from .plbart import *
     from .poolformer import *
     from .pop2piano import *
+    from .pp_doclayout_v3 import *
     from .prompt_depth_anything import *
     from .prophetnet import *
     from .pvt import *

src/transformers/models/auto/configuration_auto.py

@@ -342,6 +342,7 @@
         ("plbart", "PLBartConfig"),
         ("poolformer", "PoolFormerConfig"),
         ("pop2piano", "Pop2PianoConfig"),
+        ("pp_doclayout_v3", "PPDocLayoutV3Config"),
         ("prompt_depth_anything", "PromptDepthAnythingConfig"),
         ("prophetnet", "ProphetNetConfig"),
         ("pvt", "PvtConfig"),
@@ -824,6 +825,7 @@
         ("plbart", "PLBart"),
         ("poolformer", "PoolFormer"),
         ("pop2piano", "Pop2Piano"),
+        ("pp_doclayout_v3", "PPDocLayoutV3"),
         ("prompt_depth_anything", "PromptDepthAnything"),
         ("prophetnet", "ProphetNet"),
         ("pvt", "PVT"),

src/transformers/models/auto/image_processing_auto.py

@@ -169,6 +169,7 @@
             ("pixio", ("BitImageProcessor", "BitImageProcessorFast")),
             ("pixtral", ("PixtralImageProcessor", "PixtralImageProcessorFast")),
             ("poolformer", ("PoolFormerImageProcessor", "PoolFormerImageProcessorFast")),
+            ("pp_doclayout_v3", (None, "PPDocLayoutV3ImageProcessorFast")),
             ("prompt_depth_anything", ("PromptDepthAnythingImageProcessor", "PromptDepthAnythingImageProcessorFast")),
             ("pvt", ("PvtImageProcessor", "PvtImageProcessorFast")),
             ("pvt_v2", ("PvtImageProcessor", "PvtImageProcessorFast")),

src/transformers/models/auto/modeling_auto.py

@@ -336,6 +336,7 @@ class _BaseModelWithGenerate(PreTrainedModel, GenerationMixin):
         ("pixtral", "PixtralVisionModel"),
         ("plbart", "PLBartModel"),
         ("poolformer", "PoolFormerModel"),
+        ("pp_doclayout_v3", "PPDocLayoutV3Model"),
         ("prophetnet", "ProphetNetModel"),
         ("pvt", "PvtModel"),
         ("pvt_v2", "PvtV2Model"),
@@ -1036,6 +1037,7 @@ class _BaseModelWithGenerate(PreTrainedModel, GenerationMixin):
         ("deformable_detr", "DeformableDetrForObjectDetection"),
         ("detr", "DetrForObjectDetection"),
         ("lw_detr", "LwDetrForObjectDetection"),
+        ("pp_doclayout_v3", "PPDocLayoutV3ForObjectDetection"),
         ("rt_detr", "RTDetrForObjectDetection"),
         ("rt_detr_v2", "RTDetrV2ForObjectDetection"),
         ("table-transformer", "TableTransformerForObjectDetection"),

src/transformers/models/pp_doclayout_v3/__init__.py

@@ -0,0 +1,30 @@
+# Copyright 2026 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+from typing import TYPE_CHECKING
+
+from ...utils import _LazyModule
+from ...utils.import_utils import define_import_structure
+
+
+if TYPE_CHECKING:
+    from .configuration_pp_doclayout_v3 import *
+    from .image_processing_pp_doclayout_v3_fast import *
+    from .modeling_pp_doclayout_v3 import *
+else:
+    import sys
+
+    _file = globals()["__file__"]
+    sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)