DeepCORD: Learning-Augmented Distributed Optimization

• DeepCORD is a learning-augmented framework for distributed factor graph optimization that leverages Lie group theory and Riemannian dynamics.
• It unfolds the CORD optimizer into differentiable iterations with a self-supervised policy that dynamically tunes solver parameters using augmented graph features.
• DeepCORD demonstrates robust performance on both SE(3) and SL(4) benchmarks, outperforming traditional solvers in synchronous and asynchronous multi-robot settings.

Searching arXiv for the exact DeepCORD paper and closely related optimization baselines mentioned in the provided data. Search query: "DeepCORD distributed factor graph optimization matrix Lie groups arXiv" DeepCORD denotes a learning-augmented framework for distributed factor graph optimization on general matrix Lie groups, introduced in “Learning Adaptive Solvers for Distributed Factor Graph Optimization on Matrix Lie Groups” (Shin et al., 9 Jul 2026). The method unfolds a principled, parallel, and accelerated Riemannian optimizer, CORD, into differentiable iterations and learns a self-supervised local feedback policy that tunes solver parameters online from local optimization and communication context. In current arXiv usage, this is the paper that formally uses the name “DeepCORD.” A separate diffusion MRI paper has been discussed under a similar shorthand elsewhere, but its authors explicitly refer to their method as “deep constrained spherical deconvolution” or deep-CSD rather than DeepCORD (Yao et al., 2023).

1. Terminological scope and optimization setting

DeepCORD is formulated for distributed factor graph optimization on matrix Lie groups. Let $G \subset GL(n)$ be a matrix Lie group with Lie algebra $\mathfrak g$, and let the factor graph be a connected graph $\mathcal G=(\mathcal V,\mathcal E)$ with node variables $X_u \in G$ and pairwise relative measurements $Z_{uv} \approx X_u^{-1}X_v$. The global problem is written as

$$\min_{X \in G^{|\mathcal V|}} \sum_{(u,v)\in\mathcal E} c_{uv}(X_u Z_{uv}, X_v),$$

with edge costs $c_{uv}: G \times G \to \mathbb R_{\ge 0}$ (Shin et al., 9 Jul 2026).

The distributed setting assumes a robot index set $\mathcal A=\{1,\dots,N\}$, disjoint node partitions $\mathcal V_i \subset \mathcal V$, and a disjoint edge partition $$\mathcal E=\mathcal E_1 \sqcup \cdots \sqcup \mathcal E_N$$, where each inter-robot edge is arbitrarily assigned to one incident robot. Robot $\mathfrak g$0 optimizes a local objective

$\mathfrak g$1

and the global objective is the sum of all local costs. This formulation is motivated by multi-robot and multi-session geometric estimation problems in which centralized optimization is undesirable or infeasible.

The stated motivation is the brittleness of existing distributed solvers. The paper identifies sensitivity to hand-tuned stepsizes, damping, penalty parameters, and restart rules, with behavior depending strongly on topology, scale, noise level, and communication regime. It also notes that many existing methods primarily target rigid-body pose graphs, whereas DeepCORD is designed for general matrix Lie groups rather than only $\mathfrak g$2 (Shin et al., 9 Jul 2026).

2. Lie-group formulation and residual models

DeepCORD specializes the general objective to both $\mathfrak g$3 pose graph optimization and $\mathfrak g$4 projective submap alignment. For $\mathfrak g$5, each node is a rigid transform

$\mathfrak g$6

with Lie algebra

$\mathfrak g$7

The edge cost uses a squared chordal residual,

$\mathfrak g$8

with weighted norm

$\mathfrak g$9

and block-diagonal precision $\mathcal G=(\mathcal V,\mathcal E)$0, where $\mathcal G=(\mathcal V,\mathcal E)$1 (Shin et al., 9 Jul 2026).

For $\mathcal G=(\mathcal V,\mathcal E)$2, nodes are 3D homographies in homogeneous coordinates,

$\mathcal G=(\mathcal V,\mathcal E)$3

The residual is geodesic:

$\mathcal G=(\mathcal V,\mathcal E)$4

with

$\mathcal G=(\mathcal V,\mathcal E)$5

where $\mathcal G=(\mathcal V,\mathcal E)$6 encodes coordinates in a fixed basis of $\mathcal G=(\mathcal V,\mathcal E)$7, and $\mathcal G=(\mathcal V,\mathcal E)$8.

The optimizer is explicitly on-manifold. State increments lie in the Lie algebra, such as $\mathcal G=(\mathcal V,\mathcal E)$9, and states are updated by exponential retraction:

$X_u \in G$0

Residuals on $X_u \in G$1 use the group logarithm $X_u \in G$2, and the dynamics account for noncommutativity through co-adjoint terms $X_u \in G$3. This places DeepCORD within the class of geometric optimization methods that preserve Lie-group structure during the update process rather than working in a purely Euclidean parameterization (Shin et al., 9 Jul 2026).

3. CORD dynamics and the learned adaptive policy

The backbone of DeepCORD is CORD, a parallel and accelerated Riemannian optimizer derived from Euler–Poincaré dynamics. For stacked body velocity $X_u \in G$4, with node-level body velocity $X_u \in G$5, the continuous-time system is

$X_u \in G$6

Here $X_u \in G$7 is a mass matrix, $X_u \in G$8 is damping, and $X_u \in G$9 is the body-trivialized negative gradient. In the distributed implementation, $Z_{uv} \approx X_u^{-1}X_v$0 and $Z_{uv} \approx X_u^{-1}X_v$1 are block-diagonal across robots, with local Gauss–Newton Hessian blocks $Z_{uv} \approx X_u^{-1}X_v$2:

$Z_{uv} \approx X_u^{-1}X_v$3

for scalar $Z_{uv} \approx X_u^{-1}X_v$4 (Shin et al., 9 Jul 2026).

A semi-implicit discretization yields the per-robot update

$Z_{uv} \approx X_u^{-1}X_v$5

followed by

$Z_{uv} \approx X_u^{-1}X_v$6

The local linear systems are solved by sparse preconditioned conjugate gradients rather than dense factorization.

DeepCORD replaces fixed $Z_{uv} \approx X_u^{-1}X_v$7, $Z_{uv} \approx X_u^{-1}X_v$8, and $Z_{uv} \approx X_u^{-1}X_v$9 with a learned per-robot, per-iteration policy

$$\min_{X \in G^{|\mathcal V|}} \sum_{(u,v)\in\mathcal E} c_{uv}(X_u Z_{uv}, X_v),$$0

where $$\min_{X \in G^{|\mathcal V|}} \sum_{(u,v)\in\mathcal E} c_{uv}(X_u Z_{uv}, X_v),$$1 is robot $$\min_{X \in G^{|\mathcal V|}} \sum_{(u,v)\in\mathcal E} c_{uv}(X_u Z_{uv}, X_v),$$2’s augmented two-hop graph at iteration $$\min_{X \in G^{|\mathcal V|}} \sum_{(u,v)\in\mathcal E} c_{uv}(X_u Z_{uv}, X_v),$$3. The policy input includes node features $$\min_{X \in G^{|\mathcal V|}} \sum_{(u,v)\in\mathcal E} c_{uv}(X_u Z_{uv}, X_v),$$4, local gradient $$\min_{X \in G^{|\mathcal V|}} \sum_{(u,v)\in\mathcal E} c_{uv}(X_u Z_{uv}, X_v),$$5, random-walk structural encodings, and a communication feature $$\min_{X \in G^{|\mathcal V|}} \sum_{(u,v)\in\mathcal E} c_{uv}(X_u Z_{uv}, X_v),$$6 that captures delay or staleness; edge features include residual $$\min_{X \in G^{|\mathcal V|}} \sum_{(u,v)\in\mathcal E} c_{uv}(X_u Z_{uv}, X_v),$$7, precision vector $$\min_{X \in G^{|\mathcal V|}} \sum_{(u,v)\in\mathcal E} c_{uv}(X_u Z_{uv}, X_v),$$8, and a global context vector $$\min_{X \in G^{|\mathcal V|}} \sum_{(u,v)\in\mathcal E} c_{uv}(X_u Z_{uv}, X_v),$$9; graph-level features include intra-robot residual norm $c_{uv}: G \times G \to \mathbb R_{\ge 0}$0, inter-robot residual norm $c_{uv}: G \times G \to \mathbb R_{\ge 0}$1, gradient norm $c_{uv}: G \times G \to \mathbb R_{\ge 0}$2, and previous update norm $c_{uv}: G \times G \to \mathbb R_{\ge 0}$3.

The policy network uses node and edge MLP embedders followed by GPS layers with 8 heads and hidden size 128, then a parameter head MLP. A more detailed implementation description states that features are symlog-normalized, the node feature dimension is 13, an 8-dimensional RWSE is added to each node, and the GPS backbone has 4 layers, 8 heads, and hidden dimension 128. Outputs are mapped to valid ranges as

$c_{uv}: G \times G \to \mathbb R_{\ge 0}$4

which preserves the single-round communication per iteration inherited from CORD (Shin et al., 9 Jul 2026).

4. Self-supervised training, communication regimes, and execution

DeepCORD is trained by deep unfolding. For training instances $c_{uv}: G \times G \to \mathbb R_{\ge 0}$5, the method unrolls $c_{uv}: G \times G \to \mathbb R_{\ge 0}$6 iterations and minimizes summed local costs with regularization. The local cost is normalized by intra-robot edge count:

$c_{uv}: G \times G \to \mathbb R_{\ge 0}$7

Two regularizers are added. The first,

$c_{uv}: G \times G \to \mathbb R_{\ge 0}$8

penalizes non-monotone increases. The second,

$c_{uv}: G \times G \to \mathbb R_{\ge 0}$9

encourages a decaying damping schedule. The self-supervised objective is

$\mathcal A=\{1,\dots,N\}$0

with $\mathcal A=\{1,\dots,N\}$1 (Shin et al., 9 Jul 2026).

For numerical stability during training, the paper unrolls a simplified ODE that omits the co-adjoint and $\mathcal A=\{1,\dots,N\}$2 terms:

$\mathcal A=\{1,\dots,N\}$3

Linear solves use sparse PCG, and gradients through the solve are computed by implicit differentiation. If $\mathcal A=\{1,\dots,N\}$4, and $\mathcal A=\{1,\dots,N\}$5, then with $\mathcal A=\{1,\dots,N\}$6,

$\mathcal A=\{1,\dots,N\}$7

The appendix further shows an energy dissipation property for the simplified dynamics. For

$\mathcal A=\{1,\dots,N\}$8

one has

$\mathcal A=\{1,\dots,N\}$9

which ensures monotonic dissipation toward first-order critical points.

The distributed execution model uses a two-hop augmented graph and one communication round per iteration, exchanging boundary node states and small metadata such as the sender’s last $\mathcal V_i \subset \mathcal V$0. In the synchronous regime, robots operate in lockstep and $\mathcal V_i \subset \mathcal V$1 for received boundary nodes. In the asynchronous regime, the benchmark imposes randomized inter-robot packet delays between 0 and 10 iterations and a random drop rate of 10%. Staleness is encoded by

$\mathcal V_i \subset \mathcal V$2

so that the policy can modulate dynamics in response to delayed information. The learned schedules are phase-dependent: early iterations with large residuals favor smaller $\mathcal V_i \subset \mathcal V$3, larger $\mathcal V_i \subset \mathcal V$4, and larger $\mathcal V_i \subset \mathcal V$5, while later stages increase mass, decrease damping, and adapt $\mathcal V_i \subset \mathcal V$6 according to delay and convergence phase (Shin et al., 9 Jul 2026).

5. Empirical behavior on $\mathcal V_i \subset \mathcal V$7 and $\mathcal V_i \subset \mathcal V$8

The principal $\mathcal V_i \subset \mathcal V$9 evaluation covers standard pose-graph benchmarks—Sphere, Torus, Grid, Cubicle, Rim, and Garage—and multi-robot S3E datasets including CampusRoad1–3, Dormitory1, Library1–2, and Tunnel1, with reference costs from SE-Sync. After 100 iterations from chordal initialization, the synchronous results over 13 datasets show DeepCORD achieving the best or tied-best cost on 11/13 datasets, outperforming ROBO, AMM-PGO, and hand-tuned CORD. Under asynchronous communication with delays 0–10, drop rate 10%, and 10 Monte Carlo runs, DeepCORD achieves the lowest cost on a majority of datasets, with notable gains on Grid, Dormitory1, Library1, and Library2. Performance profiles over 500 iterations indicate that, with tolerance $$\mathcal E=\mathcal E_1 \sqcup \cdots \sqcup \mathcal E_N$$0, DeepCORD attains the highest area under the curve in the first 100 iterations and remains competitive and stable up to 500 iterations despite training with $$\mathcal E=\mathcal E_1 \sqcup \cdots \sqcup \mathcal E_N$$1 unrolled steps (Shin et al., 9 Jul 2026).

The reported robustness results emphasize initialization sensitivity. As perturbations increase, CORD’s optimality gap grows, whereas DeepCORD maintains near-optimal convergence across noise levels. Appendix results for coarse alignment initialization state that DeepCORD achieves best performance on 20/26 sequences, while CORD diverges on several asynchronous instances. Runtime analysis in the appendix reports that DeepCORD’s PCG plus neural inference is typically faster than CORD’s dense Cholesky on larger local systems, whereas DJ is fastest but much less accurate.

For $$\mathcal E=\mathcal E_1 \sqcup \cdots \sqcup \mathcal E_N$$2 projective submap alignment, the benchmarks use TUM RGB-D sequences fr1/room, fr2/desk, and fr3/household, denoted TUM1–3, with coarse spanning-tree initialization and perturbed inter-session transforms. Under asynchronous communication, after 100 iterations and 10 Monte Carlo runs, DeepCORD significantly outperforms CORD and DJ on all three sequences. The reported costs are as follows (Shin et al., 9 Jul 2026):

Dataset	Nodes / Edges	Costs: Ref.; DeepCORD / DJ / CORD
TUM1	249 / 270	0.876; 2.304 / 3.822 / 3.342
TUM2	103 / 111	0.120; 0.777 / 1.821 / 1.594
TUM3	89 / 91	0.066; 1.392 / 2.314 / 1.717

The integrated summary in the paper states that across 26 pose-graph benchmarks, comprising 13 synchronous and 13 asynchronous cases, DeepCORD achieves best results on 21/26, and also on all three $$\mathcal E=\mathcal E_1 \sqcup \cdots \sqcup \mathcal E_N$$3 datasets. The accompanying figures relate the lower objectives to improved map quality, including fused global maps on TUM and improved multi-robot trajectory consistency on S3E sequences.

6. Guarantees, limitations, and nomenclatural ambiguity

DeepCORD inherits the geometric structure of CORD, including accelerated Riemannian dynamics and the on-manifold update rule, but the paper explicitly states that it does not provide an asymptotic convergence guarantee for the learned solver (Shin et al., 9 Jul 2026). The learned outputs are constrained to positive ranges, and the training objective regularizes damping behavior, yet formal global guarantees are not given. This places the method in the category of learning-augmented optimizers whose empirical robustness exceeds their current theoretical characterization.

Several limitations are identified directly. The training horizon is limited to $$\mathcal E=\mathcal E_1 \sqcup \cdots \sqcup \mathcal E_N$$4 because of memory constraints, so behavior over very long horizons is not explicitly optimized. Local features may be insufficient to gauge global optimality, which can lead to conservative updates; CampusRoad3 synchronous is given as an example. The paper suggests stability-constrained parameter prediction, longer-horizon training formulations, and the inclusion of global feedback signals such as certifiable dual information as plausible future directions.

A separate source of ambiguity concerns the name itself. In diffusion MRI, the 2023 paper “Robust Fiber Orientation Distribution Function Estimation Using Deep Constrained Spherical Deconvolution for Diffusion MRI” develops a 3D patch-wise method for fODF estimation with scanner-invariant regularization over scan-rescan pairs, but its authors consistently refer to the method as “deep constrained spherical deconvolution” or “deep-CSD,” not DeepCORD (Yao et al., 2023). That distinction matters because the two works address unrelated domains: distributed Lie-group optimization in robotics on the one hand, and robust fODF estimation from diffusion MRI on the other. A common misconception is therefore to treat “DeepCORD” as the formal name of the diffusion MRI model; the paper itself does not do so.