paddlex 2.0.0rc4__py3-none-any.whl → 3.0.0b2__py3-none-any.whl

paddlex/inference/components/llm/erniebot.py

@@ -0,0 +1,212 @@
+# 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 time
+import json
+import erniebot
+
+from pathlib import Path
+from .base import BaseLLM
+from ....utils import logging
+from ....utils.func_register import FuncRegister
+
+from langchain.docstore.document import Document
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+
+from langchain_community.embeddings import QianfanEmbeddingsEndpoint
+from langchain_community.vectorstores import FAISS
+from langchain_community import vectorstores
+from erniebot_agent.extensions.langchain.embeddings import ErnieEmbeddings
+
+__all__ = ["ErnieBot"]
+
+
+class ErnieBot(BaseLLM):
+
+    INPUT_KEYS = ["prompts"]
+    OUTPUT_KEYS = ["cls_res"]
+    DEAULT_INPUTS = {"prompts": "prompts"}
+    DEAULT_OUTPUTS = {"cls_pred": "cls_pred"}
+    API_TYPE = "aistudio"
+
+    entities = [
+        "ernie-4.0",
+        "ernie-3.5",
+        "ernie-3.5-8k",
+        "ernie-lite",
+        "ernie-tiny-8k",
+        "ernie-speed",
+        "ernie-speed-128k",
+        "ernie-char-8k",
+    ]
+
+    _FUNC_MAP = {}
+    register = FuncRegister(_FUNC_MAP)
+
+    def __init__(self, model_name="ernie-4.0", params={}):
+        super().__init__()
+        access_token = params.get("access_token")
+        ak = params.get("ak")
+        sk = params.get("sk")
+        api_type = params.get("api_type")
+        max_retries = params.get("max_retries")
+        assert model_name in self.entities, f"model_name must be in {self.entities}"
+        assert any([access_token, ak, sk]), "access_token or ak and sk must be set"
+        self.model_name = model_name
+        self.config = {
+            "api_type": api_type,
+            "max_retries": max_retries,
+        }
+        if access_token:
+            self.config["access_token"] = access_token
+        else:
+            self.config["ak"] = ak
+            self.config["sk"] = sk
+
+    def pred(self, prompt, temperature=0.001):
+        """
+        llm predict
+        """
+        try:
+            chat_completion = erniebot.ChatCompletion.create(
+                _config_=self.config,
+                model=self.model_name,
+                messages=[{"role": "user", "content": prompt}],
+                temperature=float(temperature),
+            )
+            llm_result = chat_completion.get_result()
+            return llm_result
+        except Exception as e:
+            if len(e.args) < 1:
+                self.ERROR_MASSAGE = (
+                    "当前选择后端为AI Studio，千帆调用失败，请检查token"
+                )
+            elif (
+                e.args[-1]
+                == "暂无权限使用，请在 AI Studio 正确获取访问令牌(access token)使用"
+            ):
+                self.ERROR_MASSAGE = (
+                    "当前选择后端为AI Studio，请正确获取访问令牌(access token)使用"
+                )
+            elif e.args[-1] == "the max length of current question is 4800":
+                self.ERROR_MASSAGE = "大模型调用失败"
+            else:
+                logging.error(e)
+                self.ERROR_MASSAGE = "大模型调用失败"
+        return None
+
+    def get_vector(
+        self,
+        ocr_result,
+        sleep_time=0.5,
+        block_size=300,
+        separators=["\t", "\n", "。", "\n\n", ""],
+    ):
+        """get summary prompt"""
+
+        all_items = []
+        for i, ocr_res in enumerate(ocr_result):
+            for type, text in ocr_res.items():
+                all_items += [f"第{i}页{type}：{text}"]
+
+        text_splitter = RecursiveCharacterTextSplitter(
+            chunk_size=block_size, chunk_overlap=20, separators=separators
+        )
+        texts = text_splitter.split_text("\t".join(all_items))
+
+        all_splits = [Document(page_content=text) for text in texts]
+
+        api_type = self.config["api_type"]
+        if api_type == "qianfan":
+            os.environ["QIANFAN_AK"] = os.environ.get("EB_AK", self.config["ak"])
+            os.environ["QIANFAN_SK"] = os.environ.get("EB_SK", self.config["sk"])
+            user_ak = os.environ.get("EB_AK", self.config["ak"])
+            user_id = hash(user_ak)
+            vectorstore = FAISS.from_documents(
+                documents=all_splits, embedding=QianfanEmbeddingsEndpoint()
+            )
+
+        elif api_type == "aistudio":
+            token = self.config["access_token"]
+            vectorstore = FAISS.from_documents(
+                documents=all_splits[0:1],
+                embedding=ErnieEmbeddings(aistudio_access_token=token),
+            )
+
+            #### ErnieEmbeddings.chunk_size = 16
+            step = min(16, len(all_splits) - 1)
+            for shot_splits in [
+                all_splits[i : i + step] for i in range(1, len(all_splits), step)
+            ]:
+                time.sleep(sleep_time)
+                vectorstore_slice = FAISS.from_documents(
+                    documents=shot_splits,
+                    embedding=ErnieEmbeddings(aistudio_access_token=token),
+                )
+                vectorstore.merge_from(vectorstore_slice)
+        else:
+            raise ValueError(f"Unsupported api_type: {api_type}")
+
+        vectorstore = self.encode_vector_store(vectorstore.serialize_to_bytes())
+        return vectorstore
+
+    def caculate_similar(self, vector, key_list, llm_params=None, sleep_time=0.5):
+        """caculate similar with key and doc"""
+        if not self.is_vector_store(vector):
+            logging.warning(
+                "The retrieved vectorstore is not for PaddleX and will return the visual results of the query image"
+            )
+            return vector
+        # XXX: The initialization parameters are hard-coded.
+        if llm_params:
+            api_type = llm_params.get("api_type")
+            access_token = llm_params.get("access_token")
+            ak = llm_params.get("ak")
+            sk = llm_params.get("sk")
+        else:
+            api_type = self.config["api_type"]
+            access_token = self.config.get("access_token")
+            ak = self.config.get("ak")
+            sk = self.config.get("sk")
+        if api_type == "aistudio":
+            embeddings = ErnieEmbeddings(aistudio_access_token=access_token)
+        elif api_type == "qianfan":
+            embeddings = QianfanEmbeddingsEndpoint(qianfan_ak=ak, qianfan_sk=sk)
+        else:
+            raise ValueError(f"Unsupported api_type: {api_type}")
+
+        vectorstore = vectorstores.FAISS.deserialize_from_bytes(
+            self.decode_vector_store(vector), embeddings
+        )
+
+        # 根据提问匹配上下文
+        Q = []
+        C = []
+        for key in key_list:
+            QUESTION = f"抽取关键信息:{key}"
+            # c_str = ""
+            Q.append(QUESTION)
+            time.sleep(sleep_time)
+            docs = vectorstore.similarity_search_with_relevance_scores(QUESTION, k=2)
+            context = [(document.page_content, score) for document, score in docs]
+            context = sorted(context, key=lambda x: x[1])
+            C.extend([x[0] for x in context[::-1]])
+
+        C = list(set(C))
+        all_C = " ".join(C)
+
+        summary_prompt = all_C
+
+        return summary_prompt

paddlex/inference/components/paddle_predictor/__init__.py

@@ -0,0 +1,20 @@
+# 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 .predictor import (
+    BasePaddlePredictor,
+    ImagePredictor,
+    ImageDetPredictor,
+    TSPPPredictor,
+)

paddlex/inference/components/paddle_predictor/predictor.py

@@ -0,0 +1,332 @@
+# 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
+from abc import abstractmethod
+import lazy_paddle as paddle
+import numpy as np
+
+from ....utils.flags import FLAGS_json_format_model
+from ....utils import logging
+from ...utils.pp_option import PaddlePredictorOption
+from ..base import BaseComponent
+
+
+class Copy2GPU(BaseComponent):
+
+    def __init__(self, input_handlers):
+        super().__init__()
+        self.input_handlers = input_handlers
+
+    def apply(self, x):
+        for idx in range(len(x)):
+            self.input_handlers[idx].reshape(x[idx].shape)
+            self.input_handlers[idx].copy_from_cpu(x[idx])
+
+
+class Copy2CPU(BaseComponent):
+
+    def __init__(self, output_handlers):
+        super().__init__()
+        self.output_handlers = output_handlers
+
+    def apply(self):
+        output = []
+        for out_tensor in self.output_handlers:
+            batch = out_tensor.copy_to_cpu()
+            output.append(batch)
+        return output
+
+
+class Infer(BaseComponent):
+
+    def __init__(self, predictor):
+        super().__init__()
+        self.predictor = predictor
+
+    def apply(self):
+        self.predictor.run()
+
+
+class BasePaddlePredictor(BaseComponent):
+    """Predictor based on Paddle Inference"""
+
+    OUTPUT_KEYS = "pred"
+    DEAULT_OUTPUTS = {"pred": "pred"}
+    ENABLE_BATCH = True
+
+    def __init__(self, model_dir, model_prefix, option):
+        super().__init__()
+        self.model_dir = model_dir
+        self.model_prefix = model_prefix
+        self._update_option(option)
+
+    def _update_option(self, option):
+        if option:
+            if self.option and option == self.option:
+                return
+            self._option = option
+            self._reset()
+
+    @property
+    def option(self):
+        return self._option if hasattr(self, "_option") else None
+
+    @option.setter
+    def option(self, option):
+        self._update_option(option)
+
+    def _reset(self):
+        if not self.option:
+            self.option = PaddlePredictorOption()
+        logging.debug(f"Env: {self.option}")
+        (
+            predictor,
+            input_handlers,
+            output_handlers,
+        ) = self._create()
+        self.copy2gpu = Copy2GPU(input_handlers)
+        self.copy2cpu = Copy2CPU(output_handlers)
+        self.infer = Infer(predictor)
+        self.option.changed = False
+
+    def _create(self):
+        """_create"""
+        from lazy_paddle.inference import Config, create_predictor
+
+        model_postfix = ".json" if FLAGS_json_format_model else ".pdmodel"
+        model_file = (self.model_dir / f"{self.model_prefix}{model_postfix}").as_posix()
+        params_file = (self.model_dir / f"{self.model_prefix}.pdiparams").as_posix()
+        config = Config(model_file, params_file)
+
+        config.enable_memory_optim()
+        if self.option.device in ("gpu", "dcu"):
+            if self.option.device == "gpu":
+                config.exp_disable_mixed_precision_ops({"feed", "fetch"})
+            config.enable_use_gpu(100, self.option.device_id)
+            if self.option.device == "gpu":
+                # NOTE: The pptrt settings are not aligned with those of FD.
+                precision_map = {
+                    "trt_int8": Config.Precision.Int8,
+                    "trt_fp32": Config.Precision.Float32,
+                    "trt_fp16": Config.Precision.Half,
+                }
+                if self.option.run_mode in precision_map.keys():
+                    config.enable_tensorrt_engine(
+                        workspace_size=(1 << 25) * self.option.batch_size,
+                        max_batch_size=self.option.batch_size,
+                        min_subgraph_size=self.option.min_subgraph_size,
+                        precision_mode=precision_map[self.option.run_mode],
+                        use_static=self.option.trt_use_static,
+                        use_calib_mode=self.option.trt_calib_mode,
+                    )
+
+                    if self.option.shape_info_filename is not None:
+                        if not os.path.exists(self.option.shape_info_filename):
+                            config.collect_shape_range_info(
+                                self.option.shape_info_filename
+                            )
+                            logging.info(
+                                f"Dynamic shape info is collected into: {self.option.shape_info_filename}"
+                            )
+                        else:
+                            logging.info(
+                                f"A dynamic shape info file ( {self.option.shape_info_filename} ) already exists. \
+        No need to generate again."
+                            )
+                        config.enable_tuned_tensorrt_dynamic_shape(
+                            self.option.shape_info_filename, True
+                        )
+        elif self.option.device == "npu":
+            config.enable_custom_device("npu")
+        elif self.option.device == "xpu":
+            pass
+        elif self.option.device == "mlu":
+            config.enable_custom_device("mlu")
+        else:
+            assert self.option.device == "cpu"
+            config.disable_gpu()
+            if "mkldnn" in self.option.run_mode:
+                try:
+                    config.enable_mkldnn()
+                    if "bf16" in self.option.run_mode:
+                        config.enable_mkldnn_bfloat16()
+                except Exception as e:
+                    logging.warning(
+                        "MKL-DNN is not available. We will disable MKL-DNN."
+                    )
+                config.set_mkldnn_cache_capacity(-1)
+            else:
+                if hasattr(config, "disable_mkldnn"):
+                    config.disable_mkldnn()
+
+        # Disable paddle inference logging
+        config.disable_glog_info()
+
+        config.set_cpu_math_library_num_threads(self.option.cpu_threads)
+
+        if self.option.device in ("cpu", "gpu"):
+            if not (
+                self.option.device == "gpu" and self.option.run_mode.startswith("trt")
+            ):
+                if hasattr(config, "enable_new_ir"):
+                    config.enable_new_ir(self.option.enable_new_ir)
+                if hasattr(config, "enable_new_executor"):
+                    config.enable_new_executor()
+                config.set_optimization_level(3)
+
+        for del_p in self.option.delete_pass:
+            config.delete_pass(del_p)
+
+        if self.option.device in ("gpu", "dcu"):
+            if paddle.is_compiled_with_rocm():
+                # Delete unsupported passes in dcu
+                config.delete_pass("conv2d_add_act_fuse_pass")
+                config.delete_pass("conv2d_add_fuse_pass")
+
+        predictor = create_predictor(config)
+
+        # Get input and output handlers
+        input_names = predictor.get_input_names()
+        input_names.sort()
+        input_handlers = []
+        output_handlers = []
+        for input_name in input_names:
+            input_handler = predictor.get_input_handle(input_name)
+            input_handlers.append(input_handler)
+        output_names = predictor.get_output_names()
+        for output_name in output_names:
+            output_handler = predictor.get_output_handle(output_name)
+            output_handlers.append(output_handler)
+        return predictor, input_handlers, output_handlers
+
+    def apply(self, **kwargs):
+        if self.option.changed:
+            self._reset()
+        batches = self.to_batch(**kwargs)
+        self.copy2gpu.apply(batches)
+        self.infer.apply()
+        pred = self.copy2cpu.apply()
+        return self.format_output(pred)
+
+    @property
+    def sub_cmps(self):
+        return {
+            "Copy2GPU": self.copy2gpu,
+            "Infer": self.infer,
+            "Copy2CPU": self.copy2cpu,
+        }
+
+    @abstractmethod
+    def to_batch(self):
+        raise NotImplementedError
+
+    @abstractmethod
+    def format_output(self, pred):
+        return [{"pred": res} for res in zip(*pred)]
+
+
+class ImagePredictor(BasePaddlePredictor):
+    INPUT_KEYS = "img"
+    OUTPUT_KEYS = "pred"
+    DEAULT_INPUTS = {"img": "img"}
+    DEAULT_OUTPUTS = {"pred": "pred"}
+
+    def to_batch(self, img):
+        return [np.stack(img, axis=0).astype(dtype=np.float32, copy=False)]
+
+    def format_output(self, pred):
+        return [{"pred": res} for res in zip(*pred)]
+
+
+class ImageDetPredictor(BasePaddlePredictor):
+
+    INPUT_KEYS = [
+        ["img", "scale_factors"],
+        ["img", "scale_factors", "img_size"],
+        ["img", "img_size"],
+    ]
+    OUTPUT_KEYS = [["boxes"], ["boxes", "masks"]]
+    DEAULT_INPUTS = {"img": "img", "scale_factors": "scale_factors"}
+    DEAULT_OUTPUTS = None
+
+    def to_batch(self, img, scale_factors=[[1.0, 1.0]], img_size=None):
+        scale_factors = [scale_factor[::-1] for scale_factor in scale_factors]
+        if img_size is None:
+            return [
+                np.stack(img, axis=0).astype(dtype=np.float32, copy=False),
+                np.stack(scale_factors, axis=0).astype(dtype=np.float32, copy=False),
+            ]
+        else:
+            img_size = [img_size[::-1] for img_size in img_size]
+            return [
+                np.stack(img_size, axis=0).astype(dtype=np.float32, copy=False),
+                np.stack(img, axis=0).astype(dtype=np.float32, copy=False),
+                np.stack(scale_factors, axis=0).astype(dtype=np.float32, copy=False),
+            ]
+
+    def format_output(self, pred):
+        box_idx_start = 0
+        pred_box = []
+
+        if len(pred) == 4:
+            # Adapt to SOLOv2
+            pred_class_id = []
+            pred_mask = []
+            pred_class_id.append([pred[1], pred[2]])
+            pred_mask.append(pred[3])
+            return [
+                {
+                    "class_id": np.array(pred_class_id[i]),
+                    "masks": np.array(pred_mask[i]),
+                }
+                for i in range(len(pred_class_id))
+            ]
+
+        if len(pred) == 3:
+            # Adapt to Instance Segmentation
+            pred_mask = []
+        for idx in range(len(pred[1])):
+            np_boxes_num = pred[1][idx]
+            box_idx_end = box_idx_start + np_boxes_num
+            np_boxes = pred[0][box_idx_start:box_idx_end]
+            pred_box.append(np_boxes)
+            if len(pred) == 3:
+                np_masks = pred[2][box_idx_start:box_idx_end]
+                pred_mask.append(np_masks)
+            box_idx_start = box_idx_end
+
+        if len(pred) == 3:
+            return [
+                {"boxes": np.array(pred_box[i]), "masks": np.array(pred_mask[i])}
+                for i in range(len(pred_box))
+            ]
+        else:
+            return [{"boxes": np.array(res)} for res in pred_box]
+
+
+class TSPPPredictor(BasePaddlePredictor):
+
+    INPUT_KEYS = "ts"
+    OUTPUT_KEYS = "pred"
+    DEAULT_INPUTS = {"ts": "ts"}
+    DEAULT_OUTPUTS = {"pred": "pred"}
+
+    def to_batch(self, ts):
+        n = len(ts[0])
+        x = [np.stack([lst[i] for lst in ts], axis=0) for i in range(n)]
+        return x
+
+    def format_output(self, pred):
+        return [{"pred": res} for res in zip(*pred)]

paddlex/inference/components/retrieval/__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 .faiss import FaissIndexer, FaissBuilder