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

paddlex/model.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.
+
+from abc import abstractmethod
+from copy import deepcopy
+
+from .inference import create_predictor, PaddlePredictorOption
+from .modules import (
+    build_dataset_checker,
+    build_trainer,
+    build_evaluater,
+    build_exportor,
+)
+
+
+# TODO(gaotingquan): support _ModelBasedConfig
+def create_model(model=None, *args, **kwargs):
+    return _ModelBasedInference(model, *args, **kwargs)
+
+
+class _BaseModel:
+    def check_dataset(self, *args, **kwargs):
+        raise Exception("check_dataset is not supported!")
+
+    def train(self, *args, **kwargs):
+        raise Exception("train is not supported!")
+
+    def evaluate(self, *args, **kwargs):
+        raise Exception("evaluate is not supported!")
+
+    def export(self, *args, **kwargs):
+        raise Exception("export is not supported!")
+
+    def predict(self, *args, **kwargs):
+        raise Exception("predict is not supported!")
+
+    def set_predict(self, *args, **kwargs):
+        raise Exception("set_predict is not supported!")
+
+    def __call__(self, *args, **kwargs):
+        yield from self.predict(*args, **kwargs)
+
+
+class _ModelBasedInference(_BaseModel):
+    def __init__(self, *args, **kwargs):
+        self._predictor = create_predictor(*args, **kwargs)
+
+    def predict(self, *args, **kwargs):
+        yield from self._predictor(*args, **kwargs)
+
+    def set_predictor(self, **kwargs):
+        self._predictor.set_predictor(**kwargs)
+
+
+class _ModelBasedConfig(_BaseModel):
+    def __init__(self, config=None, *args, **kwargs):
+        super().__init__()
+        self._config = config
+        self._model_name = config.Global.model
+
+    def _build_predictor(self):
+        predict_kwargs = deepcopy(self._config.Predict)
+
+        model_dir = predict_kwargs.pop("model_dir", None)
+        # if model_dir is None, using official
+        model = self._model_name if model_dir is None else model_dir
+
+        device = self._config.Global.get("device")
+        kernel_option = predict_kwargs.pop("kernel_option", {})
+        kernel_option.update({"device": device})
+
+        pp_option = PaddlePredictorOption(self._model_name, **kernel_option)
+        predictor = create_predictor(model, pp_option=pp_option)
+        assert "input" in predict_kwargs
+        return predict_kwargs, predictor
+
+    def check_dataset(self):
+        dataset_checker = build_dataset_checker(self._config)
+        return dataset_checker.check()
+
+    def train(self):
+        trainer = build_trainer(self._config)
+        trainer.train()
+
+    def evaluate(self):
+        evaluator = build_evaluater(self._config)
+        return evaluator.evaluate()
+
+    def export(self):
+        exportor = build_exportor(self._config)
+        return exportor.export()
+
+    def predict(self):
+        predict_kwargs, predictor = self._build_predictor()
+        yield from predictor(**predict_kwargs)

paddlex/modules/__init__.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.
+
+
+from .base import (
+    build_dataset_checker,
+    build_trainer,
+    build_evaluater,
+    build_exportor,
+)
+
+from .image_classification import (
+    ClsDatasetChecker,
+    ClsTrainer,
+    ClsEvaluator,
+    ClsExportor,
+)
+
+from .multilabel_classification import (
+    MLClsDatasetChecker,
+    MLClsTrainer,
+    MLClsEvaluator,
+    MLClsExportor,
+)
+
+from .anomaly_detection import (
+    UadDatasetChecker,
+    UadTrainer,
+    UadEvaluator,
+    UadExportor,
+)
+from .general_recognition import (
+    ShiTuRecDatasetChecker,
+    ShiTuRecTrainer,
+    ShiTuRecEvaluator,
+    ShiTuRecExportor,
+)
+from .object_detection import (
+    COCODatasetChecker,
+    DetTrainer,
+    DetEvaluator,
+    DetExportor,
+)
+from .text_detection import (
+    TextDetDatasetChecker,
+    TextDetTrainer,
+    TextDetEvaluator,
+    TextDetExportor,
+)
+from .text_recognition import (
+    TextRecDatasetChecker,
+    TextRecTrainer,
+    TextRecEvaluator,
+    TextRecExportor,
+)
+from .table_recognition import (
+    TableRecDatasetChecker,
+    TableRecTrainer,
+    TableRecEvaluator,
+    TableRecExportor,
+)
+from .semantic_segmentation import (
+    SegDatasetChecker,
+    SegTrainer,
+    SegEvaluator,
+    SegExportor,
+)
+from .instance_segmentation import (
+    COCOInstSegDatasetChecker,
+    InstanceSegTrainer,
+    InstanceSegEvaluator,
+    InstanceSegExportor,
+)
+from .ts_anomaly_detection import (
+    TSADDatasetChecker,
+    TSADTrainer,
+    TSADEvaluator,
+    TSADExportor,
+)
+from .ts_classification import (
+    TSCLSDatasetChecker,
+    TSCLSTrainer,
+    TSCLSEvaluator,
+    TSCLSExportor,
+)
+
+from .face_recognition import (
+    FaceRecDatasetChecker,
+    FaceRecTrainer,
+    FaceRecEvaluator,
+    FaceRecExportor,
+)
+
+from .ts_forecast import TSFCDatasetChecker, TSFCTrainer, TSFCEvaluator

paddlex/modules/anomaly_detection/__init__.py

@@ -0,0 +1,18 @@
+# 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 .dataset_checker import UadDatasetChecker
+from .trainer import UadTrainer
+from .evaluator import UadEvaluator
+from .exportor import UadExportor

paddlex/modules/anomaly_detection/dataset_checker/__init__.py

@@ -0,0 +1,95 @@
+# 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
+import os.path as osp
+
+from ...base import BaseDatasetChecker
+from .dataset_src import check_dataset, convert_dataset, split_dataset, anaylse_dataset
+
+from ..model_list import MODELS
+
+
+class UadDatasetChecker(BaseDatasetChecker):
+    """Dataset Checker for Semantic Segmentation Model"""
+
+    entities = MODELS
+    sample_num = 10
+
+    def convert_dataset(self, src_dataset_dir: str) -> str:
+        """convert the dataset from other type to specified type
+
+        Args:
+            src_dataset_dir (str): the root directory of dataset.
+
+        Returns:
+            str: the root directory of converted dataset.
+        """
+        return convert_dataset(
+            self.check_dataset_config.convert.src_dataset_type, src_dataset_dir
+        )
+
+    def split_dataset(self, src_dataset_dir: str) -> str:
+        """repartition the train and validation dataset
+
+        Args:
+            src_dataset_dir (str): the root directory of dataset.
+
+        Returns:
+            str: the root directory of splited dataset.
+        """
+        return split_dataset(
+            src_dataset_dir,
+            self.check_dataset_config.split.train_percent,
+            self.check_dataset_config.split.val_percent,
+        )
+
+    def check_dataset(self, dataset_dir: str, sample_num: int = sample_num) -> dict:
+        """check if the dataset meets the specifications and get dataset summary
+
+        Args:
+            dataset_dir (str): the root directory of dataset.
+            sample_num (int): the number to be sampled.
+        Returns:
+            dict: dataset summary.
+        """
+        return check_dataset(dataset_dir, self.output, sample_num)
+
+    def analyse(self, dataset_dir: str) -> dict:
+        """deep analyse dataset
+
+        Args:
+            dataset_dir (str): the root directory of dataset.
+
+        Returns:
+            dict: the deep analysis results.
+        """
+        return anaylse_dataset(dataset_dir, self.output)
+
+    def get_show_type(self) -> str:
+        """get the show type of dataset
+
+        Returns:
+            str: show type
+        """
+        return "image"
+
+    def get_dataset_type(self) -> str:
+        """return the dataset type
+
+        Returns:
+            str: dataset type
+        """
+        return "SegDataset"

paddlex/modules/anomaly_detection/dataset_checker/dataset_src/__init__.py

@@ -0,0 +1,19 @@
+# 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 .check_dataset import check_dataset
+from .convert_dataset import convert_dataset
+from .split_dataset import split_dataset
+from .analyse_dataset import anaylse_dataset

paddlex/modules/anomaly_detection/dataset_checker/dataset_src/analyse_dataset.py

@@ -0,0 +1,79 @@
+# 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
+import os.path as osp
+
+import matplotlib.pyplot as plt
+import numpy as np
+from PIL import Image, ImageOps
+
+from .....utils.file_interface import custom_open
+from .....utils.logging import info
+
+
+def anaylse_dataset(dataset_dir, output):
+    """class analysis for dataset"""
+
+    split_tags = ["train", "val"]
+    label2count = {tag: dict() for tag in split_tags}
+    for tag in split_tags:
+        mapping_file = osp.join(dataset_dir, f"{tag}.txt")
+        with custom_open(mapping_file, "r") as fp:
+            lines = filter(None, (line.strip() for line in fp.readlines()))
+            for i, line in enumerate(lines):
+                _, ann_file = line.split(" ")
+                ann_file = osp.join(dataset_dir, ann_file)
+                ann = np.array(ImageOps.exif_transpose(Image.open(ann_file)), "uint8")
+                if tag == "train":
+                    if 0 not in label2count[tag]:
+                        label2count[tag][0] = 1
+                    else:
+                        label2count[tag][0] += 1
+
+                if tag == "val":
+                    for idx in set(ann.reshape([-1]).tolist()):
+                        if idx == 255:
+                            continue
+                        if idx not in label2count[tag]:
+                            label2count[tag][idx] = 1
+                        else:
+                            label2count[tag][idx] += 1
+            if label2count[tag].get(0, None) is None:
+                label2count[tag][0] = 0
+
+    train_label_idx = np.array(list(label2count["train"].keys()))
+    val_label_idx = np.array(list(label2count["val"].keys()))
+    label_idx = np.array(list(set(train_label_idx) | set(val_label_idx)))
+    x = np.arange(len(label_idx))
+    train_list = []
+    val_list = []
+    for i in range(len(label_idx)):
+        train_list.append(label2count["train"].get(i, 0))
+        val_list.append(label2count["val"].get(i, 0))
+    fig, ax = plt.subplots(figsize=(max(8, int(len(label_idx) / 5)), 5), dpi=120)
+
+    width = (0.5,)
+    ax.bar(x, train_list, width=width, label="train")
+    ax.bar(x + width, val_list, width=width, label="val")
+
+    plt.xticks(x + 0.25, label_idx)
+    ax.set_xlabel("Label Index")
+    ax.set_ylabel("Sample Counts")
+    plt.legend()
+    fig.tight_layout()
+    fig_path = os.path.join(output, "histogram.png")
+    fig.savefig(fig_path)
+    return {"histogram": os.path.join("check_dataset", "histogram.png")}

paddlex/modules/anomaly_detection/dataset_checker/dataset_src/check_dataset.py

@@ -0,0 +1,87 @@
+# 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
+import os.path as osp
+
+import numpy as np
+from PIL import Image, ImageOps
+import cv2
+
+from .utils.visualizer import visualize
+from .....utils.errors import DatasetFileNotFoundError
+from .....utils.file_interface import custom_open
+from .....utils.logging import info
+
+
+def check_dataset(dataset_dir, output, sample_num=10):
+    """check dataset"""
+    dataset_dir = osp.abspath(dataset_dir)
+    if not osp.exists(dataset_dir) or not osp.isdir(dataset_dir):
+        raise DatasetFileNotFoundError(file_path=dataset_dir)
+    vis_save_dir = osp.join(output, "demo_img")
+    if not osp.exists(vis_save_dir):
+        os.makedirs(vis_save_dir)
+    split_tags = ["train", "val"]
+    attrs = dict()
+    class_ids = set()
+    for tag in split_tags:
+        mapping_file = osp.join(dataset_dir, f"{tag}.txt")
+        if not osp.exists(mapping_file):
+            info(f"The mapping file ({mapping_file}) doesn't exist, ignored.")
+            info(
+                "If you are using MVTec_AD dataset, add args below in your training commands:"
+            )
+            info("-o CheckDataset.convert.enable=True")
+            info("-o CheckDataset.convert.src_dataset_type=MVTec_AD")
+            continue
+        with custom_open(mapping_file, "r") as fp:
+            lines = filter(None, (line.strip() for line in fp.readlines()))
+            for i, line in enumerate(lines):
+                img_file, ann_file = line.split(" ")
+                img_file = osp.join(dataset_dir, img_file)
+                ann_file = osp.join(dataset_dir, ann_file)
+                assert osp.exists(img_file), FileNotFoundError(
+                    f"{img_file} not exist, please check!"
+                )
+                assert osp.exists(ann_file), FileNotFoundError(
+                    f"{ann_file} not exist, please check!"
+                )
+                img = np.array(cv2.imread(img_file), "uint8")
+                ann = np.array(cv2.imread(ann_file), "uint8")[:, :, 0]
+                assert img.shape[:2] == ann.shape, ValueError(
+                    f"The shape of {img_file}:{img.shape[:2]} and "
+                    f"{ann_file}:{ann.shape} must be the same!"
+                )
+                if tag == "val":
+                    class_ids = class_ids | set(ann.reshape([-1]).tolist())
+                if i < sample_num:
+                    vis_img = visualize(img, ann)
+                    vis_img = Image.fromarray(vis_img)
+                    vis_save_path = osp.join(vis_save_dir, osp.basename(img_file))
+                    vis_img.save(vis_save_path)
+                    vis_save_path = osp.join(
+                        "check_dataset", os.path.relpath(vis_save_path, output)
+                    )
+                    if f"{tag}_sample_paths" not in attrs:
+                        attrs[f"{tag}_sample_paths"] = [vis_save_path]
+                    else:
+                        attrs[f"{tag}_sample_paths"].append(vis_save_path)
+            if f"{tag}_samples" not in attrs:
+                attrs[f"{tag}_samples"] = i + 1
+    if 255 in class_ids:
+        class_ids.remove(255)
+    attrs["num_classes"] = len(class_ids)
+    return attrs