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

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

@@ -0,0 +1,206 @@
+# 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 abc import abstractmethod
+import json
+from pathlib import Path
+import numpy as np
+from PIL import Image
+import pandas as pd
+
+from .....utils import logging
+from ....utils.io import (
+    JsonWriter,
+    ImageReader,
+    ImageWriter,
+    CSVWriter,
+    HtmlWriter,
+    XlsxWriter,
+    TextWriter,
+)
+
+#### [TODO] need tingquan to add explanatory notes
+
+
+def _save_list_data(save_func, save_path, data, *args, **kwargs):
+    save_path = Path(save_path)
+    if data is None:
+        return
+    if isinstance(data, list):
+        for idx, single in enumerate(data):
+            save_func(
+                (
+                    save_path.parent / f"{save_path.stem}_{idx}{save_path.suffix}"
+                ).as_posix(),
+                single,
+                *args,
+                **kwargs,
+            )
+    save_func(save_path.as_posix(), data, *args, **kwargs)
+    logging.info(f"The result has been saved in {save_path}.")
+
+
+class StrMixin:
+    @property
+    def str(self):
+        return self._to_str()
+
+    def _to_str(self, data, json_format=False, indent=4, ensure_ascii=False):
+        if json_format:
+            return json.dumps(data.json, indent=indent, ensure_ascii=ensure_ascii)
+        else:
+            return str(data)
+
+    def print(self, json_format=False, indent=4, ensure_ascii=False):
+        str_ = self._to_str(
+            self, json_format=json_format, indent=indent, ensure_ascii=ensure_ascii
+        )
+        logging.info(str_)
+
+
+class JsonMixin:
+    def __init__(self):
+        self._json_writer = JsonWriter()
+        self._show_funcs.append(self.save_to_json)
+
+    def _to_json(self):
+        def _format_data(obj):
+            if isinstance(obj, np.float32):
+                return float(obj)
+            elif isinstance(obj, np.ndarray):
+                return [_format_data(item) for item in obj.tolist()]
+            elif isinstance(obj, pd.DataFrame):
+                return obj.to_json(orient="records", force_ascii=False)
+            elif isinstance(obj, Path):
+                return obj.as_posix()
+            elif isinstance(obj, dict):
+                return type(obj)({k: _format_data(v) for k, v in obj.items()})
+            elif isinstance(obj, (list, tuple)):
+                return [_format_data(i) for i in obj]
+            else:
+                return obj
+
+        return _format_data(self)
+
+    @property
+    def json(self):
+        return self._to_json()
+
+    def save_to_json(self, save_path, indent=4, ensure_ascii=False, *args, **kwargs):
+        if not str(save_path).endswith(".json"):
+            save_path = Path(save_path) / f"{Path(self['input_path']).stem}.json"
+        _save_list_data(
+            self._json_writer.write,
+            save_path,
+            self.json,
+            indent=indent,
+            ensure_ascii=ensure_ascii,
+            *args,
+            **kwargs,
+        )
+
+
+class Base64Mixin:
+    def __init__(self, *args, **kwargs):
+        self._base64_writer = TextWriter(*args, **kwargs)
+        self._show_funcs.append(self.save_to_base64)
+
+    @abstractmethod
+    def _to_base64(self):
+        raise NotImplementedError
+
+    @property
+    def base64(self):
+        return self._to_base64()
+
+    def save_to_base64(self, save_path, *args, **kwargs):
+        if not str(save_path).lower().endswith((".b64")):
+            fp = Path(self["input_path"])
+            save_path = Path(save_path) / f"{fp.stem}{fp.suffix}"
+        _save_list_data(
+            self._base64_writer.write, save_path, self.base64, *args, **kwargs
+        )
+
+
+class ImgMixin:
+    def __init__(self, backend="pillow", *args, **kwargs):
+        self._img_writer = ImageWriter(backend=backend, *args, **kwargs)
+        self._show_funcs.append(self.save_to_img)
+
+    @abstractmethod
+    def _to_img(self):
+        raise NotImplementedError
+
+    @property
+    def img(self):
+        image = self._to_img()
+        # The img must be a PIL.Image obj
+        if isinstance(image, np.ndarray):
+            return Image.fromarray(image)
+        return image
+
+    def save_to_img(self, save_path, *args, **kwargs):
+        if not str(save_path).lower().endswith((".jpg", ".png")):
+            fp = Path(self["input_path"])
+            save_path = Path(save_path) / f"{fp.stem}{fp.suffix}"
+        _save_list_data(self._img_writer.write, save_path, self.img, *args, **kwargs)
+
+
+class CSVMixin:
+    def __init__(self, backend="pandas", *args, **kwargs):
+        self._csv_writer = CSVWriter(backend=backend, *args, **kwargs)
+        self._show_funcs.append(self.save_to_csv)
+
+    @abstractmethod
+    def _to_csv(self):
+        raise NotImplementedError
+
+    def save_to_csv(self, save_path, *args, **kwargs):
+        if not str(save_path).endswith(".csv"):
+            save_path = Path(save_path) / f"{Path(self['input_path']).stem}.csv"
+        _save_list_data(
+            self._csv_writer.write, save_path, self._to_csv(), *args, **kwargs
+        )
+
+
+class HtmlMixin:
+    def __init__(self, *args, **kwargs):
+        self._html_writer = HtmlWriter(*args, **kwargs)
+        self._show_funcs.append(self.save_to_html)
+
+    @property
+    def html(self):
+        return self._to_html()
+
+    def _to_html(self):
+        return self["html"]
+
+    def save_to_html(self, save_path, *args, **kwargs):
+        if not str(save_path).endswith(".html"):
+            save_path = Path(save_path) / f"{Path(self['input_path']).stem}.html"
+        _save_list_data(self._html_writer.write, save_path, self.html, *args, **kwargs)
+
+
+class XlsxMixin:
+    def __init__(self, *args, **kwargs):
+        self._xlsx_writer = XlsxWriter(*args, **kwargs)
+        self._show_funcs.append(self.save_to_xlsx)
+
+    def _to_xlsx(self):
+        return self["html"]
+
+    def save_to_xlsx(self, save_path, *args, **kwargs):
+        if not str(save_path).endswith(".xlsx"):
+            save_path = Path(save_path) / f"{Path(self['input_path']).stem}.xlsx"
+        _save_list_data(self._xlsx_writer.write, save_path, self.html, *args, **kwargs)

paddlex/inference/pipelines/doc_preprocessor/__init__.py

@@ -0,0 +1,15 @@
+# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .pipeline import DocPreprocessorPipeline

paddlex/inference/pipelines/doc_preprocessor/pipeline.py

@@ -0,0 +1,190 @@
+# 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 typing import Any, Dict, Optional, Union, List
+from scipy.ndimage import rotate
+import numpy as np
+from ..base import BasePipeline
+from .result import DocPreprocessorResult
+from ....utils import logging
+from ...common.reader import ReadImage
+from ...common.batch_sampler import ImageBatchSampler
+from ...utils.pp_option import PaddlePredictorOption
+
+
+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,
+    ) -> None:
+        """Initializes the doc preprocessor pipeline.
+
+        Args:
+            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.
+        """
+
+        super().__init__(device=device, pp_option=pp_option, use_hpip=use_hpip)
+
+        self.use_doc_orientation_classify = config.get(
+            "use_doc_orientation_classify", True
+        )
+        if self.use_doc_orientation_classify:
+            doc_ori_classify_config = config.get("SubModules", {}).get(
+                "DocOrientationClassify",
+                {"model_config_error": "config error for doc_ori_classify_model!"},
+            )
+            self.doc_ori_classify_model = self.create_model(doc_ori_classify_config)
+
+        self.use_doc_unwarping = config.get("use_doc_unwarping", True)
+        if self.use_doc_unwarping:
+            doc_unwarping_config = config.get("SubModules", {}).get(
+                "DocUnwarping",
+                {"model_config_error": "config error for doc_unwarping_model!"},
+            )
+            self.doc_unwarping_model = self.create_model(doc_unwarping_config)
+
+        self.batch_sampler = ImageBatchSampler(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.
+
+        Args:
+            model_settings (Dict): A dictionary containing model settings.
+
+        Returns:
+            bool: True if all required models are initialized according to the model settings, False otherwise.
+        """
+
+        if (
+            model_settings["use_doc_orientation_classify"]
+            and not self.use_doc_orientation_classify
+        ):
+            logging.error(
+                "Set use_doc_orientation_classify, but the model for doc orientation classify is not initialized."
+            )
+            return False
+
+        if model_settings["use_doc_unwarping"] and not self.use_doc_unwarping:
+            logging.error(
+                "Set use_doc_unwarping, but the model for doc unwarping is not initialized."
+            )
+            return False
+
+        return True
+
+    def get_model_settings(
+        self, use_doc_orientation_classify, use_doc_unwarping
+    ) -> dict:
+        """
+        Retrieve the model settings dictionary based on input parameters.
+
+        Args:
+            use_doc_orientation_classify (bool, optional): Whether to use document orientation classification.
+            use_doc_unwarping (bool, optional): Whether to use document unwarping.
+
+        Returns:
+            dict: A dictionary containing the model settings.
+        """
+        if use_doc_orientation_classify is None:
+            use_doc_orientation_classify = self.use_doc_orientation_classify
+        if use_doc_unwarping is None:
+            use_doc_unwarping = self.use_doc_unwarping
+        model_settings = {
+            "use_doc_orientation_classify": use_doc_orientation_classify,
+            "use_doc_unwarping": use_doc_unwarping,
+        }
+        return model_settings
+
+    def predict(
+        self,
+        input: Union[str, List[str], np.ndarray, List[np.ndarray]],
+        use_doc_orientation_classify: Optional[bool] = None,
+        use_doc_unwarping: Optional[bool] = None,
+    ) -> DocPreprocessorResult:
+        """
+        Predict the preprocessing result for the input image or images.
+
+        Args:
+            input (Union[str, list[str], np.ndarray, list[np.ndarray]]): The input image(s) or path(s) to the images or pdfs.
+            use_doc_orientation_classify (bool): Whether to use document orientation classification.
+            use_doc_unwarping (bool): Whether to use document unwarping.
+            **kwargs: Additional keyword arguments.
+
+        Returns:
+            DocPreprocessorResult: A generator yielding preprocessing results.
+        """
+
+        model_settings = self.get_model_settings(
+            use_doc_orientation_classify, use_doc_unwarping
+        )
+        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]
+
+            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)
+            else:
+                angle = -1
+                rot_img = image_array
+
+            if model_settings["use_doc_unwarping"]:
+                output_img = next(self.doc_unwarping_model(rot_img))["doctr_img"]
+            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)

paddlex/inference/pipelines/doc_preprocessor/result.py

@@ -0,0 +1,103 @@
+# 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 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 ....utils.fonts import PINGFANG_FONT_FILE_PATH, create_font
+from ...common.result import BaseCVResult, StrMixin, JsonMixin
+
+
+class DocPreprocessorResult(BaseCVResult):
+    """doc preprocessor result"""
+
+    def _to_img(self) -> Dict[str, Image.Image]:
+        """
+        Generate an image combining the original, rotated, and unwarping images.
+
+        Returns:
+            Dict[Image.Image]: A new image combining the original, rotated, and unwarping images
+        """
+        image = self["input_img"][:, :, ::-1]
+        rot_img = self["rot_img"][:, :, ::-1]
+        angle = self["angle"]
+        output_img = self["output_img"][:, :, ::-1]
+        use_doc_orientation_classify = self["model_settings"][
+            "use_doc_orientation_classify"
+        ]
+        use_doc_unwarping = self["model_settings"]["use_doc_unwarping"]
+        h1, w1 = image.shape[0:2]
+        h2, w2 = rot_img.shape[0:2]
+        h3, w3 = output_img.shape[0:2]
+        h = max(max(h1, h2), h3)
+        img_show = Image.new("RGB", (w1 + w2 + w3, h + 25), (255, 255, 255))
+        img_show.paste(Image.fromarray(image), (0, 0, w1, h1))
+        img_show.paste(Image.fromarray(rot_img), (w1, 0, w1 + w2, h2))
+        img_show.paste(Image.fromarray(output_img), (w1 + w2, 0, w1 + w2 + w3, h3))
+
+        draw_text = ImageDraw.Draw(img_show)
+        txt_list = ["Original Image", "Rotated Image", "Unwarping Image"]
+        txt_list[1] = f"Rotated Image ({use_doc_orientation_classify}, {angle})"
+        txt_list[2] = f"Unwarping Image ({use_doc_unwarping})"
+        region_w_list = [w1, w2, w3]
+        beg_w_list = [0, w1, w1 + w2]
+        for tno in range(len(txt_list)):
+            txt = txt_list[tno]
+            font = create_font(txt, (region_w_list[tno], 20), PINGFANG_FONT_FILE_PATH)
+            draw_text.text(
+                [10 + beg_w_list[tno], h + 2], txt, fill=(0, 0, 0), font=font
+            )
+        imgs = {"preprocessed_img": img_show}
+        return imgs
+
+    def _to_str(self, *args, **kwargs) -> Dict[str, str]:
+        """Converts the instance's attributes to a dictionary and then to a string.
+
+        Args:
+            *args: Additional positional arguments passed to the base class method.
+            **kwargs: Additional keyword arguments passed to the base class method.
+
+        Returns:
+            Dict[str, str]: A dictionary with the instance's attributes converted to strings.
+        """
+        data = {}
+        data["input_path"] = self["input_path"]
+        data["page_index"] = self["page_index"]
+        data["model_settings"] = self["model_settings"]
+        data["angle"] = self["angle"]
+        return JsonMixin._to_str(data, *args, **kwargs)
+
+    def _to_json(self, *args, **kwargs) -> Dict[str, str]:
+        """
+        Converts the object's data to a JSON dictionary.
+
+        Args:
+            *args: Positional arguments passed to the JsonMixin._to_json method.
+            **kwargs: Keyword arguments passed to the JsonMixin._to_json method.
+
+        Returns:
+            Dict[str, str]: A dictionary containing the object's data in JSON format.
+        """
+        data = {}
+        data["input_path"] = self["input_path"]
+        data["page_index"] = self["page_index"]
+        data["model_settings"] = self["model_settings"]
+        data["angle"] = self["angle"]
+        return JsonMixin._to_json(data, *args, **kwargs)

paddlex/inference/pipelines/face_recognition/__init__.py

@@ -0,0 +1,15 @@
+# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .pipeline import FaceRecPipeline

paddlex/inference/pipelines/face_recognition/pipeline.py

@@ -0,0 +1,61 @@
+# 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 numpy as np
+
+from ..pp_shitu_v2 import ShiTuV2Pipeline
+from .result import FaceRecResult
+
+
+class FaceRecPipeline(ShiTuV2Pipeline):
+    """Face Recognition Pipeline"""
+
+    entities = "face_recognition"
+
+    def get_rec_result(
+        self, raw_img, det_res, indexer, rec_threshold, hamming_radius, topk
+    ):
+        if len(det_res["boxes"]) == 0:
+            return {"label": [], "score": []}
+        subs_of_img = list(self.crop_by_boxes(raw_img, det_res["boxes"]))
+        img_list = [img["img"] for img in subs_of_img]
+        all_rec_res = list(self.rec_model(img_list))
+        all_rec_res = indexer(
+            [rec_res["feature"] for rec_res in all_rec_res],
+            score_thres=rec_threshold,
+            hamming_radius=hamming_radius,
+            topk=topk,
+        )
+        output = {"label": [], "score": []}
+        for res in all_rec_res:
+            output["label"].append(res["label"])
+            output["score"].append(res["score"])
+        return output
+
+    def get_final_result(self, input_data, raw_img, det_res, rec_res):
+        single_img_res = {"input_path": input_data, "input_img": raw_img, "boxes": []}
+        for i, obj in enumerate(det_res["boxes"]):
+            rec_scores = rec_res["score"][i]
+            if isinstance(rec_scores, np.ndarray):
+                rec_scores = rec_scores.tolist()
+            labels = rec_res["label"][i]
+            single_img_res["boxes"].append(
+                {
+                    "labels": labels,
+                    "rec_scores": rec_scores,
+                    "det_score": obj["score"],
+                    "coordinate": obj["coordinate"],
+                }
+            )
+        return FaceRecResult(single_img_res)

paddlex/inference/pipelines/face_recognition/result.py

@@ -0,0 +1,43 @@
+# 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 copy
+from ...common.result import BaseCVResult, JsonMixin, StrMixin
+from ..pp_shitu_v2.result import draw_box
+
+
+class FaceRecResult(BaseCVResult):
+
+    def _to_img(self):
+        """apply"""
+        boxes = [
+            {
+                "coordinate": box["coordinate"],
+                "label": box["labels"][0] if box["labels"] is not None else "Unknown",
+                "score": box["rec_scores"][0] if box["rec_scores"] is not None else 0,
+            }
+            for box in self["boxes"]
+        ]
+        image = draw_box(self["input_img"][..., ::-1], boxes)
+        return {"res": image}
+
+    def _to_str(self, *args, **kwargs):
+        data = copy.deepcopy(self)
+        data.pop("input_img")
+        return JsonMixin._to_str(data, *args, **kwargs)
+
+    def _to_json(self, *args, **kwargs):
+        data = copy.deepcopy(self)
+        data.pop("input_img")
+        return JsonMixin._to_json(data, *args, **kwargs)

paddlex/inference/pipelines/formula_recognition/__init__.py

@@ -0,0 +1,15 @@
+# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .pipeline import FormulaRecognitionPipeline