coco_stuff.py

# Copyright 2020 The HuggingFace Datasets Authors and the current dataset
# script contributor.
#
# 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.
# TODO: Address all TODOs and remove all explanatory comments
"""TODO: Add a description here."""


import json
import logging
import os.path as osp
from pycocotools import mask as mask_utils

import datasets

logger = logging.getLogger(__name__)


# TODO: Add BibTeX citation
# Find for instance the citation on arxiv or on the dataset repo/website
_CITATION = """\
@InProceedings{huggingface:dataset,
title = {A great new dataset},
author={huggingface, Inc.
},
year={2020}
}
"""

# TODO: Add description of the dataset here
# You can copy an official description
_DESCRIPTION = """\
This COCO-Stuff dataset is designed to load coco-stuff only & coco stuff thing.
"""

# TODO: Add a link to an official homepage for the dataset here
_HOMEPAGE = ""

# TODO: Add the licence for the dataset here if you can find it
_LICENSE = ""

# TODO: Add link to the official dataset URLs here
# The HuggingFace Datasets library doesn't host the datasets but only points
# to the original files.
# This can be an arbitrary nested dict/list of URLs
# (see below in `_split_generators` method)
_URLS = {}


VALID_SPLIT_NAMES = ("train", "val")


# TODO: Name of the dataset usually matches the script name with CamelCase
# instead of snake_case
class COCOStuffDataset(datasets.GeneratorBasedBuilder):
    """TODO: Short description of my dataset."""

    VERSION = datasets.Version("0.0.1")

    # This is an example of a dataset with multiple configurations.
    # If you don't want/need to define several sub-sets in your dataset,
    # just remove the BUILDER_CONFIG_CLASS and the BUILDER_CONFIGS attributes.

    # If you need to make complex sub-parts in the datasets with configurable
    # options
    # You can create your own builder configuration class to store attribute,
    # inheriting from datasets.BuilderConfig
    BUILDER_CONFIG_CLASS = datasets.BuilderConfig

    # You will be able to load one or the other configurations
    # in the following list with
    # data = datasets.load_dataset('my_dataset', 'first_domain')
    # data = datasets.load_dataset('my_dataset', 'second_domain')
    BUILDER_CONFIGS = [
        # stuff-only
        datasets.BuilderConfig(
            name="stuff-only", version=VERSION, description="stuff-only."),
        # thing-only
        datasets.BuilderConfig(
            name="thing-only", version=VERSION, description="thing-only."),
        # stuff-thing
        datasets.BuilderConfig(
            name="stuff-thing", version=VERSION, description="stuff-thing"),
    ]

    # It's not mandatory to have a default configuration.
    # Just use one if it make sense.
    DEFAULT_CONFIG_NAME = "stuff-thing"

    def _info(self):
        self.config: datasets.BuilderConfig
        features = {
            # "image": datasets.Image(),
            "image_id": datasets.Value("int32"),
            "file_name": datasets.Value("string"),
            "image_path": datasets.Value("string"),
            "mask_path": datasets.Value("string"),
            "height": datasets.Value("int32"),
            "width": datasets.Value("int32"),
            "coco_url": datasets.Value("string"),
            "objects": [
                {
                    "object_id": datasets.Value("string"),
                    "bbox": [datasets.Value("float")],
                    "x": datasets.Value("float"),
                    "y": datasets.Value("float"),
                    "w": datasets.Value("float"),
                    "h": datasets.Value("float"),
                    "category_id": datasets.Value("int32"),
                    "category": datasets.Value("string"),
                    "segmentation": {"counts": datasets.Value("string"),
                                     "size": [datasets.Value("int32")],
                                     "path": datasets.Value("string"),
                                     "index": datasets.Value("int32")},
                }
            ],
        }
        features = datasets.Features(features)
        return datasets.DatasetInfo(
            # This is the description that will appear on the datasets page.
            description=_DESCRIPTION,
            # This defines the different columns of the dataset and their types
            features=features,
            # If there's a common (input, target) tuple from the features,
            # uncomment supervised_keys line below and specify them.
            # They'll be used if as_supervised=True in builder.as_dataset.
            # supervised_keys=("sentence", "label"),
            # Homepage of the dataset for documentation
            homepage=_HOMEPAGE,
            # License for the dataset if available
            license=_LICENSE,
            # Citation for the dataset
            citation=_CITATION,
        )

    def _split_generators(self, dl_manager):
        # TODO: This method is tasked with downloading/extracting the data and
        # defining the splits depending on the configuration
        # If several configurations are possible (listed in BUILDER_CONFIGS),
        # the configuration selected by the user is in self.config.name

        # dl_manager is a datasets.download.DownloadManager that can be used
        # to download and extract URLS. It can accept any type
        # or nested list/dict and will give back the same structure with
        # the url replaced with path to local files.
        # By default the archives will be extracted and a path to a cached
        # folder where they are extracted is returned instead of the archive
        # urls = _URLS[self.config.name]
        # data_dir = dl_manager.download_and_extract(urls)
        splits = []
        split_names = ("train", "val")
        for split in split_names:
            splits.append(datasets.SplitGenerator(
                name=datasets.NamedSplit(split),
                gen_kwargs={"split": split},
            ))
        return splits

    def build_image_id_to_annotation_list_indices(self, stuff_json: dict):
        msg = "Building mapping for image_id to annotation list indices ..."
        logger.info(msg)
        image_id_to_ann_ids: dict[int, list[int]] = {}
        for idx, ann in enumerate(stuff_json["annotations"]):
            img_id = ann["image_id"]
            if img_id not in image_id_to_ann_ids:
                image_id_to_ann_ids[img_id] = []
            image_id_to_ann_ids[img_id].append(idx)
        logger.info("DONE.")
        return image_id_to_ann_ids

    def build_image_id_to_metainfo(self, stuff_json: dict):
        msg = "Building mapping for image_id to metainfo ..."
        logger.info(msg)
        image_id_to_metainfo = {}
        for img in stuff_json["images"]:
            image_id_to_metainfo[img["id"]] = img
        logger.info("DONE.")
        return image_id_to_metainfo

    def load_json(self, json_path: str):
        with open(json_path, "r") as f:
            return json.load(f)

    def load_label_file(self, label_path: str):
        with open(label_path, "r") as f:
            contents = f.read().split("\n")
        contents = list(filter(lambda x: len(x) > 0, contents))
        catid_label_pairs = [line.split(': ') for line in contents]
        catid_to_label = {
            int(catid): label for catid, label in catid_label_pairs
        }
        catid_to_label[183] = "other"
        return catid_to_label

    def _prepare_from_image_info(
            self, image_info: dict, img_dir: str, ann_dir: str, split: str):
        metainfo = {}
        metainfo["image_path"] = osp.join(
            img_dir, f"{split}2017", image_info["file_name"])
        metainfo["mask_path"] = osp.join(
            ann_dir, f"{split}2017",
            image_info["file_name"]).replace(".jpg", ".png")
        metainfo["height"] = image_info['height']
        metainfo["width"] = image_info['width']
        metainfo["coco_url"] = image_info['coco_url']
        metainfo["file_name"] = image_info["file_name"]
        if not osp.exists(metainfo["image_path"]):
            raise FileNotFoundError(
                f"Image file not found: {metainfo['image_path']}")
        if not osp.exists(metainfo["mask_path"]):
            raise FileNotFoundError(
                f"Mask file not found: {metainfo['mask_path']}")
        return metainfo

    # method parameters are unpacked from `gen_kwargs` as given in
    # `_split_generators`
    def _generate_examples(self, split: str):
        # TODO: This method handles input defined in _split_generators to
        # yield (key, example) tuples from the dataset.
        # The `key` is for legacy reasons (tfds) and is not important
        # in itself, but must be unique for each example.
        data_root = self.config.data_dir
        catid_to_label = self.load_label_file(
            osp.join(data_root, "labels.txt"))
        img_dir = osp.join(data_root, "images")
        ann_dir = osp.join(data_root, "annotations")
        stuff_json_path = osp.join(
            data_root, f"stuff_{split}2017.json")
        thing_json_path = osp.join(
            data_root, f"annotations/instances_{split}2017.json")
        stuff_metainfo = self.load_json(stuff_json_path)
        thing_metainfo = self.load_json(thing_json_path)

        image_id_to_stuff_anno_list_indices = \
            self.build_image_id_to_annotation_list_indices(stuff_metainfo)
        image_id_to_thing_anno_list_indices = \
            self.build_image_id_to_annotation_list_indices(thing_metainfo)
        image_id_to_stuff_metainfo = \
            self.build_image_id_to_metainfo(stuff_metainfo)
        # image_id_to_thing_metainfo = \
        #     self.build_image_id_to_metainfo(thing_metainfo)
        stuff_image_ids = set(image_id_to_stuff_anno_list_indices.keys())
        thing_image_ids = set(image_id_to_thing_anno_list_indices.keys())
        all_image_ids = stuff_image_ids.union(thing_image_ids)

        for image_id in all_image_ids:
            # image_thing_info = image_id_to_thing_metainfo[image_id]
            image_stuff_info = image_id_to_stuff_metainfo[image_id]
            data = self._prepare_from_image_info(
                image_stuff_info, img_dir, ann_dir, split)

            stuff_annos = []
            stuff_anno_indices = []
            stuff_path_list = []
            stuff_segms = []
            if image_id in image_id_to_stuff_anno_list_indices:
                stuff_anno_indices = image_id_to_stuff_anno_list_indices[
                    image_id]
                stuff_annos = [stuff_metainfo["annotations"][idx]
                               for idx in stuff_anno_indices]
                stuff_path_list = [stuff_json_path] * len(stuff_annos)
                stuff_segms = [ann["segmentation"] for ann in stuff_annos]
            thing_annos = []
            thing_anno_indices = []
            thing_path_list = []
            thing_segms = []
            if image_id in image_id_to_thing_anno_list_indices:
                thing_anno_indices = image_id_to_thing_anno_list_indices[
                    image_id]
                thing_annos = [thing_metainfo["annotations"][idx]
                               for idx in thing_anno_indices]
                thing_path_list = [thing_json_path] * len(thing_annos)
                thing_segms = [ann["segmentation"] for ann in thing_annos]
                thing_segms = [
                    mask_utils.frPyObjects(segm, data["height"], data["width"])
                    for segm in thing_segms]
                thing_segms = [
                    mask_utils.merge(segm, intersect=False)
                    if isinstance(segm, list) else segm
                    for segm in thing_segms]

            annos = []
            anno_ids = []
            json_path_list = []
            segms = []
            if self.config.name in ("stuff-only", "stuff-thing"):
                annos += stuff_annos
                anno_ids += stuff_anno_indices
                json_path_list += stuff_path_list
                segms += stuff_segms
            if self.config.name in ("thing-only", "stuff-thing"):
                annos += thing_annos
                anno_ids += thing_anno_indices
                json_path_list += thing_path_list
                segms += thing_segms
            counts = [
                segm["counts"].decode()
                if isinstance(segm["counts"], bytes) else segm["counts"]
                for segm in segms]
            data.update({
                "image_id": image_id,
                "objects": [
                    {
                        "object_id": ann["id"],
                        "bbox": ann["bbox"][:],
                        "x": ann["bbox"][0],
                        "y": ann["bbox"][1],
                        "w": ann["bbox"][2],
                        "h": ann["bbox"][3],
                        # the segmentation mask starts from 0 to label stuffs
                        # and things that are not `other` or `unlabelled`
                        "category_id": ann["category_id"] - 1,
                        "category": catid_to_label[ann["category_id"]],
                        "segmentation": {
                            "path": json_path_list[idx],
                            "index": anno_ids[idx],
                            "counts": counts[idx],
                            "size": segms[idx]["size"],
                        },
                    }
                    for idx, ann in enumerate(annos)
                    # category `other` in `stuff` is `thing`
                    if (ann["category_id"] in catid_to_label.keys()
                        and ann["category_id"] != 0)
                ],
            })
            yield image_id, data