- Rating
- 2
- Confidence
- 3
- Informativeness
- 2
- Presentation
- 3
- Soundness
- 2
Read review
Paper summary
The manuscript closed-loop preconditioning for anisotropic diffusion via reinforcement learning proposes CLP, a reinforcement-learning-based preconditioning framework for Symmetric Positive Definite (SPD) linear system of equations. The preconditioner is designed to maintain SPD and could update to adapt solver status. Experiments show that a trained policy can be generalized to longer solves and larger systems.
Critical strengths
- The paper is well organized, and the presentation is clear.
- The motivation behind the manuscript is reasonable and the algorithm design is convincing.
- The experiment design is well aligned with the claims.
Critical weaknesses
-
The scope of the paper is too narrow, and thus I think the potential of this algorithm is somewhat limited. The paper only discusses the strategy for linear SPD systems with single right-hand side using Richardson iteration. It is unclear how this strategy could be extended to practical applications for serval reasons.
- Cost may be too high. For large distributed machines, k extra MatVecs per update plus message passing would require significant communication, and may not be considered as “computationally tractable”.
- Training is hard. Practical solvers are much more complicated than Richardson iteration. I am convinced that this strategy works for Richardson iteration, but I am not convinced that this method would work for many realistic solvers with much more parameters and considerations.
- It is unclear how this method could be generalized to multiple right-hand sides cases (block solves).
-
The update policy is somewhat local. I understand that U is trying to capture some global information, but I am not convinced that local message passing could provide good global basis vectors to capture smooth components in the error, which may also be the limitation of many GCN-based preconditioners.
-
The baselines are not convincing. ILU factorizations in scipy like ILUT (based on supernodes) is different from standard textbook implementations. Also, pyAMG is not the best baseline. Those options are convenient but unfair as baselines, especially when you are also report timing.
-
Theorem support is limited.
Questions for authors
-
It is not too hard to compare with SOTA ILU and AMG with packages including hypre and PETSc. Adding those tests are easy for small problems considered in the paper and does not require a lot of CPU/GPU hours.
-
It would be great if the authors could add some discussion on the potential of this algorithm to real applications: large scale problems with practical solvers on distributed memory systems. Extra MatVecs and message passing could cause significant overhead. More discussion/experiments on the cost would be great.
-
How this method handles smooth components in the error? Could this policy be applied as a low-rank correction in addition to standard AMG? How this method work within CG/GMRES and/or with multiple right-hand sides (block solve)?
3 comments
W1/W2/Q3: Solvers beyond Richardson (CG), smooth error components, and combining the low-rank correction with AMG
Compatibility with accelerated solvers. To evaluate CLP beyond first-order Richardson, we retrained the policy separately within second-order Richardson and flexible CG, retaining the original architecture, preconditioner parametrization, and observations. The policy does not observe momentum, search directions, or Krylov-subspace information. On magnetized diffusion (), median iterations to a relative residual of were:
| Solver (with CLP) | Median iterations to (↓) |
|---|---|
| First-order Richardson | 754 |
| Second-order Richardson | 697 |
| Flexible CG | 520 |
Both accelerated configurations improve convergence relative to CLP with first-order Richardson. These preliminary results show that the CLP architecture can be trained within accelerated solvers without incorporating their additional dynamical information into the policy. Explicitly conditioning preconditioner updates on momentum and Krylov-subspace information remains a promising direction for further development.
Local message passing and smooth error components. Although the GNN aggregates information locally, its outputs define a globally supported low-rank basis, with correction directions coupled through the Galerkin weighting. Thus, the learned preconditioner can produce global corrections despite the local receptive field of the graph network. Moreover, residual feedback provides information about the evolving error, allowing the policy to adapt its correction as the solve progresses.
To examine whether CLP effectively reduces error components that are difficult for local relaxation methods, we decomposed the error into eigenvalue bands over 200 magnetized-diffusion instances (). Figure 8 in Appendix B.5 shows that CLP substantially attenuates error in the 10% of eigenmodes associated with the smallest eigenvalues, outperforming AMG-preconditioned Richardson in this band. It also reduces error effectively across the middle and largest-eigenvalue bands. These results show that CLP's advantage is not restricted to high-eigenvalue error components, supporting the effectiveness of its globally supported low-rank correction despite local message passing.
Integrating the low-rank correction with AMG. The CLP parametrization can also accommodate an existing SPD preconditioner. Replacing the diagonal component in Equation 4 with an SPD AMG preconditioner gives
which remains SPD because the learned low-rank correction is positive semidefinite. AMG could provide a classical coarse-space correction, while CLP adapts to the remaining error components. We consider it a promising direction for future work.
The question on multiple right-hand sides is addressed in our response to Q2 above.
W4: Theoretical support for the CLP construction
Thank you for raising the question of theoretical support. We agree that it is important to distinguish the structural properties guaranteed by the CLP construction from convergence properties established empirically. The manuscript establishes several mathematical properties that hold independently of the learned policy parameters:
- Positive definiteness and descent (Section 4.1). at every iteration because its diagonal component is strictly positive and its regularized low-rank correction is positive semidefinite. Consequently, is a descent direction for the quadratic energy whenever .
- Galerkin optimality and basis invariance (Section 4.1, Equation 6). When is nonsingular, the unregularized Galerkin correction minimizes the quadratic energy over corrections in . It depends only on this subspace rather than on the particular basis.
- Symmetries of the linear system (Section 4.3, Appendix B.6). The policy is permutation equivariant, ensuring that consistently relabelling the unknowns produces correspondingly relabelled preconditioner updates. The canonicalized observations are also invariant, up to numerical stabilization, under positive diagonal changes of variables , , for any positive diagonal .
- Consistency of training and deployment (Sections 4.2 and 4.4). The logarithmic residual-reduction rewards telescope over the training episode, with the implemented numerical offset retained in the identity. During deployment, each defect-correction cycle satisfies (Equation 10), so the correction residual corresponds to the residual of the original linear system.
These properties provide structural guarantees for the learned preconditioner and establish the consistency of the training and deployment formulations.
I really thank the authors for the response and for adding many new experiments and significantly modified the manuscript. However, I would still keep my score of 2 for the following reason:
- The authors add more timing comparisons, for example, a limited distributed system with GPUs. However, the communication bottleneck is inherent to the algorithm. The speedup is only 1.5x with two GPUs, and as communication becomes dominant, the scalability potential of this algorithm is very limited.
- In addition, the advantage over baselines does not generalize to more advanced solvers (mostly limited to Richardson).
- B.5 is tested on a 16x16 grid, and thus message passing could already reach about 10% of the nodes. The concern is still for larger problems, where message passing becomes more and more local relative to the problem size.
- Several of my comments including the multiple-RHS question were not fully addressed.
And lastly, this is a general comment, not a limitation of this paper. Graph Neural Preconditioners and several follow-up works indeed use SciPy ILU, and in fact those papers motivated me to run some very simple tests comparing different ILU options. I am not saying that the ILU in SciPy is wrong. Just that even for simple SPD matrices, the ILUT in SciPy can produce substantially different sparsity patterns in L and U compared with other commonly used ILU implementations. Therefore, results based on a single ILU implementation should be interpreted with some care.
Thank you for the detailed feedback. We address the concerns below with additional experiments and clarifications.
W3 / Q1: Added hypre BoomerAMG and PETSc ILU baselines
Thank you for suggesting comparisons with additional numerical libraries. Our original SciPy ILU and PyAMG baselines follow implementations used in prior learned-preconditioner evaluations, including Graph Neural Preconditioners (ICLR 2025). To strengthen the evaluation and assess whether CLP's convergence advantage persists against alternative classical preconditioners, we additionally evaluated PETSc ILU and hypre BoomerAMG on the main anisotropic-diffusion problem (n=256).
All methods use first-order Richardson iteration with separately tuned step sizes, isolating the effect of the preconditioning strategy. Hypre BoomerAMG uses Falgout coarsening and classical interpolation, while PETSc ILU is evaluated across fill levels k∈0,1,2,3,4, with k=1 selected for the reported comparison. Additional implementation details are provided in Appendix B.1. Median iterations to a relative residual of 10−8 are:
The additional library implementations improve convergence relative to the original ILU and AMG baselines. Nevertheless, CLP retains the lowest iteration count, requiring 1.8× fewer iterations than hypre BoomerAMG and 3.4× fewer than PETSc ILU. These results strengthen the evidence that CLP's convergence advantage within first-order Richardson iteration persists against stronger classical preconditioners.
We have incorporated these comparisons and their implementation details into Appendix B.1 of the revised manuscript.
W1/Q2: Cost analysis, multi-GPU execution, and multiple right-hand sides
Thank you for highlighting the computational and communication costs associated with large-scale deployment. For sparse PDE operators with bounded sparsity, CLP has linear per-iteration work and storage complexity in the number of unknowns at fixed network size and correction rank. Its main additional costs are GNN inference and Galerkin updates, which require k=4 sparse matrix-vector products per iteration. Distributed execution involves communication between neighboring partitions and global reductions for the low-rank correction. Although these operations do not require dense global matrices, their communication and synchronization costs remain important considerations for scaling.
To investigate these costs, we implemented a distributed-memory version of CLP that partitions each linear system across two NVIDIA RTX A6000 GPUs. Measured execution times for 100 iterations, including computation and inter-GPU communication, were:
The two-GPU implementation is slower at the smallest resolution, consistent with communication and coordination overhead, but achieves approximately 1.5× speedup on the larger systems. We additionally evaluated convergence to a relative residual tolerance of 10−8, obtaining median end-to-end solve times of 3.98 s at n=2562 and 23.36 s at n=5122 on two GPUs. For reference, the tested CPU-based AMG-preconditioned Richardson implementation required 20.72 s and 98.08 s, respectively. These timings demonstrate the performance of the tested implementations on their respective hardware configurations, rather than a hardware-matched comparison.
You also asked about multiple right-hand sides (W1 and Q3). Using the same trained policy without retraining, independent solves can be batched on a single GPU. For 200 right-hand sides on a specific magnetized diffusion problem (n=256), the average time per right-hand side to reach a relative residual tolerance of 10−6 was:
Batched execution achieves an 18.6× improvement in throughput by exploiting GPU parallelism across independent solves. This experiment demonstrates efficient multiple-right-hand-side execution, although it does not implement a coupled block Krylov method or shared block correction space.
Together, these experiments establish the feasibility of partitioned CLP execution across two GPUs and demonstrate substantial throughput gains from batching independent solves. Scaling to larger distributed-memory systems and developing block-solver extensions remain open directions. We have incorporated these experiments and implementation details into Appendix B.8 of the revised manuscript.