acceptodds
Under review as a conference paper at ICLR 2027

Conditional Set Decoder for Learning-Augmented Column-and-Constraint Generation

Abstract

Column-and-constraint generation (C&CG) solves two-stage robust optimization (2RO) problems with a nested min–max–min structure by decomposing the problem and iteratively generating worst-case scenarios through a max–min adversarial problem (AP). Learning-augmented C&CG replaces the AP with a neural network that identifies an adversarial scenario for the current first-stage decision. This prediction depends jointly on the first-stage decision and uncertainty realization. Because the two inputs have different roles and feature descriptions, existing methods encode and aggregate them separately before passing the resulting representations to the prediction network. However, separate aggregation makes their componentwise correspondence implicit, so the network must learn both adversarial-scenario identification and correspondence recovery, which increases the difficulty of the learning task. To address this issue, we propose the Conditional Set Decoder (CSD), which conditions each uncertainty-component representation on its corresponding first-stage decision component before aggregation. CSD preserves their componentwise correspondence before low-dimensional compression and avoids reconstructing it afterward. The architecture remains invariant to joint permutations of corresponding elements, supports value learning, and admits a mixed-integer linear representation. Our analysis shows that, for functions defined by interactions between corresponding elements, conditional aggregation requires a lower representation dimension than separate aggregation. Across three 2RO benchmarks—capital budgeting, robust assignment, and facility location with disruptions—CSD reduces the benchmark-specific median evaluation gap by 52.3%, 62.9%, and nearly 100%, respectively. In a controlled scenario-ranking experiment for facility location with disruptions, CSD recovers 91.1% of decision-conditioned ranking reversals, compared with 0.1% for separate aggregation.

Primary area:
optimization
Keywords:
two-stage robust optimization, learning-augmented optimization, column-and-constraint generation, set representation learning, neural surrogates

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_U3zZOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary
  1. This paper area is focusing on 2RO and try to enhance a existing learning method to CCG.
  2. This paper identify a structural limitation of existing methods (mainly Neur2RO) separate aggregation. and it proposes a method CSD to models aligned decision uncertainty before aggregation.
Critical strengths
  1. A plausible motivation for aligning feature pairs before aggregation.
Critical weaknesses
  1. The scope of applicability is unclear. It seems the method requires a meaningful componentwise correspondence between x and xi, but it is not clear how broadly this prerequisite holds across two-stage robust optimization problems.

  2. The presentation, experimental design, and analysis of results need further improvement to convincingly demonstrate that the proposed approach addresses the limitation identified in the motivation.

Questions for authors
  1. Runtime and solver settings in Table 1. Please explain why CSD’s runtime decreases for n=40n=40 and n=50n=50 compared with n=30n=30. In particular, n=30n=30 and n=40n=40 have the same median iteration count but substantially different runtimes. The values around 600 and 660 seconds also appear to reflect time limits; please clarify the difference and report the timeout handling, solver thread counts, and solver gap tolerances.

  2. Iteration reporting in Table 2. For n=25n=25 and K=8K=8, the reported iteration count is 38.5. Please clarify how this statistic is computed.

  3. Applicability to the Neur2RO knapsack benchmark. Have you evaluated the method on the two-stage robust knapsack problem used in Neur2RO? The purpose would be to assess the method’s scope of applicability, rather than simply add another benchmark. This comparison could help establish whether the benefits extend across different recourse structures or are concentrated in particular problem classes.

6 comments

Thank you for the review and suggestions.

W1. Applicability. CSD requires no one-to-one matching of raw xx and ξ\xi. In the standard 2RO formulation of Zeng and Zhao (2013, Section 2, Eq. (1)), recourse constraints are Gy≥h−Ex−MξGy\ge h-Ex-M\xi in our notation. A general construction pairs (Ejx,hj−Mjξ)(E_jx,h_j-M_j\xi) for each row jj, retaining row identities and recourse coefficients. Thus, correspondence follows from the model throughout this formulation, even with unequal dimensions or dense couplings; it is not an additional structural prerequisite. Variables can occur in multiple rows, and this construction does not require continuous recourse.

Our benchmark features follow the same principle at the project, item, or facility–customer level. In CB, nn project decisions share only four uncertainty factors. CSD learns Q(x,ξ)Q(x,\xi) within Neur2RO's C&CG interface. We have clarified feature-level correspondence in the abstract, introduction, Section 3, and Figure 3; Appendix G details DFLP's indices.

Connection between motivation and evidence. Theorem 1 characterizes the information a separate scenario representation must retain to predict values across decisions. In the constructed recourse families, Separate requires at least rr scenario dimensions, whereas CSD uses a scalar pooled state. We test the resulting scenario-selection behavior directly. On 297 held-out DFLP pairs, CSD recovers 91.1% of decision-conditioned ranking reversals versus 0.1% for Separate. Shuffling correspondence while preserving the data and model size raises CSD's median downstream gap from 0.00% to 82.32% and reduces median iterations from 9 to 2. These experiments connect correspondence to scenario ordering, premature termination, and decision quality.

The CB/RAP/DFLP comparisons use the same features, labels, splits, training budgets, and C&CG settings, with comparable parameter counts. Figure 2(b) increases both hidden widths and representation dimensions; Appendix C specifies the full configurations. Section 4 links the theoretical analysis to the scenario-recovery experiments.

Q1. CB runtime and solver settings. In Table 1, the 600 s medians are for CSD at n=20,30n=20,30, and the roughly 660 s medians are for Separate at n=30,40,50n=30,40,50. For this timing comparison, we profiled 10 randomly selected instances per seed (11,17,23), or 30 runs per architecture–size group.

CSD. At n=20,30n=20,30, median cumulative MP times were 585.44/584.53 s, versus 12.19/13.67 s for AP. Median MP runtime shares were 96.4%–97.6%.

Separate. AP solves took about 600 s cumulatively, accounting for roughly 90% of runtime.

These MP/AP times are consistent with Table 1's median total runtimes of about 600 s for CSD and 660 s for Separate.

The CSD activation analysis at n=30,40,50n=30,40,50 uses the same model and solver configuration as the main CB experiments, as specified in Appendix B.2. The table reports group medians for the last MP of each run.

nnUnstable ReLUsBinary variables after presolve
30178273
40137246
50103228

Unstable ReLUs introduce binary activation choices; their bounds and couplings affect relaxation strength. Both counts decrease at larger nn, suggesting a potential contributor to faster solves. Equal iteration counts need not imply equal runtimes.

The Table 1 runs used total/MP/AP time limits of 3,600/1,800/300 s, consistent with Appendix B.2, with each MP/AP call capped by the remaining total budget. We use two solver threads; relative MP/AP tolerances and the C&CG stopping tolerance are 10−410^{-4}. At a subproblem time limit, available incumbents are used. Runs returning decisions remain in the time and iteration statistics; their gaps are included when evaluation completes.

Q2. Why 38.5 iterations? Table 2 reports medians. For (n,K)=(25,8)(n,K)=(25,8), 50 test instances and three training seeds give 150 case–seed runs. The median averages the 75th and 76th sorted integer counts, yielding 38.5. “Instances” counts distinct cases; statistics pool all three seeds (Section 6.1 and Appendix I).

Q3. Neur2RO knapsack benchmark. We added the original KP benchmark: 504 instances, n=20,30,…,80n=20,30,\ldots,80, all four published correlation classes, seeds 11, 17, and 23, and a 3,600 s total budget per run. KP tests binary recourse coupled by a knapsack capacity under continuous budgeted profit uncertainty; item decisions are paired with their profit-deviation features.

Table 4 reports median reference gaps of 0.321% for CSD and 0.637% for Separate, a 49.7% reduction, with lower medians in every size group. Both use the same independent fixed-decision evaluation; all 1,512 evaluations per architecture are certified. Median runtimes are 535.44 s and 43.86 s, respectively. These results extend the evidence to a different recourse structure and quantify the quality–runtime trade-off. Appendices F and I give the formulation and evaluation protocol.

Thank you for the clarification.

Regarding Q1: Could the authors further explain why the number of unstable ReLUs decreases as the problem size nn increases? This seems counterintuitive, and the current explanation describes the observed pattern without clarifying its underlying cause.

I believe this is an important issue, particularly given the paper's connection to the Neur2RO research line. Understanding how the embedded neural network interacts with the MILP solver, and how its computational complexity changes with problem size, is essential for assessing the scalability and generalizability of the proposed method.

Thank you for asking us to explain the cause. The final-MP decrease reflects differences in the accumulated scenario networks: at matched K=1 and K=2, the unstable counts are similar across n. The structural reason is that exact binary endpoint interpolation (Appendix B.4) replaces the component encoders' ReLU formulations by affine expressions in the binary decisions. The remaining CB scoring block has fixed widths: 48 post-aggregation and 10 value-network ReLUs per scenario. Thus, K retained scenarios give 58K ReLUs; increasing n does not itself increase this per-scenario count.

We checked 90 diagnostic runs: ten instances at each of n=30,40,50 and three training seeds. All runs reach K=1 and K=2. Each entry below is a median over the 30 runs at that size; K=1 uses the common initial scenario, xi=0.

nUnstable at K=1Unstable at K=2K in final MPUnstable in final MP
3042784178
4041724137
5043733103

The initial single-scenario counts are almost unchanged across sizes, and the K=2 counts remain close. The differences emerge in the final accumulated MPs. Their scenario sets differ in both size and composition: at n=30, 14 of the 30 runs retain five scenarios, whereas no n=40 or n=50 run does, even though n=30 and n=40 have the same median K.

The increments in unstable units also vary across scenarios. Specifically, Nunstable(K)=∑s=1KusN_{\mathrm{unstable}}(K)=\sum_{s=1}^{K}u_s, where usu_s counts units whose preactivation intervals, computed independently over the binary input box for scenario s, cross zero. In an n=50 run, the initial scenario (0,0,0,0) contributes 40 unstable ReLUs, and the next scenario (-1,-1,-1,-1) contributes 30. Total ReLUs double from 58 to 116, while unstable ReLUs increase from 40 to 70. The new scenario changes every project's cost and revenue multipliers from 1 to 0.5; one corresponding unit's interval moves from [-0.277182, 0.119339] to [-0.773260, -0.162076], making it stable. This gives a concrete mechanism for the unequal increments: scenario features shift activation bounds and change which units cross zero.

To address the MILP interaction and scalability concern, we further analyzed how the accumulated blocks interact through their shared decision x. The full MP still grows with n: at K=2, median binary-variable counts after presolve are 159/174/191. Within this joint MP, shared decisions constrain the activation choices across scenario networks and permit conditional activation fixing.

After interpolation, corresponding preactivations in the first post-aggregation layer are affine: as(x)=cs+ds⊤xa_s(x)=c_s+d_s^\top x. For binary x,

at(x)−as(x)≥δts:=(ct−cs)+∑imin⁡{0,dti−dsi}.a_t(x)-a_s(x)\ge\delta_{ts}:=(c_t-c_s)+\sum_i\min\{0,d_{ti}-d_{si}\}.

This follows by minimizing each coefficient-difference term over xi∈{0,1}x_i\in\{0,1\}. A positive bound strictly orders the two preactivations throughout the binary decision domain. We found at least one such pair of individually unstable units under the initial and first added scenarios in 88 of the 90 runs.

At a branch-and-bound node D, let Ls(D)≤as(x)L_s(D)\le a_s(x) and at(x)≤Ut(D)a_t(x)\le U_t(D) be valid bounds. The difference bound gives at(x)≥Ls(D)+δtsa_t(x)\ge L_s(D)+\delta_{ts} and as(x)≤Ut(D)−δtsa_s(x)\le U_t(D)-\delta_{ts}, hence

L_s(D)\ge-\delta_{ts}&\Rightarrow\operatorname{ReLU}(a_t(x))=a_t(x),\\ U_t(D)\le\delta_{ts}&\Rightarrow\operatorname{ReLU}(a_s(x))=0. \end{aligned}$$ These conditions permit eliminating an activation choice throughout that node, including when the other unit remains individually unstable. They apply whenever valid individual and difference bounds are available. In the same n=50 example, another pair has all 50 coefficient differences positive, giving $\delta_{ts}=0.7130727631-0.1526326555\approx0.5604401$. With the conservative bound 0.5604, branching on $a_s\ge0$ gives $a_t\ge0.5604$, allowing t's ReLU to be replaced by its affine expression; branching on $a_t\le0$ gives $a_s\le-0.5604$, allowing s's output to be fixed to zero. Thus, scenario accumulation contributes different numbers of individually unstable units, and shared-decision relations provide a further mechanism for fixing their activations during joint MILP search.
Reviewer_dheMOpenReview ↗
Rating
2
Confidence
4
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes a conditional set decoder model that integrates into column-and-constraint generation (CCG) for adjustable or two-stage robust optimization (2RO). The model is specifically designed to address a limitation of prior work that separately embeds decisions and scenarios by aligning decisions and scenarios that occur together. On three benchmarks, they show advantages over the prior method, finding better-quality solutions more efficiently at matched network sizes.

Critical strengths
  • Motivation: The authors give a reasonable justification for limitations in prior work and provide an architecture that specifically addresses these.
  • Empirical Results: Overall, the proposed method provides relatively strong empirical results and outperforms prior work.

Together, these are consequential: the authors propose a well-motivated approach that works empirically, so I think there is a path for this work to be published.

Critical weaknesses
  • Scope & Novelty: While the motivation for the use case is relatively strong, the scope and novelty are relatively limited. Specifically, it applies to a limited subset of two-stage robust optimization problems (those with a one-to-one correspondence between first-stage decisions and uncertainty), and the remaining algorithmic components are primarily inherited from prior work. For example, even the paper this builds on includes an extension [1] with results for a facility location problem, where the proposed method would not apply. Overall, this is consequential because the proposed method has limited applicability and is relatively incremental in terms of novelty, leading to a borderline score. That said, where the method applies, it has reasonable motivation and justification.

  • Clarity, Choices, & Presentation: Clarity. First, numerous experimental details remain unclear and potentially problematic. For example, Figure 2 shows that increasing parameter counts does not improve metric quality; however, it isn't clearly stated where the parameters are being increased, i.e., whether it matters that the embedding dimension of the previous method is increased, or if it is in intermediate layers, which may not be as critical.

    Choices. An odd choice is that the authors didn't include the knapsack benchmark from [2], which fits their setting, and instead implemented entirely new benchmarks where the prior method performs worse. This makes me slightly skeptical of the implementation in these new benchmarks, or at least of the reasoning for not including the knapsack benchmark. In addition, given the structural similarity between the knapsack problem and the assignment problem, I'd expect the base method to still perform reasonably well. For the actual features used in the model, they appear to be problematic as reported, e.g., the authors pair information about facility ii with client jj, but it's not at all clear what jj is, as all clients can be served by facility ii (similar for the assignment benchmark, as each first-stage decision can correspond to multiple machines).

    Presentation. Lastly, the presentation has some issues. First, the model isn't a decoder in the classic sense (e.g., those used in translation), and it's ultimately unclear what it's decoding. Second, the proofs are hard to follow because they use separate notation and rely on other theorems without citing them or explaining how they apply to the setting, leaving readers to fill in the gaps. The interpretation of the proofs could also be strengthened; e.g., in the continuous case, they provide a result on the error, but it's unclear how this applies to the actual algorithm; e.g., given the argmax formulation, is this error even that problematic? When training, it could be the case that certain variability is lost in the encoding, but ultimately it may matter if this doesn't occur in decision-relevant regions. The discrete case is even less clear and makes a very strong assumption (that two scenarios have the same embedding), so I am not sure it is useful. Some notational inconsistencies appear; for example, the notation changes across sections in facility location. Overall, this is consequential: while the paper has a reasonable motivation and justification, it is relatively hard to parse, even for someone reasonably familiar with the prior work, which pushes my borderline view to a weak reject.

Questions for authors
  • Can the authors clarify their choice of benchmarks and why the knapsack problem from the original paper isn't included?
  • Can the authors clarify the features used in the model and justify their decisions?
  • Can the authors provide details on exactly how the network size changes?

References

  • [1] Justin Dumouchelle, Esther Julien, Jannis Kurtz, and Elias B Khalil. Deep learning for two-stage robust integer optimization. arXiv preprint arXiv:2310.04345, 2023.
  • [2] Justin Dumouchelle, Esther Julien, Jannis Kurtz, and Elias Boutros Khalil. Neur2RO: Neural two-stage robust optimization. In The Twelfth International Conference on Learning Representations, 2024.
7 comments

Thank you for the thoughtful review and suggestions.

Applicability and contribution. In the CB benchmark in our original submission, x∈{0,1}nx\in\{0,1\}^n and ξ∈[−1,1]4\xi\in[-1,1]^4 have different dimensions: nn project decisions share four uncertainty factors. CSD pairs each project's decision features with its scenario-dependent cost and revenue features. Our original wording did not clearly distinguish feature-level correspondence from one-to-one matching of raw variables. Thank you for highlighting this ambiguity. We have clarified the distinction in the abstract, introduction, Section 3.3, and Figure 3.

CSD pairs decision and uncertainty features by optimization component or recourse relation. Rows may reuse variables, and the two feature dimensions may differ. For the facility-location model in your Ref. [1], Eq. (21), (i,j)(i,j) rows can contain facility decision xix_i, customer demand bj(ξ)b_j(\xi), uncertain serving cost dij(ξo)d_{ij}(\xi^o), and static attributes. This accommodates different numbers of facilities and customers. Appendix G now explains the row indices for our benchmarks.

CSD changes the representation of Q(x,ξ)Q(x,\xi) within Neur2RO's MP/AP interface, supported by representation-dimension and value-error bounds. Separate must encode scenario information sufficient for value predictions across decisions; CSD forms decision-conditioned interactions before compression. In the constructed recourse families, Separate requires at least rr scenario dimensions, whereas CSD uses a scalar pooled state. This distinction matters when the neural surrogate itself must be optimized inside C&CG. For the family in Proposition 3, this dimension requirement remains after adding an explicit pooled interaction statistic to Separate. The DFLP ablation tests that alternative: its median gap is 12.55%, compared with 0.00% for CSD. Both architectures retain Neur2RO's C&CG framework and value supervision.

Theory and scenario selection. Theorem 1 characterizes the supervised value-learning task. Its relevance to scenario selection is examined directly: at r=32r=32, worst-scenario recovery is 94.67% for CSD versus 33.87% for Separate; on 297 held-out DFLP pairs, ranking-reversal recovery is 91.1% versus 0.1%. Shuffling correspondence with the same data and model size raises CSD's median downstream gap from 0.00% to 82.32% and reduces median iterations from 9 to 2. Thus, the experiments test information that affects scenario ordering, learned termination, and decision quality.

Proposition 4 (A.5) supplies a formal recovery condition: over a finite candidate set, uniform error at most ϵ\epsilon preserves the unique worst scenario when the top-two value margin exceeds 2ϵ2\epsilon. Proposition 2 is conditional: if scenarios with different value responses share an encoding, exact value representation is impossible. A finite candidate set alone implies neither collisions nor a latent-dimension lower bound (Appendix A.2). Section 4 now links the recovery condition and ordering experiments; Appendix A.1 cites the external theorems at their uses.

Q1. Why these benchmarks, and why was KP omitted? The original benchmarks cover project selection, assignment, and facility service with different recourse constraints. CB follows Neur2RO; RAP and DFLP use published formulations and test sets. Their comparisons share features, labels, splits, training budgets, and C&CG settings. We added Neur2RO's original KP benchmark: 504 instances (n=20,30,…,80n=20,30,\ldots,80), seeds 11, 17, and 23. Both architectures use the same evaluation protocol. CSD reduces the median reference gap from Separate's 0.637% to 0.321% (49.7%), with lower medians at every size (Table 4).

Q2. Which features are paired, and why? Rows follow the recourse structure. In RAP, row i=(ℓ,m)i=(\ell,m) pairs the decision enabling an assignment with that pair's uncertain reward; yℓm≤xℓmy_{\ell m}\le x_{\ell m} links the two stages. DFLP uses facility–customer rows (i,j)(i,j), repeating facility opening xix_i and availability 1−ξi1-\xi_i across customers, alongside facility, demand, and transportation attributes. All service alternatives remain represented. Both architectures receive the same information. Appendix G explains the indices beside Table 7.

Q3. How does network size change? Figure 2(b) fixes depth and increases hidden width ww and representation dimension dd together. The (w,d)(w,d) pairs are (11,5),(23,11),(47,23),(67,33)(11,5),(23,11),(47,23),(67,33) for both Separate branches and its explicit-interaction variant, and (15,7),(32,16),(66,33),(94,47)(15,7),(32,16),(66,33),(94,47) for CSD. Here ww is the elementwise/post-aggregation hidden width; dd sets their output and pooled dimensions and the value-head hidden width. The approximately matched budgets are 0.5K, 2K, 8K, and 16K parameters (Appendix C).

Finally, “decoder” denotes aggregation and output mapping of the conditioned representations, as in Set Transformer, Section 2.1.

My score remains unchanged, and I do not believe the authors have adequately addressed my main concerns.

  • Applicability: The authors identified a specific case where the uncertainty itself is not in the same dimension as the decisions in CB, yet they claim that their method generalizes. However, the problem essentially projects the uncertainty onto the same dimension, so it still suffers from the same limitation unless the authors implemented it without considering this. To be more precise about my main concern, for problems without a simple 1-to-1 correspondence between decisions and uncertainty, I am skeptical that the model will scale at all. For example, in the location problem in [1] (referenced above), since each uncertainty connects and co-occurs with each first-stage decision, I believe the CSD model (eq. 9 from the paper) would require eie_i for every pair, resulting in thousands of embeddings.
  • Theory: I am still not convinced that the theory added during the rebuttal actually addresses my concerns. Specifically, this has not been adequately clarified: "The interpretation of the proofs could also be strengthened; e.g., in the continuous case, they provide a result on the error, but it's unclear how this applies to the actual algorithm; e.g., given the argmax formulation, is this error even that problematic? When training, it could be the case that certain variability is lost in the encoding, but ultimately it may matter if this doesn't occur in decision-relevant regions."

Beyond that, I don't think the clarity or presentation has changed substantially.

Thank you for specifying the dense-coupling and decision-relevance concerns. We address your facility-location example directly.

Applicability and computational scaling. In Ref. [1], Eq. (21), a facility–customer row can contain the opening decision xix_i, uncertain demand bj(ξ)b_j(\xi), serving cost dij(ξ)d_{ij}(\xi), and static attributes. Variables are reused across rows, so the construction accommodates many-to-many relationships. There are m=∣F∣∣C∣m=|F||C| rows. For fixed network widths, the shared encoder requires O(∣F∣∣C∣)O(|F||C|) forward work; parameter sharing preserves the network size but does not remove this computation.

The MP representation has an additional simplification already provided by Appendix B. Fix a retained scenario ξ\xi, collect the remaining row features in sij(ξ)s_{ij}(\xi), and precompute hijb=gθ([b,sij(ξ)])h^b_{ij}=g_\theta([b,s_{ij}(\xi)]) for b∈{0,1}b\in\{0,1\}. Since xix_i is binary, the pooled representation is exactly

=c(\xi)+\sum_i B_i(\xi)x_i,$$ where $c=\sum_{i,j}h^0_{ij}$ and $B_i=\sum_j(h^1_{ij}-h^0_{ij})$. The $2m$ endpoint evaluations are performed outside the MP. Per retained scenario, the MP embeds this pooled affine expression and the fixed-size post-aggregation network. The facility–customer element-encoder ReLUs have been eliminated exactly. This preserves Eq. (9), its trained weights, and its predictions. Training and forward evaluation still process the $m$ rows. In the AP, the uncertainty features remain variable, so the binary-decision interpolation above does not eliminate those row evaluations; AP solution time also depends on the search over uncertainty. Our existing DFLP experiments use facility–customer rows (Table 7), with 200–750 rows per scenario. At the largest size, $15\times50$, Table 3 reports a median runtime of 449.11 s and a median reference gap of 1.76% for CSD. These are measured results for our DFLP benchmark; the demand-uncertainty model in Ref. [1] is a different benchmark. The construction and MP simplification above apply to that model, while its end-to-end performance would require a separate evaluation. **Theory and decision-relevant errors.** Scenario selection depends on errors in value differences between competing scenarios. A prediction offset common to all scenarios at a fixed decision leaves their ordering unchanged. Theorem 1 concerns the supervised value-learning task: in the analyzed recourse families, a separate scenario encoder must preserve enough information to distinguish values across decisions. Proposition 4 gives a sufficient margin condition for recovering the worst scenario. The algorithmic relevance is tested directly at decisions reached by C&CG. Specifically, we solve the exact AP at each architecture's returned decision on three held-out DFLP instances, three uncertainty budgets, and three training seeds: 27 runs per architecture. We compare its worst-case value with the largest exact recourse value among that run's accepted scenarios. An omitted adverse scenario is recorded when the difference exceeds the AP tolerance. | Architecture | Runs with an omitted adverse scenario | Median reference gap | |:---:|:---:|:---:| | CSD | 7/27 | 0.0002% | | Separate | 27/27 | 100.0% | This checks the concern at the actual returned decisions: in all 27 Separate runs, a more adverse scenario remains after learned termination. CSD reduces that frequency to 7/27 and returns substantially better decisions on the same subset. The comparison uses exact recourse values and the exact AP. These results are reported in Section 6.3 and Appendix M. The controlled ranking test examines the associated decision dependence. On 297 held-out DFLP pairs, a single facility-opening swap reverses the exact ordering of two scenarios. CSD recovers 91.1% of these reversals versus 0.1% for Separate; pair construction uses exact values, independently of learned scores (Appendix E). Moreover, shuffling correspondence while preserving the data and model size raises CSD's downstream median gap from 0.00% to 82.32% and reduces median iterations from 9 to 2 (Appendix J.1). Together, these tests examine the representation of changing scenario preferences and its consequences in the solving loop. For clarity, Section 3.3 specifies how variables can recur in feature rows, Appendix G gives the row definitions, and Appendix B gives the exact MP interpolation used above. Section 6.3 and Appendix M provide the ordering and termination evidence relevant to your theoretical concern.
Reviewer_7zumOpenReview ↗
Rating
3
Confidence
3
Informativeness
3
Presentation
3
Soundness
2
Read review
Paper summary

The paper studies the Conditional Set Decoder (CSD) for learning-augmented column & constraint generation in two-stage robust optimization. CSD combines corresponding first-stage decision and uncertainty features before aggregation, preserving interactions that separate set encoders must recover after compression. This paper establishes representation-dimension and approximation-error lower bounds for separate encoding and provide solver-compatible ReLU formulations and acceleration techniques. Experiments cover capital budgeting, robust assignment, and facility location with disruptions. CSD improves the median evaluation gaps across all 3 benchmarks, while controlled experiments, shuffled-correspondence ablations, and ranking-reversal tests connect these gains to the preservation of component-wise interactions.

Critical strengths

The paper identifies when a separate scenario encoder should preserve a growing number of independently distinguishable responses, while conditional aggregation can represent the analyzed interactions with a scalar pooled state. The constructions explicitly state their assumptions and distinguish continuous uncertainty from finite scenario sets. This provides a principled explanation for the proposed design

Critical weaknesses

For capital budgeting, the common-pool gap evaluates decisions only on scenarios generated by the 2 learned methods. Both methods can miss an adverse scenario, so this diagnostic can underestimate the true robust gap. The DFLP illustrates that learned termination remains imperfect even for CSD: an omitted adverse scenario is found in 7 of 27 runs. Appendix I excludes runs without returned decisions or completed evaluations, but the main tables do not report the corresponding inclusion counts. Independent worst-case evaluation where available, together with complete coverage statistics, is needed to interpret the headline quality improvements reliably

Questions for authors
  1. Were independent worst-case evaluations obtained for any capital-budgeting decisions beyond the shared scenario pool ? If so, do these evaluations preserve the reported ordering between CSD and Separate ?
  2. For each architecture and benchmark, how many case-seed runs returned decisions and obtained completed independent evaluations? Also, please clarify the actual CB runtime limits used in Table 1, whose medians cluster around 600–660 seconds, relative to the limits specified in Appendix B.2
  3. Are there any existing comparisons against exact methods available under the same hardware, solver settings and solution-quality target ? Such results would help assess the practical significance of the reported runtime tradeoffs
1 comment

Thank you for your comments on the theory, evaluation, and computational comparisons.

Response to the critical weakness. We tested direct worst-case evaluation and checked evaluation coverage. For CB, extended AP tests show the difficulty of direct evaluation; the common-pool gap provides an indirect assessment against valid MP lower bounds.

For DFLP, CSD reduces the proportion of runs with omitted adverse scenarios from 27/27 (100%) with Separate to 7/27 (25.9%) on the controlled subset. The median normalized reference gap across these 27 runs per architecture is 0.0002% for CSD and 100.0% for Separate. Table 3 evaluates every returned decision through a certified fixed-decision worst-case solve.

All runs in the main experiments returned decisions and completed their respective evaluations, including time-limited runs.

Q1. Independent worst-case evaluation for CB. Our previous CB evaluation batch used a 600-second budget per fixed-decision AP and obtained no certified solutions. To address your concern, we extended this budget to 1,600 seconds for archived decisions at three problem sizes: 10, 20, and 40 projects. All tested APs again reached the time limit without a certified worst-case value. Each test involved a single fixed-decision AP, without an outer C&CG loop. These attempts therefore did not yield certified independent evaluations with which to assess whether the CSD–Separate ordering is preserved.

The common-pool gap compares both returned decisions on the union of scenarios generated by the two methods. Each decision's pool value is compared with its run's network-free standard MP lower bound. Because this MP uses a scenario subset, it relaxes the full robust problem. Its lower bound remains valid even when adverse scenarios are omitted, and adding scenarios can tighten it. Table 1 reports a reduction from 0.394% to 0.188% (52.3%) in this metric.

Q2. Evaluation coverage and CB time limits.

Coverage. Each run is a case–seed pair for one architecture. Counts pool seeds 11, 17, and 23 and concern each run's final decision.

BenchmarkCSD returned/evaluatedSeparate returned/evaluated
CB750/750750/750
RAP750/750750/750
DFLP1,440/1,4401,440/1,440
KP (added)1,512/1,5121,512/1,512

CB counts refer to common-pool evaluations (see Q1); RAP uses independent fixed-decision evaluations, and DFLP/KP use certified fixed-decision evaluations.

Time-limited runs are included in the runtime, iteration, and gap statistics. These coverage counts are reported in Appendix I.

CB runtime and time limits. In Table 1, the 600 s medians are for CSD at n=20,30n=20,30, and the roughly 660 s medians are for Separate at n=30,40,50n=30,40,50. For this timing comparison, we profiled 10 randomly selected instances per seed (11,17,23), or 30 runs per architecture–size group.

CSD. At n=20,30n=20,30, median cumulative MP times were 585.44/584.53 s, versus 12.19/13.67 s for AP. Median MP runtime shares were 96.4%–97.6%.

Separate. AP solves took about 600 s cumulatively, accounting for roughly 90% of runtime.

The cumulative MP/AP times are consistent with Table 1's median runtimes of around 600 s for CSD and 660 s for Separate.

The Table 1 runs used total/MP/AP time limits of 3,600/1,800/300 s, consistent with Appendix B.2, with each MP/AP call capped by the remaining total budget.

Q3. Exact-method comparisons. We tested exact methods on the same machine used for our experiments.

  • CB (C&CG). Small-instance tests struggled to reach certified convergence within budget. The independent single-AP tests in Q1 also remained uncertified after 1,600 seconds.
  • RAP (C&CG). With two threads and a relative tolerance of 1e-4, 80% of the tested small instances timed out at 600 seconds.
  • DFLP (C&CG). Following your suggestion, we tested the 360 cases in the six size groups with numerical published C&CG runtimes in Table 3 (excluding “–” groups). With two threads, a relative tolerance of 1e-4, and a 3,600 s budget, exact C&CG certified 292/360 cases locally versus 304/360 in the published C&CG runs. On the 283 jointly certified cases, the median paired local/published runtime ratio was 1.061. These certification counts concern the C&CG runtime comparison. The objective references used for decision-quality evaluation draw on the published results of both C&CG and Benders decomposition, which provide certified optima for 433 of the full 480 cases; published C&CG lower bounds are used for the remaining 47.
  • KP (C&CG and B&P). Small-instance C&CG tests also struggled to reach certified convergence within budget. We additionally reproduced the core B&P method, including column generation, exact pricing, and branching. Runtimes were comparable to the published B&P results on some simple instances but substantially longer on harder ones.

For DFLP and KP, the manuscript retains the published exact-method results as the reference baselines.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.