init commit

.gitattributes

@@ -0,0 +1,55 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.lz4 filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+# Audio files - uncompressed
+*.pcm filter=lfs diff=lfs merge=lfs -text
+*.sam filter=lfs diff=lfs merge=lfs -text
+*.raw filter=lfs diff=lfs merge=lfs -text
+# Audio files - compressed
+*.aac filter=lfs diff=lfs merge=lfs -text
+*.flac filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+*.ogg filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text
+# Image files - uncompressed
+*.bmp filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.tiff filter=lfs diff=lfs merge=lfs -text
+# Image files - compressed
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,2 @@
+*.egg-info/
+*/__pycache__/

README.md

@@ -0,0 +1,146 @@
+---
+pretty_name: COCO2017
+annotations_creators:
+  - expert-generated
+size_categories:
+- 100K<n<1M
+language:
+  - en
+task_categories:
+  - object-detection
+---
+
+# Dataset Card for Dataset Name
+
+This dataset includes **COCO 2017** only. 
+
+COCO 2014 and 2015 will be included soon.
+
+## Dataset Description
+
+- **Homepage:**  https://cocodataset.org/
+- **Repository:** https://github.com/cocodataset/cocoapi
+- **Paper:** [Microsoft COCO: Common Objects in Context](https://arxiv.org/abs/1405.0312)
+
+### Dataset Summary
+
+COCO (Common Objects in Context) is a large-scale object detection, segmentation, and captioning dataset. It contains over 200,000 labeled images with over 80 category labels. It includes complex, everyday scenes with common objects in their natural context.
+
+This dataset covers only the "object detection" part of the COCO dataset. But some features and specifications for the full COCO dataset:
+
+- Object segmentation 
+- Recognition in context
+- Superpixel stuff segmentation
+- 330K images (>200K labeled)
+- 1.5 million object instances
+- 80 object categories
+- 91 stuff categories
+- 5 captions per image
+- 250,000 people with keypoints
+  
+### Data Splits
+
+- **Training set ("train")**: 118287 images annotated with 860001 bounding boxes in total.
+- **Validation set ("val")**: 5000 images annotated with 36781 bounding boxes in total.
+
+- **92 classes**: "None", "person", "bicycle", "car", "motorcycle", "airplane", "bus", "train", "truck", "boat", "traffic light", "fire hydrant", "street sign", "stop sign", "parking meter", "bench", "bird", "cat", "dog", "horse", "sheep", "cow", "elephant", "bear", "zebra", "giraffe", "hat", "backpack", "umbrella", "shoe", "eye glasses", "handbag", "tie", "suitcase", "frisbee", "skis", "snowboard", "sports ball", "kite", "baseball bat", "baseball glove", "skateboard", "surfboard", "tennis racket", "bottle", "plate", "wine glass", "cup", "fork", "knife", "spoon", "bowl", "banana", "apple", "sandwich", "orange", "broccoli", "carrot", "hot dog", "pizza", "donut", "cake", "chair", "couch", "potted plant", "bed", "mirror", "dining table", "window", "desk", "toilet", "door", "tv", "laptop", "mouse", "remote", "keyboard", "cell phone", "microwave", "oven", "toaster", "sink", "refrigerator", "blender", "book", "clock", "vase", "scissors", "teddy bear", "hair drier", "toothbrush", "hair brush"
+
+- **But only 80 classes have with annotations**: "person", "bicycle", "car", "motorcycle", "airplane", "bus", "train", "truck", "boat", "traffic light", "fire hydrant", "stop sign", "parking meter", "bench", "bird", "cat", "dog", "horse", "sheep", "cow", "elephant", "bear", "zebra", "giraffe", "backpack", "umbrella", "handbag", "tie", "suitcase", "frisbee", "skis", "snowboard", "sports ball", "kite", "baseball bat", "baseball glove", "skateboard", "surfboard", "tennis racket", "bottle", "wine glass", "cup", "fork", "knife", "spoon", "bowl", "banana", "apple", "sandwich", "orange", "broccoli", "carrot", "hot dog", "pizza", "donut", "cake", "chair", "couch", "potted plant", "bed", "dining table", "toilet", "tv", "laptop", "mouse", "remote", "keyboard", "cell phone", "microwave", "oven", "toaster", "sink", "refrigerator", "book", "clock", "vase", "scissors", "teddy bear", "hair drier", "toothbrush"
+
+### Boxes format:
+
+For the object detection set of COCO dataset, the ground-truth bounding boxes are provided in the following format: `x, y, width, height` in absolute coordinates.
+
+### Curation Rationale
+
+COCO dataset was curated with the goal of advancing the state of the art in many tasks, such as object detection, dense pose, keypoints, segmentation and image classification.
+
+### Licensing Information
+
+The annotations in this dataset belong to the COCO Consortium and are licensed under a Creative Commons Attribution 4.0 License.
+
+Mode details at: https://cocodataset.org/#termsofuse
+
+### Loading dataset
+
+You can load COCO 2017 dataset by calling:
+
+```
+from datasets import load_dataset
+# Full dataset
+dataset = load_dataset("rafaelpadilla/coco2017")
+print(dataset)
+>> DatasetDict({
+>>     train: Dataset({
+>>         features: ['image', 'image_id', 'objects'],
+>>         num_rows: 118287
+>>     })
+>>     val: Dataset({
+>>         features: ['image', 'image_id', 'objects'],
+>>         num_rows: 5000
+>>     })
+>> })
+
+# Training set only
+dataset = load_dataset("rafaelpadilla/coco2017", split="train")
+
+# Validation set only
+dataset = load_dataset("rafaelpadilla/coco2017", split="val")
+```
+
+### COCODataset Class
+
+We offer the dataset class `COCODataset` that extends VisionDataset to represents images and annotations of COCO. To use it, you need to install coco2017 package. For that, follow the steps below:
+
+1. Create and activate an environment:
+```
+conda create -n coco2017 python=3.11 
+conda activate coco2017
+```
+
+2. Install cocodataset package:
+
+```
+pip install git+https://huggingface.co/datasets/rafaelpadilla/coco2017@main
+```
+
+or alternatively:
+
+```
+git clone https://huggingface.co/datasets/rafaelpadilla/coco2017
+cd coco2017
+pip install .
+```
+
+3. Now you can import `COCODataset` class into your Python code by:
+```
+from cocodataset import COCODataset
+```
+
+
+### Citation Information
+
+@inproceedings{lin2014microsoft,  
+  title={Microsoft coco: Common objects in context},  
+  author={Lin, Tsung-Yi and Maire, Michael and Belongie, Serge and Hays, James and Perona, Pietro and Ramanan, Deva and Doll{\'a}r, Piotr and Zitnick, C Lawrence},  
+  booktitle={Computer Vision--ECCV 2014: 13th European Conference, Zurich, Switzerland, September 6-12, 2014, Proceedings, Part V 13},  
+  pages={740--755},  
+  year={2014},  
+  organization={Springer}  
+}  
+
+### Contributions
+
+Tsung-Yi Lin Google Brain  
+Genevieve Patterson MSR, Trash TV  
+Matteo R. Ronchi Caltech  
+Yin Cui Google  
+Michael Maire TTI-Chicago  
+Serge Belongie Cornell Tech  
+Lubomir Bourdev WaveOne, Inc.  
+Ross Girshick FAIR  
+James Hays Georgia Tech  
+Pietro Perona Caltech  
+Deva Ramanan CMU  
+Larry Zitnick FAIR  
+Piotr Dollár FAIR  

coco2017.py

@@ -0,0 +1,335 @@
+# 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.
+
+import json
+from pathlib import Path
+from typing import Any, Dict, Iterator, List, Optional, Tuple, Union
+
+import datasets
+from datasets.data_files import DataFilesDict
+from datasets.download.download_manager import ArchiveIterable, DownloadManager
+from datasets.features import Features
+from datasets.info import DatasetInfo
+
+# Typing
+_TYPING_BOX = Tuple[float, float, float, float]
+
+_CITATION = """\
+@article{DBLP:journals/corr/LinMBHPRDZ14,
+  author    = {Tsung{-}Yi Lin and
+               Michael Maire and
+               Serge J. Belongie and
+               Lubomir D. Bourdev and
+               Ross B. Girshick and
+               James Hays and
+               Pietro Perona and
+               Deva Ramanan and
+               Piotr Doll{\'{a}}r and
+               C. Lawrence Zitnick},
+  title     = {Microsoft {COCO:} Common Objects in Context},
+  journal   = {CoRR},
+  volume    = {abs/1405.0312},
+  year      = {2014},
+  url       = {http://arxiv.org/abs/1405.0312},
+  archivePrefix = {arXiv},
+  eprint    = {1405.0312},
+  timestamp = {Mon, 13 Aug 2018 16:48:13 +0200},
+  biburl    = {https://dblp.org/rec/bib/journals/corr/LinMBHPRDZ14},
+  bibsource = {dblp computer science bibliography, https://dblp.org}
+}
+"""
+
+_DESCRIPTION = """\
+This dataset contains all COCO 2017 images and annotations split in training (118287 images) \
+    and validation (5000 images).
+"""
+
+_HOMEPAGE = "https://cocodataset.org"
+
+_URLS = {
+    "annotations": "http://images.cocodataset.org/annotations/annotations_trainval2017.zip",
+    "train": "http://images.cocodataset.org/zips/train2017.zip",
+    "val": "http://images.cocodataset.org/zips/val2017.zip",
+}
+
+_SPLITS = ["train", "val"]
+
+_PATHS = {
+    "annotations": {
+        "train": Path("annotations/instances_train2017.json"),
+        "val": Path("annotations/instances_val2017.json"),
+    },
+    "images": {
+        "train": Path("train2017"),
+        "val": Path("val2017"),
+    },
+}
+
+_CLASSES = [
+    "None",
+    "person",
+    "bicycle",
+    "car",
+    "motorcycle",
+    "airplane",
+    "bus",
+    "train",
+    "truck",
+    "boat",
+    "traffic light",
+    "fire hydrant",
+    "street sign",
+    "stop sign",
+    "parking meter",
+    "bench",
+    "bird",
+    "cat",
+    "dog",
+    "horse",
+    "sheep",
+    "cow",
+    "elephant",
+    "bear",
+    "zebra",
+    "giraffe",
+    "hat",
+    "backpack",
+    "umbrella",
+    "shoe",
+    "eye glasses",
+    "handbag",
+    "tie",
+    "suitcase",
+    "frisbee",
+    "skis",
+    "snowboard",
+    "sports ball",
+    "kite",
+    "baseball bat",
+    "baseball glove",
+    "skateboard",
+    "surfboard",
+    "tennis racket",
+    "bottle",
+    "plate",
+    "wine glass",
+    "cup",
+    "fork",
+    "knife",
+    "spoon",
+    "bowl",
+    "banana",
+    "apple",
+    "sandwich",
+    "orange",
+    "broccoli",
+    "carrot",
+    "hot dog",
+    "pizza",
+    "donut",
+    "cake",
+    "chair",
+    "couch",
+    "potted plant",
+    "bed",
+    "mirror",
+    "dining table",
+    "window",
+    "desk",
+    "toilet",
+    "door",
+    "tv",
+    "laptop",
+    "mouse",
+    "remote",
+    "keyboard",
+    "cell phone",
+    "microwave",
+    "oven",
+    "toaster",
+    "sink",
+    "refrigerator",
+    "blender",
+    "book",
+    "clock",
+    "vase",
+    "scissors",
+    "teddy bear",
+    "hair drier",
+    "toothbrush",
+    "hair brush",
+]
+
+def round_box_values(box, decimals=2):
+    return [round(val, decimals) for val in box]
+
+class COCOHelper:
+    """Helper class to load COCO annotations"""
+
+    def __init__(self, annotation_path: Path, images_dir: Path) -> None:
+        with open(annotation_path, "r") as file:
+            data = json.load(file)
+        self.data = data
+        
+        dict_id2annot: Dict[int, Any] = {}
+        for annot in self.annotations:
+            dict_id2annot.setdefault(annot["image_id"], []).append(annot)
+
+        # Sort by id
+        dict_id2annot = {
+            k: list(sorted(v, key=lambda a: a["id"])) for k, v in dict_id2annot.items()
+        }
+
+        self.dict_path2annot: Dict[str, Any] = {}
+        self.dict_path2id: Dict[str, Any] = {}
+        for img in self.images:
+            path_img = images_dir / str(img["file_name"])
+            path_img_str = str(path_img)
+            idx = int(img["id"])
+            annot = dict_id2annot.get(idx, [])
+            self.dict_path2annot[path_img_str] = annot
+            self.dict_path2id[path_img_str] = img["id"]
+
+
+    def __len__(self) -> int:
+        return len(self.data["images"])
+
+    @property
+    def info(self) -> Dict[str, Union[str, int]]:
+        return self.data["info"]
+
+    @property
+    def licenses(self) -> List[Dict[str, Union[str, int]]]:
+        return self.data["licenses"]
+
+    @property
+    def images(self) -> List[Dict[str, Union[str, int]]]:
+        return self.data["images"]
+
+    @property
+    def annotations(self) -> List[Any]:
+        return self.data["annotations"]
+
+    @property
+    def categories(self) -> List[Dict[str, Union[str, int]]]:
+        return self.data["categories"]
+
+    def get_annotations(self, image_path: str) -> List[Any]:
+        return self.dict_path2annot.get(image_path, [])
+
+    def get_image_id(self, image_path: str) -> int:
+        return self.dict_path2id.get(image_path, -1)
+
+
+class COCO2017(datasets.GeneratorBasedBuilder):
+    """COCO 2017 dataset."""
+
+    VERSION = datasets.Version("1.0.1")
+    
+    def _info(self) -> datasets.DatasetInfo:
+        """
+        Returns the dataset metadata and features.
+
+        Returns:
+            DatasetInfo: Metadata and features of the dataset.
+        """
+        return datasets.DatasetInfo(
+            description=_DESCRIPTION,
+            features=datasets.Features(
+                {
+                    "image": datasets.Image(),
+                    "image_id": datasets.Value("int64"),
+                    "objects": datasets.Sequence(
+                        {
+                            "id": datasets.Value("int64"),
+                            "area": datasets.Value("float64"),
+                            "bbox": datasets.Sequence(
+                                datasets.Value("float32"), length=4
+                            ),
+                            "label": datasets.ClassLabel(names=_CLASSES),
+                            "iscrowd": datasets.Value("bool"),
+                        }
+                    ),
+                }
+            ),
+            homepage=_HOMEPAGE,
+            citation=_CITATION,
+        )
+
+    def _split_generators(
+        self, dl_manager: DownloadManager
+    ) -> List[datasets.SplitGenerator]:
+        """
+        Provides the split information and downloads the data.
+
+        Args:
+            dl_manager (DownloadManager): The DownloadManager to use for downloading and
+                extracting data.
+
+        Returns:
+            List[SplitGenerator]: List of SplitGenerator objects representing the data splits.
+        """
+        archive_annots = dl_manager.download_and_extract(_URLS["annotations"])
+
+        splits = []
+        for split in _SPLITS:
+            archive_split = dl_manager.download(_URLS[split])
+            annotation_path = Path(archive_annots) / _PATHS["annotations"][split]
+            images = dl_manager.iter_archive(archive_split)
+            splits.append(
+                datasets.SplitGenerator(
+                    name=datasets.Split(split),
+                    gen_kwargs={
+                        "annotation_path": annotation_path,
+                        "images_dir": _PATHS["images"][split],
+                        "images": images,
+                    },
+                )
+            )
+        return splits
+            
+    def _generate_examples(
+        self, annotation_path: Path, images_dir: Path, images: ArchiveIterable
+    ) -> Iterator:
+        """
+        Generates examples for the dataset.
+
+        Args:
+            annotation_path (Path): The path to the annotation file.
+            images_dir (Path): The path to the directory containing the images.
+            images: (ArchiveIterable): An iterable containing the images.
+
+        Yields:
+            Dict[str, Union[str, Image]]: A dictionary containing the generated examples.
+        """
+        coco_annotation = COCOHelper(annotation_path, images_dir)
+        
+        for image_path, f in images:
+            annotations = coco_annotation.get_annotations(image_path)
+            ret = {
+                "image": {"path": image_path, "bytes": f.read()},
+                "image_id": coco_annotation.get_image_id(image_path),
+                "objects": [
+                    {
+                        "id": annot["id"],
+                        "area": annot["area"],
+                        "bbox": round_box_values(annot["bbox"], 2), # [x, y, w, h]
+                        "label": annot["category_id"],
+                        "iscrowd": bool(annot["iscrowd"]),
+                    }
+                    for annot in annotations
+                ],
+            }
+
+            yield image_path, ret

cocodataset/__init__.py

@@ -0,0 +1,2 @@
+from .dataset import COCODataset
+from .utils import draw_rectangles, val_formatted_anns, create_json_COCO_format

cocodataset/dataset.py

@@ -0,0 +1,109 @@
+# This code is an adaptation of https://huggingface.co/spaces/ybelkada/cocoevaluate
+
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
+
+import torch
+from datasets import Dataset
+from PIL import Image
+from torchvision.datasets.vision import VisionDataset
+
+_TYPING_BOXES = Tuple[float, float, float, float]
+_TYPING_ANNOTS = Dict[str, Union[int, str, _TYPING_BOXES]]
+_TYPING_LABELS = Dict[str, torch.Tensor]
+
+class COCODataset(VisionDataset):
+    """
+    A class that extends VisionDataset and represents a COCO detection dataset.
+    """
+
+    def __init__(
+        self,
+        loaded_json: _TYPING_ANNOTS,
+        ids_mapping: Dict[int, int],
+        dataset: Dataset,
+        transforms: Optional[Callable] = None,
+        transform: Optional[Callable] = None,
+        target_transform: Optional[Callable] = None,
+    ) -> None:
+        """
+        Arguments:
+            loaded_json: A dictionary that contains loaded json.
+            ids_mapping (Dict[int, int]): A dictionary that maps the index to the id.
+            dataset (Dataset): The data which is going to be used.
+            transforms (Optional): A function/transform that takes in an PIL image
+                and returns a transformed version.
+            transform (Optional): A function/transform that takes in an PIL image
+                and returns a transformed version. E.g, ``transforms.RandomCrop``.
+            target_transform (Optional): A function/transform that takes in the
+                target and transforms it.
+        """
+        root = ""
+        super().__init__(root, transforms, transform, target_transform)
+
+        self.ids_mapping = ids_mapping
+        self.dataset = dataset
+        
+        self.images = {img["id"]: img for img in loaded_json["images"]}
+        self.ids = sorted(self.images)
+        self.annotations = {}
+        for annot in loaded_json["annotations"]:
+            img_id = annot["image_id"]
+            self.annotations.setdefault(img_id, []).append(annot)
+
+    def _load_image(self, idx: int) -> Image:
+        """
+        Load an image given its id.
+
+        Arguments:
+            idx: Index of the image to be loaded.
+
+        Returns:
+            PIL Image instance.
+        """
+        id = self.ids_mapping[idx]
+        img = self.dataset[id]["image"].convert("RGB")
+        return img
+
+    def _load_target(self, idx: int) -> List[Any]:
+        """
+        Load the annotations of an image given its id.
+
+        Arguments:
+            idx: Index of the image to load its annotations.
+
+        Returns:
+            List containing the annotations of the image.
+        """
+        if idx not in self.annotations:
+            return []
+        return self.annotations[idx]
+
+    def __len__(self) -> int:
+        """
+        Returns the number of elements in the dataset.
+
+        Returns:
+            int: Number of images in the dataset.
+        """
+        return len(self.ids)
+
+    def __getitem__(self, index: int) -> Dict[str, Union[torch.Tensor, _TYPING_LABELS]]:
+        """
+        Given an index, it preprocesses and returns the image and its associated annotations \
+            at a that index.
+
+        Arguments:
+            index: Index of the image.
+
+        Returns:
+            Dictionary containing preprocessed image as pixel values and its associated \
+                annotations as labels.
+        """
+        image_id = self.ids[index]
+        # PIL Image
+        image = self._load_image(image_id)  
+        # List of annotation dicts 'id', 'category_id', 'iscrowd', 'imageid', 'area', 'bbox'
+        annot_dicts = self._load_target(image_id)
+       
+        target = {"image_id": image_id, "annotations": annot_dicts}
+        return {"image": image, "target": target} 

cocodataset/utils.py

@@ -0,0 +1,190 @@
+from PIL import Image, ImageDraw, ImageFont
+import torch
+from typing import Tuple, List, Dict, Union, Optional
+import torch.utils.data as data
+from tqdm import tqdm 
+import copy 
+
+# Typings
+_TYPING_BOX = Tuple[float, float, float, float]
+_TYPING_IMAGES = List[Dict[str, int]]
+_TYPING_ANNOTATIONS = List[Dict[str, Union[int, _TYPING_BOX]]]
+_TYPING_CATEGORIES = List[Dict[str, Union[int, str]]]
+_TYPING_JSON_COCO = Dict[
+    str, Union[_TYPING_IMAGES, _TYPING_ANNOTATIONS, _TYPING_CATEGORIES]
+]
+_TYPING_BOX = Tuple[float, float, float, float]
+_TYPING_SCORES = List[float]
+_TYPING_LABELS = List[int]
+_TYPING_BOXES = List[_TYPING_BOX]
+_TYPING_PRED_REF = Union[_TYPING_SCORES, _TYPING_LABELS, _TYPING_BOXES]
+_TYPING_PREDICTION = Dict[str, _TYPING_PRED_REF]
+
+_acc_box_format = ['xywh', 'xyx2y2']
+
+def draw_rectangles(
+    image: Image,
+    boxes,
+    box_format='xyx2y2',
+    color_bbx=(255, 0, 0),
+    color_txt=(255, 255, 255),
+    thickness=1,
+    labels=None,
+    confidences=None,
+    draw_confidence=True,
+):
+    """
+    Draw rectangles around objects in an image.
+
+    Args:
+        image (Image): Image object to draw on.
+        boxes (List[torch.Tensor]): List of bounding boxes in (xywh or xyx2y2) format.
+        color_bbx (Tuple[int, int, int]): RGB color tuple for bounding box outlines. Default \
+            is (255, 0, 0) (red).
+        color_txt (Tuple[int, int, int]): RGB color tuple for text. Default is \
+            (255, 255, 255) (white).
+        thickness (int): Thickness of the bounding box outline. Default is 1.
+        labels (List[str]): List of labels for each object. Default is None.
+        confidences (List[float]): List of confidences for each object. Default is None.
+        draw_confidence (bool): Whether to draw confidence values. Default is True.
+
+    Returns:
+        Image: Image with rectangles drawn around objects.
+    """
+    # boxes: (x,y,x2,y2)
+    # color: (RGB)
+    # https://pillow.readthedocs.io/en/stable/handbook/text-anchors.html
+    # https://pillow.readthedocs.io/en/stable/reference/ImageFont.html
+    
+    assert box_format in _acc_box_format, "box_format must be {}".format(_acc_box_format)
+    offset = 0.05
+    font = ImageFont.load_default()
+    
+    # Make clones to avoid overwriting the original data
+    if boxes is not None:
+        if isinstance(boxes, torch.Tensor):
+            _boxes = copy.deepcopy(boxes).tolist()
+        elif isinstance(boxes, list):
+            _boxes = copy.deepcopy(boxes)
+    else: 
+        _boxes = None
+        
+    if confidences is not None:
+        if isinstance(confidences, torch.Tensor):
+            _confidences = copy.deepcopy(confidences).tolist()
+        elif isinstance(confidences, list):
+            _confidences = copy.deepcopy(confidences)
+    else:
+        _confidences = None
+        draw_confidence = False
+        _confidences = ["" for i in _boxes]
+
+    ret_image = image.copy()
+    img_draw = ImageDraw.Draw(ret_image)
+    for box, label, confidence in zip(_boxes, labels, _confidences):
+        if box_format == "xywh":
+            # convert to xyx2y2
+            box[2] = box[0]+box[2]
+            box[3] = box[1]+box[3]
+        text = f"{label}"
+        if draw_confidence:
+            text += f" ({100*confidence:.2f}%)"
+        text = " " + text + " "
+        _, _, txt_w, txt_h = font.getbbox(text)
+        offset_y = txt_h * offset
+        x, y, _, _ = box
+        box_txt = (x, y - txt_h - (2 * offset_y), x + txt_w, y)
+        pos_text = (x, y - txt_h - (offset_y))
+
+        # Draws rectangle around object
+        img_draw.rectangle(box, outline=color_bbx, width=thickness)
+        # Draws filled rectangle for text
+        img_draw.rectangle(box_txt, fill=color_bbx, width=thickness)
+        # Draws text
+        img_draw.text(pos_text, text, fill=color_txt, anchor="ma", font=font)
+
+    return ret_image
+
+def val_formatted_anns(
+    image_id: int, objects: _TYPING_PREDICTION, feat_name: str = "category"
+) -> List[_TYPING_PREDICTION]:
+    """
+    This function formats annotations the same way they are for training, without the need \
+        for data augmentation.
+
+    Args:
+        image_id (int): The id of the image.
+        objects (_TYPING_PREDICTION): The dictionary containing object annotations.
+        feat_name (str): The name of the feature containing the category id.
+    Returns:
+        List[Dict[str, Union[int, _TYPING_BOX]]]: List of dictionaries with formatted annotations.
+    """
+    annotations = []
+    for i in range(0, len(objects["id"])):
+        new_ann = {
+            "id": objects["id"][i],
+            "category_id": objects[feat_name][i],
+            "iscrowd": objects["iscrowd"][i],
+            "image_id": image_id,
+            "area": objects["area"][i],
+            "bbox": objects["bbox"][i],
+        }
+        annotations.append(new_ann)
+
+    return annotations
+
+def create_json_COCO_format(
+    dataset: data.Dataset, round_approx: Optional[int] = None
+) -> Tuple[Dict[int, int], _TYPING_JSON_COCO]:
+    """
+    Function to create a JSON in COCO format.
+
+    Args:
+        dataset (Dataset): The dataset to be converted to COCO format.
+        round_approx (Optional[int]): The number of decimal places to round the boxes.
+
+    Returns:
+        A tuple of a dictionary mapping image_id to index in dataset and a dictionary \
+            in COCO format.
+    """
+    feature = dataset.features["objects"].feature
+    
+    # Look for the feature name
+    for feat_name in ["category", "label"]:
+        if feat_name in feature:
+            break
+    categories = feature[feat_name].names
+    
+    id2label = {index: x for index, x in enumerate(categories, start=0)}
+    categories_json = [
+        {"supercategory": "none", "id": id, "name": id2label[id]} for id in id2label
+    ]
+
+    output_json = {}
+    output_json["images"] = []
+    output_json["annotations"] = []
+
+    # Collecting outputs from dataset
+    ids_mapping = {}
+    pbar = tqdm(dataset, desc="Collecting ground-truth annotations from dataset")
+    for idx, example in enumerate(pbar):
+        
+        ids_mapping[example["image_id"]] = idx
+
+        ann = val_formatted_anns(example["image_id"], example["objects"], feat_name)
+        output_json["images"].append(
+            {
+                "id": example["image_id"],
+                "width": example["image"].width,
+                "height": example["image"].height,
+            }
+        )
+        if round_approx is not None:
+            for annotation in ann:
+                annotation["bbox"] = [round(val, round_approx) for val in annotation["bbox"]]
+            
+        output_json["annotations"].extend(ann)
+        
+    output_json["categories"] = categories_json
+
+    return ids_mapping, output_json

requirements.txt

@@ -0,0 +1,58 @@
+aiohttp==3.8.4
+aiosignal==1.3.1
+async-timeout==4.0.2
+attrs==23.1.0
+certifi==2023.5.7
+charset-normalizer==3.2.0
+cmake==3.26.4
+contourpy==1.1.0
+Cython==3.0.0
+datasets==2.13.1
+dill==0.3.6
+filelock==3.12.2
+fonttools==4.40.0
+frozenlist==1.4.0
+fsspec==2023.6.0
+huggingface-hub==0.16.4
+idna==3.4
+Jinja2==3.1.2
+kiwisolver==1.4.4
+lit==16.0.6
+MarkupSafe==2.1.3
+matplotlib==3.7.2
+mpmath==1.3.0
+multidict==6.0.4
+multiprocess==0.70.14
+networkx==3.1
+numpy==1.25.1
+nvidia-cublas-cu11==11.10.3.66
+nvidia-cuda-cupti-cu11==11.7.101
+nvidia-cuda-nvrtc-cu11==11.7.99
+nvidia-cuda-runtime-cu11==11.7.99
+nvidia-cudnn-cu11==8.5.0.96
+nvidia-cufft-cu11==10.9.0.58
+nvidia-curand-cu11==10.2.10.91
+nvidia-cusolver-cu11==11.4.0.1
+nvidia-cusparse-cu11==11.7.4.91
+nvidia-nccl-cu11==2.14.3
+nvidia-nvtx-cu11==11.7.91
+packaging==23.1
+pandas==2.0.3
+Pillow==10.0.0
+pyarrow==12.0.1
+python-dateutil==2.8.2
+pytz==2023.3
+PyYAML==6.0.1
+requests==2.31.0
+responses==0.18.0
+six==1.16.0
+sympy==1.12
+torch==2.0.1
+torchvision==0.15.2
+tqdm==4.65.0
+triton==2.0.0
+typing_extensions==4.7.1
+tzdata==2023.3
+urllib3==2.0.3
+xxhash==3.2.0
+yarl==1.9.2

setup.py

@@ -0,0 +1,45 @@
+__version__ = "0.0.2"
+
+import subprocess
+
+from setuptools import find_packages, setup
+from setuptools.command.develop import develop
+from setuptools.command.egg_info import egg_info
+from setuptools.command.install import install
+
+def custom_command():
+    subprocess.call(["pip", "install", "numpy", "cython"])
+    subprocess.call(["pip", "install", "-r", "requirements.txt", "--user"])
+
+
+class CustomInstallCommand(install):
+    def run(self):
+        install.run(self)
+        custom_command()
+
+
+class CustomDevelopCommand(develop):
+    def run(self):
+        develop.run(self)
+        custom_command()
+
+
+class CustomEggInfoCommand(egg_info):
+    def run(self):
+        egg_info.run(self)
+        custom_command()
+
+
+setup(
+    name="cocodataset",
+    description="COCO 2017 Dataset",
+    version=__version__,
+    zip_safe=True,
+    packages=find_packages(),
+    include_package_data=True,
+    cmdclass={
+        "install": CustomInstallCommand,
+        "develop": CustomDevelopCommand,
+        "egg_info": CustomEggInfoCommand,
+    },
+)