aicrowd/arc-whestbench-convergence-2026-traj-b

WhestBench convergence study — v1-warmup-100mlps

Per-neuron cumulative mean activations of the first 100 MLPs of aicrowd/arc-whestbench-public-2026 captured at 860 log-spaced sample budgets from N=1 to N=1,000,000,000.

This is a research sidecar to v1-warmup. It demonstrates how Monte Carlo mean estimates of the activations converge as the sample budget grows.

This is trajectory B — an independent peer of aicrowd/arc-whestbench-convergence-2026 (trajectory A). Same 100 MLPs, same architecture, same snapshot schedule — but the per-MLP sample stream is drawn from a cryptographically-disjoint child of SeedSequence(mlp_seed).spawn(3)[1] (specifically .spawn(2)[1]). The two trajectories together let you measure Monte-Carlo convergence at every N without the shared-sample bias that a single trajectory has against the v1-warmup published mean. See Quick start for the matched-N MSE recipe.

Quick start

Use trajectory B in tandem with trajectory A to plot the unbiased single-estimator MC convergence curve. The factor of ½ recovers single-estimator MSE units from the variance of the difference of two independent N-sample MC estimates (Var(A−B) = Var(A) + Var(B) = 2σ²/N), so the curve sits directly on σ²/N for comparison with closed-form estimator MSEs.

from datasets import load_dataset
import numpy as np

ds_a = load_dataset("aicrowd/arc-whestbench-convergence-2026",
                    revision="v1-warmup-100mlps", split="public")
ds_b = load_dataset("aicrowd/arc-whestbench-convergence-2026-traj-b", revision="v1-warmup-100mlps", split="public")

# Sort both by mlp_id to align rows.
def _sorted(ds):
    return sorted([dict(r) for r in ds], key=lambda r: r["mlp_id"])
rows_a, rows_b = _sorted(ds_a), _sorted(ds_b)

snapshot_n = np.asarray(rows_a[0]["snapshot_n"])                          # (S,)
mse = np.empty((len(rows_a), len(snapshot_n)), dtype=np.float64)
for i, (ra, rb) in enumerate(zip(rows_a, rows_b)):
    rm_a = np.asarray(ra["running_means"])                                # (S, depth, width)
    rm_b = np.asarray(rb["running_means"])
    mse[i] = ((rm_a - rm_b) ** 2).mean(axis=(1, 2))

single_estimator_mse = 0.5 * np.median(mse, axis=0)                       # (S,)
# Plot snapshot_n (log x) vs single_estimator_mse (log y) — slope ≈ −1,
# terminates at ≈ σ²/1,000,000,000 ≈ 4e-10.

Schema (whestbench-convergence-1.0)

Column	Type	Shape	Meaning
mlp_id	int64	scalar	Same as source MLP id.
mlp_name	string	scalar	Human label.
mlp_seed	int64	scalar	int63 input seed (seed_protocol 3.0).
snapshot_n	list	(S,)	Actual sample count at each snapshot; strictly ascending. Identical across rows.
running_means	list<list<list>>	(S, depth, width) ≈ (860, 8, 256)	Per-neuron running mean. float64.
v1_warmup_all_layer_means	list<list>	(depth, width) = (8, 256)	Published value from the source dataset. float32.

Snapshot schedule

n_min = 1
n_max = 1,000,000,000
n_snapshots_requested = 1000
n_snapshots_actual    = 860

Log-spaced over [n_min, n_max], rounded to int64, deduplicated. The actual count is below the requested count because low-decade integers collapse on rounding.

Reproducibility note

running_means[-1] (at N=1,000,000,000) is NOT bit-identical to v1_warmup_all_layer_means. The convergence study uses variable chunk decomposition (to land precisely on log-spaced snapshot boundaries), while v1-warmup used uniform chunk_size=524288. Float64 addition is non-associative; the two final values agree to ~1 float64 ULP per element.

Use running_means[-1] (this run's own final) as the reference for in-study convergence-error analysis. Compare to v1_warmup_all_layer_means only with statistical tolerances.

Provenance

Configuration 1 — 91 MLPs

• GPU: NVIDIA A100-SXM4-80GB (compute capability 8.0)
• PyTorch: 2.4.1+cu124
• whestbench: 0.3.0
• Determinism: torch.use_deterministic_algorithms=True, cudnn.deterministic=True, CUBLAS_WORKSPACE_CONFIG=:4096:8
• CUDA drivers observed: 550.127.05, 565.57.01, 570.133.20, 570.172.08, 580.126.16, 580.126.20, 580.159.04

Source

• Source dataset: aicrowd/arc-whestbench-public-2026@v1-warmup
• MLP range: [0, 100)
• Source split: public