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

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

@@ -0,0 +1,92 @@
+# 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 json
+import os
+import os.path as osp
+from collections import defaultdict, Counter
+from pathlib import Path
+
+from PIL import Image, ImageOps
+from pycocotools.coco import COCO
+
+from .utils.visualizer import draw_bbox, draw_mask
+from .....utils.errors import DatasetFileNotFoundError
+from .....utils.logging import info
+
+
+def check(dataset_dir, output, sample_num=10):
+    """check dataset"""
+    info(dataset_dir)
+    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)
+
+            datanno = jsondata["annotations"]
+            sample_cnts[tag] = len(datanno)
+            coco = COCO(file_list)
+            num_class = len(coco.getCatIds())
+
+            vis_save_dir = osp.join(output, "demo_img")
+
+            image_info = jsondata["images"]
+            sample_num = min(sample_num, len(image_info))
+            if sample_num < 10:
+                info("Only {} images in {}.json".format(len(image_info), tag))
+            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_im = draw_mask(vis_im, 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/instance_segmentation/dataset_checker/dataset_src/convert_dataset.py

@@ -0,0 +1,241 @@
+# 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
+
+import cv2
+import numpy as np
+from PIL import Image, ImageDraw
+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 == "LabelMe":
+        anno_suffix = ".json"
+    else:
+        raise ConvertFailedError(
+            message=f"数据格式转换失败！不支持{dataset_type}格式数据集。当前仅支持 LabelMe 格式。"
+        )
+
+    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)
+    if dataset_type == "LabelMe":
+        convert_labelme_dataset(input_dir, anno_map)
+    else:
+        raise ValueError
+
+
+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)
+
+    # 不存在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"""
+    import pycocotools.mask as mask_util
+
+    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()
+        assert json_path.endswith(".json"), json_path
+        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"])
+        height = labelme_data["imageHeight"]
+        width = labelme_data["imageWidth"]
+        image_list.append(
+            {
+                "id": img_id,
+                "file_name": labelme_data["imagePath"].split("/")[-1],
+                "width": width,
+                "height": height,
+            }
+        )
+
+        for shape in labelme_data["shapes"]:
+            assert shape["shape_type"] == "polygon", "Only polygon are supported."
+            category_id = label_indexer.get_id(shape["label"])
+            points = shape["points"]
+            segmentation = [np.asarray(points).flatten().tolist()]
+            mask = points_to_mask([height, width], points)
+            mask = np.asfortranarray(mask.astype(np.uint8))
+            mask = mask_util.encode(mask)
+            area = float(mask_util.area(mask))
+            bbox = mask_util.toBbox(mask).flatten().tolist()
+
+            anno_num += 1
+            anno_list.append(
+                {
+                    "image_id": img_id,
+                    "bbox": bbox,
+                    "segmentation": segmentation,
+                    "category_id": category_id,
+                    "id": anno_num,
+                    "iscrowd": 0,
+                    "area": area,
+                    "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 points_to_mask(img_shape, points):
+    """convert polygon points to binary mask"""
+    mask = np.zeros(img_shape[:2], dtype=np.uint8)
+    mask = Image.fromarray(mask)
+    draw = ImageDraw.Draw(mask)
+    xy = [tuple(point) for point in points]
+    assert len(xy) > 2, "Polygon must have points more than 2"
+    draw.polygon(xy=xy, outline=1, fill=1)
+    mask = np.asarray(mask, dtype=bool)
+    return mask

paddlex/modules/instance_segmentation/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/instance_segmentation/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/instance_segmentation/dataset_checker/dataset_src/utils/visualizer.py

@@ -0,0 +1,221 @@
+# 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 pycocotools.coco import COCO
+
+from ......utils.fonts import PINGFANG_FONT_FILE_PATH
+from ......utils import logging
+
+
+def colormap(rgb=False):
+    """
+    Get colormap
+
+    The code of this function is copied from https://github.com/facebookresearch/Detectron/blob/main/detectron/\
+utils/colormap.py
+    """
+    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 color according to the index of 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_bbox(image, coco_info: COCO, img_id):
+    """
+    Draw bbox on image
+    """
+    try:
+        image_info = coco_info.loadImgs(img_id)[0]
+        font_size = int(0.024 * int(image_info["width"])) + 2
+    except:
+        font_size = 12
+    font = ImageFont.truetype(PINGFANG_FONT_FILE_PATH, font_size, encoding="utf-8")
+
+    image = image.convert("RGB")
+    draw = ImageDraw.Draw(image)
+    image_size = image.size
+    width = int(max(image_size) * 0.005)
+
+    catid2color = {}
+    catid2fontcolor = {}
+    catid_num_dict = {}
+    color_list = colormap(rgb=True)
+    annotations = coco_info.loadAnns(coco_info.getAnnIds(imgIds=img_id))
+
+    for ann in annotations:
+        catid = ann["category_id"]
+        catid_num_dict[catid] = catid_num_dict.get(catid, 0) + 1
+    for i, (catid, _) in enumerate(
+        sorted(catid_num_dict.items(), key=lambda x: x[1], reverse=True)
+    ):
+        if catid not in catid2color:
+            color_index = i % len(color_list)
+            catid2color[catid] = color_list[color_index]
+            catid2fontcolor[catid] = font_colormap(color_index)
+    for ann in annotations:
+        catid, bbox = ann["category_id"], ann["bbox"]
+        color = tuple(catid2color[catid])
+        font_color = tuple(catid2fontcolor[catid])
+
+        if len(bbox) == 4:
+            # draw bbox
+            xmin, ymin, w, h = bbox
+            xmax = xmin + w
+            ymax = ymin + h
+            draw.line(
+                [(xmin, ymin), (xmin, ymax), (xmax, ymax), (xmax, ymin), (xmin, ymin)],
+                width=width,
+                fill=color,
+            )
+        elif len(bbox) == 8:
+            x1, y1, x2, y2, x3, y3, x4, y4 = bbox
+            draw.line(
+                [(x1, y1), (x2, y2), (x3, y3), (x4, y4), (x1, y1)],
+                width=width,
+                fill=color,
+            )
+            xmin = min(x1, x2, x3, x4)
+            ymin = min(y1, y2, y3, y4)
+        else:
+            logging.info("Error: The shape of bbox must be [M, 4] or [M, 8]!")
+
+        # draw label
+        label = coco_info.loadCats(catid)[0]["name"]
+        text = "{}".format(label)
+        if tuple(map(int, PIL.__version__.split("."))) <= (10, 0, 0):
+            tw, th = draw.textsize(text, font=font)
+        else:
+            left, top, right, bottom = draw.textbbox((0, 0), text, font)
+            tw, th = right - left, bottom - top
+        if ymin < th:
+            draw.rectangle([(xmin, ymin), (xmin + tw + 4, ymin + th + 1)], fill=color)
+            draw.text((xmin + 2, ymin - 2), text, fill=font_color, font=font)
+        else:
+            draw.rectangle([(xmin, ymin - th), (xmin + tw + 4, ymin + 1)], fill=color)
+            draw.text((xmin + 2, ymin - th - 2), text, fill=font_color, font=font)
+
+    return image
+
+
+def draw_mask(image, coco_info: COCO, img_id):
+    """
+    Draw mask on image
+    """
+    mask_color_id = 0
+    w_ratio = 0.4
+    alpha = 0.6
+    color_list = colormap(rgb=True)
+    img_array = np.array(image).astype("float32")
+    h, w = img_array.shape[:2]
+    annotations = coco_info.loadAnns(coco_info.getAnnIds(imgIds=img_id))
+    for ann in annotations:
+        segm = ann["segmentation"]
+        if not segm:
+            continue
+        import pycocotools.mask as mask_util
+
+        rles = mask_util.frPyObjects(segm, h, w)
+        rle = mask_util.merge(rles)
+        mask = mask_util.decode(rle) * 255
+        color_mask = color_list[mask_color_id % len(color_list), 0:3]
+        mask_color_id += 1
+        for c in range(3):
+            color_mask[c] = color_mask[c] * (1 - w_ratio) + w_ratio * 255
+        idx = np.nonzero(mask)
+        img_array[idx[0], idx[1], :] *= 1.0 - alpha
+        img_array[idx[0], idx[1], :] += alpha * color_mask
+    return Image.fromarray(img_array.astype("uint8"))