#!/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()