Normalized Architectures are Natively 4-Bit
Abstract: Training LLMs at 4-bit precision is critical for efficiency. We show that nGPT, an architecture that constrains weights and hidden representations to the unit hypersphere, is inherently more robust to low-precision arithmetic. This removes the need for interventions-such as applying random Hadamard transforms and performing per-tensor scaling calculations-to preserve model quality, and it enables stable end-to-end NVFP4 training. We validate this approach on both a 1.2B dense model and hybrid (Mamba-Transformer) MoE models of up to 3B/30B parameters. We trace this robustness to the dot product: while quantization noise remains largely uncorrelated in both standard and normalized architectures, the signal behaves differently. In nGPT, the hypersphere constraint enhances weak positive correlations among the element-wise products, leading to a constructive accumulation of the signal across the hidden dimension while the noise continues to average out. This yields a higher effective signal-to-noise ratio and a flatter loss landscape, with the effect strengthening as the hidden dimension grows, suggesting increasing advantages at scale. A reference implementation is available at https://github.com/anonymous452026/ngpt-nvfp4
Paper Prompts
Sign up for free to create and run prompts on this paper using GPT-5.
Top Community Prompts
Explain it Like I'm 14
What is this paper about?
This paper shows a simple way to train big LLMs using tiny 4โbit numbers without breaking their quality. The trick is to use a โnormalizedโ transformer called nGPT, where all weights and hidden activations are kept the same overall size (they live on the โsurface of a sphereโ). That shape constraint makes the model naturally sturdy when using lowโprecision math, so it no longer needs extra fixes that slow things down.
What questions were the researchers asking?
They set out to find answers to a few plain questions:
- Can we design a model that is naturally good at 4โbit training, instead of adding lots of complicated fixes later?
- Why would such a model be more stable: is it because it reduces the โnoiseโ from rounding, or because it makes the true โsignalโ stronger?
- Does this work on different model types and sizes, and is it faster in practice?
How did they study it? (Methods in simple terms)
First, a few quick definitions in everyday language:
- 4โbit numbers (NVFP4): Think of storing numbers with only 4 โon/offโ switches. This makes math faster and uses less memory, but itโs less accurate.
- Quantization: Rounding real numbers to a small set of values (like rounding money to the nearest dollar). This creates rounding error, which we can call โnoise.โ
- Dot product: A math step used all over neural nets. You multiply many pairs of numbers and add them up. Imagine lots of tiny arrows; if most point the same way, their sum is big.
- Signal vs. noise: Signal is the meaningful part you want; noise is the random error from rounding.
What nGPT changes:
- nGPT forces both the modelโs weights and the activations to have a fixed overall size (like everyone standing on the surface of a sphere). This stops any single number from becoming huge and dominating the result.
What they measured:
- They looked inside a 3.6Bโparameter transformer and measured how strong the signal is compared to the noise (the โsignalโtoโnoise ratio,โ or SNR) at different steps: before multiplying, after multiplying, and after the final sum (the dot product).
- They also checked how โin syncโ the useful pieces of the signal are across many dimensions. Think of a choir: even a small amount of singers staying in tune together makes the total sound much stronger.
They ran these tests on:
- A 1.2B standard dense model.
- Larger hybrid models (MambaโTransformer MixtureโofโExperts) up to 3B/30B parameters.
- All on NVIDIA Blackwell GPUs that natively support fast 4โbit math.
What did they find, and why does it matter?
Here are the key results, explained simply:
- The win appears in the sum, not the individual numbers.
- Before adding things up, both normal GPT and nGPT had similar noise levels when using 4โbit numbers.
- After the final sum (the dot product), nGPT had a much stronger signal compared to noise. In everyday words: the important part of the calculation stacked up well, while the random errors mostly canceled out.
- Tiny positive alignment makes a big difference.
- In nGPT, the small pieces of the signal are slightly more in sync (weak positive correlations) across thousands of dimensions. Alone, each bit of alignment is tinyโbut together, they add up constructively, like many people pushing in the same direction.
- The noise, however, stays random in both models, so it mostly cancels itself out.
- As models get wider, the advantage grows.
- The more dimensions you have (bigger hidden sizes), the more these small alignments help nGPT. That means the benefit gets larger for bigger models.
- A flatter, more forgiving training landscape.
- Because the signal adds up better, the model becomes less sensitive to small disturbances (like rounding or slightly different settings). They showed the nGPT landscape is about 3.5ร โflatter,โ meaning training is steadier and less likely to break.
- No more extra 4โbit โtricksโ needed.
- Standard 4โbit training often needs addโons like Randomized Hadamard Transforms (to spread out big spikes) and perโtensor scaling (to adjust sizes on the fly). nGPT doesnโt need these, simplifying the training pipeline.
- It works in practice and can be faster.
- nGPT trained stably endโtoโend in 4โbit across different model sizes, matched or beat standard models on downstream tasks, and showed speedups on new GPUsโespecially at large widthsโbecause it avoids overhead and uses fast 4โbit math more directly.
- It was also less sensitive to learning rate choices, making it easier to tune. The best settings from higher precision carried over to 4โbit without extra sweeps.
Why does this matter? (Big picture impact)
This work suggests a different way to make lowโprecision AI work well:
- Instead of patching a standard model with many extra steps to survive 4โbit rounding, build the model so itโs naturally sturdy. nGPTโs โon the sphereโ design spreads the work across many small pieces that align just enough to make the sum strong, while random noise cancels out.
- As models get larger, this benefit grows, which is perfect for the trend toward huge LLMs.
- Practically, this can mean simpler, faster, and cheaper trainingโwith fewer moving parts to tuneโwhile keeping or improving quality.
In short: by changing the modelโs shape (normalizing it), the authors made 4โbit training โjust work,โ turning lowโprecision from something fragile into something reliable and scalable.
Knowledge Gaps
Knowledge gaps, limitations, and open questions
The paper makes strong empirical claims about nGPTโs native robustness to 4โbit (NVFP4) training and offers an SNR-based explanation. The following unresolved issues could guide future research:
- Origin of positive signal correlations: The paper attributes robustness to weak but consistent positive correlations among element-wise products under hypersphere constraints but explicitly leaves their mechanistic source โfor future work.โ Provide a formal theory linking the normalization scheme, optimizer dynamics, and residual parametrization (
ฮฑ_A,ฮฑ_M) to emergent correlations, including necessary and sufficient conditions. - Backward-pass quantization analysis: The SNR and correlation analysis focuses on forward dot-products. Quantify gradient SNR, error propagation, and element-wise correlation in the backward pass (including dYยทX and WยทdY GEMMs), and assess whether the same mechanism protects gradients under NVFP4 with/without stochastic rounding.
- Attention-specific behavior: Most analysis centers on MLP matmuls. Characterize QK dot-products, softmax stability, and attention score distributions under NVFP4 in nGPT (with the modified softmax scaling and
q,knormalization). Determine whether positive correlation and SNR gains hold for attention and KV mixing. - Generality across quantization formats and precisions: Robustness is shown for NVFP4 on Blackwell. Evaluate nGPT under alternative FP4 formats (e.g., float4 variants, block-floating), INT quantization (INT8/INT4), and lower precisions (3โbit, 2โbit) to map the limits of โnativeโ robustness and the minimal precision at which stability breaks.
- Role of stochastic rounding (SR): The dependence on SR is unclear due to ambiguous reporting in Table entries. Systematically ablate SR for both weights and activations to determine whether nGPT remains stable and unbiased without SR, and quantify quality/speed trade-offs.
- Mixed-precision exceptions: Large MoE experiments retain high precision for the final ~15% of layers (following prior recipes) despite โend-to-end NVFP4โ claims elsewhere. Test full NVFP4 across all layers (including late layers and logits) to validate true end-to-end feasibility and identify which layers, if any, still require higher precision.
- Width scaling beyond D=4096: Width-scaling claims are extrapolated from theory to D=16384. Run controlled large-width experiments (e.g., Dโ16k, 32k) to empirically validate regime transitions, saturation behavior, and the predicted ~10ร SNR ratio.
- Stability across depth and topology: The analysis emphasizes width; assess how depth, residual scaling, and architectural variants (pure Mamba, different MoE routing/gating designs, rotary vs. other positional encodings) affect correlation strength and SNR gains.
- Data distribution dependence: Correlation and SNR measurements are taken on Nemotron pretraining data. Evaluate robustness across diverse corpora (code-heavy, multilingual, noisy web, high-outlier distributions) and long-context regimes to test sensitivity to input statistics and outliers.
- Downstream evaluation breadth and significance: Report statistical confidence (variance, CIs) and expand benchmarks (e.g., reasoning, coding, instruction-following, safety) to ensure the observed downstream improvements are consistent and not dataset-specific.
- Ablations of nGPT implementation choices: The paper normalizes โall inputs,โ deviating from the official nGPT implementation. Provide ablations isolating each modification (weight normalization axes, full vs. partial activation normalization, residual update form, attention/MLP rescaling) to identify which changes are necessary for NVFP4 robustness.
- Optimizer and training schedule interactions: nGPT removes weight decay and LR warmup and uses AdamW with fixed ฮฒs. Test other optimizers (e.g., SGD variants, Adafactor), schedules, and regularizers to separate architectural effects from training recipe effects on robustness and LR insensitivity.
- Loss landscape measurement methodology: The flatness claim is based on Gaussian perturbations scaled by Frobenius norms. Validate with alternative measures (e.g., sharpness-aware minimization metrics, Hessian spectra) and link layer-wise SNR to global curvature more formally.
- Noise modeling assumptions: The analysis assumes quantization noise is largely uncorrelated. Verify this under different NVFP4 block sizes, rounding modes, and tensor statistics, and quantify when block-level outliers or hardware rounding behaviors introduce noise correlations.
- Gating and routing under quantization: For MoE, analyze the gating networkโs sensitivity to NVFP4 and whether nGPTโs constraints improve the stability of expert selection probabilities (softmax scores), especially under high-entropy or skewed routing distributions.
- Inference-time quantization: The focus is pretraining. Evaluate whether nGPTโs signal-coherence advantage translates to 4โbit inference without per-tensor scaling/RHT, including latency, throughput, and accuracy trade-offs.
- End-to-end throughput and energy: Single-layer benchmarks show speedups. Report full training wall-clock speedups, throughput (tokens/sec), memory footprint, and energy consumption for complete runs to quantify practical system-level gains from eliminating RHT/scaling.
- Robustness to hyperparameter perturbations beyond LR: The LR insensitivity is encouraging. Test robustness to batch size, gradient clipping thresholds, weight decay values, EMA, and noise injections to map the hyperparameter stability region under NVFP4.
- Expressivity and representational limits: Constraining activations/weights to the hypersphere may limit certain representational modes. Identify tasks or distributions where normalization harms expressivity and explore mitigation (e.g., selective de-normalization or learned radius).
- Temporal evolution of correlation: Measure how element-wise product correlation evolves during training (early, mid, late) and under curriculum or data-mix shifts, to determine whether correlation strength is a cause or consequence of trained representations.
- Synergy or redundancy with advanced NVFP4 techniques: Compare nGPT against state-of-the-art FP4 training methods (e.g., Quartet, โFour Over Sixโ adaptive block scaling) to assess complementary gains or redundancy, and whether combining them further reduces error/overhead.
- Hardware generality: Validate robustness on different GPU architectures (e.g., Hopper, older tensor core implementations) and accelerators (e.g., TPUs), where FP4 formats and rounding behaviors may differ.
- Context-length and positional scaling: Test whether the SNR and robustness advantages persist with very long context windows and different positional encoding schemes, which can introduce large-magnitude intermediates.
- Reproducibility and release: The reference implementation link is anonymous and parts of tables are malformed. Provide complete, public code, exact configs, seeds, logging artifacts, and hardware specs to enable reproducibility of all claims.
Practical Applications
Immediate Applications
The paper introduces a normalized Transformer architecture (nGPT) that is inherently robust to 4โbit (NVFP4) training by constraining weights and activations to the unit hypersphere. This removes common overheads (randomized Hadamard transforms and perโtensor scaling), improves dotโproduct SNR via constructive signal accumulation, flattens the loss landscape, and yields measurable training speedups on NVIDIA Blackwell GPUs.
Software/Cloud and MLOps
- Low-cost, high-throughput LLM pretraining and finetuning in NVFP4
- Sectors: software, cloud, AI platforms
- What to do: Replace standard Transformer blocks with nGPT modules; enable endโtoโend NVFP4 GEMMs; drop RHT and dynamic perโtensor scaling; retain stochastic rounding as needed; optionally keep the final ~15% layers in higher precision for very large models (as in current best practices).
- Tools/products/workflows:
- nGPT layer implementations with fused normalization kernels
- Training recipes and configs (1.2B dense, 3B/30B MoE) that run fully in NVFP4
- CI checks for โNVFP4โreadinessโ (no RHT, fixed activation scales)
- Assumptions/dependencies: Access to NVIDIA Blackwell GPUs and NVFP4 kernels; correct implementation of hypersphere normalization (weights and activations) and residual rules; potential mixedโprecision exceptions for last layers in large models.
- Shrink hyperparameter sweeps via LR transfer from BF16 to NVFP4
- Sectors: software, cloud MLOps
- What to do: Adopt a โsingleโLRโ workflowโpick LR in BF16, then reuse it for NVFP4 without reโtuning.
- Tools/products/workflows:
- LRโtransfer templates in schedulers
- โFlatness sanity checkโ jobs that perturb weights and verify loss robustness before long runs
- Assumptions/dependencies: nGPTโs flat minima observed in experiments; stable training codepath for NVFP4.
- Training cost, time, and energy reduction in production pipelines
- Sectors: software, cloud, enterprise AI
- What to do: Move highโthroughput GEMMs to NVFP4, simplify runtime path (remove RHT and amax reductions), and realize 3.3โ3.6ร layer speedups at large widths; track cost/tokens and energy/tokens KPIs.
- Tools/products/workflows:
- Cost/energy dashboards that compute $/B tokens and Wh/B tokens
- NVFP4โoptimized data loaders and mixedโprecision logging
- Assumptions/dependencies: Throughput gains depend on large hidden sizes where GEMM dominates; wellโtuned fused kernels.
- MoE training simplification for hybrid MambaโTransformer stacks
- Sectors: software, cloud platforms
- What to do: Train experts and routers with nGPT to avoid RHT and perโtensor scalingโeven for 3B/30B hybrid MoEโwhile keeping relative error near 0% vs BF16.
- Tools/products/workflows:
- MoE training templates with nGPT blocks
- NVFP4 router/experts configs and validation harnesses
- Assumptions/dependencies: Verified on MambaโTransformer MoE; other MoE variants may need minor adjustments.
Industry Verticals
- Onโprem domain finetuning under tight cost/energy budgets
- Sectors: healthcare, finance, public sector
- What to do: Run privacyโpreserving, onโprem finetunes (e.g., clinical notes, risk documents) using nGPT in NVFP4 to lower cost and energy while maintaining quality.
- Tools/products/workflows:
- nGPT finetuning playbooks with parameterโefficient methods (e.g., adapters) plus NVFP4 kernels
- Complianceโfriendly logging (energy, precision modes, stability indicators)
- Assumptions/dependencies: Sufficient GPU memory/bandwidth for NVFP4 training; domain generalization to target datasets; potential need for partial higher precision in final layers.
- Faster iteration for regulated model development
- Sectors: healthcare, finance, govtech
- What to do: Use nGPTโs LRโinsensitivity to shorten validation cycles and reduce risky hyperparameter searches; align internal SOPs to โfixed LR + NVFP4โ templates.
- Tools/products/workflows:
- โOneโpassโ tuning protocols codified in QA/validation
- SNR/flatness acceptance criteria in model cards
- Assumptions/dependencies: Validation of downstream metrics in the specific regulated domain.
Academia and Education
- Affordable lowโprecision training at university scale
- Sectors: academia, education
- What to do: Run course labs and research projects in NVFP4 with nGPT to pretrain/finetune 0.4โ1.2B models on limited budgets; replicate the paperโs SNR analyses.
- Tools/products/workflows:
- Teaching modules on hypersphere normalization, dotโproduct SNR probes, correlation metrics
- Openโsource repos with nGPT baselines and Blackwell configs
- Assumptions/dependencies: Access to Blackwell or FP4โcapable accelerators; stable reference implementation.
Energy and Sustainability
- Immediate reduction of training energy and cooling loads
- Sectors: energy, data centers, cloud operations
- What to do: Migrate qualifying training jobs to nGPT+NVFP4, track Wh/B token, and prioritize largeโwidth models where the speed/energy gains are greatest.
- Tools/products/workflows:
- Job schedulers that autoโselect NVFP4 for nGPT graphs
- Facilityโlevel dashboards linking precision mode to PUE and cooling demand
- Assumptions/dependencies: Availability of NVFP4 hardware and monitoring; adequate instrumentation to attribute savings to precision mode.
Long-Term Applications
The paperโs central mechanismโcoherent signal accumulation under hypersphere constraintsโsuggests broader opportunities as hardware, compilers, and model classes evolve.
Hardware/Compiler Co-Design
- FP4โnative accelerators and kernels that exploit hypersphere constraints
- Sectors: semiconductors, compilers
- What to build: Tensor cores and compiler passes that fuse normalization with GEMMs, eliminate dynamic scaling paths, and track SNR proxies for scheduling.
- Dependencies/assumptions: Vendor roadmaps; standardization of normalized ops in graph IRs; validation on diverse workloads.
- Push below 4 bits (e.g., 3โbit, 2โbit) training
- Sectors: semiconductors, software
- What to build: Architectures and gradient estimators that, combined with nGPTโstyle normalization, keep signal coherence at ultraโlow precision.
- Dependencies/assumptions: New number formats and unbiased gradient estimators; empirical confirmation that coherence persists at <4 bits.
Cross-Modal and Edge
- Normalized, 4โbit training for vision, speech, and multimodal models
- Sectors: vision, speech, multimodal AI
- What to do: Extend nGPT principles (weight/activation normalization and residual updates) to ViTs, conformers, and multimodal encoders/decoders.
- Tools/products/workflows:
- Crossโmodal nGPT blocks and benchmarks
- SNR/correlation probes integrated into training loops
- Dependencies/assumptions: Demonstrated correlation/coherence gains beyond language; taskโspecific adjustments.
- Onโdevice continual learning in FP4
- Sectors: robotics, edge/embedded
- What to do: Adapt normalized blocks for NPUs/edge GPUs to enable stable onโdevice finetuning and continual learning in low precision.
- Tools/products/workflows:
- Edgeโoptimized normalized layers with fused ops
- Lightweight calibration tools for fixed scales
- Dependencies/assumptions: Edge hardware support for FP4 training; memory/thermal constraints; safety validation in closedโloop systems.
Training Science and AutoML
- SNRโaware AutoML and architecture search
- Sectors: software, research
- What to build: NAS objectives that directly optimize measured dotโproduct SNR and average element correlation instead of postโhoc quantization fixes.
- Tools/products/workflows:
- Online SNR/correlation telemetry as a NAS/earlyโstopping signal
- Libraries for correlationโpromoting regularizers
- Dependencies/assumptions: Reliable, lowโoverhead SNR proxies during largeโscale training.
- Stable optimization for alignment and safety training at low precision
- Sectors: AI safety, alignment
- What to do: Run RLHF/DPO and safety finetunes in FP4 using nGPT to reduce cost while preserving stability due to flatter loss landscapes.
- Tools/products/workflows:
- FP4โcompatible PPO/DPO stacks with normalized policy/value nets
- Safety metrics tracking under lowโprecision perturbations
- Dependencies/assumptions: Empirical validation on alignment tasks; careful monitoring of reward hacking under quantization.
Market, Policy, and Standards
- Cloud SKUs and SLAs for โFP4โnative trainingโ
- Sectors: cloud providers, enterprise IT
- What to do: Offer managed nGPTโready FP4 instances with guaranteed throughput/; provide migration guides from standard Transformers.
- Tools/products/workflows:
- FP4โnative blueprints in managed ML platforms
- Automated checks that a model graph is โnormalizedโcompliantโ
- Dependencies/assumptions: Broad customer adoption; standardized benchmarking.
- Energy/Carbon reporting standards for model training
- Sectors: policy, sustainability
- What to do: Encourage or require reporting of precision modes, energy per token, and architectural choices (e.g., normalized vs standard) in grant/funding and regulatory contexts.
- Tools/products/workflows:
- Model cards with precision and energy disclosures
- Thirdโparty audits that verify lowโprecision robustness claims
- Dependencies/assumptions: Policy traction; industry consensus on metrics.
- Democratized compute access via lowโprecision training credits
- Sectors: public funding, philanthropy
- What to do: Allocate compute grants that prioritize FP4โnative (nGPT) projects to maximize tokens per dollar and reduce environmental impact.
- Tools/products/workflows:
- Grant guidelines with FP4/nGPT preference
- Shared FP4โready model zoos and checkpoints
- Dependencies/assumptions: Availability of shared Blackwell clusters; community adoption.
Notes on feasibility and scope
- The strongest immediate gains require NVIDIA Blackwell hardware with mature NVFP4 kernels and fused normalization ops.
- Large models may still keep a small tail of layers in higher precision; full endโtoโend FP4 for all scales warrants further testing.
- The core mechanism (signal coherence) is architectureโdriven; benefits should generalize across sizes and some topologies, but nonโlanguage modalities and subโ4โbit regimes need validation.
- Operational success depends on correct implementation of all nGPT normalization steps (weights, activations, residual formulation, scaling parameters) and on stable stochastic rounding and optimizer settings.
Glossary
- AdamW: An optimizer that decouples weight decay from gradient-based updates to improve generalization. "All training was conducted using the Nemotron-Pretraining-Datasets \cite{NemotronData} , AdamW optimizer with , ."
- Adaptive block scaling: A quantization technique that adjusts scaling per block to reduce FP4 quantization error. "To further reduce the inherent quantization error of NVFP4 formats, subsequent methods such as \cite{fourOverSix} introduced adaptive block scaling, modifying the NVFP4 algorithm to make the distribution of representable values more uniform and reduce error for near-maximal values."
- Amax (per-tensor amax scaling): Scaling based on the maximum absolute value within a tensor, used before quantization. "The nGPT NVFP4 configuration labeled ``ours'' removes both dynamic per-tensor amax scaling computation and RHT."
- BF16: A 16-bit floating-point format (bfloat16) commonly used in LLM training. "As shown in \cref{tab:1_2DenseDown} , the normalized architecture consistently outperforms the standard baseline across various downstream tasks in both BF16 and NVFP4 precisions."
- Blackwell GPUs: NVIDIAโs GPU architecture generation that natively supports NVFP4. "We focus on this low-precision format since it is supported natively by NVIDIA's Blackwell GPUs \cite{NvidiaBlack}."
- Bits-per-byte (BPB): A normalized evaluation metric for language modeling loss (lower is better). "We run the same model as in \cref{sec:AnalysisRobustness} and use the final validation bits-per-byte (BPB) as a normalized metric to compare between the runs."
- Dot-product SNR: The signal-to-noise ratio measured on the summed dot product output, reflecting robustness under quantization. "Figure~\ref{fig:dotsnr} shows the dot product SNR at each of the 12 layers individually averaged across all forward matmuls."
- Dynamic per-tensor scaling: Computing and applying a scale per tensor on-the-fly before quantization to control range and error. "In practice, standard transformer architectures often require fixes such as randomized Hadamard transforms (RHT), dynamic per-tensor scaling, or mixed-precision exceptions to maintain model quality \cite{NvidiaNVFP4}."
- GB200 GPU: A specific NVIDIA Blackwell-generation GPU used in performance measurements. "One-layer training speedup on a GB200 GPU as a function of hidden size."
- GEMM: General Matrix-Matrix Multiplication, the core linear algebra primitive for neural network layers. "which omits normalization for the inputs to the out projection GEMM in the attention block and the FFN2 GEMM in the MLP block."
- Hypersphere optimization: Training techniques that optimize parameters constrained on a sphere, often improving stability and transfer. "For instance, recent work on transferable hypersphere optimization \cite{Ren2026RethinkingLM} has re-evaluated LLM scaling under these conditions, demonstrating that hyperspherical constraints facilitate stable optimization, predictable scaling laws, and hyperparameter transferability across different model sizes."
- Hyperspherical geometry: The geometry of points constrained to a high-dimensional unit sphere, influencing representational structure and training dynamics. "The hyperspherical geometry already biases the model toward a representation in which signal survives 4-bit arithmetic unusually well."
- LayerNorm: A normalization technique applied across features within a layer to stabilize training. "Remove RMSNorm / LayerNorm layers"
- Logit rescaling: Multiplying pre-softmax outputs (logits) by a learnable factor to adjust output scale. "Logit rescaling: "
- LR warmup: A learning rate schedule that gradually increases the learning rate during initial training steps. "Remove weight decay and LR warmup"
- Mamba-Transformer: A hybrid architecture combining Mamba sequence models with Transformer components. "We validate this approach on both a 1.2B dense model and hybrid (Mamba-Transformer) MoE models of up to 3B/30B parameters."
- Mixture-of-Experts (MoE): An architecture that routes tokens to a subset of expert networks to increase capacity without proportional compute. "Across diverse architectures, including a 1.2B dense model and hybrid Mamba-Transformer Mixture-of-Experts (MoE) configurations ranging from 400M/600M to 3B/30B, nGPT supports stable end-to-end full NVFP4 training"
- nGPT: A normalized Transformer architecture that constrains activations and weights to the unit hypersphere. "We study nGPT \cite{loshchilov2025ngpt}, a transformer that constrains hidden states and model parameters to the unit hypersphere"
- nNVFP4: The paperโs shorthand for the NVFP4 training configuration used with nGPT. "\cref{fig:CombinedRelative}(a) shows the relative error of a 1.2B dense model trained on 1T tokens using NVFP4 and nNVFP4."
- NVFP4: NVIDIAโs 4-bit floating-point format for efficient training and inference. "nGPT supports stable end-to-end full NVFP4 training, without RHT, without dynamic per-tensor scaling"
- Randomized Hadamard Transforms (RHT): Orthogonal transforms applied to disperse outliers before quantization. "Specifically, this 'best recipe' relies on Randomized Hadamard Transforms (RHT) to computationally disperse outlier features"
- RMSNorm: Root-mean-square normalization, a variant of layer normalization that uses RMS statistics. "Remove RMSNorm / LayerNorm layers"
- Signal-to-Noise Ratio (SNR): The ratio of signal power to noise power; higher SNR indicates more robust, cleaner computation. "We define the SNR(dB) for a given tensor and its quantized counterpart as:"
- Stochastic Rounding (SR): A probabilistic rounding scheme used in low-precision training to produce unbiased gradient estimates. "and Stochastic Rounding (SR) for unbiased gradient estimation."
- Tensor cores: Specialized hardware units on NVIDIA GPUs optimized for high-throughput matrix multiplications. "At larger widths, GEMM time dominates and the benefit of Blackwell NVFP4 tensor cores becomes clear"
- Unit hypersphere: The set of vectors with unit norm in high-dimensional space; used here to constrain weights and activations. "an architecture that constrains weights and hidden representations to the unit hypersphere"
- Weight decay: L2 regularization applied to model parameters to reduce overfitting. "Remove weight decay and LR warmup"
- Weight normalization: A reparameterization technique that separates weight direction and magnitude, often improving optimization. "\cite{weightNorm} showed that weight normalization introduces implicit regularization that guides overparameterized models towards flatter, minimum-norm solutions."
Collections
Sign up for free to add this paper to one or more collections.
