Solving Quadratic Programs via Deep Unrolled Douglas-Rachford Splitting
Authors: Jinxin Xiong
Xi Gao
Linxin Yang
Jiang Xue
Xiaodong Luo
Akang Wang
Venue: Accepted by TMLR ()

Abstract: Convex quadratic programs (QPs) are fundamental to numerous applications, including finance, engineering, and energy systems. Among the various methods for solving them, the Douglas-Rachford (DR) splitting algorithm is notable for its robust convergence properties. Concurrently, the emerging field of Learning-to-Optimize offers promising avenues for enhancing algorithmic performance, with algorithm unrolling receiving considerable attention due to its computational efficiency and interpretability. In this work, we propose an approach that unrolls a modified DR splitting algorithm to efficiently learn solutions for convex QPs. Specifically, we introduce a tailored DR splitting algorithm that replaces the computationally expensive linear system-solving step with a simplified gradient-based update, while retaining convergence guarantees. Consequently, we unroll the resulting DR splitting method and present a well-crafted neural network architecture to predict QP solutions. Our method achieves up to 50% reductions in iteration counts and 40% in solve time across benchmarks on both synthetic and real-world QP datasets, demonstrating its scalability and superior performance in enhancing computational efficiency across varying sizes.

Published in Transactions on Machine Learning Research (08/2025)
Solving Quadratic Programs via Deep Unrolled Douglas-Rachford Splitting
Jinxin Xiong!? Xi Gao*, Linxin Yang!,, Jiang Xue", Xiaodong Luo!?? Akang Wang1.2
"School of Data Science, The Chinese University of Hong Kong, Shenzhen, China SSennzen International Center for Industrial and Applied Mathematics, Shenzhen Research Institute of Big Data, China
"School of Mathematics and Statistics, Xi'an Jiaotong University, China
Reviewed on OpenReview: http:/ppwwwwweee....../////arraa
Abstract
Convex quadratic programs (QPs) are fundamental to numerous applications, including finance, engineering, and energy systems. Among the various methods for solving them, the Douglas-Rachforr (DR) splitting algorithm is notable for its robust convergence prop- erties. Concurrently, the emerging field of Tearning-o--Ollinizee offers promising avenues for enhancing algorithmic performance, with algorithm unrolling receiving considerable at- tention due to its computational efficiency and interpretability. In this work, we propose an approach that unrolls a modified DR splitting algorithm to efficiently learn solutions for convex QPs. Specifically, we introduce tailored DR splitting algorithm that replacos the computationally expensive linear system-solving step with a simplified gradient-base based update, while retaining convergence guarantees. Consequently, splitting method and present well-crafted neural network architecture to predict QP so- lutions. Our method achieves up to 50% reductions in itcration counts and 40% in solve lime across benchmarks on both synthetic and real-world QP datasets, demonstrating ils scalability and superior performance in enhancing computational efficiency across varying sizes.
unroll the resulting DR
1 Introduction
Convex Quadratic Programs (QPs) are optimization problems characterized by a convex quadratic objec- tive function and linear constraints. These problems form a fundamental class of optimization tasks with applications spanning finance (Markowitz, 1952; Boyd et al., 2017), engincering (Garcia et al., 1989). energy systems (Frank& & Rebennack, 2016), and machine learning (Cortes, 1995; Tibshirani, 1996). Additionally, convex QPs serve the basis for constructing sequential convex approximations or relaxations of nonconvex problems, ensuring tractable subproblems while progressively approaching high-quality solutions (Boyd & Vandenberghe, 2004).
In recent years, there has been increasing interest in the development of first-order methods for convex QPs, with OSQP (Stellato et al., 2020) and Splitting Conic Solver (SCS) (O'Donoghuc, 2021) standing out as state-of-the-ae the-art solvers. These methods are closely related to the classical Douglas-Rachford Rachford (DR) splitting algorithm (Douglas Rachford, 1956). Notably, they require only a few matrix factorizations, which can be reused across iterations. More recently, Lu & Yang (2025) extended the Primal-Dual Hybrid Gradient (PDHG) algorithm to effectively solve convex QPs without requiring any matrix factorization. These first- order methods have demonstrated superior efficiency compared to traditional approaches like Active-Set. methods (Wolfe, 1959) and Interior Point Methods (IPMs) (Nesterov & Nemirovskii, 1994), especially for large-scale problems.
"Corresponding Author: Akang Wang <wangakanggSrriddd..n.

---

Published in Transactions on Machine Learning Research (08/2025)
With the emergence of (earn-to-Optimics (L20) methods, innovative strategies have been proposed to ac- celerate the solving of optimization problems (Chen et al., 2022; Gasse et al., 2022). By training models on diverse problem instances, L20 aims to learn problem-specific optimization strategies that surpass traditional methods in terms of efficiency and performance. In particular, the recent work of Yang ct al. (2024) proposed to unroll the matrix-free PDHG algorithu Lu & Yang (2025). This approach enables a relatively shallow network efficiently learn the optimal QP solutions that would otherwise require thousands of PDHG iter- ations. However, directly unrolling DR splitting-baser algorithms to efficiently learn QP solutions presents challenges, primarily due to the need to solve linear system at each iteration. This raises the following question:
How to unroll DR splitting- based algorithms for solving conver QPs?
In this work, we propose unrolling a modified DR splitting algorithm in which the linear wystem--olving step is replaced by an equivalent least-squares problem, climinating the need for matrix factorization. Rather than solving the least-squares problem exactly, we apply a single-step gradient descent update. Consequently, the tailored DR splitting algorithm can be seamlessly unrolled into learnable network, delivering high-quality solutions for convex QPs. The distinct contributions of this work are follows:
Unrolled DR Splitting: We present a well-crafted neural network framework that leverages the unrolling of a modified DR splitring algorithm to efficiently solve convex QPs.
Convergence Guarantee: We present the convergence properties of the modified DR splitting algorithm and demonstrate that the unrolled network can recover the optimal QP solutions.
Empirical Evaluation: We validate the proposed framework through extensive experiments. The resulting solutions are employed to warm-start the QP solver SCS. The results indicate that our method significantly enhances the efficiency of solving convex QPs. In particular, our approach reduces the number of iterations by up to 50% and the solve time by up to 40%, demonstrating its effectiveness across diverse benchmarks.
2
Related Works
QP Algorithms. Recently, machine learning techniques have been applied to develop more effective policies within algorithms, surpassing the performance of traditional hand-crafted heuristic methods. For example, Ichnowski et al. (2021); Jung et al. (2022) employed reinforcement learning to choose hyperparameters in the OSQP solver, leading to faster convergence compared to the original update rules. Venkataraman Amos used neural networks to learn acceleration methods in fixed-point algorithms. While both approaches demonstrated improved convergence rates empirically, the convergence can not be theoretically ensured.
Algorithm Unrolling, Algorithm unrolling is a technique that bridges classical iterative optimization methods and deep learning by transforming the iterative steps of an optimization algorithm into the layers of a neural network. This approach enables end-to-end training, combining the strengths of both paradigms. Unrolled networks are not only interpretable, but they also tend to require fewer parameters and less training data compared to traditional deep learning models (Monga et al., 2021). By leveraging few layers of unrolled networks, these methods often learn solutions that would otherwise require thousands of iterations in classical algorithms. Significant success has been achieved in applications such sparse coding (Gregor & LeCun, 2010), compressive sensing (Sun et al., 2016), inverse problems in imaging (Aljadaany et al., 2019; Liu et al., 2020; Su et al., 2024) and communication systems (Sun et. al., 2023). However, these methods are not applicable to general optimization algorithms. Recently, Li et al. (2024); Yang et al. (2024) proposed unrolling the PDHG algorithm into neural networks to address general lincar programs and QPs, establishing theoretical results in this context. To the best of our knowledge, such theoretical advancements have not been extended to other efficient first-order methods, such as DR splitting-baser algorithms.
2

---

Published in Transactions on Machine Learning Research (08/2025)
Learning Warm-Starts. An effective strategy to accelerate solution processes is to provide high-quality initializations. For example, Baker (2019); Diehl (2019); Zhang & Zhang (2022) proposed predicting initial points to warm-start the solution process for power system applications. However, these methods mainly focus on solution mappings and do not address the specific needs of warm-starting nonlincar programming algorithms. Highly related works of Sambharya et (2023; 2024) train fully-connected neural networks by minimizing loss after taking several steps of the fixed-point algorithms. By incorporating additional algorithmic steps following the warm-start, the predictions are refined for downstream processes. However, due to the need for vectorizing problem parameters and solving linear systems during training, this method would struggle when addressing large-scale problems. In contrast to fixed-point algorithms, Gao et al. (2024) introduced IPM-LSTM, which replaces the time-consuming process of solving linear systems in IPMs with Long Short-Term Memory (LSTM) neural networks. While this approach shows promise in providing well- centered primal-dual solution pairs for warm-starting IPM solvers, the overhead of LSTM inference limits scalability to larger instances.
3 Preliminaries
3.1 Quadratic Programs
In this work, we consider convex QPs of the following form:
min SEK
1 Px Px c.x
s.t.
Ax + s s KC
(1)
where PE E Raxx, P 2 0, A E Rmxx, C R", and b E Rm are the problem parameters, with E R"
and 8 E K = R. denoting decision variables.
3.2
Douglas-Rachee Splitting
For convex QPs, the following Marush-Kuhn-TTukee (KKT) conditions necessary and sufficient for opti- mality:
Ar +
Pr A A + c= 0, sLg. y,
s sE K,
where y is the dual variable and 1C is the dual cone to IC, defined as K = auln] z 0, E K.. Let
P
A
M
y
- A 0
C =
R x
K
Since P 0, M M T 2 i.e., M monotone. Consequently, the KKT conditions can be expressed as the following monotone inclusion problem:
0E Mu + g Ne(u), where Ne(u) represents the normal cone of C, and is defined by
(2)
Ne(u) = {ul (z - ToS0 Vz u C.
0,
& C.
The optimal solutions for problem (1) can thus be obtained by solving the monotone inclusion problem (2).
To address problem (2), the well-known DR splitting algorithm (Douglas & Rachford, 1956), as outlined Algorithm 1, can be applied. In each iteration, an intermediate point d++1 is computed by solving a linear system, which is always solvable due to the full rank of 1 M. The updated point k+1 is then obtained
3

---

Published in Transactions on Machine Learning Research (08/2025)
Algorithm Douglas-Rachford Splitting
1: Input: M, C
2: Initialize: w +- 0
3: for k = 0, 1. do
4: aht1 - (I + (M-1(ww' 9)
wht1 Ie (2 wh)
wht1 +- wh (u++1 ū 11
end for
8: Return: u² = (**,
by reflecting _+1 around w and projecting onto the conic set C using Ilc. Finally, the iterate w**11 is updated by combining wh wt11, and @*+1, balancing objective minimization with constraint satisfaction. Let u² be the optimal solution to problem (2), if it exists. Then u u² as h + oc. Additionally, the residual | w11 + at rate of (1/kk) (He & Yuan, 2015; Davis & Yin, 2016).
4 Deep Unrolled DR Splitting
In this work, aim to design neural network architecture that efficiently learns high-quality solutions for convex QPs. However, directly unrolling Algorithm 1 presents challenges due to the need to solve linear systems in Step 4. To address this, we first introduce the DR-GD algorithm. Building on this foundation, we then present the unrolled neural network framework.
(I + )g
ú i+1
U
(I+ M )I M)
U (I M+MM M
W
U B
W
w?
w e+1
V
W.A.A
2V
i E+1
I
2+1
Figure 1: The figure shows one layer of the proposed DR-GD Net, which maps inputs (ū², wf) to outputs (ū ut1 w.+)). The update paths for å, u, and and w are used to compute the new state ift1 with parameters 0 = (Ug, U U by). Then af+1 and we are incorporated with ReLU activation function and parameters 0g (Vá, V.) to get the updated ut+1, Finally, the updated af+1 + with the previous state w are updated with parameters f.. = (We we W!) to produce w+1
colored black, blue and red, respectively. Both ät
4.1 DR-GD Algorithm
Solving linear systems is often achieved via direct melhods or indirect methods (Stellato et al., 2020; O'Donoghue, 2021). However, significant challenges arise when unrolling Algorithm with linear systems being solved by cither method.
Direct method: The direct method involves matrix factorization, where dynamic pivoting used, making the sequence of operations data-dependent and, therefore, not known in advance. This adaptive nature complicates the task of breaking the algorithm into fixed, unrolled architecture.
4

---

Published in Transactions on Machine Learning Research (08/2025)
Algorithm 2 DR-GD Algorithm
1: Input: g,q.C
2: Initialize: wº - 0, a +-
3: for h: = 0, 0,1,... do
4: th 4 (1 M + M) (w 9))
Compute n² by line search
a+t1 it 1
wh+1 Ne (2 11 - w
wht1 wh + (u at 1)
end for 10:
Return u² = (xt 21
Indirect method: The indirect method, in contrast, employs iterative algorithms, such as the con- jugate gradient descent method, to solve the linear systems. While this approach circumvents the need for matrix factorization, it introduces the complexity of inner-outer iterations, complicating the unrolling process.
Since + invertible, solving the linear system in Step of Algorithm is equivalent to addressing the following unconstrained least-squares problem:
1 [I M)u (w* - 9)||?
min f(ū)= =
(3)
Morcover, provided that the -orm of the error in solving the linear systems in Step 4 is finitely summable, Algorithm 1 guarantees convergence to optimal solutions (Eckstein & Bertsekas, 1992; Combettes, 2004). If problem (3) is solved to a pre-specified accuracy using iterative methods, unrolling Algorithm results in a nested architecture due to the inner-outer iterations. The need to replicate the iterative process increases complexity and reduces efficiency, making the unrolled network more difficult scale. In this work, we streamline the process by employing single gradient step, ū++1 t- a V f at each iteration, where at denotes the previous iterate and nf is the step size. This gradient-based update enhances both efficiency and scalability when unrolled. The resulting algorithm is outlined in Algorithm 2.
Proposition 1.
The sequence {u*} generaled by Algoritlm 2 converges to the solution of problem (2). Furthermore, the sequences (x*} and (v²} also converge to the solution of problem (1).
In Proposition 1, we demonstrate that Algorithm 2 converges to the optimal solution of problem (1), with the proof provided in Appendix A. While Algorithm 2 is expected to converge at a slower rate than Algorithm 1 due to the inexact evaluation involved in solving linear systems, it offers significant advantages in terms of unrolling and parameterization by eliminating the need for matrix factorizations or innerouter iterations.
4.2 Algorithm Unrolling
In this section, we propose DR-GD Net which is designed by unrolling Algorithm 2. The structure of the model is detailed in Algorithm 3, where parameters for channel expansion are introduced to enhance the model's ftexibility and learning capacity. 1d is row vector with all ones in dimension d, ño, u and w e g(++m))x" Let θ {10g, of, of L-1 .pL be the parameters of the network, where 0g (UÉ U U b)), 0 = (VG, V and O,, (Wz. W.. W&). of R is the prior knowledge about the step-size of the l-th layer. pk is the final linear mapping for the outputs. a--) is the sigmoid activation function. Projection onto a product conc C, He is performed womponent-wise. For dimensions corresponding to the full real space IR the projection is an identity mapping, leaving the values unchanged. For dimensions corresponding to the nen-negative orthant R,, the projection (a) = max(0, a). This operation is precisely the definition of the ReLU activation function, making it standard and computationally efficient building block for implementing this type of projection. The initialization can be seen as starting with 0, which is achieved by considering a pre-iteration state --1 and wo q, and running the subsequent algorithm steps for
5

---

Published in Transactions on Machine Learning Research (08/2025)
Algorithm 3 DR-GD Net
1: Input: M, q, C, number of layers I and embedding size de. Initialize: u t- 0, u [cc(-q), w -g-- 1dd + u²:
for (= 0,... L
do
4: Update ü: v <- U
5: g' (1+ M) (1 MM+ - (W' - ):
6:
a-t1 - - 1 (w' + Uu) og'
Update u + wl (2ū (2ū Vá vVv));
Update w: w+ w We + (u w(
end for
10: Return : P4
one iteration to generate the initial state. One layer of DR-GD Net is depicted in Figure 1. Specifically, the unrolled DR-GD Net can emulate Algorithm 2 by applying a specific instantiation of O Consequently, Algorithm 3 is capable of recovering the optimal solutions to problem (1) when an adequate number of layers are employed. However, by introducing learnable parameters, our goal to allow the network adapt to different problem instances, thereby enabling it to achieve approximate solutions with much fewer layers.
4.3 Training
In this work, the neural network is trained in supervised manner, with the loss function defined as the e² distance between the predicted primal-dual solutions (x, v) and the optimal solutions (x" .v"),, obtained by solving QPs using the SCS solver.
For a dataset of QPs, M, we train the proposed network by finding the optimal e by minimizing the following loss function:
IM
min θ
Σ (I1=; 21 + 11y. - Vt 1²),
M|
where the subscript i indicates the 7th sample in M.
In the recent works of Sambharya et al. (2023; 2024), an unsupervised loss function based on the fixed-point residual was proposed, which eliminates the need for labeled data. However, noted in Sambharya el al. (2024), this approach tends to focus on localized optimization metrics within the iterative process rather than the overall objective, potentially limiting its offectiveness; that is, the loss values may appear sufficiently low even when the solutions produced are far from optimal. By leveraging supervised learning with a regression loss, the DR-GD Net can learn an effective warm-start point, enhancing the performance of downstream DR splitting- based algorithms. This approach not only aligns the network architecture with the underlying algorithm but also incorporates the global insights provided by the ground truth optimal solutions.
5 Computational Studies
To evaluate the proposed framework, we first analyze the convergence behavior of Algorithm 2 on synthetic instances of varying sizes. Next, we compare its performance against state-of-the-art solvers and learning- based basclines on both synthetic and real-world datascts. Finally, we provide a dotailed discussion of the results. The code is publicly available at sstps://gitann wwwm/eeeSyyppp//t--oooot git.
Baseline Algorithms. In our experiments, we denote our algorithm as DR-GD-NN and compare it against state-of-tho-art solvers and L20 algorithms.
The solvers considered are:

---

Published in Transactions on Machine Learning Research (08/2025)
(i) SCS (O'Donoghue, 2021): A first-order solver for quadratic cone programming based on the DR splitting algorithm with homogeneous self-dual embedding.
(ii) OSQP (Stellato et al., 2020): A first-order convex QP solver based on the ADMM, which is equivalent to DR splitting under appropriate variable transformations.
(ii) TAPHHG (Lu et al., 2024): A restarted average PDHG method (Lu & Yang, 2025) for solving convex QPs.
For SCS, the default linear solver is used with an absolute feasibility tolerance of 10- relative feasibil- ity tolerance of 10-4, and infeasibility tolerance of 10-7. SCS also employs techniques such as adaptive step sizing, over-relaxation, and data normalization to enhance performance. Further details can be found in O'Donoghue (2021). rAPDHG is configured with absolute and relative tolerances of 10-1 and enabled l2 norm rescaling, as it otherwise exhibited convergence difficulties.
Unlike SCS, OSQP enforces only primal and dual feasibility without explicitly verifying the termination criteria based on the primal-dual gap. To ensure a fair comparison, we follow the approach Lu Yang (2025); O'Donoghue (2021) obtain OSQP solutions within the desired gap tolerance. Specifically, we initialize absolute and relative feasibility tolerances 10-4 (as in SCS) and iteratively halve them if the gap tolerance is not met. Additionally, the convergence-checking interval is set to be for both SCS and OSQP in all experiments.
The learning-based baseline algorithms include:
(i) L2WS (Sambharya et al., 2024): A feedforward neural network that takes vectorized instance parameters as input to generate warm starts, followed by 60 fixed algorithmic iterations, as suggested in Sambharya et al. (2024). The network is trained with the fixed-point residual as the unsupervised loss function.
(ii) L2WS (Reg) (Sambharya et al., 2024): A method that shares the same architecture and number of iterations as L2WS((p) but employs regression loss function instead.
(iii GNN (Chen et al., 2024): A graph neural network trained using a regression loss on graphs representing the QP instances.
Datascts. The datasets used in this work include synthetic benchmarks and perturbed real-world instances. Specifically, the datasets are:
(i) QP (RHS) (Donti et al., 2021): Convex QPs parameterized only by the right-hand side of equality constraints, generated as in Donti et al. (2021), with n = 200, 500, 1000 in the experiments.
(ii) QP (Gao et al., 2024): The dataset was generated as in Gao et al. (2024), where all the parameters are perturbed by a random factor sampled from U/0.9, 1.1].
(iii) QPLIB (Furini et al., 2019): Selected instances from Furini et al. (2019) with all parameters perturbed by a random factor sampled from (009, 1.1].
(iv) Portfolio (Stellato et al., 2020):
Consider the portfolio optimization problem, as introduced in Stel- lato et al. (2020), which is formulated as follows:
min "ER" yERK
x Dr
y
- p
s.t.
y = FT. x
1 T x =
x x20 0

---

Published in Transactions on Machine Learning Research (08/2025)
where the variable E R" represents the portfolio, y R is the axillary variable. The problem is parameterized by 1 IR" the vector of expected returns, y O the risk aversion parameter, F E _uxk the factor loading matrix and D E g=x=" diagonal matrix describing the asset-specific risk. The problems with h = 200, 300, 400 factors and n = 10k assets are considered in the experiments. The instances are generated by sampling Fij ~ N(0, 1) with 50% nonzero elements, Dù ~ U10, vkl, (0, and -
All instances considered in this work are formulated (4).
min =ER"
Pæ + +
2
s.t.
Az
(4)
Ga <
1 1 <
where P PT ž 0, Re" E R R G E Rm h E Tm12 are the model parameters. The bounds on the variables are given by l,u E R" The formulation in problem (4) can be transformed into problem (1) by integrating the bound constraints into inequality constraints and merging the equality and inequality constraints. The size each dataset listed Table 1.
Table 1: Problem sizes
Instance
7
m1
m2
QP (RHS)
N
N
N/2
N/2
QP
N
N
N/2
N/2
3913
300
61
600
8845
1,546
490
1,848
QPLIB
1270
1,600
3,202
3547
1,998
89
2,959
Portfolio
k
11k
k: 1
20k
For each dataset, 400 samples are generated for training, 40 for validation, and 100 for testing. All reported results are based on the test set.
Evaluation Configurationss All experiments were conducted on an NVIDIA GeForce RTX 3090 GPU and 12th Gen Int)l(R) Core(TM) 19-12900K CPU, using Python 3.9.17, PyTorch 2.0.1, SCS 3.2.6 (O'Donoghue, 2021) and OSQP 0.6.7 (Stellato al., 2020). To demonstrate the warm-start effect across various solver configurations and ensure experimental consistency with baseline methods, explored different parameter settings for SCS each dataset, as detailed in Appendix B.
In all experiments, DR-GD Nets with 4 layers and embedding sizes of 128 are trained with batch size of 2, a learning rate of 10-5, and the Adam optimizer (Kingma, 2014). The parameters 'f are set to 0.05 for QPLIB datasets and 0.1 for the other datasets. Early stopping is employed to terminate training the validation loss shows no improvement for consocutive epochs. The model achieving the best validation performance is saved for testing.
5.1 Convergence of DR-GD
This section analyzes the convergence behavior of Algorithm 2, the foundation of our proposed DR-GD Net. The convergence of Algorithm 2 is expected to be slower than Algorithm 1, due to the inexact evaluation each iteration. In Table 2, we compare the performance Algorithm 1 and Algorithm on the dataset QP with different sizes, with stopping criterion of 10-6 for the fixed-point error ||ok+11 wo 1/2 The

---

Published in Transactions on Machine Learning Research (08/2025)
columns "Obj.", "Max Eq." "Max Ineq", and "Iter." report the objective value, maximum equality constraint violation, maximum inequality constraint violation, and number of iterations upon termination, respectively. The "Ratio" column shows the ratio of the number of iterations required by Algorithm 2 to those required by Algorithm 1.
The results indicate that, Algorithm 2 could produce solutions with the desired feasibility and optimality, though it generally requires more iterations than the original DR splitting algorithm. The computational overhead remains manageable with maximum factor of 1.50 and decreases the problem size increases. Despite its slower convergence, Algorithm 2 avoids exact computation of linear systems, making it well-suited for the development of an unrolled neural network based on this approach.
Table 2: Convergence comparison between Algorithm and Algorithm 2
Algorithm
Algorithm 2
Instance
Ratio
Obj.
Max Eq.
Max Ineq.
Iter.
Obj-
Max Fi..
Max Ineq.
Iter.
200
337.126
4.0 10-10 10
4.6 x 10
5, 049
-37.126
2.4 10-6
1.4 10-6
7,555
1.50
QP
500
90.878
1.2 10-10 10
8.7 x 10-11
13, 653
-90.878
2.0 10-6
1.6 10-6
16, 523
1.21
1000
- 160.185
3.8 x 10-1
3.2 x 10-1
30,84t
165..885
2.6 x 10-7
2.0 10-6
36, 280
1.18
5.2
Computational Results on DR-GD Net
QP (RHS). We compare the warm-start performance of (FP), L2WS (Reg), GNN, and DR-GD-NM on the QP (RHS) test set across various problem sizes. The instances are parameterized by the right-hand sides of the equality constraints, encapsulated in a single vector that serves the input to the neural network in the L2WS models. The results are summarized in Table 3. The column labeled "Cold Start" shows the number of iterations and the solve time required by the SCS solver without warm starts. The "Iters."/ "Time (s)" and "Ratio" columns present the iterations/ /total time (including model inference and solve time in seconds) and the average reduction ratio achieved by each method across all test problems. To align the experiment settings of baseline methods, solver settings were configured with advanced techniques disabled, as shown in Table 6. The best results in each category highlighted in bold.
Overall, L2WS (2Wg(Reg) and DR-GD-NN demonstrate comparable performance. Specifically, L2WS(Reg) achieves the best results on instances with 200 variables, where the simple right-hand-sidd perturbation facilitates lcarning the mapping from parameters to warm-start points. However, as the problem scale increases, DR-GD-NN surpasses L2WS (Reg), achieving a 45.4% and 53.6% reduction in iterations for datasets with 500 and 1000 variables, respectively. This highlights the efficiency of DR-GD-NN handling larger instances, where the increased input size adds complexity to the solution mapping for L2WS. The L2WS (FP) variant generally outperformed by L2WS (Reg), except in the smallest case with 100 variables. This result demonstrates the superiority of using regression loss over the unsupervised fixed-point residual loss, which primarily focuses on intermediate metrics within the iterative process. This could potentially lead L2WS (FP) to converge to suboptimal regions, particularly in larger and more complex problems. In contrast, the regression loss leverages global information from ground-truth solutions, enabling better performance across a broader range of problem sizes and complexities. Additionally, while GNN performs competitively on instances with 200 variables, it falls short on larger datasets compared DR-GD-NN.
In terms of solution time, the proposed method consistently outperforms the baseline approaches, achieving reductions of up to 53.5%. Notably, even under some rare cases where the reduction in iterations is not the largest, DR-GD-NN still demonstrates superior efficiency. This advantage is attributed to the fast inference time of the proposed framework, which eliminates the need for the additional iterative steps required by the L2WS methods. For smaller instances, the reduction in the solving time is less pronounced compared to larger problems, probably because the shorter solving time for small instances leaves less room for improvement.
QP. In this section, we compare the performance of GNN and DR-GD-NN, both of which are trained in a supervised manner, using the loss function defined in Section 4.3. Since both methods are agnostic to the parameterization of the problems, we evaluate their performance the dataset QP across different, problem
9

---

Published in Transactions on Machine Learning Research (08/2025)
Table 3: Comparison of results on QP (RHS) dataset between L2WS (Fp), L2WS (Reg), GNN and DR-GD-NN.
Cold Start
L2WS (Pp)
L2WS (Reg)
GNX
DR-GD-XI NN
Instance
Iters.
Iters.
Ratio
Iters. +
Ratio
Iters.
Ratio
Iters. 4
Ratio f
200
3,855
3,616
6.2%
2,018
47.6%
2,203
42.8%
2,208
42.6%
QP (RHS)
500
10,827
10,820
0.1%
6,117
43.5%
6,350
41.3%
5,907
45.4%
1000
24,268
24,254
0.1%
21,566
11.1%
22,416
7.6%
11,266
53.6%
Cold Start
LPW
L2WS (Reg)
CNN
DR-GD-XI NNN
Instance
Time (s)
Time (x)
Ratio
Time (s) :
Ratio
Time (s) 4
Ratio
Time (s) L
Ratio f
200
0.470
0.490
-4.5%
0.293
37.7%
0.311
34.6%
0.289
38.1%
QP (RHS)
500
6,800
7,348
-8.2%
4.436
34.8%
4.019
40.0%
3.735
44.8%
1000
85.894
88.332
-2.9%
78.681
8.1%
79,900
7.3%
40.160
53.5%
sizes. The columns labeled "Cold Start Iters.//Cold Start Time (s)" and "Iters./""Tine (s)" denote the average number of iterations taken by the SCS solver with cold start and warm start points provided by the two methods, respectively, using the same configuration as in the previous section. The "Ratio" column represents the average ratio of reduction in the number of iterations and total time, respectively. GNN and DR-GD-NN achieve similar performance on smaller datasets with 200 variables. However, DR-GD-NN performs significantly better than GNN on larger datasets with 500 and 1000 variables. This trend consistent with the results Table 3, where both methods show comparable performance on smaller problems but DR-GD-NN demonstrates greater scalability and efficiency in learning effective warm-start points for the SCS solver on larger-scale problems.
Table 4: Comparison of results QP dataset between GNN and DR-GD-NM.
Cold Start
GNN
DR-GD-NN
Instance
Iters.
Iters. 4
Ratio f
Iters. |
Ratio
200
4,568
3,200
29.9%
3,168
30.6%
QP
500
10,507
10,432
0.5%
8,768
16.4%
1000
12,660
12,672
0.3%
10,862
14.1%
Cold Start
GNN
DR-GD-NN
Instance
Time (s)
Time (s) J
Ratio t
Time (s) $
Ratio
200
0.554
0.427
23.4%
0.406
26.7%
QP
500
6.591
6.701
-0.19%
5.517
16.1%
1000
21.543
21.889
-1.1%
18.639
13.0%
QPLIB and Portfolio. In this section, we evaluate the performance of DR-GD-NN on larger datasets, including instances from QPLIB and synthetic portfolio optimization problems. For these experiments, we use the default settings of SCS, as outlined in Table 6, to highlight the practical warm-start effect of our approach.
To evaluate performance, we analyze the warm-start effect in terms of both solving time and the number of iterations. The columns labeled "OSQP", "rAPDHG" and "SCS" present the solve time and iteration count for the two solvers under cold-start conditions. The column "SCS (Warm Start)" " includes the number of iterations required by SCS after utilizing the warm-start points, the inference time of DR-GD-NN, and the solve time, along with the total time, labeled "Iters.", "Inf. Time (s)", "Solve Time (s)", and "Time (s)" respectively. The ratio of improvement on the total time and number of iterations are included in the column "Ratio". The observed reduction in iterations ranges from 33.7% to 57.8%, demonstrating that the warm-start points generated by DR-GD-NN enable robust performance, even on more challenging instances.
While the model inference time increases with problem size, remains negligible compared the solve time, especially for larger-scale problems. The reduction in solve time ranges from 8.5% to 55.7%. For the Portfolio dataset with 100 factors and the QPLIB instance 3913, the improvement in solve time is minimal
10

---

Published in Transactions on Machine Learning Research (08/2025)
compared to other cases. This is attributed to the relatively small size of these problems and their inherently short solve times. Consequently, even with significant reduction in the number of iterations, the overall improvement in solve time is limited.
Table 5: Performance of DR-GD Net on QPLIB and Portfolio datsets.
OSQP
rAPDHG
SCS
SCS (Warm Start)
Ratio
Instance
Time (8)
Time (8)
Iters.
Time (8)
Iters.
Inf.
Time (8)
Solve Time (s)
Time (s)
Iters.
Time
3913
0.043
1.988
262
0.037
98
0.003
0.031
0.034
62.5%
8.9%
4270
0.744
7.779
5,677
1.693
2.705
0.007
0.816
0.823
57.8%
55.7%
QPLIB
8845
2.328
21.976
10,519
2.771
5,393
0.004
1.445
1.449
40.3%
39.0%
3547
5.886
5.579
29,690
6.283
17,286
0.011
3.655
3.666
37.5%
37.3%
0.155
2.165
654
0.150
0.004
0.132
0.136
33.7%
8.5%
0.411
2.372
997
0.626
545
0.005
0.363
0.368
45.0%
40.8%
Portfolio
300
1.056
2.763
1,272
1.656
734
0.007
1.007
1.014
42.2%
38.6%
400
2.183
3.481
1 1,533
4,280
712
0.010
2.140
2.150
53.4%
49.6%
5.3 Analysis of Loss and Iteration Improvement
Figure (2a) provides a detailed analysis of the relationship between validation loss and iteration improve- ment ratio over training epochs for the dataset Portfolio with 100 factors. The figure demonstrates that the validation loss steadily decreases as training progresses, indicating that the DR-GD-NN model is effec- tively learning to generate high-quality warm-start points. Simultaneously, the iteration improvement ratio increases as the loss decreases, suggesting strong correlation between the proximity of the predicted solu- tions the ground-truth solutions and the models warm-starting efficiency. This trend highlights how the predicted warm-start points, they approach the optimal solutions, lead to decrease in the number of SCS solver iterations required, thereby enhancing the solver's overall efficiency.
0.35
V
900
0.30
0.04
0.25
Imorov. Rabio
Number lterations
800
Valid Loss
0.03
0.20
700
0.15
0.02
0.10
300
0.05
0.00
20
30
40
300
Epoch
(a)
(b)
Figure 2: (a) Validation loss and itcration improvement ratio on the datasct Portfolio with 100 factors during training. (b) Box plot of the number of iterations required for cold starts and warm starts on the testing samples of the dataset Portfolio with 100 factors.
Additionally, Figure (2b) presents box plot comparing the distribution of solver iterations required for cold starts and warm starts across all test samples. The clear separation between the distributions highlights the consistent and significant warm-start effect throughout the testing dataset. Specifically, the median number of iterations required after warm-starting significantly lower than that for cold-starting, with noticcably narrower interquartile range. This reduced variability suggests that DR-GD-M not only enhances average solver performance but also contributes to more stable and predictable solver behavior.
11

---

Published in Transactions on Machine Learning Research (08/2025)
6 Conclusions
In this work, we introduce the DR-GD Net, an unrolled neural network model based on modified DR splitting algorithm, which eliminated the need for exact linear system solving at each iteration. The proposed architecture can effectively learn QP solutions and serves as a high-quality warm-start mechanism for SCS, a state-of-the-art first-order solver for convex QPs. Empirical results demonstrate that the proposed framework consistently reduces both the number of iterations and solve times across a range of problem instances. Future work will proceed in two main directions. First, we will focus integrating acceleration techniques, such the classical Anderson acceleration method, into the unrolled network to enhance its efficiency and robustness. Sccond, we aim to develop more scalable training framework, potentially using unsupervisod or semi-supervised learning, to handle problems with varying sizes, structures, and numerical conditions.
Acknowledgments
This work was supported by the National Key R&D Program of China (Grant No. 2022YFA1003900), Jinxin Xiong, Linxin Yang and Akang Wang also acknowledge support from National Natural Science Foundation of China (Grant No. 12301416), Guangdong Basic and Applied Basic Research Foundation (Grant No. 2024A 151003000,,, Shenzhen Science and Technology Program (Grant No. RC3S22221000::30022), and Hetao Shenzhen-Hong Kong Science and Technology Innovation Cooperation Zone Project (No. HZQSWS- KCCYB-202406).
References
Raied Aljadaany, Dipan K Pal, and Marios Savvides. Douglas-rachhord networks: Learning both the image prior and data fidelity terms for blind image deconvolution. In Proceedings of the IEFE/CVE Conference Computer Vision and Pattern Recognition, pp. 10235 10244, 2019.
Kyri Baker. Learning warm-start points for ac optimal power flow. In 2019 IEEE 29th International Workshop Machine Leorning for Signal Processing (MLSP), pp. 1-6. IEEE, 2019.
Stephen Boyd and Lieven Vandenberghe. Conver optimization. Cambridge university press, 2004.
Stephen Boyd, Enzo Busseti, Steve Diamond, Ronald N Kahn, Kwangmoo Koh, Peter Nystrup, Jan Speth, et al. Multi-period trading via convex optimization. Foundations and Trendsh in Optimization, 3(1):1 1::1-1770 76, 2017.
Tianlong Chen, Xiaohan Chen, Wuyang Chen, Howard Hcaton, Jialin Liu, Zhangyang, Wang, and Wotao Yin. Learning to optimize: primer and benchmark. Journal of Machine Learning Research, 23(189):
1 59, 2022.
Ziang Chen, Xiaohan Chen, Jialin Liu, Xinshang Wang, and Wotao Yin. Expressive power of graph neural networks for (mixed-integer) quadratic programs. arXiv preprint Xrxi:22406. 05938, 2024.
Patrick L Combettes. Solving monotone inclusions via compositions of nonexpansive averaged operators. Optimization, (3(5-6))475-504 2004.
Corinna Cortes. Support-vector networks. Machine Learning, 1995.
Damek Davis and Wotao Yin. Convergence rate analysis of several splitting schemes. Splitting methods in communication, imaging, science, and engineering, pp. 115-163, 2016.
Frederik Dichl. Warm-starting optimal power flow with graph neural networks. In 33rd Conference Newral Information Processing Systems (NeurIPS 2019), pp. 1-6, 2019.
Priya L Donti, David Rolnick, and J Zico Kolter. De3: A learning method for optimization with hard constraints. In International Conference Learning Representations, 2021.
Jim Douglas and Henry Rachford. On the numerical solution of heat conduction problems in two and three space variables. Transactions of the American mathematical Sociely, 82(2):421-433 -439, 1956.
12

---

Published in Transactions on Machine Learning Research (08/2025)
Jonathan Eckstein and Dimitri P Bertsekas. On the douglasrachford splitting method and the proximal point algorithm for maximal monotone operators. Mathemalical Programmingg 55:293-312 1992.
Stephen Frank and Steffen Rebennack. An introduction to optimal power flow: Theory, formulation, and examples. HE transactions, 48(12):1172 1197, 2016.
Fabio Furini, Emiliano Traversi, Pietro Belotti, Antonio Frangioni, Ambros Gleixner, Nick Gould, Leo Liberti, Andrea Lodi, Ruth Misener, Hans Mittelmann, et al. Qplib: library of quadratic programming instances. Mathemalical Programming Compulalion, 11:237-2663 2019.
Xi Gao, Jinxin Xiong, Akang Wang, Qihong Duan, Jiang Xue, and Qingjiang Shi. Tpm-lstm: A learning- based interior point method for solving nonlinear programs. In The eightt Annual Conference on Newrul Information Processing Systems, 2024.
Carlos E Garcia, David M Prett, and Manfred Morari. Model prodictive control: Theory and practicea survey. Automatica, 25(3)3335-344 1989.
Maxime Gasse, Simon Bowly, Quentin Cappart, Jonas Charfreitag, Laurent Charlin, Didier Chételat, Anto- nia Chmiela, Justin Dumouchelle, Ambros Gleixner, Alcksandr M Kazachkov, et al. The machine learning for combinatorial optimization competition (ml4400): Results and insights. In NewrIPS 2021 competittons and demonstrations track, pp. 220-231. PMLR, 2022.
Karol Gregor and Yann LeCun. Learning fast approximations of sparse coding. In Proceedings of the 27th international conference on international conference on machine learning, pp. 399-406, 2010.
Bingsheng He and Xiaoming Yuan. On the convergence rate of douglas- operator splitting method. Mathematical Programming, 153(2):715 722, 2015.
Jeffrey Ichnowski, Paras Jain, Bartolomeo Stellato, Goran Banjac, Michael Luo, Francesco Borrelli, Joseph E Gonzalez, Ion Stoica, and Ken Goldberg, Accelerating quadratic optimization with reinforcement learning. Advances in Newral Information Processing Systems, 34:21043-21055, 2021.
Haewon Jung, Junyoung Park, and Jinkyoo Park. Learning context-aware adaptive solvers to accelerate quadratic programming. arXiv preprint arXim:2211.12445 2022.
Diederik P Kingma. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
Bingheng Li, Linxin Yang, Yupeng Chen, Senmiao Wang, Qian Chen, Haitao Mao, Yao Ma, Akang Wang, Tian Ding, Jiliang Tang, et al. Pollg-unooledd learning-to-optiniiz method for large-scale linear program- ming. In Forty-first International Conference on Machine Learning, 2024.
Jiulong Liu, Nanguang Chen, and Hui Ji. Learnable douglas-rachfort iteration and its applications in dot imaging. Inverse Problems & Imaging, 14(4), 2020.
Haihao Lu and Jinwen Yang. A practical and optimal first-order method for large-scale convex quadratic programming: H. lu, j. yang. Mathematical Programming, pp. 1 1-38, 2025.
Haihao Lu, Zedong Peng, and Jinwen Yang. Mpax: Mathematical programming in jax. orXiv preprinl arXiv:2412.097 2024.
Harry Markowitz. Portfolio selection, 1952.
Vishal Monga, Yuelong Li, and Yonina C Eldar. Algorithm unrolling: Interpretable, efficient deep learning for signal and image processing. IEEE Signal Processing Magazine, 38(2):18-44, 2021.
Yurii Nesterov and Arkadii Nemirovskii. Interior-point polynomial algorithms in convez programming. SIAM, 1994.
Jorge Nocedal and Stephen J Wright. Numerical optimization. Springer, 1999.
13

---

Published in Transactions on Machine Learning Research (08/2025)
Brendan O'Donoghue. Operator splitting for homogencous embedding of the linear complementarity problem. STAM Journal on Oplàmization, 31 (3):19999 2023, 2021.
Rajiv Sambharya, Georgina Hall, Brandon Amos, and Bartolomeo Stellato. End-to-end learning warm- start for real-time quadratic optimization. In Learning for Dynamics and Control Conference, pp. 220-234.
PMLR, 2023.
Rajiv Sambharya, Georgina Hall, Brandon Amos, and Bartolomeo Stellato. Learning to warm-start fixed- point optimization algorithms. Journal of Machine Learning Research, 25(166):1-46, 2024.
Bartolomeo Stellato, Goran Banjac, Paul Goulart, Alberto Bemporad, and Stephen Boyd. Osqp: An operator splitting solver for quadratic programs. Mathemalical Programming Compulation, 12(4):637-6i) 672, 2020.
Yueming Su, Qiusheng Lian, Dan Zhang, and Baoshun Shi. Transformer based douglas-rachford unrolling network for compressed sensing. Signal Processing: Image Communication, 127:117153; 2024.
Jian Sun, Huibin Li, Zongben Xu, el al. Deep admm-net for compressive sensing mri. Advances in neural information processing systems, 29, 2016.
Rongehao Sun, Yiqing Zhang, Hanying Zheng, Jianhua Guo, Jianyong Sun, and Jiang Xue. A douglas- rachford splitting approach based deep network for mimo signal detection. In 2023 IEEE Wireless Com- munications and Networking Conference (WCNC), pp. 1 IEEE, 2023.
Robert Tibshirani. Regression shrinkage and selection via the lasso. Journal of the Royal Statistical Society Series B: Slatistical Melhodology, 58(1):267 288, 1996.
Shobha Venkataraman and Brandon Amos. Neural fixed-point acceleration for convex optimization. In 8th ICML Workshop Automated Machine Learning (AutoML).
Philip Wolfe. The simplex method for quadratic programming. Econometrica: Journal of the Econometric Society, pp. 382 398, 1959.
Linxin Yang, Bingheng Li, Tian Ding, Jianghua Wu, Akang Wang, Yuyi Wang, Jiliang Tang, Ruoyu Sun, and Xiaodong Luo. An efficient unsupervised framework for convex quadratic programs via deep unrolling. Xiviv preprint Xiv:244 010511, 2024.
Ling Zhang and Baosen Zhang. Learning to solve the ac optimal power flow via a lagrangian approach. In 2022 North American Power Symposium (NAPS), 1-6, 2022. doi: 0AA.I//AAAPS01110022000000110110
14

---

Published in Transactions on Machine Learning Research (08/2025)
A Proof of Proposition
Our goal is to prove that the sequence generated by Algorithm 2 converges to the solution of problem (2). The proof will contain two parts:
First, we will prove that Algorithm 2 is convergent.
Second, we will prove that Algorithm 2 converges to the solution of problem (2).
Lemma 2. Let C' be a convex subset of Hilbert space Н. For any E H, a point E C is the projection of onto C' (t.e., = ll(()) if and only p (Id+ No is the normal cone C.
where Id is the identity operator on and
Proof. By definition of projection onto convex set C, = [l((2) if and only if (x p,y P S Vy E C. Recall the definition of normal cone: Vp E C,Nc = {=1(y - p) 2 $ 0, E C}. Therefore,
(x p.リ p) S 0, Vy E C' + (x - p) e Nc(p).
Since C' a convex set, the normal cone Nç is a maximal monotone operator, which ensures that its resolvent (Id + Nc) is a well-defined, single-valued function.
We can now construct the chain of equivalences:
= Tc(x) + (a p.y p.y p) S0,V
+ (x p) Nc(p)
+ p E (Id + Nc)
+ p= = (Id+ (c)
Lemma 3. A single iteration Algorithm 2, which maps wh to wh can be expressed by the operator Ti
follows:
[ (Id+ C2c Id)) w
w+1 =Te(w>)) w +
where
( (1- at (I+ M) (w
and CNo is the Cayley operator associated with the normal cone Ne.
Proof. The proof proceeds by direct substitution. The Cayley operator CNe defined as Cn. = 2(Id + Ne)-1 Id. Therefore, from Lemma 1, we get IIe = [CNe + Id).
Using it we reformulate the three key steps in Algorithm 2:
Step 6: 1+1 t- th - (I M) ((I + MYa² - -ww - -))
Step 7: u k+1 + Te (2 - w
Step wtt + nh (utt1_ x11
By using the definition of (,(w),, the step 6 can be rewrite as ah+l Dx By rewriting the projection operator using the Cayley operator, the step 7 can be reformulated as
1 (Oxe + Id) w = [(CNe + Id)(2 Id)] w
1
u k+
2
15

---

Published in Transactions on Machine Learning Research (08/2025)
Then, finally, step 8 can be reformulated
wht wh + uk1 k-1
[Cno + (2) Idd] wh (x(
[
1 =0 (u(==) CNo (20 - Idjw *x(u
w +
2
1
Ne (2 Idjw w
wh
2
1 (Id + C2 [d)) wt Ik(("*)
w
2
Lemma Rewrite Algorithm wh11 Tx(w=*, where Ta
(Id CN. (2 Id))
Assume
OREN Fix Th # 9, then ΣxEN [TT (w²) w 112 < t00 which implies that [ookt1 w ++0
Proof. According to Lemma 3, the Algorithm 2 can be rewritten
w+t1 (x(""*) = + 1/100 (Id + CNo(2pg Id)) w²t
(5)
where
(x(w)= = (I- n/ (I M) MI at + (I M (w-
and ON. is the Cayley operator.
Since (wi) 2x (w2)]l S 11 + M ||||| - w2l1, 2x lipschitz continuous with constant L = 1f² Amax +1+
M). Also, as
(Qx(w) - (w2),, w2) (1 M) - w2), wi w2) 2 1)" Amin (1 + M) w2 11?
Φ is strongly monotone with constant m² 1/"h Amiu (I 7+ M).
[21)((w)) w1 - (24x - W2)
[2()x(w1)) - 42 (w>) (w] w2)ll
(w]) 2x (w²) (w)(ww) Φ (w2), w1 -w2) + +|[w w2
S (4(LK)²2 4m + 1)]lur - w22l²
If 4(I"1² 4m + 1 < that is m (I then 2 Id is nonexpansive and contractive.
Assume that by using lino-scarch such that v/
Auaia MM+ then 20 Id is nonexpansive and thus Xmnxe
1 Th -
(Id Id)) A(
is an averaged operator. As (5) taking the form of Algorithm 1.2 in Combettes (2004) with A = 1, and an 1. according to Theorem 3.1 and Remark 3.4 in Combettes (2004) we can conclude that EtEn [[Ta(w"*) - w01 +00, and thus || - +0
Corollary (Corollary 5.2 Combettes (2004)). Let y E (0, 00), let {ur} be a sequence in (0. 2), and let {ax} and {bk} be a squence in H. Suppose that E A B feasible, ΣvEN vx) +00, and ΣXEN vx ([|aæ]l + [lbal]) < too. Take xn E E and set E
Øb+1 = 24 + v4 RyA (R + by) xx) + (RyBTK + bb)),
where RAA [d)+ RBB (Id + +) are the resolvants for A and B. Then {ax} converges weakly to some point x E H and RBR E (A+ B) (0).
16

---

Published in Transactions on Machine Learning Research (08/2025)
The sequence fu²} generated by Algorithm 2 converges to the solution of problem (2). Furthermore, the sequences {a*} and {v*) also converge to the solution of problem (1).
Proposition 1
Proof. From (5), let &E Rr eR, where e represents the error induced by the inexact evaluation of the resolvant of F. Therefore, the Algorithm 2 can be rewritten as
wh+1 Th(w*) 1
2 (Id (Id+ ONe (2 Id))
2 w² + RNc (2 - Idjw
2 (24 - Id)
w/ RNC (2Rp(u*) w²) (Rf(w*) c*)
By taking Ik = wh, ag = 0, by = -- 1, = and let A RNC and B= = F, Algorithm 2 is taking the form of (5). To prove the Proposition 1, we are left. show that ΣvEN ||c*|| < toc.
Let [x(ū) = _ + M) (w* 4)l|? line 5 in Algorithm can be writlen as
ak+1 = -a- -ff-(((
where the step size n² is chosen to satisfy the Wolfe conditions (Nocedal & Wright, 1999), that is
fu(a*) (1 2 V
(6)
(T 5 (2 [
(7)
where ej and 62 are the parameters for the line search and < < 02 <1
From (7), we have
- ffa (it(tt) S 1) [f
f is Lipschitz continuous with constant = maax (1 + M), as [V/x(() v S L|[e y/l Therefore
(V VSa(ū*)) v/a(ā*)
(V (V Vf((E"))V\(a(())
& ( [(((+)))|
< (/LII
which implies that
a > (Vit(th)) ) (tt)
L. (
(1 02)
-- L
17 V |/2
Therefore
1 1- 02
fa(ā²) fa
ci
Since fa(ū) 2 0
l2(tt+1) fa(uk)
1-
1 1 02
2a
201
mmin (I + M),
L
fa(
L
where amin (I + M) 2 the minimum singular value of (I+ M). (As M + M > 0, the real parts of the cigenvalues of M are nonnegative.)
The last inequality from:
(a (T MYT ((T M)a (w -))
17

---

Published in Transactions on Machine Learning Research (08/2025)
(x((**)
(11 + +M) - -ww - -1) ( (1 + M1 ( ((1 + M)a+ - -( (wx-q)) 4))
2 22mia (IT MT I1(7 + M) (wo q)1
(rayleigh quotient)
20 (T 1+MM M).
- 1 the assumption in Lemma 4, then 3K, such that Vk > K Øx+1 8e d and 2 Id is contractive. Therefore, 4k > K, < c < 1, such that | w² I cllu** - w--1l || and thus Σx=x | - wx1l < to0. As ΣVEN ||w - 11
From Lemma 4, EbEN | 11 < +o0 and ||
O. Let us further assume that r/ also satisfies
+00, Ek- || wh1l bounded. We can conclude that ΣkEn - < to0.
Defining 7h ( and taking < 9 fx((t)
< < < 1, then
2
xh fa(ū
1 - 02
< 1. min (I + M) 1 1-200 -2, 02) min (I MM)
< - 2c1
fx(at)
L
o max (1 (1+ M)
Therefore
II(T + MMa - - S + M)²² - (w* -9)ll-
| = | - + MM) (w - 9)1l
$ [[(Z + M)) M)a (w* 9)l
+
$ [[[]+ (10++))~1|+>(1=1- + M) - (w - 4)
< |[/++)]~\|++1(+- + +M)]' - (w k- - 9) + (w k-1 - 4) - -ww* s)ll
< [[++M))'|[77]1] M)a= (w 9)ll + +T/l - wx-111)
< 11 + M) k+ [1(I + MM (w -9)ll + Σ 1|22" - w--11l)
k Σ 1=0
k k j+ 1w - - (denote w(1 (1 + M)²²) (}+
= [1(1 + +M)
[ + (M) laa.
Next, prove the convergence of Σ ben ||e||| by showing the convergence of ΣvEN ap.
8
Σ ak Σ a
k-j+1
1| - -w-111
KEN
k=
b=
20
w - 8
A+1-3
Σ
1w -
w -
k
1=0
km
=
w
w
1||
T
+00
1-
1=0
Therefore, EXEN || & Eee de to0. Then according to Corollary 5, can conclude that Ew*, such that w - w" As in finite-dimensional space strong convergence and weak convergence are equivalent, we can conclude that w + w². In addition, n" = o Rr(w") (F Nc)
18

---

Published in Transactions on Machine Learning Research (08/2025)
B SCS Settings
The paramcter settings for SCS in the experiments are listed in Table 6:
Table 6: Solver configurations.
data scaling
adapt dual scale primal alpha
acceloration lookback
acceleration interval
QP /R OPLIB/Portfolo
False True
False
0.1
True
10-8
1.5
10
10
C Offline Time
Table 7: Time for collecting training and validation instances and training model (measured in seconds).
Instance
Data Collection
Training
200
6
215
QP(RHS)
500
42
481
1000
296
1007
200
5
108
QP
500
39
286
1000
145
1422
3913
505
4270
785
3598
QPLIB
8845
1355
5992
3547
2885
8388
100
85
2875
200
370
5221
Portfolio
300
948
8372
400
2579
10214
D Analysis of Number of Gradient Steps
In Table 8, compare the number of iterations required for convergence using the same experimental settings as in Section 5.1, but on newly generated instances. The solution quality follows a similar trend to the results presented in Table 2 and is therefore omitted here for brevity. We unrolled the DR-GD algorithm (Algorithm 2) with 1, 2, 3, 4, 5, and 10 gradient steps and compared the number iterations against the original DR splitting algorithm (Algorithm 1).
Despite the notable reduction in iterations with additional GD steps, we chose to unroll the algorithm with only single step in the manuscript. This design was made avoid complicated inner-outer architecture, mentioned in Section 4.1, and to maintain simpler and more straightforward structure for the unrolled network.
We investigated whether unrolling more gradient descent (GD) steps per layer improves DR-GD Net per- formance, with results shown in Table 9. We tested versions with 1, 2, 5, and 10 inner GD steps (see Algorithm 4) on validation of QP(RHS) and observed clear tradc-off. From the table, we obscrve that the most. significant solution time reductions achieved with 1 to 2 GD steps per layer and solution qual- ity deteriorates step count increases, evidenced by rising maximum violation values and growing h-error norms. These results demonstrate that current single-step approximation yields approximate solutions of higher quality as well as better performance boost.
19

---

Published in Transactions on Machine Learning Research (08/2025)
Table 8: Convergence comparison between Algorithm and Algorithm 2 with different numbers of gradient
steps per-iteration.
Algorithm
Instance
Algorithm 1
step=1
step-2
step=3
step=4
step=5
step=10
200
7447
6093
5943
5907
5876
5840
5815
QP
500
18427
14723
14171
14025
13918
13780
13646
1000
22539
17788
17015
16817
16671
16502
16358
Algorithm 4 DR-GD Net with multi-gradient steps
Input: M, q, C, number of layers L and embedding size d'.
Initialize: u t- 0, u Ie((-q), w 1dd + uu, imroll_steps for L ..... L do Update ü: w w q- 1d
for i 1,... unroll steps do vf +- ntt.
6:
7:
g' + (M+ ((I + M)ve w');
8:
n' [-vve ve vfo (w'U% + b ② gg:
9:
end for
10:
ge+1+ + /t!
Update u: e+l + IIe (2ū +1 V w w'V
11:
12: Update w: wet1 + w We + (u + W (
13:
end for
Return u uL
14:
Table 9: DR-GD Net with different unrolling of gradient steps per-iteration.
Instance
Unroll Steps
Iter. Ratio
Time Ratio
Obj.
Max Viol.
& Norm
40.4%
36.0%
-36.730
1.264
0.002
2
40.7%
34.6%
-36.807
1.929
0.004
QP(RHS) 200
5
39.7%
29.7&
-37.120
1.977
0.004
10
37.0%
22.7%
-36.426
2.048
0.005
1
39.2%
37.1%
-91.272
1.366
0.001
2
39.2%
38.2%
-91.721
3.477
0.003
QP(RHS) 500
5
36.4%
34.5%
-90.479
3.539
0.004
10
-0.8%
-4.1%
-85.441
29.962
0.479
20

---

Published in Transactions on Machine Learning Research (08/2025)
E Testing on larger perturbations
To assess the model's robustness to larger perturbations, we evaluated model trained with perturbation factor of 0.1 on test set with a 50% larger perturbation factor (0.15). As shown in Table 10, performance is maintained despite this distribution shift, providing initial evidence of the model's robustness. QPLIB 3913 was omitted from this analysis due to its limited acceleration on the original dataset.
Table 10: Testing on larger perturbations.
OSQP
SCS
SCS (Warm Start)
Ratio
Instance
Time (s)
Iters.
Time (s)
Iters.
Time (s)
Iters.
Time
4270
0.780
4,577
1.275
2,270
0.651
44.8%
42.5%
QPLIB
8845
2.391
10,489
2.292
6,189
1.767
32.1%
30.9%
3547
4.220
24,201
5.134
17,073
3.642
28.9%
28.5%
F
Solution Quality
The following Table 11 compares the solution quality and the inference time in seconds ("Inf Time(s)") of baseline methods on the QP(RHS) datasets. The results demonstrate that DR-GD-NN generally achieves better objective values and smaller distances to the optimal solutions, especially for larger-sized problems. While L2WS variants do exhibit marginally beiter feasibility ("Max Viol."), this advantage cornes al consid- erable computational expense ("Inf. Time") due their mandatory feasibility restoration step.
Table 11: Solution quality of different methods on QP(RHS) datasets.
Instance
Method
Obj.
Max Viol. & Norm
Inf. Time (s)
SCS
-36.688
(2eg)
-36.611
0.002
0.001
0.011
QP(RHS) 200
L2WS(Fp)
-36.437
0.001
0.007
0.011
GNN
-38.192
6.447
0.035
0.002
DR-GD-NN
-36.730
1.264
0.002
0.002
SCS
-91.176
(2Wgg
-90.500
0.001
0.002
0.072
QP(RHS) 500
L2WS(Fp)
-0.397
0.987
0.839
0.072
GNN
-66.463
17.903
0.110
0.005
DR-GD-NN
-91.272
1.366
0.001
0.004
SCS
-160.245
(Reg)
-84.326
0.008
0.330
0.303
QP(RHS) 1000
L2WS(FP) -0.382
0.995
0.681
0.310
GNN
-70.227
18.181
0.530
0.018
DR-GD-NN
160.545
1.750
0.001
0.012
21

---

Published in Transactions on Machine Learning Research (08/2025)
G Supplementary Experiments on Larger Instances
In this scction, we conduct experiments on QPLIB 8785, featuring problem sizes approximately 10 times larger than those in our main experiments. The specific sizes are detailed in Table 12.
The results are reported in Table 13. On average, the SCS solver required 1,559 iterations and 14.474 seconds solve this instance. However, by using the solution from our DR-GD Net as warm start, the itcration count and solve time for SCS were reduced 711 and 7.025 seconds, respectively. This corresponds to an improvement. of 50.7% in iterations and 49.7% in solve time. These results demonstrate that the proposed method performs effectively and maintains its benefits significantly larger instances.
Table 12: Problem size of instance QPLIB 8785
Instance
7
QPLIB
8785
10,399
11,362
20,798
Table 13: Performance of DR-GD Net on QPLIB datsots.
OSQP
TAPDHG
SCS
SCS (Warm Start)
Ratio
Instance
Time (8)
Iters.
Time
Iters.
Time (s)
Iters.
Inf. Time (s)
Solve Time (8)
Time (8)
Iters.
Time
QPLIB
8785
4.255
15,113
254.6
1,559
14.474
711
0.146
7.025
7.171
50.7%
49.7%
22

---

Published in Transactions on Machine Learning Research (08/2025)
H Comparison with DR-GD
The following table compares the solutions' objective values ("Obj."), feasibility satisfaction ("Max Viol." and distances to optimal solutions (*22 Norm") on the QP(RHS) datasets. DR-GD(n) represents the case where DR-GD stops after n iterations, while DR-GD-NN denotes our DR-GD neural network. The results demonstrate that DR-GD-NN produces solutions with objective values ("Obj.") and proximity to optimal solutions ('2 Norm") quite close those obtained from DR-GD(5000), while maintaining acceptably low constraint violations. Most notably, DR-GD Net. achieves this comparable solution quality using only 4 layers, representing substantial improvement in computational efficiency over the conventional approach requiring 5000 iterations. These findings validate that our network architecture effectively match the performance of standard DR-GD while requiring significantly fewer computational resources.
Table 14: Comparison of solution quality between DR-GD and DR-GD Net
Instance
Method
Obj.
Max Viol.
t Norm
DR-GD(4)
6.526
5.101
0.913
DR-GD(10)
9.615
3.774
0.995
DR-GD(100)
-18.586
2.178
0.453
QP(RHS) 200
DR-GD(500)
-33.726
0.271
0.052
DR-GD(1000)
-35.248
0.048
0.009
DR-GD(5000)
-35.525
0.000
0.000
DR-GD-NN
-36.730
1.264
0.002
DR-GD(4)
19.718
11.194
1.062
DR-GD(10)
30.545
8.917
1.167
DR-GD(100)
1.556
3.449
0.977
QP(RHS) 500
DR-GD(500)
-68.233
1.358
0.287
DR-GD(1000)
-83.588
0.378
0.118
DR-GD(5000)
-92.731
0.009
0.001
DR-GD-NN
-91.272
1.366
0.001
DR-GD(4)
43.140
17.593
1.019
DR-GD(10)
69.374
13.780
1.140
DR-GD(100) 23.985
5.808
0.980
QP(RHS) 1000
DR-GD(500)
-116.195
2.022
0.314
DR-GD(1000)
-147.401
0.563
0.143
DR-GD(5000)
-167.809
0.014
0.002
DR-GD-NN
-160.545
1.750
0.001
23

---

Published in Transactions on Machine Learning Research (08/2025)
Ablation on Number of Layers
To systematically evaluate the impact of the number of layers, we trained DR-GD Net with 1 to 6 layers on the QP(RHS) datasets and measured the resulting reduction ratios in both iteration count and solve time. Figure 3 shows the resulting reduction ratios in iteration count and solve time on the validation set. The computational performance generally improves as the number of layers increases. However, the improvements become marginal beyond layers. Therefore, balance performance and model complexity, chose to 4-layer architecture for experiments.
QP(RHS) 200
QP(RHS) 500
40
QP(RHS) 1000
Iter. Improv. Ratio (%)
30
10
1
2
Number of layers
QP(RHS) 200
QP(RHS) 500
40
QP(RHS) 1000
Time. Improv. Ratio (%)
30
20
2
Number of layers
Figure 3: Improvement ratios for iteration count (3a) and solve time (3b) the QP(RHS) validation sets, evaluated for models with different nunbers of layers.
24


Reviews:
[{"review_id": "WC2EjpDJ2y", "reviewer": "Reviewer_hB1Y", "summary": "", "questions": "", "limitations": "", "rating": null, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "**Strengths**\n\n1. The central idea of modifying a classical optimization algorithm to make it \"unroll-friendly\" is both novel and practical.\n2. Although the theoretical guarantees for the main method (DR-GD Net) are difficult to find and verify, the method is based on a theoretically sound building block (DR-GD) having a convergence guarantee.\n3. The empirical evaluation is extensive and convincing. The authors test their method on a diverse set of benchmarks.\n\n**Weaknesses**\n\n1. Proofs in Appendix A: statements and implications\n    1. In the statement of Lemma 2, it directly equates $T_k$ to a specific form involving technical terms like $C_{N_c}$ and $\\Phi_k$ *before* properly defining them in the context of Algorithm 2. While $\\Phi_k$ is defined later in Equation (5), the introduction of $T_k$ seems to assume properties that are not immediately obvious from Algorithm 2. A clearer step-by-step derivation of how Algorithm 2 maps to this form of $T_k$ would improve clarity.\n    2. As far as I understood, the proofs in Appendix A do not provide a non-asymptotic convergence rate.\n2. Possible difficulty in scaling to larger problems\n    1. A major limitation of the proposed method is that it requires the ground-truth optimal solutions of training instances. To this end, you still need to run a linear system solving algorithm or many iterations of a gradient-based algorithm that approximates it. Although the DR-GD eliminates the steps of solving linear systems inside the algorithm, the supervised training of DR-GD still suffers from them, which is nearly prohibitive for high-dimensional problems.\n    2. Another problem is that a single DR-GD Net can solve issues of fixed dimension. If the problem dimension increases, you have to train a totally new DR-GD Net from scratch.\n3. Ambiguity in the description of Algorithm 3 (DR-GD Net)\n    1. The algorithm specifies initializing iterates ${\\bf u}^0$ and ${\\bf w}^0$ using ${\\bf q}$ and $q$. There is no rationale provided for why these specific initializations (${\\bf u}^0 \\leftarrow \\Pi_{\\mathcal{C}}(-{\\bf q})$ and ${\\bf w}^0 \\leftarrow q\\cdot{\\bf}1^{d^0}+{\\bf u}^0$) were chosen or whether they are critical to the model's performance.", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "Yes", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "paper_topic_and_main_contributions": "", "excitement": null, "reproducibility": null, "ethical_concerns": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "summary_of_contributions": "This paper introduces a novel deep-learning framework, named DR-GD Net, for solving convex Quadratic Programs (QPs). To this end, the authors first propose a modification to the classical Douglas-Rachford (DR) splitting algorithm, called DR-GD algorithm, by replacing the computationally expensive step of solving linear system with a single gradient-descent (GD) step on regression loss. A theoretical guarantee of convergence to the optimal QP solution is proved. Then, the DR-GD algorithm is unrolled into a deep neural net architecture that can be trained on various instances of QPs in a supervised manner. The trained DR-GD Net is exploited to find a warm-starting point of a first-order QP solver (SCS). The proposed method is evaluated on several synthetic and real-world datasets and compared with other various (non-)learning-based methods.", "claims_and_evidence_yn": "Yes", "claims_explanation": "", "audience_yn": "Yes", "audience_explanation": "", "requested_changes": "**Required Changes**\n\n- Every point I listed above in the weaknesses should be resolved.\n\n**Recommended Changes & Some Questions expected to be answered**\n\n- Although it is pretty clear that the projection operator $\\Pi_{\\mathcal{C}}$ can be implemented with ReLU, the authors can add one more sentence to explain why.\n- Have the authors tried the version of unrolling DR-GD with a few more steps of GD for each iteration of it?", "broader_impact_concerns": "Since this work focuses on the theoretical aspects of an optimization algorithm and its simple applications, the Broader Impact Statement section seems unnecessary.", "additional_comments": "", "extra_scores": {}, "extra_text": {}}, {"review_id": "Ck18onpOXa", "reviewer": "Reviewer_yvxR", "summary": "", "questions": "", "limitations": "", "rating": null, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "## Strengths\n- **[S1]**: Methodologically, a strength of the paper is in the architecture design, which aligns with the iterations of the inexact DR splitting algorithm with a small number of learnable parameters.  \n- **[S2]**: The numerical results.  For the other learning-to-optimize-based approaches, DR-GD Net computationally finds solutions that act as a better warm start for SCS, particularly in the context of larger-sized instances.  \n\n## Weaknesses\n- **[W1]**: Minimal ablation of the approach.  One of the major weaknesses is the lack of comparisons between DR-GD and DR-GD Net.  The authors claim that the motivation for DR-GD Net is that it is designed to find high-quality solutions using $L$ layers, rather than relying on the DR-GD algorithm.  However, these comparisons are never made.  Specifically, comparing the quality of the solutions for DR-GD with $L$ iterations and DR-GD Net with $L$ layers would strengthen the motivation and this claim.  Assuming DR-GD Net computes a better solution with $L$ layers, it would be helpful to assess how many iterations DR-GD takes to find a solution of similar quality.  Additionally, comparing DR-GD Net with fewer and more than $4$ layers would be a valuable ablation.  Specifically, this would provide insight into the trade-offs between network size and whether increasing the number of layers or parameters can yield better quality solutions.  \n    \n- **[W2]**: No comparisons of raw solutions between methods.  While evaluating solutions produced by learn-to-optimize (L2O) methods is useful, it would be helpful to include results related to the raw solution quality of all methods compared to the solutions from solvers.  \n\n- **[W3]**: Limited benchmarks.  While the authors do compare against several baselines, there are some limitations in the benchmarks.  The first is concerning the benchmark size.  For instance, QPLIB contains much larger instances than those used for evaluation.  Given the author's claim of advantages in larger-scale instances, and QPLIB has instances that are 10 to 100 times larger, it would be helpful to evaluate on these instances.  There may even be other larger-scale QP benchmarks that would be a good testing point. In addition, exploring performance for larger deviations, e.g., beyond $U[0.9, 1.1]$, and perhaps even generalization of (reasonable) perturbations not seen during training would be informative.  \n\n - **[W4]**: No discussion of offline time for model.  In any L2O pipeline, it is essential to have an understanding of how long data collection and training take, especially when exact solutions are used as labels.  These should be reported in the appendix at least to help readers understand the trade-offs.  \n\n- **[W5]**: Some related work on learnable variants of DR splitting/unrolling is not discussed [1,2,3].  I have not gone over these in detail, but if relevant, the authors should include a discussion on these.  \n\n## References\n- [1] Raied Aljadaany, Dipan K Pal, and Marios Savvides. Douglas-rachford networks: Learning both the\nimage prior and data fidelity terms for blind image deconvolution. In Proceedings of the IEEE/CVF\nConference on Computer Vision and Pattern Recognition, pages 10235–10244, 2019.\n- [2] Jiulong Liu, Nanguang Chen, and Hui Ji. Learnable douglas-rachford iteration and its applications in\ndot imaging. Inverse Problems & Imaging, 14(4), 2020.\n- [3] Yueming Su, Qiusheng Lian, Dan Zhang, and Baoshun Shi. Transformer based douglas-rachford\nunrolling network for compressed sensing. Signal Processing: Image Communication, 127:117153,\n2024", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "Yes", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "paper_topic_and_main_contributions": "", "excitement": null, "reproducibility": null, "ethical_concerns": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "summary_of_contributions": "This paper proposes a neural network architecture based on an unrolled Douglas-Rachford (DR) splitting algorithm.  Specifically, the proposed architecture augments an inexact DR algorithm with learnable matrix-vector multiplications and nonlinearities.   The learned network (DR-GD Net) is evaluated as a warm start for SCS, a first-order solver for convex quadratic programs (QP).  Computationally, the authors demonstrate the efficacy of their approach over several existing learning-based methods.  In addition, the warm starts from the algorithm yield favorable computational results when compared to using solvers without warm starts.", "claims_and_evidence_yn": "Yes", "claims_explanation": "", "audience_yn": "Yes", "audience_explanation": "", "requested_changes": "W1, W2, W4, and W5 need to be addressed.  For W3, I would appreciate it if the authors could extend their numerical results to include some of the suggested changes, in particular experiments focusing on larger instances.  Figure 1 could also be improved to be more readable and include a description.  Constantly referring back to the Figure and Algorithm 2/3 was tedious.    In addition, in the bottom left of Figure 1, I believe it should be $\\tilde{\\mathbf{u}}^{\\ell}$ as input to match Algorithm 2/3.", "broader_impact_concerns": "n/a", "additional_comments": "", "extra_scores": {}, "extra_text": {}}, {"review_id": "wyG287NcY8", "reviewer": "Reviewer_UMYn", "summary": "", "questions": "", "limitations": "", "rating": null, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "Several strengths:\n\n- Theory: Replacing the linear solve in DR with a single GD step is an elegant idea that enables loop‑free unrolling. Also, authors provides formal convergence proofs and demonstrates recovery of the optimal KKT point.\n\n- Empirical Performance: Warm‑starting SCS with DR‑GD Net cuts iterations by up to 50 % and wall‑clock time by 40 %.\n  \n- Anonymous code release and complete solver hyper‑parameter listings facilitate replication.\n\nSeveral weaknesses:\n\n- Slower per‑iteration convergence of DR‑GD:  Replacing exact solves increases iterations by 18–50 % before learning. This can be viewed as a \"preconditioned\" PDHG? It is unclear whether DR splitting method stills has significant advantages over PDHG.  \n\n- Marginal gains on small problems: On Portfolio‑100, the solve‑time reduction is only about 8 %.", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "Yes", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "paper_topic_and_main_contributions": "", "excitement": null, "reproducibility": null, "ethical_concerns": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "summary_of_contributions": "The paper introduces DR‑GD Net, an unrolled neural‑network version of the Douglas–Rachford (DR) splitting method where each linear solve is replaced by a single gradient‑descent (GD) step.  This makes every DR iteration lightweight enough to serve as a network layer. The authors prove global convergence for the inexact DR‑GD algorithm, turn the unrolled iterations into a trainable architecture, and show that using the network to warm‑start the SCS solver yields sizeable speed‑ups on synthetic and real‑world quadratic‑programming (QP) benchmarks.", "claims_and_evidence_yn": "Yes", "claims_explanation": "", "audience_yn": "Yes", "audience_explanation": "", "requested_changes": "Add (at least one) stronger and more varied baselines to clarify where DR‑GD Net excels.", "broader_impact_concerns": "No.", "additional_comments": "", "extra_scores": {}, "extra_text": {}}]

Author rebuttal:

Decision: Accept (poster)