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

paddlex/inference/pipelines/__init__.py

@@ -0,0 +1,228 @@
+# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+#
+# 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
+from importlib import import_module
+from .base import BasePipeline
+from ..utils.pp_option import PaddlePredictorOption
+from .components import BaseChat, BaseRetriever, BaseGeneratePrompt
+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 .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 .instance_segmentation import InstanceSegmentationPipeline
+from .small_object_detection import SmallObjectDetectionPipeline
+from .rotated_object_detection import RotatedObjectDetectionPipeline
+from .keypoint_detection import KeypointDetectionPipeline
+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")
+
+
+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: bool = False,
+    *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 (bool, optional): Whether to use high-performance inference
+            plugin (HPIP) for prediction. Defaults to False.
+        *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"],
+            )
+    pipeline_name = config["pipeline_name"]
+
+    pipeline = BasePipeline.get(pipeline_name)(
+        config=config,
+        device=device,
+        pp_option=pp_option,
+        use_hpip=use_hpip,
+        *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/anomaly_detection/__init__.py

@@ -0,0 +1,15 @@
+# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+#
+# 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,62 @@
+# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Any, Dict, Optional, Union, List
+import numpy as np
+
+from ...utils.pp_option import PaddlePredictorOption
+from ..base import BasePipeline
+
+from ...models.anomaly_detection.result import UadResult
+
+
+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,
+    ) -> 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 high-performance inference (hpip) for prediction. Defaults to False.
+        """
+
+        super().__init__(device=device, pp_option=pp_option, use_hpip=use_hpip)
+
+        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 Reserve.
+#
+# 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,105 @@
+# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Any, Dict, Optional, Union, List
+
+import pickle
+from pathlib import Path
+import numpy as np
+
+from ...utils.pp_option import PaddlePredictorOption
+from ...common.reader import ReadImage
+from ...common.batch_sampler import ImageBatchSampler
+from ..components import CropByBoxes
+from ..base import BasePipeline
+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,
+    ):
+        super().__init__(device=device, pp_option=pp_option, use_hpip=use_hpip)
+
+        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)
+
+
+class PedestrianAttributeRecPipeline(AttributeRecPipeline):
+    entities = "pedestrian_attribute_recognition"
+
+
+class VehicleAttributeRecPipeline(AttributeRecPipeline):
+    entities = "vehicle_attribute_recognition"

paddlex/inference/pipelines/attribute_recognition/result.py

@@ -0,0 +1,100 @@
+# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+#
+# 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 os
+import cv2
+import copy
+import numpy as np
+import PIL
+from PIL import Image, ImageDraw, ImageFont
+
+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
+
+
+def draw_attribute_result(img, boxes):
+    """
+    Args:
+        img (PIL.Image.Image): PIL image
+        boxes (list): a list of dictionaries representing detection box information.
+    Returns:
+        img (PIL.Image.Image): visualized image
+    """
+    font_size = int((0.024 * int(img.width) + 2) * 0.7)
+    font = ImageFont.truetype(PINGFANG_FONT_FILE_PATH, font_size, encoding="utf-8")
+
+    draw_thickness = int(max(img.size) * 0.005)
+    draw = ImageDraw.Draw(img)
+    label2color = {}
+    catid2fontcolor = {}
+    color_list = get_colormap(rgb=True)
+
+    for i, dt in enumerate(boxes):
+        text_lines, bbox, score = dt["label"], dt["coordinate"], dt["score"]
+        if i not in label2color:
+            color_index = i % len(color_list)
+            label2color[i] = color_list[color_index]
+            catid2fontcolor[i] = font_colormap(color_index)
+        color = tuple(label2color[i]) + (255,)
+        font_color = tuple(catid2fontcolor[i])
+
+        xmin, ymin, xmax, ymax = bbox
+        # draw box
+        draw.line(
+            [(xmin, ymin), (xmin, ymax), (xmax, ymax), (xmax, ymin), (xmin, ymin)],
+            width=draw_thickness,
+            fill=color,
+        )
+        # draw label
+        current_y = ymin
+        for line in text_lines:
+            if tuple(map(int, PIL.__version__.split("."))) <= (10, 0, 0):
+                tw, th = draw.textsize(line, font=font)
+            else:
+                left, top, right, bottom = draw.textbbox((0, 0), line, font)
+                tw, th = right - left, bottom - top + 4
+
+            draw.text((5 + xmin + 1, current_y + 1), line, fill=(0, 0, 0), font=font)
+            draw.text((5 + xmin, current_y), line, fill=color, font=font)
+            current_y += th
+    return img
+
+
+class AttributeRecResult(BaseCVResult):
+
+    def _to_str(self, *args, **kwargs):
+        data = copy.deepcopy(self)
+        data.pop("input_img")
+        return JsonMixin._to_str(data, *args, **kwargs)
+
+    def _to_json(self, *args, **kwargs):
+        data = copy.deepcopy(self)
+        data.pop("input_img")
+        return JsonMixin._to_json(data, *args, **kwargs)
+
+    def _to_img(self):
+        """apply"""
+        image = Image.fromarray(cv2.cvtColor(self["input_img"], cv2.COLOR_BGR2RGB))
+        boxes = [
+            {
+                "coordinate": box["coordinate"],
+                "label": box["labels"],
+                "score": box["det_score"],
+            }
+            for box in self["boxes"]
+        ]
+        image = draw_attribute_result(image, boxes)
+        return {"res": image}

paddlex/inference/pipelines/base.py

@@ -0,0 +1,132 @@
+# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+#
+# 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
+from abc import ABC, abstractmethod
+import yaml
+import codecs
+from ...utils.subclass_register import AutoRegisterABCMetaClass
+from ..utils.pp_option import PaddlePredictorOption
+from ..models import BasePredictor
+
+
+class BasePipeline(ABC, metaclass=AutoRegisterABCMetaClass):
+    """Base class for all pipelines.
+
+    This class serves as a foundation for creating various pipelines.
+    It includes common attributes and methods that are shared among all
+    pipeline implementations.
+    """
+
+    __is_base = True
+
+    def __init__(
+        self,
+        device: str = None,
+        pp_option: PaddlePredictorOption = None,
+        use_hpip: bool = False,
+        *args,
+        **kwargs,
+    ) -> None:
+        """
+        Initializes the class with specified parameters.
+
+        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.
+        """
+        super().__init__()
+        self.device = device
+        self.pp_option = pp_option
+        self.use_hpip = use_hpip
+
+    @abstractmethod
+    def predict(self, input, **kwargs):
+        """
+        Declaration of an abstract method. Subclasses are expected to
+        provide a concrete implementation of predict.
+        Args:
+            input: The input data to predict.
+            **kwargs: Additional keyword arguments.
+        """
+        raise NotImplementedError("The method `predict` has not been implemented yet.")
+
+    def create_model(self, config: Dict, **kwargs) -> BasePredictor:
+        """
+        Create a model instance based on the given configuration.
+
+        Args:
+            config (Dict): A dictionary containing configuration settings.
+            **kwargs: The model arguments that needed to be pass.
+
+        Returns:
+            BasePredictor: An instance of the model.
+        """
+        if "model_config_error" in config:
+            raise ValueError(config["model_config_error"])
+
+        model_dir = config.get("model_dir", None)
+        hpi_params = config.get("hpi_params", None)
+
+        from .. import create_predictor
+
+        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,
+            **kwargs,
+        )
+        return model
+
+    def create_pipeline(self, config: Dict):
+        """
+        Creates a pipeline based on the provided configuration.
+
+        Args:
+            config (Dict): A dictionary containing the pipeline configuration.
+
+        Returns:
+            BasePipeline: An instance of the created pipeline.
+        """
+        if "pipeline_config_error" in config:
+            raise ValueError(config["pipeline_config_error"])
+
+        from . import create_pipeline
+
+        pipeline = create_pipeline(
+            config=config,
+            device=self.device,
+            pp_option=self.pp_option,
+            use_hpip=self.use_hpip,
+        )
+        return pipeline
+
+    def __call__(self, input, **kwargs):
+        """
+        Calls the predict method with the given input and keyword arguments.
+
+        Args:
+            input: The input data to be predicted.
+            **kwargs: Additional keyword arguments to be passed to the predict method.
+
+        Returns:
+            The prediction result from the predict method.
+        """
+        return self.predict(input, **kwargs)

paddlex/inference/pipelines/components/__init__.py

@@ -0,0 +1,23 @@
+# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+#
+# 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 .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 .faisser import FaissBuilder, FaissIndexer, IndexData