acceptodds
Under review as a conference paper at ICLR 2027

Learned Preconditioning for a Primal–Dual Interior-Point Method

Abstract

Interior-point methods (IPMs) are among the most widely used algorithms for constrained optimization, yet their Newton-based search directions require costly second-order information and large linear-system solves. Learning to optimize offers cheaper updates learned from data, but the singular behavior of logarithmic barriers near constraint boundaries makes IPMs highly sensitive to perturbations, complicating both warm starting and learning reliable updates. We introduce pdLIP, an IPM for smooth nonlinear programs that integrates learned preconditioning with pdProj, an all-shifted primal-dual projected-search IPM. A shared coordinate-wise recurrent network predicts a positive diagonal preconditioner that scales the right-hand side of the reduced Newton system for the primal step, and the remaining slack and multiplier directions are recovered analytically. The learned iterations avoid Hessian evaluations and Newton-system solves, using only first-order and coordinate-wise operations amenable to GPU parallelization. Training is self-supervised, with a loss based on a penalty-barrier merit function and the residual of perturbed optimality conditions, requiring neither target directions nor precomputed solutions. Primal and dual shifts mitigate the barrier's sensitivity to perturbations near constraint boundaries, enabling effective warm starting. Across four classes of 200-dimensional convex and nonconvex constrained problems, pdLIP warm starts reduce pdProj refinement iterations by 63-67% compared with cold starts at the same KKT residual tolerance of , with negligible warm-start generation cost relative to the subsequent pdProj solve. Improvements persist on box-constrained QPs with variables and extend to applications including portfolio optimization, support vector machines, and a nonlinear control example. These results demonstrate that learning only a structured scaling can substantially reduce the subsequent cost of high-accuracy constrained optimization.

Primary area:
optimization
Keywords:
Learning to optimize, constrained optimization, interior-point methods, learned preconditioning, primal-dual interior-point methods, self-supervised learning, warm starting

Reviews

Among:
Shape:
1234this paper, Top 30%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.67 over 3 reviews, above 70% of the others.
Reviewer_HctCOpenReview ↗
Rating
3
Confidence
2
Informativeness
3
Presentation
2
Soundness
2
Read review
Paper summary

The paper introduces pdLIP, a learned preconditioning method for a primal-dual interior-point method (IPM) for smooth nonlinear programs called pdProj. pdLIP reduces the number of iterations compared to the cold-started pdProj by replacing the second-order Newton update with a learned update Δxk\Delta x_k (obtained by learning a positive-diagonal scaling of the reduced right-hand side of the KKT system). Empirical validation includes portfolio optimization, support-vector machine, and quadrotor navigation examples, showing that a pdProj warm-started with pdLIP needs fewer refinement iterations and has lower total runtime. The results show promise for scaling to several hundred variables and constraints across these domains.

Critical strengths
  1. The premise of the paper is coherent. Replacing an expensive linear-system solve with an inexpensive learned update makes sense.
  2. Current empirical validation shows promise: the paper contains a good range of problems, and the results appear strong for many of them.
Critical weaknesses
  1. Despite showing great improvements on QPs, the paper provides more limited evidence of effectiveness on general nonlinear problems. For example, the quadrotor task shows much smaller improvements, leaving the method's general applicability less established.
  2. It is unclear what the practical cost-benefit trade-offs are. pdLIP is trained and evaluated on examples drawn from the same distribution, which makes sense. However, it is unclear whether the method’s end-to-end performance against widely used solvers is competitive in terms of efficiency / whether the inference speed-up benefits justify the training costs.
Questions for authors
  1. Could the authors include benchmarks against other methods? It would help to compare performance against other warm-start/preconditioning methods.
  2. Could the authors clarify why they used an LSTM+MLP, as opposed to any other recurrent architecture? To that end, it would be helpful to see ablations and performance on other NN architectures (e.g., how performance would change with a GRU/RNN/MLP-only/etc. instead of an LSTM).
  3. The abstract could be revisited and manually refined for clarity. A more direct, intuitive explanation of the method and its motivation would make the contribution easier to grasp on a first read and improve the presentation considerably.
2 comments
AuthorsOpenReview ↗

Nonlinear evidence, comparisons, and cost

Thank you for the careful review. We have added nonlearned baselines and a memoryless MLP comparison, and made the nonlinear evidence and practical costs clearer.

  1. Evidence beyond quadratic programs. Our experiments include nonquadratic sinusoidal objectives. pdLIP reduces refinement iterations by 63.38% when only the equality right-hand sides vary and by 64.04% when all problem data vary (Table 1).

The quadrotor also includes nonlinear dynamics and obstacle constraints. There, pdLIP reduces refinement from 9.74 to 8.00 iterations and total online time from 19.05 to 15.81 s per problem, including warm-start generation (Table 5). This extends the evidence beyond synthetic problem families to a robotics-motivated nonlinear control problem. As in many learn-to-optimize approaches, we target repeated solution of related problems. \textbf{Section 1} now clarifies that models are trained separately for each problem family and dimension. Generalization to unseen dimensions and evaluation on larger, more complex nonlinear programs remain future work.

  1. Comparisons with nonlearned warm starts. We added constant, diagonal Barzilai-Borwein, and Jacobi-style scalings in Section 5.2.1, Table 2, using 200-variable convex quadratic problems with all problem data varying. All methods share the analytical updates, projection, parameter-update rules, and best-iterate selection, with initial barrier and penalty parameters tuned separately.

We match the warm-start generation time across methods at approximately 20 seconds for a batch of 1,000 problem instances (about 20 ms per instance, amortized), allowing the cheaper nonlearned methods to take many more warm-start steps. Even with this allowance, pdLIP roughly halves refinement iterations: 4.35 versus 8.42 for Jacobi-style scaling, the best nonlearned result by this measure. The mean warm-start KKT residual falls from 0.2309 to 0.0258, and total online time is 2.44 s per problem, compared with 5.02-5.79 s for the alternatives. Appendix A.3.5, Table 6 also gives an equal-iteration comparison with 300 warm-start steps.

  1. Recurrent architecture. The LSTM retains coordinate-wise optimization history, which the MLP uses to predict the scaling coefficients. To test whether this memory helps, we added an approximately parameter-matched memoryless MLP in Appendix A.3.6, Table 7. Both models use the same features, loss, analytical updates, and 300-step warm-start budget, with initial barrier and penalty parameters tuned separately.

On the same convex quadratic family, LSTM-MLP reduces refinement iterations from 6.34 to 4.35 (31.4%) and total online time from 3.61 to 2.44 s. Although recurrence makes warm-start generation more expensive, it saves more time in refinement. This supports using memory in the update; we further motivate the architectural choice in Section 4.1.

  1. Practical cost and solver comparisons. Our pdLIP targets repeated solves of related problems, where a model trained offline can be reused across many new instances. The practical trade-off is a one-time training cost in exchange for recurring online savings, which our experiments quantify in two settings.

Appendix A.5.2 directly compares pdLIP with IPOPT for approximate solutions. On 200-variable box-constrained QPs, both methods solve 100% of the test instances to the same 10−210^{-2} KKT tolerance, with reported average times of 4.02 ms for pdLIP versus 85.27 ms for IPOPT. This demonstrates the computational benefit of pdLIP's GPU-friendly updates under the reported protocol: batched GPU inference for pdLIP and sequential CPU solves for IPOPT, with GPU input transfer excluded (Section 5.1).

For high-accuracy solutions, Table 1 shows that pdLIP initialization reduces pdProj's reported total online time from 7.41 to 2.44 s on the 200-variable convex QPs with all problem data varying, at the same 10−810^{-8} KKT tolerance. This approximately threefold speedup includes warm-start generation. The saving is 4.97 s per problem, equivalent to about 83 minutes over 1,000 solves under this protocol.

These savings accumulate as the trained model is reused, without retraining for each instance. Self-supervised training also avoids the expense of generating optimal solutions as training targets. This makes repeated-solve workloads the natural setting for pdLIP: the training investment is worthwhile once the accumulated online savings exceed the offline training and model-selection costs.

  1. Presentation. We revised the abstract to explain the motivation and method more directly and clarify the solver names and abbreviations.

Thank you to the authors for addressing my questions and concerns, adding the ablations, and improving the presentation of the paper.

I remain supportive of accepting this work by maintaining a score of 3.

Reviewer_HzBfOpenReview ↗
Rating
2
Confidence
3
Informativeness
1
Presentation
2
Soundness
2
Read review
Paper summary

The paper introduces pdLIP, a learned optimizer built on the primal–dual interior-point method pdProj. A coordinate-wise LSTM predicts positive diagonal scalings for the reduced primal update, while the remaining primal–dual directions are recovered analytically. Training combines a penalty–barrier merit function with perturbed KKT residuals. The resulting iterates warm-start pdProj for high-accuracy refinement.

Critical strengths
  • The shifted formulation of pdProj provides a suitable foundation for warm starting, addressing difficulties encountered by conventional barrier-based IPMs.
  • Learning a structured preconditioner is a natural and well-motivated direction for reducing the cost of Newton-system solves.
  • The experiments demonstrate substantial reductions in pdProj refinement iterations and total runtime on the evaluated benchmarks.
Critical weaknesses
  1. The predicted diagonal scaling directly replaces the reduced inverse operator rather than preconditioning a Newton-system solve. It is unclear how the resulting learned direction addresses ill-conditioning beyond providing an effective warm start.
  2. The loss combines a merit function containing several penalty and barrier terms with a residual term. Balancing their scales and gradients may be challenging, especially for larger problems; loss ablations and training-stability evidence are needed.
  3. The presentation is difficult to follow, with insufficient explanation of solver names and abbreviations in the abstract and redundant or inconsistent notation, such as the unexplained change from p to p^(x) after Eq. (13).
  4. The motivation for using an LSTM is insufficiently supported. Comparisons with a memoryless MLP and other architectures would clarify whether recurrent memory is necessary.
Questions for authors

See the weaknesses above.

3 comments
AuthorsOpenReview ↗

Learned scaling, ablations, and stability

Thank you for the detailed suggestions. We have clarified what the network learns, added a memoryless MLP comparison and training curves, and revised the loss discussion and notation.

  1. Learned update and preconditioning. The learned diagonal matrix PkP_k scales each coordinate using residual information and iteration history. It replaces the reduced Newton step −Gk−1qk-G_k^{-1}q_k with −Pkqk-P_kq_k, rather than preconditioning a Newton system. The slack and multiplier directions are then recovered analytically, so no Newton system is solved within a learned iteration. This avoids Hessian evaluations and linear-system solves during warm-start generation while retaining the primal-dual update structure. pdProj then refines the warm start to high accuracy.

We use "preconditioning" in the sense of scaling the update, as in preconditioned gradient methods (Gupta et al., 2018) and learned diagonal updates (Liu et al., 2023). Here, the scaled quantity is the reduced Newton right-hand side rather than an objective gradient. The shifts play a separate, regularizing role: they mitigate ill-conditioning when strict complementarity fails or the active-constraint gradients are linearly dependent (Gill and Zhang, 2024). pdLIP retains this shifted formulation, and pdProj uses the shifted Newton equations during refinement.

  1. Recurrent memory. The LSTM retains each coordinate's optimization history, and the MLP uses that history to predict its scaling. The new ablation in Appendix A.3.6, Table 7 compares this model with a memoryless MLP of approximately the same parameter count. Both use the same features, loss, analytical updates, and 300-step warm-start budget, with initial barrier and penalty parameters tuned separately.

On 200-variable convex quadratic problems with all problem data varying, LSTM-MLP reduces refinement iterations from 6.34 to 4.35 (31.4%) and total online time from 3.61 to 2.44 s, including warm-start generation. The memoryless model generates warm starts faster, but the recurrent model is faster overall because it needs less refinement. This gives a concrete reason for using recurrence. We further motivate the architectural choice in Section 4.1.

  1. Loss design and training stability. The design of the loss is explained in Section 4.4: the merit term measures progress on the shifted problem, while the residual term penalizes violations of its perturbed optimality conditions. For direct empirical evidence, we added training curves in Appendix A.3.7 for 200-variable convex quadratic and nonconvex sinusoidal-objective problems. For the selected configurations, the combined loss decreases, and the fractions of instances satisfying both eP<10−2e_P < 10^{-2} and eD<10−2e_D < 10^{-2} at the best iterate of each rollout increase to approximately 80% and 50%, respectively. The nonconvex curves fluctuate more, but both settings show sustained training progress.

Appendix A.3.8 further examines sensitivity to the initial barrier and penalty parameters and documents their selection using validation data. To assess scaling with problem dimension, Section 5.2.1 and Table 3 report results for box-constrained QPs with 10, 200, and 1,000 variables. At 1,000 variables, pdLIP reduces subsequent pdProj refinement iterations by 47.90% and total online time by 66.73%. Together, these results document the training behavior, parameter sensitivity, and practical effectiveness of the method across the tested problem dimensions.

  1. Presentation. We revised the abstract to explain the motivation and method more directly and clarify the solver names and abbreviations. Section 4.3 now consistently distinguishes the scalar pk,jp_{k,j}, vector pkp_k, and diagonal matrix Pk=diag⁡(pk)P_k=\operatorname{diag}(p_k), and corrects the p(x)p^{(x)} typo.

Thanks for your efforts. I will maintain my assessment.

Thank you for considering our response. We would like to note two further revisions related to your review.

First, as you suggested, Appendix A.3.8 (Table 8) now includes a loss ablation comparing merit-only training with our combined objective under identical settings. On the 200-variable C-ALL benchmark, adding the residual term reduces the mean warm-start KKT residual from 0.7672 to 0.0326 and raises the fraction of test problems with eP<10−2e_P < 10^{-2} and eD<10−2e_D < 10^{-2} from 0.2% to 57.6%. (The sensitivity analysis cited in our earlier reply as Appendix A.3.8 is now Appendix A.3.9.)

Second, we have clarified the contribution. Replacing the reduced inverse operator, rather than preconditioning a Newton-system solve, is what allows the learned iterations to avoid both Hessian evaluations and linear-system solves. The revised contribution bullets (Section 1) and expanded related work (Section 2) make this explicit: to the best of our knowledge, pdLIP is the first learned primal–dual IPM formulated for general smooth nonlinear programs whose learned iterations require neither Hessian evaluations nor linear-system solves. In contrast, IPM-LSTM, the closest prior approach for general nonlinear programs, approximately solves Newton systems whose construction still requires the Hessian.

We hope these revisions are helpful for your final assessment.

Reviewer_AnQjOpenReview ↗
Rating
3(+1)
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes pdLIP, a learned optimizer built on the shifted primal–dual interior-point method pdProj. A shared coordinate-wise LSTM predicts a positive diagonal scaling that replaces the curvature-dependent reduced primal solve, while the remaining primal–dual directions are recovered analytically. Training is self-supervised through a combination of the penalty–barrier merit function and the perturbed optimality residual. The learned iterates provide warm starts for subsequent high-accuracy pdProj refinement. Experiments report approximately 63–67% fewer refinement iterations on four 200-variable benchmark families, with additional results on larger box-constrained QPs, portfolio optimization, SVMs, and quadrotor control.

Critical strengths
  1. The architectural choice is well motivated. Restricting learning to a diagonal scaling removes Hessian evaluations and linear-system solves from the learned forward iterations while preserving much of the analytical primal–dual structure. This provides a clear connection between the learned component and the computational bottleneck it addresses.

  2. The self-supervised training objective avoids requiring optimal solutions or target Newton directions. This is a useful property when generating supervised training data would itself require substantial optimization effort.

  3. The warm-start evaluation uses a common KKT tolerance of (10^{-8}), and both cold-started and warm-started pdProj converge on all reported test instances. The substantial reductions in refinement work therefore constitute meaningful evidence of improved initialization. The nonlinear quadrotor experiment also extends the evaluation beyond problems with linear constraints.

Critical weaknesses
  1. The benefit attributable to learning is insufficiently isolated. The principal comparison is against cold-started pdProj. There are no controlled comparisons against simple nonlearned scaling rules within the same shifted primal–dual framework. Consequently, it remains unclear how much of the improvement requires a learned recurrent model, rather than inexpensive first-order iterations before refinement. Comparisons with tuned constant and adaptive diagonal scalings under a matched computational budget would directly address the central contribution. An ablation of the residual term would also help establish the value of the proposed training objective.

  2. The practical efficiency evidence is difficult to interpret beyond the particular pdProj implementation. The paper acknowledges that IPOPT uses a faster linear solver, while the IPM-LSTM comparison uses different refinement solvers and compares relative iteration reductions. These results support the benefit of warm-starting pdProj, but do not establish the relative efficiency of the complete competing pipelines. The approximate-solution comparisons in Appendix A.5.2 use a looser tolerance and have unequal success rates, so they do not resolve the high-accuracy comparison.

  3. The demonstrated scope is narrower than the general nonlinear-programming motivation. Models are trained separately for problem families and dimensions, with training and test instances drawn from the same distributions. The largest-dimensional experiment concerns box-constrained QPs, and the application QPs deliberately use dense matrices. The nonlinear quadrotor example is valuable, but its iteration reduction is substantially smaller, at approximately 18%. The evidence therefore primarily supports warm starting within the tested distributions; performance on larger, sparse, or more varied nonlinear problems remains uncertain.

Questions for authors
  1. Can you compare pdLIP with tuned constant and nonlearned adaptive diagonal scalings using the same analytical updates, initialization, projection, and warm-start budget? How much additional benefit comes from recurrent memory and the residual term in the loss?

  2. Can you report end-to-end comparisons against IPOPT at the common (10^{-8}) KKT tolerance, with clear distinctions between single-instance latency and batched throughput? Please clarify whether the warm-start timing includes synchronization, transfers, and best-iterate selection.

3 comments
AuthorsOpenReview ↗

New baselines, timing, and scope

Thank you for the careful review. We have added nonlearned baselines, a memoryless MLP comparison, and training curves, and clarified how we measure runtime.

  1. Benefit of learning. The new comparison in Section 5.2.1, Table 2 tests tuned constant, diagonal Barzilai-Borwein, and Jacobi-style scalings on 200-variable convex quadratic problems with all problem data varying. All methods share the analytical updates, projection, parameter-update rules, and best-iterate selection. We match the warm-start generation time across methods at approximately 20 seconds for a batch of 1,000 problem instances (about 20 ms per instance, amortized), allowing the cheaper nonlearned methods to take many more warm-start steps. Even with this allowance, pdLIP roughly halves refinement iterations: 4.35 versus 8.42 for Jacobi-style scaling, the best nonlearned result by this measure. The mean warm-start KKT residual falls from 0.2309 to 0.0258, and total online time is 2.44 s per problem, compared with 5.02-5.79 s for the alternatives. Appendix A.3.5, Table 6 also gives an equal-iteration comparison with 300 warm-start steps.

  2. Recurrent memory. We added a comparison with a memoryless MLP (with parameter count approximately matched to our LSTM-MLP model) in Appendix A.3.6, Table 7. Both models use the same features, loss, analytical updates, and 300-step budget, with initial barrier and penalty parameters tuned separately. On the same problem family, LSTM-MLP reduces refinement iterations from 6.34 to 4.35 (31.4%) and total online time from 3.61 to 2.44 s. The extra cost of recurrence is therefore more than offset by the reduction in refinement. We further motivate the architectural choice in Section 4.1.

  3. IPOPT comparisons and timing. Tables 1 and 3-5 compare IPOPT, cold-started pdProj, and pdLIP-initialized pdProj at the same 10−810^{-8} KKT tolerance. On the convex quadratic family above, they require 15.82, 13.22, and 4.35 iterations, respectively. Newton-system factorization and solution are major costs in both solvers, so iteration counts provide a meaningful comparison of refinement work. Learned warm-start steps avoid these operations. Appendix A.5.1 also reports function and gradient evaluation counts.

Wall-clock comparisons also depend on the linear-algebra implementation. IPOPT benefits from mature, optimized linear solvers, whereas the current pdProj implementation is less optimized. Developing pdProj into a production-level solver with faster linear algebra and conducting matched end-to-end runtime comparisons with IPOPT are directions for our future work.

We now give the full timing protocol in Section 5.1. Inference uses GPU batches of 1,000, and WS Cost is the elapsed batch time divided by 1,000. The timer excludes input transfer to GPU but includes initialization, all warm-start steps, best-iterate selection, convergence evaluation, and output transfer to CPU. It stops only after all required GPU work has finished. Total Time adds the mean CPU refinement time per problem. These are amortized batched costs, not single-instance latency.

  1. Nonlinear problems and scope. The experiments include nonquadratic sinusoidal objectives (Table 1) and a quadrotor task with nonlinear dynamics and obstacle constraints. On this task, pdLIP reduces refinement iterations by 17.9% (Table 5). This extends the evidence beyond synthetic problem families to a robotics-motivated nonlinear control problem. As in many learn-to-optimize approaches, we target repeated solution of related problems. Generalization to unseen dimensions and evaluation on larger, more complex nonlinear programs remain future work.

Thank you for the detailed response and additional experiments. The equal-time comparisons against constant, Diag-BB, and Jacobi-style scalings substantially address my concern about isolating the benefit of learning. In particular, reducing refinement iterations from 8.42 to 4.35 despite allowing the nonlearned methods more warm-start steps provides meaningful supporting evidence. The parameter-matched MLP comparison also strengthens the justification for recurrent memory. I will revise these parts of my assessment accordingly.

Several points remain open:

  1. Interpretation of practical efficiency. The timing protocol is now much clearer. However, the reported warm-start costs are amortized over batches of 1,000 instances, exclude input transfer, and do not establish single-instance latency. The high-accuracy runtime comparison against IPOPT also remains unavailable. Although iteration counts help characterize refinement work, they do not establish relative end-to-end runtime across different solvers. Could you report the current IPOPT runtimes at the common (10^{-8}) tolerance, with the implementation differences clearly stated? Otherwise, the efficiency conclusions should remain explicitly scoped to the reported batched setting and pdProj implementation.

  2. Contribution of the residual penalty. The new training curves demonstrate progress with the combined objective, but do not isolate the benefit of the residual term. A comparison between merit-only training and the proposed combined loss would clarify this remaining component of the method.

I appreciate the clarification that the intended setting is repeated solution of related problems. I will assess the contribution within that scope and treat transfer to unseen dimensions and more complex nonlinear problems as limitations. Overall, the additional baseline and architecture experiments materially strengthen the empirical case. Given these clarifications and the strengthened empirical evidence, I would raise the score by 1.

AuthorsOpenReview ↗

IPOPT timing and residual-term ablation

Thank youfor the follow-up questions regarding practical efficiency and the contribution of the residual term in our training objective. We address both points below, providing additional timing measurements in this response and reporting a new training-loss ablation added to the revised manuscript.

1. Practical Efficiency and IPOPT Timing. We measured CPU-to-GPU input-transfer costs on the 200-variable benchmarks, finding an overhead of 0.028 seconds per batch of 1,000 problems. Including this increases the amortized C-ALL warm-start cost from 19.93 ms to 19.96 ms per problem, an increase of approximately 0.14%. Since this has a negligible effect on the reported runtime reductions, we retain the timing convention described in Section 5.1 and quantify the excluded cost here. These warm-start costs are amortized over GPU batches and do not measure single-instance latency.

For transparency, we also measured IPOPT runtime on C-ALL at the common 10−810^{-8} KKT tolerance. IPOPT requires 0.592 s per problem, compared with 7.41 s for cold-started pdProj and 2.44 s for pdLIP-initialized pdProj. The gap lies in the cost per iteration, not the number of iterations: IPOPT needs 15.82 iterations at about 0.037 s each, while cold-started pdProj needs 13.22 iterations at about 0.56 s each. There are substantial implementation differences: IPOPT uses optimized compiled code and sparse linear solvers, whereas our current pdProj implementation uses Python/NumPy and constructs dense KKT systems. These differences are important when interpreting the wall-clock comparison and motivate further optimization of the pdProj implementation.

Our primary goal is to investigate whether inexpensive learned primal–dual updates can generate effective warm starts that reduce the computational work required to reach high accuracy. Iteration and evaluation counts (Table 1; Appendix A.5.1) provide complementary measures of this work within pdProj. Our experiments demonstrate 63–67% fewer pdProj refinement iterations across four benchmark classes at the same 10−810^{-8} KKT tolerance. On C-ALL, this translates into an approximately threefold reduction in total online time, from 7.41 s to 2.44 s, with the learned warm-start cost included. Together with the direct approximate-solution results at the looser 10−210^{-2} tolerance in Appendix A.5.2, these findings support pdLIP's practical value both for generating inexpensive approximate primal–dual solutions in GPU batches and for providing effective initializations that substantially reduce high-accuracy refinement work.

To make the algorithmic contribution and empirical scope more explicit, we have expanded the Related Work section and revised the contribution bullets in Section 1. In particular, to the best of our knowledge, pdLIP is the first learned primal–dual IPM formulated for general smooth nonlinear programs whose learned iterations require neither Hessian evaluations nor linear-system solves. As you note, iteration and evaluation counts alone do not establish relative end-to-end runtime across different solvers. We therefore scope our measured high-accuracy runtime improvements to the evaluated pdProj implementation and batched GPU warm-start setting, without claiming an end-to-end speedup over IPOPT. Optimizing the pdProj implementation for production use remains future work.

2. Contribution of the Residual Term in the Loss Function. We have added a training-loss ablation in Appendix A.3.8 (Table 8), comparing merit-only training against our proposed combined objective under identical settings (10 training epochs each). On the 200-variable C-ALL benchmark, including the residual penalty reduces the mean warm-start KKT residual from 0.7672 to 0.0326 (a 95.8% reduction) and increases the convergence fraction satisfying both eP<10−2e_P < 10^{-2} and eD<10−2e_D < 10^{-2} from 0.2% to 57.6%. These results demonstrate the benefit of the residual penalty in generating higher-quality primal–dual warm starts.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.