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

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

@@ -0,0 +1,85 @@
+# 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 List
+
+import numpy as np
+
+from .base_operator import BaseOperator
+
+
+class SortQuadBoxes(BaseOperator):
+    """SortQuadBoxes Operator."""
+
+    entities = "SortQuadBoxes"
+
+    def __init__(self):
+        """Initializes the class."""
+        super().__init__()
+
+    def __call__(self, dt_polys: List[np.ndarray]) -> np.ndarray:
+        """
+        Sort quad boxes in order from top to bottom, left to right
+        args:
+            dt_polys(ndarray):detected quad boxes with shape [4, 2]
+        return:
+            sorted boxes(ndarray) with shape [4, 2]
+        """
+        dt_boxes = np.array(dt_polys)
+        num_boxes = dt_boxes.shape[0]
+        sorted_boxes = sorted(dt_boxes, key=lambda x: (x[0][1], x[0][0]))
+        _boxes = list(sorted_boxes)
+
+        for i in range(num_boxes - 1):
+            for j in range(i, -1, -1):
+                if abs(_boxes[j + 1][0][1] - _boxes[j][0][1]) < 10 and (
+                    _boxes[j + 1][0][0] < _boxes[j][0][0]
+                ):
+                    tmp = _boxes[j]
+                    _boxes[j] = _boxes[j + 1]
+                    _boxes[j + 1] = tmp
+                else:
+                    break
+        return _boxes
+
+
+class SortPolyBoxes(BaseOperator):
+    """SortPolyBoxes Operator."""
+
+    entities = "SortPolyBoxes"
+
+    def __init__(self):
+        """Initializes the class."""
+        super().__init__()
+
+    def __call__(self, dt_polys: List[np.ndarray]) -> np.ndarray:
+        """
+        Sort poly boxes in order from top to bottom, left to right
+        args:
+            dt_polys(ndarray):detected poly boxes with a [N, 2] np.ndarray list
+        return:
+            sorted boxes(ndarray) with [N, 2] np.ndarray list
+        """
+        num_boxes = len(dt_polys)
+        if num_boxes == 0:
+            return dt_polys
+        else:
+            y_min_list = []
+            for bno in range(num_boxes):
+                y_min_list.append(min(dt_polys[bno][:, 1]))
+            rank = np.argsort(np.array(y_min_list))
+            dt_polys_rank = []
+            for no in range(num_boxes):
+                dt_polys_rank.append(dt_polys[rank[no]])
+            return dt_polys_rank

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

@@ -0,0 +1,50 @@
+# 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 numpy as np
+
+from .....utils.deps import function_requires_deps, is_dep_available
+
+if is_dep_available("opencv-contrib-python"):
+    import cv2
+
+
+@function_requires_deps("opencv-contrib-python")
+def rotate_image(image, angle):
+    if angle < 0 or angle >= 360:
+        raise ValueError("`angle` should be in range [0, 360)")
+
+    if angle < 1e-7:
+        return image
+
+    # Should we align corners?
+    h, w = image.shape[:2]
+    center = (w / 2, h / 2)
+    scale = 1.0
+    mat = cv2.getRotationMatrix2D(center, angle, scale)
+    cos = np.abs(mat[0, 0])
+    sin = np.abs(mat[0, 1])
+    new_w = int((h * sin) + (w * cos))
+    new_h = int((h * cos) + (w * sin))
+    mat[0, 2] += (new_w - w) / 2
+    mat[1, 2] += (new_h - h) / 2
+    dst_size = (new_w, new_h)
+
+    rotated = cv2.warpAffine(
+        image,
+        mat,
+        dst_size,
+        flags=cv2.INTER_CUBIC,
+    )
+    return rotated

paddlex/inference/pipelines/components/faisser.py

@@ -0,0 +1,357 @@
+# 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 pickle
+from pathlib import Path
+
+import numpy as np
+
+from ....utils import logging
+from ....utils.deps import class_requires_deps, is_dep_available
+from ...utils.io import YAMLReader, YAMLWriter
+
+if is_dep_available("faiss-cpu"):
+    import faiss
+
+
+@class_requires_deps("faiss-cpu")
+class IndexData:
+    VECTOR_FN = "vector"
+    VECTOR_SUFFIX = ".index"
+    IDMAP_FN = "id_map"
+    IDMAP_SUFFIX = ".yaml"
+
+    def __init__(self, index, index_info):
+        self._index = index
+        self._index_info = index_info
+        self._id_map = index_info["id_map"]
+        self._metric_type = index_info["metric_type"]
+        self._index_type = index_info["index_type"]
+
+    @property
+    def index(self):
+        return self._index
+
+    @property
+    def index_bytes(self):
+        return faiss.serialize_index(self._index)
+
+    @property
+    def id_map(self):
+        return self._id_map
+
+    @property
+    def metric_type(self):
+        return self._metric_type
+
+    @property
+    def index_type(self):
+        return self._index_type
+
+    @property
+    def index_info(self):
+        return {
+            "index_type": self.index_type,
+            "metric_type": self.metric_type,
+            "id_map": self._convert_int(self.id_map),
+        }
+
+    @classmethod
+    def from_bytes(cls, bytes):
+        tup = pickle.loads(bytes)
+        index = faiss.deserialize_index(tup[0])
+        return cls(index, tup[1])
+
+    def to_bytes(self):
+        tup = (faiss.serialize_index(self._index), self.index_info)
+        return pickle.dumps(tup)
+
+    def _convert_int(self, id_map):
+        return {int(k): str(v) for k, v in id_map.items()}
+
+    @staticmethod
+    def _convert_int64(id_map):
+        return {np.int64(k): str(v) for k, v in id_map.items()}
+
+    def save(self, save_dir):
+        save_dir = Path(save_dir)
+        save_dir.mkdir(parents=True, exist_ok=True)
+        vector_path = (save_dir / f"{self.VECTOR_FN}{self.VECTOR_SUFFIX}").as_posix()
+        index_info_path = (save_dir / f"{self.IDMAP_FN}{self.IDMAP_SUFFIX}").as_posix()
+
+        if self.metric_type in FaissBuilder.BINARY_METRIC_TYPE:
+            faiss.write_index_binary(self.index, vector_path)
+        else:
+            faiss.write_index(self.index, vector_path)
+
+        yaml_writer = YAMLWriter()
+        yaml_writer.write(
+            index_info_path,
+            self.index_info,
+            default_flow_style=False,
+            allow_unicode=True,
+        )
+
+    @classmethod
+    def load(cls, index):
+        if isinstance(index, str):
+            index_root = Path(index)
+            vector_path = index_root / f"{cls.VECTOR_FN}{cls.VECTOR_SUFFIX}"
+            index_info_path = index_root / f"{cls.IDMAP_FN}{cls.IDMAP_SUFFIX}"
+
+            assert (
+                vector_path.exists()
+            ), f"Not found the {cls.VECTOR_FN}{cls.VECTOR_SUFFIX} file in {index}!"
+            assert (
+                index_info_path.exists()
+            ), f"Not found the {cls.IDMAP_FN}{cls.IDMAP_SUFFIX} file in {index}!"
+
+            yaml_reader = YAMLReader()
+            index_info = yaml_reader.read(index_info_path)
+            assert (
+                "id_map" in index_info
+                and "metric_type" in index_info
+                and "index_type" in index_info
+            ), f"The index_info file({index_info_path}) may have been damaged, `id_map` or `metric_type` or `index_type` not found in `index_info`."
+            id_map = IndexData._convert_int64(index_info["id_map"])
+
+            if index_info["metric_type"] in FaissBuilder.BINARY_METRIC_TYPE:
+                index = faiss.read_index_binary(vector_path.as_posix())
+            else:
+                index = faiss.read_index(vector_path.as_posix())
+            assert index.ntotal == len(
+                id_map
+            ), "data number in index is not equal in in id_map"
+
+            return index, id_map, index_info["metric_type"], index_info["index_type"]
+        else:
+            assert isinstance(index, IndexData)
+            return index.index, index.id_map, index.metric_type, index.index_type
+
+
+class FaissIndexer:
+
+    def __init__(
+        self,
+        index,
+    ):
+        super().__init__()
+        self._indexer, self.id_map, self.metric_type, index_type = IndexData.load(index)
+
+    def __call__(self, feature, score_thres, hamming_radius, topk):
+        scores_list, ids_list = self._indexer.search(np.array(feature), topk)
+        preds = []
+        for scores, ids in zip(scores_list, ids_list):
+            preds.append({"score": [], "label": []})
+            for score, id in zip(scores, ids):
+                if id >= 0:
+                    preds[-1]["score"].append(score)
+                    preds[-1]["label"].append(self.id_map[id])
+
+        if self.metric_type in FaissBuilder.BINARY_METRIC_TYPE:
+            idxs = np.where(scores_list[:, 0] > hamming_radius)[0]
+        else:
+            idxs = np.where(scores_list[:, 0] < score_thres)[0]
+        for idx in idxs:
+            preds[idx] = {"score": None, "label": None}
+        return preds
+
+
+@class_requires_deps("faiss-cpu")
+class FaissBuilder:
+
+    SUPPORT_METRIC_TYPE = ("hamming", "IP", "L2")
+    SUPPORT_INDEX_TYPE = ("Flat", "IVF", "HNSW32")
+    BINARY_METRIC_TYPE = ("hamming",)
+    BINARY_SUPPORT_INDEX_TYPE = ("Flat", "IVF", "BinaryHash")
+
+    @classmethod
+    def _get_index_type(cls, metric_type, index_type, num=None):
+        # if IVF method, cal ivf number automaticlly
+        if index_type == "IVF":
+            index_type = index_type + str(min(int(num // 8), 65536))
+            if metric_type in cls.BINARY_METRIC_TYPE:
+                index_type += ",BFlat"
+            else:
+                index_type += ",Flat"
+
+        # for binary index, add B at head of index_type
+        if metric_type in cls.BINARY_METRIC_TYPE:
+            assert (
+                index_type in cls.BINARY_SUPPORT_INDEX_TYPE
+            ), f"The metric type({metric_type}) only support {cls.BINARY_SUPPORT_INDEX_TYPE} index types!"
+            index_type = "B" + index_type
+
+        if index_type == "HNSW32":
+            logging.warning("The HNSW32 method dose not support 'remove' operation")
+            index_type = "HNSW32"
+
+        if index_type == "Flat":
+            index_type = "Flat"
+
+        return index_type
+
+    @classmethod
+    def _get_metric_type(cls, metric_type):
+        if metric_type == "hamming":
+            return faiss.METRIC_Hamming
+        elif metric_type == "jaccard":
+            return faiss.METRIC_Jaccard
+        elif metric_type == "IP":
+            return faiss.METRIC_INNER_PRODUCT
+        elif metric_type == "L2":
+            return faiss.METRIC_L2
+
+    @classmethod
+    def build(
+        cls,
+        gallery_imgs,
+        gallery_label,
+        predict_func,
+        metric_type="IP",
+        index_type="HNSW32",
+    ):
+        assert (
+            index_type in cls.SUPPORT_INDEX_TYPE
+        ), f"Supported index types only: {cls.SUPPORT_INDEX_TYPE}!"
+
+        assert (
+            metric_type in cls.SUPPORT_METRIC_TYPE
+        ), f"Supported metric types only: {cls.SUPPORT_METRIC_TYPE}!"
+
+        if isinstance(gallery_label, str):
+            gallery_docs, gallery_list = cls.load_gallery(gallery_label, gallery_imgs)
+        else:
+            gallery_docs, gallery_list = gallery_label, gallery_imgs
+
+        features = [res["feature"] for res in predict_func(gallery_list)]
+        dtype = np.uint8 if metric_type in cls.BINARY_METRIC_TYPE else np.float32
+        features = np.array(features).astype(dtype)
+        vector_num, vector_dim = features.shape
+
+        if metric_type in cls.BINARY_METRIC_TYPE:
+            index = faiss.index_binary_factory(
+                vector_dim,
+                cls._get_index_type(metric_type, index_type, vector_num),
+                cls._get_metric_type(metric_type),
+            )
+        else:
+            index = faiss.index_factory(
+                vector_dim,
+                cls._get_index_type(metric_type, index_type, vector_num),
+                cls._get_metric_type(metric_type),
+            )
+            index = faiss.IndexIDMap2(index)
+        ids = {}
+
+        # calculate id for new data
+        index, ids = cls._add_gallery(
+            metric_type, index, ids, features, gallery_docs, mode="new"
+        )
+        return IndexData(
+            index, {"id_map": ids, "metric_type": metric_type, "index_type": index_type}
+        )
+
+    @classmethod
+    def remove(
+        cls,
+        remove_ids,
+        index,
+    ):
+        index, ids, metric_type, index_type = IndexData.load(index)
+        if index_type == "HNSW32":
+            raise RuntimeError(
+                "The index_type: HNSW32 dose not support 'remove' operation"
+            )
+        if isinstance(remove_ids, str):
+            lines = []
+            with open(remove_ids) as f:
+                lines = f.readlines()
+            remove_ids = []
+            for line in lines:
+                id_ = int(line.strip().split(" ")[0])
+                remove_ids.append(id_)
+            remove_ids = np.asarray(remove_ids)
+        else:
+            remove_ids = np.asarray(remove_ids)
+
+        # remove ids in id_map, remove index data in faiss index
+        index.remove_ids(remove_ids)
+        ids = {k: v for k, v in ids.items() if k not in remove_ids}
+        return IndexData(
+            index, {"id_map": ids, "metric_type": metric_type, "index_type": index_type}
+        )
+
+    @classmethod
+    def append(cls, gallery_imgs, gallery_label, predict_func, index):
+        index, ids, metric_type, index_type = IndexData.load(index)
+        assert (
+            metric_type in cls.SUPPORT_METRIC_TYPE
+        ), f"Supported metric types only: {cls.SUPPORT_METRIC_TYPE}!"
+
+        if isinstance(gallery_label, str):
+            gallery_docs, gallery_list = cls.load_gallery(gallery_label, gallery_imgs)
+        else:
+            gallery_docs, gallery_list = gallery_label, gallery_imgs
+
+        features = [res["feature"] for res in predict_func(gallery_list)]
+        dtype = np.uint8 if metric_type in cls.BINARY_METRIC_TYPE else np.float32
+        features = np.array(features).astype(dtype)
+
+        # calculate id for new data
+        index, ids = cls._add_gallery(
+            metric_type, index, ids, features, gallery_docs, mode="append"
+        )
+        return IndexData(
+            index, {"id_map": ids, "metric_type": metric_type, "index_type": index_type}
+        )
+
+    @classmethod
+    def _add_gallery(
+        cls, metric_type, index, ids, gallery_features, gallery_docs, mode
+    ):
+        start_id = max(ids.keys()) + 1 if ids else 0
+        ids_now = (np.arange(0, len(gallery_docs)) + start_id).astype(np.int64)
+
+        # only train when new index file
+        if mode == "new":
+            if metric_type in cls.BINARY_METRIC_TYPE:
+                index.add(gallery_features)
+            else:
+                index.train(gallery_features)
+
+        if metric_type not in cls.BINARY_METRIC_TYPE:
+            index.add_with_ids(gallery_features, ids_now)
+        # TODO(gaotingquan): how append when using hamming metric type
+        # else:
+        #   pass
+
+        for i, d in zip(list(ids_now), gallery_docs):
+            ids[i] = d
+        return index, ids
+
+    @classmethod
+    def load_gallery(cls, gallery_label_path, gallery_imgs_root="", delimiter=" "):
+        lines = []
+        files = []
+        labels = []
+        root = Path(gallery_imgs_root)
+        with open(gallery_label_path, "r", encoding="utf-8") as f:
+            lines = f.readlines()
+        for line in lines:
+            path, label = line.strip().split(delimiter)
+            file_path = root / path
+            files.append(file_path.as_posix())
+            labels.append(label)
+        return labels, files

paddlex/inference/pipelines/components/prompt_engineering/__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 .generate_ensemble_prompt import GenerateEnsemblePrompt
+from .generate_kie_prompt import GenerateKIEPrompt

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

@@ -0,0 +1,35 @@
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from abc import ABC, abstractmethod
+
+from .....utils.subclass_register import AutoRegisterABCMetaClass
+
+
+class BaseGeneratePrompt(ABC, metaclass=AutoRegisterABCMetaClass):
+    """Base Generate Prompt class."""
+
+    __is_base = True
+
+    def __init__(self):
+        """Initializes an instance of base generate prompt."""
+        super().__init__()
+
+    @abstractmethod
+    def generate_prompt(self):
+        """Declaration of an abstract method. Subclasses are expected to
+        provide a concrete implementation of generate prompt method."""
+        raise NotImplementedError(
+            "The method `generate_prompt` has not been implemented yet."
+        )

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

@@ -0,0 +1,128 @@
+# 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 GenerateEnsemblePrompt(BaseGeneratePrompt):
+    """Generate Ensemble Prompt"""
+
+    entities = ["ensemble_prompt"]
+
+    def __init__(self, config: Dict) -> None:
+        """Initializes the GenerateEnsemblePrompt 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 GenerateEnsemblePrompt."
+            )
+
+        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,
+        key: str,
+        result_methodA: str,
+        result_methodB: str,
+        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:
+            key (str): the input question.
+            result_methodA (str): the result of method A.
+            result_methodB (str): the result of method B.
+            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 == "ensemble_prompt":
+            prompt += f"""下面正式开始:
+                \n问题：```{key}```
+                \n方法A的结果：{result_methodA}
+                \n方法B的结果：{result_methodB}
+                """
+        else:
+            raise ValueError(f"{self.task_type} is currently not supported.")
+        return prompt