paddlex 3.0.0rc0__py3-none-any.whl → 3.0.0rc1__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,11 @@ 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). 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.
 
@@ -151,12 +151,19 @@ def create_pipeline(
                 config["pipeline_name"],
             )
     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)
+    if hpi_config is None:
+        hpi_config = config.get("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/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,15 +12,18 @@
 # 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 ..base import BasePipeline
 
-from ...models.anomaly_detection.result import UadResult
-
 
+@pipeline_requires_extra("cv")
 class AnomalyDetectionPipeline(BasePipeline):
     """Image AnomalyDetectionPipeline Pipeline"""
 
@@ -32,6 +35,7 @@ class AnomalyDetectionPipeline(BasePipeline):
         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 +43,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). Defaults to False.
+            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
+        )
 
         anomaly_detetion_model_config = config["SubModules"]["AnomalyDetection"]
         self.anomaly_detetion_model = self.create_model(anomaly_detetion_model_config)

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,17 +12,17 @@
 # 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 ..base import BasePipeline
+from ..components import CropByBoxes
 from .result import AttributeRecResult
 
 
@@ -35,8 +35,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 +100,11 @@ class AttributeRecPipeline(BasePipeline):
         return AttributeRecResult(single_img_res)
 
 
+@pipeline_requires_extra("cv")
 class PedestrianAttributeRecPipeline(AttributeRecPipeline):
     entities = "pedestrian_attribute_recognition"
 
 
+@pipeline_requires_extra("cv")
 class VehicleAttributeRecPipeline(AttributeRecPipeline):
     entities = "vehicle_attribute_recognition"

paddlex/inference/pipelines/attribute_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,17 +12,18 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import os
-import cv2
 import copy
-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 ...utils.io import ImageReader
-from ...common.result import BaseCVResult, StrMixin, JsonMixin
-from ...utils.color_map import get_colormap, font_colormap
+from ...common.result import BaseCVResult, JsonMixin
+from ...utils.color_map import font_colormap, get_colormap
+
+if is_dep_available("opencv-contrib-python"):
+    import cv2
 
 
 def draw_attribute_result(img, boxes):
@@ -49,7 +50,7 @@ def draw_attribute_result(img, boxes):
             label2color[i] = color_list[color_index]
             catid2fontcolor[i] = font_colormap(color_index)
         color = tuple(label2color[i]) + (255,)
-        font_color = tuple(catid2fontcolor[i])
+        tuple(catid2fontcolor[i])
 
         xmin, ymin, xmax, ymax = bbox
         # draw box
@@ -73,6 +74,7 @@ def draw_attribute_result(img, boxes):
     return img
 
 
+@class_requires_deps("opencv-contrib-python")
 class AttributeRecResult(BaseCVResult):
 
     def _to_str(self, *args, **kwargs):

paddlex/inference/pipelines/base.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,14 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from pathlib import Path
-from typing import Any, Dict, Optional
 from abc import ABC, abstractmethod
-import yaml
-import codecs
+from typing import Any, Dict, Optional, Union
+
+from ...utils import logging
 from ...utils.subclass_register import AutoRegisterABCMetaClass
-from ..utils.pp_option import PaddlePredictorOption
 from ..models import BasePredictor
+from ..utils.hpi import HPIConfig
+from ..utils.pp_option import PaddlePredictorOption
 
 
 class BasePipeline(ABC, metaclass=AutoRegisterABCMetaClass):
@@ -37,6 +37,7 @@ class BasePipeline(ABC, metaclass=AutoRegisterABCMetaClass):
         device: str = None,
         pp_option: PaddlePredictorOption = None,
         use_hpip: bool = False,
+        hpi_config: Optional[Union[Dict[str, Any], HPIConfig]] = None,
         *args,
         **kwargs,
     ) -> None:
@@ -46,12 +47,17 @@ class BasePipeline(ABC, metaclass=AutoRegisterABCMetaClass):
         Args:
             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 high-performance inference (hpip) for prediction. Defaults to False.
+            use_hpip (bool, optional): Whether to use the high-performance
+                inference plugin (HPIP). Defaults to False.
+            hpi_config (Optional[Union[Dict[str, Any], HPIConfig]], optional):
+                The high-performance inference configuration dictionary.
+                Defaults to None.
         """
         super().__init__()
         self.device = device
         self.pp_option = pp_option
         self.use_hpip = use_hpip
+        self.hpi_config = hpi_config
 
     @abstractmethod
     def predict(self, input, **kwargs):
@@ -79,18 +85,25 @@ class BasePipeline(ABC, metaclass=AutoRegisterABCMetaClass):
             raise ValueError(config["model_config_error"])
 
         model_dir = config.get("model_dir", None)
-        hpi_params = config.get("hpi_params", None)
+        # Should we log if the actual parameter to use is different from the default?
+        use_hpip = config.get("use_hpip", self.use_hpip)
+        hpi_config = config.get("hpi_config", None)
+        if self.hpi_config is not None:
+            hpi_config = hpi_config or {}
+            hpi_config = {**self.hpi_config, **hpi_config}
 
         from .. import create_predictor
 
+        logging.info("Creating model: %s", (config["model_name"], model_dir))
+
         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,
-            use_hpip=self.use_hpip,
-            hpi_params=hpi_params,
+            use_hpip=use_hpip,
+            hpi_config=hpi_config,
             **kwargs,
         )
         return model
@@ -110,11 +123,18 @@ class BasePipeline(ABC, metaclass=AutoRegisterABCMetaClass):
 
         from . import create_pipeline
 
+        use_hpip = config.get("use_hpip", self.use_hpip)
+        hpi_config = config.get("hpi_config", None)
+        if self.hpi_config is not None:
+            hpi_config = hpi_config or {}
+            hpi_config = {**self.hpi_config, **hpi_config}
+
         pipeline = create_pipeline(
             config=config,
             device=self.device,
             pp_option=self.pp_option,
-            use_hpip=self.use_hpip,
+            use_hpip=use_hpip,
+            hpi_config=hpi_config,
         )
         return pipeline
 

paddlex/inference/pipelines/components/__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.
@@ -12,12 +12,18 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from .common import CVResult, BaseResult
-from .common import SortQuadBoxes, SortPolyBoxes
-from .common import CropByPolys, CropByBoxes
-from .common import convert_points_to_boxes
-from .utils.mixin import HtmlMixin, XlsxMixin
 from .chat_server.base import BaseChat
-from .retriever.base import BaseRetriever
-from .prompt_engineering.base import BaseGeneratePrompt
+from .common import (
+    BaseResult,
+    CropByBoxes,
+    CropByPolys,
+    CVResult,
+    SortPolyBoxes,
+    SortQuadBoxes,
+    convert_points_to_boxes,
+    rotate_image,
+)
 from .faisser import FaissBuilder, FaissIndexer, IndexData
+from .prompt_engineering.base import BaseGeneratePrompt
+from .retriever.base import BaseRetriever
+from .utils.mixin import HtmlMixin, XlsxMixin

paddlex/inference/pipelines/components/chat_server/__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/components/chat_server/base.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,7 @@
 # limitations under the License.
 
 from abc import ABC, abstractmethod
-import inspect
+
 from .....utils.subclass_register import AutoRegisterABCMetaClass