Incoherent Frame Averaging for Tensor Layers
Implementation & benchmark of arXiv:2607.27613 — Regularized Bulk Universality versus Bounded-Disorder Nonuniversality for Annealed Complexity of Spherical $p$-Spin Landscapes
Source paper: Regularized Bulk Universality versus Bounded-Disorder Nonuniversality for Annealed Complexity of Spherical $p$-Spin Landscapes arXiv:2607.27613 ⓘ · analyzed Aug 31, 2026
AI-generated research hypothesis, automatically tested. Not peer-reviewed.
Idea description
Add randomized orthogonal frame mixing and an incoherence penalty to tensorized neural layers so that predictions and gradients are less controlled by a small coordinate block. The goal is to retain the bulk, approximately Gaussian behavior of tensor contractions while preventing rare coherent directions from dominating training.
Formulas
Mathematical statement
The paper studies the ordered-tensor Hamiltonian H_N^J(\sigma)=N^{-(p-1)/2}\sum_{i_1,\ldots,i_p=1}^N J_{i_1\cdots i_p}\sigma_{i_1}\cdots\sigma_{i_p} on the sphere \mathbb S_N=\{\sigma\in\mathbb R^N:\|\sigma\|_2^2=N\}, where p\geq3 and the independent disorder entries J_I have mean zero and variance one. For uniformly subexponential disorder whose first m moments match Gaussian moments, the regularized bulk error satisfies |\log(\mathbb E\mathcal Z_{N,L}^{J}/\mathbb E\mathcal Z_{N,L}^{G})|\leq C N q_N^{m-1}, with q_N=L^{p-1}N^{-(p-2)/2}(\log N)^{(p-1)/2}; L is a coordinate-size or frame-radius cutoff, m is the number of matched moments, and C is independent of N. The obstruction is a coherent block of roughly N^{1/p} coordinates, so entrywise bounds alone do not prevent localized behavior. We adapt this by penalizing the fraction of energy in the b largest coordinates after several orthogonal frames, for both activations and gradients.
Implementation notes
(1) Integration point: apply this to a tensorized MLP or tensor-contraction layer F whose input x is flattened to dimension N. During training, create R=2--8 fixed random orthogonal or signed-permutation frames R_r, transform the layer input as x_r=R_r x, evaluate F(x_r; heta), inverse-transform the output, and average. Also register a gradient hook on x to obtain g_r=\partial\mathcal L_{task}/\partial x_r. The regularizer is applied to activations and optionally gradients; it is not needed at inference if the frame ensemble is folded into a fixed deterministic average.
(2) Pseudocode:
for x, y in batch:
task = 0; reg = 0
for r in range(R):
xr = R[r] @ x
pred_r = R[r].T @ F(xr, theta)
task += cross_entropy(pred_r, y) / R
gr = grad(task, xr, create_graph=use_second_order)
topx = sum(top_b(xr**2)) / (sum(xr**2) + eps)
topg = sum(top_b(gr**2)) / (sum(gr**2) + eps)
reg += topx + lambda_g * topg
loss = task + lambda_inc * reg / R
theta = optimizer_step(theta, grad(loss, theta))
Here top_b selects the b largest entries, b is tested near N^(1/p), and epsilon prevents division by zero. Stop gradients through gr if second-order differentiation is too expensive.
(3) Taken from the paper: the tensor normalization N^(-(p-1)/2), the bulk-error scale q_N, and the coherent-block prediction b approximately N^(1/p). Estimated during training: top-b energy, gradient coherence, activation norms, and frame-to-frame output variance. Use q_N to set a schedule: start with lambda_inc=0, then increase it only if q_N is not already small and coherence exceeds a target.
(4) First experiment: use a tensorized two-layer MLP on MNIST or CIFAR-10 with matched parameter count. Compare an ordinary tensor layer, weight decay, random frame averaging without the penalty, and the full method. Measure validation accuracy, gradient-norm 99th percentiles, seed-to-seed loss variance, frame output variance, and top-b activation energy. Add a controlled b-coordinate spike to inputs or weights. Success is clean accuracy no worse than baseline, substantially lower coherence and gradient tails, and smaller degradation under the spike; a concrete target is at least 2x lower top-b energy or a measurable reduction in worst-seed validation loss.
Verification
This idea has not been verified yet.
Verification happens in two stages: Stage 1 — a mechanism check on a toy system confirms the claimed mathematical phenomenon reproduces; Stage 2 — a benchmark implements the idea on a real (small) neural network task and compares it against a tuned baseline over 8 paired seeds with a permutation test.
Artifacts
Artifacts unavailable.