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

paddlex/inference/pipelines/attribute_recognition/result.py

@@ -0,0 +1,102 @@
+# 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 copy
+
+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 BaseCVResult, JsonMixin
+from ...utils.color_map import font_colormap, get_colormap
+
+if is_dep_available("opencv-contrib-python"):
+    import cv2
+
+
+def draw_attribute_result(img, boxes):
+    """
+    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,)
+        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_requires_deps("opencv-contrib-python")
+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

@@ -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,74 +13,140 @@
 # limitations under the License.
 
 from abc import ABC, abstractmethod
-from contextvars import ContextVar, copy_context
-from typing import TypedDict, Type
+from typing import Any, Dict, Optional, Union
 
+from ...utils import logging
 from ...utils.subclass_register import AutoRegisterABCMetaClass
-from ..models import create_predictor
+from ..models import BasePredictor
+from ..utils.hpi import HPIConfig
+from ..utils.pp_option import PaddlePredictorOption
 
-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"]
-
-
-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
-
-            return _patched___init__
-
-        cls = super().__new__(mcs, name, bases, attrs)
-        cls.__init__ = _patch_init_func(cls.__init__)
-        return cls
-
-
-class BasePipeline(ABC, metaclass=_PipelineMetaClass):
-    """Base Pipeline"""
+    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, predictor_kwargs={}) -> None:
+    def __init__(
+        self,
+        device: str = None,
+        pp_option: PaddlePredictorOption = None,
+        use_hpip: bool = False,
+        hpi_config: Optional[Union[Dict[str, Any], HPIConfig]] = None,
+        *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 the high-performance
+                inference plugin (HPIP). Defaults to False.
+            hpi_config (Optional[Union[Dict[str, Any], HPIConfig]], optional):
+                The high-performance inference configuration dictionary.
+                Defaults to None.
+        """
         super().__init__()
-        self._predictor_kwargs = predictor_kwargs
-        self._device = device
+        self.device = device
+        self.pp_option = pp_option
+        self.use_hpip = use_hpip
+        self.hpi_config = hpi_config
 
     @abstractmethod
-    def set_predictor():
-        raise NotImplementedError(
-            "The method `set_predictor` has not been implemented yet."
+    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)
+        # Should we log if the actual parameter to use is different from the default?
+        use_hpip = config.get("use_hpip", self.use_hpip)
+        hpi_config = config.get("hpi_config", None)
+        if self.hpi_config is not None:
+            hpi_config = hpi_config or {}
+            hpi_config = {**self.hpi_config, **hpi_config}
+
+        from .. import create_predictor
+
+        logging.info("Creating model: %s", (config["model_name"], model_dir))
+
+        model = create_predictor(
+            model_name=config["model_name"],
+            model_dir=model_dir,
+            device=self.device,
+            batch_size=config.get("batch_size", 1),
+            pp_option=self.pp_option,
+            use_hpip=use_hpip,
+            hpi_config=hpi_config,
+            **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
+
+        use_hpip = config.get("use_hpip", self.use_hpip)
+        hpi_config = config.get("hpi_config", None)
+        if self.hpi_config is not None:
+            hpi_config = hpi_config or {}
+            hpi_config = {**self.hpi_config, **hpi_config}
+
+        pipeline = create_pipeline(
+            config=config,
+            device=self.device,
+            pp_option=self.pp_option,
+            use_hpip=use_hpip,
+            hpi_config=hpi_config,
         )
+        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,29 @@
+# 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 .chat_server.base import BaseChat
+from .common import (
+    BaseResult,
+    CropByBoxes,
+    CropByPolys,
+    CVResult,
+    SortPolyBoxes,
+    SortQuadBoxes,
+    convert_points_to_boxes,
+    rotate_image,
+)
+from .faisser import FaissBuilder, FaissIndexer, IndexData
+from .prompt_engineering.base import BaseGeneratePrompt
+from .retriever.base import BaseRetriever
+from .utils.mixin import HtmlMixin, XlsxMixin

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

@@ -0,0 +1,16 @@
+# 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 .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 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 abc import ABC, abstractmethod
+
+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 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 base64
+import json
+import re
+from typing import Dict
+
+from .....utils import logging
+from .....utils.deps import class_requires_deps
+from .base import BaseChat
+
+
+@class_requires_deps("openai")
+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'].
+        """
+        from openai import OpenAI
+
+        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']"
+            )
+
+        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,19 @@
+# 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 .base_result import BaseResult, CVResult
+from .convert_points_and_boxes import convert_points_to_boxes
+from .crop_image_regions import CropByBoxes, CropByPolys
+from .sort_boxes import SortPolyBoxes, SortQuadBoxes
+from .warp_image import rotate_image

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

@@ -0,0 +1,37 @@
+# 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 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."
+        )