paddlex 3.0.0rc1__py3-none-any.whl → 3.0.1__py3-none-any.whl

paddlex/inference/models/object_detection/processors.py

@@ -474,6 +474,8 @@ def restructured_boxes(
         ymin = max(0, ymin)
         xmax = min(w, xmax)
         ymax = min(h, ymax)
+        if xmax <= xmin or ymax <= ymin:
+            continue
         box_list.append(
             {
                 "cls_id": int(box[0]),
@@ -744,11 +746,34 @@ class DetPostProcess:
             )
 
         if layout_nms:
-            pass
-            ### Layout postprocess for NMS
             selected_indices = nms(boxes, iou_same=0.6, iou_diff=0.98)
             boxes = np.array(boxes[selected_indices])
 
+        filter_large_image = True
+        if filter_large_image and len(boxes) > 1 and boxes.shape[1] == 6:
+            if img_size[0] > img_size[1]:
+                area_thres = 0.82
+            else:
+                area_thres = 0.93
+            image_index = self.labels.index("image") if "image" in self.labels else None
+            img_area = img_size[0] * img_size[1]
+            filtered_boxes = []
+            for box in boxes:
+                label_index, score, xmin, ymin, xmax, ymax = box
+                if label_index == image_index:
+                    xmin = max(0, xmin)
+                    ymin = max(0, ymin)
+                    xmax = min(img_size[0], xmax)
+                    ymax = min(img_size[1], ymax)
+                    box_area = (xmax - xmin) * (ymax - ymin)
+                    if box_area <= area_thres * img_area:
+                        filtered_boxes.append(box)
+                else:
+                    filtered_boxes.append(box)
+            if len(filtered_boxes) == 0:
+                filtered_boxes = boxes
+            boxes = np.array(filtered_boxes)
+
         if layout_merge_bboxes_mode:
             formula_index = (
                 self.labels.index("formula") if "formula" in self.labels else None
@@ -798,7 +823,7 @@ class DetPostProcess:
                 boxes = boxes[keep_mask]
 
         if boxes.size == 0:
-            return np.array([])
+            return []
 
         if layout_unclip_ratio:
             if isinstance(layout_unclip_ratio, float):

paddlex/inference/models/object_detection/utils.py

@@ -65,4 +65,6 @@ STATIC_SHAPE_MODEL_LIST = [
     "PP-DocLayout-L",
     "PP-DocLayout-M",
     "PP-DocLayout-S",
+    "PP-DocLayout_plus-L",
+    "PP-DocBlockLayout",
 ]

paddlex/inference/models/table_structure_recognition/result.py

@@ -13,7 +13,6 @@
 # limitations under the License.
 
 import copy
-from pathlib import Path
 
 import numpy as np
 
@@ -28,15 +27,6 @@ if is_dep_available("opencv-contrib-python"):
 class TableRecResult(BaseCVResult):
     """SaveTableResults"""
 
-    def _get_input_fn(self):
-        fn = super()._get_input_fn()
-        if (page_idx := self["page_index"]) is not None:
-            fp = Path(fn)
-            stem, suffix = fp.stem, fp.suffix
-            return f"{stem}_{page_idx}{suffix}"
-        else:
-            return fn
-
     def _to_img(self):
         image = self["input_img"]
         bbox_res = self["bbox"]

paddlex/inference/models/text_detection/predictor.py

@@ -41,6 +41,7 @@ class TextDetPredictor(BasePredictor):
         box_thresh: Union[float, None] = None,
         unclip_ratio: Union[float, None] = None,
         input_shape=None,
+        max_side_limit: int = 4000,
         *args,
         **kwargs
     ):
@@ -52,6 +53,7 @@ class TextDetPredictor(BasePredictor):
         self.box_thresh = box_thresh
         self.unclip_ratio = unclip_ratio
         self.input_shape = input_shape
+        self.max_side_limit = max_side_limit
         self.pre_tfs, self.infer, self.post_op = self._build()
 
     def _build_batch_sampler(self):
@@ -85,6 +87,7 @@ class TextDetPredictor(BasePredictor):
         thresh: Union[float, None] = None,
         box_thresh: Union[float, None] = None,
         unclip_ratio: Union[float, None] = None,
+        max_side_limit: Union[int, None] = None,
     ):
 
         batch_raw_imgs = self.pre_tfs["Read"](imgs=batch_data.instances)
@@ -92,6 +95,9 @@ class TextDetPredictor(BasePredictor):
             imgs=batch_raw_imgs,
             limit_side_len=limit_side_len or self.limit_side_len,
             limit_type=limit_type or self.limit_type,
+            max_side_limit=(
+                max_side_limit if max_side_limit is not None else self.max_side_limit
+            ),
         )
         batch_imgs = self.pre_tfs["Normalize"](imgs=batch_imgs)
         batch_imgs = self.pre_tfs["ToCHW"](imgs=batch_imgs)
@@ -127,6 +133,8 @@ class TextDetPredictor(BasePredictor):
         # TODO: align to PaddleOCR
 
         if self.model_name in (
+            "PP-OCRv5_server_det",
+            "PP-OCRv5_mobile_det",
             "PP-OCRv4_server_det",
             "PP-OCRv4_mobile_det",
             "PP-OCRv3_server_det",

paddlex/inference/models/text_detection/processors.py

@@ -13,7 +13,6 @@
 # limitations under the License.
 
 import math
-import sys
 from typing import Union
 
 import numpy as np
@@ -33,8 +32,7 @@ if is_dep_available("pyclipper"):
 class DetResizeForTest:
     """DetResizeForTest"""
 
-    def __init__(self, input_shape=None, **kwargs):
-        super().__init__()
+    def __init__(self, input_shape=None, max_side_limit=4000, **kwargs):
         self.resize_type = 0
         self.keep_ratio = False
         if input_shape is not None:
@@ -55,22 +53,34 @@ class DetResizeForTest:
             self.limit_side_len = 736
             self.limit_type = "min"
 
+        self.max_side_limit = max_side_limit
+
     def __call__(
         self,
         imgs,
         limit_side_len: Union[int, None] = None,
         limit_type: Union[str, None] = None,
+        max_side_limit: Union[int, None] = None,
     ):
         """apply"""
+        max_side_limit = (
+            max_side_limit if max_side_limit is not None else self.max_side_limit
+        )
         resize_imgs, img_shapes = [], []
         for ori_img in imgs:
-            img, shape = self.resize(ori_img, limit_side_len, limit_type)
+            img, shape = self.resize(
+                ori_img, limit_side_len, limit_type, max_side_limit
+            )
             resize_imgs.append(img)
             img_shapes.append(shape)
         return resize_imgs, img_shapes
 
     def resize(
-        self, img, limit_side_len: Union[int, None], limit_type: Union[str, None]
+        self,
+        img,
+        limit_side_len: Union[int, None],
+        limit_type: Union[str, None],
+        max_side_limit: Union[int, None] = None,
     ):
         src_h, src_w, _ = img.shape
         if sum([src_h, src_w]) < 64:
@@ -79,7 +89,7 @@ class DetResizeForTest:
         if self.resize_type == 0:
             # img, shape = self.resize_image_type0(img)
             img, [ratio_h, ratio_w] = self.resize_image_type0(
-                img, limit_side_len, limit_type
+                img, limit_side_len, limit_type, max_side_limit
             )
         elif self.resize_type == 2:
             img, [ratio_h, ratio_w] = self.resize_image_type2(img)
@@ -105,6 +115,8 @@ class DetResizeForTest:
             resize_w = ori_w * resize_h / ori_h
             N = math.ceil(resize_w / 32)
             resize_w = N * 32
+        if resize_h == ori_h and resize_w == ori_w:
+            return img, [1.0, 1.0]
         ratio_h = float(resize_h) / ori_h
         ratio_w = float(resize_w) / ori_w
         img = cv2.resize(img, (int(resize_w), int(resize_h)))
@@ -112,7 +124,11 @@ class DetResizeForTest:
         return img, [ratio_h, ratio_w]
 
     def resize_image_type0(
-        self, img, limit_side_len: Union[int, None], limit_type: Union[str, None]
+        self,
+        img,
+        limit_side_len: Union[int, None],
+        limit_type: Union[str, None],
+        max_side_limit: Union[int, None] = None,
     ):
         """
         resize image to a size multiple of 32 which is required by the network
@@ -149,16 +165,28 @@ class DetResizeForTest:
         resize_h = int(h * ratio)
         resize_w = int(w * ratio)
 
+        if max(resize_h, resize_w) > max_side_limit:
+            logging.warning(
+                f"Resized image size ({resize_h}x{resize_w}) exceeds max_side_limit of {max_side_limit}. "
+                f"Resizing to fit within limit."
+            )
+            ratio = float(max_side_limit) / max(resize_h, resize_w)
+            resize_h, resize_w = int(resize_h * ratio), int(resize_w * ratio)
+
         resize_h = max(int(round(resize_h / 32) * 32), 32)
         resize_w = max(int(round(resize_w / 32) * 32), 32)
 
+        if resize_h == h and resize_w == w:
+            return img, [1.0, 1.0]
+
         try:
             if int(resize_w) <= 0 or int(resize_h) <= 0:
                 return None, (None, None)
             img = cv2.resize(img, (int(resize_w), int(resize_h)))
         except:
             logging.info(img.shape, resize_w, resize_h)
-            sys.exit(0)
+            raise
+
         ratio_h = resize_h / float(h)
         ratio_w = resize_w / float(w)
         return img, [ratio_h, ratio_w]
@@ -181,6 +209,10 @@ class DetResizeForTest:
         max_stride = 128
         resize_h = (resize_h + max_stride - 1) // max_stride * max_stride
         resize_w = (resize_w + max_stride - 1) // max_stride * max_stride
+
+        if resize_h == h and resize_w == w:
+            return img, [1.0, 1.0]
+
         img = cv2.resize(img, (int(resize_w), int(resize_h)))
         ratio_h = resize_h / float(h)
         ratio_w = resize_w / float(w)
@@ -191,6 +223,8 @@ class DetResizeForTest:
         """resize the image"""
         resize_c, resize_h, resize_w = self.input_shape  # (c, h, w)
         ori_h, ori_w = img.shape[:2]  # (h, w, c)
+        if resize_h == ori_h and resize_w == ori_w:
+            return img, [1.0, 1.0]
         ratio_h = float(resize_h) / ori_h
         ratio_w = float(resize_w) / ori_w
         img = cv2.resize(img, (int(resize_w), int(resize_h)))
@@ -200,7 +234,7 @@ class DetResizeForTest:
 @benchmark.timeit
 @class_requires_deps("opencv-contrib-python")
 class NormalizeImage:
-    """normalize image such as substract mean, divide std"""
+    """normalize image such as subtract mean, divide std"""
 
     def __init__(self, scale=None, mean=None, std=None, order="chw"):
         super().__init__()
@@ -253,7 +287,7 @@ class DBPostProcess:
         use_dilation=False,
         score_mode="fast",
         box_type="quad",
-        **kwargs
+        **kwargs,
     ):
         super().__init__()
         self.thresh = thresh

paddlex/inference/models/text_detection/result.py

@@ -13,7 +13,6 @@
 # limitations under the License.
 
 import copy
-from pathlib import Path
 
 import numpy as np
 
@@ -27,15 +26,6 @@ if is_dep_available("opencv-contrib-python"):
 @class_requires_deps("opencv-contrib-python")
 class TextDetResult(BaseCVResult):
 
-    def _get_input_fn(self):
-        fn = super()._get_input_fn()
-        if (page_idx := self["page_index"]) is not None:
-            fp = Path(fn)
-            stem, suffix = fp.stem, fp.suffix
-            return f"{stem}_{page_idx}{suffix}"
-        else:
-            return fn
-
     def _to_img(self):
         """draw rectangle"""
         boxes = self["dt_polys"]

paddlex/inference/pipelines/__init__.py

@@ -126,7 +126,8 @@ def create_pipeline(
         pp_option (Optional[PaddlePredictorOption], optional): The options for
             the PaddlePredictor. Defaults to None.
         use_hpip (Optional[bool], optional): Whether to use the high-performance
-            inference plugin (HPIP). Defaults to None.
+            inference plugin (HPIP). If set to None, the setting from the
+            configuration file or `config` will be used. Defaults to None.
         hpi_config (Optional[Union[Dict[str, Any], HPIConfig]], optional): The
             high-performance inference configuration dictionary.
             Defaults to None.
@@ -150,13 +151,16 @@ def create_pipeline(
                 pipeline,
                 config["pipeline_name"],
             )
+        config = config.copy()
     pipeline_name = config["pipeline_name"]
-    if device is None:
-        device = config.get("device", None)
     if use_hpip is None:
-        use_hpip = config.get("use_hpip", False)
+        use_hpip = config.pop("use_hpip", False)
+    else:
+        config.pop("use_hpip", None)
     if hpi_config is None:
-        hpi_config = config.get("hpi_config", None)
+        hpi_config = config.pop("hpi_config", None)
+    else:
+        config.pop("hpi_config", None)
 
     pipeline = BasePipeline.get(pipeline_name)(
         config=config,

paddlex/inference/pipelines/_parallel.py

@@ -0,0 +1,172 @@
+# Copyright (c) 2025 PaddlePaddle Authors. 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.
+
+import abc
+from concurrent.futures import ThreadPoolExecutor
+
+from ...utils import device as device_utils
+from ..common.batch_sampler import ImageBatchSampler
+from .base import BasePipeline
+
+
+class MultiDeviceSimpleInferenceExecutor(object):
+    def __init__(self, pipelines, batch_sampler, *, postprocess_result=None):
+        super().__init__()
+        self._pipelines = pipelines
+        self._batch_sampler = batch_sampler
+        self._postprocess_result = postprocess_result
+
+    @property
+    def pipelines(self):
+        return self._pipelines
+
+    def execute(
+        self,
+        input,
+        *args,
+        **kwargs,
+    ):
+        with ThreadPoolExecutor(max_workers=len(self._pipelines)) as pool:
+            input_batches = self._batch_sampler(input)
+            out_of_data = False
+            while not out_of_data:
+                input_future_pairs = []
+                for pipeline in self._pipelines:
+                    try:
+                        input_batch = next(input_batches)
+                    except StopIteration:
+                        out_of_data = True
+                        break
+                    input_instances = input_batch.instances
+                    future = pool.submit(
+                        lambda pipeline, input_instances, args, kwargs: list(
+                            pipeline.predict(input_instances, *args, **kwargs)
+                        ),
+                        pipeline,
+                        input_instances,
+                        args,
+                        kwargs,
+                    )
+                    input_future_pairs.append((input_batch, future))
+
+                # We synchronize here to keep things simple (no data
+                # prefetching, no queues, no dedicated workers), although
+                # it's less efficient.
+                for input_batch, future in input_future_pairs:
+                    result = future.result()
+                    for input_path, result_item in zip(input_batch.input_paths, result):
+                        result_item["input_path"] = input_path
+                    if self._postprocess_result:
+                        result = self._postprocess_result(result, input_batch)
+                    yield from result
+
+
+class AutoParallelSimpleInferencePipeline(BasePipeline):
+    def __init__(
+        self,
+        config,
+        *args,
+        **kwargs,
+    ):
+        super().__init__(*args, **kwargs)
+
+        self._multi_device_inference = False
+        if self.device is not None:
+            device_type, device_ids = device_utils.parse_device(self.device)
+            if device_ids is not None and len(device_ids) > 1:
+                self._multi_device_inference = True
+                self._pipelines = []
+                for device_id in device_ids:
+                    pipeline = self._create_internal_pipeline(
+                        config, device_utils.constr_device(device_type, [device_id])
+                    )
+                    self._pipelines.append(pipeline)
+                batch_size = self._get_batch_size(config)
+                batch_sampler = self._create_batch_sampler(batch_size)
+                self._executor = MultiDeviceSimpleInferenceExecutor(
+                    self._pipelines,
+                    batch_sampler,
+                    postprocess_result=self._postprocess_result,
+                )
+        if not self._multi_device_inference:
+            self._pipeline = self._create_internal_pipeline(config, self.device)
+
+    @property
+    def multi_device_inference(self):
+        return self._multi_device_inference
+
+    def __getattr__(self, name):
+        if self._multi_device_inference:
+            first_pipeline = self._executor.pipelines[0]
+            return getattr(first_pipeline, name)
+        else:
+            return getattr(self._pipeline, name)
+
+    def predict(
+        self,
+        input,
+        *args,
+        **kwargs,
+    ):
+        if self._multi_device_inference:
+            yield from self._executor.execute(
+                input,
+                *args,
+                **kwargs,
+            )
+        else:
+            yield from self._pipeline.predict(
+                input,
+                *args,
+                **kwargs,
+            )
+
+    @abc.abstractmethod
+    def _create_internal_pipeline(self, config, device):
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def _get_batch_size(self, config):
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def _create_batch_sampler(self, batch_size):
+        raise NotImplementedError
+
+    def _postprocess_result(self, result, input_batch):
+        return result
+
+
+class AutoParallelImageSimpleInferencePipeline(AutoParallelSimpleInferencePipeline):
+    @property
+    @abc.abstractmethod
+    def _pipeline_cls(self):
+        raise NotImplementedError
+
+    def _create_internal_pipeline(self, config, device):
+        return self._pipeline_cls(
+            config,
+            device=device,
+            pp_option=self.pp_option,
+            use_hpip=self.use_hpip,
+            hpi_config=self.hpi_config,
+        )
+
+    def _create_batch_sampler(self, batch_size):
+        return ImageBatchSampler(batch_size)
+
+    def _postprocess_result(self, result, input_batch):
+        for page_index, item in zip(input_batch.page_indexes, result):
+            item["page_index"] = page_index
+        return result

paddlex/inference/pipelines/anomaly_detection/pipeline.py

@@ -20,15 +20,13 @@ from ....utils.deps import pipeline_requires_extra
 from ...models.anomaly_detection.result import UadResult
 from ...utils.hpi import HPIConfig
 from ...utils.pp_option import PaddlePredictorOption
+from .._parallel import AutoParallelImageSimpleInferencePipeline
 from ..base import BasePipeline
 
 
-@pipeline_requires_extra("cv")
-class AnomalyDetectionPipeline(BasePipeline):
+class _AnomalyDetectionPipeline(BasePipeline):
     """Image AnomalyDetectionPipeline Pipeline"""
 
-    entities = "anomaly_detection"
-
     def __init__(
         self,
         config: Dict,
@@ -44,9 +42,9 @@ class AnomalyDetectionPipeline(BasePipeline):
             device (str, optional): Device to run the predictions on. Defaults to None.
             pp_option (PaddlePredictorOption, optional): PaddlePredictor options. Defaults to None.
             use_hpip (bool, optional): Whether to use the high-performance
-                inference plugin (HPIP). Defaults to False.
+                inference plugin (HPIP) by default. Defaults to False.
             hpi_config (Optional[Union[Dict[str, Any], HPIConfig]], optional):
-                The high-performance inference configuration dictionary.
+                The default high-performance inference configuration dictionary.
                 Defaults to None.
         """
 
@@ -70,3 +68,15 @@ class AnomalyDetectionPipeline(BasePipeline):
             UadResult: The predicted anomaly results.
         """
         yield from self.anomaly_detetion_model(input)
+
+
+@pipeline_requires_extra("cv")
+class AnomalyDetectionPipeline(AutoParallelImageSimpleInferencePipeline):
+    entities = "anomaly_detection"
+
+    @property
+    def _pipeline_cls(self):
+        return _AnomalyDetectionPipeline
+
+    def _get_batch_size(self, config):
+        return config["SubModules"]["AnomalyDetection"].get("batch_size", 1)

paddlex/inference/pipelines/attribute_recognition/pipeline.py

@@ -21,12 +21,13 @@ from ...common.batch_sampler import ImageBatchSampler
 from ...common.reader import ReadImage
 from ...utils.hpi import HPIConfig
 from ...utils.pp_option import PaddlePredictorOption
+from .._parallel import AutoParallelImageSimpleInferencePipeline
 from ..base import BasePipeline
 from ..components import CropByBoxes
 from .result import AttributeRecResult
 
 
-class AttributeRecPipeline(BasePipeline):
+class _AttributeRecPipeline(BasePipeline):
     """Attribute Rec Pipeline"""
 
     def __init__(
@@ -100,6 +101,15 @@ class AttributeRecPipeline(BasePipeline):
         return AttributeRecResult(single_img_res)
 
 
+class AttributeRecPipeline(AutoParallelImageSimpleInferencePipeline):
+    @property
+    def _pipeline_cls(self):
+        return _AttributeRecPipeline
+
+    def _get_batch_size(self, config):
+        return config["SubModules"]["Detection"]["batch_size"]
+
+
 @pipeline_requires_extra("cv")
 class PedestrianAttributeRecPipeline(AttributeRecPipeline):
     entities = "pedestrian_attribute_recognition"

paddlex/inference/pipelines/base.py

@@ -48,9 +48,9 @@ class BasePipeline(ABC, metaclass=AutoRegisterABCMetaClass):
             device (str, optional): The device to use for prediction. Defaults to None.
             pp_option (PaddlePredictorOption, optional): The options for PaddlePredictor. Defaults to None.
             use_hpip (bool, optional): Whether to use the high-performance
-                inference plugin (HPIP). Defaults to False.
+                inference plugin (HPIP) by default. Defaults to False.
             hpi_config (Optional[Union[Dict[str, Any], HPIConfig]], optional):
-                The high-performance inference configuration dictionary.
+                The default high-performance inference configuration dictionary.
                 Defaults to None.
         """
         super().__init__()
@@ -96,12 +96,20 @@ class BasePipeline(ABC, metaclass=AutoRegisterABCMetaClass):
 
         logging.info("Creating model: %s", (config["model_name"], model_dir))
 
+        # TODO(gaotingquan): support to specify pp_option by model in pipeline
+        if self.pp_option is not None:
+            pp_option = self.pp_option.copy()
+            pp_option.model_name = config["model_name"]
+            pp_option.run_mode = self.pp_option.run_mode
+        else:
+            pp_option = None
+
         model = create_predictor(
             model_name=config["model_name"],
             model_dir=model_dir,
             device=self.device,
             batch_size=config.get("batch_size", 1),
-            pp_option=self.pp_option,
+            pp_option=pp_option,
             use_hpip=use_hpip,
             hpi_config=hpi_config,
             **kwargs,
@@ -132,7 +140,9 @@ class BasePipeline(ABC, metaclass=AutoRegisterABCMetaClass):
         pipeline = create_pipeline(
             config=config,
             device=self.device,
-            pp_option=self.pp_option,
+            pp_option=(
+                self.pp_option.copy() if self.pp_option is not None else self.pp_option
+            ),
             use_hpip=use_hpip,
             hpi_config=hpi_config,
         )

paddlex/inference/pipelines/components/faisser.py

@@ -178,7 +178,7 @@ class FaissBuilder:
 
     @classmethod
     def _get_index_type(cls, metric_type, index_type, num=None):
-        # if IVF method, cal ivf number automaticlly
+        # if IVF method, cal ivf number automatically
         if index_type == "IVF":
             index_type = index_type + str(min(int(num // 8), 65536))
             if metric_type in cls.BINARY_METRIC_TYPE: