paddlex 2.1.0__py3-none-any.whl → 3.0.0rc0__py3-none-any.whl

paddlex/modules/base/trainer.py

@@ -0,0 +1,134 @@
+# 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 abc import ABC, abstractmethod
+from pathlib import Path
+from .build_model import build_model
+from ...utils.device import (
+    update_device_num,
+    set_env_for_device,
+    check_supported_device,
+)
+from ...utils.misc import AutoRegisterABCMetaClass
+from ...utils.config import AttrDict
+from ...utils.logging import info
+
+
+def build_trainer(config: AttrDict) -> "BaseTrainer":
+    """build model trainer
+
+    Args:
+        config (AttrDict): PaddleX pipeline config, which is loaded from pipeline yaml file.
+
+    Returns:
+        BaseTrainer: the trainer, which is subclass of BaseTrainer.
+    """
+    model_name = config.Global.model
+    try:
+        import feature_line_modules
+    except ModuleNotFoundError:
+        pass
+    return BaseTrainer.get(model_name)(config)
+
+
+class BaseTrainer(ABC, metaclass=AutoRegisterABCMetaClass):
+    """Base Model Trainer"""
+
+    __is_base = True
+
+    def __init__(self, config: AttrDict):
+        """Initialize the instance.
+
+        Args:
+            config (AttrDict):  PaddleX pipeline config, which is loaded from pipeline yaml file.
+        """
+        super().__init__()
+        self.config = config
+        self.global_config = config.Global
+        self.train_config = config.Train
+        self.eval_config = config.Evaluate
+        self.benchmark_config = config.get("Benchmark", None)
+        config_path = self.train_config.get("basic_config_path", None)
+
+        self.pdx_config, self.pdx_model = build_model(
+            self.global_config.model, config_path=config_path
+        )
+
+    def train(self, *args, **kwargs):
+        """execute model training"""
+        os.makedirs(self.global_config.output, exist_ok=True)
+        self.update_config()
+        self.dump_config()
+        train_args = self.get_train_kwargs()
+        if self.benchmark_config is not None:
+            train_args.update({"benchmark": self.benchmark_config})
+        export_with_pir = self.global_config.get("export_with_pir", False) or os.getenv(
+            "FLAGS_json_format_model"
+        ) in ["1", "True"]
+        train_args.update(
+            {
+                "uniform_output_enabled": self.train_config.get(
+                    "uniform_output_enabled", True
+                ),
+                "export_with_pir": export_with_pir,
+            }
+        )
+        train_result = self.pdx_model.train(**train_args)
+        assert (
+            train_result.returncode == 0
+        ), f"Encountered an unexpected error({train_result.returncode}) in \
+training!"
+
+    def dump_config(self, config_file_path: str = None):
+        """dump the config
+
+        Args:
+            config_file_path (str, optional): the path to save dumped config. Defaults to None,
+                means that save in `Global.output` as `config.yaml`.
+        """
+        if config_file_path is None:
+            config_file_path = os.path.join(self.global_config.output, "config.yaml")
+        self.pdx_config.dump(config_file_path)
+
+    def get_device(self, using_device_number: int = None) -> str:
+        """get device setting from config
+
+        Args:
+            using_device_number (int, optional): specify device number to use. Defaults to None,
+                means that base on config setting.
+
+        Returns:
+            str: device setting, such as: `gpu:0,1`, `npu:0,1` `cpu`.
+        """
+        check_supported_device(self.global_config.device, self.global_config.model)
+        set_env_for_device(self.global_config.device)
+        device_setting = (
+            update_device_num(self.global_config.device, using_device_number)
+            if using_device_number
+            else self.global_config.device
+        )
+        # replace "dcu" with "gpu"
+        device_setting = device_setting.replace("dcu", "gpu")
+        return device_setting
+
+    @abstractmethod
+    def update_config(self):
+        """update training config"""
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_train_kwargs(self):
+        """get key-value arguments of model training function"""
+        raise NotImplementedError

paddlex/modules/face_recognition/__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 .trainer import FaceRecTrainer
+from .dataset_checker import FaceRecDatasetChecker
+from .evaluator import FaceRecEvaluator
+from .exportor import FaceRecExportor

paddlex/modules/face_recognition/dataset_checker/__init__.py

@@ -0,0 +1,71 @@
+# 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 pathlib import Path
+
+from ...base import BaseDatasetChecker
+from .dataset_src import check_train, check_val
+from ..model_list import MODELS
+
+
+class FaceRecDatasetChecker(BaseDatasetChecker):
+    """Dataset Checker for Image Classification Model"""
+
+    entities = MODELS
+    sample_num = 10
+
+    def get_dataset_root(self, dataset_dir: str) -> str:
+        """find the dataset root dir
+
+        Args:
+            dataset_dir (str): the directory that contain dataset.
+
+        Returns:
+            str: the root directory of dataset.
+        """
+        anno_dirs = list(Path(dataset_dir).glob("**/images"))
+        assert len(anno_dirs) == 2
+        dataset_dir = anno_dirs[0].parent.parent.as_posix()
+        return dataset_dir
+
+    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.
+        """
+        train_attr = check_train(os.path.join(dataset_dir, "train"), self.output)
+        val_attr = check_val(os.path.join(dataset_dir, "val"), self.output)
+        train_attr.update(val_attr)
+        return train_attr
+
+    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 "ClsDataset"

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

@@ -0,0 +1,16 @@
+# 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_train, check_val

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

@@ -0,0 +1,174 @@
+# 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 random
+import pickle
+from PIL import Image, ImageOps
+from collections import defaultdict
+from tqdm import tqdm
+
+from .....utils.errors import DatasetFileNotFoundError, CheckFailedError
+from .utils.visualizer import draw_label
+
+
+def check_train(dataset_dir, output, sample_num=10):
+    """check dataset"""
+    dataset_dir = osp.abspath(dataset_dir)
+    # Custom dataset
+    if not osp.exists(dataset_dir) or not osp.isdir(dataset_dir):
+        raise DatasetFileNotFoundError(file_path=dataset_dir)
+
+    delim = " "
+    valid_num_parts = 2
+
+    label_map_dict = dict()
+    sample_paths = []
+    labels = []
+
+    label_file = osp.join(dataset_dir, "label.txt")
+    if not osp.exists(label_file):
+        raise DatasetFileNotFoundError(
+            file_path=label_file,
+            solution=f"Ensure that `label.txt` exist in {dataset_dir}",
+        )
+    with open(label_file, "r", encoding="utf-8") as f:
+        all_lines = f.readlines()
+        random.seed(123)
+        random.shuffle(all_lines)
+        sample_cnts = len(all_lines)
+        for line in all_lines:
+            substr = line.strip("\n").split(delim)
+            if len(substr) != valid_num_parts:
+                raise CheckFailedError(
+                    f"The number of delimiter-separated items in each row in {label_file} \
+                            should be {valid_num_parts} (current delimiter is '{delim}')."
+                )
+            file_name = substr[0]
+            label = substr[1]
+
+            img_path = osp.join(dataset_dir, file_name)
+
+            if not osp.exists(img_path):
+                raise DatasetFileNotFoundError(file_path=img_path)
+
+            vis_save_dir = osp.join(output, "demo_img")
+            if not osp.exists(vis_save_dir):
+                os.makedirs(vis_save_dir)
+
+            try:
+                label = int(label)
+                label_map_dict[label] = str(label)
+            except (ValueError, TypeError) as e:
+                raise CheckFailedError(
+                    f"Ensure that the second number in each line in {label_file} should be int."
+                ) from e
+
+            if len(sample_paths) < sample_num:
+                img = Image.open(img_path)
+                img = ImageOps.exif_transpose(img)
+                vis_im = draw_label(img, label, label_map_dict)
+                vis_path = osp.join(vis_save_dir, osp.basename(file_name))
+                vis_im.save(vis_path)
+                sample_path = osp.join(
+                    "check_dataset", os.path.relpath(vis_path, output)
+                )
+                sample_paths.append(sample_path)
+            labels.append(label)
+    if min(labels) != 0:
+        raise CheckFailedError(
+            f"Ensure that the index starts from 0 in `{label_file}`."
+        )
+    num_classes = max(labels) + 1
+    attrs = {}
+    attrs["train_label_file"] = osp.relpath(label_file, output)
+    attrs["train_num_classes"] = num_classes
+    attrs["train_samples"] = sample_cnts
+    attrs["train_sample_paths"] = sample_paths
+    return attrs
+
+
+def check_val(dataset_dir, output, sample_num=10):
+    """check dataset"""
+    dataset_dir = osp.abspath(dataset_dir)
+    # Custom dataset
+    if not osp.exists(dataset_dir) or not osp.isdir(dataset_dir):
+        raise DatasetFileNotFoundError(file_path=dataset_dir)
+
+    delim = " "
+    valid_num_parts = 3
+
+    labels = []
+    sample_paths = []
+    label_file = osp.join(dataset_dir, "pair_label.txt")
+    if not osp.exists(label_file):
+        raise DatasetFileNotFoundError(
+            file_path=label_file,
+            solution=f"Ensure that `label.txt` exist in {dataset_dir}",
+        )
+    with open(label_file, "r", encoding="utf-8") as f:
+        all_lines = f.readlines()
+        random.seed(123)
+        random.shuffle(all_lines)
+        sample_cnts = len(all_lines)
+        for line in all_lines:
+            substr = line.strip("\n").split(delim)
+            if len(substr) != valid_num_parts:
+                raise CheckFailedError(
+                    f"The number of delimiter-separated items in each row in {label_file} \
+                            should be {valid_num_parts} (current delimiter is '{delim}')."
+                )
+            left_file_name = substr[0]
+            right_file_name = substr[1]
+            label = substr[2]
+
+            left_img_path = osp.join(dataset_dir, left_file_name)
+            if not osp.exists(left_img_path):
+                raise DatasetFileNotFoundError(file_path=left_img_path)
+
+            right_img_path = osp.join(dataset_dir, right_file_name)
+            if not osp.exists(right_img_path):
+                raise DatasetFileNotFoundError(file_path=right_img_path)
+
+            try:
+                label = int(label)
+                assert label in [0, 1], "Face eval dataset only support two classes"
+            except (ValueError, TypeError) as e:
+                raise CheckFailedError(
+                    f"Ensure that the second number in each line in {label_file} should be int."
+                ) from e
+
+            vis_save_dir = osp.join(output, "demo_img")
+            if not osp.exists(vis_save_dir):
+                os.makedirs(vis_save_dir)
+
+            if len(sample_paths) < sample_num:
+                img = Image.open(left_img_path)
+                img = ImageOps.exif_transpose(img)
+                vis_path = osp.join(vis_save_dir, osp.basename(left_file_name))
+                img.save(vis_path)
+                sample_path = osp.join(
+                    "check_dataset", os.path.relpath(vis_path, output)
+                )
+                sample_paths.append(sample_path)
+
+            labels.append(label)
+    num_classes = max(labels) + 1
+    attrs = {}
+    attrs["val_label_file"] = osp.relpath(label_file, output)
+    attrs["val_num_classes"] = num_classes
+    attrs["val_samples"] = sample_cnts
+    attrs["val_sample_paths"] = sample_paths
+    return attrs

paddlex/modules/face_recognition/dataset_checker/dataset_src/utils/__init__.py

@@ -0,0 +1,13 @@
+# 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.

paddlex/modules/face_recognition/dataset_checker/dataset_src/utils/visualizer.py

@@ -0,0 +1,156 @@
+# 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 numpy as np
+import json
+from pathlib import Path
+import PIL
+from PIL import Image, ImageDraw, ImageFont
+
+from ......utils.fonts import PINGFANG_FONT_FILE_PATH
+
+
+def colormap(rgb=False):
+    """
+    Get colormap
+    """
+    color_list = np.array(
+        [
+            0xFF,
+            0x00,
+            0x00,
+            0xCC,
+            0xFF,
+            0x00,
+            0x00,
+            0xFF,
+            0x66,
+            0x00,
+            0x66,
+            0xFF,
+            0xCC,
+            0x00,
+            0xFF,
+            0xFF,
+            0x4D,
+            0x00,
+            0x80,
+            0xFF,
+            0x00,
+            0x00,
+            0xFF,
+            0xB2,
+            0x00,
+            0x1A,
+            0xFF,
+            0xFF,
+            0x00,
+            0xE5,
+            0xFF,
+            0x99,
+            0x00,
+            0x33,
+            0xFF,
+            0x00,
+            0x00,
+            0xFF,
+            0xFF,
+            0x33,
+            0x00,
+            0xFF,
+            0xFF,
+            0x00,
+            0x99,
+            0xFF,
+            0xE5,
+            0x00,
+            0x00,
+            0xFF,
+            0x1A,
+            0x00,
+            0xB2,
+            0xFF,
+            0x80,
+            0x00,
+            0xFF,
+            0xFF,
+            0x00,
+            0x4D,
+        ]
+    ).astype(np.float32)
+    color_list = color_list.reshape((-1, 3))
+    if not rgb:
+        color_list = color_list[:, ::-1]
+    return color_list.astype("int32")
+
+
+def font_colormap(color_index):
+    """
+    Get font colormap
+    """
+    dark = np.array([0x14, 0x0E, 0x35])
+    light = np.array([0xFF, 0xFF, 0xFF])
+    light_indexs = [0, 3, 4, 8, 9, 13, 14, 18, 19]
+    if color_index in light_indexs:
+        return light.astype("int32")
+    else:
+        return dark.astype("int32")
+
+
+def draw_label(image, label, label_map_dict):
+    """Draw label on image"""
+    image = image.convert("RGB")
+    image_size = image.size
+    draw = ImageDraw.Draw(image)
+    min_font_size = int(image_size[0] * 0.02)
+    max_font_size = int(image_size[0] * 0.05)
+    for font_size in range(max_font_size, min_font_size - 1, -1):
+        font = ImageFont.truetype(PINGFANG_FONT_FILE_PATH, font_size, encoding="utf-8")
+        if tuple(map(int, PIL.__version__.split("."))) <= (10, 0, 0):
+            text_width_tmp, text_height_tmp = draw.textsize(
+                label_map_dict[int(label)], font
+            )
+        else:
+            left, top, right, bottom = draw.textbbox(
+                (0, 0), label_map_dict[int(label)], font
+            )
+            text_width_tmp, text_height_tmp = right - left, bottom - top
+        if text_width_tmp <= image_size[0]:
+            break
+        else:
+            font = ImageFont.truetype(PINGFANG_FONT_FILE_PATH, min_font_size)
+    color_list = colormap(rgb=True)
+    color = tuple(color_list[0])
+    font_color = tuple(font_colormap(3))
+    if tuple(map(int, PIL.__version__.split("."))) <= (10, 0, 0):
+        text_width, text_height = draw.textsize(label_map_dict[int(label)], font)
+    else:
+        left, top, right, bottom = draw.textbbox(
+            (0, 0), label_map_dict[int(label)], font
+        )
+        text_width, text_height = right - left, bottom - top
+
+    rect_left = 3
+    rect_top = 3
+    rect_right = rect_left + text_width + 3
+    rect_bottom = rect_top + text_height + 6
+
+    draw.rectangle([(rect_left, rect_top), (rect_right, rect_bottom)], fill=color)
+
+    text_x = rect_left + 3
+    text_y = rect_top
+    draw.text((text_x, text_y), label_map_dict[int(label)], fill=font_color, font=font)
+
+    return image

paddlex/modules/face_recognition/evaluator.py

@@ -0,0 +1,52 @@
+# 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 ...utils.misc import abspath
+from ..base import BaseEvaluator
+from .model_list import MODELS
+
+
+class FaceRecEvaluator(BaseEvaluator):
+    """Face Recognition Model Evaluator"""
+
+    entities = MODELS
+
+    def update_config(self):
+        """update evalution config"""
+        if self.eval_config.log_interval:
+            self.pdx_config.update_log_interval(self.eval_config.log_interval)
+        self.update_dataset_cfg()
+        self.pdx_config.update_pretrained_weights(self.eval_config.weight_path)
+
+    def update_dataset_cfg(self):
+        val_dataset_dir = abspath(os.path.join(self.global_config.dataset_dir, "val"))
+        val_list_path = abspath(os.path.join(val_dataset_dir, "pair_label.txt"))
+        ds_cfg = [
+            f"DataLoader.Eval.dataset.name=FaceEvalDataset",
+            f"DataLoader.Eval.dataset.dataset_root={val_dataset_dir}",
+            f"DataLoader.Eval.dataset.pair_label_path={val_list_path}",
+        ]
+        self.pdx_config.update(ds_cfg)
+
+    def get_eval_kwargs(self) -> dict:
+        """get key-value arguments of model evalution function
+
+        Returns:
+            dict: the arguments of evaluation function.
+        """
+        return {
+            "weight_path": self.eval_config.weight_path,
+            "device": self.get_device(using_device_number=1),
+        }

paddlex/modules/face_recognition/exportor.py

@@ -0,0 +1,22 @@
+# 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 BaseExportor
+from .model_list import MODELS
+
+
+class FaceRecExportor(BaseExportor):
+    """Face Recognition Model Exportor"""
+
+    entities = MODELS

paddlex/modules/face_recognition/model_list.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.
+
+MODELS = ["MobileFaceNet", "ResNet50_face"]