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

paddlex/inference/models/video_detection/predictor.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,21 +12,18 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any, Union, Dict, List, Tuple
-from ....utils.func_register import FuncRegister
+from typing import Union
+
 from ....modules.video_detection.model_list import MODELS
+from ....utils.func_register import FuncRegister
 from ...common.batch_sampler import VideoBatchSampler
 from ...common.reader import ReadVideo
-from ..common import (
-    ToBatch,
-    StaticInfer,
-)
-from ..base import BasicPredictor
-from .processors import ResizeVideo, Image2Array, NormalizeVideo, DetVideoPostProcess
+from ..base import BasePredictor
+from .processors import DetVideoPostProcess, Image2Array, NormalizeVideo, ResizeVideo
 from .result import DetVideoResult
 
 
-class VideoDetPredictor(BasicPredictor):
+class VideoDetPredictor(BasePredictor):
 
     entities = MODELS
 
@@ -62,11 +59,7 @@ class VideoDetPredictor(BasicPredictor):
             if op:
                 pre_tfs[name] = op
 
-        infer = StaticInfer(
-            model_dir=self.model_dir,
-            model_prefix=self.MODEL_FILE_PREFIX,
-            option=self.pp_option,
-        )
+        infer = self.create_static_infer()
         post_op = {}
         for cfg in self.config["PostProcess"]["transform_ops"]:
             tf_key = list(cfg.keys())[0]

paddlex/inference/models/video_detection/processors.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,15 +13,16 @@
 # limitations under the License.
 
 
-import os
-import os.path as osp
-from typing import List, Sequence, Union, Optional, Tuple
+from typing import List
 
 import numpy as np
-import cv2
-import lazy_paddle as paddle
 
+from ....utils.deps import class_requires_deps
+from ...utils.benchmark import benchmark
 
+
+@benchmark.timeit
+@class_requires_deps("opencv-contrib-python")
 class ResizeVideo:
     """Resizes frames of a video to a specified target size.
 
@@ -56,6 +57,8 @@ class ResizeVideo:
         Raises:
             NotImplementedError: If a frame is not an instance of numpy.ndarray.
         """
+        import cv2
+
         num_seg = len(video)
         seg_len = len(video[0])
 
@@ -88,6 +91,7 @@ class ResizeVideo:
         return [self.resize(video) for video in videos]
 
 
+@benchmark.timeit
 class Image2Array:
     """Convert a sequence of images to a numpy array with optional transposition."""
 
@@ -143,6 +147,7 @@ class Image2Array:
         return [self.img2array(video) for video in videos]
 
 
+@benchmark.timeit
 class NormalizeVideo:
     """
     A class to normalize video frames by scaling the pixel values.
@@ -234,6 +239,8 @@ def get_region_boxes(
     Returns:
         all_box(List[List[float]]): A list of predicted bounding boxes for each image in the batch.
     """
+    import paddle
+
     anchor_step = len(anchors) // num_anchors
     if output.dim() == 3:
         output = output.unsqueeze(0)
@@ -249,12 +256,12 @@ def get_region_boxes(
     grid_x = paddle.linspace(0, w - 1, w)
     grid_x = paddle.tile(grid_x, [h, 1])
     grid_x = paddle.tile(grid_x, [batch * num_anchors, 1, 1])
-    grid_x = paddle.reshape(grid_x, [batch * num_anchors * h * w]).cuda()
+    grid_x = paddle.reshape(grid_x, [batch * num_anchors * h * w])
 
     grid_y = paddle.linspace(0, h - 1, h)
     grid_y = paddle.tile(grid_y, [w, 1]).t()
     grid_y = paddle.tile(grid_y, [batch * num_anchors, 1, 1])
-    grid_y = paddle.reshape(grid_y, [batch * num_anchors * h * w]).cuda()
+    grid_y = paddle.reshape(grid_y, [batch * num_anchors * h * w])
 
     sigmoid = paddle.nn.Sigmoid()
     xs = sigmoid(output[0]) + grid_x
@@ -274,11 +281,11 @@ def get_region_boxes(
 
     anchor_w = paddle.tile(anchor_w, [batch, 1])
     anchor_w = paddle.tile(anchor_w, [1, 1, h * w])
-    anchor_w = paddle.reshape(anchor_w, [batch * num_anchors * h * w]).cuda()
+    anchor_w = paddle.reshape(anchor_w, [batch * num_anchors * h * w])
 
     anchor_h = paddle.tile(anchor_h, [batch, 1])
     anchor_h = paddle.tile(anchor_h, [1, 1, h * w])
-    anchor_h = paddle.reshape(anchor_h, [batch * num_anchors * h * w]).cuda()
+    anchor_h = paddle.reshape(anchor_h, [batch * num_anchors * h * w])
 
     ws = paddle.exp(output[2]) * anchor_w
     hs = paddle.exp(output[3]) * anchor_h
@@ -343,6 +350,8 @@ def nms(boxes, nms_thresh):
     """
     Performs non-maximum suppression on the input boxes based on their IoUs.
     """
+    import paddle
+
     if len(boxes) == 0:
         return boxes
     det_confs = paddle.zeros([len(boxes)])
@@ -366,6 +375,8 @@ def bbox_iou(box1, box2, x1y1x2y2=True):
     """
     Returns the Intersection over Union (IoU) of two bounding boxes.
     """
+    import paddle
+
     if x1y1x2y2:
         mx = min(box1[0], box2[0])
         Mx = max(box1[2], box2[2])
@@ -399,6 +410,7 @@ def bbox_iou(box1, box2, x1y1x2y2=True):
     return carea / uarea
 
 
+@benchmark.timeit
 class DetVideoPostProcess:
     """
     A class used to perform post-processing on detection results in videos.
@@ -417,7 +429,8 @@ class DetVideoPostProcess:
         self.labels = label_list
 
     def postprocess(self, pred: List, nms_thresh: float, score_thresh: float) -> List:
-        font = cv2.FONT_HERSHEY_SIMPLEX
+        import paddle
+
         num_seg = len(pred)
         pred_all = []
         for i in range(num_seg):

paddlex/inference/models/video_detection/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,18 +12,23 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import cv2
-import numpy as np
 import random
+
+import numpy as np
 import PIL
 from PIL import Image, ImageDraw, ImageFont
 
+from ....utils.deps import class_requires_deps, is_dep_available
 from ....utils.fonts import PINGFANG_FONT_FILE_PATH
+from ...common.result import BaseVideoResult
 from ...utils.color_map import get_colormap
 from ...utils.io import VideoReader
-from ...common.result import BaseVideoResult
+
+if is_dep_available("opencv-contrib-python"):
+    import cv2
 
 
+@class_requires_deps("opencv-contrib-python")
 class DetVideoResult(BaseVideoResult):
 
     def _to_video(self):
@@ -39,7 +44,7 @@ class DetVideoResult(BaseVideoResult):
 
         for i in range(len(video)):
             image = Image.fromarray(video[i].asnumpy())
-            image_size = image.size
+            image.size
             font_size = int(0.018 * int(image.width)) + 2
             font = ImageFont.truetype(
                 PINGFANG_FONT_FILE_PATH, font_size, encoding="utf-8"

paddlex/inference/pipelines/__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.
@@ -13,50 +13,46 @@
 # limitations under the License.
 
 from pathlib import Path
-from typing import Any, Dict, Optional
-from importlib import import_module
-from .base import BasePipeline
-from ..utils.pp_option import PaddlePredictorOption
-from .components import BaseChat, BaseRetriever, BaseGeneratePrompt
+from typing import Any, Dict, Optional, Union
+
 from ...utils import logging
 from ...utils.config import parse_config
-from .ocr import OCRPipeline
-from .doc_preprocessor import DocPreprocessorPipeline
-from .layout_parsing import LayoutParsingPipeline
-from .pp_chatocr import PP_ChatOCRv3_Pipeline, PP_ChatOCRv4_Pipeline
-from .image_classification import ImageClassificationPipeline
-from .object_detection import ObjectDetectionPipeline
-from .seal_recognition import SealRecognitionPipeline
-from .table_recognition import TableRecognitionPipeline
-from .table_recognition import TableRecognitionPipelineV2
-from .multilingual_speech_recognition import MultilingualSpeechRecognitionPipeline
-from .formula_recognition import FormulaRecognitionPipeline
-from .image_multilabel_classification import ImageMultiLabelClassificationPipeline
-from .video_classification import VideoClassificationPipeline
-from .video_detection import VideoDetectionPipeline
+from ..utils.hpi import HPIConfig
+from ..utils.pp_option import PaddlePredictorOption
 from .anomaly_detection import AnomalyDetectionPipeline
-from .ts_forecasting import TSFcPipeline
-from .ts_anomaly_detection import TSAnomalyDetPipeline
-from .ts_classification import TSClsPipeline
-from .pp_shitu_v2 import ShiTuV2Pipeline
-from .face_recognition import FaceRecPipeline
 from .attribute_recognition import (
     PedestrianAttributeRecPipeline,
     VehicleAttributeRecPipeline,
 )
-
-from .semantic_segmentation import SemanticSegmentationPipeline
+from .base import BasePipeline
+from .components import BaseChat, BaseGeneratePrompt, BaseRetriever
+from .doc_preprocessor import DocPreprocessorPipeline
+from .doc_understanding import DocUnderstandingPipeline
+from .face_recognition import FaceRecPipeline
+from .formula_recognition import FormulaRecognitionPipeline
+from .image_classification import ImageClassificationPipeline
+from .image_multilabel_classification import ImageMultiLabelClassificationPipeline
 from .instance_segmentation import InstanceSegmentationPipeline
-from .small_object_detection import SmallObjectDetectionPipeline
-from .rotated_object_detection import RotatedObjectDetectionPipeline
 from .keypoint_detection import KeypointDetectionPipeline
+from .layout_parsing import LayoutParsingPipeline
+from .m_3d_bev_detection import BEVDet3DPipeline
+from .multilingual_speech_recognition import MultilingualSpeechRecognitionPipeline
+from .object_detection import ObjectDetectionPipeline
+from .ocr import OCRPipeline
 from .open_vocabulary_detection import OpenVocabularyDetectionPipeline
 from .open_vocabulary_segmentation import OpenVocabularySegmentationPipeline
-
-module_3d_bev_detection = import_module(
-    ".3d_bev_detection", "paddlex.inference.pipelines"
-)
-BEVDet3DPipeline = getattr(module_3d_bev_detection, "BEVDet3DPipeline")
+from .pp_chatocr import PP_ChatOCRv3_Pipeline, PP_ChatOCRv4_Pipeline
+from .pp_shitu_v2 import ShiTuV2Pipeline
+from .rotated_object_detection import RotatedObjectDetectionPipeline
+from .seal_recognition import SealRecognitionPipeline
+from .semantic_segmentation import SemanticSegmentationPipeline
+from .small_object_detection import SmallObjectDetectionPipeline
+from .table_recognition import TableRecognitionPipeline, TableRecognitionPipelineV2
+from .ts_anomaly_detection import TSAnomalyDetPipeline
+from .ts_classification import TSClsPipeline
+from .ts_forecasting import TSFcPipeline
+from .video_classification import VideoClassificationPipeline
+from .video_detection import VideoDetectionPipeline
 
 
 def get_pipeline_path(pipeline_name: str) -> str:
@@ -109,7 +105,8 @@ def create_pipeline(
     config: Optional[Dict[str, Any]] = None,
     device: Optional[str] = None,
     pp_option: Optional[PaddlePredictorOption] = None,
-    use_hpip: bool = False,
+    use_hpip: Optional[bool] = None,
+    hpi_config: Optional[Union[Dict[str, Any], HPIConfig]] = None,
     *args: Any,
     **kwargs: Any,
 ) -> BasePipeline:
@@ -128,8 +125,12 @@ def create_pipeline(
             Defaults to None.
         pp_option (Optional[PaddlePredictorOption], optional): The options for
             the PaddlePredictor. Defaults to None.
-        use_hpip (bool, optional): Whether to use high-performance inference
-            plugin (HPIP) for prediction. Defaults to False.
+        use_hpip (Optional[bool], optional): Whether to use the high-performance
+            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.
         *args: Additional positional arguments.
         **kwargs: Additional keyword arguments.
 
@@ -150,13 +151,23 @@ def create_pipeline(
                 pipeline,
                 config["pipeline_name"],
             )
+        config = config.copy()
     pipeline_name = config["pipeline_name"]
+    if use_hpip is None:
+        use_hpip = config.pop("use_hpip", False)
+    else:
+        config.pop("use_hpip", None)
+    if hpi_config is None:
+        hpi_config = config.pop("hpi_config", None)
+    else:
+        config.pop("hpi_config", None)
 
     pipeline = BasePipeline.get(pipeline_name)(
         config=config,
         device=device,
         pp_option=pp_option,
         use_hpip=use_hpip,
+        hpi_config=hpi_config,
         *args,
         **kwargs,
     )

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/__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/anomaly_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,26 +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.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
 
-from ...models.anomaly_detection.result import UadResult
-
 
-class AnomalyDetectionPipeline(BasePipeline):
+class _AnomalyDetectionPipeline(BasePipeline):
     """Image AnomalyDetectionPipeline Pipeline"""
 
-    entities = "anomaly_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 image anomaly detection pipeline.
 
@@ -39,10 +41,16 @@ class AnomalyDetectionPipeline(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
+        )
 
         anomaly_detetion_model_config = config["SubModules"]["AnomalyDetection"]
         self.anomaly_detetion_model = self.create_model(anomaly_detetion_model_config)
@@ -60,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/__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/attribute_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,21 +12,22 @@
 # 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 pickle
-from pathlib import Path
 import numpy as np
 
-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 ..components import CropByBoxes
+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__(
@@ -35,8 +36,11 @@ class AttributeRecPipeline(BasePipeline):
         device: str = None,
         pp_option: PaddlePredictorOption = None,
         use_hpip: bool = False,
+        hpi_config: Optional[Union[Dict[str, Any], HPIConfig]] = 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.det_model = self.create_model(config["SubModules"]["Detection"])
         self.cls_model = self.create_model(config["SubModules"]["Classification"])
@@ -97,9 +101,20 @@ 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"
 
 
+@pipeline_requires_extra("cv")
 class VehicleAttributeRecPipeline(AttributeRecPipeline):
     entities = "vehicle_attribute_recognition"