Add load_dataset support with coco/yolo/products configs

README.md

@@ -20,24 +20,94 @@ size_categories:
 
 Object detection dataset for Norwegian grocery store shelf images, from the NorgesGruppen Data competition.
 
+## Quick Start
+
+```python
+from datasets import load_dataset
+
+# COCO format (default) - raw competition annotations
+ds = load_dataset("valiantlynxz/norwegian-grocery", trust_remote_code=True)
+
+# YOLO format - auto-converted on load, no scripts needed
+ds = load_dataset("valiantlynxz/norwegian-grocery", name="yolo", trust_remote_code=True)
+
+# Product reference images - multi-angle shots per product
+ds = load_dataset("valiantlynxz/norwegian-grocery", name="products", trust_remote_code=True)
+```
+
+## Configurations
+
+| Config | Default | Description | Splits |
+|--------|---------|-------------|--------|
+| `coco` | Yes | Raw COCO annotations with full metadata | train, validation |
+| `yolo` | | YOLO normalized `[cx, cy, w, h]` (converted on-the-fly) | train, validation |
+| `products` | | Product reference images with metadata | train |
+
+### COCO Config
+
+Each example contains a shelf image and all its COCO-format annotations:
+
+```python
+ds = load_dataset("valiantlynxz/norwegian-grocery", trust_remote_code=True)
+example = ds["train"][0]
+
+example["image"]          # PIL Image
+example["image_id"]       # int
+example["width"]          # image width in pixels
+example["height"]         # image height in pixels
+example["annotations"]    # JSON string of COCO annotation list
+# Each annotation: {"id", "category_id", "bbox": [x, y, w, h], "area", "product_code", ...}
+```
+
+### YOLO Config
+
+Same images, but bounding boxes are auto-converted to YOLO normalized center format:
+
+```python
+ds = load_dataset("valiantlynxz/norwegian-grocery", name="yolo", trust_remote_code=True)
+example = ds["train"][0]
+
+example["image"]      # PIL Image
+example["image_id"]   # int
+example["labels"]     # [int, ...] - category IDs
+example["bboxes"]     # [[cx, cy, w, h], ...] - normalized to [0, 1]
+```
+
+### Products Config
+
+Reference images for 327 products, organized by product code:
+
+```python
+ds = load_dataset("valiantlynxz/norwegian-grocery", name="products", trust_remote_code=True)
+example = ds["train"][0]
+
+example["image"]            # PIL Image (one angle)
+example["product_code"]     # barcode string
+example["product_name"]     # e.g. "EVERGOOD CLASSIC KOKMALT 250G"
+example["image_type"]       # "main", "front", "back", "left", "right", "top", "bottom"
+example["annotation_count"] # how often this product appears in shelf images
+```
+
 ## Dataset Summary
 
-- **248 shelf images** from Norwegian grocery stores (4 sections: Egg, Frokost, Knekkebrod, Varmedrikker)
+- **248 shelf images** from Norwegian grocery stores (Egg, Frokost, Knekkebrod, Varmedrikker)
 - **22,731 bounding box annotations** in COCO format
 - **356 product categories** (IDs 0-355, where 355 = `unknown_product`)
-- **327 product reference images** with multi-angle photos (main, front, back, left, right, top, bottom)
+- **327 products** with multi-angle reference photos (1,582 images total)
+- Train/val split: 211 / 37 images (85/15, seed=42)
 
 ## Structure
 
 ```
+norwegian_grocery.py         # Custom loading script (auto-discovered by HF)
 train/
-  annotations.json       # COCO-format annotations
-  images/                # 248 shelf images (.jpg/.jpeg)
+  annotations.json           # COCO-format annotations
+  images/                    # 248 shelf images (.jpg/.jpeg)
 NM_NGD_product_images/
-  metadata.json          # Product names, barcodes, annotation counts
-  {barcode}/             # Product reference images per barcode
+  metadata.json              # Product names, barcodes, annotation counts
+  {barcode}/                 # Product reference images per barcode
 scripts/
-  coco_to_yolo.py        # Convert COCO to YOLO format with train/val split
+  coco_to_yolo.py            # Convert COCO to YOLO format with train/val split
 ```
 
 ## Annotation Format
@@ -61,9 +131,9 @@ COCO format (`annotations.json`):
 
 `bbox` is `[x, y, width, height]` in pixels (COCO format).
 
-## Converting to YOLO Format
+## For Local YOLO Training
 
-The included `scripts/coco_to_yolo.py` converts COCO annotations to YOLO format with an 85/15 train/val split:
+If you need on-disk YOLO files for `ultralytics`, the repo includes `scripts/coco_to_yolo.py`:
 
 ```bash
 python scripts/coco_to_yolo.py \
@@ -73,16 +143,10 @@ python scripts/coco_to_yolo.py \
     --val-ratio 0.15
 ```
 
-This creates:
-- `yolo/images/{train,val}/` - symlinked images
-- `yolo/labels/{train,val}/` - YOLO `.txt` label files
-- `yolo/category_names.json` - category ID to name mapping
-- `configs/dataset.yaml` - YOLOv8 dataset config (with absolute paths for your machine)
+This creates `yolo/images/{train,val}/`, `yolo/labels/{train,val}/`, and `configs/dataset.yaml`.
 
 ## Usage with the Detection Project in https://github.com/kuben-labs/nmai
 
-Clone this dataset into the detection project:
-
 ```bash
 cd detection/
 make data    # clones from HuggingFace

norwegian_grocery.py

@@ -0,0 +1,284 @@
+"""NorgesGruppen Grocery Detection Dataset — valiantlynxz/norwegian-grocery
+
+Custom loading script with three configs:
+    coco (default) — Raw COCO annotations + shelf images, train/val split
+    yolo           — On-the-fly COCO-to-YOLO conversion, normalized [cx, cy, w, h]
+    products       — Multi-angle product reference images with metadata
+
+Usage:
+    from datasets import load_dataset
+
+    ds = load_dataset("valiantlynxz/norwegian-grocery", trust_remote_code=True)
+    ds = load_dataset("valiantlynxz/norwegian-grocery", name="yolo", trust_remote_code=True)
+    ds = load_dataset("valiantlynxz/norwegian-grocery", name="products", trust_remote_code=True)
+"""
+
+import json
+import os
+import random
+
+import datasets
+
+
+_DESCRIPTION = (
+    "Object detection dataset for Norwegian grocery store shelf images. "
+    "248 shelf images with 22,731 bounding box annotations across 356 product categories, "
+    "plus 327 products with multi-angle reference photos."
+)
+
+_HOMEPAGE = "https://huggingface.co/datasets/valiantlynxz/norwegian-grocery"
+
+_LICENSE = "CC-BY-NC-4.0"
+
+_VAL_RATIO = 0.15
+_SPLIT_SEED = 42
+
+
+class NorwegianGroceryConfig(datasets.BuilderConfig):
+    """BuilderConfig for NorgesGruppen Grocery Detection."""
+
+    def __init__(self, format="coco", **kwargs):
+        super().__init__(**kwargs)
+        self.format = format
+
+
+class NorwegianGrocery(datasets.GeneratorBasedBuilder):
+    """NorgesGruppen grocery shelf detection dataset."""
+
+    VERSION = datasets.Version("1.0.0")
+
+    BUILDER_CONFIG_CLASS = NorwegianGroceryConfig
+
+    BUILDER_CONFIGS = [
+        NorwegianGroceryConfig(
+            name="coco",
+            version=VERSION,
+            description="Raw COCO-format annotations with full metadata",
+            format="coco",
+        ),
+        NorwegianGroceryConfig(
+            name="yolo",
+            version=VERSION,
+            description="YOLO format: normalized [cx, cy, w, h], converted on-the-fly",
+            format="yolo",
+        ),
+        NorwegianGroceryConfig(
+            name="products",
+            version=VERSION,
+            description="Product reference images with metadata",
+            format="products",
+        ),
+    ]
+
+    DEFAULT_CONFIG_NAME = "coco"
+
+    def _info(self):
+        if self.config.format == "coco":
+            features = datasets.Features(
+                {
+                    "image": datasets.Image(),
+                    "image_id": datasets.Value("int64"),
+                    "file_name": datasets.Value("string"),
+                    "width": datasets.Value("int32"),
+                    "height": datasets.Value("int32"),
+                    "annotations": datasets.Value("string"),
+                }
+            )
+        elif self.config.format == "yolo":
+            features = datasets.Features(
+                {
+                    "image": datasets.Image(),
+                    "image_id": datasets.Value("int64"),
+                    "file_name": datasets.Value("string"),
+                    "width": datasets.Value("int32"),
+                    "height": datasets.Value("int32"),
+                    "labels": datasets.Sequence(datasets.Value("int32")),
+                    "bboxes": datasets.Sequence(
+                        datasets.Sequence(datasets.Value("float32"), length=4)
+                    ),
+                }
+            )
+        else:  # products
+            features = datasets.Features(
+                {
+                    "image": datasets.Image(),
+                    "product_code": datasets.Value("string"),
+                    "product_name": datasets.Value("string"),
+                    "image_type": datasets.Value("string"),
+                    "annotation_count": datasets.Value("int32"),
+                }
+            )
+
+        return datasets.DatasetInfo(
+            description=_DESCRIPTION,
+            features=features,
+            homepage=_HOMEPAGE,
+            license=_LICENSE,
+        )
+
+    def _split_generators(self, dl_manager):
+        data_dir = os.path.dirname(os.path.abspath(__file__))
+
+        if self.config.format in ("coco", "yolo"):
+            ann_file = os.path.join(data_dir, "train", "annotations.json")
+            image_dir = os.path.join(data_dir, "train", "images")
+
+            # Compute train/val split (deterministic)
+            with open(ann_file) as f:
+                coco = json.load(f)
+            image_ids = sorted(img["id"] for img in coco["images"])
+            rng = random.Random(_SPLIT_SEED)
+            rng.shuffle(image_ids)
+            val_count = max(1, int(len(image_ids) * _VAL_RATIO))
+            val_ids = set(image_ids[:val_count])
+            train_ids = set(image_ids[val_count:])
+
+            return [
+                datasets.SplitGenerator(
+                    name=datasets.Split.TRAIN,
+                    gen_kwargs={
+                        "ann_file": ann_file,
+                        "image_dir": image_dir,
+                        "split_ids": train_ids,
+                    },
+                ),
+                datasets.SplitGenerator(
+                    name=datasets.Split.VALIDATION,
+                    gen_kwargs={
+                        "ann_file": ann_file,
+                        "image_dir": image_dir,
+                        "split_ids": val_ids,
+                    },
+                ),
+            ]
+        else:  # products
+            products_dir = os.path.join(data_dir, "NM_NGD_product_images")
+            metadata_file = os.path.join(products_dir, "metadata.json")
+            return [
+                datasets.SplitGenerator(
+                    name=datasets.Split.TRAIN,
+                    gen_kwargs={
+                        "products_dir": products_dir,
+                        "metadata_file": metadata_file,
+                    },
+                ),
+            ]
+
+    def _generate_examples(self, **kwargs):
+        if self.config.format in ("coco", "yolo"):
+            yield from self._generate_detection_examples(**kwargs)
+        else:
+            yield from self._generate_product_examples(**kwargs)
+
+    def _generate_detection_examples(self, ann_file, image_dir, split_ids):
+        """Generate examples for coco and yolo configs."""
+        with open(ann_file) as f:
+            coco = json.load(f)
+
+        id_to_img = {img["id"]: img for img in coco["images"]}
+
+        img_to_anns = {}
+        for ann in coco["annotations"]:
+            img_to_anns.setdefault(ann["image_id"], []).append(ann)
+
+        idx = 0
+        for img_id in sorted(split_ids):
+            img_info = id_to_img.get(img_id)
+            if img_info is None:
+                continue
+
+            file_name = img_info["file_name"]
+            img_path = os.path.join(image_dir, file_name)
+            if not os.path.exists(img_path):
+                continue
+
+            w = img_info["width"]
+            h = img_info["height"]
+            anns = img_to_anns.get(img_id, [])
+
+            if self.config.format == "coco":
+                yield (
+                    idx,
+                    {
+                        "image": img_path,
+                        "image_id": img_id,
+                        "file_name": file_name,
+                        "width": w,
+                        "height": h,
+                        "annotations": json.dumps(anns),
+                    },
+                )
+            else:  # yolo
+                labels = []
+                bboxes = []
+                for ann in anns:
+                    bbox = ann["bbox"]  # COCO: [x, y, w, h] top-left
+                    bw, bh = bbox[2], bbox[3]
+
+                    # Skip zero-area boxes
+                    if bw <= 0 or bh <= 0:
+                        continue
+
+                    # Convert to YOLO normalized center format
+                    cx = min(1.0, max(0.0, (bbox[0] + bw / 2) / w))
+                    cy = min(1.0, max(0.0, (bbox[1] + bh / 2) / h))
+                    nw = min(1.0, max(0.0, bw / w))
+                    nh = min(1.0, max(0.0, bh / h))
+
+                    # Skip degenerate boxes
+                    if nw <= 0 or nh <= 0:
+                        continue
+
+                    labels.append(ann["category_id"])
+                    bboxes.append([cx, cy, nw, nh])
+
+                yield (
+                    idx,
+                    {
+                        "image": img_path,
+                        "image_id": img_id,
+                        "file_name": file_name,
+                        "width": w,
+                        "height": h,
+                        "labels": labels,
+                        "bboxes": bboxes,
+                    },
+                )
+
+            idx += 1
+
+    def _generate_product_examples(self, products_dir, metadata_file):
+        """Generate examples for products config."""
+        with open(metadata_file) as f:
+            meta = json.load(f)
+
+        idx = 0
+        for product in meta["products"]:
+            if not product.get("has_images", False):
+                continue
+
+            product_code = product["product_code"]
+            product_name = product["product_name"]
+            annotation_count = product.get("annotation_count", 0)
+            product_dir = os.path.join(products_dir, product_code)
+
+            if not os.path.isdir(product_dir):
+                continue
+
+            for image_type in product.get("image_types", []):
+                # Try common extensions
+                for ext in (".jpg", ".jpeg", ".png"):
+                    img_path = os.path.join(product_dir, image_type + ext)
+                    if os.path.exists(img_path):
+                        yield (
+                            idx,
+                            {
+                                "image": img_path,
+                                "product_code": product_code,
+                                "product_name": product_name,
+                                "image_type": image_type,
+                                "annotation_count": annotation_count,
+                            },
+                        )
+                        idx += 1
+                        break