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

paddlex/inference/models/base/basic_predictor.py

@@ -0,0 +1,122 @@
+# 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 inspect
+
+from ....utils.subclass_register import AutoRegisterABCMetaClass
+from ....utils.flags import (
+    INFER_BENCHMARK,
+    INFER_BENCHMARK_WARMUP,
+)
+from ....utils import logging
+from ...components.base import BaseComponent, ComponentsEngine
+from ...utils.pp_option import PaddlePredictorOption
+from ...utils.process_hook import generatorable_method
+from ...utils.benchmark import Benchmark
+from .base_predictor import BasePredictor
+
+
+class BasicPredictor(
+    BasePredictor,
+    metaclass=AutoRegisterABCMetaClass,
+):
+
+    __is_base = True
+
+    def __init__(self, model_dir, config=None, device=None, pp_option=None):
+        super().__init__(model_dir=model_dir, config=config)
+        if not pp_option:
+            pp_option = PaddlePredictorOption(model_name=self.model_name)
+        if device:
+            pp_option.device = device
+        self.pp_option = pp_option
+
+        self.components = {}
+        self._build_components()
+        self.engine = ComponentsEngine(self.components)
+        logging.debug(f"{self.__class__.__name__}: {self.model_dir}")
+
+        if INFER_BENCHMARK:
+            self.benchmark = Benchmark(self.components)
+
+    def __call__(self, input, **kwargs):
+        self.set_predictor(**kwargs)
+        if self.benchmark:
+            self.benchmark.start()
+            if INFER_BENCHMARK_WARMUP > 0:
+                output = super().__call__(input)
+                warmup_num = 0
+                for _ in range(INFER_BENCHMARK_WARMUP):
+                    try:
+                        next(output)
+                        warmup_num += 1
+                    except StopIteration:
+                        logging.warning(
+                            f"There are only {warmup_num} batches in input data, but `INFER_BENCHMARK_WARMUP` has been set to {INFER_BENCHMARK_WARMUP}."
+                        )
+                        break
+                self.benchmark.warmup_stop(warmup_num)
+            output = list(super().__call__(input))
+            self.benchmark.collect(len(output))
+        else:
+            yield from super().__call__(input)
+
+    def apply(self, input):
+        """predict"""
+        yield from self._generate_res(self.engine(input))
+
+    @generatorable_method
+    def _generate_res(self, batch_data):
+        return [{"result": self._pack_res(data)} for data in batch_data]
+
+    def _add_component(self, cmps):
+        if not isinstance(cmps, list):
+            cmps = [cmps]
+
+        for cmp in cmps:
+            if not isinstance(cmp, (list, tuple)):
+                key = cmp.name
+            else:
+                assert len(cmp) == 2
+                key = cmp[0]
+                cmp = cmp[1]
+            assert isinstance(key, str)
+            assert isinstance(cmp, BaseComponent)
+            assert (
+                key not in self.components
+            ), f"The key ({key}) has been used: {self.components}!"
+            self.components[key] = cmp
+
+    def set_predictor(self, batch_size=None, device=None, pp_option=None):
+        if batch_size:
+            self.components["ReadCmp"].batch_size = batch_size
+
+            self.pp_option.batch_size = batch_size
+        if device and device != self.pp_option.device:
+            self.pp_option.device = device
+        if pp_option and pp_option != self.pp_option:
+            self.pp_option = pp_option
+
+    def _has_setter(self, attr):
+        prop = getattr(self.__class__, attr, None)
+        return isinstance(prop, property) and prop.fset is not None
+
+    @abstractmethod
+    def _build_components(self):
+        raise NotImplementedError
+
+    @abstractmethod
+    def _pack_res(self, data):
+        raise NotImplementedError

paddlex/inference/models/face_recognition.py

@@ -0,0 +1,21 @@
+# 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 ...modules.face_recognition.model_list import MODELS
+from .general_recognition import ShiTuRecPredictor
+
+
+class FaceRecPredictor(ShiTuRecPredictor):
+
+    entities = MODELS

paddlex/inference/models/formula_recognition.py

@@ -0,0 +1,55 @@
+# 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 ...modules.formula_recognition.model_list import MODELS
+from ..components import *
+from ..results import FormulaRecResult
+from .base import BasicPredictor
+
+
+class LaTeXOCRPredictor(BasicPredictor):
+
+    entities = MODELS
+
+    def _build_components(self):
+        self._add_component(
+            [
+                ReadImage(format="RGB"),
+                LaTeXOCRReisizeNormImg(),
+            ]
+        )
+
+        predictor = ImagePredictor(
+            model_dir=self.model_dir,
+            model_prefix=self.MODEL_FILE_PREFIX,
+            option=self.pp_option,
+        )
+        self._add_component(predictor)
+
+        op = self.build_postprocess(**self.config["PostProcess"])
+        self._add_component(op)
+
+    def build_postprocess(self, **kwargs):
+        if kwargs.get("name") == "LaTeXOCRDecode":
+            return LaTeXOCRDecode(
+                character_list=kwargs.get("character_dict"),
+            )
+        else:
+            raise Exception()
+
+    def _pack_res(self, single):
+        keys = ["input_path", "rec_text"]
+        return FormulaRecResult({key: single[key] for key in keys})

paddlex/inference/models/general_recognition.py

@@ -0,0 +1,99 @@
+# 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 ...utils.func_register import FuncRegister
+from ...modules.general_recognition.model_list import MODELS
+from ..components import *
+from ..results import BaseResult
+from .base import BasicPredictor
+
+
+class ShiTuRecPredictor(BasicPredictor):
+
+    entities = MODELS
+
+    _FUNC_MAP = {}
+    register = FuncRegister(_FUNC_MAP)
+
+    def _build_components(self):
+        self._add_component(ReadImage(format="RGB"))
+        for cfg in self.config["PreProcess"]["transform_ops"]:
+            tf_key = list(cfg.keys())[0]
+            func = self._FUNC_MAP[tf_key]
+            args = cfg.get(tf_key, {})
+            op = func(self, **args) if args else func(self)
+            self._add_component(op)
+
+        predictor = ImagePredictor(
+            model_dir=self.model_dir,
+            model_prefix=self.MODEL_FILE_PREFIX,
+            option=self.pp_option,
+        )
+        self._add_component(predictor)
+
+        post_processes = self.config["PostProcess"]
+        for key in post_processes:
+            func = self._FUNC_MAP.get(key)
+            args = post_processes.get(key, {})
+            op = func(self, **args) if args else func(self)
+            self._add_component(op)
+
+    @register("ResizeImage")
+    # TODO(gaotingquan): backend & interpolation
+    def build_resize(
+        self,
+        resize_short=None,
+        size=None,
+        backend="cv2",
+        interpolation="LINEAR",
+        return_numpy=False,
+    ):
+        assert resize_short or size
+        if resize_short:
+            op = ResizeByShort(
+                target_short_edge=resize_short, size_divisor=None, interp="LINEAR"
+            )
+        else:
+            op = Resize(target_size=size)
+        return op
+
+    @register("CropImage")
+    def build_crop(self, size=224):
+        return Crop(crop_size=size)
+
+    @register("NormalizeImage")
+    def build_normalize(
+        self,
+        mean=[0.485, 0.456, 0.406],
+        std=[0.229, 0.224, 0.225],
+        scale=1 / 255,
+        order="",
+        channel_num=3,
+    ):
+        assert channel_num == 3
+        return Normalize(mean=mean, std=std)
+
+    @register("ToCHWImage")
+    def build_to_chw(self):
+        return ToCHWImage()
+
+    @register("NormalizeFeatures")
+    def build_normalize_features(self):
+        return NormalizeFeatures()
+
+    def _pack_res(self, data):
+        keys = ["input_path", "feature"]
+        return BaseResult({key: data[key] for key in keys})

paddlex/inference/models/image_classification.py

@@ -0,0 +1,101 @@
+# 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 ...utils.func_register import FuncRegister
+from ...modules.image_classification.model_list import MODELS
+from ..components import *
+from ..results import TopkResult
+from .base import BasicPredictor
+
+
+class ClasPredictor(BasicPredictor):
+
+    entities = [*MODELS]
+
+    _FUNC_MAP = {}
+    register = FuncRegister(_FUNC_MAP)
+
+    def _build_components(self):
+        self._add_component(ReadImage(format="RGB"))
+        for cfg in self.config["PreProcess"]["transform_ops"]:
+            tf_key = list(cfg.keys())[0]
+            func = self._FUNC_MAP[tf_key]
+            args = cfg.get(tf_key, {})
+            op = func(self, **args) if args else func(self)
+            self._add_component(op)
+
+        predictor = ImagePredictor(
+            model_dir=self.model_dir,
+            model_prefix=self.MODEL_FILE_PREFIX,
+            option=self.pp_option,
+        )
+        self._add_component(predictor)
+
+        post_processes = self.config["PostProcess"]
+        for key in post_processes:
+            func = self._FUNC_MAP.get(key)
+            args = post_processes.get(key, {})
+            op = func(self, **args) if args else func(self)
+            self._add_component(op)
+
+    @register("ResizeImage")
+    # TODO(gaotingquan): backend & interpolation
+    def build_resize(
+        self, resize_short=None, size=None, backend="cv2", interpolation="LINEAR"
+    ):
+        assert resize_short or size
+        if resize_short:
+            op = ResizeByShort(
+                target_short_edge=resize_short, size_divisor=None, interp="LINEAR"
+            )
+        else:
+            op = Resize(target_size=size)
+        return op
+
+    @register("CropImage")
+    def build_crop(self, size=224):
+        return Crop(crop_size=size)
+
+    @register("NormalizeImage")
+    def build_normalize(
+        self,
+        mean=[0.485, 0.456, 0.406],
+        std=[0.229, 0.224, 0.225],
+        scale=1 / 255,
+        order="",
+        channel_num=3,
+    ):
+        assert channel_num == 3
+        assert order == ""
+        return Normalize(scale=scale, mean=mean, std=std)
+
+    @register("ToCHWImage")
+    def build_to_chw(self):
+        return ToCHWImage()
+
+    @register("Topk")
+    def build_topk(self, topk, label_list=None):
+        return Topk(topk=int(topk), class_ids=label_list)
+
+    @register("MultiLabelThreshOutput")
+    def build_threshoutput(self, threshold, label_list=None):
+        return MultiLabelThreshOutput(threshold=float(threshold), class_ids=label_list)
+
+    def _pack_res(self, single):
+        keys = ["input_path", "class_ids", "scores"]
+        if "label_names" in single:
+            keys.append("label_names")
+        return TopkResult({key: single[key] for key in keys})

paddlex/inference/models/image_unwarping.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.
+
+from ...modules.image_unwarping.model_list import MODELS
+from ..components import *
+from ..results import DocTrResult
+from .base import BasicPredictor
+
+
+class WarpPredictor(BasicPredictor):
+
+    entities = MODELS
+
+    def _build_components(self):
+        self._add_component(
+            [
+                ReadImage(format="RGB"),
+                Normalize(mean=0.0, std=1.0, scale=1.0 / 255),
+                ToCHWImage(),
+            ]
+        )
+
+        predictor = ImagePredictor(
+            model_dir=self.model_dir,
+            model_prefix=self.MODEL_FILE_PREFIX,
+            option=self.pp_option,
+        )
+        self._add_component([predictor, DocTrPostProcess()])
+
+    def _pack_res(self, single):
+        keys = ["input_path", "doctr_img"]
+        return DocTrResult({key: single[key] for key in keys})

paddlex/inference/models/instance_segmentation.py

@@ -0,0 +1,66 @@
+# 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 .object_detection import DetPredictor
+from ...utils.func_register import FuncRegister
+from ...modules.instance_segmentation.model_list import MODELS
+from ..components import *
+from ..results import InstanceSegResult
+
+
+class InstanceSegPredictor(DetPredictor):
+
+    entities = MODELS
+
+    def _build_components(self):
+        self._add_component(ReadImage(format="RGB"))
+        for cfg in self.config["Preprocess"]:
+            tf_key = cfg["type"]
+            func = self._FUNC_MAP[tf_key]
+            cfg.pop("type")
+            args = cfg
+            op = func(self, **args) if args else func(self)
+            self._add_component(op)
+
+        predictor = ImageDetPredictor(
+            model_dir=self.model_dir,
+            model_prefix=self.MODEL_FILE_PREFIX,
+            option=self.pp_option,
+        )
+        model_names = ["RT-DETR", "SOLOv2", "RCNN", "YOLO"]
+        if any(name in self.model_name for name in model_names):
+            predictor.set_inputs(
+                {"img": "img", "scale_factors": "scale_factors", "img_size": "img_size"}
+            )
+
+        postprecss = InstanceSegPostProcess(
+            threshold=self.config["draw_threshold"],
+            labels=self.config["label_list"],
+        )
+
+        if "SOLOv2" in self.model_name:
+            postprecss.set_inputs(
+                {
+                    "class_id": "class_id",
+                    "masks": "masks",
+                    "img_size": "img_size",
+                }
+            )
+        self._add_component([predictor, postprecss])
+
+    def _pack_res(self, single):
+        keys = ["input_path", "boxes", "masks"]
+        return InstanceSegResult({key: single[key] for key in keys})

paddlex/inference/models/multilabel_classification.py

@@ -0,0 +1,33 @@
+# 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 ...utils.func_register import FuncRegister
+from ...modules.multilabel_classification.model_list import MODELS
+from ..components import *
+from ..results import MLClassResult
+from ..utils.process_hook import batchable_method
+from .image_classification import ClasPredictor
+
+
+class MLClasPredictor(ClasPredictor):
+
+    entities = [*MODELS]
+
+    def _pack_res(self, single):
+        keys = ["input_path", "class_ids", "scores"]
+        if "label_names" in single:
+            keys.append("label_names")
+        return MLClassResult({key: single[key] for key in keys})

paddlex/inference/models/object_detection.py

@@ -0,0 +1,129 @@
+# 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 ...utils.func_register import FuncRegister
+from ...modules.object_detection.model_list import MODELS
+from ..components import *
+from ..results import DetResult
+from .base import BasicPredictor
+
+
+class DetPredictor(BasicPredictor):
+
+    entities = MODELS
+
+    _FUNC_MAP = {}
+    register = FuncRegister(_FUNC_MAP)
+
+    def _build_components(self):
+        self._add_component(ReadImage(format="RGB"))
+        for cfg in self.config["Preprocess"]:
+            tf_key = cfg["type"]
+            func = self._FUNC_MAP[tf_key]
+            cfg.pop("type")
+            args = cfg
+            op = func(self, **args) if args else func(self)
+            self._add_component(op)
+
+        predictor = ImageDetPredictor(
+            model_dir=self.model_dir,
+            model_prefix=self.MODEL_FILE_PREFIX,
+            option=self.pp_option,
+        )
+        model_names = ["DETR", "RCNN", "YOLOv3", "CenterNet"]
+        if any(name in self.model_name for name in model_names):
+            predictor.set_inputs(
+                {
+                    "img": "img",
+                    "scale_factors": "scale_factors",
+                    "img_size": "img_size",
+                }
+            )
+
+        if self.model_name in ["BlazeFace", "BlazeFace-FPN-SSH"]:
+            predictor.set_inputs(
+                {
+                    "img": "img",
+                    "img_size": "img_size",
+                }
+            )
+
+        self._add_component(
+            [
+                predictor,
+                DetPostProcess(
+                    threshold=self.config["draw_threshold"],
+                    labels=self.config["label_list"],
+                ),
+            ]
+        )
+
+    @register("Resize")
+    def build_resize(self, target_size, keep_ratio=False, interp=2):
+        assert target_size
+        if isinstance(interp, int):
+            interp = {
+                0: "NEAREST",
+                1: "LINEAR",
+                2: "CUBIC",
+                3: "AREA",
+                4: "LANCZOS4",
+            }[interp]
+        op = Resize(target_size=target_size[::-1], keep_ratio=keep_ratio, interp=interp)
+        return op
+
+    @register("NormalizeImage")
+    def build_normalize(
+        self,
+        norm_type=None,
+        mean=[0.485, 0.456, 0.406],
+        std=[0.229, 0.224, 0.225],
+        is_scale=True,
+    ):
+        if is_scale:
+            scale = 1.0 / 255.0
+        else:
+            scale = 1
+        if not norm_type or norm_type == "none":
+            norm_type = "mean_std"
+        if norm_type != "mean_std":
+            mean = 0
+            std = 1
+        return Normalize(scale=scale, mean=mean, std=std)
+
+    @register("Permute")
+    def build_to_chw(self):
+        return ToCHWImage()
+
+    @register("Pad")
+    def build_pad(self, fill_value=None, size=None):
+        if fill_value is None:
+            fill_value = [127.5, 127.5, 127.5]
+        if size is None:
+            size = [3, 640, 640]
+        return DetPad(size=size, fill_value=fill_value)
+
+    @register("PadStride")
+    def build_pad_stride(self, stride=32):
+        return PadStride(stride=stride)
+
+    @register("WarpAffine")
+    def build_warp_affine(self, input_h=512, input_w=512, keep_res=True):
+        return WarpAffine(input_h=input_h, input_w=input_w, keep_res=keep_res)
+
+    def _pack_res(self, single):
+        keys = ["input_path", "boxes"]
+        return DetResult({key: single[key] for key in keys})