Title: Landscape Surrogate: Learning Decision Losses for Mathematical Optimization Under Partial Information
Venue: NeurIPS 2023
Accepted: yes
Keywords: learning surrogates

predict+optimize framework

combinatorial nonlinear optimization

argmin differentiation
Abstract: Recent works in learning-integrated optimization have shown promise in settings where the optimization problem is only partially observed or where general-purpose optimizers perform poorly without expert tuning. By learning an optimizer $\mathbf{g}$ to tackle these challenging problems with $f$ as the objective, the optimization process can be substantially accelerated by leveraging past experience. The optimizer can be trained with supervision from known optimal solutions or implicitly by optimizing the compound function $f\circ \mathbf{g}$. The implicit approach may not require optimal solutions as labels and is capable of handling problem uncertainty; however, it is slow to train and deploy due to frequent calls to optimizer $\mathbf{g}$ during both training and testing. The training is further challenged by sparse gradients of $\mathbf{g}$, especially for combinatorial solvers. To address these challenges, we propose using a smooth and learnable **Landscape Surrogate** $\mathcal{M}$ as a replacement for $f\circ \mathbf{g}$. This surrogate, learnable by neural networks, can be computed faster than the solver $\mathbf{g}$, provides dense and smooth gradients during training, can generalize to unseen optimization problems, and is efficiently learned via alternating optimization. We test our approach on both synthetic problems, including shortest path and multidimensional knapsack, and real-world problems such as portfolio optimization, achieving comparable or superior objective values compared to state-of-the-art baselines while reducing the number of calls to $\mathbf{g}$. Notably, our approach outperforms existing methods for computationally expensive high-dimensional problems.

Landscape Surrogate: Learning Decision Losses for Mathematical Optimization Under Partial Information

Abstract

Recent works in learning-integrated optimization have shown promise in settings where the optimization problem is only partially observed or where general-purpose optimizers perform poorly without expert tuning. By learning an optimizer g to tackle these challenging problems with f as the objective, the optimization process can be substantially accelerated by leveraging past experience. The optimizer can be trained with supervision from known optimal solutions or implicitly by optimizing the compound function f ◦ g . The implicit approach may not require optimal solutions as labels and is capable of handling problem uncertainty; however, it is slow to train and deploy due to frequent calls to optimizer g during both training and testing. The training is further challenged by sparse gradients of g , especially for combinatorial solvers. To address these challenges, we propose using a smooth and learnable Landscape Surrogate M as a replacement for f ◦ g . This surrogate, learnable by neural networks, can be computed faster than the solver g , provides dense and smooth gradients during training, can generalize to unseen optimization problems, and is efficiently learned via alternating optimization. We test our approach on both synthetic problems, including shortest path and multidimensional knapsack, and real-world problems such as portfolio optimization, achieving comparable or superior objective values compared to state-of-the-art baselines while reducing the number of calls to g . Notably, our approach outperforms existing methods for computationally expensive high-dimensional problems.

1 Introduction

Mathematical optimization problems in various settings have been widely studied, and numerous methods exist to solve them [25, 32]. Although the literature on this topic is immense, real-world applications consider settings that are nontrivial or extremely costly to solve. The issue often stems from uncertainty in the objective or in the problem definition. For example, combinatorial problems involving nonlinear objectives are generally hard to address, even if there are efficient methods that can handle special cases (e.g., k -means). One possible approach could be learning so-called linear surrogate costs [16] that guide an efficient linear solver towards high quality solutions for the original hard nonlinear problem. This automatically finds a surrogate mixed integer linear program (MILP), for which relatively efficient solvers exist [19]. Another example is the smart predict+optimize framework (a.k.a. decision-focused learning) [13, 41] where some problem parameters are unknown at test time and must be inferred from the observed input using a model (e.g., neural nets).

Despite having completely different settings and purposes, what is common among learning surrogate costs, smart predict+optimize, and other integrations of learning and optimization, is the need to learn a certain target mapping to estimate the parameters of a latent optimization problem. This makes the optimization problem well-defined, easy to address, or both. In this work, we draw general

2

Landscape surrogateM

Original problem:fg

learn Ce:

min J

M(ce(y),z)

θ

use

(y,z, f) to refine M

minimizer

connections between different problem families and combine them into a unified framework. The core idea (section 3) is to formulate the learning problem via constructing a compound function f ◦ g that includes a parametric solver g and the original objective f . To the best of our knowledge, this paper is the first to propose a generic optimization formulation (section 3) for these types of problems.

Minimizing this new compound function f ◦ g via gradient descent is a nontrivial task as it requires differentiation through the argmin operator. Although various methods have been proposed to tackle this issue [3, 2], they have several limitations. First, they are not directly applicable to combinatorial optimization problems, which have 0 gradient almost everywhere, and thus require various computationally expensive approximations [34, 41, 15, 39]. Second, even if the decision variables are continuous, the solution space (i.e., argmin ) may be discontinuous. Some papers [12, 17] discuss the fully continuous domain but typically involve computing the Jacobian matrix, which leads to scalability issues. Furthermore, in some cases, an explicit expression for the objective may not be given, and we may only have black-box access to the objective function, preventing straightforward end-to-end backpropagation.

These limitations motivate Landscape Surrogate losses ( LANCER ), a unified model for solving coupled learning and optimization problems. LANCER accurately approximates the behavior of the compound function f ◦ g , allowing us to use it to learn our target parametric mapping (see fig. 1). Intuitively, LANCER must be differentiable and smooth (e.g., neural nets) to enable exact and efficient gradient computation. Furthermore, we propose an efficient alternating optimization algorithm that jointly trains LANCER and the parameters of the target mapping. Our motivation is that training LANCER in this manner better distills task-specific knowledge, resulting in improved overall performance. Experimental evaluations (section 5) confirm this hypothesis and demonstrate the scalability of our proposed method.

The implementation of LANCER can be found at https://github.com/facebookresearch/ LANCER .

2 Related work

Smart Predict+Optimize framework considers settings where we want to train a target mapping which predicts latent components to an optimization problem to improve downstream performance. A straightforward and naive approach in P+O is to build the target machine learning model in a two-stage fashion: train the model on ground truth problem parameters using some standard measure of accuracy (e.g., mean squared error) and then use its prediction to solve the optimization problem. However, this approach is prone to produce highly suboptimal models [6, 41] since the learning problem does not capture the task-specific objectives. Instead, 'smart' Predict+Optimize (SPO) [13] proposed to minimize the decision regret, i.e., the error induced by the optimization solution based on the estimated problem parameters coming from the machine learning model. A variety of methods exist for learning such models in the continuous, and often convex, optimization setting. These approaches usually involve backpropagating through the solver [11, 12]. In some isolated and simple scenarios, an optimal solution exists [22], or the learning problem can be formulated via efficient surrogate losses [13]. Extending the SPO framework for combinatorial problems is challenging, and current methods rely on identifying heuristic gradients often via continuous, primal, or dual relaxations [33, 41, 34, 31, 39, 15, 28]. Alternative approaches leverage specific structures of the optimization problem [9, 21, 40], such as being solvable via dynamic programming or graph

partitioning. Further work focuses on SPO for individual problems Shah et al. [37], which collects perturbed input instances and learns a separate locally convex loss for each instance. In contrast, we define the loss over the domain rather than per instance, allowing for generalization to unseen instances, and our bilevel optimization formulation enables more efficient training. Moreover, compared to prior works, our method generically applies to a wider variety of problem settings, losses, and problem formulations. See Table 1 for a direct comparison of the requirements and capabilities for different approaches.

Mixed integer nonlinear programming (MINLP) LANCER can be considered as a solver for constrained combinatorial problems with nonlinear and nonconvex objectives (MINLP), a challenging class of optimization problems [4]. Apart from SurCo [16], which we will discuss in detail in section 3, specialized solvers exist that deal with various MINLP formulations [7, 1, 19]. These specialized solvers generally require an analytical form for the objective and cannot handle black-box objectives. Additionally, these methods are not designed to handle general-purpose large-scale problems without making certain approximations or using specialized modeling techniques, such as linearizing the objective function or applying domain-specific heuristics. Lastly, some previous work directly predicts solutions to economic dispatch problems [8], uses reinforcement learning to build solutions to linear combinatorial problems [23], or uses reinforcement learning for ride hailing problems [43]. These approaches are designed for specific application domains or are tailored to linear optimization settings where the reward for a single decision variable is its objective coefficient, which is not trivially applicable in nonlinear settings.

Optimization as a layer The optimization-as-a-layer family of methods considers the composition of functions where one (or more) of the functions is defined as the solution to a mathematical optimization problem [3, 2, 17, 18]. Since both P+O and SurCo can be formulated as a nesting of a target mapping with the argmin operator (i.e., optimization solver), one can leverage approaches from this literature. The core idea here is based on using the implicit function theorem to find necessary gradients and backpropagate through the solver. Similar concepts exist for combinatorial optimization [15, 39, 28, 31, 29], where gradient non-existence is tackled through improved primal or dual relaxations.

3 A Unified Training Procedure

In this work, we focus on solving the following optimization problems:

where f is the function to be optimized (linear or nonlinear), x ∈ Ω are the decision variables that must lie in the feasible region, typically specified by (non)linear (in)equalities and possibly integer constraints, and z ∈ Z is the problem description (or problem features). For example, if f is to find a shortest path in a graph, then x is the path to be optimized, and z represents the pairwise distances (or features used to estimate them) in the formulation.

Ideally, we would like to have an optimizer that can (1) deal with the complexity of the loss function landscape (e.g., highly nonlinear objective f , complicated and possibly combinatorial domain Ω ), (2) leverage past experience in solving similar problems, and (3) can deal with a partial information setting, in which only an observable problem description y can be seen but not the true problem description z when the decision is made at test time.

To design such an optimizer, we consider the following setting: assume that for the training instances, we have access to the full problem descriptions { z i } ⊆ Z , as well as the observable descriptions { y i } ⊆ Y , while for the test instance, we only know its observable description y test , but not its full description z test . Note that such a setting naturally incorporates optimization under uncertainty, in which a decision need to be made without full information, while the full information can be obtained in hindsight (e.g., portfolio optimization). Given this setting, we propose the following general training procedure on a training set D train := { ( y i , z i ) } N i =1 to learn a good optimizer:

Here g θ : Y ↦→ Ω is a learnable solver that returns a high quality solution for objective f directly from the observable problem description y i . θ are the learnable solver's parameters. Once g θ is learned, we can solve new problem instances with observable description y test by either calling x test = g θ ( y test ) to get a reasonable solution, or continue to optimize Eqn. 1 using x = x test as an initial solution.

Theoretically, if problem description z is fully observable (i.e., y = z ), the optimization oracle arg min x ∈ Ω f ( x ; z ) solves Eqn. 2. However, solving may be computationally intractable even with full information as in nonlinear combinatorial optimization.

Our proposed training procedure is general and covers many previous works that rely on either fully or partially observed problem information.

Smart Predict+Optimize (P+O) In this setting, f belongs to a specific function family (e.g., linear or quadratic programs). The full problem description z includes objective coefficients, but we only have access to noisy versions of them in y . Then the goal in P+O is to identify a mapping c θ (e.g. a neural net) so that a downstream solver outputs a high quality solution: g θ ( y ) = arg min x ∈ Ω f ( x ; c θ ( y )) . Here arg min x ∈ Ω f can often be solved with standard approaches, and the main challenge is to estimate the problem description accurately (w.r.t. eq. (2)). Note that other P+O formulations can be encompassed within our framework in eq. (2). For instance, the regret-based formulation described in SPO [13] can be represented as max ˆ z ∈ g θ ( y ) f (ˆ z ; z ) -f ∗ where f ∗ is the optimal loss that is independent of θ .

Learning surrogate costs for MINLP When f is a general nonlinear objective (but y = z is fully observed), computing arg min x ∈ Ω f also becomes non-trivial, especially if x is in combinatorial spaces. Such problems are commonly referred as mixed integer nonlinear programming (MINLP). To leverage the power of linear combinatorial solvers, SurCo [16] sets the learnable solver to be g θ ( y ) = arg min x ∈ Ω x ⊤ c θ ( y ) , which is a linear solver and does not include the nonlinear function f at all. Intuitively, this models the complexity of f by the learned surrogate cost c θ , which is parameterized by a neural network. Surprisingly, this works quite well in practice [16].

4 LANCER : Learning Lan ds c ap e Su r rogate Losses

Variations of training objective Eqn. 2 have been proposed to learn θ in one way or another. This includes derivative-based approaches discussed in section 2 as well as domain-specific methods that learn θ efficiently and avoid backpropagating through the solver, e.g., SPO+ [13].

While these are valid approaches, at each step of the training process, we need to call a solver to evaluate g θ , which can be computationally expensive. Furthermore, g θ is learned via gradient descent of Eqn. 2, which involves backpropagating through the solver. One issue of this procedure is that the gradient is non-zero only at certain locations (i.e., when changes in the coefficients lead to changes in the optimal solution), which makes the gradient-based optimization difficult.

One question arises: can we model the composite function f ◦ g θ jointly? The intuition here is that while g θ can be hard to compute, f ◦ g θ can be smooth to model, since f can be smooth around the solution provided by g θ . If we model f ◦ g θ locally by a landscape surrogate model M , and optimize directly on the local landscape of M , then the target mapping c θ can be trained without running expensive solvers:

Note that M directly depends on c θ (not on g θ ). Obviously, M cannot be any arbitrary function. Rather it should satisfy certain conditions: 1) capture a task-specific loss f ◦ g θ (not just f and not the solver g alone, but jointly); 2) be differentiable and smooth. Differentiability allows us to train our target model c θ in end-to-end fashion (assuming c is itself differentiable). The primary advantage is that we can avoid backpropagating through the solver or even through f (e.g., multiarmed bandits). Moreover, M w is typically high dimensional (e.g., a neural net) and potentially can make the learning problem for c θ much easier. The question is how to obtain such a model M ? One

way is to parameterize it and formulate the learning problem:

The main motivation for this bi-level optimization formulation is that the surrogate model M w is not concerned to be accurate for all possible c θ ; rather, we are interested in finding the configuration of M w that yields the closest approximation to f ◦ g near θ ∗ . In other words, M w serves as a surrogate loss that approximates L at a certain landscape : M w ( Y, Z ; θ ∗ ) ∼ L ( Y, Z ; θ ∗ ) . By adopting the bi-level optimization framework, we can focus on learning accurate M w for such θ ∗ .

It is important to note that evaluating f ◦ g depends on both c θ ( y i ) and z i (see eq. (2)). Therefore, to construct an accurate surrogate model M w that can effectively approximate f ◦ g , it is essential for M w to take into consideration the influence of both inputs.

To solve eq. 4, one could apply established methods from the bi-level optimization literature, such as [17, 42]. However, majority of them still rely on ∇ θ L (or even ∇ 2 θ ), which involves differentiating through the solver. To overcome this issue, we propose a simple and generic Algorithm 1, which is based on alternating optimization (high-level idea is depicted in fig. 1). The core idea is to simultaneously learn both mappings ( M w and c θ ) to explore different solution spaces. By improving our target model c θ , we obtain better estimates of the surrogate loss around the solution, and a better estimator M w leads to better optimization of the desired loss L . The use of alternating optimization helps both mappings reach a common goal. Furthermore, similarly flavored alternating optimization techniques were found to be successful in other problems with non-differentiable nature [44, 45].

In practice, the 'inner' optimization (lines 10 and 12) does not have to be done 'perfectly'. In our approach, we perform a fixed (smaller) number of updates; that is, we do not precisely solve the minimization for both M w and c θ . For example, most experiments use 10-20 updates per t . One potential reason is that we do not want the models to overfit to the data; instead, we increase the total number of outer loop T . We discuss this further in the experimental setup.

Note that the Algorithm 1 avoids backpropagating through the solver or even through f . The only requirement is evaluating the function f at the solution of g , which can be achieved by blackbox solver access. As a result, this approach eliminates the complexity and computational expense associated with computing derivatives of combinatorial solvers, making it a more efficient and practical solution as shown in Table 1.

It is worth noting that our framework shares similarities with actor-critic reinforcement learning [24]. In this analogy, we can think of c θ as an actor responsible for making certain decisions, like predicting coefficients. On the other hand, M w plays the role of a critic which evaluates the actor's decisions by estimating the objective value f , and provides feedback to the actor.

Similar to many other approaches designed for solving problems with bi-level optimizations, including actor-critic algorithms, we currently lack theoretical guarantees regarding the convergence of LANCER with respect to either M w or c θ . This lack of guarantees can also impact the stability of the algorithm. However, this is primarily a matter that can be addressed through empirical investigation and depends on various factors, which is typical in the process of model selection. In Appendix E, we present ablation studies that we conducted to evaluate the stability of our approach across various hyperparameters and neural network architectures. These, along with our main experimental results in section 5, demonstrate that LANCER generally exhibits robustness in many cases.

4.1 Reusing landscape surrogate model M w

Once Algorithm 1 finishes, we usually discard M w as it is an intermediate result of the algorithm, and we only retain c θ (and solver g ) for model deployment. However, we have found through empirical exploration that the learned surrogate loss M w can be reused for a range of problems, increasing the versatility of the approach. This is particularly advantageous for SurCo setting, where we handle one instance at a time. In this scenario, we utilize the trained M w for unseen test instances by executing only the θ -step of Algorithm 1. The main advantage of this extension is that it eliminates the need for access to the solver g , leading to significant deployment runtime improvements.

4.2 Reusing past evaluations of f ◦ g θ

In LANCER , the learning process of M w is solely reliant on D and is independent of the current state of c θ . Put simply, to effectively learn M w , we only need the inputs and outputs of f ◦ g θ , namely c θ ( y i ) , Z , and the corresponding objective value ˆ f . Interestingly, we can cache the predicted descriptions themselves, c θ ( y i ) , without the need for the model θ or problem information. This caching mechanism allows us to reuse the data ( c θ ( y i ) , z , ˆ f ) from previous iterations ( 1 . . . T -1 ) as-is. By adopting this practice, we enhance and diversify the available training data for M w , which proves particularly advantageous for neural networks. This concept bears resemblance to the concept of a replay buffer [27] commonly found in the literature on Reinforcement Learning.

5 Experiments

We validate our approach ( LANCER ) in two settings: smart predict+optimize and learning surrogate costs for MINLP. For each setting, we study a range of problems, including linear, nonlinear, combinatorial, and others, encompassing both synthetic and real-world scenarios. Overall, LANCER exhibits superior or comparable objective values while maintaining efficient runtime . Additionally, we perform ablation studies, such as re-using M .

5.1 Synthetic data

5.1.1 Combinatorial optimization with linear objective

The shortest path (SP) and multidimensional knapsack (MKS) are both classic problems in combinatorial optimization with broad practical applications. In this setting, we consider a scenario where problem parameters z , such as graph edge weights and item prices, cannot be directly observed

Shortest Path

17.5

(%)

15.0

Regret(

12.5

Normalized

10.0

7.5

5.0

2.5

0.0

2stg

SPO+

DBB

LODLS

LANCER

Multidimensional Knapsack

60

169

Normalized Regret (%)

50

40

30

20

10

2stg

SPO+

DBB

LODLS

LANCER

during test time, and instead need to be estimated from y via learnable mapping z = c θ ( y ) . That is, we consider smart P+O setting.

Setup We use standard linear program (LP) formulation for SP and mixed integer linear program (MILP) formulation for MKS. Observed features y and the corresponding ground truth problem descriptions z for SP are generated using the same procedure as in [38]: grid size of 5 × 5 , feature dimension of y ∈ R 5 (obtained using a random linear mapping from z ), 1000 instances for both train and test. For MKS, we increased the knapsack dimension to 5 and capacity to 45, and we set the number of items to 100. Moreover, we use randomly initialized MLP (1 ReLu hidden layer) to generate features of dimension y ∈ R 256 . As for the baselines, apart from the naive 2-stage approach, we have SPO+ [13] and DBB [34], both implemented in PyEPO [38] library. Furthermore, we added LODLs, a novel method from Shah et al. [37]. We explored as best as we could all important hyperparameters for all methods on a fixed cross-validation set. Regarding the LANCER , we utilize MLP with 2 tanh hidden layers of size 200 for surrogate model M . We set T = 10 and the number of updates for M and c θ is at most 10. We use SCIP [1] to solve LP for the shortest path and MILP for knapsack. Further details can be found in Appendix C.1.1.

Results The results are summarized in fig. 2. We report the normalized regret as described in [38]. The findings indicate that LANCER and SPO+ consistently outperform the two-stage baseline, particularly when considering the warm start. As SPO+ is specifically designed for linear programs, it provides informative gradients, making it a robust baseline. Even in MKS, where theorems proposed in [13] are no longer applicable, SPO+ performs decently with minimal tuning effort. The DBB approach, however, demonstrates unsatisfactory default performance but can yield favorable outcomes with proper initialization and tuning (see the right plot). Interestingly, the other P+O baselines, initialized randomly, were unable to outperform a naive 2stg in both benchmarks.

LANCER achieves superior performance in both tasks, with a noticeable advantage in MKS. This may be attributed to the high dimension of the MKS problem and the large feature space ( y ). One possible explanation is that the sparse gradients of the derivative-based method make the learning problem harder, whereas LANCER models the landscape of f ◦ g , providing informative gradients for c θ .

5.1.2 Combinatorial optimization with nonlinear objective

In this section, we apply LANCER for solving mixed integer nonlinear programs (MINLP). Specifically, we transform a combinatorial problem with a nonlinear objective into an instance of MILP via learning linear surrogate costs as described in Ferber et al. [16]. Note that in this setting, we assume that the full problem description y = z is given and fully observable (in contrast to the P+O setting).

We begin by examining on-the-fly optimization, where each problem is treated independently. In this scenario, the cost vector c θ ( y ) simplifies to a constant value c . SurCo is then responsible for directly training the cost vector c of the linear surrogate. As we lack a distribution of problems to train M , specific adaptations to Algorithm 1 are necessary, which are outlined in detail in Appendix B. We refer to this version as LANCER -zero to be consistent with SurCo-zero.

0.56

Domain Heuristic

Probability

0.54

0.52

0.519

0.53

0.535 0.534

SCIP

SurCo-zero

LANCER-zero

0.496

0.50

0.48

0.50.499

Time

0.48

0.458 0.465 0.464

0.46

0.443

0.44

0.42

0.40

LooseDeadline

Normal Deadline

Tight Deadline

Settings

0.60

Time Probability

0.55

0.527

0.554

0.556

0.50

0.494

0.497

0.458

uo

0.45

0.437

0.434

0.40

0.389

outoftime

0.35

LooseDeadline

Normal Deadline

Tight Deadline

Settings

Setup Nonlinear shortest path problems arise when the objective is to maximize the probability of reaching a destination before a specified time in graphs with random edges [26, 14]. The problem formulation is similar to the standard linear programming (LP) formulation of the shortest path, as described in section 5.1.1, with a few adjustments: 1) the weight of each edge follows a normal distribution, i.e., w e ∼ N ( µ e , σ e ) ; 2) the objective is to maximize the probability that the sum of weights along the shortest path is below a threshold W , which can be expressed using the standard Gaussian cumulative distribution function (CDF), P ( ∑ e ∈ E w e ≤ W ) = Φ ( ( W -∑ e ∈ E µ e ) / √∑ e ∈ E σ e ) where E is the set of edges belonging to the shortest path. We use 5 × 5 and 15 × 15 grid graphs with 25 draws of edge weights. We set the threshold W to three different values corresponding to loose, normal, and tight deadlines. The remaining settings are adapted from Ferber et al. [16], and additional details can be found in Appendix C.1.2.

Results Fig. 3 illustrates the performance of different methods in both grid sizes. SCIP directly formulates the MINLP to maximize the CDF, resulting in an optimal solution. However, this approach is not scalable for larger problems and is limited to smaller instances like the 5 × 5 grid. The heuristic method assigns each edge weight as w e = µ e + γσ e , where γ is a user-defined hyperparameter, and employs standard shortest path algorithms (e.g., Bellman-Ford). As the results indicate, this heuristic approach produces highly suboptimal solutions. SurCo-zero and LANCER -zero demonstrate similar performance, with LANCER -zero being superior in almost all scenarios.

5.2 Real-world use case: quadratic and broader nonlinear portfolio selection

5.2.1 The quadratic programming (QP) formulation

In this study, we tackle the classical quadratic Markowitz [30] portfolio selection problem. We use realworld data from Quandl [35] and follow the setup described in Shah et al. [37]. The prediction task leverages each stock's historical data y to forecast future prices z , which are then utilized to solve the QP (i.e., P+O setting). The predictor is the MLP with 1 hidden layer of size 500.

Setup We follow a similar setup described in [37], except for a fix in the objective's quadratic term that slightly affects the decision error's magnitude. More details can be found in Appendix C.2.1. We compare LANCER against

two-stage and LODLs. However, SPO+ is not applicable in this nonlinear setting, and DBB's performance is notably worse since it is designed for purely combinatorial problems. Additionally, we report the optimal solution (using the ground truth values of z ) and the (Melding Decision Focused Learning) MDFL [41] method, which leverages the implicit function theorem to differentiate through the KKT conditions. For our LANCER implementation, we use an MLP with 2 hidden layers for M

and update each of the parametric mappings 5 times per iteration with a total of T = 8 iterations. We use cvxpy [10] to solve the QP.

Results Table 2 summarizes our results. We report the normalized decision loss (i.e., normalized Eqn. (2)) on test data. Since the problem is smooth and exact gradients can be calculated, MDFL achieves the best performance closely followed by the LANCER . The remaining results are in agreement with [37]. While LANCER does not achieve the best overall performance, it does so using a significantly smaller number of calls to a solver, as we discuss in more detail in Section 5.3.

5.2.2 Combinatorial portfolio selection with third-order objective

The convex portfolio optimization problem discussed in the previous section 5.2.1 is unable to capture desirable properties such as logical constraints [5, 15], or higher-order loss functions [20] that integrate metrics like co-skewness to better model risk. We use the Quandl [35] data (see Appendix C.2.2 for details on setup) and similar to section 5.1.2, we assume that the full problem description z is given at train/test time.

Results are shown in fig. 4. We first tried to solve the given MINLP exactly via SCIP. However, it fails to produce the optimal solution within a 1 hour time limit and we report the best incumbent feasible solution. MIQP (blue squares) and MILP (blue triangles) approximations overlook the co-skewness and non-linear terms, respectively. Comparing their performance, MIQP exhibits a 2 × lower loss than the MILP baseline but in a significantly longer

0.025

0.000

-0.025

100

500

1000

Objective

-0.050

random

O

LANCER-zero

20

-0.075

T

LANCER-prior

-0.100

MILP

+

MIQP

-0.125

工H

MINLP-approx

40

-0.150

SurCo-prior

SurCo-zero

100

-0.175

100

101

102

103

Deployment Runtime (s)

runtime. For LANCER and SurCo, we present results for two scenarios: learning the linear cost vector c directly ( zero ) for each instance, and a parameterized version c θ ( z ) ( prior ). The main distinction of 'prior' is that no learning occurs during test time, as we directly map the problem descriptor z to a linear cost vector and solve the MILP. Consequently, the deployment runtime is similar to that of the MILP approximation, but LANCER -prior produces slightly superior solutions. Remarkably, LANCER -zero achieves significantly better loss values, surpassing all other methods. Although it takes longer to run, the runtime remains manageable, and importantly, the solution quality improves with an increasing number of iterations.

According to our experimental findings, LANCER demonstrated the most substantial improvement in this specific setting. Encouraged by this success, we conducted a deeper exploration of the complexities of this problem, as detailed in Appendix D.

5.3 Computational efficiency

Comparing baseline methods, including LANCER , we find that querying solver g θ is the primary computational bottleneck. To evaluate this aspect, we empirically analyze different algorithms on various benchmarks in the P+O domain. The results, depicted in fig. 5, highlight that LODLs require sampling a relatively large number of points per training instance, leading to potentially time-consuming solver access. On the other hand, gradient-based methods like DBB, MDFL, and SPO+ typically solve the optimization problem 1-2 times per update but require more iterations to converge. In contrast, LANCER accesses the solver in the w -step, with the number of accesses proportional to the training set size and a small total number of alternating optimization iterations. Moreover, we leverage saved solutions from previous iterations, akin to a replay buffer, when fitting M . These combined factors allow us to achieve favorable results with a small value of T .

Multidimensional Knapsack

Portfolio Optimization

53

DBB

10

0.56

500

MDFL

SPO+

LODLS

Normalized Regret (%)

51

52

LODLS

LANCER

100

Normalized Decision Loss(

0.55

0.54

35

ik

LANCER

50k

50

0.53

10

49

20

0.52

90

48

10

0.51

47

0.50

200

103

104

105

106

103

104

105

106

107

Number of calls to BB solver

5.4 Reusing landscape surrogate M w

In this scenario, we introduce a dependency of M w on both the predicted linear cost ( c ) and the problem descriptor ( y ), as described in section 4.1. This enables us to reuse M w for different problem instances without retraining, and eliminate the dependency on the solver g θ , giving LANCER a substantial runtime acceleration. To validate this hypothesis, we pretrain M w using 200 instances of the stochastic shortest path on a 15 × 15 grid by providing concatenated ( c , y ) as input. We apply LANCER -zero to the same test set as before and present results in fig. 3, demonstrating comparable performance between these two approaches, with 'reused M w ' being much faster.

6 Conclusion

This paper makes a dual contribution. Firstly, we derive a unified training procedure to address various coupled learning and optimization settings, including smart predict+optimize and surrogate learning. This is significant as it advances our understanding of learning-integrated optimization under partial information. Secondly, we propose an effective and powerful method called LANCER to tackle this training procedure. LANCER offers several advantages over existing literature, such as versatility, differentiability, and efficiency. Experimental results validate these advantages, leading to significant performance improvements, especially in high-dimensional spaces, both in problem description and feature space. One potential drawback is the complexity of tuning M , requiring model selection and training. However, future research directions include addressing this drawback and exploring extensions of LANCER , such as applying it to fully black box f scenarios.

Acknowledgments and Disclosure of Funding

The research at the University of Southern California was supported by the National Science Foundation (NSF) under grant number 2112533. We also thank the anonymous reviewers for helpful feedback.

References

T. Achterberg. SCIP: Solving constraint integer programs. Mathematical Programming Computation , 1(1):1-41, July 2009. ISSN 1867-2957. doi: 10.1007/s12532-008-0001-1.

A. Agrawal, B. Amos, S. Barratt, S. Boyd, S. Diamond, and J. Z. Kolter. Differentiable convex optimization layers. In H. Wallach, H. Larochelle, A. Beygelzimer, F. d'Alché Buc, E. Fox, and R. Garnett, editors, Advances in Neural Information Processing Systems (NEURIPS) , volume 32, pages 9562--9574. MIT Press, Cambridge, MA, 2019.

B. Amos and J. Z. Kolter. Optnet: Differentiable optimization as a layer in neural networks. In D. Precup and Y. W. Teh, editors, Proc. of the 34th Int. Conf. Machine Learning (ICML 2017) , pages 136--145, Sydney, Australia, Aug. 6-11 2017.

P. Belotti, C. Kirches, S. Leyffer, J. Linderoth, J. Luedtke, and A. Mahajan. Mixed-integer nonlinear optimization. Acta Numerica , 22:1-131, May 2013.

D. Bertsimas, C. Darnell, and R. Soucy. Portfolio construction through mixed-integer programming at grantham, mayo, van otterloo and company. Interfaces , 29:49-66, 1999.

A. Beygelzimer and J. Langford. The offset tree for learning with partial labels. In Proc. of the 15th ACM SIGKDD Int. Conf. Knowledge Discovery and Data Mining (SIGKDD 2009) , Paris, France, June 28 -July 1 2009.

S. Burer and A. N. Letchford. Non-convex mixed-integer nonlinear programming: A survey. Surveys in Operations Research and Management Science , 17(2):97-106, 2012. ISSN 18767354.

W. Chen, S. Park, M. Tanneau, and P. Van Hentenryck. Learning optimization proxies for large-scale security-constrained economic dispatch. Electric Power Systems Research , 213: 108566, 2022.

E. Demirovi´ c, P. J. Stuckey, J. Bailey, J. Chan, C. Leckie, K. Ramamohanarao, and T. Guns. Dynamic programming for Predict+Optimise. In Proceedings of the AAAI Conference on Artificial Intelligence , 2020.

S. Diamond and S. Boyd. CVXPY: A Python-embedded modeling language for convex optimization. Journal of Machine Learning Research , 17(83):1-5, 2016.

J. Domke. Generic methods for optimization-based modeling. In N. Lawrence and M. Girolami, editors, Proc. of the 15th Int. Conf. Artificial Intelligence and Statistics (AISTATS 2012) , La Palma, Canary Islands, Spain, Apr. 21-23 2012.

P. Donti, B. Amos, and J. Z. Kolter. Task-based end-to-end model learning in stochastic optimization. In I. Guyon, U. v. Luxburg, S. Bengio, H. Wallach, R. Fergus, S. Vishwanathan, and R. Garnett, editors, Advances in Neural Information Processing Systems (NIPS) , volume 30, pages 1320-1332. MIT Press, Cambridge, MA, 2017.

A. N. Elmachtoub and P. Grigas. Smart 'predict, then optimize'. arXiv:1710.08005, Oct. 22 2017.

Y. Y. Fan, R. E. Kalaba, and J. E. Moore. Arriving on time. Journal of Optimization Theory and Applications , 127(1):497--513, Dec. 2005. doi: 10.1007/s10957-005-7498-5.

A. Ferber, B. Wilder, B. Dilkina, and M. Tambe. MIPaaL: Mixed integer program as a layer. In AAAI Conference on Artificial Intelligence (AAAI 2020) , 2020.

A. Ferber, T. Huang, D. Zha, M. Schubert, B. Steiner, B. Dilkina, and Y. Tian. Surco: Learning linear surrogates for combinatorial nonlinear optimization problems. arXiv:2210.12547, Oct. 22 2022.

S. Gould, B. Fernando, A. Cherian, P. Anderson, R. S. Cruz, and E. Guo. On differentiating parameterized argmin and argmax problems with application to bi-level optimization. arXiv:1607.05447, July 21 2016.

S. Gould, R. Hartley, and D. Campbell. Deep declarative networks: A new hope. arXiv:1909.04866, Sept. 11 2019.

Gurobi. Gurobi optimizer reference manual, 2019.

C. R. Harvey, J. C. Liechty, M. W. Liechty, and P. Muller. Portfolio selection with higher moments. Quantitative Finance , 10:469-485, 2010.

X. Hu, J. C. Lee, J. H. Lee, and A. Z. Zhong. Branch & learn for recursively and iteratively solvable problems in predict+optimize. arXiv:2205.01672, May 01 2022.

Y.-h. Kao, B. Roy, and X. Yan. Directed regression. In Advances in Neural Information Processing System , 2022.

E. Khalil, H. Dai, Y. Zhang, B. Dilkina, and L. Song. Learning combinatorial optimization algorithms over graphs. Advances in neural information processing systems , 30, 2017.

V. R. Konda and J. N. Tsitsiklis. Actor-critic algorithms. In Advances in Neural Information Processing System , 1999.

B. Korte and J. Vygen. Combinatorial Optimization: Theory and Algorithms . Number 21 in Algorithms and Combinatorics. Springer-Verlag, sixth edition, 2018.

S. Lim, C. Sommer, E. Nikolova, and D. Rus. Practical route planning under delay uncertainty: Stochastic shortest path queries. In Robotics: Science and Systems VIII , pages 249-256, 2012. doi: 10.15607/RSS.2012.VIII.032.

L.-J. Lin. Self-improving reactive agents based on reinforcement learning, planning and teaching. Machine Learning , 8:293--321, 1992.

J. Mandi, P. J. Stuckey, T. Guns, et al. Smart predict-and-optimize for hard combinatorial optimization problems. In Proceedings of the AAAI Conference on Artificial Intelligence , volume 34, pages 1603-1610, 2020.

J. Mandi, V. Bucarey, M. M. K. Tchomba, and T. Guns. Decision-focused learning: Through the lens of learning to rank. In International Conference on Machine Learning , pages 14935-14947. PMLR, 2022.

H. Markowitz. Portfolio selection. J. of Finance , 7(1):77-91, Mar. 1952.

M. Niepert, P. Minervini, and L. Franceschi. Implicit mle: backpropagating through discrete exponential family distributions. Advances in Neural Information Processing Systems , 34: 14567-14579, 2021.

J. Nocedal and S. J. Wright. Numerical Optimization . Springer Series in Operations Research and Financial Engineering. Springer-Verlag, New York, second edition, 2006.

A. Paulus, M. Rolínek, V. Musil, B. Amos, and G. Martius. Comboptnet: Fit the right np-hard problem by learning integer programming constraints. arXiv:2105.02343, May 12 2021.

M. V. Poganˇ ci` c, A. Paulus, V. Musil, G. Martius, and M. Rolinek. Differentiation of blackbox combinatorial solvers. In Proc. of the 8th Int. Conf. Learning Representations (ICLR 2020) , Addis Ababa, Ethiopia, Apr. 26-30 2020.

Quandl. Wiki various end-of-day data, 2022. URL https://www.quandl.com/data/WIKI .

N. V. Sahinidis. BARON 21.1.13: Global Optimization of Mixed-Integer Nonlinear Programs, User's Manual, 2017.

S. Shah, K. Wang, B. Wilder, A. Perrault, and M. Tambe. Decision-focused learning without decision-making: Learning locally optimized decision losses. In Advances in Neural Information Processing System , pages 1320-1332, 2022.

B. Tang and E. B. Khalil. Pyepo: A pytorch-based end-to-end predict-then-optimize library for linear and integer programming. arXiv:2206.14234, June 28 2022.

P.-W. Wang, P. Donti, B. Wilder, and Z. Kolter. Satnet: Bridging deep learning and logical reasoning using a differentiable satisfiability solver. In International Conference on Machine Learning , pages 6545-6554. PMLR, 2019.

B. Wilder, E. Ewing, B. Dilkina, and M. Tambe. End to end learning and optimization on graphs. In Advances in Neural and Information Processing Systems , 2019.

B. Wilder, B. Dilkina, and M. Tambe. Melding the data-decisions pipeline: Decision-focused learning for combinatorial optimization. In AAAI Conference on Artificial Intelligence (AAAI 2020) , 2020.

M. Ye, B. Liu, S. Wright, P. Stone, and Q. Liu. Bome! bilevel optimization made easy: A simple first-order approach. In Advances in Neural Information Processing System , 2022.

E. Yuan, W. Chen, and P. Van Hentenryck. Reinforcement learning from optimization proxy for ride-hailing vehicle relocation. Journal of Artificial Intelligence Research , 75:985-1002, 2022.

A. Zharmagambetov and M. Á. Carreira-Perpiñán. Learning interpretable, tree-based projection mappings for nonlinear embeddings. In International Conference on Artificial Intelligence and Statistics , pages 9550-9570, 2022.

A. Zharmagambetov and M. Á. Carreira-Perpiñán. Semi-supervised learning with decision trees: Graph Laplacian tree alternating optimization. In Advances in Neural Information Processing System , 2022.

A Computational complexity

It is quite straightforward to estimate the runtime of our approach from Algorithm 1 in the main paper. Let us denote I g as the time to get the solution from solver g ( y i ) . Also, let I w and I θ be the runtime of training the parametric loss M w and the target model c θ , respectively. Then, assuming evaluating f is negligible, one iteration of our algorithm naively takes O ( N · I g + I w + I θ ) , so the total runtime is O ( T · N · I g + T · I w + T · I θ ) . In practice, we iterate at most 100 times ( T < 100 ). Therefore, the main bottleneck is O ( T · N · I g ) , which is mainly overtaken by an access to g . Although we claim that leveraging M to learn θ is efficient, we admit that there is still a requirement to access the solver g .

However, there are several accelerations that can be made:

O ( N · I g ) is embarrassingly parallel computation since each request to g is independent and, additionally, subsampling on D train can be performed.

We can 'warm start' the solver g from solutions obtained in t -1 , which typically yields faster convergence.

Although we did not test this, but one can 'early stop' the solver g if it is too costly to solve optimally (e.g. large scale MILP). Our hypothesis is that it is enough to obtain a feasible solution ˆ x in certain neighborhood of x ∗ . Since we are still able to evaluate f and ( f (ˆ x ) , ˆ c , z ) is a 'valid' tuple, we can use it to train M w .

Moreover, we empirically found out that the supervised learning steps (lines 10 and 12) do not require 'perfect' learning. That is, we perform several gradient updates over w and θ , which significantly reduces I w and I θ .

B Pseudocodes

Algorithms 2-4 below closely resemble the Algorithm 1 in the main paper. However, there are minor variations that depend on the problem setting, whether it involves learning linear surrogates for MINLP or smart Predict+Optimize setting.

Algorithm 2 Pseudocode for learning LANCER and target model c θ for smart Predict+Optimize setting. Note: y - input (always observed) features, z - ground truth problem descriptions (available at train time only).

Algorithm 3 Pseudocode for learning linear surrogates with LANCER -zero (used in sections 5.1.2 and 5.2.2). Note that y = z in this setting and we have only one optimization problem instance.

Algorithm 4 Pseudocode for learning linear surrogates with LANCER -prior (used in section 5.2.2): we learn c θ on a distribution of optimization problems. Note that y = z in this setting

C Details of experimental setup

C.1 Synthetic data

C.1.1 Combinatorial optimization with linear objective

Data We follow the setup and scripts from PyEPO [38] library to generate data.

For SP, we follow the same data generation process as in the original scripts: 5 × 5 grid (40 total edges), 1000 training problem instances with 5 input features (i.e., Y ∈ R 1000 × 5 ) and the same for the test set. Input features ( y ) are generated using normal distribution with N ( 0 , 1 ) . The ground truth descriptors z are obtained by first randomly and linearly projecting y in 40 dimensions followed by nonlinearity (polynomial of degree 6 and normalization). Lastly, random noise is added to z to make the problem harder. We use the standard linear program (LP) formulation of the shortest path and implement solver g in SCIP [1].

As for MKS, we begin by generating a cost vector for each item using a random uniform distribution between 0 and 5. Then, we obtain features y by passing z through a random neural network with one hidden layer of size 500 and tanh activation. Knapsack capacity is 40, knapsack dimension is 5, 100 total items to choose from, feature dimension is 256 and there are 1000 instances in both train/test. Lastly, weight for each item is generated

θ

;

according to the uniform distribution between 0 and 1. We use the standard mixed-integer linear program (MILP) formulation of the multidimensional knapsack and implement solver g in SCIP [1].

Target mapping c θ All baselines use the same target mappings for each problem: linear mapping for SP and MLP with 1 hidden layer for MKS (size of 300 and tanh activation).

LANCER The training procedure closely follows Algorithm 2. Other problem dependent settings are as follows:

For SP, LANCER uses MLP with 2 hidden layers of size 100 (tanh activation). We train LANCER for T = 10 iterations. At each iteration, we make 5 updates (using Adam optimizer with lr = 0 . 001 ) for each mappings ( c θ and M w ).

For MKS, LANCER uses MLP with 2 hidden layers of size 200 (tanh activation). We train LANCER for T = 7 iterations. At each iteration, we perform 5 updates (using Adam optimizer with lr = 0 . 001 ) for c θ and 10 updates for M w .

Baselines

SPO+,DBB: We use the versions implemented within PyEPO and set the number of epochs to 25. Both methods use the Adam optimizer with learning rates tuned for each problem. Other arguments follow the default setting suggested by authors.

LODLs: We use the implementation provided by authors in [37]. We set the number of sampling points to 1000 and employ 'random Hessian' version of the algorithm. Other arguments follow the default setting suggested by authors.

C.1.2 Combinatorial optimization with nonlinear objective

We aim to solve the following optimization problem with nonlinear objective:

where Φ is the standard Gaussian cumulative distribution function (CDF), E is the set of all edges, W is the user-defined threshold, µ u,v and σ u,v are the mean and the variance of the corresponding edge's weight.

Data We closely follow the data generation process described in [16]. Specifically, each edge is a random variable with µ coming from the uniform distribution (between 0 . 1 and 0 . 2 ); and with σ is also generated uniformly randomly (between 0 . 1 and 0 . 3 multiplied by 1 -µ ). For thresholds W , we set them as follows: calculate the distance of the shortest path distance using the mean value as an edge weight and multiply it to 0 . 9 for tight, 1 . 0 for normal and 1 . 1 for loose deadlines, respectively. We set the number of problem instances to 25 and use the Bellman-Ford algorithm for a solver g .

LANCER The training procedure closely follows Algorithm 3. We use MLP with 2 hidden layers of size 200 (300 for 15 × 15 grid size) and tanh activation. We train LANCER for T = 40 iterations. At each iteration, we make 10 updates (using Adam optimizer) for each learnable models ( c and M w ).

Baselines

SCIP attempts to solve the original MINLP defined in Eqn. (5). We set the maximum time limit to 30 min before terminating the solver.

Domain Heuristic simply assigns each edge's weight as w e = µ e + γσ e (where γ is a hyperparameter) and run the Bellman-Ford's algorithm.

SurCo [16] replicates the same experimental setup as described in the original paper. Specifically, we use DBB [34] to differentiate through the solver with λ = 1000 and apply Adam optimizer for 40 epochs with the learning rate = 0 . 1 .

C.2 Real-world use case: quadratic and broader nonlinear portfolio selection

C.2.1 The quadratic programming (QP) formulation

We use the standard quadratic program formulation of the Markowitz' [30] portfolio selection problem:

where µ is an expected return vector for each portfolio and G is the covariance matrix. We set the user-defined hyperparameter α = 0 . 1 in all experiments and use CvxPy [10] to solve QP in eq. (6).

Data We reuse the code from Shah et al. [37] to generate data (downloaded from QuandlWIKI [35]) and use the same setup. The features y are historical stock prices and the task is to predict an expected return µ (using MLP with 1 hidden layer of size 500) in smart Predict+Optimize fashion. There are 200 instances in train/validation set and 400 instances in test set. The number of portfolios in each instance is 50.

LANCER The training procedure closely follows Algorithm 2. We use MLP with 2 hidden layers of size 100 and tanh activation. We train LANCER for T = 8 iterations. At each iteration, we make 10 updates (using Adam optimizer) to fit each mapping ( c θ and M w ).

Baselines

LODLs: We use the implementation provided by authors in [37]. We replicate their configurations for this experiment, except we made a quick fix in the code as they forgot to add a matrix transpose in the quadratic term.

MDFL (Melding Decision Focused Learning) [41]: we use the version implemented in [37] and follow their configurations.

C.2.2 Combinatorial portfolio selection with third-order objective

We extend the portfolio selection problem in eq. (6) as follows:

where S is co-skewness matrix and v is the binary variables to enforce discrete constraints (e.g. hard limit on number of portfolios). We also introduce the initial portfolio selection vector x 0 (generated uniformly at random) and enforce our final solution to be close to it (via γ ). We set the penalty on co-skewness as β = 0 . 5 , γ = 0 . 01 , m = 3 , M = 10 , f min = 0 . 01 and f max = 0 . 2 throughout all

experiments. We reuse the same data as in section C.2.1 but increase the number of portfolios to 100 and add co-skewness matrix S to it. Note that in this task we assume that all problem descriptors are fully observed (e.g. µ , G , S ).

LANCER The training procedure for LANCER -zero closely follows Algorithm 3 and LANCER -prior closely follows Algorithm 4. We use MLP with 2 hidden layers of size 300 and tanh activation. We train LANCER for T = 40 iterations. At each iteration, we perform 10 updates (using Adam optimizer) for each learnable models ( c θ and M w ). Additionally, LANCER -prior uses a parametric mapping for c θ which is implemented via 1 hidden layer MLP of size 500, which µ takes as input.

Baselines

SCIP attempts to solve the problem defined in Eqn. (7) in three different settings related to the objective: ignores all nonlinear terms (MILP), ignores cubic term (MIQP) and attempts to solve the original nonlinear problem (MINLP). We set the maximum time limit to 60 min before terminating the solver and obtaining the best solution.

For SurCo [16], we use two versions: SurCo-prior and SurCo-zero. SurCo-prior uses the same mapping for c θ as LANCER described above. We use DBB [34] to differentiate through the solver with λ = 100 and apply Adam optimizer for 100 epochs with the learning rate = 0 . 1 ( 0 . 0001 for prior).

D Combinatorial portfolio selection with third-order objective

Based on our experimental findings, LANCER showcased the most significant improvement in addressing the combinatorial portfolio selection problem. Inspired by this success, we delved further into the intricacies of this problem and sought to visualize the actual solutions obtained by the two best-performing methods: SurCo and LANCER . We present the results for a randomly selected instance in Figure 6.

We have assigned a symbol of a corresponding S&P company to each point for clarity. On the Y-axis, we represent the expected return of a selected stock, which is multiplied by its fraction ( approximate solution x in Eqn. (7)). Similarly, the X-axis displays the 'risk -skewness score' calculated as follows: α x ⊙ ( Gx ) -β x ⊙ ( Sx ⊗ x ) , where ⊙ denotes element-wise multiplication. This computation results in a vector of dimensions equal to the number of stocks, enabling us to interpret it as a score assigned to each stock. Furthermore, the combinatorial constraints outlined in Eqn. (7) enforce the selection of a maximum of M stocks with fractions lower than or equal to f max.

As we try to maximize the return and minimize the risk -skewness score, we want all points to be in the upper-left corner. This is what LANCER achieves. It is interesting to see that LANCER chooses the less number of portfolios (6 vs 9) but assigns higher fraction to them improving overall objective.

E Stability of LANCER

Similar to many other approaches designed for solving problems with bi-level optimizations, including actor-critic algorithms, we currently lack theoretical guarantees regarding the convergence of LANCER with respect to either M w or c θ . This lack of guarantees can also impact the stability of the algorithm. However, this is primarily a matter that can be addressed through empirical investigation and depends on various factors, which is typical in the process of model selection. Nevertheless, we have observed that LANCER generally exhibits robustness in many cases. As an evidence, we performed additional experiments on nonlinear shortest path problem (section 5.1.2). In the two tables below we demonstrate that the final objective does not fluctuate significantly when we experiment with different combinations of hyperparameters and variations of neural net architecture. We will leave more ablation studies as the future work.

OMLL

LANCER-zero

SurCo-zero

0.014-

TECH

AEE

SIVB

SIVB

0.012

0.010

eturn

AEE

0.008

BK

0.006

QCOM

0.004

EBAY

0.002

PHM

DTECH

M

0.000

-0.04

-0.03

-0.02

-0.01

0.00

0.01

risk - skewness

Peer reviews:
{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThis paper considers the class of problems known as Smart Predict and Optimize (or Decision-Focused Learning) where the learning task consists in learning the parameters of an optimization model given some of their features. The difficulty comes from trying to include the optimization model into the learning pipeline, since it is hard to differentiate over the optimization model. The paper proposes to learn two optimization model: one to learn the objective of the optimization model and one to learn the coefficient of the optimization model. These are trained using an iterative algorithm that tries them in sequence. The paper applies this approach to the traditional benchmarks used in SPO and show that the approach has benefits overall.\n\nSTRENGTHS:\nAlgorithm 1 is the main contribution of the paper. It is an elegant way to solve SPO problems in general.\n\nWEAKNESSES:\n1. The formalization really gets in the way in this paper. I will try to list these issues here\n\n1.a  The model M which approximates the solver should receive only one set of parameters. I do not understand why you would use c_\\theta(y_i) and z_i in (3). It would be better to explain in detail the inputs of the model M\n\n1.b In (4), the notation M_w(Y,Z;\\theta^*) does not make any sense. M_w does not receive \\theta^* in Algorithm 1. As a result, the bilevel model (4) does not make sense. \n\n1.c why is the learning task expressed as min_{\\theta,w} | M_w(c_theta(y)) - f(z) |?\n\n2. Algorithm 1 is an ADMM approach to the optimization as shown above in fact.\n\n3. I do not understand 4.1. The goal of SPO is to find the parameters of the optimization which is what c_\\theta does? How is Model M useful on testing instances and model deployment? It does not compute any solution, just the objective.\n\n4. In  4.2, you mention that you need Z to train M. This is contradictory with 4.1 where you are using it in unseen test instances. You do not have Z on unseen instances.\n\nQUESTIONS:\nSee above.\n\nLIMITATIONS:\nThe benefits on the portfolio optimization are computational only.\n\nThis area seems to always consider the same three problems.", "TITLE": "Official Review", "RECOMMENDATION": 5, "REVIEWER_CONFIDENCE": 5, "SOUNDNESS_CORRECTNESS": 2, "DATE": "2023-07-03"}

{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThis paper proposes the a novel framework for learning the predicted value of an optimization task under limited information. Specifically, the goal is to learn $\\mathcal{M}\\_w(y, z) = f (g\\_\\theta (y), z)$ function where $y$ is the limited information, $z$ is the complete information, $f$ is the objective value of an optimization function to be maximized, and $g\\_\\theta$ is a way to generate a solution to the optimization problem based on the limited information $y$. In essence, there are 2 sets of interdependent parameters to learn -- $\\theta$ and $w$, and the paper proposes an alternating update scheme for solving the joint problem. They then apply this framework to 2 classes of problems---Smart Predict-then-Optimize (SPO) and Mixed Integer Non-Linear Programming (MINLP)---and show that this method outperforms similar approaches in each class.\n\nSTRENGTHS:\n* **Great exposition**: The paper is well written and easy to follow. \n* **Good experiments**: The paper uses domains from the literature and compares to relevant past work for each problem class. The experiments are well documented and seem reasonably expansive.\n* **Interesting connection**: I'm more familiar with the SPO literature, so the connection of learned surrogates to MINLP is quite interesting!\n\nWEAKNESSES:\nThe major weakness of this paper, imo, is that it doesn't document the **training considerations** for $\\mathcal{M}_w$. The paper mentions in the conclusions that 'one potential drawback is the complexity of tuning M, requiring model selection and training', but there are no experiments about how hard/important tuning these parameters is. Specifically, it would be good to know:\n1. Shah et al. [36] highlight the importance of *convex* surrogates for learning loss functions (because they have to be optimized over) and show specifically on a version of the Portfolio Optimization domain that neural networks performs poorly (Table 1 in their paper). However, in this paper $\\mathcal{M}_w$ seems to be a neural network and performs well? Do you not observe this phenomenon of 'convexity being important for loss functions'?\n1. There seems to be a recent follow up to [36] --> [A] which seems to do 1 iteration of your alternating update (with a 2-stage warm start) and seems to do well on the Portfolio Optimization domain, even better than the MDFL method (which seems to do much better than both LODLs and LANCER in this paper). Then:\n    * How robust are your results to hyperparameter choices?\n    * How important is it to perform repeated updates? (Is this what you mean by \"epoch\" in Figure 5? And if so, how much difference is there between 1 epoch with 10x the samples vs. 10 epochs with 1x the samples?)\n    * Relatedly, how do those results change based on how good the initial guess of $\\theta$ is? Do you need fewer updates if you warm-start $\\theta$ from a 2-stage solution?\n1. Why do you measure cost in terms of the number of calls to the BB optimizer in Figure 5? There seems to be a trade-off between (a) using more calls the BB optimizer but training a simple model (as in LODLs) vs. (b) using fewer calls to the BB optimizer but training a more complex model. Do the results look very different if you use wall-clock time?\n\n_References:_\n\n[A] Shah S, Perrault A, Wilder B, Tambe M. Leaving the Nest: Going Beyond Local Loss Functions for Predict-Then-Optimize. arXiv preprint arXiv:2305.16830. 2023 May 26.\n\nQUESTIONS:\nApart from the questions in the weaknesses in the section above, I was wondering:\n1. **Choice of domains**: I noticed that you have not used the domains from either SurCO or LODLs on which they report good performance. While this is not a weakness in itself, I can't help but wonder how well LANCER performs on those domains. Should LANCER always be the choice of learning method or is the answer more nuanced?\n1. **Alternating updates**: Is it important to always do full updates in both spaces? Have you considered, perhaps, doing smaller updates? For example, in a recent paper, [B] seems to do some sort of meta-gradient update based on how $\\theta$ would change in response to $w$.\n1. **Re-using $\\mathcal{M}_w$**: The fact that landscape surrogates can be 're-used' seems to suggest that $\\mathcal{M}_w$ is learning something that is common across problem instances. Have you tried to analyze what it is that $\\mathcal{M}_w$ is learning?\n\nFrom the experiments, I'm convinced that there exist reasonable domains for which its possible to get this method to work. However, it's not clear at the moment how easy this process is... I'm willing to raise my score to a 7 if the authors provide more detailed answers to the questions in the weaknesses section\n\n_References:_\n\n[B] Sivasubramanian, Durga, et al. \"Adaptive Mixing of Auxiliary Losses in Supervised Learning.\" Proceedings of the AAAI Conference on Artificial Intelligence. Vol. 37. No. 8. 2023.\n\nLIMITATIONS:\nI appreciate the inherent conflict of interest, but I think the paper could do a better job of documenting the limitations of their approach. For example, if the authors could answer (1) from the questions section above, that would help to better contextualize the advantages and limitations of this approach.", "TITLE": "Official Review", "RECOMMENDATION": 7, "REVIEWER_CONFIDENCE": 5, "SOUNDNESS_CORRECTNESS": 3, "DATE": "2023-07-04"}

{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThis paper presents a unified framework for \"predict-then-optimize\" and surrogate cost learning for Mixed Integer Nonlinear Programming (MINLP). These problems are cast as learning an optimizer g with f as the objective. Current solutions either suffer from scalability issues or the sparse gradient problem. To overcome these, the authors propose learning a smooth and tractable landscape surrogate to replace the compound function $f\\circ g$. A neural network parameterizes the surrogate loss and it is learned through alternating optimization. This is done by alternately optimizing the target model c and landscape surrogate $\\mathcal{M}$ in a manner similar to Generative Adversarial Networks (GANs). Experiments covering both linear and non-linear objectives demonstrate the efficacy of the proposed method under both \"predict-then-optimize\" and surrogate learning settings.\n\nSTRENGTHS:\nThe paper proposes the first unified framework for \"predict-then-optimize\" and surrogate learning. The method is straightforward, and empirical results appear promising in terms of both optimization performance and runtime.\n\nWEAKNESSES:\nDirectly utilizing a neural network to parameterize the landscape may not be a good idea. The complexity of a neural network typically surpasses the original objective f. A neural network can have extremely large number of local minimums and this approach could disrupt the convexity of the original optimization problem, leading to instability in the proposed method's learning procedure. In fact, in Shah et al., several parameterizations, including neural networks, were tested and found to often result in catastrophic outcomes. There's concern about this parameterization across various optimization objectives. \n\nWhile SurCo minimizes the original objective f, LANCER learns an additional surrogate loss. However, in experiment 5.2.2, LANCER significantly outperforms SurCo. The authors should provide more analysis and clarification on why employing such a surrogate loss can surpass the original loss.\n\nThe paper lacks important implementation details. In 4.1, the authors mentioned the possibility of executing the theta-step during testing since c_{\\theta} is available for unseen test data. It is unclear if this step was used during testing in the experiments. The supplementary material also does not provide details about the number of training iterations for this theta-step during testing. If this additional optimization step was used during testing, performance without this step should also be reported to pinpoint the source of the gains compared to SurCo. In fact, SurCo can also have this extra optimization step for the unseen test data.\n\nFurthermore, the paper does not provide any implementation details for the replay buffer trick discussed in 4.2, such as the number of points needed to be stored, which could significantly impact the training time.\n\nThe unification of the \"predict+optimization\" problem and surrogate cost learning problem under optimization with partial information feels forced as half of the paper focuses on surrogate objective learning for MINLP where full information is available.\n\nSection 4 could benefit from restructuring. The main introduction of the proposed method precedes 4.1 and 4.2 and lacks a subsection title, while 4.1 and 4.2 focus on implementation details.\n\nMinor:\n\nLine 285: MDFL was proposed for combinatorial decision-focused learning and it is not the first DFL paper. A more accurate citation should be Donti et al. (2017).\n\nQUESTIONS:\nHave different parameterizations of \\mathcal{M} been tested and do they significantly affect performance?\n\nIn 4.1, the paper said we can execute the theta-step at testing time since c_{\\theta} for unseen test data. Did you try this step in your experiment? I did not find the number of training iterations of this theta-step at testing time in the supplementarial material.\n\nWas the replay buffer trick, as described in 4.2, used and how many points were needed to be stored? This could significantly impact training time but no implementation details are given in the experimental section or the supplementary material.\n\nLIMITATIONS:\nPlease refer to the Weaknesses section for a detailed discussion of the paper's limitations.", "TITLE": "Official Review", "RECOMMENDATION": 5, "REVIEWER_CONFIDENCE": 4, "SOUNDNESS_CORRECTNESS": 2, "DATE": "2023-07-06"}

{"IS_META_REVIEW": false, "comments": "SUMMARY:\n`This paper is concerned with an amortized optimization scheme for challenging variants of canonical decision problems such as MINLPs and nonlinear portfolio selection. The authors propose a method with two components, a target mapping $c_\\theta$ that maps partially observed problem descriptions $\\mathbf y$ to full descriptions $\\mathbf z$ that are passed to a traditional solver $g$ (e.g. an MILP solver), and a landscape estimator $M_w$ (i.e. a value function) that estimates the objective value attained by  $g(c_\\theta(\\mathbf y))$ w.r.t. some distribution of training instances. Together $g(c_\\theta(\\mathbf y))$ can be seen as a policy mapping problem descriptions to optimal decisions.\nThis is an empirical paper, with proof of concept results on several variants of canonical decision problems.\n\nSTRENGTHS:\nAmortized optimization is a common technique across machine learning. For example, LANCER bears striking similarity to actor-critic methods for RL, which amortizes the evaluation of an actor (i.e. policy) $\\pi_\\theta$ into a critic (i.e. value estimate) $Q_w$, and likewise the policy amortizes the optimization problem $a^*(s) = \\mathrm{argmax}_a Q_w(s, a)$. The main difference is the objective value in RL (i.e. the policy returns) are not directly observed, and so $Q_w$ is trained by fitted Q-iteration (i.e. the Bellman backup operator) instead of a supervised loss as proposed in this paper. \n\nWhile the technique proposed in this paper is not new, it is the first time I have seen it combined with traditional optimization solvers like MILPs, which are very underutilized by the ML community. Hence the concept of the paper is very intuitive, and has as much if not more potential for impact than RL papers, which are routinely published in NeurIPS proceedings but as yet have not appeared to have significant impact on industrial optimization problems.\n\nWEAKNESSES:\nLike many other solutions to bilevel optimization problems (including actor-critic algorithms), LANCER is not guaranteed to converge w.r.t. $\\mathbf w$ or $\\mathbf \\theta$. Although it is not discussed in the paper, I suspect that LANCER is likely unstable if the hyperparameters are not chosen carefully. If this is not the case, please provide evidence in the rebuttal.\n\nThe connections to other amortized optimization methods in ML generally is not a weakness in my opinion, however I think the related work and discussion could be greatly improved by placing this work in context with other methods like actor-critic RL algorithms and amortized Bayesian inference algorithms to name a few.\n\nQUESTIONS:\n- How sensitive is LANCER to hyperparameters in terms of performance and stability?\n\n- Do you think it may be necessary to regularize $c_\\theta$ to better explore the space of possible target mappings (similar to entropy-regularized policies in RL e.g. soft actor-critic)?\n\nLIMITATIONS:\n- While LANCER appears more sample efficient in terms of black-box sample efficiency is does seem a bit slower than the baselines (although it does find better solutions). Hence in latency-sensitive applications it may not be the best choice\n\n- Like Offline RL the generalization of LANCER to unseen problems will depend heavily on the support of that particular problem configuration in the training set. For out-of-distribution problems LANCER's performance is likely greatly diminished. Determining LANCER's sensitivity to distribution shift is an interesting research question.", "TITLE": "Official Review", "RECOMMENDATION": 7, "REVIEWER_CONFIDENCE": 4, "SOUNDNESS_CORRECTNESS": 3, "DATE": "2023-07-07"}