aicrowd/arc-whestbench-public-2026

Organized by: Alignment Research Center (ARC), AIcrowd

WhestBench 2026: ARC White-Box Estimation Challenge

WhestBench is a benchmark for white-box activation estimation: given the weights of a randomly initialized ReLU multi-layer perceptron (MLP) and a strict floating-point-operation (FLOP) budget, predict the average post-activation value of every neuron when the network is fed standard Gaussian inputs.

This is the WhestBench 2026 Public Dataset Release — pre-baked MLPs paired with their ground-truth activation statistics. Two independent splits, baked with disjoint seeds:

• mini (100 MLPs) — the development split. Small enough to download in seconds. Iterate on your estimator here.
• full (1,000 MLPs) — the canonical evaluation surface. Run against this once your estimator is dialed in.

mini is not a subset of full. They share no MLPs — verify with the mlp_seed column.

Quick start

The pure HuggingFace path (no whestbench install required):

from datasets import load_dataset

# Develop against mini — 100 MLPs, downloads in seconds.
# `mini` is the default config of this repo, so no name= is required.
mini = load_dataset("aicrowd/arc-whestbench-public-2026", revision="v1-phase1", split="mini")
print(mini[0]["mlp_name"])

# Lock in your numbers against full — 1,000 MLPs.
# `full` is a separate config; pass the name explicitly. mini and full are
# independent — loading full does NOT also pull mini (or vice versa).
full = load_dataset("aicrowd/arc-whestbench-public-2026", "full", revision="v1-phase1", split="full")
print(full[0]["mlp_name"])

The whestbench convenience wrapper (adds schema validation + metadata.json access + the prepared-Arrow fast path):

import whestbench

ds = whestbench.load_dataset("aicrowd/arc-whestbench-public-2026", revision="v1-phase1")
for mlp in whestbench.iter_mlps(ds):
    # `mlp` is a whestbench.MLP with .weights, .seed, .name, .width, .depth
    ...

provenance = whestbench.metadata(ds)
print(provenance["n_samples"], provenance["created_at_utc"])

Fast path on cold cache. This release ships prepared Arrow artifacts under prepared/<split>/ (mini, full). When you call whestbench.load_dataset(...) with a split= argument, the library downloads only the matching Arrow tree and memory-maps it via Dataset.load_from_disk() — skipping the parquet→arrow conversion that a fresh datasets.load_dataset(...) call pays on first use. You'll see a one-line stderr notice when the fast path fires.

Run an estimator end-to-end via the CLI:

whest run \
    --estimator my_estimator.py \
    --dataset hf://aicrowd/arc-whestbench-public-2026@v1-phase1
# (automatically uses metadata.default_split: "mini"; pass --split <name> to override)

➡️ New to the challenge? Head over to the WhestBench starter kit for a worked example estimator, the recommended project layout, FLOP-tracking patterns with flopscope, local testing tips, and the submission workflow.

Schema

Each row is one MLP. Eight columns:

Column	Type / shape	What this is
mlp_id	int32	0-based index of this MLP within the dataset (the absolute index across all parallel-bake slices).
mlp_name	string	Stable, deterministic human-readable slug like "danielle-johnson", derived from mlp_seed. Useful for log lines; carries no information beyond mlp_seed.
mlp_seed	int64	Per-MLP seed exposed in the dataset. Under seed_protocol 3.0 (whestbench_explicit_per_mlp_seeds), this is the input seed for the MLP — MLP.seed (the estimator seed) is derived locally. Under seed_protocol 2.0 (whestbench_seedsequence_hierarchy, legacy), this is the derived estimator seed itself. Estimators read mlp.seed and see the same kind of value in both protocols (a deterministic int derived from the dataset's seed material).
weights	float32[depth, width, width]	The MLP's layer weight matrices. The network has no biases and no separate linear output layer — every weight matrix is followed by a ReLU. Layer l computes h_l(x) = max(0, W_l @ h_{l-1}(x)). Weights are drawn i.i.d. from N(0, 2/width) (He initialization) at bake time.
all_layer_means	float32[depth, width]	Ground truth. Entry [l, j] is the empirical mean of neuron j's post-ReLU output at layer l, averaged over N = 1,000,000,000 independent Gaussian inputs: E_{x ~ N(0, I)}[ h_l(x)_j ] ≈ (1/N) Σ_i h_l(x_i)_j. Computed by direct Monte Carlo. This is what your estimator predicts.
final_means	float32[width]	The last row of all_layer_means — i.e. E[h_{depth}(x)_j] for each output neuron j, again over N = 1,000,000,000 samples. Materialised as its own column because the primary scoring metric (final_layer_mse) only looks at this row.
avg_variance	float64	Per-MLP mean of the per-neuron output variance at the final layer: (1/width) Σ_j Var[h_{depth}(x)_j]. A single scalar per MLP, computed alongside the means over the same Monte Carlo draws. Shipped as diagnostic provenance — useful for normalising your own MSE locally or as input to variance-aware estimators. Not consumed by the active scoring formula (the score is mse_final · max(0.1, C_m / B_m)).
sampling_budget_breakdown	string (JSON)	FLOP accounting for the bake that produced the ground truth for this row — useful as provenance. Not related to the estimator's FLOP budget at evaluation time. Decode with json.loads(...) to get a dict with keys: flop_budget, flops_used, flops_remaining, wall_time_s, flopscope_backend_time_s, flopscope_overhead_time_s, residual_wall_time_s, and by_namespace (per-namespace nested breakdown: each namespace key maps to its own {flops_used, calls, flopscope_backend_time_s, flopscope_overhead_time_s, operations}).

How the ground truth was made

Monte Carlo with N = 1,000,000,000 samples per MLP. Every entry in all_layer_means and final_means is the empirical mean over this many independent standard-Gaussian input draws. The per-neuron standard deviation of the published value is σ_activation/√N ≈ 3×10⁻⁵ (in activation units; equivalently, ground-truth MSE on the order of 10⁻⁹) — orders of magnitude smaller than any meaningful estimator gap.

Input distribution. Every Monte Carlo sample is a fresh x ~ N(0, I) of shape (width,). The same input is forward-propagated through all depth layers in one pass, so the per-layer means at indices [0..depth-1] share the same input draws.

Estimator. Sums of post-ReLU activations are accumulated in float64 for numerical stability, then divided by N at the end and downcast to float32. The final-layer variance scalar (avg_variance) comes from E[h²] - (E[h])² over the same N draws.

Compute. Sampling is chunked so memory stays bounded (~4MB per chunk on the flopscope CPU backend; tunable on the torch GPU backend via chunk_size). On the torch backend, under matched determinism config (torch.use_deterministic_algorithms=True, cudnn.deterministic=True, CUBLAS_WORKSPACE_CONFIG=:4096:8) on a fixed torch version and GPU architecture, the bake is bit-exact: weights, all_layer_means, and final_means reproduce byte-for-byte; avg_variance agrees to 1e-12 relative tolerance (1 float64 ULP from the (sum_sq/n − mean²) step). The two backends (flopscope CPU and torch GPU) produce statistically equivalent output: means agree within ~3×10⁻⁵ at N=10⁹.

Dataset summary

Splits	mini, full
MLPs total	1100
mini split MLPs	100
full split MLPs	1,000
Width	256
Depth	32
Monte Carlo samples per MLP (N)	1,000,000,000
Schema version	3.0
Seed protocol	whestbench_explicit_per_mlp_seeds v3.0

Working with this dataset

Three ways in, fastest first:

• Score an estimator — whest run --dataset hf://aicrowd/arc-whestbench-public-2026@v1-phase1 runs your estimator end-to-end against the default mini split (add --split <name> to switch). No manual download step — the data is fetched and cached for you.
• Load in Python — whestbench.load_dataset("aicrowd/arc-whestbench-public-2026", revision="v1-phase1", split="mini") returns a HuggingFace Dataset with schema validation plus whestbench.metadata(ds) provenance; iterate ready-to-use MLP objects with whestbench.iter_mlps(ds).
• Raw rows — plain datasets.load_dataset(...) works too, if you'd rather not install whestbench (see Quick start).

📖 Full walkthrough — choosing a split, FLOP budgeting, the estimator contract, and the submission flow — see Use Evaluation Datasets in the starter kit.

Reproducibility

This dataset was baked with:

• Backend: torch

• Seed protocol: whestbench_explicit_per_mlp_seeds v3.0

• Created (UTC): 2026-06-16T02:42:34.437608+00:00

This dataset was baked with seed_protocol 3.0 (explicit per-MLP seeds): every MLP's input seed lives in the parquet mlp_seed column, so the bake is fully reproducible from the published data alone. You almost never need to do this — but if you want to regenerate the dataset byte-for-byte, expand the recipe below.

Re-bake this dataset locally from its seeds

1. Extract the per-MLP seeds into one JSON file per split:

import json

import whestbench

for split in ["mini", "full"]:
    ds = whestbench.load_dataset("aicrowd/arc-whestbench-public-2026", revision="v1-phase1", split=split)
    json.dump([int(r["mlp_seed"]) for r in ds], open(f"{split}-seeds.json", "w"))

2. Re-bake each split with the same seeds:

whest dataset bake \
    --n-mlps 100 \
    --n-samples 1000000000 \
    --width 256 --depth 32 \
    --split mini \
    --mlp-seeds mini-seeds.json \
    --output ./mini-rebake \
    --torch --device cuda
whest dataset bake \
    --n-mlps 1000 \
    --n-samples 1000000000 \
    --width 256 --depth 32 \
    --split full \
    --mlp-seeds full-seeds.json \
    --output ./full-rebake \
    --torch --device cuda

The pins required for the bit-exactness guarantee (see Compute above) are recorded in metadata.bake_config alongside the whestbench and faker versions.

Provenance

Assembled from multiple partial bakes merged via whest dataset merge across a fleet of NVIDIA GeForce RTX 3090 GPUs, in 1 distinct hardware configuration.

Configuration 1 — 1100 partials

• GPU: NVIDIA GeForce RTX 3090 (compute capability 8.6)
• CPU: x86_64 (16 logical cores)
• RAM: 67 GB
• Python: 3.11.10 · PyTorch: 2.4.1+cu124 (device=cuda) · NumPy: 2.4.6
• whestbench: 0.10.0 · flopscope: 0.7.0
• Determinism: torch.use_deterministic_algorithms=True · cudnn.deterministic=True · CUBLAS_WORKSPACE_CONFIG=:4096:8
• CUDA drivers observed: 550.163.01, 570.211.01, 580.159.03, 580.65.06
• Linux kernels observed: 6.5.0-41-generic, 6.8.0-57-generic

Citation

If you use this dataset, please cite the challenge:

@misc{whestbench2026,
  title        = {{WhestBench 2026: ARC White-Box Estimation Challenge}},
  author       = {{Alignment Research Center} and {AIcrowd}},
  year         = {2026},
  howpublished = {\url{https://www.aicrowd.com/challenges/arc-white-box-estimation-challenge-2026}},
}

License

Released under CC-BY-4.0. Use is encouraged for research, competition entries, and educational material; please credit the WhestBench team and the AIcrowd challenge.