- Rating
- 3(+1)
- Confidence
- 1(−1)
- Informativeness
- 2
- Presentation
- 2
- Soundness
- 2
Read review
Paper summary
This paper proposes a method to reduce repeated solves in PDE-constrained optimization. The authors use a reference PDE solution to construct feasible designs and states, and perform multiple optimization updates within a restricted design space without re-solving the PDE. When the restricted optimization can no longer make descent progress, the algorithm updates the reference solution through gradient diagnostics and RBF corrections.
Critical strengths
- The authors leverage the analytical structure of the PDE to reuse reference solutions, thereby reducing repeated solves. This idea has a clear theoretical basis.
- The experiments demonstrate the potential to reduce solver calls
Critical weaknesses
The main objective of this paper is to reduce computational costs by amortizing PDE solves. However, Section 4.2 only compares the number of solver calls between Ours + FVM and Baseline + FVM without reporting the total wall-clock runtime, making it difficult to assess the practical utility of the proposed algorithm. The authors should either demonstrate an end-to-end speedup of Ours + FVM over Baseline + FVM under certain settings, or show an end-to-end speedup of Ours + PINN over Baseline + PINN in settings where PINNs inherently offer advantages over conventional FVM solvers.
Questions for authors
- Appendix C.2 specifies that candidate PINN retraining uses at most 1,200 Adam steps, yet Appendix C.4 states that 11 of the 17 candidate retrainings in the baseline reached a 200-step cap without passing the held-out state-accuracy gate. What is the rationale behind this 200-step cap? If the training budget for the baseline were increased, would it reduce the rejection rate and lead to better optimization outcomes?
- Can the authors prove that a non-zero accessible component necessarily corresponds to a descent direction within the current design family? For example, consider the simplex constraint , the current iterate , a feasible design family (with ), and the objective . The objective is identically zero across the entire design family (meaning no descent direction exists within the family). However, with and , Eq. (22) still yields a non-zero accessible component ().
- Could the authors provide the computational complexity of the non-PDE components, such as solving the QP subproblem in Eq. (23) and the RBF construction? This would help substantiate the scalability of the proposed framework.
4 comments
Addressing Question 1: Correction of the mismatched retraining-step budget and controlled comparison
We thank the reviewer for identifying this inconsistency. The 200-step cap was an implementation-specific budget used in the original every-update baseline, whereas the proposed refresh retraining followed the 1,200-step maximum described in Appendix C.2. We agree that this mismatch made the original timing, rejection-rate, and design-quality comparison difficult to interpret. We therefore no longer use the original comparison as evidence of computational superiority. We reran both methods under the same adaptive retraining protocol. Every candidate is evaluated every 20 Adam steps, may terminate early only after passing the same held-out state-accuracy gates, and otherwise receives a common maximum of 1,200 steps. There is no failure-based early rejection before this common limit.
Table 2. Effect of the common 1,200-step adaptive retraining protocol.
| Method | Trials/passed | State solves | Time (s) | FVM-audited |
|---|---|---|---|---|
| Every-update, original 200-step cap | ||||
| Every-update, common 1,200-step cap | ||||
| Proposed, common 1,200-step cap | refresh |
Increasing the baseline budget substantially reduces its rejection rate: 10 of 15 candidates pass, compared with 6 of 17 under the original cap. It also improves the independently audited FVM objective from to , but the improvement is only , while runtime increases from s to s. Thus, the reviewer’s concern is valid: part of the original rejection rate was caused by the restrictive 200-step budget. However, correcting this mismatch does not change the principal conclusion. Under the common 1,200-step protocol, the proposed method still achieves a lower independently audited objective while using less algorithm time than the retrained every-update baseline. We will revise Appendices C.2 and C.4 to state one consistent training protocol and replace the original comparison with these results.
Addressing Question 2: Clarification of the gradient-accessibility diagnostic and descent condition
We thank the reviewer for this counterexample. We agree that does not necessarily guarantee an in-family descent direction. Indeed, in the given example,
,
so the objective is constant along the family. We will revise the text surrounding Eq. (22) to remove the claim that a non-zero accessible component guarantees descent and instead define and as diagnostic measures of gradient accessibility and mismatch. The correct first-order condition is , where with the constraints and . Here , and denotes the feasible parameter-direction set. Thus, Eq. (22) is a diagnostic and is not equivalent to this descent condition. This clarification does not change the algorithm or experiments: actual descent is determined from evaluated feasible updates, while Eq. (22) is used only to trigger a refresh attempt, which remains subject to the feasibility and acceptance checks.
Addressing Question 3: Complexity and timing of the RBF-QP refresh step
We thank the reviewer for requesting this clarification. Let be the number of active design cells and the number of multiscale RBF weights. Constructing requires time and storage in the current dense implementation. Forming requires time and additional storage. The subsequent QP has variables, one volume equality, and cellwise bounds. Its exact solution cost is solver- and active-set-dependent; the dense linear algebra is governed by , while evaluating the linear constraints scales as per iteration. Because , the QP is not solved in the full -dimensional design space. The compact support of the Wendland basis also permits a sparse implementation for larger meshes.
Table 3: Observed non-PDE refresh overhead in the reported eight-terminal PINN experiment.
| Case | Active cells | Centers | Weights | RBF+QP (s) | Total (s) |
|---|---|---|---|---|---|
| Eight-terminal PINN | 3784 | 28 | 84 | 26.37 | 251.12 |
The three support radii produce weights. The measured RBF-construction and QP stage accounts for 10.50% of the complete algorithm time; the state-retaining stage remains the dominant cost. The current logs record RBF construction and QP solution jointly, so we report their combined measured time rather than introducing an unsupported split. We will add the complexity statement, implementation detail, and timing table to the revised appendix.
Demonstration of end-to-end wall-clock speedup under a shared adaptive PINN retraining protocol
We thank the reviewer for emphasizing that a reduction in state-solver calls does not by itself establish a practical wall-clock advantage. We address the reviewer’s second suggested comparison by evaluating the proposed and every-update methods with the same PINN-based state solver under a common adaptive retraining protocol. Both methods use the same initial design, pretrained reference network, maximum of 1,200 Adam steps per candidate retraining, held-out state-accuracy gates, hardware, and independent FVM evaluation. The reported algorithm time includes all optimization costs: cheap-phase updates, full-space diagnostics, QP solution, RBF construction, analytical distillation, state-network retraining, data transfer, and bookkeeping. Post-hoc FVM audits are excluded from both timings because they do not affect either optimization trajectory.
Table 1. End-to-end PINN comparison under the common adaptive retraining protocol.
Under this common protocol, the proposed method achieves a 30.75 lower independently audited objective while reducing algorithm wall-clock time by 85.09. The independently FVM-audited quality-versus-time curve further shows that the every-update baseline does not reach the proposed method’s audited design quality anywhere along its observed trajectory; hence, no equal-quality baseline time exists within the recorded run. The shared reference-network pretraining requires 185.55 s and is excluded from both algorithm times because the same pretrained reference is used by both methods. Even when this shared cost is included, the corresponding end-to-end totals are 436.7 s for the proposed method and 1869.4 s for the every-update baseline, so the conclusion is unchanged. We will add the timing protocol, complete cost accounting, comparison table, and independently audited quality-versus-time curve to the revised manuscript.