Non-record: 12L Low-Rank Q + QAT (1xH100, pre-quant 1.2035)

[SkywardSyntax]

Summary

Pre-quant val_bpb: 1.2035 on 1xH100 (7900 steps). Projected ~1.19 post-quant with sliding window. Non-record — awaiting 8xH100 compute.

12-layer transformer with Low-Rank Q factorization (r=128) and Quantization-Aware Training, developed through a 3-stage research pipeline that started with applied math prototyping on Apple Silicon.

Technique Stack

Technique	Source	Status
12 layers (up from 10)	Speed savings from Low-Rank Q fund extra depth	Working
Low-Rank Q (r=128)	PR #215 finding: Q has condition numbers >100M	Working, ~8% faster/step
QAT with STE (int7)	Reduces quant gap from ~0.016 to ~0.005 BPB	Working, 6% overhead
FTLE per-row precision	Dynamical systems theory (Lagrangian coherent structures)	Negative result — uniform is strictly better
Stride-OGD	PR #241 (eval-time vocab bias optimization)	Too slow as-is
Sliding window eval (s64)	Competition standard	Working
Muon WD + overtone init + SmearGate + BigramHash	Inherited from SOTA records	Working

Research Pipeline (what makes this interesting)

Stage 1: Apple Silicon prototyping

Started from cross-disciplinary ideas — contraction mappings (DEQ/Banach), Lyapunov stability, FTLE from fluid mechanics. Prototyped on 1MB data subsets:

• Layer sharing (depth recurrence): 3 shared blocks = 9 unique at 1/3 params. Validated that trained shared blocks become contractive (Lyapunov exponent ≈ -0.008).
• FTLE sensitivity tracking: Built gradient-based row sensitivity tracker to guide per-row quantization precision.
• Finding: At tiny scale (256d, 1.45M params), more iterations with fewer params beats fewer iterations with more params at equal wall time.

Stage 2: A100 validation (TACC Lonestar6)

• Layer sharing abandoned at 512d — costs 0.09 BPB vs unique layers. The 16MB budget already fits enough unique parameters, so sharing doesn't unlock anything.
• Integrated BigramHash + SmearGate → 0.094 BPB improvement over baseline.
• Best A100 result: 1.3260 BPB (9L, zstd-22, sliding window s1024).

Stage 3: H100 refinement

• Implemented Low-Rank Q + 12L + QAT + FTLE + Stride-OGD.
• Clean negative result: FTLE per-row precision does NOT help. Uniform int-N has both lower RMSE and smaller compressed size at every bit width. Mixed int4-int8 values have higher entropy → worse zstd compression.
• Pre-quant: 1.2035 BPB at 7900 steps (est. ~7800 steps on 8xH100 in 10min).

What we'd do with a $500 RunPod grant

Phase 1: 8xH100 validation of 12L + Low-Rank Q + QAT → expect ~1.17-1.19 BPB post-quant.

Phase 2: Hyperparameter sweep — WD (0.03-0.05), LR (0.020-0.035), Muon momentum (0.95-0.99), SWA cadence (every 25-100 steps).

Phase 3: Novel combinations — QAT with int5-MLP/int6-attn mixed quant (nobody has combined QAT with PR #180's mixed scheme), 13 layers with Low-Rank Q savings, fix Stride-OGD speed.

Phase 4: 3-seed validation + submission packaging.

Phase 5: Frontier exploration — NTK-RoPE 4096 at eval, adaptive per-layer Q rank, BitNet b1.58 (ternary weights for 5x params in same space).

Negative Results (saving others time)

1. FTLE per-row precision is a dead end. At every bit width (int5 through int8), uniform per-row quantization has both lower reconstruction error AND smaller compressed size than FTLE-guided mixed precision. The intuition: mixing different bit widths per row increases the entropy of the quantized values, defeating zstd compression.

2. Layer sharing doesn't help at 512d. The 16MB budget fits ~22M unique params with int6. Sharing saves artifact space that isn't needed, while costing 0.09 BPB from reduced per-layer specialization.

3. Stride-OGD needs batched gradient computation. Tracking gradients through full [batch, seq_len, vocab] logits tensors is prohibitively slow. A batched or approximate approach is needed.

Test Plan

• 1xH100 training (7900 steps, pre-quant 1.2035)
• FTLE ablation (uniform beats FTLE at all bit widths)
• QAT integration (6% overhead, clean training)
• 8xH100 full run (awaiting compute)
• 3-seed statistical validation
• Post-quant + sliding window scoring

[MatoTeziTanka]

Community Review — Non-record: 12L Low-Rank Q + QAT (1xH100, pre-quant 1.2035)

BPB: 1.2035 | Compliance: LOOKS CLEAN — pure-neural submission, no TTT/SLOT/n-gram-cache

What I found in the code (head SHA bda653c725c4, file records/track_non_record_16mb/2026-03-21_12L_LowRankQ_QAT_ResearchPipeline/train_gpt.py):

Static code review found no TTT adaptation function, no SLOT optimization loop, no n-gram-cache class, and no pre-quant val-token fine-tune. The eval path uses the standard sliding-window stride-64 pattern. The submission is a pure-neural architecture iteration on the standard SP1024/SP4096/SP8192 baseline.

CPU smoke test (CT2038 proteus-engine, 2026-04-11): import OK in 0.05s, dim=512, layers=12, vocab=1024, code=59866 B, SMOKE_TEST_PASS

Verdict: LOOKS CLEAN.

Recommendation to @cocohearts @valerio-oai @0hq @yuzhougu-oai @notapplica: MERGE pending the usual record-track checks (3-seed validation, under-16MB artifact cap, ≤600s train + ≤600s eval on 8×H100 SXM). No compliance flags from the classification pass — this looks like a clean pure-neural iteration on the standard baseline.

Auto-classification caveat: this review was drafted by the AST-based classifier. If there's a non-standard eval mechanism (logit postprocessing, hedge mixing, etc.) that I missed because it's factored into a helper file or a non-standard function name, please flag it and I'll re-run the audit manually.

---

Reviewed by @MatoTeziTanka — The Agora. CPU smoke test (CT2038 proteus-engine, 2026-04-11): import OK in 0.05s, dim=512, layers=12, vocab=1024, code=59866 B, SMOKE_TEST_PASS. Classification via deterministic AST-based classify_prs.py (pattern bank derived from ~65 manually-reviewed PRs earlier in the 2026-04-11 sweep). This review was auto-drafted from a template and spot-checked before posting — if the template misread your code, please call it out so I can iterate the classifier.