add script

README.md

@@ -1,3 +1,249 @@
 ---
 license: apache-2.0
+task_categories:
+- object-detection
+tags:
+- COCO
+- Detection
+- '2017'
+pretty_name: COCO detection dataset script
+size_categories:
+- 100K<n<1M
+dataset_info:
+  config_name: '2017'
+  features:
+  - name: id
+    dtype: int64
+  - name: objects
+    struct:
+    - name: bbox_id
+      sequence: int64
+    - name: category_id
+      sequence:
+        class_label:
+          names:
+            '0': N/A
+            '1': person
+            '2': bicycle
+            '3': car
+            '4': motorcycle
+            '5': airplane
+            '6': bus
+            '7': train
+            '8': truck
+            '9': boat
+            '10': traffic light
+            '11': fire hydrant
+            '12': street sign
+            '13': stop sign
+            '14': parking meter
+            '15': bench
+            '16': bird
+            '17': cat
+            '18': dog
+            '19': horse
+            '20': sheep
+            '21': cow
+            '22': elephant
+            '23': bear
+            '24': zebra
+            '25': giraffe
+            '26': hat
+            '27': backpack
+            '28': umbrella
+            '29': shoe
+            '30': eye glasses
+            '31': handbag
+            '32': tie
+            '33': suitcase
+            '34': frisbee
+            '35': skis
+            '36': snowboard
+            '37': sports ball
+            '38': kite
+            '39': baseball bat
+            '40': baseball glove
+            '41': skateboard
+            '42': surfboard
+            '43': tennis racket
+            '44': bottle
+            '45': plate
+            '46': wine glass
+            '47': cup
+            '48': fork
+            '49': knife
+            '50': spoon
+            '51': bowl
+            '52': banana
+            '53': apple
+            '54': sandwich
+            '55': orange
+            '56': broccoli
+            '57': carrot
+            '58': hot dog
+            '59': pizza
+            '60': donut
+            '61': cake
+            '62': chair
+            '63': couch
+            '64': potted plant
+            '65': bed
+            '66': mirror
+            '67': dining table
+            '68': window
+            '69': desk
+            '70': toilet
+            '71': door
+            '72': tv
+            '73': laptop
+            '74': mouse
+            '75': remote
+            '76': keyboard
+            '77': cell phone
+            '78': microwave
+            '79': oven
+            '80': toaster
+            '81': sink
+            '82': refrigerator
+            '83': blender
+            '84': book
+            '85': clock
+            '86': vase
+            '87': scissors
+            '88': teddy bear
+            '89': hair drier
+            '90': toothbrush
+    - name: bbox
+      sequence:
+        sequence: float64
+        length: 4
+    - name: iscrowd
+      sequence: int64
+    - name: area
+      sequence: float64
+  - name: height
+    dtype: int64
+  - name: width
+    dtype: int64
+  - name: file_name
+    dtype: string
+  - name: coco_url
+    dtype: string
+  - name: image_path
+    dtype: string
+  splits:
+  - name: train
+    num_bytes: 87231216
+    num_examples: 117266
+  - name: validation
+    num_bytes: 3692192
+    num_examples: 4952
+  download_size: 20405354669
+  dataset_size: 90923408
 ---
+## Usage
+For using the COCO dataset (2017), you need to download it manually first:
+```bash
+wget http://images.cocodataset.org/zips/train2017.zip
+wget http://images.cocodataset.org/zips/val2017.zip
+wget http://images.cocodataset.org/annotations/annotations_trainval2017.zip
+```
+
+Then to load the dataset:
+```python
+COCO_DIR = ...(path to the downloaded dataset directory)...
+ds = datasets.load_dataset(
+    "yonigozlan/coco_2017_detection_script",
+    "2017",
+    data_dir=COCO_DIR,
+    trust_remote_code=True,
+)
+```
+
+## Benchmarking
+Here is an example of how to benchmark a 🤗 Transformers object detection model on the validation data of the COCO dataset:
+
+```python
+import datasets
+import torch
+from PIL import Image
+from torch.utils.data import DataLoader
+from torchmetrics.detection.mean_ap import MeanAveragePrecision
+from tqdm import tqdm
+
+from transformers import AutoImageProcessor, AutoModelForObjectDetection
+
+# prepare data
+COCO_DIR = ...(path to the downloaded dataset directory)...
+ds = datasets.load_dataset(
+    "yonigozlan/coco_2017_detection_script",
+    "2017",
+    data_dir=COCO_DIR,
+    trust_remote_code=True,
+)
+val_data = ds["validation"]
+categories = val_data.features["objects"]["category_id"].feature.names
+id2label = {index: x for index, x in enumerate(categories, start=0)}
+label2id = {v: k for k, v in id2label.items()}
+checkpoint = "facebook/detr-resnet-50"
+
+# load model and processor
+model = AutoModelForObjectDetection.from_pretrained(
+    checkpoint, torch_dtype=torch.float16
+).to("cuda")
+id2label_model = model.config.id2label
+processor = AutoImageProcessor.from_pretrained(checkpoint)
+
+
+def collate_fn(batch):
+    data = {}
+    images = [Image.open(x["image_path"]).convert("RGB") for x in batch]
+    data["images"] = images
+    annotations = []
+    for x in batch:
+        boxes = x["objects"]["bbox"]
+        # convert to xyxy format
+        boxes = [[box[0], box[1], box[0] + box[2], box[1] + box[3]] for box in boxes]
+        labels = x["objects"]["category_id"]
+        boxes = torch.tensor(boxes)
+        labels = torch.tensor(labels)
+        annotations.append({"boxes": boxes, "labels": labels})
+    data["original_size"] = [(x["height"], x["width"]) for x in batch]
+    data["annotations"] = annotations
+    return data
+
+
+# prepare dataloader
+dataloader = DataLoader(val_data, batch_size=8, collate_fn=collate_fn)
+
+# prepare metric
+metric = MeanAveragePrecision(box_format="xyxy", class_metrics=True)
+
+# evaluation loop
+for i, batch in tqdm(enumerate(dataloader), total=len(dataloader)):
+    inputs = (
+        processor(batch["images"], return_tensors="pt").to("cuda").to(torch.float16)
+    )
+    with torch.no_grad():
+        outputs = model(**inputs)
+    target_sizes = torch.tensor([x for x in batch["original_size"]]).to("cuda")
+    results = processor.post_process_object_detection(
+        outputs, threshold=0.0, target_sizes=target_sizes
+    )
+
+    # convert predicted label id to dataset label id
+    if len(id2label_model) != len(id2label):
+        for result in results:
+            result["labels"] = torch.tensor(
+                [label2id.get(id2label_model[x.item()], 0) for x in result["labels"]]
+            )
+    # put results back to cpu
+    for result in results:
+        for k, v in result.items():
+            if isinstance(v, torch.Tensor):
+                result[k] = v.to("cpu")
+    metric.update(results, batch["annotations"])
+
+metrics = metric.compute()
+print(metrics)
+```

coco_detection_dataset_script.py

@@ -0,0 +1,325 @@
+import json
+import os
+
+import datasets
+
+
+class COCOBuilderConfig(datasets.BuilderConfig):
+    def __init__(self, name, splits, **kwargs):
+        super().__init__(name, **kwargs)
+        self.splits = splits
+
+
+# Add BibTeX citation
+# Find for instance the citation on arxiv or on the dataset repo/website
+_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}
+}
+"""
+
+# Add description of the dataset here
+# You can copy an official description
+_DESCRIPTION = """\
+COCO is a large-scale object detection, segmentation, and captioning dataset.
+"""
+
+# Add a link to an official homepage for the dataset here
+_HOMEPAGE = "http://cocodataset.org/#home"
+
+# Add the licence for the dataset here if you can find it
+_LICENSE = ""
+
+# Add link to the official dataset URLs here
+# The HuggingFace dataset library don't host the datasets but only point to the original files
+# This can be an arbitrary nested dict/list of URLs (see below in `_split_generators` method)
+
+# This script is supposed to work with local (downloaded) COCO dataset.
+_URLs = {}
+
+
+# Name of the dataset usually match the script name with CamelCase instead of snake_case
+class COCODataset(datasets.GeneratorBasedBuilder):
+    """An example dataset script to work with the local (downloaded) COCO dataset"""
+
+    VERSION = datasets.Version("0.0.0")
+
+    BUILDER_CONFIG_CLASS = COCOBuilderConfig
+    BUILDER_CONFIGS = [
+        COCOBuilderConfig(name="2017", splits=["train", "val"]),
+    ]
+    DEFAULT_CONFIG_NAME = "2017"
+
+    def _info(self):
+        # This method specifies the datasets.DatasetInfo object which contains informations and typings for the dataset
+
+        feature_dict = {
+            "id": datasets.Value("int64"),
+            "objects": {
+                "bbox_id": datasets.Sequence(datasets.Value("int64")),
+                "category_id": datasets.Sequence(
+                    datasets.ClassLabel(
+                        names=[
+                            "N/A",
+                            "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",
+                        ]
+                    )
+                ),
+                "bbox": datasets.Sequence(
+                    datasets.Sequence(datasets.Value("float64"), length=4)
+                ),
+                "iscrowd": datasets.Sequence(datasets.Value("int64")),
+                "area": datasets.Sequence(datasets.Value("float64")),
+            },
+            "height": datasets.Value("int64"),
+            "width": datasets.Value("int64"),
+            "file_name": datasets.Value("string"),
+            "coco_url": datasets.Value("string"),
+            "image_path": datasets.Value("string"),
+        }
+
+        features = datasets.Features(feature_dict)
+
+        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,  # Here we define them above because they are different between the two configurations
+            # If there's a common (input, target) tuple from the features,
+            # specify them here. They'll be used if as_supervised=True in
+            # builder.as_dataset.
+            supervised_keys=None,
+            # 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):
+        """Returns SplitGenerators."""
+        # 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
+
+        data_dir = self.config.data_dir
+        if not data_dir:
+            raise ValueError(
+                "This script is supposed to work with local (downloaded) COCO dataset. The argument `data_dir` in `load_dataset()` is required."
+            )
+
+        _DL_URLS = {
+            "train": os.path.join(data_dir, "train2017.zip"),
+            "val": os.path.join(data_dir, "val2017.zip"),
+            "annotations_trainval": os.path.join(
+                data_dir, "annotations_trainval2017.zip"
+            ),
+        }
+        archive_path = dl_manager.download_and_extract(_DL_URLS)
+
+        splits = []
+        for split in self.config.splits:
+            if split == "train":
+                dataset = datasets.SplitGenerator(
+                    name=datasets.Split.TRAIN,
+                    # These kwargs will be passed to _generate_examples
+                    gen_kwargs={
+                        "json_path": os.path.join(
+                            archive_path["annotations_trainval"],
+                            "annotations",
+                            "instances_train2017.json",
+                        ),
+                        "image_dir": os.path.join(archive_path["train"], "train2017"),
+                        "split": "train",
+                    },
+                )
+            elif split in ["val", "valid", "validation", "dev"]:
+                dataset = datasets.SplitGenerator(
+                    name=datasets.Split.VALIDATION,
+                    # These kwargs will be passed to _generate_examples
+                    gen_kwargs={
+                        "json_path": os.path.join(
+                            archive_path["annotations_trainval"],
+                            "annotations",
+                            "instances_val2017.json",
+                        ),
+                        "image_dir": os.path.join(archive_path["val"], "val2017"),
+                        "split": "valid",
+                    },
+                )
+            else:
+                continue
+
+            splits.append(dataset)
+
+        return splits
+
+    def _generate_examples(
+        # method parameters are unpacked from `gen_kwargs` as given in `_split_generators`
+        self,
+        json_path,
+        image_dir,
+        split,
+    ):
+        """Yields examples as (key, example) tuples."""
+        # This method handles input defined in _split_generators to yield (key, example) tuples from the dataset.
+        # The `key` is here for legacy reason (tfds) and is not important in itself.
+
+        features = [
+            "id",
+            "objects",
+            "height",
+            "width",
+            "file_name",
+            "coco_url",
+            "image_path",
+        ]
+        object_features = [
+            "bbox_id",
+            "category_id",
+            "bbox",
+            "iscrowd",
+            "area",
+        ]
+
+        with open(json_path, "r", encoding="UTF-8") as fp:
+            data = json.load(fp)
+
+        images = data["images"]
+        images_entry = {image["id"]: image for image in images}
+        for image_id, image_entry in images_entry.items():
+            image_entry["image_path"] = os.path.join(
+                image_dir, image_entry["file_name"]
+            )
+            image_entry["objects"] = []
+
+        objects = data["annotations"]
+        for id_, object_entry in enumerate(objects):
+            image_id = object_entry["image_id"]
+
+            entry = {k: v for k, v in object_entry.items() if k in object_features}
+            entry["bbox_id"] = object_entry["id"]
+            if entry["iscrowd"]:
+                continue
+            images_entry[image_id]["objects"].append(entry)
+
+        for id_, entry in images_entry.items():
+            entry = {k: v for k, v in entry.items() if k in features}
+            # collate objects
+            objects = entry.pop("objects")
+            if not objects:
+                continue
+            entry["objects"] = {
+                object_feature: [obj[object_feature] for obj in objects]
+                for object_feature in object_features
+            }
+
+            yield str(entry["id"]), entry