Papers
Topics
Authors
Recent
Search
2000 character limit reached

Estimating the expected output of wide random MLPs more efficiently than sampling

Published 6 May 2026 in cs.LG, cond-mat.dis-nn, and stat.ML | (2605.05179v1)

Abstract: By far the most common way to estimate an expected loss in machine learning is to draw samples, compute the loss on each one, and take the empirical average. However, sampling is not necessarily optimal. Given an MLP at initialization, we show how to estimate its expected output over Gaussian inputs without running samples through the network at all. Instead, we produce approximate representations of the distributions of activations at each layer, leveraging tools such as cumulants and Hermite expansions. We show both theoretically and empirically that for sufficiently wide networks, our estimator achieves a target mean squared error using substantially fewer FLOPs than Monte Carlo sampling. We find moreover that our methods perform particularly well at estimating the probabilities of rare events, and additionally demonstrate how they can be used for model training. Together, these findings suggest a path to producing models with a greatly reduced probability of catastrophic tail risks.

Summary

  • The paper introduces a deterministic cumulant propagation framework that analytically propagates low-order cumulants to estimate MLP outputs with error scaling as O(n^(-K)).
  • It leverages Hermite expansions and diagrammatic summation to manage non-linear activations and reduce computational cost compared to traditional Monte Carlo methods.
  • Empirical results show order-of-magnitude improvements in efficiency and accuracy, particularly for rare event estimation in wide random MLPs.

Efficient Deterministic Estimation of Expected Outputs in Wide Random MLPs

Motivation and Problem Setting

The standard approach to evaluating expected losses or output statistics in neural networks is empirical: draw samples from the input distribution, run them through the network, and average the results (Monte Carlo (MC) sampling). While simple, this method is generally sub-optimal in terms of computational efficiency, especially in high-dimensional networks and when rare-event estimation is necessary. This paper addresses the deterministic estimation of expected outputs of wide, randomly initialized multilayer perceptrons (MLPs) given a formal input distribution (specifically, Gaussian), with the goal of achieving lower mean-squared error (MSE) per computational cost than MC sampling.

The problem is formulated as follows: Given a specific instance of an MLP with input, output, and hidden dimension nn, LL hidden layers, and specified activation functions ϕ1,,ϕL\phi_1,\dots,\phi_L, with weights drawn i.i.d. from N(0,c/n)\mathcal{N}(0, c/n), estimate EXN(0,In)[Mθ(X)]\mathbb{E}_{X \sim \mathcal{N}(0, I_n)}[M_\theta(X)] (the "quenched" mean), for given weights and specified computational budget.

Methodological Framework

The approach centers on deterministic, sample-free estimation using high-dimensional moment methods and asymptotic techniques rooted in statistical physics and probability theory. The key technical innovation is the propagation of low-order cumulants of pre- and post-activation distributions through the network, leveraging network width nn as a scaling parameter to control error. The approach is formalized in a cumulant propagation framework, based on:

  • Cumulant Expansion: The activation statistics of each layer are propagated by estimating their cumulants up to a chosen order KK. Given that for Gaussian random variables, higher cumulants vanish, deviations from Gaussianity (central in finite width networks) are captured by nonzero higher cumulants.
  • Hermite Expansions: Nonlinear activation functions are handled via Hermite expansions, allowing analytic propagation of cumulant estimates through polynomial or analytic nonlinearities.
  • Diagrammatic Summation: The computation of output cumulants is reduced to a combinatorial diagrammatic expansion, generalizing the standard Isserlis/formula and covariance propagation recurrences.

The algorithm tracks a minimal set of cumulant statistics such that the total MSE incurred by omitting higher-order terms scales as O(nK)O(n^{-K}) for “well-behaved” activations and sufficiently large nn.

Algorithmic Details and Variants

Several algorithmic variants are proposed, structured around choices of cumulant order, tensor representation, and computational/accuracy trade-offs:

  • Basic Cumulant Propagation: Tracks cumulants up to order KK, combining multilinear propagation rules (for linear layers) with Hermite-based recurrence relations (for nonlinearities). Achieves MSE LL0 in LL1 FLOPs.
  • Augmented Versions: Includes additional cumulant projections (e.g., traces of higher cumulant tensors) for improved finite-LL2 accuracy.
  • Factorized Representation: Leverages the symmetric and partially factorized structure of high-order cumulant tensors to reduce memory and computation from LL3 to LL4, in exchange for quadratic dependence in depth LL5.

These algorithms can be directly differentiated with respect to network parameters, enabling their use as estimators in mechanistic training or distillation.

Theoretical Results

A central theoretical contribution is the derivation and proof of asymptotic error bounds and computational complexity for the cumulant propagation algorithm family.

Main claims:

  • For polynomial activations and fixed depth LL6, the deterministic estimator achieves target MSE LL7 in LL8 time, versus LL9 for MC sampling—an asymptotic improvement by a factor of ϕ1,,ϕL\phi_1,\dots,\phi_L0.
  • For general analytic activation functions, analogous behavior is conjectured and empirically confirmed, with additional technical caveats regarding Hermite expansion truncation.

The error analysis relies on bounding the contraction of cumulant tensors through each layer, formalized in a general diagrammatic expansion. The depth dependence is worse for deterministic estimation than MC for very deep networks, but in practically relevant regimes (depth moderate, width large), the deterministic approach dominates.

Empirical Results

Extensive experiments substantiate the theory across a range of ϕ1,,ϕL\phi_1,\dots,\phi_L1, ϕ1,,ϕL\phi_1,\dots,\phi_L2, activation functions (ReLU, GELU, tanh), and cumulant orders ϕ1,,ϕL\phi_1,\dots,\phi_L3.

Key empirical findings:

  • Efficiency: For ReLU MLPs of width up to 256, deterministic cumulant propagation (factorized version) achieves order-of-magnitude lower MSE per FLOP than MC sampling across a broad computational regime, with improvements up to ϕ1,,ϕL\phi_1,\dots,\phi_L4–ϕ1,,ϕL\phi_1,\dots,\phi_L5 for moderate depths.
  • Rare Event Estimation: For estimation of events with probabilities ϕ1,,ϕL\phi_1,\dots,\phi_L6 (with ϕ1,,ϕL\phi_1,\dots,\phi_L7 the sample size of MC estimate), deterministic methods outperform all stochastic and Gaussian-extrapolation baselines, maintaining useful relative error where MC degenerates.
  • Mechanistic Distillation: Deterministic estimators can be utilized to train student networks by minimizing analytically estimated expected loss. While not quite matching SGD’s efficiency on non-random networks, this demonstration opens a path for future research on analytic training.
  • Scaling Law Confirmation: Empirically validated scaling of MSE as ϕ1,,ϕL\phi_1,\dots,\phi_L8, with clear benefits from increasing cumulant order ϕ1,,ϕL\phi_1,\dots,\phi_L9 at moderate and large widths.

Implications and Future Directions

The results have significant implications for both practical training and theoretical understanding of wide MLPs.

  • Training for Extreme-Value Reliability: By efficiently estimating expected loss in rare-event regimes, these methods offer the potential to train networks that are robust to tail risks and failure modes unseen in finite samples—an important consideration for safety-critical systems.
  • Mechanistic Training Paradigms: The ability to analytically propagate uncertainty and optimize “mechanistic” loss estimates could pave the way for training protocols wherein sample inefficiency is side-stepped, provided one can extend the theory to post-initialization or adapt to non-Gaussian input distributions.
  • Extension to Learned or Structured Networks: While the present results rigorously apply to random (or “maximally unstructured”) weights at initialization, the methodology suggests avenues for approximate analytic propagation in partially trained or structured networks, via decomposition into structured/random components.
  • Algorithmic Generalizations: Beyond MLPs, similar strategies may be applicable to other architectures wherever input-output relations admit sufficient analytic description (e.g., convolutional or residual networks at initialization).

Depth and activation dependence remain as limitations: For very deep networks, the error scaling for deterministic estimators is suboptimal, and algorithmic improvements are needed to match MC in these cases.

Conclusion

This work demonstrates that analytic, deterministic estimation using cumulant propagation and Hermite expansions can substantially outperform MC sampling for wide random MLPs, both in theory and practice, especially when rare event probabilities or low MSE are required. These results elucidate the connection between asymptotic network theory and practical algorithm design, and offer promising foundations for future research on sample-free training methods, rare event risk mitigation, and mechanistic interpretability in neural networks.

Reference:

"Estimating the expected output of wide random MLPs more efficiently than sampling" (2605.05179)

Paper to Video (Beta)

No one has generated a video about this paper yet.

Whiteboard

No one has generated a whiteboard explanation for this paper yet.

Explain it Like I'm 14

What This Paper Is About (Big Picture)

Training and testing neural networks usually means “try lots of examples and average the results.” That’s like tasting a big pot of soup over and over to guess how salty it is. This paper shows a different way: instead of sampling many times, they do the math to estimate the average output of a certain kind of neural network without running any examples through it. In many cases, this math-based method is faster and more accurate than sampling, especially for estimating very rare (but important) outcomes.

The networks they study are wide random MLPs (multilayer perceptrons), which are standard fully connected neural networks with many neurons per layer and random weights at the start.

What Questions They Asked

  • Can we estimate the average output of a wide, randomly initialized MLP when the inputs follow a normal (Gaussian) distribution, without using lots of random samples?
  • Can such “mechanistic” math-based estimates be cheaper (fewer computer operations) and more accurate (lower error) than Monte Carlo sampling (the usual “try many examples” approach)?
  • Does this method work especially well for low-probability events (rare “tails”) that are very hard to measure by sampling?
  • Can these estimates also be used to train models (not just measure them)?

How Their Method Works (In Plain Language)

Think of passing a cloud of inputs through a network. Instead of tracking every single input, they track simple “summaries” of the cloud at each layer. Then they update those summaries as the data moves through weights and activation functions. Finally, from the last layer’s summaries, they read off the network’s expected (average) output.

Here are the key ideas, explained simply:

  • “Summaries” of a distribution: These include things like the mean (average), variance (how spread out it is), and higher-order “shape” measures. Mathematicians call these cumulants.
    • First-order cumulant = mean.
    • Second-order cumulants = variances and covariances.
    • Higher-order cumulants describe more detailed shape features beyond a normal (bell-curve) distribution.
  • Propagating cumulants through the network:
    • Through a weight matrix (a linear step): it’s like mixing ingredients — the way summaries change is fairly straightforward (you can compute new means/variances by combining the old ones).
    • Through an activation function (a nonlinear step like ReLU): trickier. They use something called a Hermite expansion. You can think of it like approximating a squiggly curve by adding up simple building-block curves. This lets them predict how the summaries change after the nonlinearity.
  • Making it accurate and efficient:
    • They track cumulants up to some maximum order K. Higher K = more detail = more compute.
    • They add technical tweaks to handle cases where the same neuron shows up multiple times in a calculation (which can cause big correlations). Two examples:
    • Power cumulants: track summaries of powers (like x2) to better capture diagonal terms exactly.
    • For odd K, they also keep one extra “trace” number that compresses certain higher-order information.
    • Factorized representation: for higher orders, they store the big tensors (multi-dimensional arrays) in a clever compressed way. This cuts the compute cost roughly by a factor equal to the network’s width (number of neurons per layer), without losing accuracy.
  • Why this can beat sampling:
    • Sampling accuracy improves only like 1/sqrt(N) where N is the number of samples. To get 10 times better, you need 100 times more samples.
    • Their approach improves by carefully carrying forward precise statistical information layer by layer. For wide networks, its error shrinks fast, and its compute grows slowly, so it can win big.

What They Found

  • Theory (guarantees on paper):
    • For networks of fixed depth (number of layers), their method can reach a target error using about n times fewer floating-point operations (FLOPs) than standard sampling. Here, n is the network’s width (neurons per layer).
    • In short: as networks get wider, their method gets relatively more efficient than sampling.
  • Experiments (tests on real networks):
    • On ReLU MLPs with width 256 and up to 8 hidden layers, their best versions often beat Monte Carlo sampling by large margins (10× to 1000× fewer FLOPs for the same error), depending on depth and the chosen K.
    • The method works not just for ReLU but also for other activations like GELU and tanh.
    • It’s especially good for low-probability events. Sampling struggles when events are rare (you might not see them at all), but their method can still estimate those probabilities well. They showed strong performance even when probabilities were 100–10,000 times smaller than what ordinary sampling could handle with the same compute.
    • They also used their estimator to train a “student” network to match a random “teacher” network’s behavior (mechanistic distillation). It worked and was competitive with usual training, though slightly less efficient in their basic demo.
  • Practical note about compute:
    • They measured compute in FLOPs (a fair way to compare methods). In real wall-clock time, some overhead made their code slower than the FLOP count suggests, but this is an engineering issue they expect could be optimized.

Why This Matters

  • Faster, more reliable estimates: If you can get accurate averages and probabilities without running tons of examples, you can save a lot of compute.
  • Safer models by focusing on rare events: Many real-world risks are rare but dangerous. Sampling often misses them. A mechanistic method that estimates tiny probabilities well could train models to avoid catastrophic mistakes, even if those mistakes almost never show up in training data.
  • A new way to think about training: Instead of “try examples and see,” this points toward “use the rules and structure to calculate what will happen.” That could change how we design, analyze, and train neural networks — not just at the start of training but potentially throughout, once these techniques are extended to learned (not-just-random) networks.

Final Takeaway

The paper shows that, for wide random MLPs and Gaussian inputs, you can often do better than plain sampling. By mathematically tracking how a distribution flows through the network (using cumulants and Hermite expansions), you can estimate averages — and especially rare-event probabilities — more efficiently. This could unlock safer and more compute-efficient ways to build and train neural networks in the future.

Knowledge Gaps

Knowledge gaps, limitations, and open questions

Below is a single consolidated list of what remains missing, uncertain, or unexplored in the paper, phrased to be actionable for future research.

  • Depth dependence not characterized: Theoretical guarantees assume constant depth L and do not quantify error or runtime dependence on L; provide non-asymptotic bounds or precise asymptotics for growing depth (e.g., L → ∞).
  • Narrow-network regime unresolved: No methods or bounds for fixed width n with ε → 0; develop estimators that beat sampling without relying on 1/n expansions.
  • Average-case over weights only: Results are in expectation over random Gaussian weights; derive high-probability guarantees over weights or per-network deterministic conditions for accuracy.
  • Polynomial-activation restriction in theory: Proofs assume polynomial activations; extend rigorous guarantees to common non-polynomial activations (ReLU, GELU, tanh), including Hermite and diagram-truncation error control.
  • Uncertain depth-wise error accumulation: No computable layerwise truncation-error bounds for cumulant and diagram summations; provide bounds and stopping rules to control error propagation across layers.
  • K selection lacks finite-n guidance: No adaptive procedure to choose cumulant order K to meet a target ε at realistic widths; design error estimators and K-adaptation strategies during propagation.
  • Memory and constant-factor complexity: For K ≥ 3, storage and ops still scale as n{K-1}–nK with large constants; quantify constants, memory footprints, and develop more compact/sparse/factorized representations and symmetric-tensor kernels.
  • Wall-clock vs FLOPs gap: Non-matmul overhead dominates runtime despite small FLOP share; implement and benchmark optimized kernels (e.g., symmetric einsums, kernel fusion) and report real-device speedups.
  • General input distributions: Methods assume X ~ N(0, I); extend to anisotropic covariances, mixtures of Gaussians, heavy-tailed or elliptic distributions, and black-box empirical inputs (e.g., via moment-matching or score-based surrogates).
  • Losses depending on inputs: Only simple output-dependent losses handled by treating loss as an “activation”; develop recipes for common ML losses (cross-entropy, hinge, classification margins) that depend on both inputs and outputs.
  • Biases and modern components: Although “adaptable,” there is no rigorous/empirical treatment of biases, layernorm, residual connections, dropout, or other modern modules; extend algorithms and analyze their impact on cumulant propagation.
  • Architectural scope limited to MLPs with equal widths: Generalize to varying layer widths, residual MLPs, CNNs, attention/transformers, and structured matrices; specify how diagram rules and factorized tensors carry over.
  • Weight distribution assumptions: Weights i.i.d. Gaussian with variance 2/n; analyze robustness to non-Gaussian, correlated, or structured weights (e.g., orthogonal, Toeplitz, low-rank) and different initialization scalings.
  • Effect of initialization scale c: Only c = 2/n is used; systematically analyze sensitivity of estimator accuracy and stability to c and other popular initializations (e.g., Xavier).
  • Finite-width, non-asymptotic bounds: Provide explicit finite-n error bounds (not just big-O) with numerically meaningful constants, at least for ReLU networks and small K.
  • Constants in runtime/error rates: c_K, c′_K, c′′_K are unspecified; upper-bound or estimate them for standard activations to guide practical parameter choices and predict crossovers with sampling.
  • Factorized speedups for K = 2: Factorization is only shown beneficial for K ≥ 3; investigate whether mixed-order or hybrid representations can accelerate K = 2 while preserving estimator fidelity.
  • Numerical stability: Assess stability when tracking higher-order cumulants (e.g., roundoff, catastrophic cancellation) and propose conditioning/regularization schemes.
  • Low-probability estimation coverage: Experiments use a single threshold (z > 3) at the final layer; evaluate across multiple tail events, quantiles, multi-dimensional predicates, and different network depths and widths.
  • Ground truth for rare events: Current ground truth relies on massive Monte Carlo; develop alternative references (analytic bounds, importance sampling with guarantees) to validate probabilities below feasible MC rates.
  • Hybrid mechanistic–sampling estimators: Explore control variates and importance sampling that combine small numbers of samples with mechanistic estimates to further reduce error, especially in tails.
  • Gradient estimation theory: No guarantees on bias/variance of gradients through mechanistic estimates; analyze gradient accuracy and convergence of mechanistic training vs SGD for representative objectives.
  • Training beyond initialization: Methods target random initializations; formalize a “structure vs randomness” decomposition for partially trained weights and instantiate algorithms that exploit learned structure.
  • Mechanistic distillation scope: Demonstrations are small-scale and on random teachers; scale to trained teachers, larger widths, real datasets, and compare generalization, sample efficiency, and robustness.
  • Full-distribution estimates: Focus is on expected output (means); extend to higher moments, quantiles, and full predictive distributions to enable risk-sensitive training (e.g., CVaR, tail risk constraints).
  • Multi-output and loss coupling: Clarify how to handle coupled losses across output coordinates (e.g., softmax cross-entropy) and propagate cross-cumulants efficiently.
  • Activation coverage: Assess performance and provide Hermite-coefficient tooling for a broader set of nonlinearities (leaky ReLU, ELU, Swish, SiLU), including handling non-smooth points rigorously.
  • Bias-variance tradeoffs in augmented variants: Provide theory guiding when augmented vs basic vs factorized variants are preferable under a fixed compute/memory budget.
  • Robustness to distribution shift: Empirically test whether mechanistic training reduces tail risks under shifts compared to SGD-trained baselines; quantify improvements in out-of-distribution safety metrics.
  • Benchmarks and reproducibility: Provide standardized benchmarks (architectures, depths, widths, input distributions, tail events) and optimized open-source kernels to enable fair, hardware-level comparisons to sampling.

Practical Applications

Practical Applications of “Estimating the expected output of wide random MLPs more efficiently than sampling”

Below are actionable, real-world applications derived from the paper’s findings and methods. Each item includes sectors, potential tools/workflows, and key assumptions or dependencies that affect feasibility.

Immediate Applications

These can be prototyped or deployed now in settings close to the paper’s assumptions (wide MLPs, Gaussian/whitened inputs, random or near-initialized weights, closed-form output losses).

  • Efficient expectation and tail-probability estimation for uncertain inputs in MLP components
    • What: Replace Monte Carlo (MC) forward passes with cumulant propagation to estimate output means/variances and low-probability threshold events for modules receiving Gaussian (or whitened) noise.
    • Sectors: software/ML infrastructure; robotics and control; embedded systems; signal processing; education/research.
    • Tools/workflows:
    • Integrate a “cumulant propagation head” (basic or factorized) into PyTorch/JAX for layer-by-layer uncertainty/expectation propagation.
    • Use K=2 for fast mean/covariance propagation (Gaussian approximation) or K≥3 for rare-event probabilities.
    • Add a “risk head” that computes P(z>t) via Hermite expansions near the final layer.
    • Assumptions/dependencies:
    • Inputs are Gaussian or can be whitened/approximated as Gaussian.
    • Networks are wide (n ≳ 100–1,000) and not too deep (constant L; empirically best up to ~4–8 layers at n=256).
    • Activations with available/tractable Hermite coefficients (ReLU, GELU, tanh; biases supported with minor adaptation).
    • Most robust at or near random initialization; guarantees are tightest for random He-initialized MLPs.
  • Faster rare-event (tail risk) estimation for early-stage safety audits
    • What: Use the factorized cumulant propagation (e.g., K=3) to estimate low probabilities (e.g., threshold exceedances) with orders-of-magnitude fewer FLOPs than MC, especially when true probabilities ≪ 1/N (N = MC samples).
    • Sectors: AI safety, simulation QA, robotics test benches, software verification for ML components.
    • Tools/workflows:
    • Batch-run tail-probability scans over design thresholds or sensor-noise levels without brute-force sampling.
    • Add “tail-risk regression tests” to CI pipelines that flag extreme-probability regressions at initialization time.
    • Assumptions/dependencies:
    • Gaussian/whitened inputs and fixed weights.
    • Works best at large width and modest depth.
    • Tail events expressed as closed-form output functions (e.g., final threshold function).
  • Mechanistic distillation for research prototypes
    • What: Train a student network to match the expected outputs of a (random) teacher by differentiating through the analytic estimator (mechanistic distillation).
    • Sectors: academia; ML methodology.
    • Tools/workflows:
    • Prototype a “mechanistic trainer” that uses analytic gradients of expected loss instead of stochastic mini-batches in controlled settings (e.g., Gaussian inputs, linear/threshold output losses).
    • Assumptions/dependencies:
    • Strongest performance when both teacher and student are in the random, wide regime.
    • For partially trained or narrow networks, reliability degrades; may need hybrid sampling-analytic strategies.
  • Compute and energy savings in expectation-heavy experiments
    • What: Replace MC in repeated expectation-estimation tasks (e.g., hyperparameter sweeps that use Gaussian-noise probes of sensitivity) with cumulant propagation for large FLOP and energy savings.
    • Sectors: ML infrastructure; sustainability; HPC labs.
    • Tools/workflows:
    • Plug-in estimator that collapses evaluation runs (many MC samples) into one analytic pass, leveraging factorized tensors for K≥3.
    • Assumptions/dependencies:
    • Same as above (Gaussian/whitened inputs; wide MLPs; closed-form losses).
    • Availability of framework-level implementations (e.g., PyTorch/JAX) with efficient symmetric tensor einsums.
  • Curriculum and pedagogy: deterministic uncertainty propagation
    • What: Use this method as a teaching/lab tool to demonstrate cumulants, Hermite expansions, and their use in neural uncertainty propagation.
    • Sectors: education; academic labs.
    • Tools/workflows:
    • Assignments or tutorials comparing MC vs. cumulant propagation in small MLPs for mean/covariance and rare-event estimation.
    • Assumptions/dependencies:
    • Educational setting; no additional constraints beyond basic framework support.

Long-Term Applications

These require further research, scaling, or engineering (e.g., extensions to trained/deeper architectures; non-Gaussian inputs; regulatory acceptance).

  • Mechanistic training for rare-event minimization in safety-critical systems
    • What: Train models to explicitly minimize tail risks by optimizing analytic estimates of rare-event probabilities (mechanistic training), reducing dependence on chance observation of rare failures during SGD.
    • Sectors: autonomous systems (AVs, drones, robotics), healthcare devices, finance (risk engines), energy (grid control).
    • Tools/workflows:
    • “Risk-regularized optimizers” that backpropagate through analytic tail risk.
    • Hybrid “structure vs. randomness” estimators that decompose trained weights into structured + random parts to maintain analytic tractability.
    • Assumptions/dependencies:
    • Extension of methods to partially trained networks and deeper architectures.
    • Robustness to non-Gaussian or empirical input distributions (e.g., via normalizing flows/whitening).
    • Efficient kernels for higher-order cumulants at scale.
  • Static analysis and certification of neural tail risks
    • What: Build “static analyzers” for neural modules that deliver certified or bounded estimates of failure probabilities under specified input distributions, improving assurance and pre-deployment checks.
    • Sectors: regulation/compliance; AI assurance; defense; aerospace; medical devices.
    • Tools/workflows:
    • Compliance-grade toolchains that produce quantitative tail-risk certificates for specified operating conditions.
    • Integration with standards for ML safety cases (model cards, risk reports) including rare-event evidence.
    • Assumptions/dependencies:
    • Regulatory frameworks receptive to analytic evidence.
    • Theoretical extensions to deliver formal bounds (not just estimates) in trained networks and non-Gaussian settings.
  • Generalization to transformers/CNNs and real-world input distributions
    • What: Extend cumulant propagation and diagram-based expansions to common architectures and non-Gaussian inputs (e.g., via learned latent-Gaussian maps).
    • Sectors: software/AI platforms; NLP; vision; multimodal systems.
    • Tools/workflows:
    • Normalizing-flow or diffusion-based “input mappers” that Gaussianize inputs before propagation.
    • Layer-wise factorized cumulant representations for attention and convolution.
    • Assumptions/dependencies:
    • New theory and numerics for attention mechanisms and weight sharing.
    • Efficient exploitation of symmetry and sparsity to contain combinatorial growth.
  • Analytic evaluation for formal environments (games, theorem proving, simulators)
    • What: Use analytic expectation estimation where rules are known and losses are closed-form: board games, formal mathematics, physics-based simulators.
    • Sectors: software/games; formal methods; scientific computing/engineering.
    • Tools/workflows:
    • “Mechanistic value estimators” that replace or augment self-play rollouts with analytic approximations under specified input priors.
    • Hybrid pipelines combining limited sampling with mechanistic corrections for variance reduction.
    • Assumptions/dependencies:
    • Formalizable input/transition distributions and loss functions.
    • Adaptations to non-MLP architectures typically used in these domains.
  • Online monitoring and shift-aware tail-risk guards
    • What: Deploy lightweight analytic monitors that estimate tail probabilities for current operating conditions and flag risk increases (e.g., due to distribution shift).
    • Sectors: MLOps; monitoring/observability; safety.
    • Tools/workflows:
    • Streaming “risk meters” that maintain cumulant estimates for inputs (via online whitening or learned Gaussianization) and compute exceedance probabilities in real time.
    • Assumptions/dependencies:
    • Robust streaming estimates of input cumulants.
    • Calibrated mappings from empirical to approximate Gaussian representations.
  • Hardware and systems support for higher-order analytic propagation
    • What: Accelerate factorized cumulant propagation with kernels for symmetric tensor einsums and diagram summations; integrate at compiler/runtime level.
    • Sectors: AI hardware; systems/compilers; cloud platforms.
    • Tools/workflows:
    • Vendor libraries for symmetric/factorized tensor algebra.
    • Graph compilers that fuse cumulant einsums with standard linear layers.
    • Assumptions/dependencies:
    • Demand from applications above; standardization of APIs for cumulant operators.
  • Risk-aware architecture design and initialization
    • What: Use mechanistic estimates at design time to select architectures/initializations that minimize tail risks or sensitivity to input noise.
    • Sectors: ML engineering; safety-critical design.
    • Tools/workflows:
    • AutoML modules that score candidate architectures/initializations by analytic tail-risk metrics before training.
    • Assumptions/dependencies:
    • Validity of analytic scores as predictors of downstream (trained) behavior; empirical validation pipelines.

Notes on Cross-Cutting Assumptions and Dependencies

  • Input distribution: Current methods assume Gaussian inputs; practical use may require whitening, Gaussianization (e.g., normalizing flows), or acceptance of approximation error.
  • Network regime: Theory and the largest gains hold for wide MLPs with constant depth and (near) random He initialization; performance degrades with depth at fixed width.
  • Losses: Best suited to closed-form functions of the output (e.g., linear loss, thresholds). More complex losses that depend on inputs may need additional modeling.
  • Activations: ReLU, GELU, tanh are supported; theory proven for polynomial activations, with empirical support beyond that; biases are supported with adaptations.
  • Compute: Factorized versions deliver asymptotic FLOP savings (∼n vs. MC) but require efficient implementations of symmetric/factorized tensor operations.
  • Validation: For safety-critical deployment, transition from estimates to verifiable bounds (and acceptance by regulators) is an open research/standards question.

Glossary

  • Activation extrapolation: A technique that extrapolates activation behavior to estimate rare-event probabilities. "their activation extrapolation methods have features in common with our low probability estimation methods."
  • Annealed average: Expectation taken over random parameters (e.g., weights) rather than over inputs. "the annealed average over the choice of weights"
  • Augmented algorithm: A variant that tracks additional cumulant information (e.g., traces) to improve accuracy at extra cost. "We refer to this as the augmented version of our algorithm"
  • Catastrophic tail risks: Extremely low-probability outcomes with very high loss. "greatly reduced probability of catastrophic tail risks."
  • Covariance propagation: Analytic technique for propagating means and covariances through networks. "formulas for covariance propagation"
  • Cumulant: Joint statistics that generalize moments and capture non-Gaussian structure; first two orders are mean and covariance. "The kth-order cumulants of a vector-valued random variable XRnX\in\mathbb R^n"
  • Cumulant propagation: Propagating low-order cumulants layer by layer to approximate activation distributions. "we employ cumulant propagation"
  • Cumulant tensor: A multi-index array collecting all kth-order cumulants for a vector; used throughout the propagation. "the (K+1)th\left(K+1\right)th-order cumulant tensor"
  • Diagram summation formula for cumulants: A Hermite-based combinatorial expansion expressing output cumulants via input cumulants and activation Hermite coefficients. "We refer to this formula as the (Hermite-based) diagram summation formula for cumulants"
  • Einsum: A tensor-contraction notation/operation (Einstein summation) used to implement multilinear updates efficiently. "taking an einsum of the kkth-order estimated cumulant tensor"
  • Factorized representation: A compact form of a higher-order cumulant tensor that reduces storage and computation. "admits a factorized representation of size nK1n^{K-1}"
  • Factorized version: An algorithmic variant that maintains cumulant tensors in a factorized form to cut FLOPs. "We refer to this as the factorized version of our algorithm"
  • FLOPs: Floating-point operation count used to measure computational budget. "floating-point operations (FLOPs)"
  • Full trace: The complete contraction (sum over repeated indices) of a higher-order cumulant tensor used to control errors for odd K. "the full trace of the (K+1)th\left(K+1\right)th-order cumulant tensor"
  • Gaussian processes: Distributions over functions where any finite set of function values is jointly Gaussian; used to analyze infinitely wide networks. "infinitely-wide random networks as Gaussian processes"
  • GELU: Gaussian Error Linear Unit, an activation function that blends linear and Gaussian behaviors. "we check the performance of our algorithm on GELU\operatorname{GELU} \citep{gelu}"
  • Hermite coefficients: Coefficients in the Hermite polynomial expansion of an activation under a Gaussian measure. "The Hermite coefficients in this expansion are given by"
  • Hermite expansion: Series expansion of a function in Hermite polynomials relative to a Gaussian, enabling analytic propagation through nonlinearities. "the Hermite expansion of ϕ\phi with respect to YY is the series expansion"
  • Mechanistic distillation: Distilling a teacher into a student by optimizing a differentiable, analytic expectation estimate rather than sample-based loss. "a process we refer to as mechanistic distillation."
  • Mechanistic training: Training by differentiating mechanistic (analytic) loss estimates instead of stochastic sample averages. "We refer to this as mechanistic training."
  • Monte Carlo sampling: Estimating expectations by averaging outputs over random samples from the input distribution. "The baseline estimation procedure we consider is Monte Carlo sampling."
  • Neural Tangent Kernel: A kernel governing training dynamics of infinitely wide networks under gradient descent. "the Neural Tangent Kernel associated with the training of infinitely-wide networks"
  • Noticeable function: In complexity/cryptography, a function bounded below by an inverse polynomial in input size. "for every noticeable function 0<ε ⁣(n)10<\varepsilon\!\left(n\right)\leq 1"
  • Partition formula: The relation expressing moments as sums over products of cumulants across set partitions. "by the partition formula"
  • Power cumulants: Cumulants of powers of distinct coordinates (e.g., κ[X_iα1,…,X_jαm]) used to handle repeated-index effects. "The kkth-order power cumulants of XX are the cumulants of the form"
  • Probabilist's Hermite polynomial: The monic orthogonal polynomials under the standard Gaussian, used in Hermite expansions. "the kkth probabilist's Hermite polynomial"
  • Quenched average: Expectation over inputs with parameters held fixed, contrasting with annealed averages over parameter randomness. "i.e., a quenched average, in the language of statistical physics."
  • Strassen-type matrix multiplication: Fast sub-cubic algorithms for matrix products; here excluded in runtime assumptions. "We assume the use of naive rather than Strassen-type matrix multiplication in all algorithms."
  • Structure versus randomness: A heuristic dichotomy splitting objects into a structured part and a random residual for analysis. "akin to the ``structure versus randomness'' dichotomy"
  • Threshold function: A discontinuous activation that outputs 1 if input exceeds a cutoff and 0 otherwise. "the threshold function $\mathbbm 1_{z>3}$"
  • Traceless tensor: A tensor whose contractions over any index pair vanish. "a traceless tensor is one for which taking the trace over any pair of indices results in the zero tensor"
  • Variance-normalized MSE: Mean squared error normalized by the variance of a single forward pass to enable fair comparisons. "variance-normalized MSE"
  • Wide random MLPs: Fully connected networks at large width with randomly initialized weights, analyzed in the paper’s regime. "wide random multilayer perceptrons (MLPs)"

Open Problems

We haven't generated a list of open problems mentioned in this paper yet.

Collections

Sign up for free to add this paper to one or more collections.

Tweets

Sign up for free to view the 13 tweets with 125 likes about this paper.