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

paddlex/inference/pipelines/components/prompt_engineering/generate_kie_prompt.py

@@ -0,0 +1,148 @@
+# 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 typing import Dict
+
+from .base import BaseGeneratePrompt
+
+
+class GenerateKIEPrompt(BaseGeneratePrompt):
+    """Generate KIE Prompt"""
+
+    entities = [
+        "text_kie_prompt_v1",
+        "table_kie_prompt_v1",
+        "text_kie_prompt_v2",
+        "table_kie_prompt_v2",
+    ]
+
+    def __init__(self, config: Dict) -> None:
+        """Initializes the GenerateKIEPrompt instance with the given configuration.
+
+        Args:
+            config (Dict): A dictionary containing configuration settings.
+                - task_type (str): The type of task to generate a prompt for, in the support entities list.
+                - task_description (str, optional): A description of the task. Defaults to an empty string.
+                - output_format (str, optional): The desired output format. Defaults to an empty string.
+                - rules_str (str, optional): A string representing rules for the task. Defaults to an empty string.
+                - few_shot_demo_text_content (str, optional): Text content for few-shot demos. Defaults to an empty string.
+                - few_shot_demo_key_value_list (str, optional): A key-value list for few-shot demos. Defaults to an empty string.
+
+        Raises:
+            ValueError: If the task type is not in the allowed entities for GenerateKIEPrompt.
+        """
+        super().__init__()
+
+        task_type = config.get("task_type", "")
+        task_description = config.get("task_description", "")
+        output_format = config.get("output_format", "")
+        rules_str = config.get("rules_str", "")
+        few_shot_demo_text_content = config.get("few_shot_demo_text_content", "")
+        few_shot_demo_key_value_list = config.get("few_shot_demo_key_value_list", "")
+
+        if task_description is None:
+            task_description = ""
+
+        if output_format is None:
+            output_format = ""
+
+        if rules_str is None:
+            rules_str = ""
+
+        if few_shot_demo_text_content is None:
+            few_shot_demo_text_content = ""
+
+        if few_shot_demo_key_value_list is None:
+            few_shot_demo_key_value_list = ""
+
+        if task_type not in self.entities:
+            raise ValueError(
+                f"task type must be in {self.entities} of GenerateKIEPrompt."
+            )
+
+        self.task_type = task_type
+        self.task_description = task_description
+        self.output_format = output_format
+        self.rules_str = rules_str
+        self.few_shot_demo_text_content = few_shot_demo_text_content
+        self.few_shot_demo_key_value_list = few_shot_demo_key_value_list
+
+    def generate_prompt(
+        self,
+        text_content: str,
+        key_list: list,
+        task_description: str = None,
+        output_format: str = None,
+        rules_str: str = None,
+        few_shot_demo_text_content: str = None,
+        few_shot_demo_key_value_list: str = None,
+    ) -> str:
+        """Generates a prompt based on the given parameters.
+
+        Args:
+            text_content (str): The main text content to be used in the prompt.
+            key_list (list): A list of keywords for information extraction.
+            task_description (str, optional): A description of the task. Defaults to None.
+            output_format (str, optional): The desired output format. Defaults to None.
+            rules_str (str, optional): A string containing rules or instructions. Defaults to None.
+            few_shot_demo_text_content (str, optional): Text content for few-shot demos. Defaults to None.
+            few_shot_demo_key_value_list (str, optional): Key-value list for few-shot demos. Defaults to None.
+        Returns:
+            str: The generated prompt.
+
+        Raises:
+            ValueError: If the task_type is not supported.
+        """
+        if task_description is None:
+            task_description = self.task_description
+
+        if output_format is None:
+            output_format = self.output_format
+
+        if rules_str is None:
+            rules_str = self.rules_str
+
+        if few_shot_demo_text_content is None:
+            few_shot_demo_text_content = self.few_shot_demo_text_content
+
+        if few_shot_demo_key_value_list is None:
+            few_shot_demo_key_value_list = self.few_shot_demo_key_value_list
+
+        prompt = f"""{task_description}{rules_str}{output_format}{few_shot_demo_text_content}{few_shot_demo_key_value_list}"""
+        task_type = self.task_type
+        if task_type == "table_kie_prompt_v1":
+            prompt += f"""\n结合上面，下面正式开始：\
+                表格内容：```{text_content}```\
+                关键词列表：[{key_list}]。""".replace(
+                "    ", ""
+            )
+        elif task_type == "text_kie_prompt_v1":
+            prompt += f"""\n结合上面的例子，下面正式开始：\
+                OCR文字：```{text_content}```\
+                关键词列表：[{key_list}]。""".replace(
+                "    ", ""
+            )
+        elif task_type == "table_kie_prompt_v2":
+            prompt += f"""\n结合上面，下面正式开始：\
+                表格内容：```{text_content}```\
+                \n问题列表：{key_list}。""".replace(
+                "    ", ""
+            )
+        elif task_type == "text_kie_prompt_v2":
+            prompt += f"""\n结合上面的例子，下面正式开始：\
+                OCR文字：```{text_content}```\
+                \n问题列表：{key_list}。""".replace(
+                "    ", ""
+            )
+        return prompt

paddlex/inference/pipelines/components/retriever/__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 .openai_bot_retriever import OpenAIBotRetriever
+from .qianfan_bot_retriever import QianFanBotRetriever

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

@@ -0,0 +1,228 @@
+# 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 time
+from abc import ABC, abstractmethod
+from typing import List
+
+from paddlex.utils import logging
+
+from .....utils.deps import class_requires_deps, is_dep_available
+from .....utils.subclass_register import AutoRegisterABCMetaClass
+
+if is_dep_available("langchain"):
+    from langchain.docstore.document import Document
+    from langchain.text_splitter import RecursiveCharacterTextSplitter
+if is_dep_available("langchain-community"):
+    from langchain_community import vectorstores
+    from langchain_community.vectorstores import FAISS
+
+
+@class_requires_deps("langchain", "langchain-community")
+class BaseRetriever(ABC, metaclass=AutoRegisterABCMetaClass):
+    """Base Retriever"""
+
+    __is_base = True
+
+    VECTOR_STORE_PREFIX = "PADDLEX_VECTOR_STORE"
+
+    def __init__(self):
+        """Initializes an instance of base retriever."""
+        super().__init__()
+        self.model_name = None
+        self.embedding = None
+
+    @abstractmethod
+    def generate_vector_database(self):
+        """
+        Declaration of an abstract method. Subclasses are expected to
+        provide a concrete implementation of generate_vector_database.
+        """
+        raise NotImplementedError(
+            "The method `generate_vector_database` has not been implemented yet."
+        )
+
+    @abstractmethod
+    def similarity_retrieval(self):
+        """
+        Declaration of an abstract method. Subclasses are expected to
+        provide a concrete implementation of similarity_retrieval.
+        """
+        raise NotImplementedError(
+            "The method `similarity_retrieval` has not been implemented yet."
+        )
+
+    def get_model_name(self) -> str:
+        """
+        Get the model name used for generating vectors.
+
+        Returns:
+            str: The model name.
+        """
+        return self.model_name
+
+    def is_vector_store(self, s: str) -> bool:
+        """
+        Check if the given string starts with the vector store prefix.
+
+        Args:
+            s (str): The input string to check.
+
+        Returns:
+            bool: True if the string starts with the vector store prefix, False otherwise.
+        """
+        return s.startswith(self.VECTOR_STORE_PREFIX)
+
+    def encode_vector_store(self, vector_store_bytes: bytes) -> str:
+        """
+        Encode the vector store bytes into a base64 string prefixed with a specific prefix.
+
+        Args:
+            vector_store_bytes (bytes): The bytes to encode.
+
+        Returns:
+            str: The encoded string with the prefix.
+        """
+        return self.VECTOR_STORE_PREFIX + base64.b64encode(vector_store_bytes).decode(
+            "ascii"
+        )
+
+    def decode_vector_store(self, vector_store_str: str) -> bytes:
+        """
+        Decodes the vector store string by removing the prefix and decoding the base64 encoded string.
+
+        Args:
+            vector_store_str (str): The vector store string with a prefix.
+
+        Returns:
+            bytes: The decoded vector store data.
+        """
+        return base64.b64decode(vector_store_str[len(self.VECTOR_STORE_PREFIX) :])
+
+    def generate_vector_database(
+        self,
+        text_list: List[str],
+        block_size: int = 300,
+        separators: List[str] = ["\t", "\n", "。", "\n\n", ""],
+    ) -> "FAISS":
+        """
+        Generates a vector database from a list of texts.
+
+        Args:
+            text_list (list[str]): A list of texts to generate the vector database from.
+            block_size (int): The size of each chunk to split the text into.
+            separators (list[str]): A list of separators to use when splitting the text.
+
+        Returns:
+            FAISS: The generated vector database.
+
+        Raises:
+            ValueError: If an unsupported API type is configured.
+        """
+        text_splitter = RecursiveCharacterTextSplitter(
+            chunk_size=block_size, chunk_overlap=20, separators=separators
+        )
+        texts = text_splitter.split_text("\t".join(text_list))
+        all_splits = [Document(page_content=text) for text in texts]
+
+        try:
+            vectorstore = FAISS.from_documents(
+                documents=all_splits, embedding=self.embedding
+            )
+        except ValueError:
+            vectorstore = None
+
+        return vectorstore
+
+    def encode_vector_store_to_bytes(self, vectorstore: "FAISS") -> str:
+        """
+        Encode the vector store serialized to bytes.
+
+        Args:
+            vectorstore (FAISS): The vector store to be serialized and encoded.
+
+        Returns:
+            str: The encoded vector store.
+        """
+        if vectorstore is None:
+            vectorstore = self.VECTOR_STORE_PREFIX
+        else:
+            vectorstore = self.encode_vector_store(vectorstore.serialize_to_bytes())
+        return vectorstore
+
+    def decode_vector_store_from_bytes(self, vectorstore: str) -> "FAISS":
+        """
+        Decode a vector store from bytes according to the specified API type.
+
+        Args:
+            vectorstore (str): The serialized vector store string.
+
+        Returns:
+            FAISS: Deserialized vector store object.
+
+        Raises:
+            ValueError: If the retrieved vector store is not for PaddleX
+            or if an unsupported API type is specified.
+        """
+        if not self.is_vector_store(vectorstore):
+            raise ValueError("The retrieved vectorstore is not for PaddleX.")
+
+        vectorstore = self.decode_vector_store(vectorstore)
+
+        if vectorstore == b"":
+            logging.warning("The retrieved vectorstore is empty,will empty vector.")
+            return None
+
+        vector = vectorstores.FAISS.deserialize_from_bytes(
+            vectorstore,
+            embeddings=self.embedding,
+            allow_dangerous_deserialization=True,
+        )
+        return vector
+
+    def similarity_retrieval(
+        self,
+        query_text_list: List[str],
+        vectorstore: "FAISS",
+        sleep_time: float = 0.5,
+        topk: int = 2,
+        min_characters: int = 3500,
+    ) -> str:
+        """
+        Retrieve similar contexts based on a list of query texts.
+
+        Args:
+            query_text_list (list[str]): A list of query texts to search for similar contexts.
+            vectorstore (FAISS): The vector store where to perform the similarity search.
+            sleep_time (float): The time to sleep between each query, in seconds. Default is 0.5.
+            topk (int): The number of results to retrieve per query. Default is 2.
+            min_characters (int): The minimum number of characters required for text processing, defaults to 3500.
+        Returns:
+            str: A concatenated string of all unique contexts found.
+        """
+        all_C = ""
+        if vectorstore is None:
+            return all_C
+        for query_text in query_text_list:
+            QUESTION = query_text
+            time.sleep(sleep_time)
+            docs = vectorstore.similarity_search_with_relevance_scores(QUESTION, k=topk)
+            context = [(document.page_content, score) for document, score in docs]
+            context = sorted(context, key=lambda x: x[1])
+            for text, score in context[::-1]:
+                if score >= -0.1:
+                    if len(all_C) + len(text) > min_characters:
+                        break
+                    all_C += text
+        return all_C

paddlex/inference/pipelines/components/retriever/openai_bot_retriever.py

@@ -0,0 +1,70 @@
+# 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 typing import Dict
+
+from .base import BaseRetriever
+
+
+class OpenAIBotRetriever(BaseRetriever):
+    """OpenAI Bot Retriever"""
+
+    entities = [
+        "openai",
+    ]
+
+    def __init__(self, config: Dict) -> None:
+        """
+        Initializes the OpenAIBotRetriever instance with the provided configuration.
+
+        Args:
+            config (Dict): A dictionary containing configuration settings.
+                - model_name (str): The name of the model to use.
+                - api_type (str): The type of API to use ('qianfan' or 'openai').
+                - api_key (str): The API key for 'openai' API.
+                - base_url (str): The base URL for 'openai' API.
+
+        Raises:
+            ValueError: If api_type is not one of ['qianfan','openai'],
+            base_url is None for api_type is openai,
+            api_key is None for api_type is openai.
+        """
+        super().__init__()
+
+        model_name = config.get("model_name", None)
+        api_key = config.get("api_key", None)
+        base_url = config.get("base_url", None)
+        tiktoken_enabled = config.get("tiktoken_enabled", False)
+
+        if 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.")
+
+        try:
+            from langchain_openai import OpenAIEmbeddings
+        except:
+            raise Exception(
+                "langchain-openai is not installed, please install it first."
+            )
+
+        self.embedding = OpenAIEmbeddings(
+            model=model_name,
+            api_key=api_key,
+            base_url=base_url,
+            tiktoken_enabled=tiktoken_enabled,
+        )
+
+        self.model_name = model_name
+        self.config = config

paddlex/inference/pipelines/components/retriever/qianfan_bot_retriever.py

@@ -0,0 +1,166 @@
+# 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 json
+from typing import Dict, List
+
+import requests
+
+from paddlex.utils import logging
+
+from .....utils.deps import is_dep_available
+from .base import BaseRetriever
+
+
+class QianFanBotRetriever(BaseRetriever):
+    """QianFan Bot Retriever"""
+
+    entities = [
+        "qianfan",
+    ]
+
+    MODELS = [
+        "tao-8k",
+        "embedding-v1",
+        "bge-large-zh",
+        "bge-large-en",
+    ]
+
+    def __init__(self, config: Dict) -> None:
+        """
+        Initializes the ErnieBotRetriever instance with the provided configuration.
+
+        Args:
+            config (Dict): A dictionary containing configuration settings.
+                - model_name (str): The name of the model to use.
+                - api_type (str): The type of API to use ('qianfan' or 'openai').
+                - api_key (str): The API key for 'qianfan' API.
+                - base_url (str): The base URL for 'qianfan' API.
+
+        Raises:
+            ValueError: If api_type is not one of ['qianfan','openai'],
+                base_url is None for api_type is qianfan,
+                api_key is None for api_type is qianfan.
+        """
+        super().__init__()
+
+        model_name = config.get("model_name", None)
+        api_key = config.get("api_key", None)
+        base_url = config.get("base_url", None)
+
+        if model_name not in self.MODELS:
+            raise ValueError(
+                f"model_name must be in {self.MODELS} of QianFanBotRetriever."
+            )
+
+        if api_key is None:
+            raise ValueError("api_key cannot be empty when api_type is qianfan.")
+
+        if base_url is None:
+            raise ValueError("base_url cannot be empty when api_type is qianfan.")
+
+        self.embedding = QianfanEmbeddings(
+            model=model_name,
+            base_url=base_url,
+            api_key=api_key,
+        )
+
+        self.model_name = model_name
+        self.config = config
+
+
+if is_dep_available("langchain-core"):
+    from langchain_core.embeddings import Embeddings
+
+    class QianfanEmbeddings(Embeddings):
+        """`Baidu Qianfan Embeddings` embedding models."""
+
+        def __init__(
+            self,
+            api_key: str,
+            base_url: str = "https://qianfan.baidubce.com/v2",
+            model: str = "embedding-v1",
+            **kwargs,
+        ):
+            """
+            Initialize the Baidu Qianfan Embeddings class.
+
+            Args:
+                api_key (str): The Qianfan API key.
+                base_url (str): The base URL for 'qianfan' API.
+                model (str): Model name. Default is "embedding-v1",select in ["tao-8k","embedding-v1","bge-large-en","bge-large-zh"].
+                kwargs (dict): Additional keyword arguments passed to the base Embeddings class.
+            """
+            super().__init__(**kwargs)
+            chunk_size_map = {
+                "tao-8k": 1,
+                "embedding-v1": 16,
+                "bge-large-en": 16,
+                "bge-large-zh": 16,
+            }
+            self.api_key = api_key
+            self.base_url = base_url
+            self.model = model
+            self.chunk_size = chunk_size_map.get(model, 1)
+
+        def embed(self, texts: str, **kwargs) -> List[float]:
+            url = f"{self.base_url}/embeddings"
+            payload = json.dumps(
+                {"model": kwargs.get("model", self.model), "input": [f"{texts}"]}
+            )
+            headers = {
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {self.api_key}",
+            }
+
+            response = requests.request("POST", url, headers=headers, data=payload)
+            if response.status_code != 200:
+                logging.error(
+                    f"Failed to call Qianfan API. Status code: {response.status_code}, Response content: {response}"
+                )
+
+            return response.json()
+
+        def embed_query(self, text: str) -> List[float]:
+            resp = self.embed_documents([text])
+            return resp[0]
+
+        def embed_documents(self, texts: List[str]) -> List[List[float]]:
+            """
+            Embeds a list of text documents using the AutoVOT algorithm.
+
+            Args:
+                texts (List[str]): A list of text documents to embed.
+
+            Returns:
+                List[List[float]]: A list of embeddings for each document in the input list.
+                                Each embedding is represented as a list of float values.
+            """
+            lst = []
+            for chunk in texts:
+                resp = self.embed(texts=chunk)
+                lst.extend([res["embedding"] for res in resp["data"]])
+            return lst
+
+        async def aembed_query(self, text: str) -> List[float]:
+            embeddings = await self.aembed_documents([text])
+            return embeddings[0]
+
+        async def aembed_documents(self, texts: List[str]) -> List[List[float]]:
+            lst = []
+            for chunk in texts:
+                resp = await self.embed(texts=chunk)
+                for res in resp["data"]:
+                    lst.extend([res["embedding"]])
+            return lst

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

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