paddlex 3.0.0b2__py3-none-any.whl → 3.0.0rc1__py3-none-any.whl

paddlex/inference/models/video_detection/result.py

@@ -0,0 +1,109 @@
+# 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.
+
+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
+
+if is_dep_available("opencv-contrib-python"):
+    import cv2
+
+
+@class_requires_deps("opencv-contrib-python")
+class DetVideoResult(BaseVideoResult):
+
+    def _to_video(self):
+        """Draw label on image"""
+        video_reader = VideoReader(backend="decord")
+        video = video_reader.read(self["input_path"])
+        video = list(video)
+        write_fps = video_reader.get_fps()
+        label2color = {}
+        catid2fontcolor = {}
+        color_list = get_colormap(rgb=True)
+        video_list = []
+
+        for i in range(len(video)):
+            image = Image.fromarray(video[i].asnumpy())
+            image.size
+            font_size = int(0.018 * int(image.width)) + 2
+            font = ImageFont.truetype(
+                PINGFANG_FONT_FILE_PATH, font_size, encoding="utf-8"
+            )
+            draw_thickness = int(max(image.size) * 0.002)
+            draw = ImageDraw.Draw(image)
+            results = self["result"][i]
+            for result in results:
+                bbox, score, class_name = result
+                if class_name not in label2color:
+                    random_index = random.randint(0, len(color_list) - 1)
+                    label2color[class_name] = color_list[random_index]
+                    catid2fontcolor[class_name] = self._get_font_colormap(random_index)
+                color = tuple(label2color[class_name])
+                font_color = tuple(catid2fontcolor[class_name])
+                xmin, ymin, xmax, ymax = bbox
+                rectangle = [
+                    (xmin, ymin),
+                    (xmin, ymax),
+                    (xmax, ymax),
+                    (xmax, ymin),
+                    (xmin, ymin),
+                ]
+                draw.line(
+                    rectangle,
+                    width=draw_thickness,
+                    fill=color,
+                )
+                text = "{} {:.2f}".format(class_name, score)
+                if tuple(map(int, PIL.__version__.split("."))) <= (10, 0, 0):
+                    tw, th = draw.textsize(text, font=font)
+                else:
+                    left, top, right, bottom = draw.textbbox((0, 0), text, font)
+                    tw, th = right - left, bottom - top + 4
+                if ymin < th:
+                    draw.rectangle(
+                        [(xmin, ymin), (xmin + tw + 4, ymin + th + 1)], fill=color
+                    )
+                    draw.text((xmin + 2, ymin - 2), text, fill=font_color, font=font)
+                else:
+                    draw.rectangle(
+                        [(xmin, ymin - th), (xmin + tw + 4, ymin + 1)], fill=color
+                    )
+                    draw.text(
+                        (xmin + 2, ymin - th - 2), text, fill=font_color, font=font
+                    )
+
+            image = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2BGR)
+            video_list.append(image)
+        return {"res": (np.array(video_list), write_fps)}
+
+    def _get_font_colormap(self, color_index):
+        """
+        Get font colormap
+        """
+        dark = np.array([0x14, 0x0E, 0x35])
+        light = np.array([0xFF, 0xFF, 0xFF])
+        light_indexs = [0, 3, 4, 8, 9, 13, 14, 18, 19]
+        if color_index in light_indexs:
+            return light.astype("int32")
+        else:
+            return dark.astype("int32")

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,40 +13,82 @@
 # limitations under the License.
 
 from pathlib import Path
-from typing import Any, Dict, Optional
+from typing import Any, Dict, Optional, Union
 
+from ...utils import logging
 from ...utils.config import parse_config
-from ..utils.get_pipeline_path import get_pipeline_path
-from .base import BasePipeline
-from .single_model_pipeline import (
-    _SingleModelPipeline,
-    ImageClassification,
-    ObjectDetection,
-    InstanceSegmentation,
-    SemanticSegmentation,
-    TSFc,
-    TSAd,
-    TSCls,
-    MultiLableImageClas,
-    SmallObjDet,
-    AnomalyDetection,
-)
-from .ocr import OCRPipeline
-from .formula_recognition import FormulaRecognitionPipeline
-from .table_recognition import TableRecPipeline
-from .face_recognition import FaceRecPipeline
-from .seal_recognition import SealOCRPipeline
-from .ppchatocrv3 import PPChatOCRPipeline
-from .layout_parsing import LayoutParsingPipeline
-from .pp_shitu_v2 import ShiTuV2Pipeline
+from ..utils.hpi import HPIConfig
+from ..utils.pp_option import PaddlePredictorOption
+from .anomaly_detection import AnomalyDetectionPipeline
 from .attribute_recognition import (
     PedestrianAttributeRecPipeline,
     VehicleAttributeRecPipeline,
 )
+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 .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
+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:
+    """
+    Get the full path of the pipeline configuration file based on the provided pipeline name.
+
+    Args:
+        pipeline_name (str): The name of the pipeline.
+
+    Returns:
+        str: The full path to the pipeline configuration file or None if not found.
+    """
+    pipeline_path = (
+        Path(__file__).parent.parent.parent
+        / "configs/pipelines"
+        / f"{pipeline_name}.yaml"
+    ).resolve()
+    if not Path(pipeline_path).exists():
+        return None
+    return pipeline_path
 
 
 def load_pipeline_config(pipeline: str) -> Dict[str, Any]:
-    if not Path(pipeline).exists():
+    """
+    Load the pipeline configuration.
+
+    Args:
+        pipeline (str): The name of the pipeline or the path to the config file.
+
+    Returns:
+        Dict[str, Any]: The parsed pipeline configuration.
+
+    Raises:
+        Exception: If the config file of pipeline does not exist.
+    """
+    if not (pipeline.endswith(".yml") or pipeline.endswith(".yaml")):
         pipeline_path = get_pipeline_path(pipeline)
         if pipeline_path is None:
             raise Exception(
@@ -58,70 +100,136 @@ def load_pipeline_config(pipeline: str) -> Dict[str, Any]:
     return config
 
 
-def create_pipeline_from_config(
-    config: Dict[str, Any],
-    device=None,
-    pp_option=None,
-    use_hpip: bool = False,
-    hpi_params: Optional[Dict[str, Any]] = None,
-    *args,
-    **kwargs,
+def create_pipeline(
+    pipeline: Optional[str] = None,
+    config: Optional[Dict[str, Any]] = None,
+    device: Optional[str] = None,
+    pp_option: Optional[PaddlePredictorOption] = None,
+    use_hpip: Optional[bool] = None,
+    hpi_config: Optional[Union[Dict[str, Any], HPIConfig]] = None,
+    *args: Any,
+    **kwargs: Any,
 ) -> BasePipeline:
-    pipeline_name = config["Global"]["pipeline_name"]
-    pipeline_setting = config["Pipeline"]
-
-    predictor_kwargs = {"use_hpip": use_hpip}
-    if "use_hpip" in pipeline_setting:
-        predictor_kwargs["use_hpip"] = use_hpip
-    if hpi_params is not None:
-        predictor_kwargs["hpi_params"] = hpi_params
-        pipeline_setting.pop("hpi_params", None)
-    elif "hpi_params" in pipeline_setting:
-        predictor_kwargs["hpi_params"] = pipeline_setting.pop("hpi_params")
-
-    if pp_option is not None:
-        predictor_kwargs["pp_option"] = pp_option
-        pipeline_setting.pop("pp_option", None)
-    elif "pp_option" in pipeline_setting:
-        predictor_kwargs["pp_option"] = pipeline_setting.pop("pp_option")
-
-    if device:
-        pipeline_setting.pop("device", None)
+    """
+    Create a pipeline instance based on the provided parameters.
+
+    If the input parameter config is not provided, it is obtained from the
+    default config corresponding to the pipeline name.
+
+    Args:
+        pipeline (Optional[str], optional): The name of the pipeline to
+            create, or the path to the config file. Defaults to None.
+        config (Optional[Dict[str, Any]], optional): The pipeline configuration.
+            Defaults to None.
+        device (Optional[str], optional): The device to run the pipeline on.
+            Defaults to None.
+        pp_option (Optional[PaddlePredictorOption], optional): The options for
+            the PaddlePredictor. Defaults to None.
+        use_hpip (Optional[bool], optional): Whether to use the high-performance
+            inference plugin (HPIP). Defaults to None.
+        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.
+
+    Returns:
+        BasePipeline: The created pipeline instance.
+    """
+    if pipeline is None and config is None:
+        raise ValueError(
+            "Both `pipeline` and `config` cannot be None at the same time."
+        )
+    if config is None:
+        config = load_pipeline_config(pipeline)
     else:
-        device = pipeline_setting.pop("device", None)
+        if pipeline is not None and config["pipeline_name"] != pipeline:
+            logging.warning(
+                "The pipeline name in the config (%r) is different from the specified pipeline name (%r). %r will be used.",
+                config["pipeline_name"],
+                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_setting.update(kwargs)
     pipeline = BasePipeline.get(pipeline_name)(
-        device=device, predictor_kwargs=predictor_kwargs, *args, **pipeline_setting
+        config=config,
+        device=device,
+        pp_option=pp_option,
+        use_hpip=use_hpip,
+        hpi_config=hpi_config,
+        *args,
+        **kwargs,
     )
-
     return pipeline
 
 
-def create_pipeline(
-    pipeline: str,
-    device=None,
-    pp_option=None,
-    use_hpip: bool = False,
-    hpi_params: Optional[Dict[str, Any]] = None,
+def create_chat_bot(config: Dict, *args, **kwargs) -> BaseChat:
+    """Creates an instance of a chat bot based on the provided configuration.
+
+    Args:
+        config (Dict): Configuration settings, expected to be a dictionary with at least a 'model_name' key.
+        *args: Additional positional arguments. Not used in this function but allowed for future compatibility.
+        **kwargs: Additional keyword arguments. Not used in this function but allowed for future compatibility.
+
+    Returns:
+        BaseChat: An instance of the chat bot class corresponding to the 'model_name' in the config.
+    """
+    if "chat_bot_config_error" in config:
+        raise ValueError(config["chat_bot_config_error"])
+
+    api_type = config["api_type"]
+    chat_bot = BaseChat.get(api_type)(config)
+    return chat_bot
+
+
+def create_retriever(
+    config: Dict,
     *args,
     **kwargs,
-) -> BasePipeline:
-    """build model evaluater
+) -> BaseRetriever:
+    """
+    Creates a retriever instance based on the provided configuration.
 
     Args:
-        pipeline (str): the pipeline name, that is name of pipeline class
+        config (Dict): Configuration settings, expected to be a dictionary with at least a 'model_name' key.
+        *args: Additional positional arguments. Not used in this function but allowed for future compatibility.
+        **kwargs: Additional keyword arguments. Not used in this function but allowed for future compatibility.
 
     Returns:
-        BasePipeline: the pipeline, which is subclass of BasePipeline.
+        BaseRetriever: An instance of a retriever class corresponding to the 'model_name' in the config.
     """
-    config = load_pipeline_config(pipeline)
-    return create_pipeline_from_config(
-        config,
-        device=device,
-        pp_option=pp_option,
-        use_hpip=use_hpip,
-        hpi_params=hpi_params,
-        *args,
-        **kwargs,
-    )
+    if "retriever_config_error" in config:
+        raise ValueError(config["retriever_config_error"])
+    api_type = config["api_type"]
+    retriever = BaseRetriever.get(api_type)(config)
+    return retriever
+
+
+def create_prompt_engineering(
+    config: Dict,
+    *args,
+    **kwargs,
+) -> BaseGeneratePrompt:
+    """
+    Creates a prompt engineering instance based on the provided configuration.
+
+    Args:
+        config (Dict): Configuration settings, expected to be a dictionary with at least a 'task_type' key.
+        *args: Variable length argument list for additional positional arguments.
+        **kwargs: Arbitrary keyword arguments.
+
+    Returns:
+        BaseGeneratePrompt: An instance of a prompt engineering class corresponding to the 'task_type' in the config.
+    """
+    if "pe_config_error" in config:
+        raise ValueError(config["pe_config_error"])
+    task_type = config["task_type"]
+    pe = BaseGeneratePrompt.get(task_type)(config)
+    return pe

paddlex/inference/pipelines/anomaly_detection/__init__.py

@@ -0,0 +1,15 @@
+# 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 .pipeline import AnomalyDetectionPipeline

paddlex/inference/pipelines/anomaly_detection/pipeline.py

@@ -0,0 +1,72 @@
+# 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, 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
+
+
+@pipeline_requires_extra("cv")
+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.
+
+        Args:
+            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 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, hpi_config=hpi_config
+        )
+
+        anomaly_detetion_model_config = config["SubModules"]["AnomalyDetection"]
+        self.anomaly_detetion_model = self.create_model(anomaly_detetion_model_config)
+
+    def predict(
+        self, input: Union[str, List[str], np.ndarray, List[np.ndarray]], **kwargs
+    ) -> UadResult:
+        """Predicts anomaly detection results for the given input.
+
+        Args:
+            input (Union[str, list[str], np.ndarray, list[np.ndarray]]): The input image(s) or path(s) to the images.
+            **kwargs: Additional keyword arguments that can be passed to the function.
+
+        Returns:
+            UadResult: The predicted anomaly results.
+        """
+        yield from self.anomaly_detetion_model(input)

paddlex/inference/pipelines/attribute_recognition/__init__.py

@@ -0,0 +1,15 @@
+# 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 .pipeline import PedestrianAttributeRecPipeline, VehicleAttributeRecPipeline

paddlex/inference/pipelines/attribute_recognition/pipeline.py

@@ -0,0 +1,110 @@
+# 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, List, Optional, Union
+
+import numpy as np
+
+from ....utils.deps import pipeline_requires_extra
+from ...common.batch_sampler import ImageBatchSampler
+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
+
+
+class AttributeRecPipeline(BasePipeline):
+    """Attribute Rec Pipeline"""
+
+    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,
+    ):
+        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"])
+        self._crop_by_boxes = CropByBoxes()
+        self._img_reader = ReadImage(format="BGR")
+
+        self.det_threshold = config["SubModules"]["Detection"].get("threshold", 0.5)
+        self.cls_threshold = config["SubModules"]["Classification"].get(
+            "threshold", 0.7
+        )
+
+        self.batch_sampler = ImageBatchSampler(
+            batch_size=config["SubModules"]["Detection"]["batch_size"]
+        )
+        self.img_reader = ReadImage(format="BGR")
+
+    def predict(
+        self,
+        input: Union[str, List[str], np.ndarray, List[np.ndarray]],
+        det_threshold: float = None,
+        cls_threshold: Union[float, dict, list, None] = None,
+        **kwargs
+    ):
+        det_threshold = self.det_threshold if det_threshold is None else det_threshold
+        cls_threshold = self.cls_threshold if cls_threshold is None else cls_threshold
+        for img_id, batch_data in enumerate(self.batch_sampler(input)):
+            raw_imgs = self.img_reader(batch_data.instances)
+            all_det_res = list(self.det_model(raw_imgs, threshold=det_threshold))
+            for input_path, input_data, raw_img, det_res in zip(
+                batch_data.input_paths, batch_data.instances, raw_imgs, all_det_res
+            ):
+                cls_res = self.get_cls_result(raw_img, det_res, cls_threshold)
+                yield self.get_final_result(input_path, raw_img, det_res, cls_res)
+
+    def get_cls_result(self, raw_img, det_res, cls_threshold):
+        subs_of_img = list(self._crop_by_boxes(raw_img, det_res["boxes"]))
+        img_list = [img["img"] for img in subs_of_img]
+        all_cls_res = list(self.cls_model(img_list, threshold=cls_threshold))
+        output = {"label": [], "score": []}
+        for res in all_cls_res:
+            output["label"].append(res["label_names"])
+            output["score"].append(res["scores"])
+        return output
+
+    def get_final_result(self, input_path, raw_img, det_res, rec_res):
+        single_img_res = {"input_path": input_path, "input_img": raw_img, "boxes": []}
+        for i, obj in enumerate(det_res["boxes"]):
+            cls_scores = rec_res["score"][i]
+            labels = rec_res["label"][i]
+            single_img_res["boxes"].append(
+                {
+                    "labels": labels,
+                    "cls_scores": cls_scores,
+                    "det_score": obj["score"],
+                    "coordinate": obj["coordinate"],
+                }
+            )
+        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"