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

paddlex/inference/pipelines/base.py

@@ -12,75 +12,121 @@
 # 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
-from contextvars import ContextVar, copy_context
-from typing import TypedDict, Type
-
+import yaml
+import codecs
 from ...utils.subclass_register import AutoRegisterABCMetaClass
-from ..models import create_predictor
+from ..utils.pp_option import PaddlePredictorOption
+from ..models import BasePredictor
 
-pipeline_info_list_var = ContextVar("pipeline_info_list", default=None)
 
+class BasePipeline(ABC, metaclass=AutoRegisterABCMetaClass):
+    """Base class for all pipelines.
 
-class _PipelineInfo(TypedDict):
-    cls: Type["BasePipeline"]
+    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
 
-class _PipelineMetaClass(AutoRegisterABCMetaClass):
-    def __new__(mcs, name, bases, attrs):
-        def _patch_init_func(init_func):
-            def _patched___init__(self, *args, **kwargs):
-                ctx = copy_context()
-                pipeline_info_list = [
-                    *ctx.get(pipeline_info_list_var, []),
-                    _PipelineInfo(cls=type(self)),
-                ]
-                ctx.run(pipeline_info_list_var.set, pipeline_info_list)
-                ret = ctx.run(init_func, self, *args, **kwargs)
-                return ret
+    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
 
-            return _patched___init__
+    @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
 
-        cls = super().__new__(mcs, name, bases, attrs)
-        cls.__init__ = _patch_init_func(cls.__init__)
-        return cls
+    def create_pipeline(self, config: Dict):
+        """
+        Creates a pipeline based on the provided configuration.
 
+        Args:
+            config (Dict): A dictionary containing the pipeline configuration.
 
-class BasePipeline(ABC, metaclass=_PipelineMetaClass):
-    """Base Pipeline"""
+        Returns:
+            BasePipeline: An instance of the created pipeline.
+        """
+        if "pipeline_config_error" in config:
+            raise ValueError(config["pipeline_config_error"])
 
-    __is_base = True
+        from . import create_pipeline
 
-    def __init__(self, device, predictor_kwargs={}) -> None:
-        super().__init__()
-        self._predictor_kwargs = predictor_kwargs
-        self._device = device
-
-    @abstractmethod
-    def set_predictor():
-        raise NotImplementedError(
-            "The method `set_predictor` has not been implemented yet."
+        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.
 
-    # alias the __call__() to predict()
-    def __call__(self, *args, **kwargs):
-        yield from self.predict(*args, **kwargs)
-
-    def _create(self, model=None, pipeline=None, *args, **kwargs):
-        if model:
-            return create_predictor(
-                *args,
-                model=model,
-                device=self._device,
-                **kwargs,
-                **self._predictor_kwargs
-            )
-        elif pipeline:
-            return pipeline(
-                *args,
-                device=self._device,
-                predictor_kwargs=self._predictor_kwargs,
-                **kwargs
-            )
-        else:
-            raise Exception()
+        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

paddlex/inference/pipelines/components/chat_server/__init__.py

@@ -0,0 +1,16 @@
+# 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 .base import BaseChat
+from .openai_bot_chat import OpenAIBotChat

paddlex/inference/pipelines/components/chat_server/base.py

@@ -0,0 +1,39 @@
+# 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 abc import ABC, abstractmethod
+import inspect
+from .....utils.subclass_register import AutoRegisterABCMetaClass
+
+
+class BaseChat(ABC, metaclass=AutoRegisterABCMetaClass):
+    """Base class for all chat bots. This class serves as a foundation
+    for creating various chat bots.
+    """
+
+    __is_base = True
+
+    def __init__(self) -> None:
+        """Initializes an instance of base chat."""
+        super().__init__()
+
+    @abstractmethod
+    def generate_chat_results(self):
+        """
+        Declaration of an abstract method. Subclasses are expected to
+        provide a concrete implementation of generate_chat_results.
+        """
+        raise NotImplementedError(
+            "The method `generate_chat_results` has not been implemented yet."
+        )

paddlex/inference/pipelines/components/chat_server/openai_bot_chat.py

@@ -0,0 +1,236 @@
+# 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 re
+import json
+import base64
+from typing import Dict
+from .....utils import logging
+from .base import BaseChat
+
+
+class OpenAIBotChat(BaseChat):
+    """OpenAI Bot Chat"""
+
+    entities = [
+        "openai",
+    ]
+
+    def __init__(self, config: Dict) -> None:
+        """Initializes the OpenAIBotChat with given configuration.
+
+        Args:
+            config (Dict): Configuration dictionary containing model_name, api_type, base_url, api_key, end_point.
+
+        Raises:
+            ValueError: If api_type is not one of ['openai'],
+            base_url is None for api_type is openai,
+            api_key is None for api_type is openai.
+            ValueError: If end_point is not one of ['completion', 'chat_completion'].
+        """
+        super().__init__()
+        model_name = config.get("model_name", None)
+        # compatible with historical model name
+        if model_name == "ernie-3.5":
+            model_name = "ernie-3.5-8k"
+        api_type = config.get("api_type", None)
+        api_key = config.get("api_key", None)
+        base_url = config.get("base_url", None)
+        end_point = config.get("end_point", "chat_completion")
+
+        if api_type not in ["openai"]:
+            raise ValueError("api_type must be one of ['openai']")
+
+        if api_type == "openai" and api_key is None:
+            raise ValueError("api_key cannot be empty when api_type is openai.")
+
+        if base_url is None:
+            raise ValueError("base_url cannot be empty when api_type is openai.")
+
+        if end_point not in ["completion", "chat_completion"]:
+            raise ValueError(
+                "end_point must be one of ['completion', 'chat_completion']"
+            )
+
+        try:
+            from openai import OpenAI
+        except:
+            raise Exception("openai is not installed, please install it first.")
+
+        self.client = OpenAI(base_url=base_url, api_key=api_key)
+
+        self.model_name = model_name
+        self.config = config
+
+    def generate_chat_results(
+        self,
+        prompt: str,
+        image: base64 = None,
+        temperature: float = 0.001,
+        max_retries: int = 1,
+    ) -> Dict:
+        """
+        Generate chat results using the specified model and configuration.
+
+        Args:
+            prompt (str): The user's input prompt.
+            image (base64): The user's input image for MLLM, defaults to None.
+            temperature (float, optional): The temperature parameter for llms, defaults to 0.001.
+            max_retries (int, optional): The maximum number of retries for llms API calls, defaults to 1.
+
+        Returns:
+            Dict: The chat completion result from the model.
+        """
+        llm_result = {"content": None, "reasoning_content": None}
+        try:
+            if image:
+                chat_completion = self.client.chat.completions.create(
+                    model=self.model_name,
+                    messages=[
+                        {
+                            "role": "system",
+                            # XXX: give a basic prompt for common
+                            "content": "You are a helpful assistant.",
+                        },
+                        {
+                            "role": "user",
+                            "content": [
+                                {"type": "text", "text": prompt},
+                                {
+                                    "type": "image_url",
+                                    "image_url": {
+                                        "url": f"data:image/jpeg;base64,{image}"
+                                    },
+                                },
+                            ],
+                        },
+                    ],
+                    stream=False,
+                    temperature=temperature,
+                    top_p=0.001,
+                )
+                llm_result["content"] = chat_completion.choices[0].message.content
+                return llm_result
+            elif self.config.get("end_point", "chat_completion") == "chat_completion":
+                chat_completion = self.client.chat.completions.create(
+                    model=self.model_name,
+                    messages=[
+                        {
+                            "role": "user",
+                            "content": prompt,
+                        },
+                    ],
+                    stream=False,
+                    temperature=temperature,
+                    top_p=0.001,
+                )
+                llm_result["content"] = chat_completion.choices[0].message.content
+                try:
+                    llm_result["reasoning_content"] = chat_completion.choices[
+                        0
+                    ].message.reasoning_content
+                except:
+                    pass
+                return llm_result
+            else:
+                chat_completion = self.client.completions.create(
+                    model=self.model_name,
+                    prompt=prompt,
+                    max_tokens=self.config.get("max_tokens", 1024),
+                    temperature=float(temperature),
+                    stream=False,
+                )
+                if isinstance(chat_completion, str):
+                    chat_completion = json.loads(chat_completion)
+                    llm_result = chat_completion["choices"][0]["text"]
+                else:
+                    llm_result["content"] = chat_completion.choices[0].text
+                return llm_result
+        except Exception as e:
+            logging.error(e)
+            self.ERROR_MASSAGE = "大模型调用失败"
+        return llm_result
+
+    def fix_llm_result_format(self, llm_result: str) -> dict:
+        """
+        Fix the format of the LLM result.
+
+        Args:
+            llm_result (str): The result from the LLM (Large Language Model).
+
+        Returns:
+            dict: A fixed format dictionary from the LLM result.
+        """
+        if not llm_result:
+            return {}
+
+        if "json" in llm_result or "```" in llm_result:
+            index = llm_result.find("{")
+            if index != -1:
+                llm_result = llm_result[index:]
+            index = llm_result.rfind("}")
+            if index != -1:
+                llm_result = llm_result[: index + 1]
+            llm_result = (
+                llm_result.replace("```", "").replace("json", "").replace("/n", "")
+            )
+            llm_result = llm_result.replace("[", "").replace("]", "")
+
+        try:
+            llm_result = json.loads(llm_result)
+            llm_result_final = {}
+            if "问题" in llm_result.keys() and "答案" in llm_result.keys():
+                key = llm_result["问题"]
+                value = llm_result["答案"]
+                if isinstance(value, list):
+                    if len(value) > 0:
+                        llm_result_final[key] = value[0].strip(f"{key}:").strip(key)
+                else:
+                    llm_result_final[key] = value.strip(f"{key}:").strip(key)
+                return llm_result_final
+            for key in llm_result:
+                value = llm_result[key]
+                if isinstance(value, list):
+                    if len(value) > 0:
+                        llm_result_final[key] = value[0]
+                else:
+                    llm_result_final[key] = value
+            return llm_result_final
+
+        except:
+            results = (
+                llm_result.replace("\n", "")
+                .replace("    ", "")
+                .replace("{", "")
+                .replace("}", "")
+            )
+            if not results.endswith('"'):
+                results = results + '"'
+            pattern = r'"(.*?)": "([^"]*)"'
+            matches = re.findall(pattern, str(results))
+            if len(matches) > 0:
+                llm_result = {k: v for k, v in matches}
+                if "问题" in llm_result.keys() and "答案" in llm_result.keys():
+                    llm_result_final = {}
+                    key = llm_result["问题"]
+                    value = llm_result["答案"]
+                    if isinstance(value, list):
+                        if len(value) > 0:
+                            llm_result_final[key] = value[0].strip(f"{key}:").strip(key)
+                    else:
+                        llm_result_final[key] = value.strip(f"{key}:").strip(key)
+                    return llm_result_final
+                return llm_result
+            else:
+                return {}

paddlex/inference/pipelines/components/common/__init__.py

@@ -0,0 +1,18 @@
+# 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 .base_result import CVResult, BaseResult
+from .sort_boxes import SortQuadBoxes, SortPolyBoxes
+from .crop_image_regions import CropByPolys, CropByBoxes
+from .convert_points_and_boxes import convert_points_to_boxes

paddlex/inference/pipelines/components/common/base_operator.py

@@ -0,0 +1,36 @@
+# 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 abc import ABC, abstractmethod
+from .....utils.subclass_register import AutoRegisterABCMetaClass
+
+
+class BaseOperator(ABC, metaclass=AutoRegisterABCMetaClass):
+    """Base Operator"""
+
+    __is_base = True
+
+    def __init__(self):
+        """Initializes an instance of base operator."""
+        super().__init__()
+
+    @abstractmethod
+    def __call__(self):
+        """
+        Declaration of an abstract method. Subclasses are expected to
+        provide a concrete implementation of call method.
+        """
+        raise NotImplementedError(
+            "The component method `__call__` has not been implemented yet."
+        )

paddlex/inference/pipelines/components/common/base_result.py

@@ -0,0 +1,65 @@
+# 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 inspect
+from typing import Dict
+from ....utils.io import ImageReader, ImageWriter
+from ..utils.mixin import JsonMixin, ImgMixin, StrMixin
+
+
+class BaseResult(dict, StrMixin, JsonMixin):
+    """Base Result"""
+
+    def __init__(self, data: Dict) -> None:
+        """Initializes the instance with the provided data.
+
+        Args:
+            data (Dict): The data to initialize the instance with.
+        """
+        super().__init__(data)
+        self._show_funcs = []
+        StrMixin.__init__(self)
+        JsonMixin.__init__(self)
+
+    def save_all(self, save_path: str) -> None:
+        """
+        Save all show functions to the specified path if they accept a save_path argument.
+
+        Args:
+            save_path (str): The path to save the functions' output.
+
+        Returns:
+            None
+        """
+        for func in self._show_funcs:
+            signature = inspect.signature(func)
+            if "save_path" in signature.parameters:
+                func(save_path=save_path)
+            else:
+                func()
+
+
+class CVResult(BaseResult, ImgMixin):
+    """Result For Computer Vision Tasks"""
+
+    def __init__(self, data: Dict) -> None:
+        """Initializes the instance with the given data and sets up image processing with the 'pillow' backend.
+
+        Args:
+            data (Dict): The data to initialize the instance with.
+        """
+        super().__init__(data)
+        ImgMixin.__init__(self, "pillow")
+        self._img_reader = ImageReader(backend="pillow")
+        self._img_writer = ImageWriter(backend="pillow")

paddlex/inference/pipelines/components/common/convert_points_and_boxes.py

@@ -0,0 +1,46 @@
+# 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.
+
+__all__ = ["convert_points_to_boxes"]
+
+import numpy as np
+import copy
+
+
+def convert_points_to_boxes(dt_polys: list) -> np.ndarray:
+    """
+    Converts a list of polygons to a numpy array of bounding boxes.
+
+    Args:
+        dt_polys (list): A list of polygons, where each polygon is represented
+                        as a list of (x, y) points.
+
+    Returns:
+        np.ndarray: A numpy array of bounding boxes, where each box is represented
+                    as [left, top, right, bottom].
+                    If the input list is empty, returns an empty numpy array.
+    """
+
+    if len(dt_polys) > 0:
+        dt_polys_tmp = dt_polys.copy()
+        dt_polys_tmp = np.array(dt_polys_tmp)
+        boxes_left = np.min(dt_polys_tmp[:, :, 0], axis=1)
+        boxes_right = np.max(dt_polys_tmp[:, :, 0], axis=1)
+        boxes_top = np.min(dt_polys_tmp[:, :, 1], axis=1)
+        boxes_bottom = np.max(dt_polys_tmp[:, :, 1], axis=1)
+        dt_boxes = np.array([boxes_left, boxes_top, boxes_right, boxes_bottom])
+        dt_boxes = dt_boxes.T
+    else:
+        dt_boxes = np.array([])
+    return dt_boxes