paddlex 2.1.0__py3-none-any.whl → 3.0.0__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

@@ -0,0 +1,239 @@
+# 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 pathlib import Path
+from typing import Any, Dict, Optional, Union
+
+from ...utils import logging
+from ...utils.config import parse_config
+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]:
+    """
+    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(
+                f"The pipeline ({pipeline}) does not exist! Please use a pipeline name or a config file path!"
+            )
+    else:
+        pipeline_path = pipeline
+    config = parse_config(pipeline_path)
+    return config
+
+
+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:
+    """
+    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). 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.
+
+    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:
+        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"],
+            )
+        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,
+    )
+    return pipeline
+
+
+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,
+) -> BaseRetriever:
+    """
+    Creates a retriever instance 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:
+        BaseRetriever: An instance of a retriever class corresponding to the 'model_name' in the config.
+    """
+    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/_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

@@ -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,82 @@
+# 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 .._parallel import AutoParallelImageSimpleInferencePipeline
+from ..base import BasePipeline
+
+
+class _AnomalyDetectionPipeline(BasePipeline):
+    """Image AnomalyDetectionPipeline 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,
+    ) -> 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) 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
+        )
+
+        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)
+
+
+@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

@@ -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