Idea description

Initialize latent coordinate-frame parameters analytically from two temporally separated neural predictions instead of starting joint optimization from arbitrary translation and orientation. This removes the continuous gauge before backpropagation and should prevent EKF-like or gradient-based failures caused by large yaw and position initialization errors.

Formulas

$$d_q=q_2-q_1,\qquad d_\ell=\ell_2^v-\ell_1^v,\qquad d_q=R(\psi)d_\ell,$$

$$\hat\psi=\operatorname{atan2}(d_{q,y},d_{q,x})-\operatorname{atan2}(d_{\ell,y},d_{\ell,x})\pmod{2\pi},$$

$$\hat x=q_1-R(\hat\psi)\ell_1^v,\qquad \hat p=\hat x+R(\hat\psi)\ell_1^t,$$

$$\min_{x,p,\psi}\sum_{k=1}^{T}\rho\!\left(\|q_k-x-R(\psi)\ell_k^v\|_{\Sigma_v^{-1}}^2+\|p-x-R(\psi)\ell_k^t\|_{\Sigma_t^{-1}}^2\right),$$

Mathematical statement

Let d_q=q_2-q_1 and d_ell=ell_2^v-ell_1^v be the global and relay-frame displacement vectors at two views. In the noiseless planar case d_q=R(psi)d_ell, so the relative yaw is psi_hat=atan2(d_{q,y},d_{q,x})-atan2(d_{ell,y},d_{ell,x}) modulo 2pi, provided norm(d_ell)>0. Given this yaw, the relay translation is x_hat=q_1-R(psi_hat)ell_1^v. If the target vector is observed in the relay frame, the target estimate is p_hat=x_hat+R(psi_hat)ell_1^t; for noisy data, average these estimates over all views with robust weights. In a neural setting q_k and ell_k^v may be predicted by a pose encoder and sensor encoder, while ell_k^t is a learned target-bearing representation. The initialization is used only to choose the gauge; subsequent optimization can refine all quantities.

Implementation notes

1. Integration point: apply this as a warm-start layer before training a neural sensor-fusion model, recurrent filter, differentiable optimizer, or latent-variable encoder. Select two frames from each sequence with the largest predicted displacement norm, rather than using adjacent frames. 2. Pseudocode: encode q[1:T], ell_v[1:T], and ell_t[1:T]; choose (a,b)=argmax norm(q[b]-q[a]); compute dq=q[b]-q[a] and dl=ell_v[b]-ell_v[a]; reject the pair if norm(dl)<epsilon; calculate psi0 with the atan2 formula; calculate x0=q[a]-R(psi0)@ell_v[a]; calculate p0 as the robust weighted mean of x0+R(psi0)@ell_t[k]; initialize the calibration head with (p0,x0,psi0); then run 10-50 refinement steps using the joint residual objective. 3. The paper supplies the two-view identifiability construction and the failure condition d_l=0. Neural quantities, covariance weights, pair selection, and robust Huber or Tukey weighting are estimated empirically. 4. First cheap experiment: use a 2-D synthetic localization task with an MLP or GRU receiving noisy range-bearing-like vectors, initialize yaw errors uniformly over [-pi,pi] and translation errors up to 2 m, and compare random initialization, supervised frame initialization, and this two-view initializer. Measure iterations to reach a fixed residual and final target error. The prediction is that convergence failures will concentrate when the selected displacement norm is small or the window condition number exceeds about 100; on well-excited windows, initialization should converge from near-pi yaw errors and reduce optimization steps by at least a factor of two relative to random initialization.

Verification

Beats tuned baseline

Stage 1 · Toy mechanism gate: Passed ✓

Stage 2 · Mechanism transferred to benchmark: Confirmed ✓

Stage 2 · Practical benchmark result: Significant win ✓

Methodology: 8 paired seeds, permutation test (p<0.05) against a learning-rate-tuned baseline. How verification works

Stage 1 — Mechanism check agent confidence 9/10

Built a NumPy/SciPy constructive two-view gauge initializer and verified it numerically. Noiseless recovery was essentially exact, with position error 1.3e-15 and yaw error 4.4e-16. Under independent measurement noise, yaw RMSE followed the predicted inverse-displacement law with fitted log-log slope -1.007; near zero displacement, yaw became unidentifiable. The initializer also reduced median refinement evaluations from 9 to 5, although final residuals were unchanged.

Agent confidence: 9/10

Baseline: Random gauge refinement: median residual 0.009597, median 9 function evaluations, median target error 0.01999.
Idea: Constructive initializer: median residual 0.009597, median 5 function evaluations, target error 0.01492; noiseless position/yaw errors 1.3e-15/4.4e-16; noisy yaw slope -1.007 versus predicted -1.

Limitations: Tested only a tiny synthetic planar localization problem with equal weighting and SciPy refinement, not a neural encoder, recurrent filter, EKF, robust weighting, covariance weighting, or real sensor data. The singular sweep demonstrated loss of identifiability but did not estimate a formal condition-number threshold.

How to run: python3 two_view_experiment.py

Stage 2 — Benchmark vs. tuned baseline (arXiv:2608.09464) Sep 2, 2026

Beats the tuned baseline by 5.9% (p=0.0152, wins 7 / 8 paired seeds; metric: lower is better).

Benchmark: Two_view_gauge_localization_v2
Model: mlp_tiny
Paired seeds: 8
Baseline mean: 1.1336
Idea mean: 1.0666
Effect (Δ): -0.067 (−5.9%; negative = idea better)
Wins: 7 / 8 paired seeds
p-value: 0.0152 (permutation test, 20 000 shuffles)
Smallest detectable effect: ±5.0%
Mechanism: Confirmed ✓
Practical effect: Helps
Baseline tuning: swept over 3 configs

Limitations:

The registered benchmark is a synthetic planar localization task, not real sensor data. It uses a feed-forward MLP and represents the intervention as analytic target-estimate initialization of the output head rather than explicit jointly optimized translation, target, and yaw latent parameters. Robust Huber/Tukey weighting, covariance weighting, EKF or recurrent models, varying epoch budgets, and larger architectures were not tested.

How to run: python3 two_view_bench.py

Verdict computed by deterministic test code from paired-seed statistics — not by the language model.

Stage 2 — Benchmark Sep 1, 2026 latest Worked ✓

Agent confidence: 8/10

Implemented and benchmarked constructive two-view gauge initialization on the officially registered custom track two_view_gauge_localization_v2. Using the same MLP architecture, 18 epochs, and shared learning-rate grid, the idea achieved mean test MSE 1.066647 versus 1.133622 for the tuned baseline, with 7/8 paired wins and permutation p=0.0152. The NN-scale mechanism signature was confirmed: analytic two-view estimates had test MSE 0.011936 before training, while the trained idea system also outperformed the trained baseline.

Baseline: Tuned lr=0.01, 18 epochs; full 8-seed mean test MSE 1.1336221471, std 0.0914779152.
Idea: lr=0.01, 18 epochs; full 8-seed mean test MSE 1.0666468143, std 0.0693029094; paired delta -0.0669753328, 7/8 wins, permutation p=0.0152.

Benchmark result