paddlex 3.0.0rc0__py3-none-any.whl → 3.0.1__py3-none-any.whl

paddlex/inference/pipelines/components/prompt_engineering/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.
@@ -12,8 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import inspect
 from abc import ABC, abstractmethod
+
 from .....utils.subclass_register import AutoRegisterABCMetaClass
 
 

paddlex/inference/pipelines/components/prompt_engineering/generate_ensemble_prompt.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,6 +13,7 @@
 # limitations under the License.
 
 from typing import Dict
+
 from .base import BaseGeneratePrompt
 
 

paddlex/inference/pipelines/components/prompt_engineering/generate_kie_prompt.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,8 +13,8 @@
 # limitations under the License.
 
 from typing import Dict
+
 from .base import BaseGeneratePrompt
-from .....utils import logging
 
 
 class GenerateKIEPrompt(BaseGeneratePrompt):

paddlex/inference/pipelines/components/retriever/__init__.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.
@@ -12,5 +12,5 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from .qianfan_bot_retriever import QianFanBotRetriever
 from .openai_bot_retriever import OpenAIBotRetriever
+from .qianfan_bot_retriever import QianFanBotRetriever

paddlex/inference/pipelines/components/retriever/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.
@@ -11,22 +11,25 @@
 # 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, List
-from abc import ABC, abstractmethod
-
-import time
 import base64
-
-from langchain.docstore.document import Document
-from langchain.text_splitter import RecursiveCharacterTextSplitter
-from langchain_community.vectorstores import FAISS
-from langchain_community import vectorstores
+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"""
 
@@ -112,7 +115,7 @@ class BaseRetriever(ABC, metaclass=AutoRegisterABCMetaClass):
         text_list: List[str],
         block_size: int = 300,
         separators: List[str] = ["\t", "\n", "。", "\n\n", ""],
-    ) -> FAISS:
+    ) -> "FAISS":
         """
         Generates a vector database from a list of texts.
 
@@ -137,12 +140,12 @@ class BaseRetriever(ABC, metaclass=AutoRegisterABCMetaClass):
             vectorstore = FAISS.from_documents(
                 documents=all_splits, embedding=self.embedding
             )
-        except ValueError as e:
+        except ValueError:
             vectorstore = None
 
         return vectorstore
 
-    def encode_vector_store_to_bytes(self, vectorstore: FAISS) -> str:
+    def encode_vector_store_to_bytes(self, vectorstore: "FAISS") -> str:
         """
         Encode the vector store serialized to bytes.
 
@@ -158,7 +161,7 @@ class BaseRetriever(ABC, metaclass=AutoRegisterABCMetaClass):
             vectorstore = self.encode_vector_store(vectorstore.serialize_to_bytes())
         return vectorstore
 
-    def decode_vector_store_from_bytes(self, vectorstore: str) -> FAISS:
+    def decode_vector_store_from_bytes(self, vectorstore: str) -> "FAISS":
         """
         Decode a vector store from bytes according to the specified API type.
 
@@ -191,7 +194,7 @@ class BaseRetriever(ABC, metaclass=AutoRegisterABCMetaClass):
     def similarity_retrieval(
         self,
         query_text_list: List[str],
-        vectorstore: FAISS,
+        vectorstore: "FAISS",
         sleep_time: float = 0.5,
         topk: int = 2,
         min_characters: int = 3500,
@@ -208,7 +211,6 @@ class BaseRetriever(ABC, metaclass=AutoRegisterABCMetaClass):
         Returns:
             str: A concatenated string of all unique contexts found.
         """
-        C = []
         all_C = ""
         if vectorstore is None:
             return all_C

paddlex/inference/pipelines/components/retriever/openai_bot_retriever.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.
@@ -11,7 +11,7 @@
 # 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, List
+from typing import Dict
 
 from .base import BaseRetriever
 

paddlex/inference/pipelines/components/retriever/qianfan_bot_retriever.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.
@@ -12,14 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from operator import le
+import json
 from typing import Dict, List
 
-import json
 import requests
-from langchain_core.embeddings import Embeddings
 
 from paddlex.utils import logging
+
+from .....utils.deps import is_dep_available
 from .base import BaseRetriever
 
 
@@ -80,84 +80,87 @@ class QianFanBotRetriever(BaseRetriever):
         self.config = config
 
 
-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}"
+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}"]}
             )
-
-        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
+            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

@@ -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.

paddlex/inference/pipelines/components/utils/mixin.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.
@@ -12,22 +12,22 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from abc import abstractmethod
 import json
+from abc import abstractmethod
 from pathlib import Path
+
 import numpy as np
-from PIL import Image
 import pandas as pd
+from PIL import Image
 
 from .....utils import logging
 from ....utils.io import (
-    JsonWriter,
-    ImageReader,
-    ImageWriter,
     CSVWriter,
     HtmlWriter,
-    XlsxWriter,
+    ImageWriter,
+    JsonWriter,
     TextWriter,
+    XlsxWriter,
 )
 
 #### [TODO] need tingquan to add explanatory notes

paddlex/inference/pipelines/doc_preprocessor/__init__.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.

paddlex/inference/pipelines/doc_preprocessor/pipeline.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.
@@ -12,28 +12,32 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any, Dict, Optional, Union, List
-from scipy.ndimage import rotate
+from typing import Any, Dict, List, Optional, Union
+
 import numpy as np
-from ..base import BasePipeline
-from .result import DocPreprocessorResult
+
 from ....utils import logging
-from ...common.reader import ReadImage
+from ....utils.deps import pipeline_requires_extra
 from ...common.batch_sampler import ImageBatchSampler
+from ...common.reader import ReadImage
+from ...utils.hpi import HPIConfig
 from ...utils.pp_option import PaddlePredictorOption
+from .._parallel import AutoParallelImageSimpleInferencePipeline
+from ..base import BasePipeline
+from ..components import rotate_image
+from .result import DocPreprocessorResult
 
 
-class DocPreprocessorPipeline(BasePipeline):
+class _DocPreprocessorPipeline(BasePipeline):
     """Doc Preprocessor Pipeline"""
 
-    entities = "doc_preprocessor"
-
     def __init__(
         self,
         config: Dict,
         device: Optional[str] = None,
         pp_option: Optional[PaddlePredictorOption] = None,
         use_hpip: bool = False,
+        hpi_config: Optional[Union[Dict[str, Any], HPIConfig]] = None,
     ) -> None:
         """Initializes the doc preprocessor pipeline.
 
@@ -41,10 +45,16 @@ class DocPreprocessorPipeline(BasePipeline):
             config (Dict): Configuration dictionary containing various settings.
             device (str, optional): Device to run the predictions on. Defaults to None.
             pp_option (PaddlePredictorOption, optional): PaddlePredictor options. Defaults to None.
-            use_hpip (bool, optional): Whether to use high-performance inference (hpip) for prediction. Defaults to False.
+            use_hpip (bool, optional): Whether to use the high-performance
+                inference plugin (HPIP) by default. Defaults to False.
+            hpi_config (Optional[Union[Dict[str, Any], HPIConfig]], optional):
+                The default high-performance inference configuration dictionary.
+                Defaults to None.
         """
 
-        super().__init__(device=device, pp_option=pp_option, use_hpip=use_hpip)
+        super().__init__(
+            device=device, pp_option=pp_option, use_hpip=use_hpip, hpi_config=hpi_config
+        )
 
         self.use_doc_orientation_classify = config.get(
             "use_doc_orientation_classify", True
@@ -64,28 +74,9 @@ class DocPreprocessorPipeline(BasePipeline):
             )
             self.doc_unwarping_model = self.create_model(doc_unwarping_config)
 
-        self.batch_sampler = ImageBatchSampler(batch_size=1)
+        self.batch_sampler = ImageBatchSampler(batch_size=config.get("batch_size", 1))
         self.img_reader = ReadImage(format="BGR")
 
-    def rotate_image(self, image_array: np.ndarray, rotate_angle: float) -> np.ndarray:
-        """
-        Rotate the given image array by the specified angle.
-
-        Args:
-            image_array (np.ndarray): The input image array to be rotated.
-            rotate_angle (float): The angle in degrees by which to rotate the image.
-
-        Returns:
-            np.ndarray: The rotated image array.
-
-        Raises:
-            AssertionError: If rotate_angle is not in the range [0, 360).
-        """
-        assert (
-            rotate_angle >= 0 and rotate_angle < 360
-        ), "rotate_angle must in [0-360), but get {rotate_angle}."
-        return rotate(image_array, rotate_angle, reshape=True)
-
     def check_model_settings_valid(self, model_settings: Dict) -> bool:
         """
         Check if the the input params for model settings are valid based on the initialized models.
@@ -162,29 +153,57 @@ class DocPreprocessorPipeline(BasePipeline):
         if not self.check_model_settings_valid(model_settings):
             yield {"error": "the input params for model settings are invalid!"}
 
-        for img_id, batch_data in enumerate(self.batch_sampler(input)):
-            image_array = self.img_reader(batch_data.instances)[0]
+        for _, batch_data in enumerate(self.batch_sampler(input)):
+            image_arrays = self.img_reader(batch_data.instances)
 
             if model_settings["use_doc_orientation_classify"]:
-                pred = next(self.doc_ori_classify_model(image_array))
-                angle = int(pred["label_names"][0])
-                rot_img = self.rotate_image(image_array, angle)
+                preds = list(self.doc_ori_classify_model(image_arrays))
+                angles = []
+                rot_imgs = []
+                for img, pred in zip(image_arrays, preds):
+                    angle = int(pred["label_names"][0])
+                    angles.append(angle)
+                    rot_img = rotate_image(img, angle)
+                    rot_imgs.append(rot_img)
             else:
-                angle = -1
-                rot_img = image_array
+                angles = [-1 for _ in range(len(image_arrays))]
+                rot_imgs = image_arrays
 
             if model_settings["use_doc_unwarping"]:
-                output_img = next(self.doc_unwarping_model(rot_img))["doctr_img"]
+                output_imgs = [
+                    item["doctr_img"][:, :, ::-1]
+                    for item in self.doc_unwarping_model(rot_imgs)
+                ]
             else:
-                output_img = rot_img
-
-            single_img_res = {
-                "input_path": batch_data.input_paths[0],
-                "page_index": batch_data.page_indexes[0],
-                "input_img": image_array,
-                "model_settings": model_settings,
-                "angle": angle,
-                "rot_img": rot_img,
-                "output_img": output_img,
-            }
-            yield DocPreprocessorResult(single_img_res)
+                output_imgs = rot_imgs
+
+            for input_path, page_index, image_array, angle, rot_img, output_img in zip(
+                batch_data.input_paths,
+                batch_data.page_indexes,
+                image_arrays,
+                angles,
+                rot_imgs,
+                output_imgs,
+            ):
+                single_img_res = {
+                    "input_path": input_path,
+                    "page_index": page_index,
+                    "input_img": image_array,
+                    "model_settings": model_settings,
+                    "angle": angle,
+                    "rot_img": rot_img,
+                    "output_img": output_img,
+                }
+                yield DocPreprocessorResult(single_img_res)
+
+
+@pipeline_requires_extra("ocr")
+class DocPreprocessorPipeline(AutoParallelImageSimpleInferencePipeline):
+    entities = "doc_preprocessor"
+
+    @property
+    def _pipeline_cls(self):
+        return _DocPreprocessorPipeline
+
+    def _get_batch_size(self, config):
+        return config.get("batch_size", 1)

paddlex/inference/pipelines/doc_preprocessor/result.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,16 +13,11 @@
 # limitations under the License.
 
 from typing import Dict
-import math
-import random
-from pathlib import Path
-import copy
-import numpy as np
-import cv2
-import PIL
-from PIL import Image, ImageDraw, ImageFont
+
+from PIL import Image, ImageDraw
+
 from ....utils.fonts import PINGFANG_FONT_FILE_PATH, create_font
-from ...common.result import BaseCVResult, StrMixin, JsonMixin
+from ...common.result import BaseCVResult, JsonMixin
 
 
 class DocPreprocessorResult(BaseCVResult):

paddlex/inference/pipelines/doc_understanding/__init__.py

@@ -0,0 +1,15 @@
+# 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 .pipeline import DocUnderstandingPipeline