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

paddlex/inference/models/semantic_segmentation.py

@@ -0,0 +1,86 @@
+# 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.semantic_segmentation.model_list import MODELS
+from ..components import *
+from ..results import SegResult
+from .base import BasicPredictor
+
+
+class SegPredictor(BasicPredictor):
+
+    entities = MODELS
+
+    _FUNC_MAP = {}
+    register = FuncRegister(_FUNC_MAP)
+
+    def _build_components(self):
+        self._add_component(ReadImage(format="RGB"))
+        self._add_component(ToCHWImage())
+        for cfg in self.config["Deploy"]["transforms"]:
+            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 = ImagePredictor(
+            model_dir=self.model_dir,
+            model_prefix=self.MODEL_FILE_PREFIX,
+            option=self.pp_option,
+        )
+        self._add_component(predictor)
+
+    @register("Resize")
+    def build_resize(
+        self, target_size, keep_ratio=False, size_divisor=None, interp="LINEAR"
+    ):
+        assert target_size
+        op = Resize(
+            target_size=target_size,
+            keep_ratio=keep_ratio,
+            size_divisor=size_divisor,
+            interp=interp,
+        )
+        return op
+
+    @register("ResizeByLong")
+    def build_resizebylong(self, long_size):
+        assert long_size
+        return ResizeByLong(
+            target_long_edge=long_size, size_divisor=size_divisor, interp=interp
+        )
+
+    @register("ResizeByShort")
+    def build_resizebylong(self, short_size):
+        assert short_size
+        return ResizeByLong(
+            target_long_edge=short_size, size_divisor=size_divisor, interp=interp
+        )
+
+    @register("Normalize")
+    def build_normalize(
+        self,
+        mean=0.5,
+        std=0.5,
+    ):
+        return Normalize(mean=mean, std=std)
+
+    def _pack_res(self, single):
+        keys = ["input_path", "pred"]
+        return SegResult({key: single[key] for key in keys})

paddlex/inference/models/table_recognition.py

@@ -0,0 +1,106 @@
+# 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.table_recognition.model_list import MODELS
+from ..components import *
+from ..results import TableRecResult
+from .base import BasicPredictor
+
+
+class TablePredictor(BasicPredictor):
+    """table recognition predictor"""
+
+    entities = MODELS
+
+    _FUNC_MAP = {}
+    register = FuncRegister(_FUNC_MAP)
+
+    def _build_components(self):
+        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)
+            if op:
+                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)
+
+        op = self.build_postprocess(
+            model_name=self.config["Global"]["model_name"], **self.config["PostProcess"]
+        )
+        self._add_component(op)
+
+    def build_postprocess(self, model_name, **kwargs):
+        if kwargs.get("name") == "TableLabelDecode":
+            return TableLabelDecode(
+                model_name=model_name,
+                merge_no_span_structure=kwargs.get("merge_no_span_structure"),
+                dict_character=kwargs.get("character_dict"),
+            )
+        else:
+            raise Exception()
+
+    @register("DecodeImage")
+    def build_readimg(self, channel_first=False, img_mode="BGR"):
+        assert channel_first is False
+        assert img_mode == "BGR"
+        return ReadImage(format=img_mode)
+
+    @register("TableLabelEncode")
+    def foo(self, *args, **kwargs):
+        return None
+
+    @register("TableBoxEncode")
+    def foo(self, *args, **kwargs):
+        return None
+
+    @register("ResizeTableImage")
+    def build_resize_table(self, max_len=488):
+        return ResizeByLong(target_long_edge=max_len)
+
+    @register("NormalizeImage")
+    def build_normalize(
+        self,
+        mean=[0.485, 0.456, 0.406],
+        std=[0.229, 0.224, 0.225],
+        scale=1 / 255,
+        order="hwc",
+    ):
+        return Normalize(mean=mean, std=std)
+
+    @register("PaddingTableImage")
+    def build_padding(self, size=[488, 448], pad_value=0):
+        return Pad(target_size=size[0], val=pad_value)
+
+    @register("ToCHWImage")
+    def build_to_chw(self):
+        return ToCHWImage()
+
+    @register("KeepKeys")
+    def foo(self, *args, **kwargs):
+        return None
+
+    def _pack_res(self, single):
+        keys = ["input_path", "bbox", "structure"]
+        return TableRecResult({key: single[key] for key in keys})

paddlex/inference/models/text_detection.py

@@ -0,0 +1,105 @@
+# 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.text_detection.model_list import MODELS
+from ..components import *
+from ..results import TextDetResult
+from .base import BasicPredictor
+
+
+class TextDetPredictor(BasicPredictor):
+
+    entities = MODELS
+
+    _FUNC_MAP = {}
+    register = FuncRegister(_FUNC_MAP)
+
+    def _build_components(self):
+        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)
+            if op:
+                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)
+
+        op = self.build_postprocess(**self.config["PostProcess"])
+        self._add_component(op)
+
+    @register("DecodeImage")
+    def build_readimg(self, channel_first, img_mode):
+        assert channel_first == False
+        return ReadImage(format=img_mode)
+
+    @register("DetResizeForTest")
+    def build_resize(self, **kwargs):
+        # TODO: align to PaddleOCR
+        if self.model_name in ("PP-OCRv4_server_det", "PP-OCRv4_mobile_det"):
+            resize_long = kwargs.get("resize_long", 960)
+            return DetResizeForTest(limit_side_len=resize_long, limit_type="max")
+        return DetResizeForTest(**kwargs)
+
+    @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,
+    ):
+        return NormalizeImage(
+            mean=mean, std=std, scale=scale, order=order, channel_num=channel_num
+        )
+
+    @register("ToCHWImage")
+    def build_to_chw(self):
+        return ToCHWImage()
+
+    def build_postprocess(self, **kwargs):
+        if kwargs.get("name") == "DBPostProcess":
+            return DBPostProcess(
+                thresh=kwargs.get("thresh", 0.3),
+                box_thresh=kwargs.get("box_thresh", 0.7),
+                max_candidates=kwargs.get("max_candidates", 1000),
+                unclip_ratio=kwargs.get("unclip_ratio", 2.0),
+                use_dilation=kwargs.get("use_dilation", False),
+                score_mode=kwargs.get("score_mode", "fast"),
+                box_type=kwargs.get("box_type", "quad"),
+            )
+
+        else:
+            raise Exception()
+
+    @register("DetLabelEncode")
+    def foo(self, *args, **kwargs):
+        return None
+
+    @register("KeepKeys")
+    def foo(self, *args, **kwargs):
+        return None
+
+    def _pack_res(self, single):
+        keys = ["input_path", "dt_polys", "dt_scores"]
+        return TextDetResult({key: single[key] for key in keys})

paddlex/inference/models/text_recognition.py

@@ -0,0 +1,78 @@
+# 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.text_recognition.model_list import MODELS
+from ..components import *
+from ..results import TextRecResult
+from .base import BasicPredictor
+
+
+class TextRecPredictor(BasicPredictor):
+
+    entities = MODELS
+
+    _FUNC_MAP = {}
+    register = FuncRegister(_FUNC_MAP)
+
+    def _build_components(self):
+        for cfg in self.config["PreProcess"]["transform_ops"]:
+            tf_key = list(cfg.keys())[0]
+            assert tf_key in self._FUNC_MAP
+            func = self._FUNC_MAP[tf_key]
+            args = cfg.get(tf_key, {})
+            op = func(self, **args) if args else func(self)
+            if op:
+                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)
+
+        op = self.build_postprocess(**self.config["PostProcess"])
+        self._add_component(op)
+
+    @register("DecodeImage")
+    def build_readimg(self, channel_first, img_mode):
+        assert channel_first == False
+        return ReadImage(format=img_mode)
+
+    @register("RecResizeImg")
+    def build_resize(self, image_shape):
+        return OCRReisizeNormImg(rec_image_shape=image_shape)
+
+    def build_postprocess(self, **kwargs):
+        if kwargs.get("name") == "CTCLabelDecode":
+            return CTCLabelDecode(
+                character_list=kwargs.get("character_dict"),
+            )
+        else:
+            raise Exception()
+
+    @register("MultiLabelEncode")
+    def foo(self, *args, **kwargs):
+        return None
+
+    @register("KeepKeys")
+    def foo(self, *args, **kwargs):
+        return None
+
+    def _pack_res(self, single):
+        keys = ["input_path", "rec_text", "rec_score"]
+        return TextRecResult({key: single[key] for key in keys})

paddlex/inference/models/ts_ad.py

@@ -0,0 +1,68 @@
+# 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 os
+
+from ...modules.ts_anomaly_detection.model_list import MODELS
+from ..components import *
+from ..results import TSAdResult
+from .base import BasicPredictor
+
+
+class TSAdPredictor(BasicPredictor):
+
+    entities = MODELS
+
+    def _build_components(self):
+        if not self.config.get("info_params", None):
+            raise Exception("info_params is not found in config file")
+
+        self._add_component(ReadTS())
+        self._add_component(TSCutOff(self.config["size"]))
+
+        if self.config.get("scale", None):
+            scaler_file_path = os.path.join(self.model_dir, "scaler.pkl")
+            if not os.path.exists(scaler_file_path):
+                raise Exception(f"Cannot find scaler file: {scaler_file_path}")
+            self._add_component(
+                TSNormalize(scaler_file_path, self.config["info_params"])
+            )
+
+        self._add_component(BuildTSDataset(self.config["info_params"]))
+
+        if self.config.get("time_feat", None):
+            self._add_component(
+                TimeFeature(
+                    self.config["info_params"],
+                    self.config["size"],
+                    self.config["holiday"],
+                )
+            )
+        self._add_component(TStoArray(self.config["input_data"]))
+
+        predictor = TSPPPredictor(
+            model_dir=self.model_dir,
+            model_prefix=self.MODEL_FILE_PREFIX,
+            option=self.pp_option,
+        )
+        self._add_component(predictor)
+
+        self._add_component(
+            GetAnomaly(self.config["model_threshold"], self.config["info_params"])
+        )
+
+    def _pack_res(self, single):
+        return TSAdResult(
+            {"input_path": single["input_path"], "anomaly": single["anomaly"]}
+        )

paddlex/inference/models/ts_cls.py

@@ -0,0 +1,57 @@
+# 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 os
+from ...modules.ts_classification.model_list import MODELS
+from ..components import *
+from ..results import TSClsResult
+from .base import BasicPredictor
+
+
+class TSClsPredictor(BasicPredictor):
+
+    entities = MODELS
+
+    def _build_components(self):
+        if not self.config.get("info_params", None):
+            raise Exception("info_params is not found in config file")
+
+        self._add_component(ReadTS())
+        if self.config.get("scale", None):
+            scaler_file_path = os.path.join(self.model_dir, "scaler.pkl")
+            if not os.path.exists(scaler_file_path):
+                raise Exception(f"Cannot find scaler file: {scaler_file_path}")
+            self._add_component(
+                TSNormalize(scaler_file_path, self.config["info_params"])
+            )
+
+        self._add_component(BuildTSDataset(self.config["info_params"]))
+        self._add_component(BuildPadMask(self.config["input_data"]))
+        self._add_component(TStoArray(self.config["input_data"]))
+
+        predictor = TSPPPredictor(
+            model_dir=self.model_dir,
+            model_prefix=self.MODEL_FILE_PREFIX,
+            option=self.pp_option,
+        )
+        self._add_component(predictor)
+        self._add_component(GetCls())
+
+    def _pack_res(self, single):
+        return TSClsResult(
+            {
+                "input_path": single["input_path"],
+                "classification": single["classification"],
+            }
+        )

paddlex/inference/models/ts_fc.py

@@ -0,0 +1,73 @@
+# 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 os
+
+from ...modules.ts_forecast.model_list import MODELS
+from ..components import *
+from ..results import TSFcResult
+from .base import BasicPredictor
+
+
+class TSFcPredictor(BasicPredictor):
+
+    entities = MODELS
+
+    def _build_components(self):
+        if not self.config.get("info_params", None):
+            raise Exception("info_params is not found in config file")
+
+        self._add_component(ReadTS())
+        self._add_component(TSCutOff(self.config["size"]))
+
+        if self.config.get("scale", None):
+            scaler_file_path = os.path.join(self.model_dir, "scaler.pkl")
+            if not os.path.exists(scaler_file_path):
+                raise Exception(f"Cannot find scaler file: {scaler_file_path}")
+            self._add_component(
+                TSNormalize(scaler_file_path, self.config["info_params"])
+            )
+
+        self._add_component(BuildTSDataset(self.config["info_params"]))
+
+        if self.config.get("time_feat", None):
+            self._add_component(
+                TimeFeature(
+                    self.config["info_params"],
+                    self.config["size"],
+                    self.config["holiday"],
+                )
+            )
+        self._add_component(TStoArray(self.config["input_data"]))
+
+        predictor = TSPPPredictor(
+            model_dir=self.model_dir,
+            model_prefix=self.MODEL_FILE_PREFIX,
+            option=self.pp_option,
+        )
+        self._add_component(predictor)
+
+        self._add_component(ArraytoTS(self.config["info_params"]))
+        if self.config.get("scale", None):
+            scaler_file_path = os.path.join(self.model_dir, "scaler.pkl")
+            if not os.path.exists(scaler_file_path):
+                raise Exception(f"Cannot find scaler file: {scaler_file_path}")
+            self._add_component(
+                TSDeNormalize(scaler_file_path, self.config["info_params"])
+            )
+
+    def _pack_res(self, single):
+        return TSFcResult(
+            {"input_path": single["input_path"], "forecast": single["pred"]}
+        )