- Rating
- 2
- Confidence
- 2
- Informativeness
- 2
- Presentation
- 3
- Soundness
- 2
Read review
Paper summary
This paper proposes PIDSolver, a learning-based framework for optimization with algebraic constraints, evaluated on AC optimal power flow (AC-OPF). It couples a conditional diffusion network that generates control variables with a learned power-flow surrogate that predicts the remaining physical states. Constraint residuals computed from these outputs provide end-to-end training signals, while accelerated sampling trades inference time against solution quality. The paper also presents conditional error and feasibility analyses. Experiments on the IEEE 118-bus system report lower constraint violations at comparable generation costs relative to the evaluated learning-based baselines, with additional ablation, random-seed, and load-shift experiments.
Critical strengths
-
The two-network design is interesting and well motivated. Separating control generation from the prediction of the remaining physical states provides a coherent way to incorporate constraint feedback into diffusion training. This directly targets the computational burden of repeatedly solving power-flow equations within training and gives the framework a clear practical motivation.
-
The reported results provide encouraging empirical evidence within the tested setting. PIDSolver reduces reactive-power violations while maintaining generation costs comparable to the diffusion baselines. The fine-tuning ablation and repeated runs across five seeds further support the usefulness and repeatability of the reported improvement on the IEEE 118-bus system.
Critical weaknesses
-
The baseline protocols are insufficiently detailed to establish whether the comparisons evaluate complete methods under comparable conditions. In particular, it is unclear which correction, projection, or post-processing stages are retained for M1, M4, and M5, and whether their associated computation is consistently accounted for. The implementation of M2's training accelerations also needs clarification. These details could materially change the interpretation of both the constraint-violation and training-time improvements.
-
The evaluation does not yet clearly establish the practical trade-off between speed and independently verified feasibility. Table 2 reports GPU batch times for 1,000 samples, while a corresponding comparison with conventional OPF solving under matched feasibility tolerances is missing. Furthermore, low average violations and power-flow convergence do not by themselves establish the proportion of operationally feasible outputs. Without a clearly specified independent validation procedure and comparable timing, the practical significance of the reported gains remains uncertain.
Questions for authors
-
For M1, M4, and M5, which correction, projection, and post-processing stages were included in the comparisons, and do the reported runtimes cover those stages? Please also clarify the baseline training configurations, including whether M2 uses the acceleration mechanisms proposed in its original work.
-
Which numerical solver and feasibility tolerances were used for the conventional OPF reference? Under the same final feasibility criteria, how does PIDSolver compare with conventional solving in single-instance latency and total solution time, including any feasibility recovery? Please distinguish these timings from the 1,000-sample batch throughput reported in Table 2.
-
Are the reported test violations evaluated using the surrogate-predicted physical states or an independent numerical power-flow calculation? Under explicitly stated equality and inequality tolerances, what fraction of test instances is feasible, and what are the maximum or high-percentile violations? This would help determine whether the lower mean violations translate into reliable feasible solutions.
14 comments
(B) Regarding the inference-time accounting conventions: To make the conventions checkable, we explicitly state the computation included in the timing of each row:
| Method | 24-bus (s/1k) | 118-bus (s/1k) | 300-bus (s/1k) | Computation included in the row |
|---|---|---|---|---|
| M1 (DeepOPF-V) | <0.01 | <0.01 | <0.01 | DNN forward + power-balance-reconstruction correction |
| M2 (PINN) | 0.05 | 0.07 | --- (did not converge) | DNN forward |
| M3 (DC3 completion stage) | <0.01 | <0.01 | <0.01 | DNN forward only (correction diverges within 2–3 steps) |
| M4 (DDPM) | 1.49 | 1.52 | 1.52 | 1000-step DDPM denoising |
| M5 (constrained DDIM) | 1.52 | 3.70 | 9.25 | 30-step DDIM denoising + per-step constraint correction (differentiable Newton completion) |
| PIDSolver | 1.51 | 1.55 | 1.54 | 1000-step DDIM denoising |
| PyPower OPF (reference) | 163.9 | 346.0 | 907.6 | per-instance AC-OPF solve |
(C) Regarding M2's training acceleration: We reproduced the "batched GPU solve" version recommended in the original paper (the completion Newton system is vectorized across the batch, performing one linear solve per sweep), and updated the training-time statistics accordingly. To align with the naive "per-sample Newton + implicit-function-theorem gradient" implementation in DC3, we also measured the per-sample serial Newton method: under the same 3000 training epochs, the 118-bus system is estimated to take about 88 hours. We should also state honestly: in our reproduction, M2 did not converge on the 300-bus system (reflecting a scale limitation of the method and the original paper did not test the 300-bus system). The updated offline training-time comparison on a single RTX 5090 GPU is summarized below (as shown in Table 3):
| Method | 24-bus | 118-bus | 300-bus |
|---|---|---|---|
| M1 (DeepOPF-V) | $\le$5 min | $\le$5 min | $\le$5 min |
| M2 (PINN) | $\le$1 h | $\le$1 h | --- |
| M3 (DC3) | - | - | - |
| M4 (DDPM) | $\le$1 h | $\le$1 h | $\le$1 h |
| M5 (constrained DDIM) | $\le$1 h | $\le$1 h | $\le$1 h |
| PIDSolver | $\le$1 h | $\le$1 h | $\le$1 h |
PIDSolver training cost is also comparable with the batched-GPU version of the PINN-based solver M2, whereas the serial per-sample Newton protocol of M2 extrapolates to $\approx$88,h on 118-bus system. M3 is reported as ``-'' because its correction phase diverges within 2--3 epochs on all three systems and its training never completes. Its projected full-budget cost is $\approx$86,h on 118-bus system, confirming that the per-sample solver-plus-inversion channel is unaffordable at diffusion-training scale.
Weakness 2: Regarding the speed–feasibility trade-off, Table 2’s batch GPU times lack a matched comparison with conventional OPF solving under comparable tolerances.
Response. We thank the reviewer for this insightful comment. We have now added a matched comparison with conventional OPF solvers and per-sample feasibility statistics, all measured under the same feasibility conventions, as explained below.
(A) Regarding the comparison with conventional OPF solvers under matched conventions:
We report the latency of solving a single AC-OPF instance with Ipopt (within the PowerModels framework, with no solver options modified, i.e., the Ipopt 3.x default convergence tolerances: tol , acceptable_tol ). On the same machine (PIDSolver on an RTX 5090 GPU, Ipopt on its CPU), the inference times are listed item by item below:
| System | Ipopt single instance (ms, median) | PIDSolver single instance (s, denoising n=1, measured) | PIDSolver 1000-sample batch (s, denoising) | Ipopt 1000 samples total |
|---|---|---|---|---|
| 24 | 41.5 | 1.51 | 40 | |
| 118 | 166.5 | 1.55 | 170 | |
| 300 | 487.1 | 1.54 | 500 |
We would also like to explain to the reviewer the significance of this comparison in practice: real power dispatch requires repeatedly solving AC-OPF over a vast number of load scenarios (in day-ahead and real-time dispatch the number of scenarios runs into the hundreds of thousands, and the cumulative solve time is enormous). The value of PIDSolver lies precisely in amortizing the optimization into training, delivering dispatch solutions close to AC-OPF quality with second-scale batched inference. Therefore, comparing only single-instance solve times underestimates the practical significance of this batched, amortized solving. We present the numbers of both sides honestly, side by side, for the reviewer to judge this trade-off.
(B) Regarding whether low average violations imply feasible outputs: Low average violations alone do not guarantee per-sample feasibility, so we introduce per-sample feasibility statistics over the 1000 test samples. A sample is counted as feasible if, after an independent PyPower solve, none of the four violation classes exceeds the threshold . Samples for which the AC-PF solve fails are counted as infeasible, and the denominator is always the full set of 1000 samples. How is the threshold chosen? In engineering practice, dispatchers often resort to direct current optimal power flow (DC-OPF), the linearized simplification of the AC model, to trade accuracy for speed. Although AC-OPF has an optimal solution, solving each instance from scratch is too slow for real-time dispatch. One therefore has to resort to a DC-OPF surrogate, even though the resulting solutions are inexact. We therefore set by taking the violation results of the DC-OPF solution as the reference and shrinking their magnitude by , which gives for the three test cases.
| Method | 24: | 118: | 300: |
|---|---|---|---|
| M1 (DeepOPF-V) | 41.7% | 7.2% | 47.2% |
| M2 (PINN) | 64.1% | 0.0% | --- (did not converge) |
| M3 (DC3 completion stage) | 3.5% | 9.3% | 18.0% |
| M4 (DDPM) | 74.9% | 13.9% | 58.3% |
| M5 (constrained DDIM) | 62.7% | 10.0% | 50.2% |
| PIDSolver | 100.0% | 100.0% | 99.4% |
Under their respective discriminating thresholds, PIDSolver achieves per-sample feasibility fractions of 100% on the 24/118-bus systems and 99.4% on the 300-bus system, while the strongest baseline only reaches 74.9%/13.9%/61.9% (M4 on 24/118, M3 on 300) — the lower average violations likewise translate into an overwhelming feasibility advantage at the per-sample level. The detailed results and anlysis can be found in Appendix G.6.
(C) Regarding the independent verification procedure: This revised manuscript now states clearly that all reported metrics are derived from independent PyPower AC-PF computations, independent of the surrogate model.
We would like to express our sincere gratitude to the reviewer for the thorough and insightful comments, as well as for the kind recognition of our work, which are very encouraging to us. We have carefully addressed each of the concerns raised, as detailed below. In particular, the comments prompted us to fully disclose and re-measure the baseline protocols: we re-implemented M1–M5 following the original settings of each paper, stated the retained stages and the timing accounting item by item, and added matched comparisons with conventional solvers together with per-sample feasibility and tail statistics. We sincerely hope that these clarifications and revisions fully resolve the points raised, and we would be most grateful for any further comments.
Weakness 1: Regarding the baselines, the stages and runtime accounting for M1, M4, and M5 and M2’s training accelerations are insufficiently detailed.
Response. We thank the reviewer for raising this point. In response, we have carefully re-verified the reproduction of each baseline against the original settings of its paper, with all deviations explicitly noted below, and measured all methods under a single, consistent evaluation pipeline (independent PyPower verification, no clipping post-processing for any baseline or for PIDSolver).
(A) Regarding which stages are retained for M1, M4, and M5: Below, we describe the stages each method retains or omits and the implementation details (the full performance comparison and the implementation details of every method are reported in Table 1 and Appendix F). Unless otherwise noted, we adopted the hyperparameters and training protocols reported in each baseline's original paper.
M1 = a supervised deep neural network predicting (V,θ), with the original method's power balance reconstruction correction step retained. Its output is used directly at evaluation time.
M2 = reproduced according to the original protocol: under the original semi-supervised protocol with all hyperparameter settings as reported in the original work. In order to compare fairly, the DNN outputs with linear activations. A differentiable Newton completion recovers remaining variables. The loss combines the supervised MSE with the weighted cost and constraint-violation terms of the original protocol.
M3 = reproduced according to the original paper, but not fully in its original unsupervised training form: if trained completely according to the original unsupervised protocol, it diverges within 2–3 epochs on all three systems, so we first performed supervised pre-training and then applied the original DC3 protocol for unsupervised training (completion stage: supervised training + per-sample numerical power-flow completion; correction stage: one Newton solve + one Jacobian inversion per sample, with gradients injected via the implicit function theorem). Even so, the correction stage still diverged within 2–3 epochs on all three systems, and applying the correction at test time to the solutions produced by M3 also diverges within 2–3 correction steps. The M3 rows in the Table 1 therefore retain the completion stage only, and their time counts only the completion computation.
M4 = the vanilla DDPM: performs stochastic reverse sampling, with no clipping and no correction of any form.
M5 = the fast constrained DDIM implemented according to "Algorithm 1" of the original paper: 30-step DDIM, η=0.2, applying constraint correction x0∣t←x0∣t−λt∇(RH+RG) to the clean estimate at each step (implemented via differentiable Newton completion; λt=λ0(1−αˉt), λ0=0.01. The original paper does not specify σt, so we adopt the standard DDIM convention).
PIDSolver = pre-training (denoiser Θ1 + surrogate network Θ2, with the surrogate trained on the bi-objective MSE$+\eta|h|^2$) + fine-tuning (Eq. (28), λh=λg=0.1, λc=0.0001); inference is deterministic T-step DDIM, with no clipping/correction post-processing. The final dependent variables z are obtained from an independent PyPower AC-PF solve, and the surrogate network exists only in the training stage. The detailed Algorithm can be found in Appendix E.