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

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

@@ -0,0 +1,132 @@
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
+#
+# 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
+from collections import defaultdict
+
+from PIL import Image, ImageOps
+
+from .....utils.errors import CheckFailedError, DatasetFileNotFoundError
+from .utils.visualizer import draw_multi_label
+
+
+def check(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)
+
+    tags = ["train", "val"]
+    delim = "\t"
+    valid_num_parts = 2
+
+    sample_cnts = dict()
+    label_map_dict = dict()
+    sample_paths = defaultdict(list)
+    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()
+        for line in all_lines:
+            substr = line.strip("\n").split(" ", 1)
+            try:
+                label_idx = int(substr[0])
+                labels.append(label_idx)
+                label_map_dict[label_idx] = str(substr[1])
+            except:
+                raise CheckFailedError(
+                    f"Ensure that the first number in each line in {label_file} should be int."
+                )
+    if min(labels) != 0:
+        raise CheckFailedError(
+            f"Ensure that the index starts from 0 in `{label_file}`."
+        )
+
+    for tag in tags:
+        file_list = osp.join(dataset_dir, f"{tag}.txt")
+        if not osp.exists(file_list):
+            if tag in ("train", "val"):
+                # train and val file lists must exist
+                raise DatasetFileNotFoundError(
+                    file_path=file_list,
+                    solution=f"Ensure that both `train.txt` and `val.txt` exist in {dataset_dir}",
+                )
+            else:
+                # tag == 'test'
+                continue
+        else:
+            with open(file_list, "r", encoding="utf-8") as f:
+                all_lines = f.readlines()
+                random.seed(123)
+                random.shuffle(all_lines)
+                sample_cnts[tag] = 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 {file_list} \
+                                    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)
+
+                    if len(sample_paths[tag]) < sample_num:
+                        img = Image.open(img_path)
+                        img = ImageOps.exif_transpose(img)
+                        vis_im = draw_multi_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[tag].append(sample_path)
+
+                    try:
+                        label = list(map(int, label.split(",")))
+                    except (ValueError, TypeError) as e:
+                        raise CheckFailedError(
+                            f"Ensure that the second number in each line in {label_file} should be int."
+                        ) from e
+
+    num_classes = max(labels) + 1
+
+    attrs = {}
+    attrs["label_file"] = osp.relpath(label_file, output)
+    attrs["num_classes"] = num_classes
+    attrs["train_samples"] = sample_cnts["train"]
+    attrs["train_sample_paths"] = sample_paths["train"]
+
+    attrs["val_samples"] = sample_cnts["val"]
+    attrs["val_sample_paths"] = sample_paths["val"]
+
+    return attrs

paddlex/modules/multilabel_classification/dataset_checker/dataset_src/convert_dataset.py

@@ -0,0 +1,120 @@
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
+#
+# 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.deps import function_requires_deps, is_dep_available
+from .....utils.errors import ConvertFailedError
+from .....utils.logging import info, warning
+
+if is_dep_available("pycocotools"):
+    from pycocotools.coco import COCO
+if is_dep_available("tqdm"):
+    from tqdm import tqdm
+
+
+def check_src_dataset(root_dir, dataset_type):
+    """check src dataset format validity"""
+    if dataset_type in ("COCO"):
+        pass
+    else:
+        raise ConvertFailedError(
+            message=f"数据格式转换失败！不支持{dataset_type}格式数据集。当前仅支持 COCO 格式。"
+        )
+
+    err_msg_prefix = f"数据格式转换失败！请参考上述`{dataset_type}格式数据集示例`检查待转换数据集格式。"
+
+    for anno in ["annotations/instance_train.json", "annotations/instance_val.json"]:
+        src_anno_path = os.path.join(root_dir, anno)
+        if not os.path.exists(src_anno_path):
+            raise ConvertFailedError(
+                message=f"{err_msg_prefix}保证{src_anno_path}文件存在。"
+            )
+    return None
+
+
+def convert(dataset_type, input_dir):
+    """convert dataset to multilabel format"""
+    # check format validity
+    check_src_dataset(input_dir, dataset_type)
+
+    if dataset_type in ("COCO"):
+        convert_coco_dataset(input_dir)
+    else:
+        raise ConvertFailedError(
+            message=f"数据格式转换失败！不支持{dataset_type}格式数据集。当前仅支持 COCO 格式。"
+        )
+
+
+def convert_coco_dataset(root_dir):
+    for anno in ["annotations/instance_train.json", "annotations/instance_val.json"]:
+        src_img_dir = root_dir
+        src_anno_path = os.path.join(root_dir, anno)
+        coco2multilabels(src_img_dir, src_anno_path, root_dir)
+
+
+@function_requires_deps("pycocotools", "tqdm")
+def coco2multilabels(src_img_dir, src_anno_path, root_dir):
+    image_dir = os.path.join(root_dir, "images")
+    label_type = (
+        os.path.basename(src_anno_path).replace("instance_", "").replace(".json", "")
+    )
+    anno_save_path = os.path.join(root_dir, "{}.txt".format(label_type))
+    coco = COCO(src_anno_path)
+    cat_id_map = {
+        old_cat_id: new_cat_id for new_cat_id, old_cat_id in enumerate(coco.getCatIds())
+    }
+    num_classes = len(list(cat_id_map.keys()))
+
+    with open(anno_save_path, "w") as fp:
+        for img_id in tqdm(sorted(coco.getImgIds())):
+            img_info = coco.loadImgs([img_id])[0]
+            img_filename = img_info["file_name"]
+            img_w = img_info["width"]
+            img_h = img_info["height"]
+
+            img_filepath = os.path.join(image_dir, img_filename)
+            if not os.path.exists(img_filepath):
+                warning(
+                    "Illegal image file: {}, "
+                    "and it will be ignored".format(img_filepath)
+                )
+                continue
+
+            if img_w < 0 or img_h < 0:
+                warning(
+                    "Illegal width: {} or height: {} in annotation, "
+                    "and im_id: {} will be ignored".format(img_w, img_h, img_id)
+                )
+                continue
+
+            ins_anno_ids = coco.getAnnIds(imgIds=[img_id])
+            instances = coco.loadAnns(ins_anno_ids)
+
+            label = [0] * num_classes
+            for instance in instances:
+                label[cat_id_map[instance["category_id"]]] = 1
+            img_filename = os.path.join("images", img_filename)
+            fp.writelines("{}\t{}\n".format(img_filename, ",".join(map(str, label))))
+        fp.close()
+    if label_type == "train":
+        label_txt_save_path = os.path.join(root_dir, "label.txt")
+        with open(label_txt_save_path, "w") as fp:
+            for cat in coco.cats.values():
+                id = cat["id"]
+                name = cat["name"]
+                fp.writelines("{} {}\n".format(id, name))
+            fp.close()
+            info("Save label names to {}.".format(label_txt_save_path))

paddlex/modules/multilabel_classification/dataset_checker/dataset_src/split_dataset.py

@@ -0,0 +1,81 @@
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
+#
+# 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 random import shuffle
+
+from .....utils.file_interface import custom_open
+
+
+def split_dataset(root_dir, train_rate, val_rate):
+    """
+    将图像数据集按照比例分成训练集、验证集和测试集，并生成对应的.txt文件。
+
+    Args:
+        root_dir (str): 数据集根目录路径。
+        train_rate (int): 训练集占总数据集的比例（%）。
+        val_rate (int): 验证集占总数据集的比例（%）。
+
+    Returns:
+        str: 数据划分结果信息。
+    """
+    sum_rate = train_rate + val_rate
+    assert (
+        sum_rate == 100
+    ), f"The sum of train_rate({train_rate}), val_rate({val_rate}) should equal 100!"
+    assert (
+        train_rate > 0 and val_rate > 0
+    ), f"The train_rate({train_rate}) and val_rate({val_rate}) should be greater than 0!"
+    tags = ["train", "val"]
+    valid_path = False
+    image_files = []
+    for tag in tags:
+        split_image_list = os.path.abspath(os.path.join(root_dir, f"{tag}.txt"))
+        rename_image_list = os.path.abspath(os.path.join(root_dir, f"{tag}.txt.bak"))
+        if os.path.exists(split_image_list):
+            with custom_open(split_image_list, "r") as f:
+                lines = f.readlines()
+            image_files = image_files + lines
+            valid_path = True
+            if not os.path.exists(rename_image_list):
+                os.rename(split_image_list, rename_image_list)
+
+    assert (
+        valid_path
+    ), f"The files to be divided{tags[0]}.txt, {tags[1]}.txt, do not exist in the dataset directory."
+
+    shuffle(image_files)
+    start = 0
+    image_num = len(image_files)
+    rate_list = [train_rate, val_rate]
+    for i, tag in enumerate(tags):
+
+        rate = rate_list[i]
+        if rate == 0:
+            continue
+
+        end = start + round(image_num * rate / 100)
+        if sum(rate_list[i + 1 :]) == 0:
+            end = image_num
+
+        txt_file = os.path.abspath(os.path.join(root_dir, tag + ".txt"))
+        with custom_open(txt_file, "w") as f:
+            m = 0
+            for id in range(start, end):
+                m += 1
+                f.write(image_files[id])
+        start = end
+
+    return root_dir

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

@@ -0,0 +1,13 @@
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
+#
+# 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/multilabel_classification/dataset_checker/dataset_src/utils/visualizer.py

@@ -0,0 +1,149 @@
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
+#
+# 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 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_multi_label(image, label, label_map_dict):
+    labels = label.split(",")
+    label_names = [
+        label_map_dict[i] for i, label in enumerate(labels) if int(label) == 1
+    ]
+    image = image.convert("RGB")
+    image_width, image_height = image.size
+    font_size = int(image_width * 0.06)
+
+    font = ImageFont.truetype(PINGFANG_FONT_FILE_PATH, font_size)
+    text_lines = []
+    row_width = 0
+    row_height = 0
+    row_text = "\t"
+    for label_name in label_names:
+        text = f"{label_name}\t"
+        x1, y1, x2, y2 = font.getbbox(text)
+        text_width, row_height = x2 - x1, y2 - y1
+        if row_width + text_width <= image_width:
+            row_text += text
+            row_width += text_width
+        else:
+            text_lines.append(row_text)
+            row_text = "\t" + text
+            row_width = text_width
+    text_lines.append(row_text)
+    color_list = colormap(rgb=True)
+    color = tuple(color_list[0])
+    new_image_height = image_height + len(text_lines) * int(row_height * 1.8)
+    new_image = Image.new("RGB", (image_width, new_image_height), color)
+    new_image.paste(image, (0, 0))
+
+    draw = ImageDraw.Draw(new_image)
+    font_color = tuple(font_colormap(3))
+    for i, text in enumerate(text_lines):
+        draw.text(
+            (0, image_height + i * int(row_height * 1.2)),
+            text,
+            fill=font_color,
+            font=font,
+        )
+    return new_image

paddlex/modules/multilabel_classification/evaluator.py

@@ -0,0 +1,43 @@
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
+#
+# 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 BaseEvaluator
+from .model_list import MODELS
+
+
+class MLClsEvaluator(BaseEvaluator):
+    """Image Classification Model Evaluator"""
+
+    entities = MODELS
+
+    def update_config(self):
+        """update evaluation config"""
+        if self.eval_config.log_interval:
+            self.pdx_config.update_log_interval(self.eval_config.log_interval)
+        if self.pdx_config["Arch"]["name"] == "DistillationModel":
+            self.pdx_config.update_teacher_model(pretrained=False)
+            self.pdx_config.update_student_model(pretrained=False)
+        self.pdx_config.update_dataset(self.global_config.dataset_dir, "MLClsDataset")
+        self.pdx_config.update_pretrained_weights(self.eval_config.weight_path)
+
+    def get_eval_kwargs(self) -> dict:
+        """get key-value arguments of model evaluation 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/multilabel_classification/exportor.py

@@ -0,0 +1,22 @@
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
+#
+# 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 MLClsExportor(BaseExportor):
+    """Image Classification Model Exportor"""
+
+    entities = MODELS

paddlex/modules/multilabel_classification/model_list.py

@@ -0,0 +1,24 @@
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
+#
+# 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 = [
+    "ResNet50_ML",
+    "PP-LCNet_x1_0_ML",
+    "PP-HGNetV2-B0_ML",
+    "PP-HGNetV2-B4_ML",
+    "PP-HGNetV2-B6_ML",
+    "CLIP_vit_base_patch16_448_ML",
+    "PP-LCNet_x1_0_pedestrian_attribute",
+    "PP-LCNet_x1_0_vehicle_attribute",
+]

paddlex/modules/multilabel_classification/trainer.py

@@ -0,0 +1,85 @@
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
+#
+# 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 shutil
+from pathlib import Path
+
+from ..base import BaseTrainer
+from .model_list import MODELS
+
+
+class MLClsTrainer(BaseTrainer):
+    """Image Classification Model Trainer"""
+
+    entities = MODELS
+
+    def dump_label_dict(self, src_label_dict_path: str):
+        """dump label dict config
+
+        Args:
+            src_label_dict_path (str): path to label dict file to be saved.
+        """
+        dst_label_dict_path = Path(self.global_config.output).joinpath("label_dict.txt")
+        shutil.copyfile(src_label_dict_path, dst_label_dict_path)
+
+    def update_config(self):
+        """update training config"""
+        if self.train_config.log_interval:
+            self.pdx_config.update_log_interval(self.train_config.log_interval)
+        if self.train_config.eval_interval:
+            self.pdx_config.update_eval_interval(self.train_config.eval_interval)
+        if self.train_config.save_interval:
+            self.pdx_config.update_save_interval(self.train_config.save_interval)
+
+        self.pdx_config.update_dataset(self.global_config.dataset_dir, "MLClsDataset")
+        if self.train_config.num_classes is not None:
+            self.pdx_config.update_num_classes(self.train_config.num_classes)
+        if (
+            self.train_config.pretrain_weight_path
+            and self.train_config.pretrain_weight_path != ""
+        ):
+            self.pdx_config.update_pretrained_weights(
+                self.train_config.pretrain_weight_path
+            )
+
+        label_dict_path = Path(self.global_config.dataset_dir).joinpath("label.txt")
+        if label_dict_path.exists():
+            self.dump_label_dict(label_dict_path)
+        if self.train_config.batch_size is not None:
+            self.pdx_config.update_batch_size(self.train_config.batch_size)
+        if self.train_config.learning_rate is not None:
+            self.pdx_config.update_learning_rate(self.train_config.learning_rate)
+        if self.train_config.epochs_iters is not None:
+            self.pdx_config._update_epochs(self.train_config.epochs_iters)
+        if self.train_config.warmup_steps is not None:
+            self.pdx_config.update_warmup_epochs(self.train_config.warmup_steps)
+        if self.global_config.output is not None:
+            self.pdx_config._update_output_dir(self.global_config.output)
+
+    def get_train_kwargs(self) -> dict:
+        """get key-value arguments of model training function
+
+        Returns:
+            dict: the arguments of training function.
+        """
+        train_args = {"device": self.get_device()}
+        if (
+            self.train_config.resume_path is not None
+            and self.train_config.resume_path != ""
+        ):
+            train_args["resume_path"] = self.train_config.resume_path
+        train_args["dy2st"] = self.train_config.get("dy2st", False)
+        # amp support 'O1', 'O2', 'OFF'
+        train_args["amp"] = self.train_config.get("amp", "OFF")
+        return train_args