Publish ICW as verified WebDataset shards

Replace the image-folder upload with 26 identity-preserving TAR shards and reproducibility metadata.

.gitignore

@@ -1,6 +0,0 @@
-.DS_Store
-**/.DS_Store
-__pycache__/
-**/__pycache__/
-*.py[cod]
-.cache/

README.md

@@ -9,6 +9,7 @@ language:
 tags:
 - image
 - datasets
+- webdataset
 - computer-vision
 - image-retrieval
 - animal-re-identification
@@ -17,6 +18,15 @@ tags:
 pretty_name: Individual Cats in the Wild
 size_categories:
 - 10K<n<100K
+configs:
+- config_name: default
+  data_files:
+  - split: train
+    path: data/train-*.tar
+  - split: validation
+    path: data/validation-*.tar
+  - split: test
+    path: data/test-*.tar
 ---
 
 # Individual Cats in the Wild (ICW)
@@ -29,7 +39,7 @@ fine-grained recognition and image retrieval research.
 ICW accompanies the MeowID project:
 
 > **MeowID: A Dual-Expert Retrieval System for Individual Cat Identification**
->  
+>
 > Zhangchi Hu, Yi Shang, Haocheng Yang, Qiwei Hu, and Yuzheng Li (2026)
 
 - Project repository: https://github.com/RicePasteM/MeowID
@@ -37,34 +47,127 @@ ICW accompanies the MeowID project:
 
 ## Dataset structure
 
+The release uses identity-preserving [WebDataset](https://github.com/webdataset/webdataset)
+TAR shards. Shards target approximately 1 GiB, and all images of one identity
+remain in the same shard.
+
 ```text
-icw_split/
-├── train/
-│   └── <cat_id>/
-│       └── <image_id>.jpg
-├── val/
-│   └── <cat_id>/
-│       └── <image_id>.jpg
-├── test/
-│   └── <cat_id>/
-│       └── <image_id>.jpg
+ICW/
+├── data/
+│   ├── train-00000.tar
+│   ├── ...
+│   ├── train-00023.tar
+│   ├── validation-00000.tar
+│   └── test-00000.tar
 ├── cats.csv
 ├── metadata.csv
-└── check_integrity.py
+├── splits.csv
+├── manifest.json
+├── verify_webdataset.py
+└── extract_to_imagefolder.py
+```
+
+| Split | Identities | Images | Shards | Images per identity |
+| --- | ---: | ---: | ---: | ---: |
+| Train | 18,877 | 77,094 | 24 | 3–19 (mean 4.08) |
+| Validation | 500 | 2,851 | 1 | 5–14 (mean 5.70) |
+| Test | 500 | 2,846 | 1 | 5–17 (mean 5.69) |
+| **Total** | **19,877** | **82,791** | **26** | **3–19 (mean 4.17)** |
+
+Identity sets are strictly disjoint across the three splits.
+
+## Sample format
+
+Each WebDataset example contains adjacent members with the same key:
+
+```text
+00001234_000001.jpg
+00001234_000001.json
 ```
 
-Each eight-digit `cat_id` denotes one identity. Identity directories are
-strictly disjoint across the training, validation, and test splits.
+The JSON member contains the identity, split, original path, normalized crop
+box, source provenance, and the corresponding row from `metadata.csv`.
+`identity_id` is the benchmark label; `image_id` identifies an observation of
+that individual.
+
+## Loading
+
+Install the vision dependencies:
+
+```bash
+pip install "datasets[vision]"
+```
+
+The dataset card defines all three splits, so it can be streamed directly:
+
+```python
+from datasets import load_dataset
+
+dataset = load_dataset("RicePasteM/ICW", streaming=True)
+sample = next(iter(dataset["train"]))
+
+image = sample["jpg"]
+metadata = sample["json"]
+identity_id = metadata["identity_id"]
+```
 
-| Split | Identities | Images | Images per identity |
-| --- | ---: | ---: | ---: |
-| Train | 18,877 | 77,094 | 3–19 (mean 4.08) |
-| Validation | 500 | 2,851 | 5–14 (mean 5.70) |
-| Test | 500 | 2,846 | 5–17 (mean 5.69) |
-| **Total** | **19,877** | **82,791** | **3–19 (mean 4.17)** |
+An explicit WebDataset configuration is also possible:
+
+```python
+from datasets import load_dataset
+
+files = {
+    "train": "hf://datasets/RicePasteM/ICW/data/train-*.tar",
+    "validation": "hf://datasets/RicePasteM/ICW/data/validation-*.tar",
+    "test": "hf://datasets/RicePasteM/ICW/data/test-*.tar",
+}
+dataset = load_dataset("webdataset", data_files=files, streaming=True)
+```
+
+To restore the conventional image-folder layout:
+
+```bash
+python extract_to_imagefolder.py /path/to/ICW /path/to/icw_imagefolder
+```
+
+This produces `train/<identity>/<image>.jpg`,
+`validation/<identity>/<image>.jpg`, and `test/<identity>/<image>.jpg`.
+
+## Metadata
+
+All tables are UTF-8 encoded. The original `cats.csv` and `metadata.csv` use a
+UTF-8 byte-order mark, so pass `encoding="utf-8-sig"` when reading them.
+
+### `cats.csv`
+
+One row per identity. It includes the eight-digit `cat_folder` label, source
+platform, source-side animal identifier, source-reported attributes, profile
+URL, and preserved source metadata.
+
+### `metadata.csv`
 
-The complete directory occupies approximately 24 GB before repository-side
-compression.
+One row per image. It includes `cat_folder`, `image_filename`, source
+provenance, source-reported attributes, original URLs, normalized crop box,
+curation assignment, and preserved source metadata.
+
+### `splits.csv`
+
+One row per identity with its split, image count, and containing shard. This
+table is the fastest way to map an identity to a TAR file without scanning the
+archives.
+
+### `manifest.json`
+
+The release manifest records sample and identity counts, byte sizes, SHA-256
+checksums, and key ranges for every shard. Run the included verifier after a
+download:
+
+```bash
+python verify_webdataset.py /path/to/ICW
+```
+
+Source-reported fields may be incomplete, outdated, or inaccurate and should
+not be treated as verified biological labels.
 
 ## Construction
 
@@ -79,8 +182,6 @@ The release was built through the following stages:
 5. Identities were assigned to mutually exclusive train, validation, and test
    splits.
 
-The identity distribution by source is:
-
 | Source | Identities |
 | --- | ---: |
 | PetFinder 2026 | 16,785 |
@@ -93,79 +194,16 @@ The identity distribution by source is:
 Source names describe provenance, not endorsement of this dataset or its
 authors.
 
-## Metadata
-
-Both CSV files are UTF-8 encoded with a byte-order mark. Use
-`encoding="utf-8-sig"` when reading them directly.
-
-### `cats.csv`
-
-One row per identity:
-
-| Field | Description |
-| --- | --- |
-| `cat_folder` | Eight-digit identity directory name |
-| `source`, `source_name` | Source platform identifiers |
-| `animal_id` | Source-side animal/listing identifier |
-| `name`, `breed`, `gender` | Attributes reported by the source listing |
-| `referer_url` | Original public profile URL |
-| `metadata_json` | Preserved source and curation metadata |
-
-### `metadata.csv`
-
-One row per image:
-
-| Field | Description |
-| --- | --- |
-| `cat_folder`, `image_filename` | Path key for the local JPEG |
-| `source`, `source_name`, `animal_id` | Source provenance |
-| `name`, `breed`, `gender` | Source-reported attributes |
-| `image_url`, `referer_url` | Original image and profile URLs |
-| `norm_x`, `norm_y`, `norm_w`, `norm_h` | Normalized crop bounding box |
-| `assignment_id` | Internal curation assignment identifier |
-| `metadata_json` | Preserved source and curation metadata |
-
-Source-reported fields may be incomplete, outdated, or inaccurate and should
-not be treated as verified biological labels.
-
-## Loading the images
-
-The directory layout is compatible with common image-folder loaders. With
-Hugging Face Datasets:
-
-```python
-from datasets import load_dataset
-
-dataset = load_dataset(
-    "imagefolder",
-    data_dir="/path/to/icw_split",
-    drop_metadata=True,
-    drop_labels=False,
-)
-print(dataset)
-```
-
-The explicit `drop_metadata=True` is required because the root-level
-`metadata.csv` is ICW's provenance table rather than an ImageFolder metadata
-file with a `file_name` column. `drop_labels=False` keeps the identity inferred
-from each directory name.
-
-For identity retrieval, use directory names as identity labels and preserve the
-provided split boundaries. Do not merge identities across splits.
-
 ## Intended uses
 
-ICW is intended for non-commercial research and evaluation involving:
-
-- individual animal identification and re-identification;
-- fine-grained image retrieval;
-- route-aware face and whole-animal recognition;
-- representation learning under changes in pose, viewpoint, lighting,
-  background, camera, and occlusion.
+ICW is intended for non-commercial research and evaluation involving
+individual animal identification, fine-grained image retrieval, route-aware
+face and whole-animal recognition, and representation learning under changes
+in pose, viewpoint, lighting, background, camera, and occlusion.
 
 The dataset is not intended for identifying people, inferring pet ownership,
-contacting source organizations or individuals, making automated animal-welfare
-decisions, or any commercial deployment.
+contacting source organizations or individuals, making automated
+animal-welfare decisions, or commercial deployment.
 
 ## Limitations and responsible use
 
@@ -173,7 +211,6 @@ decisions, or any commercial deployment.
   sample of the global cat population.
 - Geographic, platform, breed, age, health, photographic, and curation biases
   may affect model behavior.
-- Some identities have substantially more observations than others.
 - Listings and URLs can become outdated after collection.
 - Free-text source metadata can contain contact details or other incidental
   information. Do not use it to identify, profile, or contact people.
@@ -185,26 +222,21 @@ requirements in their jurisdiction and application.
 
 ## Data quality
 
-The included `check_integrity.py` verifies directory/CSV correspondence,
-identity disjointness, JPEG signatures, per-identity image counts, and bounding
-box ranges.
+The release was validated on 17 August 2026:
 
-The local release was validated on 17 August 2026:
-
-- 19,877 unique identity directories;
-- 82,791 corresponding metadata rows and JPEG files;
+- 19,877 identities and 82,791 paired JPEG/JSON examples;
 - no identity overlap between train, validation, and test;
-- no missing, empty, or invalid-signature JPEG files;
-- all normalized bounding boxes within `[0, 1]` and with non-zero area.
+- no identity split across multiple shards;
+- deterministic member ordering and valid sidecar JSON;
+- byte sizes and SHA-256 checksums verified for all 26 shards;
+- all original metadata rows matched to exactly one image.
 
 ## Licensing and source rights
 
 The dataset-specific selection, identity organization, split assignments,
 curation annotations, and original documentation contributed by the MeowID
-authors are licensed under the **Creative Commons
-Attribution-NonCommercial 4.0 International license (CC BY-NC 4.0)**. See
-[`LICENSE`](LICENSE) and the
-[Creative Commons license page](https://creativecommons.org/licenses/by-nc/4.0/).
+authors are licensed under the **Creative Commons Attribution-NonCommercial
+4.0 International license (CC BY-NC 4.0)**. See [`LICENSE`](LICENSE).
 
 This license applies only to material for which the MeowID authors hold the
 necessary rights. **Third-party photographs, source listing text, trademarks,
@@ -219,8 +251,6 @@ only the minimum path or source identifier needed to locate the record.
 
 ## Citation
 
-If you use ICW or MeowID in academic work, please cite:
-
 ```bibtex
 @article{hu2026meowid,
   title  = {MeowID: A Dual-Expert Retrieval System for Individual Cat Identification},

check_integrity.py

@@ -1,302 +0,0 @@
-#!/usr/bin/env python3
-"""Check integrity of icw_split dataset."""
-
-import csv
-import json
-import os
-from collections import defaultdict
-from pathlib import Path
-
-BASE = Path(__file__).resolve().parent
-SPLITS = ["train", "val", "test"]
-
-print("=" * 60)
-print("DATASET INTEGRITY CHECK")
-print("=" * 60)
-
-# ── 1. Gather actual directories and files ───────────────────────────
-actual_dirs_by_split = {}
-actual_images_by_split = {}
-all_actual_dirs = set()
-all_actual_images = {}
-total_images = 0
-
-for split in SPLITS:
-    split_path = BASE / split
-    dirs = set()
-    images = {}
-    for d in sorted(split_path.iterdir()):
-        if d.is_dir():
-            dirs.add(d.name)
-            imgs = sorted(f.name for f in d.iterdir() if f.is_file() and f.suffix.lower() == ".jpg")
-            images[d.name] = imgs
-            for img in imgs:
-                all_actual_images[(d.name, img)] = split
-            total_images += len(imgs)
-    actual_dirs_by_split[split] = dirs
-    actual_images_by_split[split] = images
-    all_actual_dirs.update(dirs)
-
-# Also check for non-.jpg files
-non_jpg = []
-for split in SPLITS:
-    for d in (BASE / split).iterdir():
-        if d.is_dir():
-            for f in d.iterdir():
-                if f.is_file() and f.suffix.lower() != ".jpg":
-                    non_jpg.append(str(f.relative_to(BASE)))
-
-print(f"\nActual directories: train={len(actual_dirs_by_split['train'])}, "
-      f"val={len(actual_dirs_by_split['val'])}, "
-      f"test={len(actual_dirs_by_split['test'])}")
-print(f"Total unique dirs: {len(all_actual_dirs)}")
-print(f"Total images: {total_images}")
-print(f"Non-jpg files: {len(non_jpg)} {' '.join(non_jpg) if non_jpg else '(none)'}")
-
-# ── 2. Check cross-split duplication ─────────────────────────────────
-print("\n── Cross-split duplication ──")
-train_set = set(actual_dirs_by_split["train"])
-val_set   = set(actual_dirs_by_split["val"])
-test_set  = set(actual_dirs_by_split["test"])
-
-tv_overlap = train_set & val_set
-tt_overlap = train_set & test_set
-vt_overlap = val_set & test_set
-
-if tv_overlap:
-    print(f"WARNING: train ∩ val = {len(tv_overlap)} cats: {sorted(tv_overlap)[:20]}...")
-if tt_overlap:
-    print(f"WARNING: train ∩ test = {len(tt_overlap)} cats: {sorted(tt_overlap)[:20]}...")
-if vt_overlap:
-    print(f"WARNING: val ∩ test = {len(vt_overlap)} cats: {sorted(vt_overlap)[:20]}...")
-if not tv_overlap and not tt_overlap and not vt_overlap:
-    print("OK - no cross-split duplication")
-
-# ── 3. Parse cats.csv ─────────────────────────────────────────────────
-print("\n── cats.csv ──")
-cats_csv_path = BASE / "cats.csv"
-cats_csv_cats = set()
-cats_csv_rows = 0
-cats_csv_malformed = 0
-cats_csv_extra_cols = []
-cats_expected_cols = 9
-
-with open(cats_csv_path, "r", encoding="utf-8-sig") as f:
-    # Try csv module first
-    reader = csv.reader(f)
-    header = next(reader)
-    expected_header = ["cat_folder","source","source_name","animal_id","name","breed","gender","referer_url","metadata_json"]
-    if header != expected_header:
-        print(f"WARNING: cats.csv header mismatch")
-        print(f"  Expected: {expected_header}")
-        print(f"  Got:      {header}")
-
-    for i, row in enumerate(reader, start=1):
-        if len(row) != cats_expected_cols:
-            cats_csv_malformed += 1
-            cats_csv_extra_cols.append((i, len(row)))
-            continue
-        cats_csv_cats.add(row[0])  # cat_folder
-        cats_csv_rows += 1
-
-print(f"Total rows (well-formed): {cats_csv_rows}")
-print(f"Malformed rows (wrong col count): {cats_csv_malformed}")
-if cats_csv_malformed:
-    print(f"  First 10: {cats_csv_extra_cols[:10]}")
-print(f"Unique cat_folders: {len(cats_csv_cats)}")
-
-# ── 3b. Check cats.csv vs actual directories ─────────────────────────
-print("\n── cats.csv vs actual dirs ──")
-dirs_not_in_csv = all_actual_dirs - cats_csv_cats
-csv_not_in_dirs = cats_csv_cats - all_actual_dirs
-
-if dirs_not_in_csv:
-    print(f"WARNING: {len(dirs_not_in_csv)} dir(s) exist but NOT in cats.csv:")
-    for d in sorted(dirs_not_in_csv)[:30]:
-        split = [s for s in SPLITS if d in actual_dirs_by_split[s]][0]
-        print(f"  {d} (in {split})")
-else:
-    print("OK - all actual dirs found in cats.csv")
-
-if csv_not_in_dirs:
-    print(f"WARNING: {len(csv_not_in_dirs)} cat(s) in cats.csv but no directory:")
-    for d in sorted(csv_not_in_dirs)[:30]:
-        print(f"  {d}")
-else:
-    print("OK - all cats.csv entries have corresponding dirs")
-
-# ── 4. Parse metadata.csv ────────────────────────────────────────────
-print("\n── metadata.csv ──")
-meta_csv_path = BASE / "metadata.csv"
-meta_csv_entries = set()  # (cat_folder, image_filename)
-meta_csv_rows = 0
-meta_csv_malformed = 0
-meta_csv_extra_cols = []
-meta_expected_cols = 16
-meta_cat_image_counts = defaultdict(int)
-
-with open(meta_csv_path, "r", encoding="utf-8-sig") as f:
-    reader = csv.reader(f)
-    header = next(reader)
-    expected_meta_header = [
-        "cat_folder","image_filename","source","source_name","animal_id",
-        "name","breed","gender","image_url","referer_url",
-        "norm_x","norm_y","norm_w","norm_h","assignment_id","metadata_json"
-    ]
-    if header != expected_meta_header:
-        print(f"WARNING: metadata.csv header mismatch")
-        diff = [(i, a, b) for i, (a, b) in enumerate(zip(header, expected_meta_header)) if a != b]
-        print(f"  Differences: {diff}")
-    if len(header) != meta_expected_cols:
-        print(f"WARNING: header has {len(header)} cols, expected {meta_expected_cols}")
-
-    for i, row in enumerate(reader, start=1):
-        if len(row) != meta_expected_cols:
-            meta_csv_malformed += 1
-            meta_csv_extra_cols.append((i, len(row)))
-            continue
-        meta_csv_entries.add((row[0], row[1]))
-        meta_cat_image_counts[row[0]] += 1
-        meta_csv_rows += 1
-
-print(f"Total rows (well-formed): {meta_csv_rows}")
-print(f"Malformed rows (wrong col count): {meta_csv_malformed}")
-if meta_csv_malformed:
-    print(f"  First 10: {meta_csv_extra_cols[:10]}")
-print(f"Unique (cat_folder, image) pairs: {len(meta_csv_entries)}")
-print(f"Unique cat_folders in metadata: {len(meta_cat_image_counts)}")
-
-# ── 5. Check metadata.csv vs actual images ───────────────────────────
-print("\n── metadata.csv vs actual images ──")
-actual_image_set = set(all_actual_images.keys())  # (cat_folder, image_filename)
-
-images_not_in_meta = actual_image_set - meta_csv_entries
-meta_not_actual = meta_csv_entries - actual_image_set
-
-if images_not_in_meta:
-    print(f"WARNING: {len(images_not_in_meta)} image(s) exist on disk but NOT in metadata.csv:")
-    for cat, img in sorted(images_not_in_meta)[:30]:
-        split = all_actual_images[(cat, img)]
-        print(f"  {cat}/{img} (in {split})")
-else:
-    print("OK - all actual images found in metadata.csv")
-
-if meta_not_actual:
-    print(f"WARNING: {len(meta_not_actual)} entry(s) in metadata.csv but no file on disk:")
-    for cat, img in sorted(meta_not_actual)[:30]:
-        print(f"  {cat}/{img}")
-else:
-    print("OK - all metadata.csv entries have corresponding files")
-
-# ── 6. Check image counts match between actual and metadata per cat ──
-print("\n── Image counts per cat: disk vs metadata.csv ──")
-count_mismatches = []
-for cat_id in all_actual_dirs:
-    actual_count = 0
-    for split in SPLITS:
-        if cat_id in actual_images_by_split[split]:
-            actual_count = len(actual_images_by_split[split][cat_id])
-            break
-    meta_count = meta_cat_image_counts.get(cat_id, 0)
-    if actual_count != meta_count:
-        count_mismatches.append((cat_id, actual_count, meta_count))
-
-if count_mismatches:
-    print(f"WARNING: {len(count_mismatches)} cat(s) have mismatched image counts:")
-    for cat, a, m in sorted(count_mismatches)[:30]:
-        print(f"  {cat}: disk={a}, metadata={m}")
-else:
-    print("OK - all image counts match")
-
-# ── 7. Check image file integrity (corrupt JPGs) ─────────────────────
-print("\n── Image file integrity ──")
-corrupt_count = 0
-corrupt_files = []
-empty_files = 0
-
-for (cat, img), split in all_actual_images.items():
-    fpath = BASE / split / cat / img
-    try:
-        fsize = fpath.stat().st_size
-        if fsize == 0:
-            empty_files += 1
-            corrupt_files.append(f"{split}/{cat}/{img} (empty)")
-            continue
-        # Check JPEG magic bytes
-        with open(fpath, "rb") as ff:
-            magic = ff.read(4)
-        if magic[:2] != b'\xff\xd8':
-            corrupt_count += 1
-            corrupt_files.append(f"{split}/{cat}/{img} (bad magic: {magic.hex()})")
-    except Exception as e:
-        corrupt_count += 1
-        corrupt_files.append(f"{split}/{cat}/{img} (error: {e})")
-
-if empty_files > 0:
-    print(f"WARNING: {empty_files} empty file(s)")
-if corrupt_count > 0:
-    print(f"WARNING: {corrupt_count} corrupt/readable JPG(s)")
-    for f in corrupt_files[:30]:
-        print(f"  {f}")
-else:
-    print(f"OK - all {total_images} images pass JPG magic byte check")
-
-# ── 8. Spot-check bounding box values ────────────────────────────────
-print("\n── Bounding box sanity check ──")
-bb_out_of_range = 0
-bb_zero_area = 0
-with open(meta_csv_path, "r", encoding="utf-8-sig") as f:
-    reader = csv.reader(f)
-    next(reader)
-    for i, row in enumerate(reader, start=1):
-        if len(row) != meta_expected_cols:
-            continue
-        try:
-            nx, ny, nw, nh = float(row[10]), float(row[11]), float(row[12]), float(row[13])
-        except ValueError:
-            continue
-        if not (0 <= nx <= 1 and 0 <= ny <= 1 and 0 <= nw <= 1 and 0 <= nh <= 1):
-            bb_out_of_range += 1
-        if nw <= 0 or nh <= 0:
-            bb_zero_area += 1
-
-if bb_out_of_range:
-    print(f"WARNING: {bb_out_of_range} rows have bbox values outside [0,1]")
-else:
-    print("OK - all bbox values in [0,1] range")
-if bb_zero_area:
-    print(f"WARNING: {bb_zero_area} rows have zero-area bbox")
-else:
-    print("OK - no zero-area bboxes")
-
-# ── 9. Split ratios ─────────────────────────────────────────────────
-print("\n── Split statistics ──")
-for split in SPLITS:
-    n_cats = len(actual_dirs_by_split[split])
-    n_imgs = sum(len(v) for v in actual_images_by_split[split].values())
-    print(f"  {split:6s}: {n_cats:>6} cats, {n_imgs:>6} images, "
-          f"avg={n_imgs/n_cats:.1f} imgs/cat")
-
-# ── 10. Summary ──────────────────────────────────────────────────────
-print("\n" + "=" * 60)
-print("SUMMARY")
-print("=" * 60)
-issues = []
-if cats_csv_malformed: issues.append(f"{cats_csv_malformed} malformed rows in cats.csv")
-if meta_csv_malformed: issues.append(f"{meta_csv_malformed} malformed rows in metadata.csv")
-if dirs_not_in_csv: issues.append(f"{len(dirs_not_in_csv)} dirs missing from cats.csv")
-if csv_not_in_dirs: issues.append(f"{len(csv_not_in_dirs)} cats.csv entries with no dir")
-if images_not_in_meta: issues.append(f"{len(images_not_in_meta)} images missing from metadata.csv")
-if meta_not_actual: issues.append(f"{len(meta_not_actual)} metadata entries with no file")
-if count_mismatches: issues.append(f"{len(count_mismatches)} cats with mismatched image counts")
-if corrupt_count: issues.append(f"{corrupt_count} corrupt JPGs")
-if empty_files: issues.append(f"{empty_files} empty files")
-if non_jpg: issues.append(f"{len(non_jpg)} non-JPG files")
-if tv_overlap or tt_overlap or vt_overlap: issues.append("cross-split duplication detected")
-
-if issues:
-    print("ISSUES FOUND:")
-    for iss in issues:
-        print(f"  - {iss}")
-else:
-    print("Dataset is clean! No issues found.")

data/test-00000.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3ec421df4bc89aa9f3e98c1b88364c64f7bf3b567c320dc9c41fd471ef454107
+size 852213760

data/train-00000.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:aa7cf82ae95d605cf48c7b71bf97d0b38ee3ac3b92b26233c1c0b60afed54459
+size 1073192960

data/train-00001.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1529b3115d838f7dbe31895b799a9d801bfdbe8ed835ef993b210e52d6c07896
+size 1073397760

data/train-00002.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b1a624eb5c75b96235f8dc489674436cde4239cb3d16dcc9824f7b7266ee67e6
+size 1072261120

data/train-00003.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:20a660f3d3043e2d52595473804064b5da22ae3ed5637c7c0a2720f0c1c2d75d
+size 1073029120

data/train-00004.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c889c9ce9552242eae37b0639968746f37edb6f663eced1d8646a86ce2082291
+size 1072988160

data/train-00005.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fda64747b0f9d347c6d6915fefd3aff7d925a173b214c8c9aca1aeee782ee3e2
+size 1070929920

data/train-00006.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8014b52a77137cc7bff97912610e721a4088ef000dc608d63b611e39f4d9d0a9
+size 1070141440

data/train-00007.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:38db5c73df4aee7de5136211a42c6c35c088e7db3b35d7cbb9f8ab60e8e0116e
+size 1073346560

data/train-00008.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:40e7dea7b37a8e047265d5bf75b57b5bcec26775e0d53e488a4ace87e5fff5be
+size 1071462400

data/train-00009.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1c56bcdbc9b8c6cd8933008b4d4085056cb66bbc20a7fc781c77be9aa76df7a0
+size 1073592320

data/train-00010.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9a863dd6f4430f4410ae701678de4f8185c08a318ef1a49ac70081335e174774
+size 1073387520

data/train-00011.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e3dbb9413276f0f9f9b8938efcaca9c2f4b5a00ae859cc7d4421f5f716bfc66e
+size 1072721920

data/train-00012.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5f8b114d239d3d43f2ebdc332759aa77f1746f47e1420560b83a7d08b200b154
+size 1070407680

data/train-00013.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:db3d75d97a7b791a9bc18cffb8635fcd11a7fa16cd18814191de1442599b4099
+size 1072343040

data/train-00014.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a54dc7301069ab628a129cf991c2f96e3e5fd81524eab640d278bde081e4310e
+size 1073633280

data/train-00015.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c33a24c55c0f4deba2c38ddc458b76ce1a4d3ee2f95eb237e4622b06ef67a0e5
+size 1070991360

data/train-00016.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:562d9afbaf6774d1ba8c50bdabd0cd2c05fbfc510123f8b2c2ebb819d4cb8651
+size 1071759360

data/train-00017.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f398809a6cee554f157759002779e2bf4e7bc94d4ffcc4b8d1bfbd2c1ed056b7
+size 1071493120

data/train-00018.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ce6a028a69191626625f574da0b6d7561496180f4eeaf13dcf9aae6c50405828
+size 1073223680

data/train-00019.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6e5abd80bfb8e91e182d15cf29d8c95bcc0af545d908311d0b8d03113d1706eb
+size 1071411200

data/train-00020.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:616f7e756d0251c74cce7ee01367281d8c9c9897d721f25f7077218fba041c44
+size 1073541120

data/train-00021.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bcc258cd629037b059efb08e019ac875179b10603413871d843ca8eb7cea922d
+size 1073049600

data/train-00022.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5d716ea74aebfdf4bb0549eb9388d837140d23254804575be9c6fdafc95062cb
+size 1073694720

data/train-00023.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8405124308caa14143b0107c718f01139c19f3ace0ea74f510b30ebfcd57b707
+size 523161600

data/validation-00000.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:526d8252bf81630b886c7de3cbd28d88ed023bc63b9d3fd3ee95a7911ca67b26
+size 820797440

extract_to_imagefolder.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python3
+"""Restore ICW WebDataset shards to split/identity/image.jpg folders."""
+
+from __future__ import annotations
+
+import argparse
+import io
+import json
+import tarfile
+from pathlib import Path
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("release", type=Path)
+    parser.add_argument("output", type=Path)
+    args = parser.parse_args()
+    release = args.release.resolve()
+    output = args.output.resolve()
+    output.mkdir(parents=True, exist_ok=True)
+
+    manifest = json.loads((release / "manifest.json").read_text(encoding="utf-8"))
+    restored = 0
+    for shard in manifest["shards"]:
+        pending_key: str | None = None
+        pending_image: bytes | None = None
+        with tarfile.open(release / shard["path"], "r:") as archive:
+            for member in archive:
+                extracted = archive.extractfile(member)
+                if extracted is None:
+                    raise RuntimeError(f"Cannot read {member.name}")
+                key = Path(member.name).stem
+                if member.name.endswith(".jpg"):
+                    pending_key = key
+                    pending_image = extracted.read()
+                elif member.name.endswith(".json"):
+                    if pending_key != key or pending_image is None:
+                        raise RuntimeError(f"Invalid member order near {member.name}")
+                    metadata = json.load(extracted)
+                    split = str(metadata["split"])
+                    identity = str(metadata["identity_id"])
+                    image_name = str(metadata["image_filename"])
+                    destination = output / split / identity / image_name
+                    destination.parent.mkdir(parents=True, exist_ok=True)
+                    destination.write_bytes(pending_image)
+                    restored += 1
+                    pending_key = None
+                    pending_image = None
+        print(f"restored {shard['path']}")
+    print(f"complete: {restored} images restored to {output}")
+
+
+if __name__ == "__main__":
+    main()

manifest.json

@@ -0,0 +1,285 @@
+{
+  "format": "webdataset",
+  "target_shard_size_bytes": 1073741824,
+  "total_samples": 82791,
+  "total_identities": 19877,
+  "splits": {
+    "train": {
+      "samples": 77094,
+      "identities": 18877,
+      "shards": 24
+    },
+    "validation": {
+      "samples": 2851,
+      "identities": 500,
+      "shards": 1
+    },
+    "test": {
+      "samples": 2846,
+      "identities": 500,
+      "shards": 1
+    }
+  },
+  "shards": [
+    {
+      "path": "data/train-00000.tar",
+      "split": "train",
+      "samples": 2924,
+      "identities": 751,
+      "size_bytes": 1073192960,
+      "sha256": "aa7cf82ae95d605cf48c7b71bf97d0b38ee3ac3b92b26233c1c0b60afed54459",
+      "first_key": "00000000_000000",
+      "last_key": "00000777_000002"
+    },
+    {
+      "path": "data/train-00001.tar",
+      "split": "train",
+      "samples": 2820,
+      "identities": 740,
+      "size_bytes": 1073397760,
+      "sha256": "1529b3115d838f7dbe31895b799a9d801bfdbe8ed835ef993b210e52d6c07896",
+      "first_key": "00000778_000000",
+      "last_key": "00001548_000003"
+    },
+    {
+      "path": "data/train-00002.tar",
+      "split": "train",
+      "samples": 2773,
+      "identities": 716,
+      "size_bytes": 1072261120,
+      "sha256": "b1a624eb5c75b96235f8dc489674436cde4239cb3d16dcc9824f7b7266ee67e6",
+      "first_key": "00001549_000000",
+      "last_key": "00002295_000004"
+    },
+    {
+      "path": "data/train-00003.tar",
+      "split": "train",
+      "samples": 2534,
+      "identities": 655,
+      "size_bytes": 1073029120,
+      "sha256": "20a660f3d3043e2d52595473804064b5da22ae3ed5637c7c0a2720f0c1c2d75d",
+      "first_key": "00002296_000000",
+      "last_key": "00002972_000003"
+    },
+    {
+      "path": "data/train-00004.tar",
+      "split": "train",
+      "samples": 2857,
+      "identities": 738,
+      "size_bytes": 1072988160,
+      "sha256": "c889c9ce9552242eae37b0639968746f37edb6f663eced1d8646a86ce2082291",
+      "first_key": "00002973_000000",
+      "last_key": "00003738_000002"
+    },
+    {
+      "path": "data/train-00005.tar",
+      "split": "train",
+      "samples": 2627,
+      "identities": 684,
+      "size_bytes": 1070929920,
+      "sha256": "fda64747b0f9d347c6d6915fefd3aff7d925a173b214c8c9aca1aeee782ee3e2",
+      "first_key": "00003739_000000",
+      "last_key": "00004445_000002"
+    },
+    {
+      "path": "data/train-00006.tar",
+      "split": "train",
+      "samples": 2854,
+      "identities": 741,
+      "size_bytes": 1070141440,
+      "sha256": "8014b52a77137cc7bff97912610e721a4088ef000dc608d63b611e39f4d9d0a9",
+      "first_key": "00004446_000000",
+      "last_key": "00005206_000004"
+    },
+    {
+      "path": "data/train-00007.tar",
+      "split": "train",
+      "samples": 2723,
+      "identities": 697,
+      "size_bytes": 1073346560,
+      "sha256": "38db5c73df4aee7de5136211a42c6c35c088e7db3b35d7cbb9f8ab60e8e0116e",
+      "first_key": "00005207_000000",
+      "last_key": "00005938_000002"
+    },
+    {
+      "path": "data/train-00008.tar",
+      "split": "train",
+      "samples": 2776,
+      "identities": 707,
+      "size_bytes": 1071462400,
+      "sha256": "40e7dea7b37a8e047265d5bf75b57b5bcec26775e0d53e488a4ace87e5fff5be",
+      "first_key": "00005939_000000",
+      "last_key": "00006685_000003"
+    },
+    {
+      "path": "data/train-00009.tar",
+      "split": "train",
+      "samples": 2716,
+      "identities": 696,
+      "size_bytes": 1073592320,
+      "sha256": "1c56bcdbc9b8c6cd8933008b4d4085056cb66bbc20a7fc781c77be9aa76df7a0",
+      "first_key": "00006686_000000",
+      "last_key": "00007421_000002"
+    },
+    {
+      "path": "data/train-00010.tar",
+      "split": "train",
+      "samples": 2936,
+      "identities": 757,
+      "size_bytes": 1073387520,
+      "sha256": "9a863dd6f4430f4410ae701678de4f8185c08a318ef1a49ac70081335e174774",
+      "first_key": "00007422_000000",
+      "last_key": "00008210_000002"
+    },
+    {
+      "path": "data/train-00011.tar",
+      "split": "train",
+      "samples": 2823,
+      "identities": 715,
+      "size_bytes": 1072721920,
+      "sha256": "e3dbb9413276f0f9f9b8938efcaca9c2f4b5a00ae859cc7d4421f5f716bfc66e",
+      "first_key": "00008211_000000",
+      "last_key": "00008954_000002"
+    },
+    {
+      "path": "data/train-00012.tar",
+      "split": "train",
+      "samples": 2820,
+      "identities": 722,
+      "size_bytes": 1070407680,
+      "sha256": "5f8b114d239d3d43f2ebdc332759aa77f1746f47e1420560b83a7d08b200b154",
+      "first_key": "00008955_000000",
+      "last_key": "00009719_000003"
+    },
+    {
+      "path": "data/train-00013.tar",
+      "split": "train",
+      "samples": 2786,
+      "identities": 700,
+      "size_bytes": 1072343040,
+      "sha256": "db3d75d97a7b791a9bc18cffb8635fcd11a7fa16cd18814191de1442599b4099",
+      "first_key": "00009720_000000",
+      "last_key": "00010453_000002"
+    },
+    {
+      "path": "data/train-00014.tar",
+      "split": "train",
+      "samples": 2586,
+      "identities": 661,
+      "size_bytes": 1073633280,
+      "sha256": "a54dc7301069ab628a129cf991c2f96e3e5fd81524eab640d278bde081e4310e",
+      "first_key": "00010454_000000",
+      "last_key": "00011141_000004"
+    },
+    {
+      "path": "data/train-00015.tar",
+      "split": "train",
+      "samples": 2758,
+      "identities": 724,
+      "size_bytes": 1070991360,
+      "sha256": "c33a24c55c0f4deba2c38ddc458b76ce1a4d3ee2f95eb237e4622b06ef67a0e5",
+      "first_key": "00011142_000000",
+      "last_key": "00011897_000005"
+    },
+    {
+      "path": "data/train-00016.tar",
+      "split": "train",
+      "samples": 2561,
+      "identities": 642,
+      "size_bytes": 1071759360,
+      "sha256": "562d9afbaf6774d1ba8c50bdabd0cd2c05fbfc510123f8b2c2ebb819d4cb8651",
+      "first_key": "00011898_000000",
+      "last_key": "00012564_000002"
+    },
+    {
+      "path": "data/train-00017.tar",
+      "split": "train",
+      "samples": 2894,
+      "identities": 744,
+      "size_bytes": 1071493120,
+      "sha256": "f398809a6cee554f157759002779e2bf4e7bc94d4ffcc4b8d1bfbd2c1ed056b7",
+      "first_key": "00012565_000000",
+      "last_key": "00013342_000004"
+    },
+    {
+      "path": "data/train-00018.tar",
+      "split": "train",
+      "samples": 2573,
+      "identities": 664,
+      "size_bytes": 1073223680,
+      "sha256": "ce6a028a69191626625f574da0b6d7561496180f4eeaf13dcf9aae6c50405828",
+      "first_key": "00013343_000000",
+      "last_key": "00014037_000003"
+    },
+    {
+      "path": "data/train-00019.tar",
+      "split": "train",
+      "samples": 2746,
+      "identities": 699,
+      "size_bytes": 1071411200,
+      "sha256": "6e5abd80bfb8e91e182d15cf29d8c95bcc0af545d908311d0b8d03113d1706eb",
+      "first_key": "00014038_000000",
+      "last_key": "00014767_000003"
+    },
+    {
+      "path": "data/train-00020.tar",
+      "split": "train",
+      "samples": 2774,
+      "identities": 692,
+      "size_bytes": 1073541120,
+      "sha256": "616f7e756d0251c74cce7ee01367281d8c9c9897d721f25f7077218fba041c44",
+      "first_key": "00014768_000000",
+      "last_key": "00015505_000002"
+    },
+    {
+      "path": "data/train-00021.tar",
+      "split": "train",
+      "samples": 2719,
+      "identities": 697,
+      "size_bytes": 1073049600,
+      "sha256": "bcc258cd629037b059efb08e019ac875179b10603413871d843ca8eb7cea922d",
+      "first_key": "00015506_000000",
+      "last_key": "00016252_000002"
+    },
+    {
+      "path": "data/train-00022.tar",
+      "split": "train",
+      "samples": 7784,
+      "identities": 1533,
+      "size_bytes": 1073694720,
+      "sha256": "5d716ea74aebfdf4bb0549eb9388d837140d23254804575be9c6fdafc95062cb",
+      "first_key": "00016253_000000",
+      "last_key": "00017919_000003"
+    },
+    {
+      "path": "data/train-00023.tar",
+      "split": "train",
+      "samples": 8730,
+      "identities": 1802,
+      "size_bytes": 523161600,
+      "sha256": "8405124308caa14143b0107c718f01139c19f3ace0ea74f510b30ebfcd57b707",
+      "first_key": "00017920_000000",
+      "last_key": "00019876_000002"
+    },
+    {
+      "path": "data/validation-00000.tar",
+      "split": "validation",
+      "samples": 2851,
+      "identities": 500,
+      "size_bytes": 820797440,
+      "sha256": "526d8252bf81630b886c7de3cbd28d88ed023bc63b9d3fd3ee95a7911ca67b26",
+      "first_key": "00000028_000000",
+      "last_key": "00019862_000007"
+    },
+    {
+      "path": "data/test-00000.tar",
+      "split": "test",
+      "samples": 2846,
+      "identities": 500,
+      "size_bytes": 852213760,
+      "sha256": "3ec421df4bc89aa9f3e98c1b88364c64f7bf3b567c320dc9c41fd471ef454107",
+      "first_key": "00000012_000000",
+      "last_key": "00019855_000016"
+    }
+  ]
+}

verify_webdataset.py

@@ -0,0 +1,109 @@
+#!/usr/bin/env python3
+"""Verify an ICW WebDataset release against its manifest."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import tarfile
+from collections import Counter, defaultdict
+from pathlib import Path
+
+
+def sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(8 * 1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("root", nargs="?", type=Path, default=Path(__file__).resolve().parent)
+    args = parser.parse_args()
+    root = args.root.resolve()
+    manifest = json.loads((root / "manifest.json").read_text(encoding="utf-8"))
+
+    split_samples: Counter[str] = Counter()
+    split_identities: dict[str, set[str]] = defaultdict(set)
+    total_samples = 0
+
+    for record in manifest["shards"]:
+        path = root / record["path"]
+        if path.stat().st_size != record["size_bytes"]:
+            raise SystemExit(f"Size mismatch: {path}")
+        if sha256_file(path) != record["sha256"]:
+            raise SystemExit(f"SHA-256 mismatch: {path}")
+
+        sample_count = 0
+        identities: set[str] = set()
+        expected_json_key: str | None = None
+        with tarfile.open(path, "r:") as archive:
+            for member in archive:
+                if not member.isfile():
+                    raise SystemExit(f"Unexpected non-file member: {path}:{member.name}")
+                member_path = Path(member.name)
+                key = member_path.stem
+                if member_path.suffix == ".jpg":
+                    if expected_json_key is not None:
+                        raise SystemExit(f"Missing JSON after {expected_json_key} in {path}")
+                    expected_json_key = key
+                elif member_path.suffix == ".json":
+                    if key != expected_json_key:
+                        raise SystemExit(f"JPG/JSON ordering mismatch in {path}: {key}")
+                    extracted = archive.extractfile(member)
+                    if extracted is None:
+                        raise SystemExit(f"Cannot read {path}:{member.name}")
+                    metadata = json.load(extracted)
+                    if metadata["split"] != record["split"]:
+                        raise SystemExit(f"Split mismatch in {path}:{member.name}")
+                    if metadata["identity_id"] not in key:
+                        raise SystemExit(f"Identity/key mismatch in {path}:{member.name}")
+                    identities.add(metadata["identity_id"])
+                    sample_count += 1
+                    expected_json_key = None
+                else:
+                    raise SystemExit(f"Unexpected suffix in {path}:{member.name}")
+        if expected_json_key is not None:
+            raise SystemExit(f"Missing final JSON in {path}")
+        if sample_count != record["samples"]:
+            raise SystemExit(f"Sample count mismatch in {path}")
+        if len(identities) != record["identities"]:
+            raise SystemExit(f"Identity count mismatch in {path}")
+
+        split = record["split"]
+        split_samples[split] += sample_count
+        overlap = split_identities[split].intersection(identities)
+        if overlap:
+            raise SystemExit(f"Identity split across shards: {next(iter(overlap))}")
+        split_identities[split].update(identities)
+        total_samples += sample_count
+        print(f"verified {record['path']}")
+
+    split_sets = list(split_identities.items())
+    for index, (left_name, left_ids) in enumerate(split_sets):
+        for right_name, right_ids in split_sets[index + 1 :]:
+            overlap = left_ids.intersection(right_ids)
+            if overlap:
+                raise SystemExit(
+                    f"Identity overlap between {left_name} and {right_name}: {next(iter(overlap))}"
+                )
+
+    if total_samples != manifest["total_samples"]:
+        raise SystemExit("Total sample count mismatch")
+    for split, expected in manifest["splits"].items():
+        if split_samples[split] != expected["samples"]:
+            raise SystemExit(f"Manifest sample mismatch for {split}")
+        if len(split_identities[split]) != expected["identities"]:
+            raise SystemExit(f"Manifest identity mismatch for {split}")
+    print(
+        f"OK: {total_samples} samples, "
+        f"{sum(len(values) for values in split_identities.values())} identities, "
+        f"{len(manifest['shards'])} shards"
+    )
+
+
+if __name__ == "__main__":
+    main()