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

paddlex/inference/pipelines/image_multilabel_classification/pipeline.py

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# Copyright (c) 2024 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.
@@ -12,27 +12,28 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any, Dict, Optional, Union, List
+from typing import Any, Dict, List, Optional, Union
+
 import numpy as np
-from ...common.reader import ReadImage
-from ...common.batch_sampler import ImageBatchSampler
-from ...utils.pp_option import PaddlePredictorOption
-from ..base import BasePipeline
 
+from ....utils.deps import pipeline_requires_extra
 from ...models.image_multilabel_classification.result import MLClassResult
+from ...utils.hpi import HPIConfig
+from ...utils.pp_option import PaddlePredictorOption
+from .._parallel import AutoParallelImageSimpleInferencePipeline
+from ..base import BasePipeline
 
 
-class ImageMultiLabelClassificationPipeline(BasePipeline):
+class _ImageMultiLabelClassificationPipeline(BasePipeline):
     """Image Multi Label Classification Pipeline"""
 
-    entities = "image_multilabel_classification"
-
     def __init__(
         self,
         config: Dict,
         device: str = None,
         pp_option: PaddlePredictorOption = None,
         use_hpip: bool = False,
+        hpi_config: Optional[Union[Dict[str, Any], HPIConfig]] = None,
     ) -> None:
         """
         Initializes the class with given configurations and options.
@@ -41,9 +42,15 @@ class ImageMultiLabelClassificationPipeline(BasePipeline):
             config (Dict): Configuration dictionary containing model and other parameters.
             device (str): The device to run the prediction on. Default is None.
             pp_option (PaddlePredictorOption): Options for PaddlePaddle predictor. Default is None.
-            use_hpip (bool): Whether to use high-performance inference (hpip) for prediction. Defaults to False.
+            use_hpip (Optional[bool], optional): Whether to use the
+                high-performance inference plugin (HPIP) by default. Defaults to None.
+            hpi_config (Optional[Union[Dict[str, Any], HPIConfig]], optional):
+                The high-performance inference configuration dictionary.
+                Defaults to None.
         """
-        super().__init__(device=device, pp_option=pp_option, use_hpip=use_hpip)
+        super().__init__(
+            device=device, pp_option=pp_option, use_hpip=use_hpip, hpi_config=hpi_config
+        )
 
         self.threshold = config["SubModules"]["ImageMultiLabelClassification"].get(
             "threshold", None
@@ -54,7 +61,7 @@ class ImageMultiLabelClassificationPipeline(BasePipeline):
         self.image_multilabel_classification_model = self.create_model(
             image_multilabel_classification_model_config
         )
-        batch_size = image_multilabel_classification_model_config["batch_size"]
+        image_multilabel_classification_model_config["batch_size"]
 
     def predict(
         self,
@@ -76,3 +83,15 @@ class ImageMultiLabelClassificationPipeline(BasePipeline):
             input=input,
             threshold=self.threshold if threshold is None else threshold,
         )
+
+
+@pipeline_requires_extra("cv")
+class ImageMultiLabelClassificationPipeline(AutoParallelImageSimpleInferencePipeline):
+    entities = "image_multilabel_classification"
+
+    @property
+    def _pipeline_cls(self):
+        return _ImageMultiLabelClassificationPipeline
+
+    def _get_batch_size(self, config):
+        return config["SubModules"]["ImageMultiLabelClassification"]["batch_size"]

paddlex/inference/pipelines/instance_segmentation/__init__.py

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# Copyright (c) 2024 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.

paddlex/inference/pipelines/instance_segmentation/pipeline.py

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# Copyright (c) 2024 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.
@@ -12,25 +12,28 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any, Dict, Optional, Union, List
+from typing import Any, Dict, List, Optional, Union
+
 import numpy as np
-from ...utils.pp_option import PaddlePredictorOption
-from ..base import BasePipeline
 
+from ....utils.deps import pipeline_requires_extra
 from ...models.instance_segmentation.result import InstanceSegResult
+from ...utils.hpi import HPIConfig
+from ...utils.pp_option import PaddlePredictorOption
+from .._parallel import AutoParallelImageSimpleInferencePipeline
+from ..base import BasePipeline
 
 
-class InstanceSegmentationPipeline(BasePipeline):
+class _InstanceSegmentationPipeline(BasePipeline):
     """Instance Segmentation Pipeline"""
 
-    entities = "instance_segmentation"
-
     def __init__(
         self,
         config: Dict,
         device: str = None,
         pp_option: PaddlePredictorOption = None,
         use_hpip: bool = False,
+        hpi_config: Optional[Union[Dict[str, Any], HPIConfig]] = None,
     ) -> None:
         """
         Initializes the class with given configurations and options.
@@ -39,9 +42,15 @@ class InstanceSegmentationPipeline(BasePipeline):
             config (Dict): Configuration dictionary containing model and other parameters.
             device (str): The device to run the prediction on. Default is None.
             pp_option (PaddlePredictorOption): Options for PaddlePaddle predictor. Default is None.
-            use_hpip (bool): Whether to use high-performance inference (hpip) for prediction. Defaults to False.
+            use_hpip (bool, optional): Whether to use the high-performance
+                inference plugin (HPIP) by default. Defaults to False.
+            hpi_config (Optional[Union[Dict[str, Any], HPIConfig]], optional):
+                The default high-performance inference configuration dictionary.
+                Defaults to None.
         """
-        super().__init__(device=device, pp_option=pp_option, use_hpip=use_hpip)
+        super().__init__(
+            device=device, pp_option=pp_option, use_hpip=use_hpip, hpi_config=hpi_config
+        )
 
         instance_segmentation_model_config = config["SubModules"][
             "InstanceSegmentation"
@@ -68,3 +77,15 @@ class InstanceSegmentationPipeline(BasePipeline):
             InstanceSegResult: The predicted instance segmentation results.
         """
         yield from self.instance_segmentation_model(input, threshold=threshold)
+
+
+@pipeline_requires_extra("cv")
+class InstanceSegmentationPipeline(AutoParallelImageSimpleInferencePipeline):
+    entities = "instance_segmentation"
+
+    @property
+    def _pipeline_cls(self):
+        return _InstanceSegmentationPipeline
+
+    def _get_batch_size(self, config):
+        return config["SubModules"]["InstanceSegmentation"].get("batch_size", 1)

paddlex/inference/pipelines/keypoint_detection/__init__.py

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# Copyright (c) 2024 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.

paddlex/inference/pipelines/keypoint_detection/pipeline.py

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# Copyright (c) 2024 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.
@@ -12,27 +12,30 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any, Dict, Optional, Union, Tuple, List
+from typing import Any, Dict, List, Optional, Tuple, Union
+
 import numpy as np
-from ...utils.pp_option import PaddlePredictorOption
-from ..base import BasePipeline
 
+from ....utils.deps import pipeline_requires_extra
 from ...models.keypoint_detection.result import KptResult
+from ...utils.hpi import HPIConfig
+from ...utils.pp_option import PaddlePredictorOption
+from .._parallel import AutoParallelImageSimpleInferencePipeline
+from ..base import BasePipeline
 
 Number = Union[int, float]
 
 
-class KeypointDetectionPipeline(BasePipeline):
+class _KeypointDetectionPipeline(BasePipeline):
     """Keypoint Detection pipeline"""
 
-    entities = "human_keypoint_detection"
-
     def __init__(
         self,
         config: Dict,
         device: str = None,
         pp_option: PaddlePredictorOption = None,
         use_hpip: bool = False,
+        hpi_config: Optional[Union[Dict[str, Any], HPIConfig]] = None,
     ) -> None:
         """
         Initializes the class with given configurations and options.
@@ -41,9 +44,15 @@ class KeypointDetectionPipeline(BasePipeline):
             config (Dict): Configuration dictionary containing model and other parameters.
             device (str): The device to run the prediction on. Default is None.
             pp_option (PaddlePredictorOption): Options for PaddlePaddle predictor. Default is None.
-            use_hpip (bool): Whether to use high-performance inference (hpip) for prediction. Defaults to False.
+            use_hpip (bool, optional): Whether to use the high-performance
+                inference plugin (HPIP) by default. Defaults to False.
+            hpi_config (Optional[Union[Dict[str, Any], HPIConfig]], optional):
+                The default high-performance inference configuration dictionary.
+                Defaults to None.
         """
-        super().__init__(device=device, pp_option=pp_option, use_hpip=use_hpip)
+        super().__init__(
+            device=device, pp_option=pp_option, use_hpip=use_hpip, hpi_config=hpi_config
+        )
 
         # create object detection model
         model_cfg = config["SubModules"]["ObjectDetection"]
@@ -135,3 +144,15 @@ class KeypointDetectionPipeline(BasePipeline):
                     }
                 )
             yield KptResult(single_img_res)
+
+
+@pipeline_requires_extra("cv")
+class KeypointDetectionPipeline(AutoParallelImageSimpleInferencePipeline):
+    entities = "human_keypoint_detection"
+
+    @property
+    def _pipeline_cls(self):
+        return _KeypointDetectionPipeline
+
+    def _get_batch_size(self, config):
+        return config["SubModules"]["ObjectDetection"].get("batch_size", 1)

paddlex/inference/pipelines/layout_parsing/__init__.py

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# Copyright (c) 2024 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.

paddlex/inference/pipelines/layout_parsing/pipeline.py

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# Copyright (c) 2024 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.
@@ -12,32 +12,35 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Dict, Optional, Union, List, Tuple
+from typing import Any, Dict, List, Optional, Tuple, Union
+
 import numpy as np
-from ..base import BasePipeline
-from .utils import get_sub_regions_ocr_res, sorted_layout_boxes
-from ..components import CropByBoxes
-from .result import LayoutParsingResult
+
 from ....utils import logging
-from ...utils.pp_option import PaddlePredictorOption
-from ...common.reader import ReadImage
+from ....utils.deps import pipeline_requires_extra
 from ...common.batch_sampler import ImageBatchSampler
-from ..ocr.result import OCRResult
-
+from ...common.reader import ReadImage
 from ...models.object_detection.result import DetResult
+from ...utils.hpi import HPIConfig
+from ...utils.pp_option import PaddlePredictorOption
+from .._parallel import AutoParallelImageSimpleInferencePipeline
+from ..base import BasePipeline
+from ..components import CropByBoxes
+from ..ocr.result import OCRResult
+from .result import LayoutParsingResult
+from .utils import get_sub_regions_ocr_res, sorted_layout_boxes
 
 
-class LayoutParsingPipeline(BasePipeline):
+class _LayoutParsingPipeline(BasePipeline):
     """Layout Parsing Pipeline"""
 
-    entities = ["layout_parsing"]
-
     def __init__(
         self,
         config: Dict,
         device: str = None,
         pp_option: PaddlePredictorOption = None,
         use_hpip: bool = False,
+        hpi_config: Optional[Union[Dict[str, Any], HPIConfig]] = None,
     ) -> None:
         """Initializes the layout parsing pipeline.
 
@@ -45,10 +48,16 @@ class LayoutParsingPipeline(BasePipeline):
             config (Dict): Configuration dictionary containing various settings.
             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 high-performance inference (hpip) for prediction. Defaults to False.
+            use_hpip (bool, optional): Whether to use the high-performance
+                inference plugin (HPIP) by default. Defaults to False.
+            hpi_config (Optional[Union[Dict[str, Any], HPIConfig]], optional):
+                The default high-performance inference configuration dictionary.
+                Defaults to None.
         """
 
-        super().__init__(device=device, pp_option=pp_option, use_hpip=use_hpip)
+        super().__init__(
+            device=device, pp_option=pp_option, use_hpip=use_hpip, hpi_config=hpi_config
+        )
 
         self.inintial_predictor(config)
 
@@ -68,7 +77,6 @@ class LayoutParsingPipeline(BasePipeline):
         """
 
         self.use_doc_preprocessor = config.get("use_doc_preprocessor", True)
-        self.use_general_ocr = config.get("use_general_ocr", True)
         self.use_table_recognition = config.get("use_table_recognition", True)
         self.use_seal_recognition = config.get("use_seal_recognition", True)
         self.use_formula_recognition = config.get("use_formula_recognition", True)
@@ -105,12 +113,11 @@ class LayoutParsingPipeline(BasePipeline):
             layout_kwargs["layout_merge_bboxes_mode"] = layout_merge_bboxes_mode
         self.layout_det_model = self.create_model(layout_det_config, **layout_kwargs)
 
-        if self.use_general_ocr or self.use_table_recognition:
-            general_ocr_config = config.get("SubPipelines", {}).get(
-                "GeneralOCR",
-                {"pipeline_config_error": "config error for general_ocr_pipeline!"},
-            )
-            self.general_ocr_pipeline = self.create_pipeline(general_ocr_config)
+        general_ocr_config = config.get("SubPipelines", {}).get(
+            "GeneralOCR",
+            {"pipeline_config_error": "config error for general_ocr_pipeline!"},
+        )
+        self.general_ocr_pipeline = self.create_pipeline(general_ocr_config)
 
         if self.use_seal_recognition:
             seal_recognition_config = config.get("SubPipelines", {}).get(
@@ -229,10 +236,10 @@ class LayoutParsingPipeline(BasePipeline):
                     )
                     seal_index += 1
             else:
-                ocr_res_in_box, matched_idxs = get_sub_regions_ocr_res(
+                ocr_res_in_box, matched_idxes = get_sub_regions_ocr_res(
                     overall_ocr_res, [box], return_match_idx=True
                 )
-                for matched_idx in matched_idxs:
+                for matched_idx in matched_idxes:
                     if matched_ocr_dict.get(matched_idx, None) is None:
                         matched_ocr_dict[matched_idx] = [object_box_idx]
                     else:
@@ -296,12 +303,6 @@ class LayoutParsingPipeline(BasePipeline):
             )
             return False
 
-        if input_params["use_general_ocr"] and not self.use_general_ocr:
-            logging.error(
-                "Set use_general_ocr, but the models for general OCR are not initialized."
-            )
-            return False
-
         if input_params["use_seal_recognition"] and not self.use_seal_recognition:
             logging.error(
                 "Set use_seal_recognition, but the models for seal recognition are not initialized."
@@ -320,7 +321,6 @@ class LayoutParsingPipeline(BasePipeline):
         self,
         use_doc_orientation_classify: Optional[bool],
         use_doc_unwarping: Optional[bool],
-        use_general_ocr: Optional[bool],
         use_seal_recognition: Optional[bool],
         use_table_recognition: Optional[bool],
         use_formula_recognition: Optional[bool],
@@ -331,7 +331,6 @@ class LayoutParsingPipeline(BasePipeline):
         Args:
             use_doc_orientation_classify (Optional[bool]): Whether to use document orientation classification.
             use_doc_unwarping (Optional[bool]): Whether to use document unwarping.
-            use_general_ocr (Optional[bool]): Whether to use general OCR.
             use_seal_recognition (Optional[bool]): Whether to use seal recognition.
             use_table_recognition (Optional[bool]): Whether to use table recognition.
 
@@ -346,9 +345,6 @@ class LayoutParsingPipeline(BasePipeline):
             else:
                 use_doc_preprocessor = False
 
-        if use_general_ocr is None:
-            use_general_ocr = self.use_general_ocr
-
         if use_seal_recognition is None:
             use_seal_recognition = self.use_seal_recognition
 
@@ -360,7 +356,6 @@ class LayoutParsingPipeline(BasePipeline):
 
         return dict(
             use_doc_preprocessor=use_doc_preprocessor,
-            use_general_ocr=use_general_ocr,
             use_seal_recognition=use_seal_recognition,
             use_table_recognition=use_table_recognition,
             use_formula_recognition=use_formula_recognition,
@@ -372,7 +367,6 @@ class LayoutParsingPipeline(BasePipeline):
         use_doc_orientation_classify: Optional[bool] = None,
         use_doc_unwarping: Optional[bool] = None,
         use_textline_orientation: Optional[bool] = None,
-        use_general_ocr: Optional[bool] = None,
         use_seal_recognition: Optional[bool] = None,
         use_table_recognition: Optional[bool] = None,
         use_formula_recognition: Optional[bool] = None,
@@ -402,7 +396,6 @@ class LayoutParsingPipeline(BasePipeline):
             use_doc_orientation_classify (Optional[bool]): Whether to use document orientation classification.
             use_doc_unwarping (Optional[bool]): Whether to use document unwarping.
             use_textline_orientation (Optional[bool]): Whether to use textline orientation prediction.
-            use_general_ocr (Optional[bool]): Whether to use general OCR.
             use_seal_recognition (Optional[bool]): Whether to use seal recognition.
             use_table_recognition (Optional[bool]): Whether to use table recognition.
             use_formula_recognition (Optional[bool]): Whether to use formula recognition.
@@ -436,7 +429,6 @@ class LayoutParsingPipeline(BasePipeline):
         model_settings = self.get_model_settings(
             use_doc_orientation_classify,
             use_doc_unwarping,
-            use_general_ocr,
             use_seal_recognition,
             use_table_recognition,
             use_formula_recognition,
@@ -471,24 +463,18 @@ class LayoutParsingPipeline(BasePipeline):
                 )
             )
 
-            if (
-                model_settings["use_general_ocr"]
-                or model_settings["use_table_recognition"]
-            ):
-                overall_ocr_res = next(
-                    self.general_ocr_pipeline(
-                        doc_preprocessor_image,
-                        use_textline_orientation=use_textline_orientation,
-                        text_det_limit_side_len=text_det_limit_side_len,
-                        text_det_limit_type=text_det_limit_type,
-                        text_det_thresh=text_det_thresh,
-                        text_det_box_thresh=text_det_box_thresh,
-                        text_det_unclip_ratio=text_det_unclip_ratio,
-                        text_rec_score_thresh=text_rec_score_thresh,
-                    )
+            overall_ocr_res = next(
+                self.general_ocr_pipeline(
+                    doc_preprocessor_image,
+                    use_textline_orientation=use_textline_orientation,
+                    text_det_limit_side_len=text_det_limit_side_len,
+                    text_det_limit_type=text_det_limit_type,
+                    text_det_thresh=text_det_thresh,
+                    text_det_box_thresh=text_det_box_thresh,
+                    text_det_unclip_ratio=text_det_unclip_ratio,
+                    text_rec_score_thresh=text_rec_score_thresh,
                 )
-            else:
-                overall_ocr_res = {}
+            )
 
             if model_settings["use_table_recognition"]:
                 table_res_all = next(
@@ -568,3 +554,15 @@ class LayoutParsingPipeline(BasePipeline):
                 "model_settings": model_settings,
             }
             yield LayoutParsingResult(single_img_res)
+
+
+@pipeline_requires_extra("ocr")
+class LayoutParsingPipeline(AutoParallelImageSimpleInferencePipeline):
+    entities = ["layout_parsing"]
+
+    @property
+    def _pipeline_cls(self):
+        return _LayoutParsingPipeline
+
+    def _get_batch_size(self, config):
+        return 1