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

paddlex/modules/object_detection/dataset_checker/dataset_src/check_dataset.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 os
+import os.path as osp
+from collections import defaultdict, Counter
+from pathlib import Path
+from PIL import Image, ImageOps
+import json
+from pycocotools.coco import COCO
+
+from .....utils.errors import DatasetFileNotFoundError
+from .utils.visualizer import draw_bbox
+
+
+def check(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)
+
+    sample_cnts = dict()
+    sample_paths = defaultdict(list)
+    im_sizes = defaultdict(Counter)
+    tags = ["instance_train", "instance_val"]
+    for _, tag in enumerate(tags):
+        file_list = osp.join(dataset_dir, f"annotations/{tag}.json")
+        if not osp.exists(file_list):
+            if tag in ("instance_train", "instance_val"):
+                # train and val file lists must exist
+                raise DatasetFileNotFoundError(
+                    file_path=file_list,
+                    solution=f"Ensure that both `instance_train.json` and `instance_val.json` exist in \
+{dataset_dir}/annotations",
+                )
+            else:
+                continue
+        else:
+            with open(file_list, "r", encoding="utf-8") as f:
+                jsondata = json.load(f)
+
+            coco = COCO(file_list)
+            num_class = len(coco.getCatIds())
+
+            vis_save_dir = osp.join(output, "demo_img")
+
+            image_info = jsondata["images"]
+            sample_cnts[tag] = len(image_info)
+            sample_num = min(sample_num, len(image_info))
+            for i in range(sample_num):
+                file_name = image_info[i]["file_name"]
+                img_id = image_info[i]["id"]
+                img_path = osp.join(dataset_dir, "images", file_name)
+                if not osp.exists(img_path):
+                    raise DatasetFileNotFoundError(file_path=img_path)
+                img = Image.open(img_path)
+                img = ImageOps.exif_transpose(img)
+                vis_im = draw_bbox(img, coco, img_id)
+                vis_path = osp.join(vis_save_dir, file_name)
+                Path(vis_path).parent.mkdir(parents=True, exist_ok=True)
+                vis_im.save(vis_path)
+                sample_path = osp.join(
+                    "check_dataset", os.path.relpath(vis_path, output)
+                )
+                sample_paths[tag].append(sample_path)
+
+    attrs = {}
+    attrs["num_classes"] = num_class
+    attrs["train_samples"] = sample_cnts["instance_train"]
+    attrs["train_sample_paths"] = sample_paths["instance_train"]
+
+    attrs["val_samples"] = sample_cnts["instance_val"]
+    attrs["val_sample_paths"] = sample_paths["instance_val"]
+    return attrs

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

@@ -0,0 +1,433 @@
+# 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 shutil
+import json
+import random
+import xml.etree.ElementTree as ET
+from tqdm import tqdm
+
+from .....utils.file_interface import custom_open, write_json_file
+from .....utils.errors import ConvertFailedError
+from .....utils.logging import info, warning
+
+
+class Indexer(object):
+    """Indexer"""
+
+    def __init__(self):
+        """init indexer"""
+        self._map = {}
+        self.idx = 0
+
+    def get_id(self, key):
+        """get id by key"""
+        if key not in self._map:
+            self.idx += 1
+            self._map[key] = self.idx
+        return self._map[key]
+
+    def get_list(self, key_name):
+        """return list containing key and id"""
+        map_list = []
+        for key in self._map:
+            val = self._map[key]
+            map_list.append({key_name: key, "id": val})
+        return map_list
+
+
+class Extension(object):
+    """Extension"""
+
+    def __init__(self, exts_list):
+        """init extension"""
+        self._exts_list = ["." + ext for ext in exts_list]
+
+    def __iter__(self):
+        """iterator"""
+        return iter(self._exts_list)
+
+    def update(self, ext):
+        """update extension"""
+        self._exts_list.remove(ext)
+        self._exts_list.insert(0, ext)
+
+
+def check_src_dataset(root_dir, dataset_type):
+    """check src dataset format validity"""
+    if dataset_type in ("VOC", "VOCWithUnlabeled"):
+        anno_suffix = ".xml"
+    elif dataset_type in ("LabelMe", "LabelMeWithUnlabeled"):
+        anno_suffix = ".json"
+    else:
+        raise ConvertFailedError(
+            message=f"数据格式转换失败！不支持{dataset_type}格式数据集。当前仅支持 VOC、LabelMe 和 VOCWithUnlabeled、LabelMeWithUnlabeled 格式。"
+        )
+
+    err_msg_prefix = f"数据格式转换失败！请参考上述`{dataset_type}格式数据集示例`检查待转换数据集格式。"
+
+    anno_map = {}
+    for dst_anno, src_anno in [
+        ("instance_train.json", "train_anno_list.txt"),
+        ("instance_val.json", "val_anno_list.txt"),
+    ]:
+        src_anno_path = os.path.join(root_dir, src_anno)
+        if not os.path.exists(src_anno_path):
+            if dst_anno == "instance_train.json":
+                raise ConvertFailedError(
+                    message=f"{err_msg_prefix}保证{src_anno_path}文件存在。"
+                )
+            continue
+        with custom_open(src_anno_path, "r") as f:
+            anno_list = f.readlines()
+        for anno_fn in anno_list:
+            anno_fn = anno_fn.strip().split(" ")[-1]
+            anno_path = os.path.join(root_dir, anno_fn)
+            if not os.path.exists(anno_path):
+                raise ConvertFailedError(
+                    message=f'{err_msg_prefix}保证"{src_anno_path}"中的"{anno_fn}"文件存在。'
+                )
+        anno_map[dst_anno] = src_anno_path
+    return anno_map
+
+
+def convert(dataset_type, input_dir):
+    """convert dataset to coco format"""
+    # check format validity
+    anno_map = check_src_dataset(input_dir, dataset_type)
+    (
+        convert_voc_dataset(input_dir, anno_map)
+        if dataset_type in ("VOC", "VOCWithUnlabeled")
+        else convert_labelme_dataset(input_dir, anno_map)
+    )
+
+
+def split_anno_list(root_dir, anno_map):
+    """Split anno list to 80% train and 20% val"""
+
+    train_anno_list = []
+    val_anno_list = []
+    anno_list_bak = os.path.join(root_dir, "train_anno_list.txt.bak")
+    shutil.move(anno_map["instance_train.json"], anno_list_bak),
+    with custom_open(anno_list_bak, "r") as f:
+        src_anno = f.readlines()
+    random.shuffle(src_anno)
+    train_anno_list = src_anno[: int(len(src_anno) * 0.8)]
+    val_anno_list = src_anno[int(len(src_anno) * 0.8) :]
+    with custom_open(os.path.join(root_dir, "train_anno_list.txt"), "w") as f:
+        f.writelines(train_anno_list)
+    with custom_open(os.path.join(root_dir, "val_anno_list.txt"), "w") as f:
+        f.writelines(val_anno_list)
+    anno_map["instance_train.json"] = os.path.join(root_dir, "train_anno_list.txt")
+    anno_map["instance_val.json"] = os.path.join(root_dir, "val_anno_list.txt")
+    msg = f"{os.path.join(root_dir,'val_anno_list.txt')}不存在，数据集已默认按照80%训练集，20%验证集划分,\
+        且将原始'train_anno_list.txt'重命名为'train_anno_list.txt.bak'."
+
+    warning(msg)
+    return anno_map
+
+
+def convert_labelme_dataset(root_dir, anno_map):
+    """convert dataset labeled by LabelMe to coco format"""
+    label_indexer = Indexer()
+    img_indexer = Indexer()
+
+    annotations_dir = os.path.join(root_dir, "annotations")
+    if not os.path.exists(annotations_dir):
+        os.makedirs(annotations_dir)
+
+    # FIXME(gaotingquan): support lmssl
+    unlabeled_path = os.path.join(root_dir, "unlabeled.txt")
+    if os.path.exists(unlabeled_path):
+        shutil.move(unlabeled_path, os.path.join(annotations_dir, "unlabeled.txt"))
+
+    # 不存在val_anno_list，对原始数据集进行划分
+    if "instance_val.json" not in anno_map:
+        anno_map = split_anno_list(root_dir, anno_map)
+
+    for dst_anno in anno_map:
+        labelme2coco(
+            label_indexer,
+            img_indexer,
+            root_dir,
+            anno_map[dst_anno],
+            os.path.join(annotations_dir, dst_anno),
+        )
+
+
+def labelme2coco(label_indexer, img_indexer, root_dir, anno_path, save_path):
+    """convert json files generated by LabelMe to coco format and save to files"""
+    with custom_open(anno_path, "r") as f:
+        json_list = f.readlines()
+
+    anno_num = 0
+    anno_list = []
+    image_list = []
+    info(f"Start loading json annotation files from {anno_path} ...")
+    for json_path in tqdm(json_list):
+        json_path = json_path.strip()
+        if not json_path.endswith(".json"):
+            info(f'An illegal json path("{json_path}") found! Has been ignored.')
+            continue
+
+        with custom_open(os.path.join(root_dir, json_path.strip()), "r") as f:
+            labelme_data = json.load(f)
+
+        img_id = img_indexer.get_id(labelme_data["imagePath"])
+        image_list.append(
+            {
+                "id": img_id,
+                "file_name": labelme_data["imagePath"].split("/")[-1],
+                "width": labelme_data["imageWidth"],
+                "height": labelme_data["imageHeight"],
+            }
+        )
+
+        for shape in labelme_data["shapes"]:
+            assert shape["shape_type"] == "rectangle", "Only rectangle are supported."
+            category_id = label_indexer.get_id(shape["label"])
+            (x1, y1), (x2, y2) = shape["points"]
+            x1, x2 = sorted([x1, x2])
+            y1, y2 = sorted([y1, y2])
+            bbox = list(map(float, [x1, y1, x2 - x1, y2 - y1]))
+            anno_num += 1
+            anno_list.append(
+                {
+                    "image_id": img_id,
+                    "bbox": bbox,
+                    "category_id": category_id,
+                    "id": anno_num,
+                    "iscrowd": 0,
+                    "area": bbox[2] * bbox[3],
+                    "ignore": 0,
+                }
+            )
+
+    category_list = label_indexer.get_list(key_name="name")
+    data_coco = {
+        "images": image_list,
+        "categories": category_list,
+        "annotations": anno_list,
+    }
+
+    write_json_file(data_coco, save_path)
+    info(f"The converted annotations has been save to {save_path}.")
+
+
+def convert_voc_dataset(root_dir, anno_map):
+    """convert VOC format dataset to coco format"""
+    label_indexer = Indexer()
+    img_indexer = Indexer()
+
+    annotations_dir = os.path.join(root_dir, "annotations")
+    if not os.path.exists(annotations_dir):
+        os.makedirs(annotations_dir)
+
+    # FIXME(gaotingquan): support lmssl
+    unlabeled_path = os.path.join(root_dir, "unlabeled.txt")
+    if os.path.exists(unlabeled_path):
+        shutil.move(unlabeled_path, os.path.join(annotations_dir, "unlabeled.txt"))
+
+    # 不存在val_anno_list，对原始数据集进行划分
+    if "instance_val.json" not in anno_map:
+        anno_map = split_anno_list(root_dir, anno_map)
+
+    for dst_anno in anno_map:
+        ann_paths = voc_get_label_anno(root_dir, anno_map[dst_anno])
+
+        voc_xmls_to_cocojson(
+            root_dir=root_dir,
+            annotation_paths=ann_paths,
+            label_indexer=label_indexer,
+            img_indexer=img_indexer,
+            output=annotations_dir,
+            output_file=dst_anno,
+        )
+
+
+def voc_get_label_anno(root_dir, anno_path):
+    """
+    Read VOC format annotation file.
+
+    Args:
+        root_dir (str): The directoty of VOC annotation file.
+        anno_path (str): The annoation file path.
+
+    Returns:
+        tuple: A tuple of two elements, the first of which is of type dict, representing the mapping between tag names
+        and their corresponding ids, and the second of type list, representing the list of paths to all annotated files.
+    """
+    if not os.path.exists(anno_path):
+        info(f"The annotation file {anno_path} don't exists, has been ignored!")
+        return []
+    with custom_open(anno_path, "r") as f:
+        ann_ids = f.readlines()
+
+    ann_paths = []
+    info(f"Start loading xml annotation files from {anno_path} ...")
+    for aid in ann_ids:
+        aid = aid.strip().split(" ")[-1]
+        if not aid.endswith(".xml"):
+            info(f'An illegal xml path("{aid}") found! Has been ignored.')
+            continue
+        ann_path = os.path.join(root_dir, aid)
+        ann_paths.append(ann_path)
+
+    return ann_paths
+
+
+def voc_get_image_info(annotation_root, img_indexer):
+    """
+    Get the iamge info from VOC annotation file.
+
+    Args:
+        annotation_root: The annotation root.
+        img_indexer: indexer to get image id by filename.
+
+    Returns:
+        dict: The image info.
+
+    Raises:
+        AssertionError: When filename cannot be found in 'annotation_root'.
+    """
+    filename = annotation_root.findtext("filename")
+    assert filename is not None, filename
+    img_name = os.path.basename(filename)
+    im_id = img_indexer.get_id(filename)
+
+    size = annotation_root.find("size")
+    width = float(size.findtext("width"))
+    height = float(size.findtext("height"))
+
+    image_info = {"file_name": filename, "height": height, "width": width, "id": im_id}
+    return image_info
+
+
+def voc_get_coco_annotation(obj, label_indexer):
+    """
+    Convert VOC format annotation to COCO format.
+
+    Args:
+        obj: a obj in VOC.
+        label_indexer: indexer to get category id by label name.
+
+    Returns:
+        dict: A dict with the COCO format annotation info.
+
+    Raises:
+        AssertionError: When the width or height of the annotation box is illegal.
+    """
+    label = obj.findtext("name")
+    category_id = label_indexer.get_id(label)
+    bndbox = obj.find("bndbox")
+    xmin = float(bndbox.findtext("xmin"))
+    ymin = float(bndbox.findtext("ymin"))
+    xmax = float(bndbox.findtext("xmax"))
+    ymax = float(bndbox.findtext("ymax"))
+    if xmin > xmax or ymin > ymax:
+        temp = xmin
+        xmin = min(xmin, xmax)
+        xmax = max(temp, xmax)
+        temp = ymin
+        ymin = min(ymin, ymax)
+        ymax = max(temp, ymax)
+
+    o_width = xmax - xmin
+    o_height = ymax - ymin
+    anno = {
+        "area": o_width * o_height,
+        "iscrowd": 0,
+        "bbox": [xmin, ymin, o_width, o_height],
+        "category_id": category_id,
+        "ignore": 0,
+    }
+    return anno
+
+
+def voc_xmls_to_cocojson(
+    root_dir, annotation_paths, label_indexer, img_indexer, output, output_file
+):
+    """
+    Convert VOC format data to COCO format.
+
+    Args:
+        annotation_paths (list): A list of paths to the XML files.
+        label_indexer: indexer to get category id by label name.
+        img_indexer: indexer to get image id by filename.
+        output (str): The directory to save output JSON file.
+        output_file (str): Output JSON file name.
+
+    Returns:
+        None
+    """
+    extension_list = ["jpg", "png", "jpeg", "JPG", "PNG", "JPEG"]
+    suffixs = Extension(extension_list)
+
+    def match(root_dir, prefilename, prexlm_name):
+        """matching extension"""
+        for ext in suffixs:
+            if os.path.exists(os.path.join(root_dir, "images", prefilename + ext)):
+                suffixs.update(ext)
+                return prefilename + ext
+            elif os.path.exists(os.path.join(root_dir, "images", prexlm_name + ext)):
+                suffixs.update(ext)
+                return prexlm_name + ext
+        return None
+
+    output_json_dict = {
+        "images": [],
+        "type": "instances",
+        "annotations": [],
+        "categories": [],
+    }
+
+    bnd_id = 1  # bounding box start id
+    info("Start converting !")
+    for a_path in tqdm(annotation_paths):
+        # Read annotation xml
+        ann_tree = ET.parse(a_path)
+        ann_root = ann_tree.getroot()
+        file_name = ann_root.find("filename")
+        prefile_name = file_name.text.split(".")[0]
+        prexlm_name = os.path.basename(a_path).split(".")[0]
+        # 根据file_name 和 xlm_name 分别匹配查找图片
+        f_name = match(root_dir, prefile_name, prexlm_name)
+        if f_name is not None:
+            file_name.text = f_name
+        else:
+            prefile_name_set = set({prefile_name, prexlm_name})
+            prefile_name_set = ",".join(prefile_name_set)
+            suffix_set = ",".join(extension_list)
+            images_path = os.path.join(root_dir, "images")
+            info(
+                f"{images_path}/{{{prefile_name_set}}}.{{{suffix_set}}} both not exists,will be skipped."
+            )
+            continue
+        img_info = voc_get_image_info(ann_root, img_indexer)
+        output_json_dict["images"].append(img_info)
+
+        for obj in ann_root.findall("object"):
+            if obj.find("bndbox") is None:  # Skip the ojbect wihtout bndbox
+                continue
+            ann = voc_get_coco_annotation(obj=obj, label_indexer=label_indexer)
+            ann.update({"image_id": img_info["id"], "id": bnd_id})
+            output_json_dict["annotations"].append(ann)
+            bnd_id = bnd_id + 1
+
+    output_json_dict["categories"] = label_indexer.get_list(key_name="name")
+    output_file = os.path.join(output, output_file)
+    write_json_file(output_json_dict, output_file)
+    info(f"The converted annotations has been save to {output_file}.")

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

@@ -0,0 +1,119 @@
+# 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 shutil
+import random
+import json
+from tqdm import tqdm
+
+from .....utils.file_interface import custom_open, write_json_file
+from .....utils.logging import info
+
+
+def split_dataset(root_dir, train_rate, val_rate):
+    """split dataset"""
+    assert (
+        train_rate + val_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!"
+
+    all_image_info_list = []
+    all_category_dict = {}
+    max_image_id = 0
+    for fn in ["instance_train.json", "instance_val.json"]:
+        anno_path = os.path.join(root_dir, "annotations", fn)
+        if not os.path.exists(anno_path):
+            info(f"The annotation file {anno_path} don't exists, has been ignored!")
+            continue
+        image_info_list, category_list, max_image_id = json2list(
+            anno_path, max_image_id
+        )
+        all_image_info_list.extend(image_info_list)
+
+        for category in category_list:
+            if category["id"] not in all_category_dict:
+                all_category_dict[category["id"]] = category
+
+    total_num = len(all_image_info_list)
+    random.shuffle(all_image_info_list)
+
+    all_category_list = [all_category_dict[k] for k in all_category_dict]
+
+    start = 0
+    for fn, rate in [
+        ("instance_train.json", train_rate),
+        ("instance_val.json", val_rate),
+    ]:
+        end = start + round(total_num * rate / 100)
+        save_path = os.path.join(root_dir, "annotations", fn)
+        if os.path.exists(save_path):
+            bak_path = save_path + ".bak"
+            shutil.move(save_path, bak_path)
+            info(f"The original annotation file {fn} has been backed up to {bak_path}.")
+        assemble_write(all_image_info_list[start:end], all_category_list, save_path)
+        start = end
+    return root_dir
+
+
+def json2list(json_path, base_image_num):
+    """load json as list"""
+    assert os.path.exists(json_path), json_path
+    with custom_open(json_path, "r") as f:
+        data = json.load(f)
+    image_info_dict = {}
+    max_image_id = 0
+    for image_info in data["images"]:
+        # 得到全局唯一的image_id
+        global_image_id = image_info["id"] + base_image_num
+        max_image_id = max(global_image_id, max_image_id)
+        image_info["id"] = global_image_id
+        image_info_dict[global_image_id] = {"img": image_info, "anno": []}
+
+    image_info_dict = {
+        image_info["id"]: {"img": image_info, "anno": []}
+        for image_info in data["images"]
+    }
+    info(f"Start loading annotation file {json_path}...")
+    for anno in tqdm(data["annotations"]):
+        global_image_id = anno["image_id"] + base_image_num
+        anno["image_id"] = global_image_id
+        image_info_dict[global_image_id]["anno"].append(anno)
+    image_info_list = [
+        (image_info_dict[image_info]["img"], image_info_dict[image_info]["anno"])
+        for image_info in image_info_dict
+    ]
+    return image_info_list, data["categories"], max_image_id
+
+
+def assemble_write(image_info_list, category_list, save_path):
+    """assemble coco format and save to file"""
+    coco_data = {"categories": category_list}
+    image_list = [i[0] for i in image_info_list]
+    all_anno_list = []
+    for i in image_info_list:
+        all_anno_list.extend(i[1])
+    anno_list = []
+    for i, anno in enumerate(all_anno_list):
+        anno["id"] = i + 1
+        anno_list.append(anno)
+
+    coco_data["images"] = image_list
+    coco_data["annotations"] = anno_list
+
+    write_json_file(coco_data, save_path)
+    info(f"The splited annotations has been save to {save_path}.")

paddlex/modules/object_detection/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.