v2: add new sources, extraction pipeline, better train/val split

- Added Sebring Q Tobi Lap 6 and Paul Ricard Alpine LMPh video sources
- Proper stratified 85/15 train/val split (was nearly empty val before)
- Augmented minority racing classes (gears 4, 7) to 200 samples
- 5,964 train / 1,003 val images (up from 5,321 / 318)
- Added scripts/extract.py and scripts/build_dataset.py for pipeline
- Added scripts/find_label_issues.py (cleanlab-based QA)
- Added examples/ with reference crops per gear per source
- Added labels/ CSVs for frame-range labeling
- Added AGENTS.md with domain context and crop coordinates

.gitignore

@@ -0,0 +1,5 @@
+raw/
+composites/
+__pycache__/
+*.pyc
+.venv/

.python-version

@@ -0,0 +1 @@
+3.12

AGENTS.md

@@ -0,0 +1,25 @@
+# Agent Context: Racing Gear Digits Dataset
+
+## Domain knowledge
+
+- A **lap** in circuit racing takes ~1.5–2.5 minutes depending on track length. During a single lap the driver uses every gear at least once (except reverse/neutral).
+- So any ~2 minute window of onboard footage guarantees examples of **all forward gears** (typically 1–6 or 1–7 depending on car).
+- **Gear changes are not uniform** — the car spends much more time in mid-range gears (2, 3, 4) than in 1st or top gear. Low gears appear briefly during braking zones; top gear only on long straights.
+- The **gear indicator** is part of the telemetry overlay baked into the video. Its position, font, size, and background vary per video source. Each source needs its own crop coordinates.
+- Gears **0, 8, 9** don't occur in normal racing — 0 is neutral (rare), 8+ don't exist on these cars. We include them via MNIST for classifier completeness.
+
+## Video sources
+
+Each video source has different crop coordinates for the gear digit:
+
+| Video | Resolution | Gear crop (x, y, w, h) | Gears | Notes |
+|-------|-----------|------------------------|-------|-------|
+| Sebring Q Tobi Lap 6 | 1920×1080 | (1440, 780, 90, 105) | 1–6 | White digit on dark semi-transparent overlay |
+| Paul Ricard Alpine LMPh | 832×464 | (685, 320, 55, 55) | 1–7 | White digit on dark circle |
+
+## Working with the data
+
+- Use `uv run` for all Python scripts (dependencies managed via pyproject.toml)
+- Extraction scripts live in `scripts/`, reference examples live in `examples/`
+- The dataset parquet files are in `data/` and tracked with Git LFS
+- Source column values: `racing` (real crops), `racing_aug` (augmented), `mnist` (handwritten)

README.md

@@ -29,33 +29,67 @@ Similar in spirit to MNIST but for a specific real-world application: reading th
 
 ## Dataset
 
-- **5,321 training** / **318 validation** images
+- **5,964 training** / **1,003 validation** images
 - **32×32 grayscale** PNG images
 - **10 classes** (digits 0-9)
-- **Source column** distinguishes `racing` (real video crops) from `mnist` (handwritten digits)
+- **Source column** distinguishes `racing-original`, `paul-ricard-alpine`, `sebring-tobi-lap6`, `racing_aug` (augmented), and `mnist`
+- **Proper stratified split** — 15% of each racing source held out for validation
+- **Augmented minority classes** — racing digits with <200 training samples augmented via random shifts, brightness/contrast jitter, and Gaussian noise
 
 ### Racing sources
 
 | Source | Gears | Style |
 |--------|-------|-------|
-| TDS Racing IMSA Sebring 2026 | 1-6 | White digit on gray RPM gauge face (inverted) |
-| Alpine LMPh Paul Ricard | 1-7 | White digit on dark circle |
+| TDS Racing IMSA Sebring 2026 (original) | 1-6 | White digit on gray RPM gauge face |
+| Sebring Q Tobi Lap 6 | 1-6 | White digit on dark semi-transparent overlay |
+| Paul Ricard Alpine LMPh | 1-7 | White digit on dark circle |
 | MNIST supplement | 0-9 | Handwritten digits (generalization) |
 
-### Distribution
-
-| Digit | Train (racing) | Train (mnist) | Total |
-|-------|---------------|---------------|-------|
-| 0 | 0 | 200 | 200 |
-| 1 | 1,013 | 200 | 1,213 |
-| 2 | 1,576 | 200 | 1,776 |
-| 3 | 423 | 200 | 623 |
-| 4 | 42 | 200 | 242 |
-| 5 | 123 | 200 | 323 |
-| 6 | 122 | 200 | 322 |
-| 7 | 22 | 200 | 222 |
-| 8 | 0 | 200 | 200 |
-| 9 | 0 | 200 | 200 |
+### Train distribution
+
+| Digit | Racing (orig) | Sebring | Paul Ricard | Aug | MNIST | Total |
+|-------|--------------|---------|-------------|-----|-------|-------|
+| 0 | 0 | 0 | 0 | 0 | 196 | 196 |
+| 1 | 864 | 36 | 35 | 0 | 196 | 1,167 |
+| 2 | 1,344 | 74 | 105 | 0 | 196 | 1,719 |
+| 3 | 364 | 99 | 162 | 0 | 196 | 821 |
+| 4 | 37 | 68 | 4 | 91 | 196 | 396 |
+| 5 | 107 | 138 | 49 | 0 | 196 | 490 |
+| 6 | 106 | 79 | 35 | 0 | 196 | 416 |
+| 7 | 19 | 0 | 45 | 137 | 196 | 397 |
+| 8 | 0 | 0 | 0 | 0 | 196 | 196 |
+| 9 | 0 | 0 | 0 | 0 | 196 | 196 |
+
+## Adding new video sources
+
+1. **Extract** gear crops from a video:
+   ```bash
+   uv run python scripts/extract.py <video_path> <source_name> <x> <y> <w> <h>
+   ```
+   This creates `raw/<source>/unlabeled/` frames and a `composites/<source>/unlabeled.png` contact sheet.
+
+2. **Label** by reading the contact sheet and creating `labels/<source>.csv`:
+   ```csv
+   start,end,label
+   0,14,5
+   15,39,6
+   ```
+   Each row maps a frame range (inclusive, 0-indexed) to a gear digit.
+
+3. **Build** the dataset:
+   ```bash
+   uv run python scripts/build_dataset.py
+   ```
+   This reads all `raw/` sources and `labels/` CSVs, does stratified train/val splitting, augments minority classes, and writes the parquet files.
+
+## Augmentations (racing_aug)
+
+For racing classes with fewer than 200 training samples, synthetic samples are generated:
+
+- **Random translation** — up to ±3px shift in x/y
+- **Brightness jitter** — 0.7–1.3×
+- **Contrast jitter** — 0.8–1.2×
+- **Gaussian noise** — σ=8, 30% probability
 
 ## Usage
 
@@ -64,14 +98,14 @@ from datasets import load_dataset
 
 ds = load_dataset("tobil/racing-gears")
 
-# Filter to racing images only
-racing = ds["train"].filter(lambda x: x["source"] == "racing")
+# Filter to real racing images only
+racing = ds["train"].filter(lambda x: x["source"] not in ("mnist", "racing_aug"))
 
 # Standard training loop
 for example in ds["train"]:
     image = example["image"]   # PIL Image, 32x32 grayscale
     label = example["label"]   # int 0-9
-    source = example["source"] # "racing" or "mnist"
+    source = example["source"] # source identifier
 ```
 
 ## Context

data/train-00000-of-00001.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:6cdd3fec9dc3f3084be12e265e2a3f0348daae69d6a8df901fa72374e7b795d1
-size 2662017
+oid sha256:d26003e895be7179eb7ba79bf52be3a9f61002aea06edff5cdbb1477fc126deb
+size 3069846

data/validation-00000-of-00001.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:5a332266d74a858d671499dedca9a3fc2144dbb690c4f66b941a9ad96e646192
-size 137289
+oid sha256:fff1985132a5327726db322612af37ee21bd0de1913ef4f22ab44e093b12bb9e
+size 508839

labels/paul-ricard-alpine.csv

@@ -0,0 +1,58 @@
+start,end,label
+0,2,3
+3,12,5
+13,39,6
+40,43,6
+44,47,6
+48,79,3
+80,84,3
+85,87,3
+88,97,5
+98,101,5
+102,104,4
+105,117,3
+118,127,3
+128,137,2
+138,139,2
+140,158,2
+159,166,2
+167,175,2
+176,181,2
+182,189,2
+190,199,3
+200,210,3
+211,220,5
+221,237,5
+238,242,5
+243,246,6
+247,258,7
+259,278,7
+279,296,7
+297,298,7
+299,301,6
+302,303,5
+304,305,4
+306,319,3
+320,334,3
+335,337,3
+338,345,1
+346,355,1
+356,359,1
+360,365,1
+366,367,1
+368,371,1
+372,374,2
+375,379,3
+380,399,3
+400,413,3
+414,419,2
+420,425,2
+426,437,2
+438,459,2
+460,465,2
+466,469,1
+470,471,1
+472,479,2
+480,499,3
+500,509,3
+510,513,3

labels/sebring-tobi-lap6.csv

@@ -0,0 +1,71 @@
+start,end,label
+0,17,5
+18,38,6
+39,39,5
+40,54,5
+55,59,5
+60,75,5
+76,79,5
+80,81,4
+82,83,3
+84,118,3
+119,123,3
+124,132,3
+133,139,4
+140,143,4
+144,147,5
+148,163,5
+164,175,6
+176,183,6
+184,187,5
+188,190,4
+191,193,3
+194,198,2
+199,207,2
+208,213,1
+214,237,1
+238,245,1
+246,252,2
+253,269,2
+270,279,2
+280,289,3
+290,299,3
+300,303,3
+304,308,4
+309,318,4
+319,324,4
+325,327,4
+328,332,4
+333,337,3
+338,341,2
+342,349,2
+350,354,2
+355,359,2
+360,369,4
+370,376,4
+377,381,4
+382,385,3
+386,393,2
+394,399,2
+400,406,2
+407,413,2
+414,419,3
+420,439,3
+440,445,3
+446,449,4
+450,458,4
+459,465,5
+466,479,5
+480,489,5
+490,497,5
+498,505,6
+506,519,6
+520,525,6
+526,531,6
+532,537,5
+538,543,5
+544,551,5
+552,559,5
+560,565,5
+566,575,6
+576,587,6

pyproject.toml

@@ -0,0 +1,16 @@
+[project]
+name = "2026-03-30-datasets-tobil"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "cleanlab>=2.9.0",
+    "datasets>=4.8.4",
+    "pandas>=3.0.1",
+    "pillow>=12.1.1",
+    "pyarrow>=23.0.1",
+    "scikit-learn>=1.8.0",
+    "torch>=2.11.0",
+    "torchvision>=0.26.0",
+]

scripts/build_dataset.py

@@ -0,0 +1,254 @@
+"""Build the racing-gears dataset parquet files from raw/ images and labels.
+
+Reads:
+    raw/<source>/<label>/*.png        - pre-sorted images (racing-original, mnist)
+    raw/<source>/unlabeled/*.png      - extracted frames needing labels
+    labels/<source>.csv               - frame range labels (start,end,label)
+
+Writes:
+    data/train-00000-of-00001.parquet
+    data/validation-00000-of-00001.parquet
+    composites/<source>/label_<N>.png - per-label composites for verification
+
+Usage:
+    uv run python scripts/build_dataset.py [--val-frac 0.15] [--aug-target 200] [--no-mnist]
+"""
+
+import argparse
+import csv
+import io
+import os
+import random
+
+import numpy as np
+import pandas as pd
+from PIL import Image, ImageEnhance
+
+
+random.seed(42)
+np.random.seed(42)
+
+TARGET_SIZE = (32, 32)
+
+
+def img_to_bytes(img: Image.Image) -> bytes:
+    buf = io.BytesIO()
+    img.save(buf, format="PNG")
+    return buf.getvalue()
+
+
+def load_labeled_dir(source_dir: str, source_name: str) -> list[dict]:
+    """Load images from raw/<source>/<label>/ directory structure."""
+    rows = []
+    for label_dir in sorted(os.listdir(source_dir)):
+        label_path = os.path.join(source_dir, label_dir)
+        if not os.path.isdir(label_path) or label_dir == "unlabeled":
+            continue
+        try:
+            label = int(label_dir)
+        except ValueError:
+            continue
+        for f in sorted(os.listdir(label_path)):
+            if not f.endswith(".png"):
+                continue
+            img = Image.open(os.path.join(label_path, f)).convert("L").resize(TARGET_SIZE)
+            rows.append({
+                "image": {"bytes": img_to_bytes(img), "path": None},
+                "label": label,
+                "source": source_name,
+            })
+    return rows
+
+
+def load_from_labels_csv(source_name: str) -> list[dict]:
+    """Load unlabeled frames and apply labels from CSV."""
+    csv_path = f"labels/{source_name}.csv"
+    frames_dir = f"raw/{source_name}/unlabeled"
+
+    if not os.path.exists(csv_path) or not os.path.exists(frames_dir):
+        return []
+
+    # Read label ranges
+    ranges = []
+    with open(csv_path) as f:
+        reader = csv.DictReader(f)
+        for row in reader:
+            ranges.append((int(row["start"]), int(row["end"]), int(row["label"])))
+
+    # Map frame index to label
+    frame_labels = {}
+    for start, end, label in ranges:
+        for i in range(start, end + 1):
+            frame_labels[i] = label
+
+    # Load frames
+    frames = sorted(f for f in os.listdir(frames_dir) if f.endswith(".png"))
+    rows = []
+    skipped = 0
+    for idx, f in enumerate(frames):
+        if idx not in frame_labels:
+            skipped += 1
+            continue
+        img = Image.open(os.path.join(frames_dir, f)).convert("L").resize(TARGET_SIZE)
+        rows.append({
+            "image": {"bytes": img_to_bytes(img), "path": None},
+            "label": frame_labels[idx],
+            "source": source_name,
+        })
+
+    if skipped:
+        print(f"  Warning: {skipped} frames in {source_name} had no label (skipped)")
+    return rows
+
+
+def augment(img: Image.Image) -> Image.Image:
+    """Random augmentation: shift, brightness, contrast, noise."""
+    dx, dy = random.randint(-3, 3), random.randint(-3, 3)
+    img = img.transform(img.size, Image.AFFINE, (1, 0, dx, 0, 1, dy), fillcolor=0)
+    img = ImageEnhance.Brightness(img).enhance(random.uniform(0.7, 1.3))
+    img = ImageEnhance.Contrast(img).enhance(random.uniform(0.8, 1.2))
+    if random.random() < 0.3:
+        arr = np.array(img, dtype=np.float32)
+        arr += np.random.normal(0, 8, arr.shape)
+        arr = np.clip(arr, 0, 255).astype(np.uint8)
+        img = Image.fromarray(arr, mode="L")
+    return img
+
+
+def make_composite(images: list[Image.Image], output_path: str, cell: int = 36, max_cols: int = 50):
+    if not images:
+        return
+    cols = min(max_cols, len(images))
+    rows = (len(images) + cols - 1) // cols
+    sheet = Image.new("L", (cols * cell, rows * cell), 0)
+    for idx, img in enumerate(images):
+        r, c = idx // cols, idx % cols
+        sheet.paste(img.resize((cell, cell)), (c * cell, r * cell))
+    sheet.save(output_path)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Build racing-gears dataset")
+    parser.add_argument("--val-frac", type=float, default=0.15, help="Validation fraction (default: 0.15)")
+    parser.add_argument("--aug-target", type=int, default=200, help="Min racing samples per class after augmentation (default: 200)")
+    parser.add_argument("--no-mnist", action="store_true", help="Exclude MNIST data")
+    args = parser.parse_args()
+
+    all_rows = []
+
+    # 1. Load pre-sorted sources (racing-original, mnist)
+    for source_dir in sorted(os.listdir("raw")):
+        source_path = os.path.join("raw", source_dir)
+        if not os.path.isdir(source_path):
+            continue
+
+        # Check if this source has a labels CSV (unlabeled frames)
+        csv_rows = load_from_labels_csv(source_dir)
+        if csv_rows:
+            print(f"Loaded {len(csv_rows)} labeled frames from {source_dir}")
+            all_rows.extend(csv_rows)
+
+        # Check if this source has pre-sorted label dirs
+        if source_dir == "mnist" and args.no_mnist:
+            print(f"Skipping {source_dir} (--no-mnist)")
+            continue
+        dir_rows = load_labeled_dir(source_path, source_dir)
+        if dir_rows:
+            print(f"Loaded {len(dir_rows)} pre-sorted images from {source_dir}")
+            all_rows.extend(dir_rows)
+
+    df = pd.DataFrame(all_rows)
+    print(f"\nTotal: {len(df)} images")
+    print(pd.crosstab(df["label"], df["source"]))
+
+    # 2. Separate racing vs mnist
+    racing_sources = [s for s in df["source"].unique() if s != "mnist"]
+    racing = df[df["source"].isin(racing_sources)].copy()
+    mnist = df[df["source"] == "mnist"].copy()
+
+    # 3. Stratified train/val split for racing
+    racing_train_parts, racing_val_parts = [], []
+    for label in sorted(racing["label"].unique()):
+        group = racing[racing["label"] == label].sample(frac=1, random_state=42)
+        n_val = max(1, int(len(group) * args.val_frac))
+        racing_val_parts.append(group.iloc[:n_val])
+        racing_train_parts.append(group.iloc[n_val:])
+
+    racing_train = pd.concat(racing_train_parts, ignore_index=True) if racing_train_parts else pd.DataFrame()
+    racing_val = pd.concat(racing_val_parts, ignore_index=True) if racing_val_parts else pd.DataFrame()
+
+    # 4. Augment underrepresented racing classes
+    aug_rows = []
+    for label in sorted(racing_train["label"].unique()):
+        group = racing_train[racing_train["label"] == label]
+        n_have = len(group)
+        n_need = max(0, args.aug_target - n_have)
+        if n_need > 0:
+            print(f"  Augmenting label {label}: {n_have} -> {n_have + n_need} (+{n_need})")
+            source_rows = group.to_dict("records")
+            for _ in range(n_need):
+                row = random.choice(source_rows)
+                orig_img = Image.open(io.BytesIO(row["image"]["bytes"])).convert("L")
+                aug_img = augment(orig_img)
+                aug_rows.append({
+                    "image": {"bytes": img_to_bytes(aug_img), "path": None},
+                    "label": label,
+                    "source": "racing_aug",
+                })
+
+    if aug_rows:
+        racing_train = pd.concat([racing_train, pd.DataFrame(aug_rows)], ignore_index=True)
+
+    # 5. Stratified split for MNIST
+    if not mnist.empty:
+        mnist_train_parts, mnist_val_parts = [], []
+        for label in sorted(mnist["label"].unique()):
+            group = mnist[mnist["label"] == label].sample(frac=1, random_state=42)
+            n_val = max(5, int(len(group) * args.val_frac))
+            mnist_val_parts.append(group.iloc[:n_val])
+            mnist_train_parts.append(group.iloc[n_val:])
+        mnist_train = pd.concat(mnist_train_parts, ignore_index=True)
+        mnist_val = pd.concat(mnist_val_parts, ignore_index=True)
+    else:
+        mnist_train = pd.DataFrame()
+        mnist_val = pd.DataFrame()
+
+    # 6. Combine and shuffle
+    train_parts = [p for p in [racing_train, mnist_train] if not p.empty]
+    val_parts = [p for p in [racing_val, mnist_val] if not p.empty]
+    new_train = pd.concat(train_parts, ignore_index=True).sample(frac=1, random_state=42).reset_index(drop=True)
+    new_val = pd.concat(val_parts, ignore_index=True).sample(frac=1, random_state=42).reset_index(drop=True)
+
+    print(f"\n=== Final dataset ===")
+    print(f"Train: {len(new_train)}, Val: {len(new_val)}")
+    print("\nTrain:")
+    print(pd.crosstab(new_train["label"], new_train["source"]))
+    print("\nVal:")
+    print(pd.crosstab(new_val["label"], new_val["source"]))
+
+    # 7. Write parquet
+    os.makedirs("data", exist_ok=True)
+    new_train.to_parquet("data/train-00000-of-00001.parquet", index=False)
+    new_val.to_parquet("data/validation-00000-of-00001.parquet", index=False)
+    print(f"\nWritten to data/")
+
+    # 8. Generate per-label composites for verification
+    for split_name, split_df in [("train", new_train), ("val", new_val)]:
+        for source in sorted(split_df["source"].unique()):
+            if source == "racing_aug":
+                continue
+            comp_dir = f"composites/{source}"
+            os.makedirs(comp_dir, exist_ok=True)
+            for label in sorted(split_df["label"].unique()):
+                subset = split_df[(split_df["source"] == source) & (split_df["label"] == label)]
+                if subset.empty:
+                    continue
+                images = [
+                    Image.open(io.BytesIO(row["image"]["bytes"])).convert("L")
+                    for _, row in subset.iterrows()
+                ]
+                make_composite(images, f"{comp_dir}/{split_name}_label_{label}.png")
+
+
+if __name__ == "__main__":
+    main()

scripts/extract.py

@@ -0,0 +1,73 @@
+"""Extract gear digit crops from a racing video.
+
+Usage:
+    uv run python scripts/extract.py <video_path> <source_name> <x> <y> <w> <h> [--fps 5]
+
+Example:
+    uv run python scripts/extract.py /path/to/video.mp4 sebring-tobi-lap6 1440 780 90 105
+    uv run python scripts/extract.py /path/to/video.mp4 paul-ricard-alpine 685 320 55 55
+
+Outputs:
+    raw/<source_name>/unlabeled/frame_XXXXX.png  - individual crops
+    composites/<source_name>/unlabeled.png        - contact sheet for labeling
+"""
+
+import argparse
+import os
+import subprocess
+import sys
+from PIL import Image
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Extract gear crops from racing video")
+    parser.add_argument("video", help="Path to video file")
+    parser.add_argument("source", help="Source name (e.g. sebring-tobi-lap6)")
+    parser.add_argument("x", type=int, help="Crop X offset")
+    parser.add_argument("y", type=int, help="Crop Y offset")
+    parser.add_argument("w", type=int, help="Crop width")
+    parser.add_argument("h", type=int, help="Crop height")
+    parser.add_argument("--fps", type=int, default=5, help="Extraction frame rate (default: 5)")
+    args = parser.parse_args()
+
+    out_dir = f"raw/{args.source}/unlabeled"
+    comp_dir = f"composites/{args.source}"
+    os.makedirs(out_dir, exist_ok=True)
+    os.makedirs(comp_dir, exist_ok=True)
+
+    # Extract with ffmpeg
+    print(f"Extracting from {args.video}")
+    print(f"  Crop: ({args.x}, {args.y}, {args.w}×{args.h}) at {args.fps}fps")
+    cmd = [
+        "ffmpeg", "-y",
+        "-i", args.video,
+        "-vf", f"crop={args.w}:{args.h}:{args.x}:{args.y}",
+        "-r", str(args.fps),
+        f"{out_dir}/frame_%05d.png",
+    ]
+    subprocess.run(cmd, capture_output=True)
+
+    # Build composite contact sheet
+    frames = sorted(f for f in os.listdir(out_dir) if f.endswith(".png"))
+    print(f"  Extracted {len(frames)} frames")
+
+    cols = 40
+    cell = 40
+    rows = (len(frames) + cols - 1) // cols
+    sheet = Image.new("L", (cols * cell, rows * cell), 0)
+    for idx, f in enumerate(frames):
+        img = Image.open(os.path.join(out_dir, f)).convert("L").resize((cell, cell))
+        r, c = idx // cols, idx % cols
+        sheet.paste(img, (c * cell, r * cell))
+    
+    comp_path = f"{comp_dir}/unlabeled.png"
+    sheet.save(comp_path)
+    print(f"  Composite: {comp_path} ({cols}×{rows})")
+    print()
+    print(f"Next: create labels/{args.source}.csv with columns: start,end,label")
+    print(f"  Each row is a frame range (0-indexed) and its gear digit.")
+    print(f"  Then run: uv run python scripts/build_dataset.py")
+
+
+if __name__ == "__main__":
+    main()

scripts/find_label_issues.py

@@ -0,0 +1,161 @@
+"""Find mislabeled samples using Cleanlab + a small CNN.
+
+1. Train a simple CNN on the dataset with cross-validation
+2. Get out-of-fold predicted probabilities
+3. Run Cleanlab to find label issues, outliers, duplicates
+
+Usage:
+    uv run python scripts/find_label_issues.py
+"""
+
+import io
+import numpy as np
+import pandas as pd
+from PIL import Image
+from sklearn.model_selection import StratifiedKFold
+
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.data import DataLoader, TensorDataset
+
+
+# --- 1. Load data ---
+print("Loading data...")
+df = pd.read_parquet("data/train-00000-of-00001.parquet")
+
+images = []
+for _, row in df.iterrows():
+    img = Image.open(io.BytesIO(row["image"]["bytes"])).convert("L")
+    arr = np.array(img, dtype=np.float32) / 255.0
+    images.append(arr)
+
+X = np.stack(images)[:, np.newaxis, :, :]  # (N, 1, 32, 32)
+y = df["label"].values
+sources = df["source"].values
+print(f"Loaded {len(X)} images, {len(np.unique(y))} classes")
+
+
+# --- 2. Simple CNN ---
+class SmallCNN(nn.Module):
+    def __init__(self, num_classes=10):
+        super().__init__()
+        self.features = nn.Sequential(
+            nn.Conv2d(1, 32, 3, padding=1), nn.ReLU(), nn.MaxPool2d(2),
+            nn.Conv2d(32, 64, 3, padding=1), nn.ReLU(), nn.MaxPool2d(2),
+            nn.Conv2d(64, 64, 3, padding=1), nn.ReLU(), nn.AdaptiveAvgPool2d(4),
+        )
+        self.classifier = nn.Sequential(
+            nn.Flatten(),
+            nn.Linear(64 * 4 * 4, 128), nn.ReLU(), nn.Dropout(0.3),
+            nn.Linear(128, num_classes),
+        )
+
+    def forward(self, x):
+        return self.classifier(self.features(x))
+
+
+def train_and_predict(X_train, y_train, X_val, epochs=15, batch_size=64):
+    device = torch.device("mps" if torch.backends.mps.is_available() else "cpu")
+    model = SmallCNN().to(device)
+    optimizer = optim.Adam(model.parameters(), lr=1e-3)
+    criterion = nn.CrossEntropyLoss()
+
+    train_ds = TensorDataset(torch.tensor(X_train), torch.tensor(y_train, dtype=torch.long))
+    loader = DataLoader(train_ds, batch_size=batch_size, shuffle=True)
+
+    model.train()
+    for epoch in range(epochs):
+        for xb, yb in loader:
+            xb, yb = xb.to(device), yb.to(device)
+            optimizer.zero_grad()
+            loss = criterion(model(xb), yb)
+            loss.backward()
+            optimizer.step()
+
+    # Predict probabilities on val
+    model.eval()
+    with torch.no_grad():
+        val_tensor = torch.tensor(X_val).to(device)
+        logits = model(val_tensor)
+        probs = torch.softmax(logits, dim=1).cpu().numpy()
+    return probs
+
+
+# --- 3. Cross-validated predictions ---
+print("\nTraining 5-fold cross-validated CNN...")
+n_splits = 5
+skf = StratifiedKFold(n_splits=n_splits, shuffle=True, random_state=42)
+pred_probs = np.zeros((len(X), 10))
+
+for fold, (train_idx, val_idx) in enumerate(skf.split(X, y)):
+    print(f"  Fold {fold + 1}/{n_splits}...")
+    probs = train_and_predict(X[train_idx], y[train_idx], X[val_idx])
+    pred_probs[val_idx] = probs
+
+print(f"  OOF accuracy: {(pred_probs.argmax(axis=1) == y).mean():.3f}")
+
+
+# --- 4. Cleanlab ---
+print("\nRunning Cleanlab...")
+from cleanlab import Datalab
+
+lab = Datalab(
+    data={"label": y.tolist(), "source": sources.tolist()},
+    label_name="label",
+)
+lab.find_issues(pred_probs=pred_probs)
+
+print("\n=== Issue Summary ===")
+print(lab.get_issue_summary())
+
+# Get label issues
+issues = lab.get_issues("label")
+label_issues = issues[issues["is_label_issue"]].sort_values("label_score")
+
+print(f"\n=== {len(label_issues)} Label Issues Found ===")
+if len(label_issues) > 0:
+    for idx in label_issues.index[:50]:
+        given = y[idx]
+        predicted = pred_probs[idx].argmax()
+        score = issues.loc[idx, "label_score"]
+        src = sources[idx]
+        print(f"  idx={idx:5d}  given={given}  predicted={predicted}  score={score:.4f}  source={src}")
+
+# Save full results
+results = pd.DataFrame({
+    "index": range(len(y)),
+    "label": y,
+    "predicted": pred_probs.argmax(axis=1),
+    "label_score": issues["label_score"].values,
+    "is_label_issue": issues["is_label_issue"].values,
+    "source": sources,
+})
+results.to_csv("label_issues.csv", index=False)
+print(f"\nFull results saved to label_issues.csv")
+
+# Make composite of worst issues
+print("\nGenerating composite of flagged issues...")
+if len(label_issues) > 0:
+    from PIL import ImageDraw
+    cell = 48
+    n_show = min(100, len(label_issues))
+    cols = min(20, n_show)
+    rows = (n_show + cols - 1) // cols
+    sheet = Image.new("RGB", (cols * cell, rows * cell), (0, 0, 0))
+    draw = ImageDraw.Draw(sheet)
+
+    for i, idx in enumerate(label_issues.index[:n_show]):
+        img = Image.open(io.BytesIO(df.iloc[idx]["image"]["bytes"])).convert("L")
+        img_rgb = img.resize((cell, cell)).convert("RGB")
+        r, c = i // cols, i % cols
+        x, y_pos = c * cell, r * cell
+        sheet.paste(img_rgb, (x, y_pos))
+        given = y[idx]
+        predicted = pred_probs[idx].argmax()
+        # Red label = given, Green label = predicted
+        draw.text((x + 2, y_pos + 2), str(given), fill=(255, 80, 80))
+        draw.text((x + 2, y_pos + 14), str(predicted), fill=(80, 255, 80))
+
+    sheet.save("composites/label_issues.png")
+    print(f"  composites/label_issues.png (red=given, green=predicted)")