| --- |
| dataset_info: |
| features: |
| - name: image |
| dtype: image |
| - name: objects |
| struct: |
| - name: bbox |
| sequence: |
| sequence: float64 |
| - name: segmentation |
| sequence: |
| sequence: |
| sequence: float64 |
| - name: categories |
| sequence: int64 |
| splits: |
| - name: train |
| num_bytes: 17598458856.47 |
| num_examples: 117266 |
| - name: validation |
| num_bytes: 795110726.04 |
| num_examples: 4952 |
| download_size: 20170024873 |
| dataset_size: 18393569582.510002 |
| configs: |
| - config_name: default |
| data_files: |
| - split: train |
| path: data/train-* |
| - split: validation |
| path: data/validation-* |
| task_categories: |
| - object-detection |
| --- |
| |
| # MS-COCO2017 |
|
|
| ## Use the dataset |
|
|
| ```py |
| from random import randint |
| from datasets import load_dataset |
| from PIL import Image, ImageDraw, ImageFont |
| |
| ds = load_dataset("ariG23498/coco2017", streaming=True, split="validation") |
| |
| sample = next(iter(ds)) |
| |
| |
| def draw_bboxes_on_image( |
| image: Image.Image, |
| objects: dict, |
| category_names: dict = None, |
| box_color: str = "red", |
| text_color: str = "white" |
| ) -> Image.Image: |
| image_copy = image.copy() |
| draw = ImageDraw.Draw(image_copy) |
| font = ImageFont.load_default() |
| |
| bboxes = objects.get("bbox", []) |
| categories = objects.get("categories", []) |
| |
| for bbox, category_id in zip(bboxes, categories): |
| x, y, width, height = bbox |
| x_min, y_min = x, y |
| x_max, y_max = x + width, y + height |
| |
| # Draw bounding box |
| draw.rectangle([x_min, y_min, x_max, y_max], outline=box_color, width=2) |
| |
| # Prepare label |
| label = category_names.get(category_id, str(category_id)) if category_names else str(category_id) |
| text_bbox = draw.textbbox((0, 0), label, font=font) |
| text_width = text_bbox[2] - text_bbox[0] |
| text_height = text_bbox[3] - text_bbox[1] |
| label_top = max(y_min - text_height - 4, 0) |
| |
| # Draw label background and text |
| draw.rectangle( |
| [x_min, label_top, x_min + text_width + 4, label_top + text_height + 2], |
| fill=box_color |
| ) |
| draw.text((x_min + 2, label_top + 1), label, fill=text_color, font=font) |
| |
| return image_copy |
| |
| |
| |
| def draw_segmaps_on_image( |
| image: Image.Image, |
| objects: dict, |
| category_names: dict = None, |
| alpha: float = 0.4, |
| text_color: str = "white" |
| ) -> Image.Image: |
| base_image = image.convert("RGBA").copy() |
| overlay = Image.new("RGBA", base_image.size, (255, 255, 255, 0)) |
| draw = ImageDraw.Draw(overlay) |
| font = ImageFont.load_default() |
| |
| segmentations = objects.get("segmentation", []) |
| categories = objects.get("categories", []) |
| |
| for segmentation, category_id in zip(segmentations, categories): |
| polygons = segmentation if isinstance(segmentation[0], list) else [segmentation] |
| label = category_names.get(category_id, str(category_id)) if category_names else str(category_id) |
| |
| for polygon in polygons: |
| if len(polygon) >= 6: |
| points = [(polygon[i], polygon[i + 1]) for i in range(0, len(polygon), 2)] |
| |
| # Draw filled polygon |
| segmap_color = (randint(125, 255), randint(0, 125), randint(0, 255)) |
| rgba_fill = (*segmap_color, int(255 * alpha)) |
| draw.polygon(points, fill=rgba_fill) |
| |
| # Draw label at first vertex |
| x0, y0 = points[0] |
| draw.text((x0 + 2, y0 + 2), label, fill=text_color, font=font) |
| |
| return Image.alpha_composite(base_image, overlay).convert("RGB") |
| |
| # For Bounding Boxes |
| od_image = draw_bboxes_on_image( |
| image=sample["image"], |
| objects=sample["objects"], |
| ) |
| |
| # For Segmentation Maps |
| segmap_image = draw_segmaps_on_image( |
| image=sample["image"], |
| objects=sample["objects"] |
| ) |
| ``` |
|
|
| ## Get the categories |
|
|
| ```py |
| import json |
| |
| with open("/content/annotations/instances_train2017.json") as f: |
| instances = json.load(f) |
| |
| instances["categories"] |
| ``` |
|
|
| ## Build the dataset and upload to Hub |
|
|
| ```py |
| !pip install -U -q datasets |
| |
| # Download and unzip COCO 2017 |
| !wget -q http://images.cocodataset.org/zips/train2017.zip |
| !wget -q http://images.cocodataset.org/zips/val2017.zip |
| !wget -q http://images.cocodataset.org/annotations/annotations_trainval2017.zip |
| |
| !unzip -q train2017.zip |
| !unzip -q val2017.zip |
| !unzip -q annotations_trainval2017.zip |
| |
| import json |
| import shutil |
| from pathlib import Path |
| from tqdm import tqdm |
| from datasets import load_dataset |
| |
| base_dir = Path("/content") |
| splits = { |
| "train": { |
| "image_dir": base_dir / "train2017", |
| "annotation_file": base_dir / "annotations" / "instances_train2017.json", |
| }, |
| "val": { |
| "image_dir": base_dir / "val2017", |
| "annotation_file": base_dir / "annotations" / "instances_val2017.json", |
| } |
| } |
| output_dir = base_dir / "coco_imagefolder" |
| output_dir.mkdir(parents=True, exist_ok=True) |
| |
| def normalize_segmentation(segmentation): |
| if isinstance(segmentation, list): |
| if all(isinstance(poly, list) for poly in segmentation): |
| return segmentation # already a list of polygons |
| elif all(isinstance(pt, (int, float)) for pt in segmentation): |
| return [segmentation] # wrap single polygon |
| return [] # skip RLE or malformed segmentations |
| |
| def convert_coco_to_jsonl(image_dir, annotation_path, output_metadata_path): |
| with open(annotation_path) as f: |
| data = json.load(f) |
| |
| id_to_filename = {img['id']: img['file_name'] for img in data['images']} |
| annotations_by_image = {} |
| |
| for ann in data['annotations']: |
| img_id = ann['image_id'] |
| bbox = ann['bbox'] |
| category = ann['category_id'] |
| segmentation = normalize_segmentation(ann['segmentation']) |
| |
| if not segmentation: |
| continue # skip if malformed or RLE |
| |
| if img_id not in annotations_by_image: |
| annotations_by_image[img_id] = { |
| "file_name": id_to_filename[img_id], |
| "objects": { |
| "bbox": [], |
| "segmentation": [], |
| "categories": [], |
| } |
| } |
| |
| annotations_by_image[img_id]["objects"]["bbox"].append(bbox) |
| annotations_by_image[img_id]["objects"]["segmentation"].append(segmentation) |
| annotations_by_image[img_id]["objects"]["categories"].append(category) |
| |
| with open(output_metadata_path, "w") as f: |
| for metadata in annotations_by_image.values(): |
| json.dump(metadata, f) |
| f.write("\n") |
| |
| # Build imagefolder structure |
| for split, info in splits.items(): |
| split_dir = output_dir / split |
| split_dir.mkdir(parents=True, exist_ok=True) |
| |
| # Copy images |
| for img_path in tqdm(info["image_dir"].glob("*.jpg"), desc=f"Copying {split} images"): |
| shutil.copy(img_path, split_dir / img_path.name) |
| |
| # Write JSONL metadata |
| metadata_path = split_dir / "metadata.jsonl" |
| convert_coco_to_jsonl(split_dir, info["annotation_file"], metadata_path) |
| |
| # Load and push |
| dataset = load_dataset("imagefolder", data_dir=str(output_dir)) |
| dataset.push_to_hub("ariG23498/coco2017") |
| ``` |
