NOCAP NoCap Benchmark · Evidence Report
BottleCapAI NoCap-Test · Carol Calin · Sealed Benchmark Report

GPT-2 124M Stack Reaches Target Quality 8.3% Faster Than AdamW Baseline

Executive Technical Summary: By combining the Muon Matrix Optimizer, B32 Systems Microbatching, and Timing-Cheap Split-QKV Attention Projections, our composite training stack reaches the official GPT-2 validation loss threshold ($\text{val\_disjoint} \le 3.3821$) in an average of 3.544 hours across 3 independent random seeds. This delivers an 8.3% training time reduction compared to the sealed AdamW baseline (3.866 hours) on a single NVIDIA A100 GPU.

Time Reduction (ΔT%)
8.3% Faster
3.544 h mean vs 3.866 h baseline
Target Loss Gate
≤ 3.3821
Disjoint Validation Loss
Seed Replication
3 / 3 Seeds
Verified on seeds 1337, 2029 & 4242
Hardware & Precision
1x A100 (bf16)
NVIDIA A100-SXM4-40GB GPU
01 / Optimizer Architecture

Muon Optimizer: Matrix Momentum & Newton–Schulz Orthogonalization

Replacing scalar coordinate scaling with 2D matrix momentum and 5-step Newton–Schulz polynomial updates.

📐 Matrix Momentum

Standard AdamW scales parameter coordinates independently. Muon treats 2D weight tensors as matrix operators. It computes SGD momentum matrix $G$, then updates weights using its nearest semi-orthogonal matrix $O = \text{Ortho}(G) = U V^T$:

$$\begin{aligned} \text{Ortho}(G) &= U V^T \quad (G = U S V^T) \\ W &\leftarrow W - \eta \cdot \text{Ortho}(G) \end{aligned}$$

🔀 Parameter Routing

Hidden 2D weight matrices (linear projections & attention layers) are optimized with Muon. 1D parameters (embedding tables, layer norms, and biases) remain on AdamW.

Hidden 2D Layers: Muon Optimizer (lr=0.02)
Embeddings & 1D: AdamW Optimizer (lr=0.0018)

⚡ Newton–Schulz (NS5)

Instead of expensive SVD calls, Muon uses a 5-step Newton–Schulz polynomial iteration ($\phi(x) = 3.4445x - 4.7750x^3 + 2.0315x^5$) executed via native bfloat16 matrix multiplications.

$$\begin{aligned} \phi(X) &= a X + b X^3 + c X^5 \\ a = 3.4445,& \; b = -4.7750, \; c = 2.0315 \end{aligned}$$

🔬 Interactive Newton–Schulz Spectrum Animator (NS0 → NS5)

Click the steps to see how 5 Newton–Schulz iterations flatten singular value variance into an orthogonal matrix update.

Step 0 (Raw G matrix): Ill-conditioned singular values range from 0.05 to 4.20. Max Singular Variance: 3.85
💡 AI Terminology Rationale: Why Muon over AdamW or Shampoo?

1. AdamW Scalar Ill-Conditioning

AdamW rescales parameters scalar-by-scalar using coordinate variance $\sqrt{v_t}$. In deep Transformer weight matrices, singular values span several orders of magnitude, causing slow gradient convergence along ill-conditioned directions.

2. Shampoo Computational Overhead

Shampoo computes preconditioner matrix roots $(G G^T)^{-1/4}$, costing $O(d^3)$ operations and suffering from severe numerical instability in bfloat16 precision.

3. Muon Tensor Core Efficiency

Muon replaces matrix square roots with 5 native matrix multiplication polynomial steps ($\phi(X) = a X + b X^3 + c X^5$), achieving exact semi-orthogonality ($U V^T$) at maximum GPU Tensor Core throughput.

02 / Systems Microbatching

B32 Microbatch Packing & GPU Occupancy

Maximizing A100 Tensor Core throughput while keeping total tokens per update fixed at 524,288 tokens.

📦 Systems Microbatching

Changing microbatch size to 32 (with 16 gradient accumulation steps) is a hardware throughput optimization. It does not alter the loss function or optimization gradient math.

🔒 Fixed Token Budget Invariant

To guarantee a fair benchmark clock, the total token count per optimizer step is kept strictly constant:

$$\begin{aligned} \text{Tokens/Update} &= \text{Microbatch} \times \text{Accum} \times \text{SeqLen} \\ \text{B16}: 16 \times 32 &\times 1024 = 524,288 \\ \text{B32}: 32 \times 16 &\times 1024 = 524,288 \end{aligned}$$

⚡ Banked Step Speedup

Larger microbatches improve SM occupancy on NVIDIA A100 GPUs, halving gradient accumulation kernel launches and saving ~6% core step execution time.

03 / Attention Architecture

Timing-Cheap Split-QKV Projections

Separating Query, Key, and Value matrices under Muon for independent orthogonalization.

✂️ Fused vs. Split QKV

Fused QKV ($W_{QKV} \in \mathbb{R}^{d \times 3d}$) forces Newton–Schulz to orthogonalize Query, Key, and Value projections as one block. Separating them into $W_Q, W_K, W_V \in \mathbb{R}^{d \times d}$ allows independent optimization.

❌ Dual-Polar Split Tax (NO-GO)

Dual-polar split QKV improved validation loss (+0.015 CE), but introduced a +2.6% compute overhead per step. It was rejected as a NO-GO in the Failure Ledger.

✅ Timing-Cheap Split-QKV

Our candidate uses Timing-Cheap Split-QKV (muon_split_qkv=1, match_joint=0), preserving the validation gain with zero step-time tax.

🔀 Interactive Layout Transport Visualizer

W_Q [d × d]
W_K [d × d]
W_V [d × d]
3 Independent NS Kernel Calls
zeropower_via_newtonschulz5
Timing-Cheap Split-QKV (Candidate): Separates W_Q, W_K, and W_V into 3 distinct [d × d] matrices. Allows independent orthogonalization with zero step-time tax.
04 / Performance Curves

First-Passage Validation Loss Curves

Disjoint validation loss vs. training execution time in hours on 1x NVIDIA A100 GPU.

Interactive Overview: Showing all validation loss curves.
Candidate runs (magenta/teal/purple) cross the 3.3821 target line left of the baseline.
05 / Verification Calculator

Recompute Benchmark Speedups

Scrub through training steps to verify cumulative execution time and percentage time saved.

Step Scrubber

Training Step: 4736
Train Time (ms)
12,789,522 ms
Train Time (Hours)
3.553 h
Disjoint Val Loss
3.3740
Time Saved (ΔT%)
+8.1% Faster

Verification Arithmetic

1

First-Passage Quality Gate

Identify the first logged step where disjoint validation loss drops to ≤ 3.3821.

2

Hours Conversion

Divide cumulative training time (train_time_ms) by 3,600,000.

$$T_{\text{h}} = \frac{\text{train\_time\_ms}}{3,600,000}$$
3

Speedup Percentage Calculation

Compute relative time saved against the sealed AdamW baseline clock (3.866 hours).

$$\Delta T\% = \frac{3.866 - T_{\text{h}}}{3.866} \times 100\%$$
06 / Benchmark Scoreboard

Official Campaign Scoreboard

Comparing candidate seeds, matched stock controls, and the sealed AdamW baseline.

Run Identifier Stack Configuration First Cross Step Validation Loss Train Time (Hours) Time Reduction (ΔT%) Status
Candidate · Seed 1337 Muon + B32 + Split-QKV Step 4736 3.3741 3.553 h +8.1% Passed Gate
Candidate · Seed 2029 Muon + B32 + Split-QKV Step 4736 3.3726 3.567 h +7.7% Passed Gate
Candidate · Seed 4242 Muon + B32 + Split-QKV Step 4736 3.3733 3.511 h +9.2% Passed Gate
Baseline (F1_seal) Sealed AdamW Baseline Step 4736 3.3815 3.866 h 0.0% (Ref) Baseline Denominator
Stock Control · Seed 1337 Muon + Joint QKV No Cross 3.3848 N/A N/A Did Not Cross
Stock Control · Seed 2029 Muon + Joint QKV No Cross 3.3840 N/A N/A Did Not Cross
07 / Negative Results

Failure Ledger (Rejected Approaches)

Documenting failed hyperparameter attempts and discarded architectural variants.

Dual-Polar Split QKV

+2.6% Time Ratio

Recomputing polar maps for dual-polar QKV introduced a +2.6% execution time overhead, negating optimizer gains.

Naive Canon Architecture

+30% Step Tax

Adding naive canonical block transformations added a severe ~30% per-step compute penalty.

Short Warmdown (256 steps)

Quality Miss

Attempting a short 256-step warmdown ended at validation loss ~3.405, failing to reach the 3.3821 target line.

Tier A Screening Candidates

5/5 Rejections

Five screening candidates were rejected due to early loss plateauing before reaching full sealed runs.

08 / Technical Glossary

AI & Campaign Glossary

Definitions of core deep learning optimization and benchmark terminology.

Disjoint Validation Loss
Evaluation metric computed on held-out token sequences strictly isolated from training batches. Target threshold is set at ≤ 3.3821.
First-Passage Clock (T)
The exact cumulative training execution time logged at the first step where validation loss reaches the target threshold.
Newton–Schulz Iteration (NS5)
5-step degree-5 polynomial matrix iteration approximating nearest semi-orthogonal update U V^T via fast native PyTorch matmuls in bfloat16.
Timing-Cheap Split-QKV
Separating Q, K, V attention projections into 3 distinct [d × d] weight matrices under Muon with optimized memory layout, eliminating the +2.6% compute tax.
B32 Systems Precision
Reshaping GPU microbatches from 16 to 32 while halving gradient accumulation loops to 16, preserving the 524,288 token invariant while saving ~6% step execution time.
WSD Schedule
Warmup-Stable-Warmdown learning rate schedule (476 warmup / 3100 stable / 1192 warmdown steps) that keeps learning rate high before rapid convergence.
Sealed Baseline (F1_seal)
Locked reference AdamW baseline clock (3.866 hours / 13,918,669 ms) on 1x A100 GPU serving as the sole public percentage denominator.
Kill → Bank → Seal Workflow
Process discipline: Phase 1 (Kill bad ideas fast) → Phase 2 (Bank passing building blocks) → Phase 3 (Seal full candidate recipe across 3 seeds).
09 / Downloads & Evidence

Downloadable Artifacts, Datasets & Code

Preview raw datasets online or click direct download links for code, logs, and technical docs.

🐍
muon_opt.py
PyTorch Muon Kernel Code
Download
📄
f1_seal.csv
Baseline Denominator Log
Download
📄
s1337_cand.csv
Candidate · Seed 1337 Log
Download
📄
s2029_cand.csv
Candidate · Seed 2029 Log
Download
📄
s4242_cand.csv
Candidate · Seed 4242 Log
Download
📊
chart_series.json
Combined Series JSON
Download
📝
NOCAP_DOCUMENTATION.md
Complete Markdown Guide
Download