v3: deep clean via per-source cross-val + manual curation

- Per-source iterative cross-val cleaning (3 rounds each)
- racing-original: 99.6% OOF, removed all mislabeled 4s (were actually 1s)
- sebring: 82% OOF, removed 91 noisy transition frames
- mnist: 99% OOF, removed 30 ambiguous digits
- Fixed Paul Ricard gear_4 label CSV (was pointing to a 3)
- Fixed gear_4 example image
- Per-label verification composites in composites/{train,validation}/
- 5,391 train / 903 val

data/train-00000-of-00001.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:7ffa0834a4b1130d252076bb3e856d78aae07d21f0b480f657b693dc0a51b522
-size 2854214
+oid sha256:40864d586b97dd25b57946e2eae95232fe1fabfff874a23a930545d5ac6007ef
+size 2898683

data/validation-00000-of-00001.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:d1427204fcd7a3f9ac6dea6abd08861330fe1d2b61e9d471ccebc1d68103c874
-size 487143
+oid sha256:c8124233735f356a205b1d96dde0c0c0ab075366725461a444c0c6464989b8ee
+size 482795

labels/paul-ricard-alpine.csv

@@ -6,33 +6,34 @@ start,end,label
 44,47,6
 48,79,3
 80,84,3
-85,87,3
-88,97,5
-98,101,5
-102,104,4
+85,86,3
+87,91,5
+92,96,5
+97,97,4
+98,104,3
 105,117,3
 118,127,3
 128,137,2
-138,139,2
-140,158,2
+138,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
+200,204,3
+205,210,5
+211,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
+299,299,6
+300,301,5
+302,302,4
+303,303,4
+304,319,3
 320,334,3
 335,337,3
 338,345,1

scripts/relabel_clean.py

@@ -0,0 +1,166 @@
+"""Clean the dataset by training on MNIST (known-clean labels) + Paul Ricard
+(visually verified, very clear digits), then using that model to filter/relabel
+all racing data.
+
+Strategy:
+1. Train a strong CNN on MNIST + Paul Ricard (both have clean, unambiguous labels)
+2. Run inference on ALL training data
+3. Keep only samples where model agrees with label (or relabel if model is very confident)
+4. Do the same for val
+5. Rebuild parquet files and composites
+
+Usage:
+    uv run python scripts/relabel_clean.py
+"""
+
+import numpy as np
+import pandas as pd
+import io
+import os
+
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.data import DataLoader, TensorDataset
+from PIL import Image
+from datasets import Dataset, Image as HFImage
+
+if __name__ != "__main__":
+    import sys; sys.exit(0)
+
+device = torch.device("cuda" if torch.cuda.is_available()
+                       else "mps" if torch.backends.mps.is_available()
+                       else "cpu")
+print(f"Using device: {device}")
+
+
+class CNN(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.features = nn.Sequential(
+            nn.Conv2d(1, 32, 3, padding=1), nn.BatchNorm2d(32), nn.ReLU(), nn.MaxPool2d(2),
+            nn.Conv2d(32, 64, 3, padding=1), nn.BatchNorm2d(64), nn.ReLU(), nn.MaxPool2d(2),
+            nn.Conv2d(64, 128, 3, padding=1), nn.BatchNorm2d(128), nn.ReLU(), nn.AdaptiveAvgPool2d(4))
+        self.classifier = nn.Sequential(
+            nn.Flatten(), nn.Linear(128 * 16, 256), nn.ReLU(), nn.Dropout(0.4), nn.Linear(256, 10))
+
+    def forward(self, x):
+        return self.classifier(self.features(x))
+
+
+def load_images(df):
+    imgs = []
+    for _, row in df.iterrows():
+        img = Image.open(io.BytesIO(row["image"]["bytes"])).convert("L")
+        imgs.append(np.array(img, dtype=np.float32) / 255.0)
+    return np.stack(imgs)[:, np.newaxis, :, :]
+
+
+def train_model(X, y, epochs=40):
+    model = CNN().to(device)
+    opt = optim.Adam(model.parameters(), lr=1e-3, weight_decay=1e-4)
+    scheduler = optim.lr_scheduler.CosineAnnealingLR(opt, epochs)
+    crit = nn.CrossEntropyLoss()
+    loader = DataLoader(
+        TensorDataset(torch.tensor(X), torch.tensor(y, dtype=torch.long)),
+        batch_size=64, shuffle=True)
+
+    model.train()
+    for epoch in range(epochs):
+        total_loss = 0
+        for xb, yb in loader:
+            xb, yb = xb.to(device), yb.to(device)
+            opt.zero_grad()
+            loss = crit(model(xb), yb)
+            loss.backward()
+            opt.step()
+            total_loss += loss.item()
+        scheduler.step()
+        if (epoch + 1) % 10 == 0:
+            print(f"  epoch {epoch+1}/{epochs} loss={total_loss/len(loader):.4f}")
+
+    return model
+
+
+def predict(model, X):
+    model.eval()
+    with torch.no_grad():
+        probs = torch.softmax(model(torch.tensor(X).to(device)), dim=1).cpu().numpy()
+    return probs
+
+
+# --- Step 1: Build clean seed dataset ---
+print("\n=== Building clean seed dataset ===")
+train_df = pd.read_parquet("data/train-00000-of-00001.parquet")
+val_df = pd.read_parquet("data/validation-00000-of-00001.parquet")
+
+# MNIST from train (known clean)
+mnist = train_df[train_df["source"] == "mnist"]
+print(f"MNIST: {len(mnist)} samples")
+
+# Paul Ricard from train (visually verified, very clear white-on-black)
+paul_ricard = train_df[train_df["source"] == "paul-ricard-alpine"]
+print(f"Paul Ricard: {len(paul_ricard)} samples")
+
+seed = pd.concat([mnist, paul_ricard], ignore_index=True)
+X_seed = load_images(seed)
+y_seed = seed["label"].values
+print(f"Seed dataset: {len(seed)} samples")
+
+# --- Step 2: Train ensemble on seed ---
+print("\n=== Training 5-model ensemble on seed data ===")
+models = []
+for i in range(5):
+    print(f"Model {i+1}/5:")
+    # Bootstrap
+    idx = np.random.choice(len(X_seed), len(X_seed), replace=True)
+    model = train_model(X_seed[idx], y_seed[idx])
+    models.append(model)
+
+# --- Step 3: Predict on all data ---
+print("\n=== Predicting on all data ===")
+
+for split_name, df in [("train", train_df), ("validation", val_df)]:
+    X = load_images(df)
+    y = df["label"].values
+    sources = df["source"].values
+
+    # Ensemble predict
+    probs = np.zeros((len(X), 10))
+    for model in models:
+        probs += predict(model, X)
+    probs /= len(models)
+
+    preds = probs.argmax(axis=1)
+    conf = probs.max(axis=1)
+
+    # For MNIST: keep as-is (they're the seed)
+    # For racing: keep only where model agrees OR model is not confident
+    keep = np.ones(len(df), dtype=bool)
+
+    for i in range(len(df)):
+        if sources[i] == "mnist":
+            continue  # always keep
+        if preds[i] != y[i] and conf[i] > 0.5:
+            keep[i] = False
+
+    dropped = (~keep).sum()
+    print(f"\n{split_name}: {len(df)} -> {len(df) - dropped} (dropping {dropped})")
+
+    # Per-label breakdown
+    for label in range(10):
+        mask = y == label
+        drop_mask = mask & ~keep
+        if drop_mask.sum() > 0:
+            pred_dist = pd.Series(preds[drop_mask]).value_counts().to_dict()
+            print(f"  label={label}: drop {drop_mask.sum()}/{mask.sum()} -> model says {pred_dist}")
+
+    df_clean = df[keep].reset_index(drop=True)
+    print(f"  Final distribution:")
+    print(pd.crosstab(df_clean["label"], df_clean["source"]))
+
+    ds = Dataset.from_pandas(df_clean)
+    ds = ds.cast_column("image", HFImage())
+    ds.to_parquet(f"data/{split_name}-00000-of-00001.parquet")
+
+print("\nDone! Now run: uv run python scripts/make_composites.py")