Add dataset card, audit checklist, conversion script, and manifest

DD_ASSET_COMPLETENESS_CHECKLIST.md

@@ -0,0 +1,103 @@
+# DD 资产完整性清单
+
+- `synthetic_imagefolders.tar.gz`
+- `other_pretrained_models.tar`
+
+
+## 结论
+
+- `synthetic_imagefolders.tar.gz`：13 个 DD 方法的内层压缩包都存在且均可完整读取，但方法 × 数据集 × IPC 覆盖不全。
+- `other_pretrained_models.tar`：归档可读取，但没有包含当前 ResNet-based 配置所引用的全部 teacher checkpoint。
+- 因此，仅依靠这两个归档不能完整运行当前项目的全部实验组合。
+
+## 1. `synthetic_imagefolders.tar.gz`
+
+### 1.1 内层方法包
+
+- [x] DC
+- [x] DM
+- [x] DSA
+- [x] ATT
+- [x] MTT
+- [x] TESLA
+- [x] FreD
+- [x] NCFM
+- [x] CVDD
+- [x] G-VBSM（归档目录名为 `GVBSM`）
+- [x] SCDD
+- [x] SRe²L（归档目录名为 `SRe2L`）
+- [x] WMDD
+
+### 1.2 数据集与 IPC 覆盖
+
+单元格中的数字表示归档内实际存在的 IPC；`—` 表示没有该数据集。
+
+| 家族 | 方法 | CIFAR-10 | CIFAR-100 | TinyImageNet200 | ImageNette | ImageNet-1K |
+|---|---|---|---|---|---|---|
+| ConvNet-based | DC | 1/10/50 | 1/10/50 | — | — | — |
+| ConvNet-based | DM | 1/10/50 | 1/10/50 | — | — | — |
+| ConvNet-based | DSA | 1/10/50 | 1/10/50 | — | — | — |
+| ConvNet-based | ATT | 1/10/50 | 1/10/50 | 1/10/50 | 1/10 | — |
+| ConvNet-based | MTT | 1/10/50 | 1/10/50 | 1/10/50 | 1/10 | — |
+| ConvNet-based | TESLA | 1/10/50 | 1/10/50 | 1/10/50 | 1/10 | — |
+| ConvNet-based | FreD | 1/10/50 | 1/10/50 | 1 | 1/10 | — |
+| ConvNet-based | NCFM | 1/10/50 | 1/10/50 | 1/10/50 | 1/10/50 | — |
+| ResNet-based | CVDD | 1/10/50 | 1/10/50 | 1/10/50 | 1/10/50 | 1/10/50 |
+| ResNet-based | G-VBSM | 1/10/50 | 1/10/50 | 1/10/50 | — | 1/10/50 |
+| ResNet-based | SCDD | 1/10/50 | 1/10/50 | — | — | — |
+| ResNet-based | SRe²L | **—** | **—** | 1/10/50 | — | 1/10/50 |
+| ResNet-based | WMDD | **—** | **—** | 1/10/50 | 10/50 | 1/10/50 |
+
+
+## 2. `other_pretrained_models.tar`
+
+### 2.1 当前 ResNet-based 配置的精确路径核对
+
+| 使用方 | 数据集 | 当前配置引用 | 归档状态 |
+|---|---|---|---|
+| CVDD | CIFAR-10 | `other_pretrained_models/CVDD/cifar10/ResNet18.pth` | [x] 在 |
+| CVDD | CIFAR-100 | `other_pretrained_models/CVDD/cifar100/ResNet18.pth` | [x] 在 |
+| CVDD | TinyImageNet200 | `other_pretrained_models/GVBSM/tiny/ResNet18/squeeze_ResNet18.pth` | [ ] 缺失 |
+| CVDD | ImageNet-1K | `offcial_resnet18`（运行时 torchvision 权重） | [ ] 归档中无文件 |
+| G-VBSM | CIFAR-10 | `other_pretrained_models/GVBSM/CIFAR-10/ResNet18/squeeze_ResNet18.pth` | [x] 在 |
+| G-VBSM | CIFAR-100 | `other_pretrained_models/GVBSM/CIFAR-100/ResNet18/squeeze_ResNet18.pth` | [x] 在 |
+| G-VBSM | TinyImageNet200 | `other_pretrained_models/GVBSM/tiny/ResNet18/squeeze_ResNet18.pth` | [ ] 缺失 |
+| G-VBSM | ImageNet-1K | `offcial_resnet18`（运行时 torchvision 权重） | [ ] 归档中无文件 |
+| SCDD | CIFAR-10 | `other_pretrained_models/SRe2L/cifar10/ckpt.pth` | [ ] 缺失 |
+| SCDD | CIFAR-100 | `other_pretrained_models/SRe2L/cifar100/ckpt.pth` | [ ] 缺失 |
+| SCDD | ImageNet-1K | `offcial_resnet18`（运行时 torchvision 权重） | [ ] 归档中无文件 |
+| SRe²L | CIFAR-10 | `other_pretrained_models/SRe2L/cifar10/ckpt.pth` | [ ] 缺失 |
+| SRe²L | CIFAR-100 | `other_pretrained_models/SRe2L/cifar100/ckpt.pth` | [ ] 缺失 |
+| SRe²L | ImageNet-1K | `offcial_resnet18`（运行时 torchvision 权重） | [ ] 归档中无文件 |
+| WMDD | CIFAR-10 | `other_pretrained_models/SRe2L/cifar10/ckpt.pth` | [ ] 缺失 |
+| WMDD | CIFAR-100 | `other_pretrained_models/SRe2L/cifar100/ckpt.pth` | [ ] 缺失 |
+| WMDD | TinyImageNet200 | `other_pretrained_models/WMDD/tiny-imagenet_model_49.pth` | [x] 在 |
+| WMDD | ImageNet-1K | `offcial_resnet18`（运行时 torchvision 权重） | [ ] 归档中无文件 |
+
+补充：
+
+- [x] `other_pretrained_models/WMDD/imagenette_model_49.pth` 存在，可对应 WMDD 的 ImageNette reproduction 配置。
+- `offcial_resnet18` 是项目代码中的既有拼写；它不是归档路径，而是触发 torchvision 加载 ImageNet 预训练 ResNet-18。
+
+### 2.2 唯一的关键缺失 checkpoint
+
+以下 3 个唯一文件缺失，共影响当前 8 个 ResNet-based 配置：
+
+- [ ] `other_pretrained_models/GVBSM/tiny/ResNet18/squeeze_ResNet18.pth`
+- [ ] `other_pretrained_models/SRe2L/cifar10/ckpt.pth`
+- [ ] `other_pretrained_models/SRe2L/cifar100/ckpt.pth`
+
+另外，ImageNet-1K 的 official ResNet-18 权重不在该归档中：
+
+- [ ] torchvision official ResNet-18 checkpoint
+
+### 2.3 数量汇总
+
+以当前 `tools/configs/tricks/` 中 18 个 ResNet-based 方法配置为口径：
+
+- [x] 5 个配置的精确本地 teacher 路径能在归档中找到。
+- [ ] 8 个配置引用了归档中缺失的本地 teacher 文件。
+- [ ] 5 个 ImageNet-1K 配置依赖归档外的 torchvision official ResNet-18。
+
+归档中标记为存在的关键 teacher 文件均为非空文件，并已完整读取其载荷；文件长度与 tar 元数据一致。
+

README.md

@@ -0,0 +1,173 @@
+---
+pretty_name: Dataset Distillation Collection
+tags:
+- dataset-distillation
+- computer-vision
+- parquet
+configs:
+- config_name: images
+  default: true
+  data_files:
+  - split: train
+    path: data/images/**/*.parquet
+- config_name: teachers
+  data_files:
+  - split: train
+    path: data/teachers/*.parquet
+- config_name: manifest
+  data_files:
+  - split: train
+    path: data/manifest/*.parquet
+dataset_info:
+- config_name: images
+  features:
+  - name: method
+    dtype: string
+  - name: dataset
+    dtype: string
+  - name: ipc
+    dtype: int32
+  - name: class_id
+    dtype: int32
+  - name: image_id
+    dtype: int32
+  - name: source_path
+    dtype: string
+  - name: extension
+    dtype: string
+  - name: image
+    dtype: image
+  - name: sample_weight
+    dtype: float64
+  - name: sha256
+    dtype: string
+  - name: byte_size
+    dtype: int64
+  - name: source_archive
+    dtype: string
+  splits:
+  - name: train
+    num_examples: 481090
+- config_name: teachers
+  features:
+  - name: provider
+    dtype: string
+  - name: dataset
+    dtype: string
+  - name: architecture
+    dtype: string
+  - name: used_by
+    sequence: string
+  - name: source_path
+    dtype: string
+  - name: checkpoint
+    dtype: binary
+  - name: sha256
+    dtype: string
+  - name: byte_size
+    dtype: int64
+  - name: source_archive
+    dtype: string
+  splits:
+  - name: train
+    num_examples: 6
+- config_name: manifest
+  features:
+  - name: asset_type
+    dtype: string
+  - name: relative_path
+    dtype: string
+  - name: method_or_provider
+    dtype: string
+  - name: row_count
+    dtype: int64
+  - name: payload_bytes
+    dtype: int64
+  - name: parquet_bytes
+    dtype: int64
+  - name: sha256
+    dtype: string
+  splits:
+  - name: train
+    num_examples: 26
+---
+
+# Dataset Distillation Collection
+
+This repository is a byte-preserving Parquet conversion of the assets audited in:
+
+- `synthetic_imagefolders.tar.gz`
+- `other_pretrained_models.tar`
+
+It contains 481,090 synthetic images from 13 dataset-distillation methods and six ResNet-18 teacher checkpoints that were physically present in the teacher archive. The original compressed image bytes and checkpoint bytes are stored directly in Parquet binary columns; no image re-encoding or checkpoint rewriting was performed.
+
+## Configurations
+
+### `images`
+
+One row per physical image. Important columns:
+
+- `method`, `dataset`, `ipc`, `class_id`, and `image_id` identify the experiment cell and sample.
+- `image` is the Hugging Face image feature backed by the original JPEG/PNG bytes.
+- `sample_weight` is populated for all 73,800 WMDD rows and null for other methods.
+- `sha256` and `byte_size` validate the original compressed image payload.
+- `source_path` and `source_archive` preserve provenance.
+
+`ipc` is the nominal IPC recorded in the source folder. FreD and NCFM deliberately contain more physical images than `classes × ipc`; every physical image is retained.
+
+### `teachers`
+
+One row per teacher checkpoint. The `checkpoint` column contains the original `.pth` bytes. The six included checkpoints are:
+
+- CVDD ResNet-18 for CIFAR-10 and CIFAR-100
+- G-VBSM ResNet-18 for CIFAR-10 and CIFAR-100
+- WMDD ResNet-18 for TinyImageNet-200 and ImageNette
+
+The source archive did not contain the following required assets, so this repository does not fabricate or substitute them:
+
+- `other_pretrained_models/GVBSM/tiny/ResNet18/squeeze_ResNet18.pth`
+- `other_pretrained_models/SRe2L/cifar10/ckpt.pth`
+- `other_pretrained_models/SRe2L/cifar100/ckpt.pth`
+- torchvision's official ImageNet ResNet-18 checkpoint (a runtime dependency in the project)
+
+### `manifest`
+
+One row per uploaded image or teacher Parquet shard, including row counts, payload sizes, Parquet sizes, and SHA-256 digests.
+
+## Usage
+
+```python
+from datasets import load_dataset
+
+# Stream images without downloading the whole collection.
+images = load_dataset(
+    "Passenger555/DatasetDistillationCollection",
+    "images",
+    split="train",
+    streaming=True,
+)
+first_image = next(iter(images))
+
+# Restore a teacher checkpoint byte-for-byte.
+teachers = load_dataset(
+    "Passenger555/DatasetDistillationCollection",
+    "teachers",
+    split="train",
+    streaming=True,
+)
+teacher = next(iter(teachers))
+with open("teacher.pth", "wb") as handle:
+    handle.write(teacher["checkpoint"])
+```
+
+## Validation
+
+The conversion was independently read back before upload. Validation covered all 481,090 image payloads and all six checkpoint payloads:
+
+- recomputed SHA-256 matched every Parquet row;
+- image row counts matched all 119 audited method/dataset/IPC groups;
+- one image from each group decoded successfully;
+- all WMDD sample weights were present and all non-WMDD weights were null;
+- every shard matched the SHA-256 and file size recorded in the manifest.
+
+See `DD_ASSET_COMPLETENESS_CHECKLIST.md` for the complete coverage matrix and `conversion_summary.json` for machine-readable counts and checksums.

conversion_summary.json

@@ -0,0 +1,1042 @@
+{
+  "created_at_utc": "2026-09-15T10:44:36.818347+00:00",
+  "format": "byte-preserving Parquet",
+  "image_schema": "method: string not null\ndataset: string not null\nipc: int32 not null\nclass_id: int32 not null\nimage_id: int32 not null\nsource_path: string not null\nextension: string not null\nimage: struct<bytes: binary not null, path: string not null> not null\n  child 0, bytes: binary not null\n  child 1, path: string not null\nsample_weight: double\nsha256: string not null\nbyte_size: int64 not null\nsource_archive: string not null",
+  "teacher_schema": "provider: string not null\ndataset: string not null\narchitecture: string not null\nused_by: list<item: string> not null\n  child 0, item: string\nsource_path: string not null\ncheckpoint: binary not null\nsha256: string not null\nbyte_size: int64 not null\nsource_archive: string not null",
+  "image_rows": 481090,
+  "image_payload_bytes": 5175494578,
+  "teacher_rows": 6,
+  "teacher_payload_bytes": 359292695,
+  "image_group_counts": [
+    {
+      "method": "ATT",
+      "dataset": "CIFAR-10",
+      "ipc": 1,
+      "rows": 10
+    },
+    {
+      "method": "ATT",
+      "dataset": "CIFAR-10",
+      "ipc": 10,
+      "rows": 100
+    },
+    {
+      "method": "ATT",
+      "dataset": "CIFAR-10",
+      "ipc": 50,
+      "rows": 500
+    },
+    {
+      "method": "ATT",
+      "dataset": "CIFAR-100",
+      "ipc": 1,
+      "rows": 100
+    },
+    {
+      "method": "ATT",
+      "dataset": "CIFAR-100",
+      "ipc": 10,
+      "rows": 1000
+    },
+    {
+      "method": "ATT",
+      "dataset": "CIFAR-100",
+      "ipc": 50,
+      "rows": 5000
+    },
+    {
+      "method": "ATT",
+      "dataset": "ImageNette",
+      "ipc": 1,
+      "rows": 10
+    },
+    {
+      "method": "ATT",
+      "dataset": "ImageNette",
+      "ipc": 10,
+      "rows": 100
+    },
+    {
+      "method": "ATT",
+      "dataset": "TinyImageNet-200",
+      "ipc": 1,
+      "rows": 200
+    },
+    {
+      "method": "ATT",
+      "dataset": "TinyImageNet-200",
+      "ipc": 10,
+      "rows": 2000
+    },
+    {
+      "method": "ATT",
+      "dataset": "TinyImageNet-200",
+      "ipc": 50,
+      "rows": 10000
+    },
+    {
+      "method": "CVDD",
+      "dataset": "CIFAR-10",
+      "ipc": 1,
+      "rows": 10
+    },
+    {
+      "method": "CVDD",
+      "dataset": "CIFAR-10",
+      "ipc": 10,
+      "rows": 100
+    },
+    {
+      "method": "CVDD",
+      "dataset": "CIFAR-10",
+      "ipc": 50,
+      "rows": 500
+    },
+    {
+      "method": "CVDD",
+      "dataset": "CIFAR-100",
+      "ipc": 1,
+      "rows": 100
+    },
+    {
+      "method": "CVDD",
+      "dataset": "CIFAR-100",
+      "ipc": 10,
+      "rows": 1000
+    },
+    {
+      "method": "CVDD",
+      "dataset": "CIFAR-100",
+      "ipc": 50,
+      "rows": 5000
+    },
+    {
+      "method": "CVDD",
+      "dataset": "ImageNet-1K",
+      "ipc": 1,
+      "rows": 1000
+    },
+    {
+      "method": "CVDD",
+      "dataset": "ImageNet-1K",
+      "ipc": 10,
+      "rows": 10000
+    },
+    {
+      "method": "CVDD",
+      "dataset": "ImageNet-1K",
+      "ipc": 50,
+      "rows": 50000
+    },
+    {
+      "method": "CVDD",
+      "dataset": "ImageNette",
+      "ipc": 1,
+      "rows": 10
+    },
+    {
+      "method": "CVDD",
+      "dataset": "ImageNette",
+      "ipc": 10,
+      "rows": 100
+    },
+    {
+      "method": "CVDD",
+      "dataset": "ImageNette",
+      "ipc": 50,
+      "rows": 500
+    },
+    {
+      "method": "CVDD",
+      "dataset": "TinyImageNet-200",
+      "ipc": 1,
+      "rows": 200
+    },
+    {
+      "method": "CVDD",
+      "dataset": "TinyImageNet-200",
+      "ipc": 10,
+      "rows": 2000
+    },
+    {
+      "method": "CVDD",
+      "dataset": "TinyImageNet-200",
+      "ipc": 50,
+      "rows": 10000
+    },
+    {
+      "method": "DC",
+      "dataset": "CIFAR-10",
+      "ipc": 1,
+      "rows": 10
+    },
+    {
+      "method": "DC",
+      "dataset": "CIFAR-10",
+      "ipc": 10,
+      "rows": 100
+    },
+    {
+      "method": "DC",
+      "dataset": "CIFAR-10",
+      "ipc": 50,
+      "rows": 500
+    },
+    {
+      "method": "DC",
+      "dataset": "CIFAR-100",
+      "ipc": 1,
+      "rows": 100
+    },
+    {
+      "method": "DC",
+      "dataset": "CIFAR-100",
+      "ipc": 10,
+      "rows": 1000
+    },
+    {
+      "method": "DC",
+      "dataset": "CIFAR-100",
+      "ipc": 50,
+      "rows": 5000
+    },
+    {
+      "method": "DM",
+      "dataset": "CIFAR-10",
+      "ipc": 1,
+      "rows": 10
+    },
+    {
+      "method": "DM",
+      "dataset": "CIFAR-10",
+      "ipc": 10,
+      "rows": 100
+    },
+    {
+      "method": "DM",
+      "dataset": "CIFAR-10",
+      "ipc": 50,
+      "rows": 500
+    },
+    {
+      "method": "DM",
+      "dataset": "CIFAR-100",
+      "ipc": 1,
+      "rows": 100
+    },
+    {
+      "method": "DM",
+      "dataset": "CIFAR-100",
+      "ipc": 10,
+      "rows": 1000
+    },
+    {
+      "method": "DM",
+      "dataset": "CIFAR-100",
+      "ipc": 50,
+      "rows": 5000
+    },
+    {
+      "method": "DSA",
+      "dataset": "CIFAR-10",
+      "ipc": 1,
+      "rows": 10
+    },
+    {
+      "method": "DSA",
+      "dataset": "CIFAR-10",
+      "ipc": 10,
+      "rows": 100
+    },
+    {
+      "method": "DSA",
+      "dataset": "CIFAR-10",
+      "ipc": 50,
+      "rows": 500
+    },
+    {
+      "method": "DSA",
+      "dataset": "CIFAR-100",
+      "ipc": 1,
+      "rows": 100
+    },
+    {
+      "method": "DSA",
+      "dataset": "CIFAR-100",
+      "ipc": 10,
+      "rows": 1000
+    },
+    {
+      "method": "DSA",
+      "dataset": "CIFAR-100",
+      "ipc": 50,
+      "rows": 5000
+    },
+    {
+      "method": "FreD",
+      "dataset": "CIFAR-10",
+      "ipc": 1,
+      "rows": 160
+    },
+    {
+      "method": "FreD",
+      "dataset": "CIFAR-10",
+      "ipc": 10,
+      "rows": 640
+    },
+    {
+      "method": "FreD",
+      "dataset": "CIFAR-10",
+      "ipc": 50,
+      "rows": 2000
+    },
+    {
+      "method": "FreD",
+      "dataset": "CIFAR-100",
+      "ipc": 1,
+      "rows": 800
+    },
+    {
+      "method": "FreD",
+      "dataset": "CIFAR-100",
+      "ipc": 10,
+      "rows": 1000
+    },
+    {
+      "method": "FreD",
+      "dataset": "CIFAR-100",
+      "ipc": 50,
+      "rows": 5000
+    },
+    {
+      "method": "FreD",
+      "dataset": "ImageNette",
+      "ipc": 1,
+      "rows": 80
+    },
+    {
+      "method": "FreD",
+      "dataset": "ImageNette",
+      "ipc": 10,
+      "rows": 400
+    },
+    {
+      "method": "FreD",
+      "dataset": "TinyImageNet-200",
+      "ipc": 1,
+      "rows": 1600
+    },
+    {
+      "method": "GVBSM",
+      "dataset": "CIFAR-10",
+      "ipc": 1,
+      "rows": 10
+    },
+    {
+      "method": "GVBSM",
+      "dataset": "CIFAR-10",
+      "ipc": 10,
+      "rows": 100
+    },
+    {
+      "method": "GVBSM",
+      "dataset": "CIFAR-10",
+      "ipc": 50,
+      "rows": 500
+    },
+    {
+      "method": "GVBSM",
+      "dataset": "CIFAR-100",
+      "ipc": 1,
+      "rows": 100
+    },
+    {
+      "method": "GVBSM",
+      "dataset": "CIFAR-100",
+      "ipc": 10,
+      "rows": 1000
+    },
+    {
+      "method": "GVBSM",
+      "dataset": "CIFAR-100",
+      "ipc": 50,
+      "rows": 5000
+    },
+    {
+      "method": "GVBSM",
+      "dataset": "ImageNet-1K",
+      "ipc": 1,
+      "rows": 1000
+    },
+    {
+      "method": "GVBSM",
+      "dataset": "ImageNet-1K",
+      "ipc": 10,
+      "rows": 10000
+    },
+    {
+      "method": "GVBSM",
+      "dataset": "ImageNet-1K",
+      "ipc": 50,
+      "rows": 50000
+    },
+    {
+      "method": "GVBSM",
+      "dataset": "TinyImageNet-200",
+      "ipc": 1,
+      "rows": 200
+    },
+    {
+      "method": "GVBSM",
+      "dataset": "TinyImageNet-200",
+      "ipc": 10,
+      "rows": 2000
+    },
+    {
+      "method": "GVBSM",
+      "dataset": "TinyImageNet-200",
+      "ipc": 50,
+      "rows": 10000
+    },
+    {
+      "method": "MTT",
+      "dataset": "CIFAR-10",
+      "ipc": 1,
+      "rows": 10
+    },
+    {
+      "method": "MTT",
+      "dataset": "CIFAR-10",
+      "ipc": 10,
+      "rows": 100
+    },
+    {
+      "method": "MTT",
+      "dataset": "CIFAR-10",
+      "ipc": 50,
+      "rows": 500
+    },
+    {
+      "method": "MTT",
+      "dataset": "CIFAR-100",
+      "ipc": 1,
+      "rows": 100
+    },
+    {
+      "method": "MTT",
+      "dataset": "CIFAR-100",
+      "ipc": 10,
+      "rows": 1000
+    },
+    {
+      "method": "MTT",
+      "dataset": "CIFAR-100",
+      "ipc": 50,
+      "rows": 5000
+    },
+    {
+      "method": "MTT",
+      "dataset": "ImageNette",
+      "ipc": 1,
+      "rows": 10
+    },
+    {
+      "method": "MTT",
+      "dataset": "ImageNette",
+      "ipc": 10,
+      "rows": 100
+    },
+    {
+      "method": "MTT",
+      "dataset": "TinyImageNet-200",
+      "ipc": 1,
+      "rows": 200
+    },
+    {
+      "method": "MTT",
+      "dataset": "TinyImageNet-200",
+      "ipc": 10,
+      "rows": 2000
+    },
+    {
+      "method": "MTT",
+      "dataset": "TinyImageNet-200",
+      "ipc": 50,
+      "rows": 10000
+    },
+    {
+      "method": "NCFM",
+      "dataset": "CIFAR-10",
+      "ipc": 1,
+      "rows": 40
+    },
+    {
+      "method": "NCFM",
+      "dataset": "CIFAR-10",
+      "ipc": 10,
+      "rows": 400
+    },
+    {
+      "method": "NCFM",
+      "dataset": "CIFAR-10",
+      "ipc": 50,
+      "rows": 2000
+    },
+    {
+      "method": "NCFM",
+      "dataset": "CIFAR-100",
+      "ipc": 1,
+      "rows": 400
+    },
+    {
+      "method": "NCFM",
+      "dataset": "CIFAR-100",
+      "ipc": 10,
+      "rows": 4000
+    },
+    {
+      "method": "NCFM",
+      "dataset": "CIFAR-100",
+      "ipc": 50,
+      "rows": 20000
+    },
+    {
+      "method": "NCFM",
+      "dataset": "ImageNette",
+      "ipc": 1,
+      "rows": 40
+    },
+    {
+      "method": "NCFM",
+      "dataset": "ImageNette",
+      "ipc": 10,
+      "rows": 400
+    },
+    {
+      "method": "NCFM",
+      "dataset": "ImageNette",
+      "ipc": 50,
+      "rows": 2000
+    },
+    {
+      "method": "NCFM",
+      "dataset": "TinyImageNet-200",
+      "ipc": 1,
+      "rows": 800
+    },
+    {
+      "method": "NCFM",
+      "dataset": "TinyImageNet-200",
+      "ipc": 10,
+      "rows": 8000
+    },
+    {
+      "method": "NCFM",
+      "dataset": "TinyImageNet-200",
+      "ipc": 50,
+      "rows": 40000
+    },
+    {
+      "method": "SCDD",
+      "dataset": "CIFAR-10",
+      "ipc": 1,
+      "rows": 10
+    },
+    {
+      "method": "SCDD",
+      "dataset": "CIFAR-10",
+      "ipc": 10,
+      "rows": 100
+    },
+    {
+      "method": "SCDD",
+      "dataset": "CIFAR-10",
+      "ipc": 50,
+      "rows": 500
+    },
+    {
+      "method": "SCDD",
+      "dataset": "CIFAR-100",
+      "ipc": 1,
+      "rows": 100
+    },
+    {
+      "method": "SCDD",
+      "dataset": "CIFAR-100",
+      "ipc": 10,
+      "rows": 1000
+    },
+    {
+      "method": "SCDD",
+      "dataset": "CIFAR-100",
+      "ipc": 50,
+      "rows": 5000
+    },
+    {
+      "method": "SRe2L",
+      "dataset": "ImageNet-1K",
+      "ipc": 1,
+      "rows": 1000
+    },
+    {
+      "method": "SRe2L",
+      "dataset": "ImageNet-1K",
+      "ipc": 10,
+      "rows": 10000
+    },
+    {
+      "method": "SRe2L",
+      "dataset": "ImageNet-1K",
+      "ipc": 50,
+      "rows": 50000
+    },
+    {
+      "method": "SRe2L",
+      "dataset": "TinyImageNet-200",
+      "ipc": 1,
+      "rows": 200
+    },
+    {
+      "method": "SRe2L",
+      "dataset": "TinyImageNet-200",
+      "ipc": 10,
+      "rows": 2000
+    },
+    {
+      "method": "SRe2L",
+      "dataset": "TinyImageNet-200",
+      "ipc": 50,
+      "rows": 10000
+    },
+    {
+      "method": "TESLA",
+      "dataset": "CIFAR-10",
+      "ipc": 1,
+      "rows": 10
+    },
+    {
+      "method": "TESLA",
+      "dataset": "CIFAR-10",
+      "ipc": 10,
+      "rows": 100
+    },
+    {
+      "method": "TESLA",
+      "dataset": "CIFAR-10",
+      "ipc": 50,
+      "rows": 500
+    },
+    {
+      "method": "TESLA",
+      "dataset": "CIFAR-100",
+      "ipc": 1,
+      "rows": 100
+    },
+    {
+      "method": "TESLA",
+      "dataset": "CIFAR-100",
+      "ipc": 10,
+      "rows": 1000
+    },
+    {
+      "method": "TESLA",
+      "dataset": "CIFAR-100",
+      "ipc": 50,
+      "rows": 5000
+    },
+    {
+      "method": "TESLA",
+      "dataset": "ImageNette",
+      "ipc": 1,
+      "rows": 10
+    },
+    {
+      "method": "TESLA",
+      "dataset": "ImageNette",
+      "ipc": 10,
+      "rows": 100
+    },
+    {
+      "method": "TESLA",
+      "dataset": "TinyImageNet-200",
+      "ipc": 1,
+      "rows": 200
+    },
+    {
+      "method": "TESLA",
+      "dataset": "TinyImageNet-200",
+      "ipc": 10,
+      "rows": 2000
+    },
+    {
+      "method": "TESLA",
+      "dataset": "TinyImageNet-200",
+      "ipc": 50,
+      "rows": 10000
+    },
+    {
+      "method": "WMDD",
+      "dataset": "ImageNet-1K",
+      "ipc": 1,
+      "rows": 1000
+    },
+    {
+      "method": "WMDD",
+      "dataset": "ImageNet-1K",
+      "ipc": 10,
+      "rows": 10000
+    },
+    {
+      "method": "WMDD",
+      "dataset": "ImageNet-1K",
+      "ipc": 50,
+      "rows": 50000
+    },
+    {
+      "method": "WMDD",
+      "dataset": "ImageNette",
+      "ipc": 10,
+      "rows": 100
+    },
+    {
+      "method": "WMDD",
+      "dataset": "ImageNette",
+      "ipc": 50,
+      "rows": 500
+    },
+    {
+      "method": "WMDD",
+      "dataset": "TinyImageNet-200",
+      "ipc": 1,
+      "rows": 200
+    },
+    {
+      "method": "WMDD",
+      "dataset": "TinyImageNet-200",
+      "ipc": 10,
+      "rows": 2000
+    },
+    {
+      "method": "WMDD",
+      "dataset": "TinyImageNet-200",
+      "ipc": 50,
+      "rows": 10000
+    }
+  ],
+  "teachers_present": [
+    {
+      "provider": "CVDD",
+      "dataset": "CIFAR-10",
+      "architecture": "ResNet18",
+      "used_by": [
+        "CVDD"
+      ],
+      "source_path": "other_pretrained_models/CVDD/cifar10/ResNet18.pth",
+      "sha256": "66a048c98d0601ad83e0ecdaf63ef27bc0082a56c1b53624314fb529ea28b6f7",
+      "byte_size": 44774524,
+      "source_archive": "other_pretrained_models.tar"
+    },
+    {
+      "provider": "CVDD",
+      "dataset": "CIFAR-100",
+      "architecture": "ResNet18",
+      "used_by": [
+        "CVDD"
+      ],
+      "source_path": "other_pretrained_models/CVDD/cifar100/ResNet18.pth",
+      "sha256": "5552a974472866a840b9b59f3af2226238de655fe9ab8a28d62db42d8a443249",
+      "byte_size": 44959228,
+      "source_archive": "other_pretrained_models.tar"
+    },
+    {
+      "provider": "GVBSM",
+      "dataset": "CIFAR-10",
+      "architecture": "ResNet18",
+      "used_by": [
+        "GVBSM"
+      ],
+      "source_path": "other_pretrained_models/GVBSM/CIFAR-10/ResNet18/squeeze_ResNet18.pth",
+      "sha256": "cf1769dca8a063c5e9dce66f7a622f92582035852c412d5539b7723f8166cc07",
+      "byte_size": 44775145,
+      "source_archive": "other_pretrained_models.tar"
+    },
+    {
+      "provider": "GVBSM",
+      "dataset": "CIFAR-100",
+      "architecture": "ResNet18",
+      "used_by": [
+        "GVBSM"
+      ],
+      "source_path": "other_pretrained_models/GVBSM/CIFAR-100/ResNet18/squeeze_ResNet18.pth",
+      "sha256": "078064217ad9c590589a9d6bd01d3aec3681bcd0c19266b2793994f7f4dc74d5",
+      "byte_size": 44960300,
+      "source_archive": "other_pretrained_models.tar"
+    },
+    {
+      "provider": "WMDD",
+      "dataset": "TinyImageNet-200",
+      "architecture": "ResNet18",
+      "used_by": [
+        "WMDD"
+      ],
+      "source_path": "other_pretrained_models/WMDD/tiny-imagenet_model_49.pth",
+      "sha256": "18f2eca0e6738f29718c7810823a408fba39c3e4a70fac2c091734ecddfb5755",
+      "byte_size": 90270731,
+      "source_archive": "other_pretrained_models.tar"
+    },
+    {
+      "provider": "WMDD",
+      "dataset": "ImageNette",
+      "architecture": "ResNet18",
+      "used_by": [
+        "WMDD"
+      ],
+      "source_path": "other_pretrained_models/WMDD/imagenette_model_49.pth",
+      "sha256": "9dab362ef2b5bd85f0ae43dea3316404eba83c5f25ea1f404978c0b0d0982634",
+      "byte_size": 89552767,
+      "source_archive": "other_pretrained_models.tar"
+    }
+  ],
+  "teachers_missing_from_source_archives": [
+    "other_pretrained_models/GVBSM/tiny/ResNet18/squeeze_ResNet18.pth",
+    "other_pretrained_models/SRe2L/cifar10/ckpt.pth",
+    "other_pretrained_models/SRe2L/cifar100/ckpt.pth",
+    "torchvision official ResNet-18 checkpoint (runtime dependency)"
+  ],
+  "shards": [
+    {
+      "asset_type": "image",
+      "relative_path": "data/images/ATT/train-00000.parquet",
+      "method_or_provider": "ATT",
+      "row_count": 19020,
+      "payload_bytes": 143450156,
+      "parquet_bytes": 144187670,
+      "sha256": "4d8ec682f6246c1904ea9ffd0d6b8b893e5561c4f3610606329a1166a1ec4ba5"
+    },
+    {
+      "asset_type": "image",
+      "relative_path": "data/images/CVDD/train-00000.parquet",
+      "method_or_provider": "CVDD",
+      "row_count": 41422,
+      "payload_bytes": 471846325,
+      "parquet_bytes": 448884548,
+      "sha256": "9a5a12497cd5083818e15ec6d6c51fd215d881d6c0b9f642292ee88cbbf643da"
+    },
+    {
+      "asset_type": "image",
+      "relative_path": "data/images/CVDD/train-00001.parquet",
+      "method_or_provider": "CVDD",
+      "row_count": 39098,
+      "payload_bytes": 390477930,
+      "parquet_bytes": 368743985,
+      "sha256": "efee8eadd62da3f03cd263124eaef6ee89e5eb8d2730a732be19d904c4a06a0d"
+    },
+    {
+      "asset_type": "image",
+      "relative_path": "data/images/DC/train-00000.parquet",
+      "method_or_provider": "DC",
+      "row_count": 6710,
+      "payload_bytes": 19142510,
+      "parquet_bytes": 19358788,
+      "sha256": "97a54095a2e00e62782843b27fa6e585aad8b2577c8b94c3e26654f78e705609"
+    },
+    {
+      "asset_type": "image",
+      "relative_path": "data/images/DM/train-00000.parquet",
+      "method_or_provider": "DM",
+      "row_count": 6710,
+      "payload_bytes": 16358180,
+      "parquet_bytes": 16455166,
+      "sha256": "64108a75645475c11d22712d1489da273db9d4cba53766c1ada7b08c077febcd"
+    },
+    {
+      "asset_type": "image",
+      "relative_path": "data/images/DSA/train-00000.parquet",
+      "method_or_provider": "DSA",
+      "row_count": 6710,
+      "payload_bytes": 16896533,
+      "parquet_bytes": 16989162,
+      "sha256": "03df00831c952c35033ffab53bfe9c203d83c93368c33ae4827cbbaa300b34bc"
+    },
+    {
+      "asset_type": "image",
+      "relative_path": "data/images/FreD/train-00000.parquet",
+      "method_or_provider": "FreD",
+      "row_count": 11680,
+      "payload_bytes": 53842603,
+      "parquet_bytes": 54055670,
+      "sha256": "4dd418c058b144836789c361e5d8b34685ded7fb8c938f69b1edfd1b1aa76336"
+    },
+    {
+      "asset_type": "image",
+      "relative_path": "data/images/GVBSM/train-00000.parquet",
+      "method_or_provider": "GVBSM",
+      "row_count": 33007,
+      "payload_bytes": 471855842,
+      "parquet_bytes": 457709994,
+      "sha256": "e15dc16c845ed3854c25f4d8301b82e904fdaef1e39b428778943abdfa3fe891"
+    },
+    {
+      "asset_type": "image",
+      "relative_path": "data/images/GVBSM/train-00001.parquet",
+      "method_or_provider": "GVBSM",
+      "row_count": 27366,
+      "payload_bytes": 471857746,
+      "parquet_bytes": 456948167,
+      "sha256": "1d601a22693b0cadbdaca76478a38a93e5d043eaf1937432317ad6c2010b9874"
+    },
+    {
+      "asset_type": "image",
+      "relative_path": "data/images/GVBSM/train-00002.parquet",
+      "method_or_provider": "GVBSM",
+      "row_count": 19537,
+      "payload_bytes": 249211679,
+      "parquet_bytes": 245845521,
+      "sha256": "db7f1c0664ddd12c84ae3eb276de6499a1b9a9c7248a6638c7c9fe71a6a5f19b"
+    },
+    {
+      "asset_type": "image",
+      "relative_path": "data/images/MTT/train-00000.parquet",
+      "method_or_provider": "MTT",
+      "row_count": 19020,
+      "payload_bytes": 142286162,
+      "parquet_bytes": 143014119,
+      "sha256": "2ef7c74d5efeefe9830938d94c1ad8c057d891a849825d80c9af5a71493e3e7d"
+    },
+    {
+      "asset_type": "image",
+      "relative_path": "data/images/NCFM/train-00000.parquet",
+      "method_or_provider": "NCFM",
+      "row_count": 70535,
+      "payload_bytes": 471851561,
+      "parquet_bytes": 474299273,
+      "sha256": "1b00235ce8acafeaf2e62b11089417058ebfe548a15cea823504555c6acd89f0"
+    },
+    {
+      "asset_type": "image",
+      "relative_path": "data/images/NCFM/train-00001.parquet",
+      "method_or_provider": "NCFM",
+      "row_count": 7545,
+      "payload_bytes": 63689314,
+      "parquet_bytes": 64057880,
+      "sha256": "b9985d85fdb3e273e85eae8c7aa8aca391e2dbf1655ed4bdb2cabff5a2270070"
+    },
+    {
+      "asset_type": "image",
+      "relative_path": "data/images/SCDD/train-00000.parquet",
+      "method_or_provider": "SCDD",
+      "row_count": 6710,
+      "payload_bytes": 6621146,
+      "parquet_bytes": 2745229,
+      "sha256": "13985e2f585167c093153885e5e3805d7b02707352f65f926084c3bee209f71c"
+    },
+    {
+      "asset_type": "image",
+      "relative_path": "data/images/SRe2L/train-00000.parquet",
+      "method_or_provider": "SRe2L",
+      "row_count": 34222,
+      "payload_bytes": 471852649,
+      "parquet_bytes": 453065586,
+      "sha256": "66551601cd07bc68fe34e2ed666048c665a44d582592ac66793f25e1a17a4d5f"
+    },
+    {
+      "asset_type": "image",
+      "relative_path": "data/images/SRe2L/train-00001.parquet",
+      "method_or_provider": "SRe2L",
+      "row_count": 38978,
+      "payload_bytes": 395288099,
+      "parquet_bytes": 373629020,
+      "sha256": "4bd9dade77da4e03bb7286b53ed5d926609d4f2eacad1dc29d8d77dbd73ee081"
+    },
+    {
+      "asset_type": "image",
+      "relative_path": "data/images/TESLA/train-00000.parquet",
+      "method_or_provider": "TESLA",
+      "row_count": 19020,
+      "payload_bytes": 134559924,
+      "parquet_bytes": 135270981,
+      "sha256": "8ae7f3e06a153e26c35f93ac0fab85ee9ecafea998b34bef208b04ffcae96010"
+    },
+    {
+      "asset_type": "image",
+      "relative_path": "data/images/WMDD/train-00000.parquet",
+      "method_or_provider": "WMDD",
+      "row_count": 30714,
+      "payload_bytes": 471840741,
+      "parquet_bytes": 454879577,
+      "sha256": "0826ba776b879a4c4d39615db4a6956dbb6b36a70a25607af006ae90e1f82c56"
+    },
+    {
+      "asset_type": "image",
+      "relative_path": "data/images/WMDD/train-00001.parquet",
+      "method_or_provider": "WMDD",
+      "row_count": 28424,
+      "payload_bytes": 471841579,
+      "parquet_bytes": 456341996,
+      "sha256": "9fc15d9fe4e33431eac96f4d769e79786119f3b4a77648479f017b089cf5c007"
+    },
+    {
+      "asset_type": "image",
+      "relative_path": "data/images/WMDD/train-00002.parquet",
+      "method_or_provider": "WMDD",
+      "row_count": 14662,
+      "payload_bytes": 240723899,
+      "parquet_bytes": 232726403,
+      "sha256": "57f35513a1eea6eb0b70c63662c54a8b4ccc6b856097a91055d97689999c1223"
+    },
+    {
+      "asset_type": "teacher",
+      "relative_path": "data/teachers/wmdd-tinyimagenet-200-resnet18.parquet",
+      "method_or_provider": "WMDD",
+      "row_count": 1,
+      "payload_bytes": 90270731,
+      "parquet_bytes": 83614972,
+      "sha256": "7d7c715e118ced55d59dbb2bf69ab176f1ec6606324d368aa835470b1202ac98"
+    },
+    {
+      "asset_type": "teacher",
+      "relative_path": "data/teachers/wmdd-imagenette-resnet18.parquet",
+      "method_or_provider": "WMDD",
+      "row_count": 1,
+      "payload_bytes": 89552767,
+      "parquet_bytes": 82873021,
+      "sha256": "b3c599d2fd589fca8924997cbce6525dfc41f769de7e0055dd3dcba10081550f"
+    },
+    {
+      "asset_type": "teacher",
+      "relative_path": "data/teachers/gvbsm-cifar-10-resnet18.parquet",
+      "method_or_provider": "GVBSM",
+      "row_count": 1,
+      "payload_bytes": 44775145,
+      "parquet_bytes": 41478988,
+      "sha256": "e22d98dbee1de036d04e4400591b4c7af11877d9acb83d68b482463255da8f99"
+    },
+    {
+      "asset_type": "teacher",
+      "relative_path": "data/teachers/gvbsm-cifar-100-resnet18.parquet",
+      "method_or_provider": "GVBSM",
+      "row_count": 1,
+      "payload_bytes": 44960300,
+      "parquet_bytes": 41594776,
+      "sha256": "e5bc9cc418a3bd7d644e022600deeb663b892fb0931fad9d1e0cae8855f623f7"
+    },
+    {
+      "asset_type": "teacher",
+      "relative_path": "data/teachers/cvdd-cifar-100-resnet18.parquet",
+      "method_or_provider": "CVDD",
+      "row_count": 1,
+      "payload_bytes": 44959228,
+      "parquet_bytes": 41902811,
+      "sha256": "82b49f7472d7127ac4d3e957d60fcd915454b0e4a9c138e4b9f8abe4a76aa89f"
+    },
+    {
+      "asset_type": "teacher",
+      "relative_path": "data/teachers/cvdd-cifar-10-resnet18.parquet",
+      "method_or_provider": "CVDD",
+      "row_count": 1,
+      "payload_bytes": 44774524,
+      "parquet_bytes": 28640044,
+      "sha256": "3e010e7e3867545871a4afd6632b96f4e9ea1566ee37c40af95e82a031376d22"
+    }
+  ]
+}

convert_assets.py

@@ -0,0 +1,633 @@
+#!/usr/bin/env python3
+"""Convert DataDistillBed image folders and selected ResNet teachers to Parquet.
+
+The conversion is byte-preserving: compressed image bytes and checkpoint bytes are
+stored directly in binary Parquet columns.  The script validates the exact physical
+image counts found during the archive audit and records SHA-256 digests for every
+payload and output shard.
+"""
+
+from __future__ import annotations
+
+import argparse
+import collections
+import datetime as dt
+import hashlib
+import json
+import os
+import re
+import tarfile
+from pathlib import Path, PurePosixPath
+from typing import Any, Iterable
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+
+DATASET_ALIASES = {
+    "cifar10": "CIFAR-10",
+    "cifar100": "CIFAR-100",
+    "tiny": "TinyImageNet-200",
+    "imagenette": "ImageNette",
+    "imagenette128": "ImageNette",
+    "imagenet": "ImageNet-1K",
+}
+
+NUM_CLASSES = {
+    "CIFAR-10": 10,
+    "CIFAR-100": 100,
+    "TinyImageNet-200": 200,
+    "ImageNette": 10,
+    "ImageNet-1K": 1000,
+}
+
+STANDARD_GROUPS = {
+    "DC": {"CIFAR-10": (1, 10, 50), "CIFAR-100": (1, 10, 50)},
+    "DM": {"CIFAR-10": (1, 10, 50), "CIFAR-100": (1, 10, 50)},
+    "DSA": {"CIFAR-10": (1, 10, 50), "CIFAR-100": (1, 10, 50)},
+    "ATT": {
+        "CIFAR-10": (1, 10, 50),
+        "CIFAR-100": (1, 10, 50),
+        "TinyImageNet-200": (1, 10, 50),
+        "ImageNette": (1, 10),
+    },
+    "MTT": {
+        "CIFAR-10": (1, 10, 50),
+        "CIFAR-100": (1, 10, 50),
+        "TinyImageNet-200": (1, 10, 50),
+        "ImageNette": (1, 10),
+    },
+    "TESLA": {
+        "CIFAR-10": (1, 10, 50),
+        "CIFAR-100": (1, 10, 50),
+        "TinyImageNet-200": (1, 10, 50),
+        "ImageNette": (1, 10),
+    },
+    "CVDD": {
+        "CIFAR-10": (1, 10, 50),
+        "CIFAR-100": (1, 10, 50),
+        "TinyImageNet-200": (1, 10, 50),
+        "ImageNette": (1, 10, 50),
+        "ImageNet-1K": (1, 10, 50),
+    },
+    "GVBSM": {
+        "CIFAR-10": (1, 10, 50),
+        "CIFAR-100": (1, 10, 50),
+        "TinyImageNet-200": (1, 10, 50),
+        "ImageNet-1K": (1, 10, 50),
+    },
+    "SCDD": {"CIFAR-10": (1, 10, 50), "CIFAR-100": (1, 10, 50)},
+    "SRe2L": {
+        "TinyImageNet-200": (1, 10, 50),
+        "ImageNet-1K": (1, 10, 50),
+    },
+    "WMDD": {
+        "TinyImageNet-200": (1, 10, 50),
+        "ImageNette": (10, 50),
+        "ImageNet-1K": (1, 10, 50),
+    },
+}
+
+FRED_COUNTS = {
+    ("CIFAR-10", 1): 160,
+    ("CIFAR-10", 10): 640,
+    ("CIFAR-10", 50): 2000,
+    ("CIFAR-100", 1): 800,
+    ("CIFAR-100", 10): 1000,
+    ("CIFAR-100", 50): 5000,
+    ("TinyImageNet-200", 1): 1600,
+    ("ImageNette", 1): 80,
+    ("ImageNette", 10): 400,
+}
+
+NCFM_GROUPS = {
+    "CIFAR-10": (1, 10, 50),
+    "CIFAR-100": (1, 10, 50),
+    "TinyImageNet-200": (1, 10, 50),
+    "ImageNette": (1, 10, 50),
+}
+
+TEACHERS = {
+    "other_pretrained_models/CVDD/cifar10/ResNet18.pth": {
+        "provider": "CVDD",
+        "dataset": "CIFAR-10",
+        "architecture": "ResNet18",
+        "used_by": ["CVDD"],
+    },
+    "other_pretrained_models/CVDD/cifar100/ResNet18.pth": {
+        "provider": "CVDD",
+        "dataset": "CIFAR-100",
+        "architecture": "ResNet18",
+        "used_by": ["CVDD"],
+    },
+    "other_pretrained_models/GVBSM/CIFAR-10/ResNet18/squeeze_ResNet18.pth": {
+        "provider": "GVBSM",
+        "dataset": "CIFAR-10",
+        "architecture": "ResNet18",
+        "used_by": ["GVBSM"],
+    },
+    "other_pretrained_models/GVBSM/CIFAR-100/ResNet18/squeeze_ResNet18.pth": {
+        "provider": "GVBSM",
+        "dataset": "CIFAR-100",
+        "architecture": "ResNet18",
+        "used_by": ["GVBSM"],
+    },
+    "other_pretrained_models/WMDD/tiny-imagenet_model_49.pth": {
+        "provider": "WMDD",
+        "dataset": "TinyImageNet-200",
+        "architecture": "ResNet18",
+        "used_by": ["WMDD"],
+    },
+    "other_pretrained_models/WMDD/imagenette_model_49.pth": {
+        "provider": "WMDD",
+        "dataset": "ImageNette",
+        "architecture": "ResNet18",
+        "used_by": ["WMDD"],
+    },
+}
+
+MISSING_TEACHERS = [
+    "other_pretrained_models/GVBSM/tiny/ResNet18/squeeze_ResNet18.pth",
+    "other_pretrained_models/SRe2L/cifar10/ckpt.pth",
+    "other_pretrained_models/SRe2L/cifar100/ckpt.pth",
+    "torchvision official ResNet-18 checkpoint (runtime dependency)",
+]
+
+IMAGE_SCHEMA = pa.schema(
+    [
+        pa.field("method", pa.string(), nullable=False),
+        pa.field("dataset", pa.string(), nullable=False),
+        pa.field("ipc", pa.int32(), nullable=False),
+        pa.field("class_id", pa.int32(), nullable=False),
+        pa.field("image_id", pa.int32(), nullable=False),
+        pa.field("source_path", pa.string(), nullable=False),
+        pa.field("extension", pa.string(), nullable=False),
+        pa.field(
+            "image",
+            pa.struct(
+                [
+                    pa.field("bytes", pa.binary(), nullable=False),
+                    pa.field("path", pa.string(), nullable=False),
+                ]
+            ),
+            nullable=False,
+        ),
+        pa.field("sample_weight", pa.float64()),
+        pa.field("sha256", pa.string(), nullable=False),
+        pa.field("byte_size", pa.int64(), nullable=False),
+        pa.field("source_archive", pa.string(), nullable=False),
+    ]
+)
+
+TEACHER_SCHEMA = pa.schema(
+    [
+        pa.field("provider", pa.string(), nullable=False),
+        pa.field("dataset", pa.string(), nullable=False),
+        pa.field("architecture", pa.string(), nullable=False),
+        pa.field("used_by", pa.list_(pa.string()), nullable=False),
+        pa.field("source_path", pa.string(), nullable=False),
+        pa.field("checkpoint", pa.binary(), nullable=False),
+        pa.field("sha256", pa.string(), nullable=False),
+        pa.field("byte_size", pa.int64(), nullable=False),
+        pa.field("source_archive", pa.string(), nullable=False),
+    ]
+)
+
+SHARD_SCHEMA = pa.schema(
+    [
+        pa.field("asset_type", pa.string(), nullable=False),
+        pa.field("relative_path", pa.string(), nullable=False),
+        pa.field("method_or_provider", pa.string(), nullable=False),
+        pa.field("row_count", pa.int64(), nullable=False),
+        pa.field("payload_bytes", pa.int64(), nullable=False),
+        pa.field("parquet_bytes", pa.int64(), nullable=False),
+        pa.field("sha256", pa.string(), nullable=False),
+    ]
+)
+
+
+def sha256_file(path: Path, chunk_size: int = 8 * 1024 * 1024) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        while chunk := handle.read(chunk_size):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def normalized_tar_path(name: str) -> str:
+    value = name.replace("\\", "/")
+    while value.startswith("./"):
+        value = value[2:]
+    return value
+
+
+def parse_image_path(name: str) -> tuple[str, int, int, int, str]:
+    normalized = normalized_tar_path(name)
+    parts = PurePosixPath(normalized).parts
+    dataset = next(
+        (DATASET_ALIASES[p.lower()] for p in parts if p.lower() in DATASET_ALIASES),
+        None,
+    )
+    ipc_token = next((p for p in parts if re.fullmatch(r"ipc\d+", p.lower())), None)
+    class_token = next((p for p in parts if re.fullmatch(r"new\d+", p.lower())), None)
+    if dataset is None or ipc_token is None or class_token is None:
+        raise ValueError(f"Cannot parse dataset/ipc/class from {normalized!r}")
+
+    ipc = int(ipc_token[3:])
+    class_id = int(class_token[3:])
+    filename = parts[-1]
+    explicit = re.search(r"class(\d+)_id(\d+)", filename, flags=re.IGNORECASE)
+    generic = re.search(r"image_(\d+)", filename, flags=re.IGNORECASE)
+    if explicit:
+        filename_class = int(explicit.group(1))
+        if filename_class != class_id:
+            raise ValueError(
+                f"Directory class {class_id} disagrees with filename class "
+                f"{filename_class}: {normalized}"
+            )
+        image_id = int(explicit.group(2))
+    elif generic:
+        image_id = int(generic.group(1))
+    else:
+        raise ValueError(f"Cannot parse image id from {normalized!r}")
+
+    extension = Path(filename).suffix.lower()
+    if extension not in {".jpg", ".jpeg", ".png"}:
+        raise ValueError(f"Unsupported image extension in {normalized!r}")
+    return dataset, ipc, class_id, image_id, extension
+
+
+def expected_physical_counts() -> dict[tuple[str, str, int], int]:
+    result: dict[tuple[str, str, int], int] = {}
+    for method, datasets in STANDARD_GROUPS.items():
+        for dataset, ipcs in datasets.items():
+            for ipc in ipcs:
+                result[(method, dataset, ipc)] = NUM_CLASSES[dataset] * ipc
+    for (dataset, ipc), count in FRED_COUNTS.items():
+        result[("FreD", dataset, ipc)] = count
+    for dataset, ipcs in NCFM_GROUPS.items():
+        for ipc in ipcs:
+            result[("NCFM", dataset, ipc)] = NUM_CLASSES[dataset] * ipc * 4
+    return result
+
+
+def load_wmdd_weights(archive: Path) -> dict[tuple[str, int], list[list[float]]]:
+    result: dict[tuple[str, int], list[list[float]]] = {}
+    with tarfile.open(archive, "r:gz") as tf:
+        for member in tf:
+            if not member.isfile() or not member.name.endswith("sample_weights.txt"):
+                continue
+            dataset, ipc, _, _, _ = parse_weight_path(member.name)
+            extracted = tf.extractfile(member)
+            if extracted is None:
+                raise RuntimeError(f"Cannot extract {member.name}")
+            lines = extracted.read().decode("utf-8").splitlines()
+            matrix = [[float(value) for value in line.split()] for line in lines]
+            if len(matrix) != NUM_CLASSES[dataset]:
+                raise ValueError(f"Wrong class count in {member.name}: {len(matrix)}")
+            if any(len(row) != ipc for row in matrix):
+                raise ValueError(f"Wrong IPC width in {member.name}")
+            result[(dataset, ipc)] = matrix
+    return result
+
+
+def parse_weight_path(name: str) -> tuple[str, int, int, int, str]:
+    normalized = normalized_tar_path(name)
+    parts = PurePosixPath(normalized).parts
+    dataset = next(
+        (DATASET_ALIASES[p.lower()] for p in parts if p.lower() in DATASET_ALIASES),
+        None,
+    )
+    ipc_token = next((p for p in parts if re.fullmatch(r"ipc\d+", p.lower())), None)
+    if dataset is None or ipc_token is None:
+        raise ValueError(f"Cannot parse WMDD weight path {normalized!r}")
+    return dataset, int(ipc_token[3:]), 0, 0, ".txt"
+
+
+class ImageShardWriter:
+    def __init__(self, root: Path, method: str, target_bytes: int, batch_size: int):
+        self.root = root
+        self.method = method
+        self.target_bytes = target_bytes
+        self.batch_size = batch_size
+        self.shard_index = -1
+        self.writer: pq.ParquetWriter | None = None
+        self.path: Path | None = None
+        self.rows: list[dict[str, Any]] = []
+        self.rows_in_shard = 0
+        self.payload_in_shard = 0
+        self.records: list[dict[str, Any]] = []
+
+    def _open(self) -> None:
+        self.shard_index += 1
+        directory = self.root / "data" / "images" / self.method
+        directory.mkdir(parents=True, exist_ok=True)
+        self.path = directory / f"train-{self.shard_index:05d}.parquet"
+        if self.path.exists():
+            raise FileExistsError(f"Refusing to overwrite {self.path}")
+        self.writer = pq.ParquetWriter(
+            self.path,
+            IMAGE_SCHEMA,
+            compression="zstd",
+            compression_level=3,
+            use_dictionary=["method", "dataset", "extension", "source_archive"],
+            write_statistics=[
+                "method",
+                "dataset",
+                "ipc",
+                "class_id",
+                "image_id",
+                "sample_weight",
+                "byte_size",
+            ],
+            data_page_size=1024 * 1024,
+        )
+
+    def _flush_rows(self) -> None:
+        if not self.rows:
+            return
+        assert self.writer is not None
+        table = pa.Table.from_pylist(self.rows, schema=IMAGE_SCHEMA)
+        self.writer.write_table(table, row_group_size=self.batch_size)
+        self.rows.clear()
+
+    def _close(self) -> None:
+        if self.writer is None or self.path is None:
+            return
+        self._flush_rows()
+        self.writer.close()
+        parquet_file = pq.ParquetFile(self.path)
+        if parquet_file.metadata.num_rows != self.rows_in_shard:
+            raise RuntimeError(f"Row-count mismatch in {self.path}")
+        self.records.append(
+            {
+                "asset_type": "image",
+                "relative_path": self.path.relative_to(self.root).as_posix(),
+                "method_or_provider": self.method,
+                "row_count": self.rows_in_shard,
+                "payload_bytes": self.payload_in_shard,
+                "parquet_bytes": self.path.stat().st_size,
+                "sha256": sha256_file(self.path),
+            }
+        )
+        self.writer = None
+        self.path = None
+        self.rows_in_shard = 0
+        self.payload_in_shard = 0
+
+    def append(self, row: dict[str, Any]) -> None:
+        payload_size = int(row["byte_size"])
+        if self.writer is None:
+            self._open()
+        elif self.rows_in_shard and self.payload_in_shard + payload_size > self.target_bytes:
+            self._close()
+            self._open()
+        self.rows.append(row)
+        self.rows_in_shard += 1
+        self.payload_in_shard += payload_size
+        if len(self.rows) >= self.batch_size:
+            self._flush_rows()
+
+    def close(self) -> list[dict[str, Any]]:
+        self._close()
+        return self.records
+
+
+def convert_images(
+    inner_root: Path, output_root: Path, target_bytes: int, batch_size: int
+) -> tuple[list[dict[str, Any]], dict[tuple[str, str, int], int], int, int]:
+    expected = expected_physical_counts()
+    observed: collections.Counter[tuple[str, str, int]] = collections.Counter()
+    class_ids: dict[tuple[str, str, int], set[int]] = collections.defaultdict(set)
+    shard_records: list[dict[str, Any]] = []
+    total_payload = 0
+    total_rows = 0
+
+    archives = sorted(inner_root.glob("*.tar.gz"))
+    archive_methods = {path.name.removesuffix(".tar.gz") for path in archives}
+    expected_methods = set(STANDARD_GROUPS) | {"FreD", "NCFM"}
+    if archive_methods != expected_methods:
+        raise ValueError(
+            f"Method archives differ from checklist: found={sorted(archive_methods)}, "
+            f"expected={sorted(expected_methods)}"
+        )
+
+    for archive in archives:
+        method = archive.name.removesuffix(".tar.gz")
+        print(f"[images] {method}: reading {archive.name}", flush=True)
+        weights = load_wmdd_weights(archive) if method == "WMDD" else {}
+        writer = ImageShardWriter(output_root, method, target_bytes, batch_size)
+        with tarfile.open(archive, "r:gz") as tf:
+            for member in tf:
+                if not member.isfile():
+                    continue
+                normalized = normalized_tar_path(member.name)
+                suffix = Path(normalized).suffix.lower()
+                if suffix == ".txt" and normalized.endswith("sample_weights.txt"):
+                    if method != "WMDD":
+                        raise ValueError(f"Unexpected sample weights outside WMDD: {normalized}")
+                    continue
+                if suffix not in {".jpg", ".jpeg", ".png"}:
+                    raise ValueError(f"Unexpected non-image file in {archive.name}: {normalized}")
+
+                dataset, ipc, class_id, image_id, extension = parse_image_path(normalized)
+                key = (method, dataset, ipc)
+                if key not in expected:
+                    raise ValueError(f"Image group is not in the checklist: {key}")
+                if class_id < 0 or class_id >= NUM_CLASSES[dataset]:
+                    raise ValueError(f"Class id outside range in {normalized}")
+                extracted = tf.extractfile(member)
+                if extracted is None:
+                    raise RuntimeError(f"Cannot extract {normalized}")
+                payload = extracted.read()
+                if len(payload) != member.size:
+                    raise RuntimeError(
+                        f"Short read for {normalized}: {len(payload)} != {member.size}"
+                    )
+
+                sample_weight = None
+                if method == "WMDD":
+                    matrix = weights.get((dataset, ipc))
+                    if matrix is None:
+                        raise ValueError(f"Missing WMDD weights for {dataset} IPC {ipc}")
+                    if image_id < 0 or image_id >= ipc:
+                        raise ValueError(f"WMDD image id outside IPC range: {normalized}")
+                    sample_weight = matrix[class_id][image_id]
+
+                writer.append(
+                    {
+                        "method": method,
+                        "dataset": dataset,
+                        "ipc": ipc,
+                        "class_id": class_id,
+                        "image_id": image_id,
+                        "source_path": normalized,
+                        "extension": extension,
+                        "image": {"bytes": payload, "path": normalized},
+                        "sample_weight": sample_weight,
+                        "sha256": hashlib.sha256(payload).hexdigest(),
+                        "byte_size": len(payload),
+                        "source_archive": archive.name,
+                    }
+                )
+                observed[key] += 1
+                class_ids[key].add(class_id)
+                total_rows += 1
+                total_payload += len(payload)
+
+        shard_records.extend(writer.close())
+        method_rows = sum(value for key, value in observed.items() if key[0] == method)
+        print(f"[images] {method}: wrote {method_rows:,} rows", flush=True)
+
+    if dict(observed) != expected:
+        missing = {key: value for key, value in expected.items() if observed.get(key) != value}
+        extra = {key: value for key, value in observed.items() if expected.get(key) != value}
+        raise ValueError(f"Physical count validation failed; expected-diff={missing}, observed-diff={extra}")
+    for key in sorted(expected):
+        required = set(range(NUM_CLASSES[key[1]]))
+        if class_ids[key] != required:
+            raise ValueError(f"Class coverage validation failed for {key}")
+    return shard_records, dict(observed), total_rows, total_payload
+
+
+def teacher_filename(spec: dict[str, Any]) -> str:
+    values = [spec["provider"], spec["dataset"], spec["architecture"]]
+    return "-".join(re.sub(r"[^A-Za-z0-9]+", "-", value).strip("-") for value in values).lower()
+
+
+def convert_teachers(
+    archive: Path, output_root: Path
+) -> tuple[list[dict[str, Any]], list[dict[str, Any]], int]:
+    output_dir = output_root / "data" / "teachers"
+    output_dir.mkdir(parents=True, exist_ok=True)
+    found: dict[str, dict[str, Any]] = {}
+    shard_records: list[dict[str, Any]] = []
+    total_payload = 0
+
+    with tarfile.open(archive, "r:") as tf:
+        for member in tf:
+            if not member.isfile():
+                continue
+            normalized = normalized_tar_path(member.name)
+            spec = TEACHERS.get(normalized)
+            if spec is None:
+                continue
+            extracted = tf.extractfile(member)
+            if extracted is None:
+                raise RuntimeError(f"Cannot extract {normalized}")
+            payload = extracted.read()
+            if len(payload) != member.size:
+                raise RuntimeError(f"Short read for {normalized}")
+            digest = hashlib.sha256(payload).hexdigest()
+            output = output_dir / f"{teacher_filename(spec)}.parquet"
+            if output.exists():
+                raise FileExistsError(f"Refusing to overwrite {output}")
+            row = {
+                **spec,
+                "source_path": normalized,
+                "checkpoint": payload,
+                "sha256": digest,
+                "byte_size": len(payload),
+                "source_archive": archive.name,
+            }
+            table = pa.Table.from_pylist([row], schema=TEACHER_SCHEMA)
+            pq.write_table(
+                table,
+                output,
+                compression="zstd",
+                compression_level=1,
+                use_dictionary=["provider", "dataset", "architecture", "source_archive"],
+                write_statistics=["provider", "dataset", "architecture", "byte_size"],
+                data_page_size=1024 * 1024,
+            )
+            check = pq.read_table(output, columns=["sha256", "byte_size"]).to_pylist()[0]
+            if check["sha256"] != digest or check["byte_size"] != len(payload):
+                raise RuntimeError(f"Teacher Parquet verification failed for {output}")
+            found[normalized] = {key: value for key, value in row.items() if key != "checkpoint"}
+            total_payload += len(payload)
+            shard_records.append(
+                {
+                    "asset_type": "teacher",
+                    "relative_path": output.relative_to(output_root).as_posix(),
+                    "method_or_provider": spec["provider"],
+                    "row_count": 1,
+                    "payload_bytes": len(payload),
+                    "parquet_bytes": output.stat().st_size,
+                    "sha256": sha256_file(output),
+                }
+            )
+            print(f"[teacher] {normalized}: {len(payload):,} bytes", flush=True)
+
+    missing_present = sorted(set(TEACHERS) - set(found))
+    if missing_present:
+        raise ValueError(f"Checklist says teacher exists but archive lookup failed: {missing_present}")
+    return shard_records, [found[path] for path in TEACHERS], total_payload
+
+
+def write_manifest(output_root: Path, records: Iterable[dict[str, Any]]) -> None:
+    manifest_dir = output_root / "data" / "manifest"
+    manifest_dir.mkdir(parents=True, exist_ok=True)
+    output = manifest_dir / "shards.parquet"
+    if output.exists():
+        raise FileExistsError(f"Refusing to overwrite {output}")
+    table = pa.Table.from_pylist(list(records), schema=SHARD_SCHEMA)
+    pq.write_table(table, output, compression="zstd", compression_level=3)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--inner-root", required=True, type=Path)
+    parser.add_argument("--teacher-archive", required=True, type=Path)
+    parser.add_argument("--output-root", required=True, type=Path)
+    parser.add_argument("--target-shard-mib", type=int, default=450)
+    parser.add_argument("--batch-size", type=int, default=512)
+    args = parser.parse_args()
+
+    data_root = args.output_root / "data"
+    if data_root.exists() and any(data_root.rglob("*.parquet")):
+        raise FileExistsError(
+            f"Parquet output already exists under {data_root}; refusing to overwrite"
+        )
+    args.output_root.mkdir(parents=True, exist_ok=True)
+
+    image_shards, counts, image_rows, image_payload = convert_images(
+        args.inner_root,
+        args.output_root,
+        args.target_shard_mib * 1024 * 1024,
+        args.batch_size,
+    )
+    teacher_shards, teachers, teacher_payload = convert_teachers(
+        args.teacher_archive, args.output_root
+    )
+    all_shards = image_shards + teacher_shards
+    write_manifest(args.output_root, all_shards)
+
+    summary = {
+        "created_at_utc": dt.datetime.now(dt.timezone.utc).isoformat(),
+        "format": "byte-preserving Parquet",
+        "image_schema": str(IMAGE_SCHEMA),
+        "teacher_schema": str(TEACHER_SCHEMA),
+        "image_rows": image_rows,
+        "image_payload_bytes": image_payload,
+        "teacher_rows": len(teachers),
+        "teacher_payload_bytes": teacher_payload,
+        "image_group_counts": [
+            {"method": key[0], "dataset": key[1], "ipc": key[2], "rows": value}
+            for key, value in sorted(counts.items())
+        ],
+        "teachers_present": teachers,
+        "teachers_missing_from_source_archives": MISSING_TEACHERS,
+        "shards": all_shards,
+    }
+    summary_path = args.output_root / "conversion_summary.json"
+    summary_path.write_text(json.dumps(summary, ensure_ascii=False, indent=2), encoding="utf-8")
+    print(
+        f"[done] images={image_rows:,} ({image_payload:,} bytes), "
+        f"teachers={len(teachers)} ({teacher_payload:,} bytes), "
+        f"shards={len(all_shards)}",
+        flush=True,
+    )
+
+
+if __name__ == "__main__":
+    main()

data/manifest/shards.parquet

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