Upload contamination.py with huggingface_hub

contamination.py

@@ -0,0 +1,74 @@
+"""Near-duplicate check between the generic benchmark and the images Sev models were trained on.
+
+Every training image of kev-vision-decisions-full (photo, document and chart sources) and of doc-index is hashed once
+(256-bit average hash, as in the dataset audit); a benchmark item is flagged when its image is within MAX_BITS of any
+training image. The same photo re-encoded or resized by another uploader lands within a few bits; different photos of a
+similar scene rarely do. Writes {bench: {n, flagged, by_source}} and the flagged item ids.
+
+    uv run modal run modal_app.py::contamination        # -> /vol/runs/eval/contamination.json
+"""
+import argparse, json
+from collections import Counter, defaultdict
+from pathlib import Path
+
+import numpy as np
+import pyarrow.parquet as pq
+
+from .sources import ahash
+
+MAX_BITS = 6
+FULL = "Jacqkues/kev-vision-decisions-full"
+IMAGE_SOURCES = ["aokvqa", "vqav2", "scienceqa", "chartnet", "documents", "rvl_cdip", "ava", "pets", "eurosat", "fairface_age"]
+
+
+def _words(h):
+    """256-bit int -> 4 uint64 words, for vectorised Hamming distances."""
+    return [(h >> (64 * k)) & (2**64 - 1) for k in range(4)]
+
+
+def _hash_file(path):
+    hs = []
+    for b in pq.ParquetFile(path).iter_batches(batch_size=500, columns=["image"]):
+        for r in b.to_pylist():
+            if r["image"] and r["image"].get("bytes"): hs.append(_words(ahash(r["image"]["bytes"])))
+    return np.array(hs, dtype=np.uint64).reshape(-1, 4)
+
+
+def main():
+    from huggingface_hub import hf_hub_download
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--bench", default="/vol/data/generic.parquet")
+    ap.add_argument("--docindex", default="/vol/data/docindex")
+    ap.add_argument("--out", default="/vol/runs/eval/contamination.json")
+    a = ap.parse_args()
+
+    items = [r for b in pq.ParquetFile(a.bench).iter_batches(batch_size=500, columns=["id", "bench", "image"]) for r in b.to_pylist()]
+    bench = np.array([_words(ahash(r["image"])) for r in items], dtype=np.uint64)
+    print(f"{len(items)} benchmark images hashed", flush=True)
+
+    train = {s: hf_hub_download(FULL, f"train/{s}.parquet", repo_type="dataset") for s in IMAGE_SOURCES}
+    train.update({f"docindex/{p.stem}": str(p) for p in sorted(Path(a.docindex, "train").glob("*.parquet"))})
+    best = np.full(len(items), 257); best_src = [None] * len(items)
+    for src, path in train.items():
+        th = _hash_file(path)
+        for s in range(0, len(th), 4000):                                  # [bench, chunk] Hamming distances
+            d = sum(np.bitwise_count(bench[:, None, k] ^ th[None, s:s + 4000, k]).astype(np.int32) for k in range(4)).min(axis=1)
+            better = d < best
+            best = np.where(better, d, best)
+            for i in np.nonzero(better)[0]: best_src[i] = src
+        print(f"{src}: {len(th)} training images, {(best <= MAX_BITS).sum()} benchmark items flagged so far", flush=True)
+
+    flagged = defaultdict(list); report = {}
+    for it, d, s in zip(items, best, best_src):
+        if d <= MAX_BITS: flagged[it["bench"]].append({"id": it["id"], "source": s, "bits": int(d)})
+    for b, n in Counter(it["bench"] for it in items).items():
+        report[b] = {"n": n, "flagged": len(flagged[b]), "share": round(len(flagged[b]) / n, 4),
+                     "by_source": dict(Counter(f["source"] for f in flagged[b]))}
+        print(b, report[b], flush=True)
+    Path(a.out).parent.mkdir(parents=True, exist_ok=True)
+    Path(a.out).write_text(json.dumps({"max_bits": MAX_BITS, "benches": report, "flagged": flagged}, indent=1))
+    print(f"saved {a.out}", flush=True)
+
+
+if __name__ == "__main__":
+    main()