Estimating the expected output of wide random MLPs more efficiently than sampling
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.
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 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 "
- 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 -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 th-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 "
- 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 -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 \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 with respect to 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 "
- 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 th-order power cumulants of are the cumulants of the form"
- Probabilist's Hermite polynomial: The monic orthogonal polynomials under the standard Gaussian, used in Hermite expansions. "the th 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)"
Collections
Sign up for free to add this paper to one or more collections.