|
|
--- |
|
|
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") |
|
|
``` |
