In many real-world applications, machine learning models are not the end of the road. Instead, their predictions—such as traffic forecasts, energy prices, or wireless channel states—serve as inputs to a downstream optimization problem. This "Predict-then-Optimize" pipeline is powerful, but it faces a massive computational hurdle: training the model to minimize "regret" (the loss in decision quality) requires differentiating through the optimization solver itself.
When the downstream problem is a complex combinatorial or non-convex program, calling a solver in every training iteration is prohibitively slow. Researchers like Jayanta Mandi and Tias Guns have pioneered a shift away from this "solver-in-the-loop" bottleneck. The core insight is that we don't need to solve the optimization problem from scratch every time; we can instead use solution caching and surrogate landscapes to provide the necessary gradient signals at a fraction of the cost.
The Bottleneck of Exact Optimization
The standard approach to Decision-Focused Learning (DFL) involves integrating a solver directly into the neural network's loss function. As Jayanta Mandi and colleagues explain in their foundational survey, this ensures the model prioritizes decision quality over simple statistical accuracy. However, if your training set has thousands of instances and your model needs hundreds of epochs, you might end up calling an NP-hard solver millions of times.
This computational burden is the primary reason DFL has struggled to scale. To address this, Yifei Shen and Jun Zhang proposed using lookup tables for recurring sub-problems in wireless resource allocation, avoiding redundant calculations during the iterative learning phase. This idea of "remembering" past work is the seed of the solution caching movement.
Solution Pools as Inner Approximations
The most influential mechanism for scaling DFL is the solution pool or cache. Instead of invoking a heavy-duty solver for every gradient step, the system maintains a persistent set of feasible solutions discovered during previous iterations.
As detailed in Contrastive Losses and Solution Caching for Predict-and-Optimize, this cache acts as an inner approximation of the feasible space. When the model makes a new prediction, instead of asking a solver "what is the optimal solution for these parameters?", we simply perform a fast linear search over the existing cache.
This works because of a key intuition: to generate a useful gradient, the model doesn't always need the perfect solution. It just needs a better solution than the one it currently favors. Jayanta Mandi and Jörg Hoffmann 0001 demonstrated in their work on automated planning that even sub-optimal plans or cached historical solutions provide a sufficient signal for the model to learn impactful features.
Learning the Landscape with Surrogates
While caching works well for discrete solution spaces, continuous or highly complex landscapes benefit from surrogate models. In the LANCER framework, Arman Zharmagambetov and Brandon Amos replace the non-differentiable solver with a smooth, learnable neural network surrogate.
This surrogate is trained using a replay buffer of past solver evaluations. Much like experience replay in reinforcement learning, this buffer allows the system to "decouple" model training from solver calls. The surrogate learns to approximate the optimization landscape, providing dense, reliable gradients that allow the main model to improve without waiting for a heavy solver to execute. Similarly, Bao Duong and Sunil Gupta use reservoir sampling and replay buffers in causal discovery to avoid retraining surrogates from scratch, significantly reducing the total computation for black-box optimization.
Warm-Starting and Intermittent Solving
A final piece of the efficiency puzzle is knowing when to call the solver. Rather than never calling it, researchers use hybrid strategies. Jayanta Mandi suggests intermittent solving, where the solver is invoked only for a small fraction of training instances to refresh the cache. For the rest, the model relies on the solution pool.
In the context of control, Dirk Reinhardt and Moritz Diehl argue in MPC4RL that buffers should store not just the final solution, but the internal "primal-dual states" of the optimizer. This allows for warm-starting, where the solver begins its search from a high-quality previous state rather than from scratch, slashing the time required for each necessary solver call.
By treating optimization results as a reusable resource—whether through discrete caches, smooth surrogates, or warm-started buffers—this research direction has transformed Decision-Focused Learning from a theoretical curiosity into a scalable tool for real-world decision-making.