Passenger555/datadistillbed-raw-results

DataDistillBed — raw experiment results

Converted from the on-disk experiment trees described in DATA_AND_CODE.md, following 原始实验结果存储与重组建议.md. Supports In Search of Lost Consistency in Dataset Distillation (NeurIPS 2026).

Two layers:

• analysis layer — runs, one row per logical training attempt, typed;
• archival layer — raw_records + artifacts + manifest, byte-exact, so any original file can be rebuilt and re-checked against its SHA-256.

Every conversion is verified. verify.py rebuilt all 841,786 unique contents from the archival layer and matched every SHA-256 (0 mismatches), covering all 2,357,367 original files, re-read and re-hashed 3,000/3,000 originals straight off disk, and cross-checked 416,077/416,077 contents' line counts between runs and raw_records; repro_fig4.py recomputes the paper's Figure 4 from runs and reproduces all 8 origin + 26 distilled curves point-for-point against the JSON the published figure was made from. ~58 GiB and 2.4M files become 2.1 GB in four tables.

Tables

runs (default config)

One row per training attempt, not per checkpoint. results.jsonl is opened in append mode (train.py:304), so a re-run leaves the old curve in front of the new one; each such segment becomes its own row with attempt_index, and the highest attempt_index for a content_id is the current training.

column	meaning
run_id, content_id, attempt_index, n_attempts	identity
family, cell, source_path	provenance (see Families)
cell_dataset/method/epochs/ipc/model/suffix	parsed from the cell directory name
dataset, method, model, ipc, epochs_budget	resolved fields — the run's own args/hparams win, the cell name only fills in blanks
hparams_seed, trial_seed, seed	hparams_seed × trial_seed are 300 independent configurations, not 100 repeated 3×
args_json, hparams_json	full config, stored once per attempt instead of once per checkpoint
args_varied, hparams_varied	true if the config changed mid-file (it never should)
epoch, step, env0_in_acc, env0_out_acc, env1_in_acc, env1_out_acc, loss, mem_gb, step_time	per-checkpoint arrays, float64/int64
last_epoch, max_epoch, complete	completeness
final_acc, best_acc	last / max of env1_in_acc
n_checkpoints, n_lines, n_bad_lines	parse accounting

raw_records

content_id, family, line_index, raw_line — one row per line of every unique results.jsonl, as raw bytes. Preserves field order, number formatting, whitespace, the append history, and the difference between "key absent" and "value null". Join line_index ascending and "\n" to rebuild the file.

artifacts

content_id, family, artifact_type, content_bytes, n_bytes, sha256 — out.txt, err.txt, done, plus the case-study log.txt / results.txt / flops.txt. The 304,197 empty err.txt files collapse to a single row here.

manifest

One row per original file: source_path, container_kind (loose/tar/zip), container_path, member_path, cell, run_dir_hash, file_name, file_kind, n_bytes, sha256, content_id, first_seen. Several source_paths map to one content_id when the bytes are identical; first_seen marks the row that carried the content into the archival layer.

case_study_runs

The ConvNeXt roadmap and EfficientNet scaling experiments, which never went through the DomainBed harness and have no results.jsonl. Parsed from log.txt (JSON per epoch) and results.txt (Epoch 5: Loss=…, Test Acc=…%). Accuracies are fractions in [0,1]. is_canonical marks the row each figure should use — convnext_draw_pic_v5.py reads convnext_new/ first and falls back to the older tree, and that precedence is reproduced here.

Reading the data correctly

These rules are not optional; ignoring them produces wrong numbers.

• e{N} in a cell name is downstream training epochs, not distillation steps. The main repo's README.md and PROJECT_SKILL.txt say the opposite.
• Accuracy is env1_in_acc (final_acc here).
• Completeness is last_epoch >= epochs_budget - 1.5. Never trust the done marker: 28 of 1199 origin runs carry done while truncated. done is kept in artifacts for auditing, and is deliberately not used by complete.
• Aggregate with a global max, never a mean. Each cell is 100 hparams × 3 trial seeds = 300 independent configurations; trial_seed changes the data split, so it is part of the configuration.
• Images seen: origin = epoch × 50000; distilled = ipc × n_classes × epochs.
• Take the last attempt of a content_id unless you are studying re-runs.
• Label a run by its own args, not by the folder it sits in. cifar100_WMDDe300_ipc50_resnet_ holds 300 CIFAR-10 runs (295 complete) against 23 CIFAR-100 ones (22 complete) — the wrong tar was uploaded for that cell. dataset here already comes from the run, so those rows land under CIFAR-10 correctly; coverage.py prints such cells under mislabelled_cell so the relabelling is never silent. The paper's 0.6662 comes from the 22 real ones and is correct but conservative.
• The ResNet origin baseline is -resnet (KD=False), not resnetk — the baseline must not depend on a fixed teacher. resnetk is kept as a separate model value.

Families and version precedence

family is not a filter. Dedup is global and by content SHA-256, so a file that appears in several snapshots is one row carrying the first family that saw those bytes — 1,199 of the Figure-4 origin contents are labelled trick. Select by content_id via the manifest (as repro_fig4.py does) when you mean "the files in this tree"; family only records provenance.

family records which snapshot a row came from. The same experiment cell often exists in several; coverage.py resolves them with FAMILY_RANK, newest first, and writes data/selection_canonical.parquet holding one row per logical configuration. Identical bytes across snapshots are already a single content_id, so precedence only decides between genuinely different re-runs.

Order: trick (live tree) → cluster_scvl → aug → sep → trick_20260507 (May-7 snapshot) → the per-topic trees (cifar_convnet, cifar_resnet, subset_*, tiny_resnet, imagenet_resnet, tiny_origin_e100, nats, lr_exp, case_study, step) → the Figure-4 tars (fig4_origin, fig4_distilled) → the bundled zips → reproduction, gh_stage.

cluster_scvl sits below trick deliberately. Only cells the local trees lack entirely were pulled, so precedence has nothing to decide; ranking it there means no already-verified number can shift underneath the paper. All 85 of its data-bearing tars did turn out to be net-new (84 cells absent locally, one differing only by model), so no overlap arose.

Rebuilding

cd dmb_dataset/tools
python convert.py            # raw trees -> the four tables
python case_study.py         # ConvNeXt + EfficientNet -> case_study_runs.parquet
python verify.py             # SHA-256 round-trip, every file
python repro_fig4.py         # rebuild Figure 4 from parquet, diff vs published JSON
python coverage.py --report  # coverage matrix + canonical selection
python ipc_gap.py            # exploratory ipc sweep (superseded by paper_cells.py)
python paper_cells.py        # per-cell diff against the tables the paper prints
python nats_cells.py         # same, for the NATS-Bench appendix table

convert.py never writes to the source trees. content_index.jsonl records sha256 -> content_id, so a re-run resumes with dedup intact.

Provenance

Sources are the local trees under D:\kubectl listed in DATA_AND_CODE.md §4, plus cluster_scvl -- 140 tars pulled from the williamli-scvl Nautilus namespace, holding the cells no local tree had. The other namespace, dataset-distillation (ConvNet-based), adds nothing: its result trees are already covered locally.

The pull was verified end to end: 174 x 10 MiB chunks, each hash-checked on arrival, concatenated to a bundle whose SHA-256 matches the one computed on the pod, then unpacked. 54 of those 140 tars hold zero results.jsonl -- runs that crashed before training on a missing config or missing distilled data -- so only 85 carry results. Cells that exist on neither the local trees nor this pull are still reported by coverage.py as gaps.

Cell-level completeness

n_configs > 0 is too coarse a coverage test -- one run passes it. coverage.py grades each cell against 100 hparams x 3 trial seeds = 300 configurations, with one exclusion and one exception:

• ImageNet targets 60, not 300. The paper sampled 20 hyperparameter sets there (sec 4), so its 57-58 per cell is correct by design.
• images-seen-aligned cells (budget derived from an image count -- 625, 642, 834 ...) are Figure 4 sweeps, never meant to fill a 300-cell.

NATS-Bench cells target 300 like any other, but must not be grouped by args["model"]. There the network is the thing being searched, so that field holds the candidate architecture rather than a fixed evaluation backbone, and grouping by it splits one 300-configuration cell into a 152/148 pair that both look half-empty. coverage.py forces mdl = "nas" when cell_model == "nas".

1,020 main-table cells: 780 full, 185 partial, 55 sparse. Two narrower checks compare against the paper: paper_cells.py covers 117 cells (108 OK, 5 thin, 4 missing) and nats_cells.py the 77 of tab:cifar_nats (75 OK, 2 thin).

paper_cells.py marks each expectation printed or assumed. Printed cells have a number in an appendix consistency table; assumed ones only carry a Table 1 checkmark, with no per-ipc breakdown published, so the ipc {1,10,50} expectation is ours rather than the paper's. All 9 thin/missing cells are assumed -- every number the paper actually prints is fully backed. What is short is the ipc coverage behind two Table 1 checkmarks (ImageNette SRe2L and WMDD, ResNet side). The cluster does not close any of them: the ipc10/50 tars do not exist there, and the two ipc1 tars that do exist hold 60 crashed run directories and zero results.jsonl (missing hparams config / missing distilled data). 54 of the 140 cluster tars are empty in exactly this way; the 85 that do carry data fill other cells -- 84 of them cells no local tree had, adding 22,359 runs without touching a single one of the nine. paper_cells.py reports the same 108/5/4 after the cluster ingest as before it, and repro_fig4.py still passes point-for-point. See reports/COVERAGE_REPORT.md §4 and §5.