Passenger555/datadistillbed-raw-results

DataDistillBed raw experiment results

Converted from the on-disk experiment trees described in DATA_AND_CODE.md (conversion workspace, not shipped here). Further protocol audits are maintained in the documentation repository. Supports In Search of Lost Consistency in Dataset Distillation (ICLR 2027 submission).

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.

Through the 2026-09-19 release, the original and incremental verification runs cover 868,699 unique contents and 2,411,161 source-file manifest rows with zero SHA-256 mismatches. The incremental verification rebuilt all 26,914 contents referenced by the new manifest, re-read and re-hashed 3,000/3,000 new source files straight off disk, and cross-checked all 13,397/13,397 new typed runs against their raw-record line counts. ~58 GiB and 2.4M files become 2.1 GB in four tables. On 2026-09-13, the manifest totals, all 416,077 raw-record line counts, ten reconstructed result-file SHA-256 hashes, and all 128 accuracy values and run counts in the paper's training_curves.json (Figure 4) were independently checked against the tables. Numerical reproduction establishes traceability; the training-input and comparison caveats below still apply. The original on-disk source trees and conversion scripts are not shipped with this dataset.

2026-09-19 origin and subset release

Five immutable families were added from the two 2026-09-19 result packages. Only formal result directories were converted; attempts, pilot, and validation trees are excluded, as are selected-image PNG and NumPy payloads.

family	planned configs	runs rows	stored complete=true	NaN / non-complete result rows	archived OOM without results.jsonl
origin_repro_20260907	1,200	1,200	1,169	31	0
random50_20260907	3,600	3,600	3,557	43	0
el2n50_20260907	3,600	3,600	3,563	37	0
random50_e300_20260908	3,600	3,600	3,548	52	0
origin_subsets_repro_20260908	1,500	1,397	1,367	30	103

The 103 OOM classifications follow the existing archive convention: their out.txt and err.txt bytes and source paths are preserved by artifacts and manifest, but no synthetic row is added to runs. These are declared cross-machine OOM classifications retained from the source package, not 103 independent failures measured on the packaging machine. Random and EL2N runs are labelled with method=Random / method=EL2N and ipc=50; their s0/s1/s2 subset identity remains in source_path.

The corresponding experiment code snapshots are proposed in origin_exp/ and origin_exp_new/.

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	Standard 100-by-3 sweeps contain 300 runs and 298 distinct hyperparameter vectors: 297 random draws plus the default (hparams_seed=0) repeated across the three trials. Nonzero hyperparameter seeds are sampled using both hparams_seed and trial_seed.
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 (n_checkpoints is per attempt; n_lines counts the whole file and repeats on every attempt row)

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". Rebuild the file by concatenating each line plus "\n" in line_index order (all 429,474 files end with a trailing newline; see data/trailing_newline.json).

artifacts

content_id, family, artifact_type, content_bytes, n_bytes, sha256: out.txt, err.txt, done, plus the case-study log.txt / train.log / results.txt / flops.txt. The 365,748 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).
• The stored complete flag uses last_epoch >= epochs_budget - 1.5. This tolerance can accept truncated short runs: in each Figure 4 two-epoch origin cell, 63 ConvNet or 68 ResNet runs stop at epoch 1 but pass the rule. Treat the flag as the extraction criterion when reproducing the figure; inspect the actual endpoint when requiring completed training schedules. The done marker is archived but is not used by complete.
• To reproduce Figure 4, take the global maximum of final test accuracy within each selected cell, using the last attempt and its stored completeness flag. This is an oracle comparison selected on test accuracy. Standard cells contain up to 100 hyperparameter seeds × 3 trial seeds; the nonzero seeds draw different hyperparameters in each trial.
• Images seen use the actual training images per epoch. CIFAR origin sweeps use epochs × 50,000. For literal-image distilled datasets, the nominal count is epochs × ipc × n_classes. FreD and NCFM are exceptions: their Figure 4 CIFAR-10 IPC-50 step counts imply about 2,000 training images per epoch, roughly four times the nominal 500. Account for decoded images when interpreting their training cost.
• 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_.tar (cells converted from tars keep the .tar suffix) 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 is numerically reproducible, but its winning CIFAR-100 run has batch size 630 and 80 steps per epoch, implying about 50,000 training images per epoch rather than the nominal 5,000. Among the 21 complete CIFAR-100 runs whose step counts match 5,000 images, the maximum is 0.5493. Dataset relabelling alone does not fix this training-input anomaly; exclude the anomalous run from IPC-50 comparisons and treat the remaining cell as incomplete.
• Select ResNet origin baselines by KD flag and training recipe. Require knowledge_distillation=false for a supervised baseline. The resnetk suffix does not reliably encode KD use: the November CIFAR resnetk origin runs have KD disabled but belong to a different code batch. resnetk is a cell-name label (cell_model); the resolved model column reads resnet for those rows. Inspect hparams_json.knowledge_distillation directly: distilled -resnet rows commonly have KD enabled, as do 840 -resnet origin-cell rows in the aug / tiny_origin_e100 families.
• Archived V1 code contains a 100x ResNet learning-rate multiplier. V1 commit f66cead, dated 2025-11-12 UTC, sets target_lr = 100 * lr when model == "resnet". For runs executing this code, recorded [5e-5, 5e-3] becomes the optimizer's base range [5e-3, 0.5], before warmup and decay. The code signatures and optimizer-specific accuracy patterns strongly support this explanation for the November resnetk batch in cifar_resnet and subset_resnet; confirmation of the code actually executed remains outstanding. The same commit also unfreezes ResNet batch-normalization statistics, so accuracy differences between sweeps cannot be attributed to learning rate alone. Preserve the recorded values and label any inferred adjustment explicitly. A family name is insufficient: cifar_resnet includes earlier origin runs, and the checked aug SGD origin profile is consistent with unscaled learning rates. Do not apply a blanket 100x correction to either family. See the source audit and the dataset checks.

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 (313,329 rows; shipped with the dataset). Identical bytes across snapshots are already a single content_id, so precedence only decides between different re-runs.

Newest additions: origin_repro_20260907, random50_20260907, el2n50_20260907, random50_e300_20260908, and origin_subsets_repro_20260908. The existing paper-family precedence remains: 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 86 of its data-bearing tars did turn out to be net-new (86 cells, none present in any local tree), 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

The dmb_dataset/tools/ scripts and reports/COVERAGE_REPORT.md live in the conversion workspace, not in this dataset repo. 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 86 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:

• The four ImageNet distilled e300 cells in imagenet_resnet contain 60 runs each. This is 20 hparams_seeds × 3 trial seeds, consistent with Sec 4's stated 60 settings. Each cell has 57 or 58 runs satisfying the stored complete flag. Other budgets and origin sweeps have different observed counts, so this is not a completeness claim for every ImageNet cell.
• 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 86 that do carry data fill other cells, none of which any 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.