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

paddlex/inference/pipelines/doc_understanding/pipeline.py

@@ -0,0 +1,71 @@
+# 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.
+# 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 Any, Dict, Optional, Union
+
+from ....utils.deps import pipeline_requires_extra
+from ...models.doc_vlm.result import DocVLMResult
+from ...utils.hpi import HPIConfig
+from ...utils.pp_option import PaddlePredictorOption
+from ..base import BasePipeline
+
+
+@pipeline_requires_extra("multimodal")
+class DocUnderstandingPipeline(BasePipeline):
+    """Doc Understanding Pipeline"""
+
+    entities = "doc_understanding"
+
+    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.
+
+        Args:
+            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, 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, hpi_config=hpi_config
+        )
+
+        doc_understanding_model_config = config.get("SubModules", {}).get(
+            "DocUnderstanding",
+            {"model_config_error": "config error for doc_understanding_model!"},
+        )
+        self.doc_understanding_model = self.create_model(doc_understanding_model_config)
+
+    def predict(self, input: Dict, **kwargs) -> DocVLMResult:
+        """Predicts doc understanding results for the given input.
+
+        Args:
+            input (dict): The input image and query.
+            **kwargs: Additional keyword arguments that can be passed to the function.
+
+        Returns:
+            DocVLMResult: The predicted doc understanding results.
+        """
+        yield from self.doc_understanding_model(input, **kwargs)

paddlex/inference/pipelines/face_recognition/__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/face_recognition/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.
@@ -14,10 +14,12 @@
 
 import numpy as np
 
+from ....utils.deps import pipeline_requires_extra
 from ..pp_shitu_v2 import ShiTuV2Pipeline
 from .result import FaceRecResult
 
 
+@pipeline_requires_extra("cv")
 class FaceRecPipeline(ShiTuV2Pipeline):
     """Face Recognition Pipeline"""
 

paddlex/inference/pipelines/face_recognition/result.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.
@@ -13,7 +13,8 @@
 # limitations under the License.
 
 import copy
-from ...common.result import BaseCVResult, JsonMixin, StrMixin
+
+from ...common.result import BaseCVResult, JsonMixin
 from ..pp_shitu_v2.result import draw_box
 
 

paddlex/inference/pipelines/formula_recognition/__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/formula_recognition/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,38 +12,33 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import os, sys
-from typing import Any, Dict, Optional, Union, List, Tuple
+from typing import Any, Dict, List, Optional, Tuple, Union
+
 import numpy as np
-import cv2
-from ..base import BasePipeline
-from ..components import CropByBoxes, convert_points_to_boxes
 
-from .result import FormulaRecognitionResult
-from ...models.formula_recognition.result import (
-    FormulaRecResult as SingleFormulaRecognitionResult,
-)
 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 ..doc_preprocessor.result import DocPreprocessorResult
-
+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 .result import FormulaRecognitionResult
 
 
-class FormulaRecognitionPipeline(BasePipeline):
+class _FormulaRecognitionPipeline(BasePipeline):
     """Formula Recognition Pipeline"""
 
-    entities = ["formula_recognition"]
-
     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 formula recognition pipeline.
 
@@ -51,10 +46,16 @@ class FormulaRecognitionPipeline(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.use_doc_preprocessor = config.get("use_doc_preprocessor", True)
         if self.use_doc_preprocessor:
@@ -104,7 +105,7 @@ class FormulaRecognitionPipeline(BasePipeline):
 
         self._crop_by_boxes = CropByBoxes()
 
-        self.batch_sampler = ImageBatchSampler(batch_size=1)
+        self.batch_sampler = ImageBatchSampler(batch_size=config.get("batch_size", 1))
         self.img_reader = ReadImage(format="BGR")
 
     def get_model_settings(
@@ -141,14 +142,14 @@ class FormulaRecognitionPipeline(BasePipeline):
         )
 
     def check_model_settings_valid(
-        self, model_settings: Dict, layout_det_res: DetResult
+        self, model_settings: Dict, layout_det_res: Union[DetResult, List[DetResult]]
     ) -> bool:
         """
         Check if the input parameters are valid based on the initialized models.
 
         Args:
             model_settings (Dict): A dictionary containing input parameters.
-            layout_det_res (DetResult): The layout detection result.
+            layout_det_res (Union[DetResult, List[DetResult]]): The layout detection result(s).
         Returns:
             bool: True if all required models are initialized according to input parameters, False otherwise.
         """
@@ -174,32 +175,13 @@ class FormulaRecognitionPipeline(BasePipeline):
 
         return True
 
-    def predict_single_formula_recognition_res(
-        self,
-        image_array: np.ndarray,
-    ) -> SingleFormulaRecognitionResult:
-        """
-        Predict formula recognition results from an image array, layout detection results.
-
-        Args:
-            image_array (np.ndarray): The input image represented as a numpy array.
-            formula_box (list): The formula box coordinates.
-            flag_find_nei_text (bool): Whether to find neighboring text.
-        Returns:
-            SingleFormulaRecognitionResult: single formula recognition result.
-        """
-
-        formula_recognition_pred = next(self.formula_recognition_model(image_array))
-
-        return formula_recognition_pred
-
     def predict(
         self,
         input: Union[str, List[str], np.ndarray, List[np.ndarray]],
         use_layout_detection: Optional[bool] = None,
         use_doc_orientation_classify: Optional[bool] = None,
         use_doc_unwarping: Optional[bool] = None,
-        layout_det_res: Optional[DetResult] = None,
+        layout_det_res: Optional[Union[DetResult, List[DetResult]]] = None,
         layout_threshold: Optional[Union[float, dict]] = None,
         layout_nms: Optional[bool] = None,
         layout_unclip_ratio: Optional[Union[float, Tuple[float, float]]] = None,
@@ -214,14 +196,13 @@ class FormulaRecognitionPipeline(BasePipeline):
             use_layout_detection (Optional[bool]): Whether to use layout detection.
             use_doc_orientation_classify (Optional[bool]): Whether to use document orientation classification.
             use_doc_unwarping (Optional[bool]): Whether to use document unwarping.
-            layout_det_res (Optional[DetResult]): The layout detection result.
+            layout_det_res (Optional[Union[DetResult, List[DetResult]]]): The layout detection result(s).
                 It will be used if it is not None and use_layout_detection is False.
             **kwargs: Additional keyword arguments.
 
         Returns:
             formulaRecognitionResult: The predicted formula recognition result.
         """
-
         model_settings = self.get_model_settings(
             use_doc_orientation_classify,
             use_doc_unwarping,
@@ -231,73 +212,136 @@ class FormulaRecognitionPipeline(BasePipeline):
         if not self.check_model_settings_valid(model_settings, layout_det_res):
             yield {"error": "the input params for model settings are invalid!"}
 
-        for img_id, batch_data in enumerate(self.batch_sampler(input)):
-            image_array = self.img_reader(batch_data.instances)[0]
+        external_layout_det_results = layout_det_res
+        if external_layout_det_results is not None:
+            if not isinstance(external_layout_det_results, list):
+                external_layout_det_results = [external_layout_det_results]
+            external_layout_det_results = iter(external_layout_det_results)
+
+        for _, batch_data in enumerate(self.batch_sampler(input)):
+            image_arrays = self.img_reader(batch_data.instances)
 
             if model_settings["use_doc_preprocessor"]:
-                doc_preprocessor_res = next(
+                doc_preprocessor_results = list(
                     self.doc_preprocessor_pipeline(
-                        image_array,
+                        image_arrays,
                         use_doc_orientation_classify=use_doc_orientation_classify,
                         use_doc_unwarping=use_doc_unwarping,
                     )
                 )
             else:
-                doc_preprocessor_res = {"output_img": image_array}
+                doc_preprocessor_results = [{"output_img": arr} for arr in image_arrays]
 
-            doc_preprocessor_image = doc_preprocessor_res["output_img"]
+            doc_preprocessor_images = [
+                item["output_img"] for item in doc_preprocessor_results
+            ]
 
-            formula_res_list = []
-            formula_region_id = 1
+            formula_results = []
 
-            if not model_settings["use_layout_detection"] and layout_det_res is None:
-                layout_det_res = {}
-                img_height, img_width = doc_preprocessor_image.shape[:2]
-                single_formula_rec_res = self.predict_single_formula_recognition_res(
-                    doc_preprocessor_image,
+            if (
+                not model_settings["use_layout_detection"]
+                and external_layout_det_results is None
+            ):
+                layout_det_results = [{} for _ in doc_preprocessor_images]
+                formula_rec_results = list(
+                    self.formula_recognition_model(doc_preprocessor_images)
                 )
-                single_formula_rec_res["formula_region_id"] = formula_region_id
-                formula_res_list.append(single_formula_rec_res)
-                formula_region_id += 1
+                for formula_rec_res in formula_rec_results:
+                    formula_results_for_img = []
+                    formula_rec_res["formula_region_id"] = 1
+                    formula_results_for_img.append(formula_rec_res)
+                    formula_results.append(formula_results_for_img)
             else:
                 if model_settings["use_layout_detection"]:
-                    layout_det_res = next(
+                    layout_det_results = list(
                         self.layout_det_model(
-                            doc_preprocessor_image,
+                            doc_preprocessor_images,
                             threshold=layout_threshold,
                             layout_nms=layout_nms,
                             layout_unclip_ratio=layout_unclip_ratio,
                             layout_merge_bboxes_mode=layout_merge_bboxes_mode,
                         )
                     )
-                formula_crop_img = []
-                for box_info in layout_det_res["boxes"]:
-                    if box_info["label"].lower() in ["formula"]:
-                        crop_img_info = self._crop_by_boxes(
-                            doc_preprocessor_image, [box_info]
-                        )
-                        crop_img_info = crop_img_info[0]
-                        formula_crop_img.append(crop_img_info["img"])
-                        single_formula_rec_res = {}
-                        single_formula_rec_res["formula_region_id"] = formula_region_id
-                        single_formula_rec_res["dt_polys"] = box_info["coordinate"]
-                        formula_res_list.append(single_formula_rec_res)
-                        formula_region_id += 1
-                for idx, formula_rec_res in enumerate(
-                    self.formula_recognition_model(formula_crop_img)
+                else:
+                    layout_det_results = []
+                    for _ in doc_preprocessor_images:
+                        try:
+                            layout_det_res = next(external_layout_det_results)
+                        except StopIteration:
+                            raise ValueError("No more layout det results")
+                        layout_det_results.append(layout_det_res)
+
+                formula_crop_imgs = []
+                formula_det_results = []
+                chunk_indices = [0]
+                for doc_preprocessor_image, layout_det_res in zip(
+                    doc_preprocessor_images, layout_det_results
                 ):
-                    formula_region_id = formula_res_list[idx]["formula_region_id"]
-                    dt_polys = formula_res_list[idx]["dt_polys"]
-                    formula_rec_res["formula_region_id"] = formula_region_id
-                    formula_rec_res["dt_polys"] = dt_polys
-                    formula_res_list[idx] = formula_rec_res
-
-            single_img_res = {
-                "input_path": batch_data.input_paths[0],
-                "page_index": batch_data.page_indexes[0],
-                "layout_det_res": layout_det_res,
-                "doc_preprocessor_res": doc_preprocessor_res,
-                "formula_res_list": formula_res_list,
-                "model_settings": model_settings,
-            }
-            yield FormulaRecognitionResult(single_img_res)
+                    formula_region_id = 1
+                    for box_info in layout_det_res["boxes"]:
+                        if box_info["label"].lower() in ["formula"]:
+                            crop_img_info = self._crop_by_boxes(
+                                doc_preprocessor_image, [box_info]
+                            )
+                            crop_img_info = crop_img_info[0]
+                            formula_crop_imgs.append(crop_img_info["img"])
+                            res = {}
+                            res["formula_region_id"] = formula_region_id
+                            res["dt_polys"] = box_info["coordinate"]
+                            formula_det_results.append(res)
+                            formula_region_id += 1
+                    chunk_indices.append(len(formula_crop_imgs))
+
+                formula_rec_results = list(
+                    self.formula_recognition_model(formula_crop_imgs)
+                )
+                for idx in range(len(chunk_indices) - 1):
+                    formula_det_results_for_idx = formula_det_results[
+                        chunk_indices[idx] : chunk_indices[idx + 1]
+                    ]
+                    formula_rec_results_for_idx = formula_rec_results[
+                        chunk_indices[idx] : chunk_indices[idx + 1]
+                    ]
+                    for formula_det_res, formula_rec_res in zip(
+                        formula_det_results_for_idx, formula_rec_results_for_idx
+                    ):
+                        formula_region_id = formula_det_res["formula_region_id"]
+                        dt_polys = formula_det_res["dt_polys"]
+                        formula_rec_res["formula_region_id"] = formula_region_id
+                        formula_rec_res["dt_polys"] = dt_polys
+                    formula_results.append(formula_rec_results_for_idx)
+
+            for (
+                input_path,
+                page_index,
+                layout_det_res,
+                doc_preprocessor_res,
+                formula_results_for_img,
+            ) in zip(
+                batch_data.input_paths,
+                batch_data.page_indexes,
+                layout_det_results,
+                doc_preprocessor_results,
+                formula_results,
+            ):
+                single_img_res = {
+                    "input_path": input_path,
+                    "page_index": page_index,
+                    "layout_det_res": layout_det_res,
+                    "doc_preprocessor_res": doc_preprocessor_res,
+                    "formula_res_list": formula_results_for_img,
+                    "model_settings": model_settings,
+                }
+                yield FormulaRecognitionResult(single_img_res)
+
+
+@pipeline_requires_extra("ocr")
+class FormulaRecognitionPipeline(AutoParallelImageSimpleInferencePipeline):
+    entities = ["formula_recognition"]
+
+    @property
+    def _pipeline_cls(self):
+        return _FormulaRecognitionPipeline
+
+    def _get_batch_size(self, config):
+        return config.get("batch_size", 1)

paddlex/inference/pipelines/formula_recognition/result.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,48 +12,38 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import os, sys
-from typing import Tuple, List, Dict, Any
-import cv2
-import PIL
 import math
-import copy
+import os
 import random
-import tempfile
 import subprocess
+import tempfile
+from typing import Dict, Tuple
+
 import numpy as np
-from pathlib import Path
-import PIL
-from PIL import Image, ImageDraw, ImageFont
+from PIL import Image, ImageDraw
 
-from ...common.result import BaseCVResult, JsonMixin, ImgMixin, StrMixin
 from ....utils import logging
+from ....utils.deps import class_requires_deps, function_requires_deps, is_dep_available
 from ....utils.fonts import PINGFANG_FONT_FILE_PATH
+from ...common.result import BaseCVResult, JsonMixin
 from ...models.formula_recognition.result import (
-    get_align_equation,
-    generate_tex_file,
-    generate_pdf_file,
-    env_valid,
-    pdf2img,
-    create_font,
     crop_white_area,
     draw_box_txt_fine,
     draw_formula_module,
+    env_valid,
+    generate_pdf_file,
+    generate_tex_file,
+    pdf2img,
 )
 
+if is_dep_available("opencv-contrib-python"):
+    import cv2
 
+
+@class_requires_deps("opencv-contrib-python")
 class FormulaRecognitionResult(BaseCVResult):
     """Formula Recognition Result"""
 
-    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) -> Dict[str, Image.Image]:
         """
         Converts the internal data to a PIL Image with detection and recognition results.
@@ -61,7 +51,7 @@ class FormulaRecognitionResult(BaseCVResult):
         Returns:
             Dict[str, Image.Image]: An image with detection boxes, texts, and scores blended on it.
         """
-        image = Image.fromarray(self["doc_preprocessor_res"]["output_img"])
+        image = Image.fromarray(self["doc_preprocessor_res"]["output_img"][:, :, ::-1])
         res_img_dict = {}
         model_settings = self["model_settings"]
         if model_settings["use_doc_preprocessor"]:
@@ -123,10 +113,10 @@ class FormulaRecognitionResult(BaseCVResult):
         random.seed(0)
         draw_left = ImageDraw.Draw(img_left)
 
-        formula_res_list = self["formula_res_list"]
+        self["formula_res_list"]
         for tno in range(len(self["formula_res_list"])):
             formula_res = self["formula_res_list"][tno]
-            formula_region_id = formula_res["formula_region_id"]
+            formula_res["formula_region_id"]
             formula = str(formula_res["rec_formula"])
             dt_polys = formula_res["dt_polys"]
             x1, y1, x2, y2 = list(dt_polys)
@@ -226,6 +216,7 @@ class FormulaRecognitionResult(BaseCVResult):
         return JsonMixin._to_json(data, *args, **kwargs)
 
 
+@function_requires_deps("opencv-contrib-python")
 def draw_box_formula_fine(
     img_size: Tuple[int, int], box: np.ndarray, formula: str, is_debug: bool = False
 ) -> np.ndarray:

paddlex/inference/pipelines/image_classification/__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/image_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_classification.result import TopkResult
+from ...utils.hpi import HPIConfig
+from ...utils.pp_option import PaddlePredictorOption
+from .._parallel import AutoParallelImageSimpleInferencePipeline
+from ..base import BasePipeline
 
 
-class ImageClassificationPipeline(BasePipeline):
+class _ImageClassificationPipeline(BasePipeline):
     """Image Classification Pipeline"""
 
-    entities = "image_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 ImageClassificationPipeline(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
+        )
 
         image_classification_model_config = config["SubModules"]["ImageClassification"]
         model_kwargs = {}
@@ -69,3 +76,15 @@ class ImageClassificationPipeline(BasePipeline):
 
         topk = kwargs.pop("topk", self.topk)
         yield from self.image_classification_model(input, topk=topk)
+
+
+@pipeline_requires_extra("cv")
+class ImageClassificationPipeline(AutoParallelImageSimpleInferencePipeline):
+    entities = "image_classification"
+
+    @property
+    def _pipeline_cls(self):
+        return _ImageClassificationPipeline
+
+    def _get_batch_size(self, config):
+        return config["SubModules"]["ImageClassification"].get("batch_size", 1)

paddlex/inference/pipelines/image_multilabel_classification/__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.