Neural Two-Stage Stochastic Optimization

• Neural two-stage stochastic optimization is a method that integrates learned neural surrogates with traditional two-stage programming to approximate expensive recourse evaluations.
• It leverages neural networks to predict recourse cost or distributional outcomes, enabling faster optimization while preserving explicit first-stage decision feasibility.
• Applications in power systems, facility location, and network design demonstrate substantial speedups over conventional scenario-based methods.

Neural two-stage stochastic optimization denotes a family of methods that combine two-stage stochastic programming with learned components, most commonly neural surrogates for the recourse or value function, but also learned scenario encoders, decomposition accelerators, and solver-aware scenario-selection policies. The common starting point is the two-stage program

$$\min_{x\in\mathcal X}\; c^\top x+\mathbb E_\xi[Q(x,\xi)],$$

with second-stage value function

$$Q(x,\xi)=\min_y\{F(y,\xi): y\in\mathcal Y(x,\xi)\},$$

and the common motivation is that the standard scenario-based extensive form scales poorly with the number of scenarios and becomes especially hard when second-stage recourse is mixed-integer or nonlinear (Dumouchelle et al., 2022). Within this literature, the learned component usually does not replace optimization outright; rather, it reduces the cost of evaluating or approximating downstream recourse while preserving explicit optimization over first-stage decisions and, in many formulations, exact enforcement of first-stage hard constraints (Dumouchelle et al., 2022).

1. Mathematical setting and computational motivation

The canonical finite-scenario approximation of a two-stage stochastic program is the extensive form

$$\min_{x,\{y_k\}_{k=1}^K}\left\{c^\top x+\sum_{k=1}^K p_k F(y_k,\xi_k): x\in\mathcal X,\; y_k\in\mathcal Y(x,\xi_k)\ \forall k\right\}.$$

This deterministic reformulation introduces one copy of the second-stage variables and constraints per scenario, so model size grows linearly in $K$. When the second stage is LP-like, classical decomposition methods can exploit structure, but once second-stage recourse is a MIP or NLP, generic scalable exact methods become much weaker (Dumouchelle et al., 2022). The same scenario-replication difficulty appears in risk-neutral and risk-averse Sample Average Approximation formulations, including mean-CVaR models, where auxiliary variables are added for each scenario (Alcántara et al., 2024).

This computational bottleneck is the primary reason neural methods entered the two-stage literature. Rather than solving all recourse problems explicitly inside a large monolithic model, they aim to amortize recourse evaluation by learning a mapping from first-stage decisions and uncertainty information to a scalar summary of second-stage consequences. In the most direct formulations, the target is the expected recourse cost itself; in later variants, the target becomes a full conditional distribution of recourse values, a convex recourse surrogate compatible with LP embedding, a neural estimator used inside decomposition, or a scenario-reduction policy that selects which scenarios should remain in the optimization model (Dumouchelle et al., 2022).

A recurring misconception is that neural two-stage stochastic optimization is primarily about predicting first-stage decisions. In the central value-function line of work, the learned model predicts recourse cost, not the final decision, and the first-stage decision is still obtained by solving an optimization problem against the learned surrogate (Dumouchelle et al., 2022). This distinction is methodologically important because it preserves explicit combinatorial or physical feasibility conditions on the first stage.

2. Expected-recourse surrogates and embedded optimization

The defining reference point for the field is Neur2SP, which approximates the expected second-stage value function with a neural network and then embeds that surrogate into a mixed-integer optimization model (Dumouchelle et al., 2022). It uses two variants. NN-E learns the mapping

$$(x,\{\xi_k\}_{k=1}^K)\mapsto \sum_{k=1}^K p_k Q(x,\xi_k),$$

while NN-P learns the per-scenario mapping

$(x,\xi)\mapsto Q(x,\xi).$

NN-E therefore embeds one prediction network into the optimizer, whereas NN-P embeds one copy per scenario; this difference is the main reason NN-E scales much better with scenario count (Dumouchelle et al., 2022).

Neur2SP uses a DeepSets-style permutation-invariant scenario encoder for NN-E, feed-forward ReLU networks for the optimization-embedded prediction part, PyTorch for training, and random search over 100 hyperparameter settings with an 80/20 training-validation split (Dumouchelle et al., 2022). The crucial modeling step is that a ReLU network can be encoded exactly as mixed-integer linear constraints. After training, the recourse term is replaced by the network output, so the first-stage optimization becomes a deterministic MIP over the original first-stage variables plus hidden-layer variables and binaries representing the neural network (Dumouchelle et al., 2022). The paper calls this embedded surrogate model MIP-NN.

Empirically, Neur2SP established the main practical template. On four benchmark two-stage problem classes with MIP and NLP second-stage problems, NN-E solved in between $0.11$s and $1.66$s, while the extensive-form baseline often required minutes to hours and frequently hit the $10{,}800$s time limit (Dumouchelle et al., 2022). The most distinctive property was that NN-E solve time was essentially independent of the number of scenarios, because only one learned predictor was embedded and the scenario set was compressed externally before optimization (Dumouchelle et al., 2022).

A related development replaced static training sets by an alternating optimize-and-retrain loop. “Alternating mixed-integer programming and neural network training for approximating stochastic two-stage problems” states that the proposed algorithm alternates between optimizing the first-stage variables and retraining the NN, and that the alternating approach provides improved first-stage decisions and a tighter approximation between the expected objective and its neural network approximation (Kronqvist et al., 2023). In that line, the contribution is not a new embedding mechanism but an optimization-aware data-generation policy: training points are iteratively generated from solutions found during optimization rather than relying only on predefined data (Kronqvist et al., 2023).

3. Distributional and structure-aware variants

A major extension of expectation-only surrogates is to learn the conditional distribution of second-stage outcomes. “A Quantile Neural Network Framework for Two-stage Stochastic Optimization” models the distribution of the second-stage objective with a quantile neural network, using 50 output neurons corresponding to 50 equally spaced quantiles from $\tau=0.01$ to $$Q(x,\xi)=\min_y\{F(y,\xi): y\in\mathcal Y(x,\xi)\},$$0 (Alcántara et al., 2024). The network is trained with the composite quantile loss and embedded as a mixed-integer linear model through standard big-$$Q(x,\xi)=\min_y\{F(y,\xi): y\in\mathcal Y(x,\xi)\},$$1 ReLU constraints (Alcántara et al., 2024). This permits both expected-value optimization and mean-CVaR optimization from the same learned surrogate. In the reported experiments, QNN solve times were roughly $$Q(x,\xi)=\min_y\{F(y,\xi): y\in\mathcal Y(x,\xi)\},$$2 to $$Q(x,\xi)=\min_y\{F(y,\xi): y\in\mathcal Y(x,\xi)\},$$3 seconds, IQNN solve times were below $$Q(x,\xi)=\min_y\{F(y,\xi): y\in\mathcal Y(x,\xi)\},$$4 seconds in the risk-neutral study, and SAA often hit the 3-hour or 2-hour time limit depending on the setting (Alcántara et al., 2024). The conceptual shift is from learning only $$Q(x,\xi)=\min_y\{F(y,\xi): y\in\mathcal Y(x,\xi)\},$$5 to learning $$Q(x,\xi)=\min_y\{F(y,\xi): y\in\mathcal Y(x,\xi)\},$$6, thereby making risk-sensitive objectives available in the same embedded framework (Alcántara et al., 2024).

A second structure-aware direction concerns convexity. “ICNN-enhanced 2SP” argues that when the recourse/value function is convex in the first-stage variables, generic ReLU surrogates are unnecessarily expensive because exact embedding requires a MIP even though the underlying problem is convex (Liu et al., 8 May 2025). It replaces the decision-mapping network by an Input Convex Neural Network with ReLU activations and nonnegative hidden-to-hidden weights, so the trained surrogate can be embedded exactly as a linear program: $$Q(x,\xi)=\min_y\{F(y,\xi): y\in\mathcal Y(x,\xi)\},$$7 subject to linear epigraph constraints for the ICNN and $$Q(x,\xi)=\min_y\{F(y,\xi): y\in\mathcal Y(x,\xi)\},$$8 (Liu et al., 8 May 2025). The paper reports that ICNN-enhanced 2SP often exhibits considerably faster solution times than the MIP-based formulations while preserving solution quality, with speedups of up to $$Q(x,\xi)=\min_y\{F(y,\xi): y\in\mathcal Y(x,\xi)\},$$9 on the most challenging instances (Liu et al., 8 May 2025). This variant is explicitly limited to convex or convexifiable recourse, but it demonstrates an important design principle: the neural architecture can be chosen to match the geometry of the stochastic program rather than only to maximize predictive flexibility (Liu et al., 8 May 2025).

Together, these variants show that “neural two-stage stochastic optimization” is not a single method class. It includes expectation surrogates, distributional surrogates, and structure-aware surrogates, each altering what is learned and what optimization class remains after embedding.

4. Decomposition, scenario management, and solver-aware learning

Another branch of the literature leaves the master problem or extensive form largely intact but learns a component of the solution algorithm. In “A Neural Column-and-Constraint Generation Method for Solving Two-Stage Stochastic Unit Commitment,” the neural model approximates the second-stage recourse cost

$$\min_{x,\{y_k\}_{k=1}^K}\left\{c^\top x+\sum_{k=1}^K p_k F(y_k,\xi_k): x\in\mathcal X,\; y_k\in\mathcal Y(x,\xi_k)\ \forall k\right\}.$$0

and is used inside a column-and-constraint generation loop to score scenarios and select the highest-cost scenario instead of solving all scenario subproblems exactly at each iteration (Shao et al., 14 Aug 2025). The paper reports that about 60% of total CCG time is spent solving recourse problems, rising above 95% when the number of scenarios is above 1,000, which makes this substitution especially attractive (Shao et al., 14 Aug 2025). On the IEEE 118-bus system, Neural CCG achieves up to $$\min_{x,\{y_k\}_{k=1}^K}\left\{c^\top x+\sum_{k=1}^K p_k F(y_k,\xi_k): x\in\mathcal X,\; y_k\in\mathcal Y(x,\xi_k)\ \forall k\right\}.$$1 speedup while maintaining a mean optimality gap below $$\min_{x,\{y_k\}_{k=1}^K}\left\{c^\top x+\sum_{k=1}^K p_k F(y_k,\xi_k): x\in\mathcal X,\; y_k\in\mathcal Y(x,\xi_k)\ \forall k\right\}.$$2 (Shao et al., 14 Aug 2025). The exact master problem is retained, but classical CCG convergence guarantees no longer apply; the reported formal guarantee is finite termination when the first-stage decision set is finite (Shao et al., 14 Aug 2025).

A complementary family learns scenario reduction rather than recourse evaluation. “HGCN2SP” treats scenario selection and scenario ordering as a sequential decision problem over a hierarchical graph representation of the two-stage stochastic instance (Wu et al., 20 Nov 2025). Each scenario is first encoded as a bipartite graph of variables and constraints, then scenarios are linked in a higher-level graph by cosine similarity of flattened uncertainty vectors, and a hierarchical GCN plus attention-based decoder selects an ordered sequence of scenarios for a reduced extensive form (Wu et al., 20 Nov 2025). The model is trained with PPO using solver feedback as reward, combining negative solve time with a measure of agreement between the reduced-model first-stage solution and the full-instance optimal first-stage solution (Wu et al., 20 Nov 2025). This work is significant because it makes “solver-aware” learning explicit: the learned action is not a value surrogate but an ordered reduced scenario set, and the paper reports that scenario order materially affects runtime, with only 12% of random permutations faster than the learned order for one CFLP setting and 18% faster for another (Wu et al., 20 Nov 2025).

These methods broaden the field beyond embedded recourse surrogates. Neural two-stage stochastic optimization now includes learned decomposition oracles and learned scenario-management policies, provided they are integrated with an optimization solver rather than replacing it.

5. Application domains and empirical profile

Power systems have become the principal application domain. “Neural Two-Stage Stochastic Optimization for Solving Unit Commitment Problem” learns the expected second-stage dispatch cost over a scenario set, compresses the scenario set through an encoder-decoder architecture, and embeds the resulting ReLU main network into the first-stage unit commitment MILP (Shao et al., 13 Jul 2025). The paper reports average gap $$\min_{x,\{y_k\}_{k=1}^K}\left\{c^\top x+\sum_{k=1}^K p_k F(y_k,\xi_k): x\in\mathcal X,\; y_k\in\mathcal Y(x,\xi_k)\ \forall k\right\}.$$3, average runtime $$\min_{x,\{y_k\}_{k=1}^K}\left\{c^\top x+\sum_{k=1}^K p_k F(y_k,\xi_k): x\in\mathcal X,\; y_k\in\mathcal Y(x,\xi_k)\ \forall k\right\}.$$4s versus Gurobi $$\min_{x,\{y_k\}_{k=1}^K}\left\{c^\top x+\sum_{k=1}^K p_k F(y_k,\xi_k): x\in\mathcal X,\; y_k\in\mathcal Y(x,\xi_k)\ \forall k\right\}.$$5s, and average speedup $$\min_{x,\{y_k\}_{k=1}^K}\left\{c^\top x+\sum_{k=1}^K p_k F(y_k,\xi_k): x\in\mathcal X,\; y_k\in\mathcal Y(x,\xi_k)\ \forall k\right\}.$$6 across IEEE 5-bus, 30-bus, and 118-bus systems (Shao et al., 13 Jul 2025). A central claim is that the model’s size remains constant regardless of the number of scenarios, because the optimizer sees only the fixed scenario embedding and the compact embedded network (Shao et al., 13 Jul 2025).

The same application logic has been transferred to distribution-system Volt-VAR optimization. “Neural Two-Stage Stochastic Volt-VAR Optimization for Three-Phase Unbalanced Distribution Systems with Network Reconfiguration” formulates network reconfiguration and OLTC tap settings as first-stage decisions and DER dispatch and network states as second-stage recourse, then replaces the expensive recourse value by a neural surrogate split into a spatiotemporal GCN scenario encoder and a small optimization-embedded ReLU head (Shao et al., 27 Oct 2025). On a modified IEEE 123-bus unbalanced distribution system, the method achieves over 50 times speedup compared to conventional solvers and decomposition methods, while maintaining a typical optimality gap below $$\min_{x,\{y_k\}_{k=1}^K}\left\{c^\top x+\sum_{k=1}^K p_k F(y_k,\xi_k): x\in\mathcal X,\; y_k\in\mathcal Y(x,\xi_k)\ \forall k\right\}.$$7 (Shao et al., 27 Oct 2025). In the 123_Bus_FM case, runtime stays near 30–36 seconds as scenario count grows from 10 to 100, while Gurobi grows from 512.5 s to 7262.6 s (Shao et al., 27 Oct 2025).

Beyond power systems, the foundational benchmark studies remain important because they show the methods are not tied to one domain. Neur2SP evaluates capacitated facility location, investment, stochastic server location, and pooling problems, including MIP and NLP second-stage recourse, and shows that the strongest benefits arise on larger scenario sets and structurally hard recourse models (Dumouchelle et al., 2022). HGCN2SP evaluates CFLP and network design, showing that learned scenario reduction can improve time-quality tradeoffs even when the recourse is handled by a conventional solver (Wu et al., 20 Nov 2025). Quantile-based surrogates have been tested on facility location and investment problems, where they are competitive in risk-neutral settings and particularly valuable when mean-CVaR objectives make SAA difficult to solve within time limits (Alcántara et al., 2024).

A notable empirical pattern across these applications is that neural approaches are most compelling in scenario-rich regimes. This suggests that their advantage comes less from replacing stochastic optimization in small instances than from decoupling online solve time from the raw number of scenarios.

6. Theory, limitations, and related extensions

The theoretical status of the field remains uneven. The original Neur2SP paper is explicit that it does not provide formal approximation guarantees, convergence theorems, regret bounds, or finite-sample error-to-decision-quality results; its justification is mainly empirical, and the framework is presented as a heuristic for solution generation rather than an exact stochastic programming algorithm (Dumouchelle et al., 2022). The quantile-surrogate framework is similarly methodological and computational rather than theorem-driven, and its authors emphasize approximation error sources such as training-data coverage, quantile discretization, and tail approximation (Alcántara et al., 2024). Neural CCG proves finite termination, but classical optimality guarantees no longer apply once exact recourse evaluation is replaced by neural scenario scoring (Shao et al., 14 Aug 2025).

At the same time, adjacent lines of work have supplied stronger theory for specialized variants. “Solutions of Two-stage Stochastic Minimax Problems” studies a two-stage stochastic minimax model with a nonconvex-concave first stage and a strongly convex-concave second stage, proves that the second-stage minimax value function is continuously differentiable, gives the gradient formulas

$$\min_{x,\{y_k\}_{k=1}^K}\left\{c^\top x+\sum_{k=1}^K p_k F(y_k,\xi_k): x\in\mathcal X,\; y_k\in\mathcal Y(x,\xi_k)\ \forall k\right\}.$$8

and establishes almost sure convergence of SAA KKT points to the true KKT set (Sun et al., 5 Nov 2025). “Two-Stage Stochastic Optimization via Primal-Dual Decomposition and Deep Unrolling” develops PDD-SSCA for coupled, generally nonconvex two-stage problems and proves almost sure convergence of the outer iterates to KKT points of the original problem up to an $$\min_{x,\{y_k\}_{k=1}^K}\left\{c^\top x+\sum_{k=1}^K p_k F(y_k,\xi_k): x\in\mathcal X,\; y_k\in\mathcal Y(x,\xi_k)\ \forall k\right\}.$$9 error induced by finite inner unrolling (Liu et al., 2021). “Constrained Online Two-stage Stochastic Optimization: Algorithm with (and without) Predictions” is not a neural policy paper, but it provides a learning-augmented online two-stage framework with regret $K$0 when distributional predictions are available (Hu et al., 2024).

There is also a broader related literature that extends the recourse-learning idea outside classical two-stage SP. Neural SDDP learns transferable piecewise-linear value functions across multi-stage stochastic linear programs, which reduces to learning the expected recourse function in the two-stage case (Dai et al., 2021). Continuous-time stochastic control work learns cost-to-go functions with adaptive sampling informed by the stochastic Pontryagin maximum principle, which is conceptually close to learning recourse values in policy-relevant regions rather than uniformly over the state space (Li et al., 2022). A recent two-step stochastic control framework proves that the empirical optimum of a neural-network-parametrized risk–reward objective converges in probability to the true optimal value as network capacity and training sample size increase, even when the optimal feedback policy may be discontinuous because of binding constraints (Chen et al., 6 Mar 2026).

Several limitations are now well established. Performance depends on training-data coverage and surrogate generalization (Shao et al., 14 Aug 2025). Retraining may be needed if system conditions or uncertainty distributions shift (Shao et al., 14 Aug 2025). ICNN-based formulations are restricted to convex or convexifiable recourse (Liu et al., 8 May 2025). Embedded ReLU surrogates preserve first-stage feasibility but do not, by themselves, provide exact second-stage feasibility guarantees under all scenarios (Shao et al., 13 Jul 2025). For risk-sensitive surrogates, tail modeling and quantile crossing remain prescriptive issues (Alcántara et al., 2024). These limitations explain why the most mature implementations remain hybrid: they preserve optimization structure, use neural models for the most expensive stochastic component, and often treat the neural solution as either a fast high-quality answer or a warm start for an exact solver.

In that sense, neural two-stage stochastic optimization has evolved into a structured rather than purely predictive field. Its characteristic move is to learn the expensive stochastic part of the model while leaving the prescriptive core—feasible first-stage optimization under explicit constraints—inside mathematical programming.