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

paddlex/inference/components/base.py

@@ -1,292 +0,0 @@
-# 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 abc import ABC, abstractmethod
-from copy import deepcopy
-from types import GeneratorType
-
-from ...utils.flags import INFER_BENCHMARK
-from ...utils import logging
-from ..utils.benchmark import Timer
-
-
-class BaseComponent(ABC):
-
-    YIELD_BATCH = True
-    KEEP_INPUT = True
-    ENABLE_BATCH = False
-
-    INPUT_KEYS = None
-    OUTPUT_KEYS = None
-
-    def __init__(self):
-        self.inputs = self.DEAULT_INPUTS if hasattr(self, "DEAULT_INPUTS") else {}
-        self.outputs = self.DEAULT_OUTPUTS if hasattr(self, "DEAULT_OUTPUTS") else {}
-
-        if INFER_BENCHMARK:
-            self.timer = Timer()
-            self.apply = self.timer.watch_func(self.apply)
-
-    def __call__(self, input_list):
-        # use list type for batched data
-        if not isinstance(input_list, list):
-            input_list = [input_list]
-
-        output_list = []
-        for args, input_ in self._check_input(input_list):
-            output = self.apply(**args)
-            if not output:
-                if self.YIELD_BATCH:
-                    yield input_list
-                else:
-                    for item in input_list:
-                        yield item
-
-            # output may be a generator, when the apply() uses yield
-            if (
-                isinstance(output, GeneratorType)
-                or output.__class__.__name__ == "generator"
-            ):
-                # if output is a generator, use for-in to get every one batch output data and yield one by one
-                for each_output in output:
-                    reassemble_data = self._check_output(each_output, input_)
-                    if self.YIELD_BATCH:
-                        yield reassemble_data
-                    else:
-                        for item in reassemble_data:
-                            yield item
-            # if output is not a generator, process all data of that and yield, so use output_list to collect all reassemble_data
-            else:
-                reassemble_data = self._check_output(output, input_)
-                output_list.extend(reassemble_data)
-
-        # avoid yielding output_list when the output is a generator
-        if len(output_list) > 0:
-            if self.YIELD_BATCH:
-                yield output_list
-            else:
-                for item in output_list:
-                    yield item
-
-    def _check_input(self, input_list):
-        # check if the value of input data meets the requirements of apply(),
-        # and reassemble the parameters of apply() from input_list
-        def _check_type(input_):
-            if not isinstance(input_, dict):
-                if len(self.inputs) == 1:
-                    key = list(self.inputs.keys())[0]
-                    input_ = {key: input_}
-                else:
-                    raise Exception(
-                        f"The input must be a dict or a list of dict, unless the input of the component only requires one argument, but the component({self.__class__.__name__}) requires {list(self.inputs.keys())}!"
-                    )
-            return input_
-
-        def _check_args_key(args):
-            sig = inspect.signature(self.apply)
-            for param in sig.parameters.values():
-                if param.kind == inspect.Parameter.VAR_KEYWORD:
-                    logging.debug(
-                        f"The apply function parameter of {self.__class__.__name__} is **kwargs, so would not inspect!"
-                    )
-                    continue
-                if param.default == inspect.Parameter.empty and param.name not in args:
-                    raise Exception(
-                        f"The parameter ({param.name}) is needed by {self.__class__.__name__}, but {list(args.keys())} only found!"
-                    )
-
-        if self.inputs is None:
-            return [({}, None)]
-
-        if self.need_batch_input:
-            args = {}
-            for input_ in input_list:
-                input_ = _check_type(input_)
-                for k, v in self.inputs.items():
-                    if v not in input_:
-                        raise Exception(
-                            f"The value ({v}) is needed by {self.__class__.__name__}. But not found in Data ({input_.keys()})!"
-                        )
-                    if k not in args:
-                        args[k] = []
-                    args[k].append(input_.get(v))
-                _check_args_key(args)
-            reassemble_input = [(args, input_list)]
-        else:
-            reassemble_input = []
-            for input_ in input_list:
-                input_ = _check_type(input_)
-                args = {}
-                for k, v in self.inputs.items():
-                    if v not in input_:
-                        raise Exception(
-                            f"The value ({v}) is needed by {self.__class__.__name__}. But not found in Data ({input_.keys()})!"
-                        )
-                    args[k] = input_.get(v)
-                _check_args_key(args)
-                reassemble_input.append((args, input_))
-        return reassemble_input
-
-    def _check_output(self, output, ori_data):
-        # check if the value of apply() output data meets the requirements of setting
-        # when the output data is list type, reassemble each of that
-        if isinstance(output, list):
-            if self.need_batch_input:
-                assert isinstance(ori_data, list) and len(ori_data) == len(output)
-                output_list = []
-                for ori_item, output_item in zip(ori_data, output):
-                    data = ori_item.copy() if self.keep_input else {}
-                    if isinstance(self.outputs, type(None)):
-                        logging.debug(
-                            f"The `output_key` of {self.__class__.__name__} is None, so would not inspect!"
-                        )
-                        data.update(output_item)
-                    else:
-                        for k, v in self.outputs.items():
-                            if k not in output_item:
-                                raise Exception(
-                                    f"The value ({k}) is needed by {self.__class__.__name__}. But not found in Data ({output_item.keys()})!"
-                                )
-                            data.update({v: output_item[k]})
-                    output_list.append(data)
-                return output_list
-            else:
-                assert isinstance(ori_data, dict)
-                output_list = []
-                for output_item in output:
-                    data = ori_data.copy() if self.keep_input else {}
-                    if isinstance(self.outputs, type(None)):
-                        logging.debug(
-                            f"The `output_key` of {self.__class__.__name__} is None, so would not inspect!"
-                        )
-                        data.update(output_item)
-                    else:
-                        for k, v in self.outputs.items():
-                            if k not in output_item:
-                                raise Exception(
-                                    f"The value ({k}) is needed by {self.__class__.__name__}. But not found in Data ({output_item.keys()})!"
-                                )
-                            data.update({v: output_item[k]})
-                    output_list.append(data)
-                return output_list
-        else:
-            assert isinstance(ori_data, dict) and isinstance(output, dict)
-            data = ori_data.copy() if self.keep_input else {}
-            if isinstance(self.outputs, type(None)):
-                logging.debug(
-                    f"The `output_key` of {self.__class__.__name__} is None, so would not inspect!"
-                )
-                data.update(output)
-            else:
-                for k, v in self.outputs.items():
-                    if k not in output:
-                        raise Exception(
-                            f"The value of key ({k}) is needed add to Data. But not found in output of {self.__class__.__name__}: ({output.keys()})!"
-                        )
-                    data.update({v: output[k]})
-        return [data]
-
-    def set_inputs(self, inputs):
-        assert isinstance(inputs, dict)
-        input_keys = deepcopy(self.INPUT_KEYS)
-
-        # e.g, input_keys is None or []
-        if input_keys is None or (
-            isinstance(input_keys, list) and len(input_keys) == 0
-        ):
-            self.inputs = {}
-            if inputs:
-                raise Exception
-            return
-
-        # e.g, input_keys is 'img'
-        if not isinstance(input_keys, list):
-            input_keys = [[input_keys]]
-        # e.g, input_keys is ['img'] or [['img']]
-        elif len(input_keys) > 0:
-            # e.g, input_keys is ['img']
-            if not isinstance(input_keys[0], list):
-                input_keys = [input_keys]
-
-        ck_pass = False
-        for key_group in input_keys:
-            for key in key_group:
-                if key not in inputs:
-                    break
-            # check pass
-            else:
-                ck_pass = True
-            if ck_pass == True:
-                break
-        else:
-            raise Exception(
-                f"The input {input_keys} are needed by {self.__class__.__name__}. But only get: {list(inputs.keys())}"
-            )
-        self.inputs = inputs
-
-    def set_outputs(self, outputs):
-        assert isinstance(outputs, dict)
-        output_keys = deepcopy(self.OUTPUT_KEYS)
-        if not isinstance(output_keys, list):
-            output_keys = [output_keys]
-
-        for k in output_keys:
-            if k not in outputs:
-                logging.debug(
-                    f"The output ({k}) of {self.__class__.__name__} would be abandon!"
-                )
-        self.outputs = outputs
-
-    @classmethod
-    def get_input_keys(cls) -> list:
-        return cls.input_keys
-
-    @classmethod
-    def get_output_keys(cls) -> list:
-        return cls.output_keys
-
-    @property
-    def need_batch_input(self):
-        return getattr(self, "ENABLE_BATCH", False)
-
-    @property
-    def keep_input(self):
-        return getattr(self, "KEEP_INPUT", True)
-
-    @property
-    def name(self):
-        return getattr(self, "NAME", self.__class__.__name__)
-
-    @property
-    def sub_cmps(self):
-        return None
-
-    @abstractmethod
-    def apply(self, input):
-        raise NotImplementedError
-
-
-class ComponentsEngine(object):
-    def __init__(self, ops):
-        self.ops = ops
-        self.keys = list(ops.keys())
-
-    def __call__(self, data, i=0):
-        data_gen = self.ops[self.keys[i]](data)
-        if i + 1 < len(self.ops):
-            for data in data_gen:
-                yield from self.__call__(data, i + 1)
-        else:
-            yield from data_gen

paddlex/inference/components/llm/__init__.py

@@ -1,25 +0,0 @@
-# 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 BaseLLM
-from .erniebot import ErnieBot
-
-
-def create_llm_api(model_name: str, params={}) -> BaseLLM:
-    # for CI
-    if model_name == "paddlex_ci":
-        return
-    return BaseLLM.get(model_name)(
-        model_name=model_name,
-        params=params,
-    )

paddlex/inference/components/llm/base.py

@@ -1,65 +0,0 @@
-# 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 base64
-from ..base import BaseComponent
-from ....utils.subclass_register import AutoRegisterABCMetaClass
-
-__all__ = ["BaseLLM"]
-
-
-class BaseLLM(BaseComponent, metaclass=AutoRegisterABCMetaClass):
-    __is_base = True
-
-    ERROR_MASSAGE = ""
-    VECTOR_STORE_PREFIX = "PADDLEX_VECTOR_STORE"
-
-    def __init__(self):
-        super().__init__()
-
-    def pre_process(self, inputs):
-        return inputs
-
-    def post_process(self, outputs):
-        return outputs
-
-    def pred(self, inputs):
-        raise NotImplementedError("The method `pred` has not been implemented yet.")
-
-    def get_vector(self):
-        raise NotImplementedError(
-            "The method `get_vector` has not been implemented yet."
-        )
-
-    def caculate_similar(self):
-        raise NotImplementedError(
-            "The method `caculate_similar` has not been implemented yet."
-        )
-
-    def apply(self, inputs):
-        pre_process_results = self.pre_process(inputs)
-        pred_results = self.pred(pre_process_results)
-        post_process_results = self.post_process(pred_results)
-        return post_process_results
-
-    def is_vector_store(self, s):
-        return s.startswith(self.VECTOR_STORE_PREFIX)
-
-    def encode_vector_store(self, vector_store_bytes):
-        return self.VECTOR_STORE_PREFIX + base64.b64encode(vector_store_bytes).decode(
-            "ascii"
-        )
-
-    def decode_vector_store(self, vector_store_str):
-        return base64.b64decode(vector_store_str[len(self.VECTOR_STORE_PREFIX) :])

paddlex/inference/components/llm/erniebot.py

@@ -1,212 +0,0 @@
-# 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

@@ -1,20 +0,0 @@
-# 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,
-)