add files (#1)

.github/workflows/ci.yaml

@@ -0,0 +1,55 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  build_and_release:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ['3.8', '3.9', '3.10']
+
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v2
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: |
+          pip install -U pip setuptools wheel poetry
+          poetry install
+
+      - name: Format
+        run: |
+          poetry run black --check .
+
+      - name: Lint
+        run: |
+          poetry run flake8 . --ignore=E501,W503,E203
+
+      - name: Type check
+        run: |
+          poetry run mypy . \
+            --ignore-missing-imports \
+            --no-strict-optional \
+            --no-site-packages \
+            --cache-dir=/dev/null
+            
+      - name: Run tests
+        run: |
+          poetry run pytest --color=yes -rf
+      
+      - name: Push to Huggingface hub
+        if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+        env:
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}
+          HF_USERNAME: ${{ secrets.HF_USERNAME }}
+        run: |
+          git fetch --unshallow
+          git push --force https://${HF_USERNAME}:${HF_TOKEN}@huggingface.co/datasets/${HF_USERNAME}/cocostuff main

.gitignore

@@ -0,0 +1,166 @@
+# Created by https://www.toptal.com/developers/gitignore/api/python
+# Edit at https://www.toptal.com/developers/gitignore?templates=python
+
+### Python ###
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# End of https://www.toptal.com/developers/gitignore/api/python

README.md

@@ -0,0 +1,276 @@
+---
+language:
+- en
+license: cc-by-4.0
+
+tags:
+- computer-vision
+- object-detection
+- ms-coco
+
+datasets:
+- stuff-thing
+- stuff-only
+
+metrics:
+- accuracy
+- iou
+---
+
+# Dataset Card for COCO-Stuff
+
+[![CI](https://github.com/shunk031/huggingface-datasets_cocostuff/actions/workflows/ci.yaml/badge.svg)](https://github.com/shunk031/huggingface-datasets_cocostuff/actions/workflows/ci.yaml)
+
+## Table of Contents
+- [Table of Contents](#table-of-contents)
+- [Dataset Description](#dataset-description)
+  - [Dataset Summary](#dataset-summary)
+  - [Dataset Preprocessing](#dataset-preprocessing)
+  - [Supported Tasks and Leaderboards](#supported-tasks-and-leaderboards)
+  - [Languages](#languages)
+- [Dataset Structure](#dataset-structure)
+  - [Data Instances](#data-instances)
+  - [Data Fields](#data-fields)
+  - [Data Splits](#data-splits)
+- [Dataset Creation](#dataset-creation)
+  - [Curation Rationale](#curation-rationale)
+  - [Source Data](#source-data)
+  - [Annotations](#annotations)
+  - [Personal and Sensitive Information](#personal-and-sensitive-information)
+- [Considerations for Using the Data](#considerations-for-using-the-data)
+  - [Social Impact of Dataset](#social-impact-of-dataset)
+  - [Discussion of Biases](#discussion-of-biases)
+  - [Other Known Limitations](#other-known-limitations)
+- [Additional Information](#additional-information)
+  - [Dataset Curators](#dataset-curators)
+  - [Licensing Information](#licensing-information)
+  - [Citation Information](#citation-information)
+  - [Contributions](#contributions)
+
+## Dataset Description
+
+- Homepage: https://github.com/nightrome/cocostuff
+- Repository: https://github.com/nightrome/cocostuff
+- Paper (preprint): https://arxiv.org/abs/1612.03716
+- Paper (CVPR2018): https://openaccess.thecvf.com/content_cvpr_2018/html/Caesar_COCO-Stuff_Thing_and_CVPR_2018_paper.html
+
+### Dataset Summary
+
+COCO-Stuff is the largest existing dataset with dense stuff and thing annotations. 
+
+From the paper:
+
+> Semantic classes can be either things (objects with a well-defined shape, e.g. car, person) or stuff (amorphous background regions, e.g. grass, sky). While lots of classification and detection works focus on thing classes, less attention has been given to stuff classes. Nonetheless, stuff classes are important as they allow to explain important aspects of an image, including (1) scene type; (2) which thing classes are likely to be present and their location (through contextual reasoning); (3) physical attributes, material types and geometric properties of the scene. To understand stuff and things in context we introduce COCO-Stuff, which augments all 164K images of the COCO 2017 dataset with pixel-wise annotations for 91 stuff classes. We introduce an efficient stuff annotation protocol based on superpixels, which leverages the original thing annotations. We quantify the speed versus quality trade-off of our protocol and explore the relation between annotation time and boundary complexity. Furthermore, we use COCO-Stuff to analyze: (a) the importance of stuff and thing classes in terms of their surface cover and how frequently they are mentioned in image captions; (b) the spatial relations between stuff and things, highlighting the rich contextual relations that make our dataset unique; (c) the performance of a modern semantic segmentation method on stuff and thing classes, and whether stuff is easier to segment than things.
+
+### Dataset Preprocessing
+
+### Supported Tasks and Leaderboards
+
+### Languages
+
+All of annotations use English as primary language.
+
+## Dataset Structure
+
+### Data Instances
+
+When loading a specific configuration, users has to append a version dependent suffix:
+
+```python
+from datasets import load_dataset
+load_dataset("shunk031/cocostuff", "stuff-things")
+```
+
+#### stuff-things
+
+An example of looks as follows.
+
+```json
+{
+    'image': <PIL.JpegImagePlugin.JpegImageFile image mode=RGB size=640x480 at 0x7FCA033C9C40>,
+    'image_filename': '000000000009.jpg',
+    'image_id': '9',
+    'width': 640
+    'height': 480,
+    'objects': [
+        {
+            'object_id': '121',
+            'x': 0,
+            'y': 11,
+            'w': 640,
+            'h': 469,
+            'name': 'food-other'
+        },
+        {
+            'object_id': '143',
+            'x': 0,
+            'y': 0
+            'w': 640,
+            'h': 480,
+            'name': 'plastic'
+        },
+        {
+            'object_id': '165',
+            'x': 0,
+            'y': 0,
+            'w': 319,
+            'h': 118,
+            'name': 'table'
+        },
+        {
+            'object_id': '183',
+            'x': 0,
+            'y': 2,
+            'w': 631,
+            'h': 472,
+            'name': 'unknown-183'
+        }
+    ],
+    'stuff_map': <PIL.PngImagePlugin.PngImageFile image mode=L size=640x480 at 0x7FCA0222D880>,
+ }
+```
+
+#### stuff-only
+
+An example of looks as follows.
+
+```json
+{
+    'image': <PIL.JpegImagePlugin.JpegImageFile image mode=RGB size=640x480 at 0x7FCA033C9C40>,
+    'image_filename': '000000000009.jpg',
+    'image_id': '9',
+    'width': 640
+    'height': 480,
+    'objects': [
+        {
+            'object_id': '121',
+            'x': 0,
+            'y': 11,
+            'w': 640,
+            'h': 469,
+            'name': 'food-other'
+        },
+        {
+            'object_id': '143',
+            'x': 0,
+            'y': 0
+            'w': 640,
+            'h': 480,
+            'name': 'plastic'
+        },
+        {
+            'object_id': '165',
+            'x': 0,
+            'y': 0,
+            'w': 319,
+            'h': 118,
+            'name': 'table'
+        },
+        {
+            'object_id': '183',
+            'x': 0,
+            'y': 2,
+            'w': 631,
+            'h': 472,
+            'name': 'unknown-183'
+        }
+    ]
+ }
+```
+
+### Data Fields
+
+#### stuff-things
+
+- `image`: A `PIL.Image.Image` object containing the image.
+- `image_id`: Unique numeric ID of the image.
+- `image_filename`: File name of the image.
+- `width`: Image width.
+- `height`: Image height.
+- `stuff_map`: A `PIL.Image.Image` object containing the Stuff + thing PNG-style annotations
+- `objects`: Holds a list of `Object` data classes:
+    - `object_id`: Unique numeric ID of the object.
+    - `x`: x coordinate of bounding box's top left corner.
+    - `y`: y coordinate of bounding box's top left corner.
+    - `w`: Bounding box width.
+    - `h`: Bounding box height.
+    - `name`: object name
+
+#### stuff-only
+
+- `image`: A `PIL.Image.Image` object containing the image.
+- `image_id`: Unique numeric ID of the image.
+- `image_filename`: File name of the image.
+- `width`: Image width.
+- `height`: Image height.
+- `objects`: Holds a list of `Object` data classes:
+    - `object_id`: Unique numeric ID of the object.
+    - `x`: x coordinate of bounding box's top left corner.
+    - `y`: y coordinate of bounding box's top left corner.
+    - `w`: Bounding box width.
+    - `h`: Bounding box height.
+    - `name`: object name
+
+### Data Splits
+
+| name        | train   | validation |
+|-------------|--------:|-----------:|
+| stuff-thing | 118,280 | 5,000      |
+| stuff-only  | 118,280 | 5,000      |
+
+## Dataset Creation
+
+### Curation Rationale
+
+### Source Data
+
+#### Initial Data Collection and Normalization
+
+#### Who are the source language producers?
+
+### Annotations
+
+#### Annotation process
+
+#### Who are the annotators?
+
+From the paper:
+
+> COCO-Stuff contains 172 classes: 80 thing, 91 stuff, and 1 class unlabeled. The 80 thing classes are the same as in COCO [35]. The 91 stuff classes are curated by an expert annotator. The class unlabeled is used in two situations: if a label does not belong to any of the 171 predefined classes, or if the annotator cannot infer the label of a pixel.
+
+### Personal and Sensitive Information
+
+## Considerations for Using the Data
+
+### Social Impact of Dataset
+
+### Discussion of Biases
+
+### Other Known Limitations
+
+## Additional Information
+
+### Dataset Curators
+
+### Licensing Information
+
+COCO-Stuff is a derivative work of the COCO dataset. The authors of COCO do not in any form endorse this work. Different licenses apply:
+- COCO images: [Flickr Terms of use](http://cocodataset.org/#termsofuse) 
+- COCO annotations: [Creative Commons Attribution 4.0 License](http://cocodataset.org/#termsofuse)
+- COCO-Stuff annotations & code: [Creative Commons Attribution 4.0 License](http://cocodataset.org/#termsofuse)
+
+### Citation Information
+
+```bibtex
+@INPROCEEDINGS{caesar2018cvpr,
+  title={COCO-Stuff: Thing and stuff classes in context},
+  author={Caesar, Holger and Uijlings, Jasper and Ferrari, Vittorio},
+  booktitle={Computer vision and pattern recognition (CVPR), 2018 IEEE conference on},
+  organization={IEEE},
+  year={2018}
+}
+```
+
+### Contributions
+
+Thanks to [@nightrome](https://github.com/nightrome) for publishing the COCO-Stuff dataset.

cocostuff.py

@@ -0,0 +1,368 @@
+import copy
+import json
+import logging
+import os
+from collections import defaultdict
+from typing import Dict, TypedDict
+
+import datasets as ds
+
+logger = logging.getLogger(__name__)
+
+_CITATION = """\
+@INPROCEEDINGS{caesar2018cvpr,
+  title={COCO-Stuff: Thing and stuff classes in context},
+  author={Caesar, Holger and Uijlings, Jasper and Ferrari, Vittorio},
+  booktitle={Computer vision and pattern recognition (CVPR), 2018 IEEE conference on},
+  organization={IEEE},
+  year={2018}
+}
+"""
+
+_DESCRIPTION = """\
+COCO-Stuff augments all 164K images of the popular COCO dataset with pixel-level stuff annotations. These annotations can be used for scene understanding tasks like semantic segmentation, object detection and image captioning.
+"""
+
+_HOMEPAGE = "https://github.com/nightrome/cocostuff"
+
+_LICENSE = """\
+COCO-Stuff is a derivative work of the COCO dataset. The authors of COCO do not in any form endorse this work. Different licenses apply:
+- COCO images: Flickr Terms of use
+- COCO annotations: Creative Commons Attribution 4.0 License
+- COCO-Stuff annotations & code: Creative Commons Attribution 4.0 License
+"""
+
+
+class URLs(TypedDict):
+    train: str
+    val: str
+    stuffthingmaps_trainval: str
+    stuff_trainval: str
+    labels: str
+
+
+_URLS: URLs = {
+    "train": "http://images.cocodataset.org/zips/train2017.zip",
+    "val": "http://images.cocodataset.org/zips/val2017.zip",
+    "stuffthingmaps_trainval": "http://calvin.inf.ed.ac.uk/wp-content/uploads/data/cocostuffdataset/stuffthingmaps_trainval2017.zip",
+    "stuff_trainval": "http://calvin.inf.ed.ac.uk/wp-content/uploads/data/cocostuffdataset/stuff_trainval2017.zip",
+    "labels": "https://raw.githubusercontent.com/nightrome/cocostuff/master/labels.txt",
+}
+
+
+class GenerateExamplesArguments(TypedDict):
+    image_dirpath: str
+    stuff_dirpath: str
+    stuff_thing_maps_dirpath: str
+    labels_path: str
+    split: str
+
+
+def _load_json(json_path: str):
+    logger.info(f"Load json from {json_path}")
+    with open(json_path, "r") as rf:
+        json_data = json.load(rf)
+    return json_data
+
+
+def _load_labels(labels_path: str) -> Dict[int, str]:
+    label_id_to_label_name: Dict[int, str] = {}
+
+    logger.info(f"Load labels from {labels_path}")
+    with open(labels_path, "r") as rf:
+        for line in rf:
+            label_id, label_name = line.strip().split(": ")
+            label_id_to_label_name[int(label_id)] = label_name
+    return label_id_to_label_name
+
+
+class CocoStuffDataset(ds.GeneratorBasedBuilder):
+
+    VERSION = ds.Version("1.0.0")  # type: ignore
+
+    BUILDER_CONFIGS = [
+        ds.BuilderConfig(
+            name="stuff-thing",
+            version=VERSION,  # type: ignore
+            description="Stuff+thing PNG-style annotations on COCO 2017 trainval",
+        ),
+        ds.BuilderConfig(
+            name="stuff-only",
+            version=VERSION,  # type: ignore
+            description="Stuff-only COCO-style annotations on COCO 2017 trainval",
+        ),
+    ]
+
+    def _info(self) -> ds.DatasetInfo:
+        if self.config.name == "stuff-thing":
+            features = ds.Features(
+                {
+                    "image": ds.Image(),
+                    "image_id": ds.Value("int32"),
+                    "image_filename": ds.Value("string"),
+                    "width": ds.Value("int32"),
+                    "height": ds.Value("int32"),
+                    "stuff_map": ds.Image(),
+                    "objects": [
+                        {
+                            "object_id": ds.Value("string"),
+                            "x": ds.Value("int32"),
+                            "y": ds.Value("int32"),
+                            "w": ds.Value("int32"),
+                            "h": ds.Value("int32"),
+                            "name": ds.Value("string"),
+                        }
+                    ],
+                }
+            )
+        elif self.config.name == "stuff-only":
+            features = ds.Features(
+                {
+                    "image": ds.Image(),
+                    "image_id": ds.Value("int32"),
+                    "image_filename": ds.Value("string"),
+                    "width": ds.Value("int32"),
+                    "height": ds.Value("int32"),
+                    "objects": [
+                        {
+                            "object_id": ds.Value("int32"),
+                            "x": ds.Value("int32"),
+                            "y": ds.Value("int32"),
+                            "w": ds.Value("int32"),
+                            "h": ds.Value("int32"),
+                            "name": ds.Value("string"),
+                        }
+                    ],
+                }
+            )
+        else:
+            raise ValueError(f"Invalid dataset name: {self.config.name}")
+
+        return ds.DatasetInfo(
+            description=_DESCRIPTION,
+            features=features,
+            homepage=_HOMEPAGE,
+            license=_LICENSE,
+            citation=_CITATION,
+        )
+
+    def load_stuff_json(self, stuff_dirpath: str, split: str):
+        return _load_json(
+            json_path=os.path.join(stuff_dirpath, f"stuff_{split}2017.json")
+        )
+
+    def get_image_id_to_image_infos(self, images):
+
+        image_id_to_image_infos = {}
+        for img_dict in images:
+            image_id = img_dict.pop("id")
+            image_id_to_image_infos[image_id] = img_dict
+
+        image_id_to_image_infos = dict(sorted(image_id_to_image_infos.items()))
+        return image_id_to_image_infos
+
+    def get_image_id_to_annotations(self, annotations):
+
+        image_id_to_annotations = defaultdict(list)
+        for ann_dict in annotations:
+            image_id = ann_dict.pop("image_id")
+            image_id_to_annotations[image_id].append(ann_dict)
+
+        image_id_to_annotations = dict(sorted(image_id_to_annotations.items()))
+        return image_id_to_annotations
+
+    def _split_generators(self, dl_manager: ds.DownloadManager):
+        downloaded_files = dl_manager.download_and_extract(_URLS)
+
+        tng_image_dirpath = os.path.join(downloaded_files["train"], "train2017")
+        val_image_dirpath = os.path.join(downloaded_files["val"], "val2017")
+
+        stuff_dirpath = downloaded_files["stuff_trainval"]
+        stuff_things_maps_dirpath = downloaded_files["stuffthingmaps_trainval"]
+        labels_path = downloaded_files["labels"]
+
+        tng_gen_kwargs: GenerateExamplesArguments = {
+            "image_dirpath": tng_image_dirpath,
+            "stuff_dirpath": stuff_dirpath,
+            "stuff_thing_maps_dirpath": stuff_things_maps_dirpath,
+            "labels_path": labels_path,
+            "split": "train",
+        }
+        val_gen_kwargs: GenerateExamplesArguments = {
+            "image_dirpath": val_image_dirpath,
+            "stuff_dirpath": stuff_dirpath,
+            "stuff_thing_maps_dirpath": stuff_things_maps_dirpath,
+            "labels_path": labels_path,
+            "split": "val",
+        }
+        return [
+            ds.SplitGenerator(
+                name=ds.Split.TRAIN,  # type: ignore
+                gen_kwargs=tng_gen_kwargs,  # type: ignore
+            ),
+            ds.SplitGenerator(
+                name=ds.Split.VALIDATION,  # type: ignore
+                gen_kwargs=val_gen_kwargs,  # type: ignore
+            ),
+        ]
+
+    def _generate_examples_for_stuff_thing(
+        self,
+        image_dirpath: str,
+        stuff_dirpath: str,
+        stuff_thing_maps_dirpath: str,
+        labels_path: str,
+        split: str,
+    ):
+        id_to_label = _load_labels(labels_path=labels_path)
+        stuff_json = self.load_stuff_json(stuff_dirpath=stuff_dirpath, split=split)
+
+        image_id_to_image_infos = self.get_image_id_to_image_infos(
+            images=copy.deepcopy(stuff_json["images"])
+        )
+        image_id_to_stuff_annotations = self.get_image_id_to_annotations(
+            annotations=copy.deepcopy(stuff_json["annotations"])
+        )
+
+        assert len(image_id_to_image_infos.keys()) >= len(
+            image_id_to_stuff_annotations.keys()
+        )
+
+        for image_id in image_id_to_stuff_annotations.keys():
+
+            img_info = image_id_to_image_infos[image_id]
+            image_filename = img_info["file_name"]
+            image_filepath = os.path.join(image_dirpath, image_filename)
+            img_example_dict = {
+                "image": image_filepath,
+                "image_id": image_id,
+                "image_filename": image_filename,
+                "width": img_info["width"],
+                "height": img_info["height"],
+            }
+
+            img_anns = image_id_to_stuff_annotations[image_id]
+            bboxes = [list(map(int, ann["bbox"])) for ann in img_anns]
+            category_ids = [ann["category_id"] for ann in img_anns]
+            category_labels = list(
+                map(
+                    lambda cat_id: id_to_label.get(cat_id, f"unknown-{cat_id}"),
+                    category_ids,
+                )
+            )
+            assert len(bboxes) == len(category_ids) == len(category_labels)
+            zip_it = zip(bboxes, category_ids, category_labels)
+            objects_example = [
+                {
+                    "object_id": category_id,
+                    "x": bbox[0],
+                    "y": bbox[1],
+                    "w": bbox[2],
+                    "h": bbox[3],
+                    "name": category_label,
+                }
+                for bbox, category_id, category_label in zip_it
+            ]
+
+            root, _ = os.path.splitext(img_example_dict["image_filename"])
+            stuff_map_filepath = os.path.join(
+                stuff_thing_maps_dirpath, f"{split}2017", f"{root}.png"
+            )
+
+            example_dict = {
+                **img_example_dict,
+                "objects": objects_example,
+                "stuff_map": stuff_map_filepath,
+            }
+            yield image_id, example_dict
+
+    def _generate_examples_for_stuff_only(
+        self,
+        image_dirpath: str,
+        stuff_dirpath: str,
+        labels_path: str,
+        split: str,
+    ):
+        id_to_label = _load_labels(labels_path=labels_path)
+        stuff_json = self.load_stuff_json(stuff_dirpath=stuff_dirpath, split=split)
+
+        image_id_to_image_infos = self.get_image_id_to_image_infos(
+            images=copy.deepcopy(stuff_json["images"])
+        )
+        image_id_to_stuff_annotations = self.get_image_id_to_annotations(
+            annotations=copy.deepcopy(stuff_json["annotations"])
+        )
+
+        assert len(image_id_to_image_infos.keys()) >= len(
+            image_id_to_stuff_annotations.keys()
+        )
+
+        for image_id in image_id_to_stuff_annotations.keys():
+
+            img_info = image_id_to_image_infos[image_id]
+            image_filename = img_info["file_name"]
+            image_filepath = os.path.join(image_dirpath, image_filename)
+            img_example_dict = {
+                "image": image_filepath,
+                "image_id": image_id,
+                "image_filename": image_filename,
+                "width": img_info["width"],
+                "height": img_info["height"],
+            }
+
+            img_anns = image_id_to_stuff_annotations[image_id]
+            bboxes = [list(map(int, ann["bbox"])) for ann in img_anns]
+            category_ids = [ann["category_id"] for ann in img_anns]
+            category_labels = list(
+                map(
+                    lambda cat_id: id_to_label.get(cat_id, f"unknown-{cat_id}"),
+                    category_ids,
+                )
+            )
+            assert len(bboxes) == len(category_ids) == len(category_labels)
+            zip_it = zip(bboxes, category_ids, category_labels)
+            objects_example = [
+                {
+                    "object_id": category_id,
+                    "x": bbox[0],
+                    "y": bbox[1],
+                    "w": bbox[2],
+                    "h": bbox[3],
+                    "name": category_label,
+                }
+                for bbox, category_id, category_label in zip_it
+            ]
+
+            example_dict = {
+                **img_example_dict,
+                "objects": objects_example,
+            }
+            yield image_id, example_dict
+
+    def _generate_examples(  # type: ignore
+        self,
+        image_dirpath: str,
+        stuff_dirpath: str,
+        stuff_thing_maps_dirpath: str,
+        labels_path: str,
+        split: str,
+    ):
+        logger.info(f"Generating examples for {split}.")
+
+        if "stuff-thing" in self.config.name:
+            return self._generate_examples_for_stuff_thing(
+                image_dirpath=image_dirpath,
+                stuff_dirpath=stuff_dirpath,
+                stuff_thing_maps_dirpath=stuff_thing_maps_dirpath,
+                labels_path=labels_path,
+                split=split,
+            )
+        elif "stuff-only" in self.config.name:
+            return self._generate_examples_for_stuff_only(
+                image_dirpath=image_dirpath,
+                stuff_dirpath=stuff_dirpath,
+                labels_path=labels_path,
+                split=split,
+            )
+        else:
+            raise ValueError(f"Invalid dataset name: {self.config.name}")

pyproject.toml

@@ -0,0 +1,24 @@
+[tool.poetry]
+name = "huggingface-datasets-cocostuff"
+version = "0.1.0"
+description = ""
+authors = ["Shunsuke KITADA <[email protected]>"]
+readme = "README.md"
+packages = []
+
+[tool.poetry.dependencies]
+python = "^3.8"
+datasets = "^2.6.1"
+pillow = "^9.3.0"
+
+
+[tool.poetry.group.dev.dependencies]
+black = "^22.10.0"
+isort = "^5.10.1"
+flake8 = "^5.0.4"
+mypy = "^0.982"
+pytest = "^7.2.0"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

tests/cocostuff_test.py

@@ -0,0 +1,61 @@
+import logging
+import os
+
+import datasets as ds
+import pytest
+
+logging.basicConfig(
+    format="%(asctime)s - %(levelname)s - %(name)s - %(message)s", level=logging.INFO
+)
+
+
+@pytest.fixture
+def dataset_path() -> str:
+    return "cocostuff.py"
+
+
+@pytest.mark.skipif(
+    bool(os.environ.get("CI", False)),
+    reason="Because this test downloads a large data set, we will skip running it on CI.",
+)
+def test_load_stuff_thing_dataset(dataset_path: str):
+    dataset = ds.load_dataset(path=dataset_path, name="stuff-thing")
+
+    expected_features = [
+        "image",
+        "image_id",
+        "image_filename",
+        "width",
+        "height",
+        "stuff_map",
+        "objects",
+    ]
+    for expected_feature in expected_features:
+        assert expected_feature in dataset["train"].features.keys()  # type: ignore
+        assert expected_feature in dataset["validation"].features.keys()  # type: ignore
+
+    assert dataset["train"].num_rows == 118280  # type: ignore
+    assert dataset["validation"].num_rows == 5000  # type: ignore
+
+
+@pytest.mark.skipif(
+    bool(os.environ.get("CI", False)),
+    reason="Because this test downloads a large data set, we will skip running it on CI.",
+)
+def test_load_stuff_only_dataset(dataset_path: str):
+    dataset = ds.load_dataset(path=dataset_path, name="stuff-only")
+
+    expected_features = [
+        "image",
+        "image_id",
+        "image_filename",
+        "width",
+        "height",
+        "objects",
+    ]
+    for expected_feature in expected_features:
+        assert expected_feature in dataset["train"].features.keys()  # type: ignore
+        assert expected_feature in dataset["validation"].features.keys()  # type: ignore
+
+    assert dataset["train"].num_rows == 118280  # type: ignore
+    assert dataset["validation"].num_rows == 5000  # type: ignore