The adaptive sampling algorithm for reduced-order models can be repurposed to adaptively select training examples for amortized optimization surrogates, focusing labels on high-uncertainty parameter regions.

This discovery has a Claude-generated validation package with a full experimental design.

Precise Hypothesis

Spine & Adversarial Read

• highThe claimed 3-5x label efficiency gain is a generic active-learning result already well-established (uncertainty sampling, query-by-committee, BALD, etc.) — framing it as 'repurposing a ROM algorithm' may overstate novelty versus decades of active learning / Bayesian experimental design literature applied to surrogate modeling.
  This EVP could not retrieve prior-art search results to confirm or bound this overlap (no live web search snippets were available). The protocol should explicitly benchmark against standard active-learning baselines (BALD, GP-UCB acquisition, max-variance GP) in addition to random sampling, so that any measured gain is attributed to the specific ROM-derived acquisition criterion rather than to active learning per se. This is currently an unresolved gap requiring a dedicated literature search before publication claims of novelty are finalized.
• highWhy these three specific benchmark tasks and this particular uncertainty proxy (ensemble variance) rather than alternatives (e.g., GP posterior variance, dropout, conformal prediction intervals, or the ROM's original residual-based error estimator applied directly)? An unjustified methodology choice risks the result being an artifact of ensemble-NN quirks rather than a genuine demonstration of the ROM-sampling principle.
  Partial resolution: the protocol includes an explicit ablation (Step 9a) comparing acquisition functions (variance vs. residual-proxy vs. random) and could be extended to include GP-posterior-variance as a fourth arm. The three benchmark tasks were chosen to span the impact statement's named domains (physics/engineering, finance) and to include one task structurally close to the ROM's native PDE setting as a positive control. However, benchmark selection is still somewhat arbitrary (e.g., airfoil shape optimization vs. topology optimization is not uniquely motivated) and should be justified further by citing which benchmarks are standard/reproducible in the active-learning-for-surrogates literature — this justification is currently incomplete.
• mediumThe oracle-cost-dominates assumption (labels 10-100x more expensive than surrogate inference) may not hold for the finance benchmark (a QP solve via CVXPY can take milliseconds), making the finance task a weak/inflated demonstration of practical value even if the algorithm 'works' numerically.
  The boundary conditions section already flags this requirement explicitly. Mitigation: for the finance task, either (a) artificially inflate oracle cost to represent realistic institutional-scale portfolio optimization (large covariance matrices, robust optimization with inner min-max loops) so the cost ratio is representative, or (b) reframe the finance result as a controlled numerical validation of label-efficiency only, not a cost/ROI claim, and reserve ROI claims for the physics/engineering tasks where the cost asymmetry is empirically realistic.

Experimental Protocol

ROI Projection

Implementation Sketch

# Pseudocode: Adaptive Label Selection for Amortized Optimization Surrogates

initialize oracle_solver(task)                     # SU2 / CVXPY / IPOPT
pool = sobol_sample(param_space, n=100_000)         # unlabeled candidate pool
labeled_set = random_sample(pool, k=seed_size=30)
labels = {p: oracle_solver(p) for p in labeled_set}

surrogate_ensemble = [MLP(dims) for _ in range(M=8)]

def train_ensemble(ensemble, labeled_set, labels):
    for net in ensemble:
        net.fit(labeled_set, labels, epochs=E, bootstrap=True)
    return ensemble

def acquisition_score(pool_point, ensemble):
    preds = [net.predict(pool_point) for net in ensemble]
    return variance(preds)          # or ROM-style residual-projection-error proxy

while len(labeled_set) < budget:
    surrogate_ensemble = train_ensemble(surrogate_ensemble, labeled_set, labels)
    scores = {p: acquisition_score(p, surrogate_ensemble) for p in pool - labeled_set}
    top_k = top_k_by_score(scores, k=batch_size=25)
    for p in top_k:
        labels[p] = oracle_solver(p)     # EXPENSIVE call
        labeled_set.add(p)

evaluate(surrogate_ensemble, held_out_test_set)
compare_to(random_baseline_curve)
report(label_efficiency_ratio, calibration_spearman, wallclock_overhead)