RowDualNet: Neural Warm-Start for LAP

• The paper introduces a novel approach that predicts row dual variables and employs the Min-Trick to construct feasible column potentials, ensuring dual feasibility.
• RowDualNet leverages a row-centric architecture with a shared residual MLP and top-K sparse refinement, thereby avoiding the O(N²) memory burden common in graph-based methods.
• Empirical results show significant runtime speedups over classical solvers on both synthetic and real-world datasets, scaling up to N=16,384 with a 0% optimality gap.

Searching arXiv for the primary RowDualNet paper and a small set of directly relevant contextual papers. RowDualNet is a neural model for the Linear Assignment Problem (LAP) that predicts dual variables for exact combinatorial optimization rather than predicting assignments directly. It was introduced as part of a learning-augmented framework in which predicted row dual potentials $\hat{u}$ are converted into feasible column potentials $\hat{v}$ by a constructive LP-duality mechanism, the Min-Trick, and then used to warm-start an exact solver such as Jonker-Volgenant (LAPJV). The stated objective is to accelerate exact assignment solving without sacrificing optimality, worst-case guarantees, or scalability, while avoiding the $\mathcal{O}(N^2)$ memory burden characteristic of graph-based neural approaches; the method is reported to scale to $N=16{,}384$ with a $0\%$ optimality gap across tested instances (Yavlovich et al., 10 May 2026).

1. Problem setting and optimization target

RowDualNet is formulated for the square LAP on a cost matrix $C \in \mathbb{R}^{N \times N}$, where $C_{ij}$ is the cost of assigning row-agent $i$ to column-task $j$. The primal problem is

$$\min_X \sum_{i,j} C_{ij} X_{ij} \quad \text{s.t.} \quad \sum_j X_{ij} = 1 \ \forall i,\; \sum_i X_{ij} = 1 \ \forall j,\; X_{ij} \in \{0,1\}.$$

The classical exact methods emphasized are the Hungarian algorithm and Jonker-Volgenant (LAPJV), both with worst-case time complexity $\hat{v}$0. The paper identifies large-scale instances, especially for $\hat{v}$1, as the regime in which cubic scaling becomes a bottleneck. It further argues that LAPJV is particularly sensitive to initialization quality: if its initial dual or greedy phase fails to match many rows, the expensive second phase must perform many augmenting path searches, which dominate runtime (Yavlovich et al., 10 May 2026).

This framing positions RowDualNet as a method for reducing search effort inside an exact solver rather than replacing the solver. A plausible implication is that the approach is best understood within the broader learning-augmented optimization paradigm: learned advice changes the starting point of a certified procedure, while correctness remains anchored in the classical algorithm.

2. Dual warm-starting and the Min-Trick construction

The central design choice is to predict row dual variables $\hat{v}$2 instead of a discrete assignment matrix. For the dual of the LAP LP relaxation,

$\hat{v}$3

RowDualNet outputs only $\hat{v}$4, after which feasible column duals are constructed as

$\hat{v}$5

This guarantees dual feasibility by construction, since

$\hat{v}$6

The reduced costs are defined as

$\hat{v}$7

A perfect matching on zero-reduced-cost edges yields optimality under complementary slackness. The paper identifies the Min-Trick as the main feasibility mechanism and characterizes it as constructive, non-iterative, projection-free, and cheap enough to be practical. This directly addresses a failure mode of earlier learned-dual approaches, which often required iterative projection or repair steps that could eliminate any runtime advantage (Yavlovich et al., 10 May 2026).

The exactness claim is correspondingly narrow and precise: the warm-start can alter runtime, but not correctness. Because the seed is dual-feasible and LAPJV is exact, the final output remains optimal.

3. Row-independent architecture and feature representation

RowDualNet is explicitly designed to avoid the $\hat{v}$8 memory bottleneck common in graph neural approaches to assignment. Instead of representing the LAP as a bipartite graph with $\hat{v}$9 edges and maintaining edge-level latent states, it treats the problem as a set of rows processed largely independently. The neural pipeline is:

• extract compact row-centric features $\mathcal{O}(N^2)$0, where $\mathcal{O}(N^2)$1;
• pass each row through a shared MLP to predict $\mathcal{O}(N^2)$2;
• add a lightweight sparse refinement based on top-$\mathcal{O}(N^2)$3 competitive columns (Yavlovich et al., 10 May 2026).

The appendix specifies a residual MLP with 3 blocks, hidden dimension $\mathcal{O}(N^2)$4, and top-$\mathcal{O}(N^2)$5 sparse refinement with $\mathcal{O}(N^2)$6. The feature representation consists of 21 row-centric features, grouped into distributional statistics, ambiguity metrics, competition signals, local context, and positional encodings. Concretely, the summary lists row min, max, mean, std; entropy and difficulty; near-best fraction and global column-best count; $\mathcal{O}(N^2)$7-smallest statistics and rank-based features; and sinusoidal row embeddings (Yavlovich et al., 10 May 2026).

The motivating intuition is that each row dual value $\mathcal{O}(N^2)$8 reflects how “expensive” that row is to match. RowDualNet estimates this using summaries of row cost distributions and competition structure rather than explicit pairwise message passing over all row-column edges. This suggests a deliberate trade-off: reduced representational granularity in exchange for linear memory in $\mathcal{O}(N^2)$9 for the neural component.

4. Training objective, inference pipeline, and robustness mechanism

Supervision is derived from exact dual labels $N=16{,}384$0 computed offline using LAPJV. The model is trained with

$N=16{,}384$1

where $N=16{,}384$2 is the set of edges in the optimal matching. The MAE term aligns predicted row duals with optimal dual labels, while the complementary-slackness penalty encourages tightness on optimal edges. Optimization uses AdamW with weight decay $N=16{,}384$3, initial learning rate $N=16{,}384$4, and ReduceLROnPlateau. Because dual variables are translation-invariant, gauge fixing is applied by centering the dual labels to make targets unique and stable (Yavlovich et al., 10 May 2026).

At inference time, the end-to-end pipeline includes data transfer, feature extraction, neural inference, the Min-Trick, and exact LAPJV solve. The paper reports experiments on a single CPU-GPU node with an NVIDIA RTX 3090 and an Intel i7-12700 (Yavlovich et al., 10 May 2026).

A distinct component of the method is its safeguard against harmful learned advice. The framework computes the density or average degree of the equality subgraph induced by the predicted duals,

$N=16{,}384$5

and, if $N=16{,}384$6 for a validation-tuned threshold $N=16{,}384$7, reverts to cold-start LAPJV. The paper argues that the check has overhead $N=16{,}384$8, which is asymptotically dominated by LAPJV’s $N=16{,}384$9. The intended guarantee is therefore learning-augmented robustness: if predictions are good, warm-starting helps; if predictions are poor, the method falls back without asymptotic runtime degradation (Yavlovich et al., 10 May 2026).

5. Empirical scaling and reported performance

The empirical study covers synthetic benchmarks and zero-shot transfer to real-world data. Synthetic training uses about 1,700 matrices with sizes $0\%$0, and testing extends to $0\%$1. Two synthetic distributions are used: Dense Uniform with $0\%$2, and Block-Structured data with group-based latent structure intended to simulate task-agent compatibility classes (Yavlovich et al., 10 May 2026).

For $0\%$3, the reported speedup is consistently $0\%$4. On dense synthetic data, the paper reports about $0\%$5 over SciPy and about $0\%$6 over LAP at $0\%$7, with a peak speedup around $0\%$8. On block-structured data, it reports about $0\%$9 over SciPy and nearly $C \in \mathbb{R}^{N \times N}$0 over LAP at the largest sizes. The method is also highlighted as scaling to $C \in \mathbb{R}^{N \times N}$1 without OOM, a scale the paper states prior graph-based neural matching methods could not handle (Yavlovich et al., 10 May 2026).

On real-world Large-Scale Multi-Person Tracking data, with sizes from $C \in \mathbb{R}^{N \times N}$2 to $C \in \mathbb{R}^{N \times N}$3, RowDualNet is evaluated zero-shot after synthetic training. The reported outcome is a consistent speedup of about $C \in \mathbb{R}^{N \times N}$4 over the faster baseline (LAP) for $C \in \mathbb{R}^{N \times N}$5, and about $C \in \mathbb{R}^{N \times N}$6 over SciPy. On OpenStreetMap-derived transportation cost matrices for 7 cities at $C \in \mathbb{R}^{N \times N}$7, the reported speedups are about $C \in \mathbb{R}^{N \times N}$8–$C \in \mathbb{R}^{N \times N}$9 over SciPy and about $C_{ij}$0–$C_{ij}$1 over LAP; the paper summarizes this as more than $C_{ij}$2 improvement on transportation tasks in many cases. Across all tested instances, the optimality gap remains $C_{ij}$3 (Yavlovich et al., 10 May 2026).

Setting	Scale	Reported result
Dense synthetic	up to $C_{ij}$4	about $C_{ij}$5 over SciPy; about $C_{ij}$6 over LAP
Block-structured synthetic	largest sizes	about $C_{ij}$7 over SciPy; nearly $C_{ij}$8 over LAP
MOT	$C_{ij}$9	about $i$0 over LAP; about $i$1 over SciPy
Transportation (LPT/OSM)	$i$2	about $i$3–$i$4 over SciPy; about $i$5–$i$6 over LAP

Ablations further identify the mechanism behind these gains. Random initialization and heuristic seeds can be worse than cold start, linear models may help slightly at small $i$7 but degrade for larger $i$8, and only the deep RowDualNet maintains robust gains. Internally, cold-start heuristics resolve only about 26–27% of assignments early, whereas RowDualNet warm-start resolves about 76% immediately, reducing augmenting-path search effort by about 68% (Yavlovich et al., 10 May 2026).

6. Relation to prior work, limitations, and naming ambiguity

The paper situates RowDualNet against three alternatives: classical exact solvers, earlier learned-dual methods, and graph-based neural assignment solvers. Against SciPy’s linear_sum_assignment and the LAP library implementation, it reports better end-to-end runtime on large instances. Against the learned median baseline from Dinitz et al. (2021), it argues that a static prototype dual fails to scale well and often falls below baseline performance, whereas RowDualNet adapts to each instance. Against graph-based methods such as GLAN, HybridGNN, MAGNET, and related edge or message-passing approaches, it emphasizes three limitations: $i$9 memory, approximate outputs, and poor scalability beyond roughly $j$0 (Yavlovich et al., 10 May 2026).

The limitations are correspondingly explicit. The method requires dual labels for supervised training, generated offline by an exact solver. It assumes a square LAP and compatibility with a solver’s dual warm-start interface. The fallback threshold $j$1 is validation-tuned. Neural overhead remains nonzero and may matter for small $j$2, where cold-start solvers are already very fast. The feature design is row-centric and may miss fine-grained global structure that full graph models can represent. The Min-Trick itself is $j$3, so preprocessing is not negligible even if asymptotically dominated by the solver. Future directions proposed by the authors include extension to min-cost flow, semi-supervised training when exact dual labels are unavailable, and broader learning-augmented integration with other exact optimization backends (Yavlovich et al., 10 May 2026).

A recurrent source of confusion is nomenclature. RowDualNet is unrelated to the reparameterizable dual-resolution network RDRNet for real-time semantic segmentation (Yang et al., 2024), and it is also distinct from LR-CNN’s row-centric convolutional scheduling for memory reduction in CNN training (Wang et al., 2024). The common “row” vocabulary does not indicate a shared algorithmic family; in RowDualNet, the row-centricity refers to row-wise feature extraction and dual prediction for LAP instances, not to convolutional architecture or row-scheduled CNN execution.