Evolutionary framework for two-stage stochastic resource allocation problems

TL;DR

This paper introduces an evolutionary framework combining local search and genetic algorithms to efficiently solve large-scale two-stage stochastic resource allocation problems, optimizing costs across multiple scenarios.

Contribution

It presents a novel hybrid evolutionary approach specifically designed for two-stage stochastic resource allocation problems, improving scalability and solution quality.

Findings

Effective on large instances of stochastic Steiner tree problems

Outperforms traditional methods in solution quality and computational efficiency

Supports diverse types of two-stage stochastic resource allocation problems

Abstract

Resource allocation problems are a family of problems in which resources must be selected to satisfy given demands. This paper focuses on the two-stage stochastic generalization of resource allocation problems where future demands are expressed in a finite number of possible scenarios. The goal is to select cost effective resources to be acquired in the present time (first stage), and to implement a complete solution for each scenario (second stage), while minimizing the total expected cost of the choices in both stages. We propose an evolutionary framework for solving general two-stage stochastic resource allocation problems. In each iteration of our framework, a local search algorithm selects resources to be acquired in the first stage. A genetic metaheuristic then completes the solutions for each scenario and relevant information is passed onto the next iteration, thereby supporting the acquisition of promising resources in the following first stage. Experimentation on numerous instances of the two-stage stochastic Steiner tree problem suggests that our evolutionary framework is powerful enough to address large instances of a wide variety of two-stage stochastic resource allocation problems.

Tables

Table 1. Table 1 : EvFW parameters.

perturbation intensity		$\alpha =0.7$
minimum improvement ratio		$i=0.001$
max iterations since best solution		$b=3$
max iterations since last improvement		$l=2$
tail generations factor		$t=3$

Table 2. Table 2 : BRKGA parameters.

population size		$p=25$
elite set size		$p_e=\lceil 0.1p\rceil$
number of mutants		$p_m=\lceil 0.2p\rceil$
elite crossover probability		${\rho }_e=0.4$
number of generations		$g=25$

Table 3. Table 3 : Results for instances from benchmark 1.

			$EF$		$2B{C}^{\ast }$		EvFW
instance	$\left|S\right|$	$OPT$	time	gap	time	gap	time	gap
lin01_53_80	5	797.0	0.2	-	2.2	-	8.4	2.9
lin01_53_80	10	633.2	0.7	-	2.5	-	10.9	0.9
lin01_53_80	20	753.9	5.7	-	6.9	-	29.4	0.3
lin01_53_80	50	768.9	33.4	-	10.4	-	75.6	0.1
lin02_55_82	5	476.2	0.1	-	1.1	-	4.6	0.0
lin02_55_82	10	739.1	1.0	-	3.0	-	16.5	1.7
lin02_55_82	20	752.2	4.9	-	4.3	-	31.1	0.3
lin02_55_82	50	732.6	31.2	-	10.7	-	76.9	0.5
lin03_57_84	5	653.0	0.5	-	1.9	-	6.0	0.7
lin03_57_84	10	834.7	3.8	-	8.7	-	19.2	1.4
lin03_57_84	20	854.9	10.8	-	7.3	-	38.7	0.1
lin03_57_84	50	895.7	103.1	-	21.3	-	96.7	0.2
lin04_157_266	5	1922.1	140.4	-	959.2	-	84.6	1.6
lin04_157_266	10	1959.1	415.8	-	989.2	-	139.9	0.6
lin04_157_266	20	1954.9	5498.7	-	3016.7	-	239.2	1.4
lin04_157_266	50	2097.7	7200.0	19.5	5330.2	-	546.3	4.3
lin05_160_269	5	2215.5	282.0	-	2681.2	-	108.3	2.6
lin05_160_269	10	2210.2	1866.7	-	4096.0	-	174.3	3.1
lin05_160_269	20	2412.2⋄	7200.0	5.6	7200.0	4.7	352.9	-0.8
lin05_160_269	50	2297.0	7200.0	21.3	3627.4	-	842.9	2.0
lin06_165_274	5	1975.8	212.8	-	760.9	-	88.0	1.0
lin06_165_274	10	1918.7	501.7	-	808.4	-	126.4	0.2
lin06_165_274	20	2457.6	7200.0	-	3222.9	-	473.7	2.5
lin06_165_274	50	2186.8	7200.0	22.5	2795.5	-	1139.3	0.5
Average			1879.7		1482.0		197.1
$\diamond$ instance in which Bomze et al. [2010] does not reach the optimum.
In fact, we found a solution with cost 2356.5.
$\left|S\right|$ – number of scenarios.
$OPT$ – Optimal solution costs obtained by Bomze et al. [2010].
$EF$ – results from Extensive Form algorithm by Bomze et al. [2010].
$2B{C}^{\ast }$ – results from 2-stage B&C algorithm by Bomze et al. [2010].
EvFW– average results from evolutionary framework.
time – computational time in seconds.
gap – optimality gap in percentage.

Equations

$$\min$$

$$R^{\prime }\in (\Re \cap f(D)).$$

$$c^j(r)=(1-\alpha +2\alpha Q^j(r))c(r).$$

$$\min$$

$$(R_0\cup R_s)\in (\Re \cap f(D_s)),\forall s\in S.$$

$$c^{\prime}_{s}(r)=\left\{\begin{array}[]{ll}0&\mbox{if $r\in R_{0}$,}\\ c_{s}(r)&\mbox{otherwise,}\end{array}\right.$$

$$\text{F}(R_0,{\text{A}}_{\text{P}},\mathcal{I})=\sum _{s\in S}\sum _{r\in R_s}{c}_s(r)\cdot p_s.$$

$$\mathrm{OPT}(\mathcal{I})\le \text{F}(\varnothing ,{\text{A}}_{\text{P}},\mathcal{I})\le \beta \sum _{s\in S}{p}_s{\mathrm{OPT}}_{\text{P}}(I_s)\le \beta (1+\gamma )\mathrm{OPT}(\mathcal{I}).$$

$$\mathrm{RC}(r,R_0,{\text{A}}_{\text{P}},\mathcal{I})=c_0(r)+\text{F}(R_0\cup \{r\},{\text{A}}_{\text{P}},\mathcal{I})-\text{F}(R_0,{\text{A}}_{\text{P}},\mathcal{I}).$$

$$\text{F}(R_0\backslash \{r\},{\text{A}}_{\text{P}},\mathcal{I})-\text{F}(R_0,{\text{A}}_{\text{P}},\mathcal{I})-c_0(r)<0$$

$$\bar{Q}(r)=\sum _{s\in S}{Q}_s(r)\cdot p_s.$$

$$c^{\prime}_{s}(r)=\left\{\begin{array}[]{ll}0&\mbox{if $r\in R_{0}$,}\\ (1-\alpha+2\alpha Q_{s}(r))c_{s}(r)&\mbox{otherwise.}\end{array}\right.$$

$$\text{F}(R_0,{\text{A}}_{\text{P}},\mathcal{I},\mathcal{Q})=\sum _{s\in S}\sum _{r\in R_s}{c}_s(r)\cdot p_s.$$

$$\mathrm{RC}(r,R_0,{\text{A}}_{\text{P}},\mathcal{I},\mathcal{Q})$$

$$\text{leavevmode}\text{leavevmode}\text{leavevmode}-\text{F}(R_0,{\text{A}}_{\text{P}},\mathcal{I},\mathcal{Q}).$$

$$\min$$

$$\displaystyle\mbox{$T$ is a tree that spans $D$}\enspace.$$

$$\sum _{e\in E_0}c(e)+\sum _{s\in S}\sum _{e\in E_s}{c}_s(e)\cdot p_s.$$

$${\text{A}}_{\text{P}}$$

Full text

We propose an evolutionary framework for solving general two-stage stochastic resource allocation problems. In each iteration of our framework, a local search algorithm selects resources to be acquired in the first stage. A genetic metaheuristic then completes the solutions for each scenario and relevant information is passed onto the next iteration, thereby supporting the acquisition of promising resources in the following first stage. Experimentation on numerous instances of the two-stage stochastic Steiner tree problem suggests that our evolutionary framework is powerful enough to address large instances of a wide variety of two-stage stochastic resource allocation problems.

††journal: arXiv

1 Introduction

Resource allocation problems arise when companies are faced with the decision of choosing resources to build an infrastructure at a minimum cost which meets some given demands and constraints. However, in the real world, there are many uncertainties concerning the costs and demands of future resources. Stochastic programming is a field of research that is concerned with the modeling of these uncertainties [Birge & Louveaux, 2011, Shapiro et al., 2014]. A common approach is to rely on a scenario decomposition analysis. The uncertainty about the problem parameters is modeled by a limited number of subproblems (scenarios), weighted by their occurrence probability and containing a restricted representation of the problem uncertainties. By obtaining the optimal solutions for each scenario, one could expect to find similarities and trends among the scenarios to come up with a solution that holds a good trade-off under all scenarios.

Two-stage stochastic programming is a mathematical framework to model stochastic problems using a scenario decomposition approach. The first stage reflects decisions that should be made at the present time. On the other hand, the second stage reflects the decisions that should be made at a future time, considering a set of possible scenarios, each giving a presumable realization of the uncertain data. The goal is to find the minimum cost solution, which comprises the first stage cost and the second stage expected cost considering all scenarios.

Literature is plenty of operations research problems modeled as two-stage stochastic problems. In the following, related works based upon real-life case studies offer examples of two-stage stochastic problems with an underlying resource allocation problem.

Supply chain network design:

Kara & Onut [2010] developed a revenue maximization model for a network design problem, faced by a waste-paper recycling industry, in which one must find locations for recycling centers and flows among a multi-facility environment. The model deals with the management of a Closed-Loop Supply Chain (CLSC), i.e., it considers both the forward flow (new paper from manufacturers to customers) and the reverse flow (waste paper from customers back to manufacturer). Badri et al. [2017] introduce a model for the design of a CLSC in which demand and return volumes of a product are stochastic. The objective is to maximize the economic value added (EVA) of the supply chain, considering supply chain costs, sales growth, working capital and fixed assets during a given planning horizon. In the first-stage, the decisions are made with respect to the number and location of facilities in a three-echelon logistics network. In the second-stage, the flows and storage of products are determined to each scenario, from which the EVA can be obtained.

Inventory management:

Cunha et al. [2017] propose a model for inventory control, within a given planning horizon, of a single-item one-echelon supply chain, considering periodic review of the stock position and uncertainty of the demand levels from the retailer. The first-stage decisions concern the optimization of two inventory control variables: (i) the review periodicity of the stock level and (ii) the target level for each stock replenishment order. The second-stage decisions refer to the stock levels and to the quantities ordered over the periods of the planning horizon, which are directly influenced by the first-stage decisions and the realizations of the uncertain demands. The objective is to minimize the costs of ordering, carrying and shortage.

Airline operations:

McCarty & Cohn [2018] propose a model for the decision-making of anticipating passenger reaccommodation from delayed flights. The first-stage decisions assign passengers to new itineraries in anticipation of the delay’s impact and second-stage decisions adjust itineraries for passengers who missed their connections once the delay has been realized. Carreira et al. [2017] investigate an airline fleet planning problem with the objective to select aircrafts to purchase (first-stage) or lease (second-stage) in order to satisfy all passengers demands.

Disaster relief:

Krasko & Rebennack [2017] present an optimization model to manage hazardous post-fire debris flow and to coordinate pre-disaster mitigation (first-stage) with disaster response (second-stage). More specifically, in the first stage the decisions concern on mitigation actions (mulching, check dams, straw wattles and debris basin) and setting the number of vehicles to stock in each hospital. The second stage is composed of storm scenarios, each one deriving in a rescue vehicle routing problem. The recourse decisions are made within a multi-period framework aiming for the evacuation plan which minimizes casualties.

Tour scheduling:

Restrepo et al. [2017] investigate a multi-activity tour scheduling problem with uncertain demands. A model is proposed to generate, in the first stage, weekly tours (days-off, working days, shift start times and shift lengths) for employees with identical skills (first-stage). In the second-stage a set of demand scenarios are given and for each scenario the working tours must cope with the realized demand. This is made by allocating work activities and breaks to the employees daily shifts while minimizing undercovering and overcovering of demand.

Agriculture:

Cobuloglu & Esra Buyuktahtakin [2017] present a model for food and biofuel production incorporating economic and environmental impacts under yield and price level uncertainties. Sales revenue and the costs of seeding, production, harvesting and transportation at the farm level are considered as economic variables. The model also considers environmental effects including carbon emission and sequestration, soil erosion and nitrogen leakage to water. The first-stage decisions regards allocating different areas of land to food and energy crops, while the second-stage variables are recourse decisions related to harvesting, budget allocation and amounts of yield types.

The numerous real-life applications arising from different fields being modeled as two-stage stochastic problems, emphasize the importance of developing efficient methodologies to tackle these problems.

Rockafellar & Wets [1991] introduced a paradigm to solve two-stage stochastic problems, called progressive hedging. This method was originally proposed for problems with continuous variables only, preferably linear problems. In the first step, a set of optimal solutions is obtained for the scenarios. Then, in the second step, through an averaging computation over all scenarios solutions, a good compromise first stage solution is built. Rockafellar & Wets have shown that, by iterating the first and second steps, the progressive hedging converges to the optimum if the problem is convex.

Løkketangen & Woodruff [1996] extend the ideas of Rockafellar & Wets introducing an integer progressive hedging framework applicable to mixed-integer two-stage stochastic problems. Later, Watson & Woodruff [2010] noticed that some issues arise when using this integer progressive hedging, especially for large-scale instances, resulting in either non-convergence or unacceptably long running-times. Moreover, Watson & Woodruff [2010] proposed a number of algorithmic enhancements to improve the progressive hedging performance as a heuristic for stochastic mixed-integer programs.

A two-stage mixed-integer stochastic problem can be reduced to a single mixed-integer programming model (MILP), often called deterministic equivalent formulation. For practical problems, this extended formulation takes the form of a large scale MILP, since all first and second stage variables, including all scenarios, are dealt with simultaneously. For relatively small instances, mixed-integer programming solvers can be used to solve the deterministic equivalent model of the problem, as suggested by Parija et al. [2004]. However, for practical resource allocation problems, the deterministic equivalent forms are usually too large to tackle, even with a state-of-the-art MIP solver. Moreover, Tometzki & Engell [2009] points out that MILP solvers still do not exploit the staircase structure of these deterministic formulations.

To avoid the computational burden of solving a two-stage stochastic problem through its deterministic MILP model, Till et al. [2007] proposed a stage decomposition approach. Their method uses an evolutionary metaheuristic to explore and optimize the first stage decision variables. For each set of values explored by the metaheuristic for the first stage variables, the full second stage recourse cost is calculated for the decoupled scenarios. This is made by applying a MILP solver to each scenario independently. Both papers perform computational experiments on real-world scheduling problems with uncertain demands and capacities. The results show that the stage decomposition approach delivered better solutions than by solving the deterministic model, within limited computational time. Later, Tometzki & Engell [2011] showed that the stage decomposition approach proposed by Till et al. [2007] can potentially benefit from good starting solutions for the evolutionary algorithm. Numerical experiments show that initialization methods using mathematical programs can significantly improve the results compared to random initialization of the evolutionary algorithm population.

Amorim et al. [2015] presented a hybrid method to build algorithms, that combine a mixed-integer linear solver with a path-relinking metaheuristic, to solve two-stage stochastic problems with continuous second stage decision variables. In the first step of this hybrid algorithm, each scenario is solved individually by a mixed-integer linear solver. The solutions obtained for each scenario are ranked by their stochastic costs. The best ones are used by the path-relinking phase as guiding solutions to better explore the solution space. The hybrid method was tested considering a stochastic lot sizing and scheduling problem, and results have shown that the method outperformed the use of the mixed-integer linear solver alone, especially for the hardest instances.

In the past few decades, there have been staggering increases on the rate by which new data sets are generated, as well as the amount of stored data collected by numerous devices (mobile phones, software logs, wireless sensor networks). This phenomena is commonly referred to as big data Hu et al. [2014], which offers modern resource allocation problems the access to a continuous flow of information. Therefore, efficient optimization methods, capable of dealing with large volumes of data, are in need. This matter is even more relevant for two-stage stochastic problems, since an instance size is also affected by the number of scenarios.

Our contributions

This work proposes an efficient heuristic methodology, called evolutionary framework (EvFW), to tackle large-scale general two-stage stochastic optimization problems. It contains a two-step main loop, each step responsible for solving one stage and supplied with relevant information from the previous step. Briefly, the first step selects first stage resources until a local optimum is attained. The second step solves each second stage scenario using a biased random keys genetic algorithm (BRKGA). Our proposed methodology, to the best of our knowledge, is the first fully heuristic stage decomposition approach to solve two-stage stochastic resource allocation problems. The fact that EvFW does not rely on ILP solvers allows it to tackle larger instances, that derive from modern resource allocation problems.

The two-stage stochastic Steiner tree problem (SSTP) was selected to showcase the EvFW effectiveness. The SSTP is an NP-hard network design problem with many real-life applications and it was recently selected to compose the 11th DIMACS Implementation Challenge [DIMACS, 2014]. Computational tests were performed on 24 instances from Bomze et al. [2010], and 560 much larger instances from DIMACS [DIMACS, 2014] and first solved by us in Hokama et al. [2014]. For the former, our methodology obtains near-optimal solutions in short computational times. For the latter, within reasonable computational times, it obtains cost-effective solutions for instances with 20 times more scenarios than those from the literature. These results produce a new benchmark for stochastic optimization methods to solve large-scale resource allocation problems. To the best of our knowledge, these are all the instances with results reported in the literature.

This paper is organized as follows. Section 2 provides a brief introduction to (non-stochastical) resource allocation problems, accompanied with their mathematical formulations. This section also gives the basic concepts of the BRKGA metaheuristic and how it can be applied to solve these problems. Section 3 extends the mathematical formulations given in the previous section for general two-stage stochastic resource allocation problems, which are the focus of this work. Section 4 presents a detailed description of our proposed methodology, EvFW, addressing the first stage local search, second stage metaheuristic, feedback between iterations, and convergence criteria. Section 5 shows a case study on the application of EvFW for the two-stage stochastic Steiner tree problem. Computational experiments for this case study are performed and discussed in the same section, comparing EvFW with results from the literature. Finally, Section 6 presents our considerations and final remarks.

2 Resource allocation problems

We consider a generic (non-stochastic) resource allocation problem, which will be denoted by P, where resources with non-negative costs are selected to build a minimum cost infrastructure that meets given demands and some side constraints. Side constraints restrict the possible combination of selected resources and must be respected in any feasible solution.

Let $R$ be a resource set, $c:R\rightarrow\mathbb{R}^{+}$ be a cost function, and $D$ be a demand set. We define $I=(R,c,D)$ as an instance for P, and $\Re$ as the family of all combinations of resources that respect the given side constraints of P. Let $f$ be a function that maps $D$ to the sub-family $f(D)\subseteq\Re$ of all resource sets that attend $D$.

A solution for instance $I=(R,c,D)$ of problem P is a set $R^{\prime}\in\Re$ such that $R^{\prime}$ belongs to $f(D)$, that is, the set of resources $R^{\prime}$ attends $D$ and respects the side constraints. The goal is to find a solution $R^{\prime}$ with a minimum cost. Therefore, problem P can be formulated as

[TABLE]

Now, let $\textrm{A}_{\textrm{P}}$ be a generic algorithm for a generic problem P, that receives an instance $I=(R,c,D)$ and returns a solution $R^{\prime}$. We consider that $\textrm{A}_{\textrm{P}}$ is any simple and fast heuristic for P, such that it does not return an optimal solution. In the following subsections, we briefly describe the metaheuristic BRKGA and how to combine it with algorithm $\textrm{A}_{\textrm{P}}$ to find good solutions for P.

2.1 BRKGA overview

The Biased Random Key Genetic Algorithm (BRKGA), presented by Gonçalves & Resende [2011], is a general search metaheuristic based on genetic algorithms, where a population of individuals evolves through the Darwinian principle of the survival of the fittest.

Each individual $j$ of the population is represented by a chromosome $Q^{j}$, encoded as a vector with $m$ alleles. Each allele is a random key uniformly drawn over the interval $[0,1]$. The decoder is an algorithm that translates a chromosome $Q^{j}$ into a solution $R^{j}$. The fitness is a function that evaluates a solution $R^{j}$.

The BRKGA initializes the population with $p$ randomly generated chromosomes, and this population evolves along $g$ generations. For $i=1,\dots,g-1$, the population is updated from generation $i$ to $i+1$ according to the following steps:

For each individual $j$ at $i$, decode the chromosome $Q^{j}$ into a solution $R^{j}$. 2. 2.

Evaluate the fitness of each solution $R^{j}$ for each individual $j$ at $i$. 3. 3.

Copy the best $p_{e}$ individuals (elite set) from $i$ to $i+1$. 4. 4.

Add $p_{m}$ randomly generated chromosomes (mutants) to $i+1$. 5. 5.

Produce $p-(p_{e}+p_{m})$ new chromosomes to $i+1$ using crossovers.

The crossover generates a new individual by sampling each allele from one of its parents. Both parents are from the current generation and exactly one is from the elite set. An allele is sampled from the elite parent with probability $\rho_{e}$.

After $g$ generations, the BRKGA returns the best individual’s chromosome $Q^{*}$ and its decoded solution $R^{*}$.

2.2 BRKGA and resource allocation problems

We show a method to apply the BRKGA to a resource allocation problem P. This method is particularly interesting for dealing with NP-hard problems for which some fast approximation algorithm or heuristic is known.

Considering an instance $I=(R,c,D)$ and a BRKGA individual $j$, we define the following terms:

Chromosome

Each allele of chromosome $Q^{j}$ corresponds to a resource $r\in R$ with key $Q^{j}(r)$. Thus, the chromosome $Q^{j}$ is a vector of size $|R|$.

Initial population

We replace exactly one randomly generated chromosome from standard BRKGA initial population by a regular chromosome $Q$, in which all allele values are equal to $0.5$, this will be a neutral chromosome.

Decoder

For each resource $r\in R$ and chromosome $j$, the allele key $Q^{j}(r)$ is used as a perturbation for the corresponding resource cost $c(r)$. Let $\alpha\in{\mathbb{R}}^{+}_{*}$ be a parameter that determines the perturbation intensity. The new perturbed cost of $r$ is

[TABLE]

Now, we decode $Q^{j}$ into a solution $R^{j}$ by using $\textrm{A}_{\textrm{P}}$ to solve a new instance $I^{j}=(R,c^{j},D)$.

Note that for any $r\in R$, $Q^{j}(r)<0.5$ gives a discount to the cost of resource $r$, while $Q^{j}(r)>0.5$ increases its cost. The idea is that the perturbed costs allow $\textrm{A}_{\textrm{P}}$ to search over, possible good, solutions that were not considered when $\textrm{A}_{\textrm{P}}$ worked with the original costs. Moreover, the regular chromosome added to the initial population guarantees that the original costs are also considered by $\textrm{A}_{\textrm{P}}$.

Fitness

Individual $j$ fitness is the cost of the decoded (from $Q^{j}$) solution $R^{j}$ evaluated with the original costs, i.e. $\sum_{r\in R^{j}}c(r)$. It is important to note that perturbed costs are passed to $\textrm{A}_{\textrm{P}}$ to find $R^{\prime}$ but are not considered to evaluate the real cost of $R^{\prime}$.

We denote by BRKGA($I,\textrm{A}_{\textrm{P}},Q$) a call for BRKGA to solve input $I$ of P, using algorithm $\textrm{A}_{\textrm{P}}$, and adding a chromosome $Q$ to the initial population.

3 Two-stage stochastic resource allocation problems

We now describe the family of two-stage stochastic resource allocation problems, based on (non-stochastic) resource allocation problems defined in the previous section. Our framework EvFW aims to solve this family of problems.

Formally, given a resource allocation problem P, we denote as SP, the two-stage stochastic version of P. We define SP as follows: Let $S$ be a scenario set, such that each scenario $s\in S$ has probability $p_{s}$ to occur. Let $R$ be a resource set, such that each resource $r\in R$ has first stage cost $c_{0}(r)$ and, for each scenario $s\in S$, resource $r$ has a second stage cost $c_{s}(r)$. Furthermore, let $D_{s}$ be the demand set to be attended for each scenario $s\in S$.

Considering probabilities $Pr=\{p_{s}:s\in S\}$, cost functions $C=\{c_{0},c_{s}:s\in S\}$, and demands ${\cal D}=\{D_{s}:s\in S\}$, we define ${\cal I}=(S,Pr,R,C,{\cal D})$ as an instance for SP. A solution for SP is defined by a set of resources to be acquired in the first stage $R_{0}\subseteq R$ and, for each $s\in S$, a set of resources $R_{s}\subseteq R\backslash R_{0}$, such that $R_{0}\cup R_{s}$ is a solution for instance $I_{s}=(R,c_{s},D_{s})$ of P. Note that it is necessary to find a solution for each possible scenario. The goal is to find an SP solution with the minimum cost. Therefore, the SP can be formulated as

[TABLE]

Note that the two-stage stochastic versions of relevant problems from combinatorial optimization and operations research, such as set cover [Christofides & Korman, 1975], network design [Johnson et al., 1978], facility location [Drezner, 1995], and vehicle routing [Caceres-Cruz et al., 2014] problems, fit into this generic problem definition.

For an instance ${\cal I}$ of SP, the recourse cost function $\textrm{F}(R_{0},\textrm{A}_{\textrm{P}},{\cal I})$ is the cost of solving each scenario of ${\cal I}$ with $\textrm{A}_{\textrm{P}}$, considering cost zero for first stage resources $R_{0}$. Intuitively this is the cost of completing the solution for each scenario, given that resources $R_{0}$ are already acquired and paid in the first stage. More formally, for each scenario $s\in S$, we define

[TABLE]

and let $R_{s}$ be the solution obtained by algorithm $\textrm{A}_{\textrm{P}}$ when it solves instance $I_{s}=(R,c^{\prime}_{s},D_{s})$ of P, for each scenario $s$ of instance ${\cal I}$ of problem SP. We define the recourse cost function

[TABLE]

It is worth mentioning that an upper bound for the optimum cost of SP consists of letting all resources to be acquired at each scenario of the second stage using the $\textrm{A}_{\textrm{P}}$, i.e., no resource is acquired in first stage and $R_{0}=\emptyset$. Moreover, note that if $\gamma$ is the highest inflation ratio of the resources and $\textrm{A}_{\textrm{P}}$ is a $\beta$-approximation algorithm for P, then this upper bound is a $\beta(1+\gamma)$-approximation for the optimum cost of SP.

Formally, let $\textrm{F}(\emptyset,\textrm{A}_{\textrm{P}},{\cal I})$ be the value of this upper bound, $\mathrm{OPT}({\cal I})$ be the cost of an optimal solution, and $\mathrm{OPT}_{\textrm{P}}(I_{s})$ be the cost of an optimal solution for instance $I_{s}=(R,c_{s},D_{s})$ of P. We have that

[TABLE]

If $\textrm{A}_{\textrm{P}}$ is an exact algorithm, the value of this upper bound is a $(1+\gamma)$ approximation factor, that is, $\mathrm{OPT}({\cal I})\leq\textrm{F}(\emptyset,\textrm{A}_{\textrm{P}},{\cal I})\leq(1+\gamma)\mathrm{OPT}({\cal I})\enspace.$

4 Evolutionary framework

In this section, we describe the proposed Evolutionary Framework (EvFW) for the family of two-stage stochastic resource allocation problems. We first give an overview of the main algorithm, then we give details of each step, and finally we present a flow diagram, in Figure 1, summarizing the framework.

Overview

The proposed evolutionary framework (EvFW) for an SP has a main loop with two steps. In the first step, the local search algorithm (LS) selects first stage resources towards a local optimum. In the second step, the selected first stage resources are sent to the second stage metaheuristic (SSM) that uses BRKGA to solve each scenario of the second stage. At the end of each EvFW iteration, a solution is obtained and relevant information is given as feedback for the next EvFW iteration. After any convergence criterion is met, the main loop terminates and a final tail step uses the SSM to refine the solution. Algorithm 1 shows the pseudo-code of EvFW. The subroutines are explained in the following subsections.

4.1 Local search

We first explain the local search algorithm (LS) for the first EvFW iteration, which does not consider feedback information. In the subsequent iterations, the LS considers feedback from the SSM, which we explain in Section 4.3.

The LS is responsible for identifying profitable resources to acquire in the first stage. A resource is considered profitable if acquiring it does not increase the overall cost of the solution, i.e. its reduced cost (RC) is non-positive. Let ${\cal I}$ be an instance for SP and $R_{0}\subseteq R$ be a set of resources already acquired in the first stage, then we define the reduced cost of a resource $r$ in $R\backslash R_{0}$ as

[TABLE]

Note that if $\textrm{A}_{\textrm{P}}$ is not an exact algorithm then the reduced cost is just an estimate of the resource actual profit.

The LS begins with $R_{0}=\emptyset$ and considers one resource at a time in an arbitrary order. For each resource $r$, the algorithm computes its reduced cost $\mathrm{RC}(r,R_{0},\textrm{A}_{\textrm{P}},{\cal I})$. If $\mathrm{RC}(r,R_{0},\textrm{A}_{\textrm{P}},{\cal I})\leq 0$ then $r$ is added to the first stage solution, i.e. $R_{0}\leftarrow R_{0}\cup\{r\}$. Note that this algorithm uses a first improvement approach.

Since the addition of new resources to $R_{0}$ may change the reduced cost of resources already in $R_{0}$, the LS verifies if removing some of the resources previously acquired reduces the cost of the solution. Considering each resource $r$ in $R_{0}$ in the order in which the resources were acquired, if

[TABLE]

then the algorithm removes $r$ from $R_{0}$. The result is a set $R_{0}$ of resources to be acquired in the first stage.

The pseudo-code of the local search will be presented in Section 4.3 when feedback information will be described.

4.2 Second stage metaheuristic

The second stage metaheuristic (SSM) is responsible for solving each scenario, considering the resources acquired in the first stage. Additionally, the SSM uses the solution for each scenario to compose an SP solution and give feedback about promising resources to be acquired in the first stage (in the next iteration). Note that $R_{0}$ is the set of resources acquired in the first stage by the LS.

For each scenario $s$, the SSM consider an instance $I_{s}=(R,c^{\prime}_{s},D_{s})$ of P where $c^{\prime}_{s}(r)=0$ if a resource $r$ is in $R_{0}$, and $c^{\prime}_{s}(r)=c_{s}(r)$ otherwise. Then we solve instance $I_{s}$ with BRKGA and $\textrm{A}_{\textrm{P}}$, as shown in Section 2.2, obtaining chromosome $Q^{*}_{s}$ with solution $R^{*}_{s}$ for the best individual. The cost for the SP solution can be obtained by equation (3).

The SSM receives the set $\cal Q$ of best chromosomes ${\cal Q}_{s}$ for each scenario $s$ from a previous iteration. In the first iteration, all alleles of all chromosomes are set to 0.5. Obviously SSM returns the set ${{\cal Q}^{*}}=\{Q^{*}_{s}:s\in S\}$ of best chromosomes found in the current iteration as feedback for the next EvFW iteration. Algorithm 2 presents the pseudo-code for this procedure.

4.3 Feedback

From the second EvFW iteration onwards, similar to the SSM, the LS receives as feedback the chromosome set ${\cal Q}=\{Q_{s}:s\in S\}$, where each $Q_{s}$ is the chromosome for the best individual in scenario $s$ from the previous EvFW iteration.

We define the weighted average allele, for each resource $r\in R$, as

[TABLE]

Recall that in the first EvFW iteration, the LS begins with $R_{0}=\emptyset$ and considers one resource at a time, to be added to $R_{0}$, in an arbitrary order. From the second EvFW iteration onwards the LS uses a non-increasing order over $\bar{Q}$. This is motivated by the notion that resources with low weighted average allele were likely used in the best solution for several scenarios in the previous EvFW iteration. Thus, these resources represent promising acquisitions for the first stage.

For each scenario $s\in S$, using perturbed costs from (2), we define

[TABLE]

Let $R_{s}$ be the solution obtained by $\textrm{A}_{\textrm{P}}$ when it solves instance $I_{s}=(R,c^{\prime}_{s},D_{s})$ of P. We redefine the recourse cost function (5) as

[TABLE]

Note that while the costs $c^{\prime}_{s}$ from (7) bias $\textrm{A}_{\textrm{P}}$ when building solution $R_{s}$ for scenario $s$, these costs are not used at (8). Using this new recourse cost function, we redefine the reduced cost as

[TABLE]

By using the redefined F and $\mathrm{RC}$ functions, the LS bias the construction of second stage solutions to take advantage of resources with low weighted average allele. Observe that both the new recourse cost function and the new reduced cost function are equivalent to the original ones if for every $Q\in{\cal Q}$ and $r\in R$ we have $Q(r)=0.5$. Algorithm 3 presents the pseudo-code of the Local Search Algorithm.

4.4 Convergence criteria and tail step

At the end of each iteration of the EvFW main loop, some convergence criteria are checked to decide if the algorithm should keep searching for better solutions in new iterations, or just refine the best solution achieved so far in the tail step.

The two basic convergence criteria need the parameters $i\in{\mathbb{R}}^{+}_{*}$, $b\in{\mathbb{N}}$ and $l\in{\mathbb{N}}$, that correspond to the minimum improvement ratio, the maximum number of EvFW iterations since the best solution was found, and the maximum number of EvFW iterations since the last solution improvement, respectively.

Let $S^{*}$ be the best solution found so far, $S^{\prime}$ be the solution from the last EvFW iteration, and $S$ be the current solution. If $c(S^{*})>(1+i)c(S)$ then the global improvement counter (GIC) is reset to [math]. Otherwise, the GIC increases by $1$. Similarly, if $c(S^{\prime})>(1+i)c(S)$ then the local improvement counter (LIC) is reset to [math]. Otherwise, the LIC increases by $1$. When the GIC equals $b$ or the LIC equals $l$ then the respective convergence criterion is achieved. The idea behind these convergence criteria is to allow, up to a certain limit, the algorithm to search for solutions out of a local minimum. Another convergence criterion that may be used is a time limit.

If any of the convergence criteria is achieved, the EvFW main loop ends and the algorithm obtains the best solution $S^{*}=(R_{0},{\cal R})$ so far, as well as the set of chromosomes ${\cal Q}$ associated with it, and uses a tail step to improve the solution achieved in each scenario. We use TailStep(${\cal I},{\cal Q},\textrm{A}_{\textrm{P}},R_{0}$) to denote a call for the tail step algorithm. This algorithm is identical to the SSM, except that in its calls to BRKGA the number of generations is multiplied by a tail generations factor ($t$).

5 Case study: stochastic Steiner tree

In this section, we apply our EvFW to the two-stage stochastic Steiner tree problem (SSTP), and show some computational results. We also compare our results with those from the literature.

The Steiner tree problem in graphs (STP) is a classical network design problem. Its goal is to find a minimum cost tree that spans a given subset of nodes, called terminals. This combinatorial optimization problem has several applications, including: communication networks and power systems [Magnanti & Wong, 1984], wire routing in VLSI circuits [Lengauer, 1990], and the study of phylogenetic trees [Cavalli-Sforza & Edwards, 1967]. The STP supposes full knowledge of the terminals to be connected and of the edge costs involved.

The SSTP is a version of the STP that uses a set of possible scenarios to capture uncertainty, both from the terminal set to be connected, and from the costs of the edges. Each scenario is characterized by a terminal set, second stage edge costs and a probability of occurrence. In the SSTP, some edges are acquired in the first stage, considering the set of possible scenarios, and in each scenario of the second stage, some other edges are acquired, at an inflated cost, to complete a tree that connects the scenario’s terminal set (in fact, a subgraph that contains such a tree). The cost of a solution is the sum of first stage edge costs plus the expected second stage edge costs.

Figure 2 depicts an instance of the SSTP with ten nodes and five scenarios. The top leftmost graph shows the first stage edge costs, and the other graphs show, for each scenario, the terminal nodes, the second stage edge costs and the occurrence probability.

Figure 3 depicts the optimal solution for the instance shown in Figure 2. The top leftmost graph shows the edges acquired in the first stage, and the other graphs show, for each scenario, the edges acquired in the second stage. Notice that, in each scenario, the union of first and second stage edges contains a tree that connects the scenario’s terminal nodes.

Gupta et al. [2007] investigated the SSTP, showing a $40$-approximation algorithm for the special case of the SSTP in which the second stage costs are determined by a fixed inflation ratio. This algorithm is based on a primal-dual scheme, guided by a relaxed integer linear programming (ILP) solution. Swamy & Shmoys [2006] presented a $4$-approximation algorithm, that uses cost-sharing properties, for this SSTP fixed inflation ratio special case. Gupta et al. [2007] have also shown that the general case (non-fixed inflation ratio) is as hard as the label cover problem, whose approximation ratio lower bound is $\mathrm{\Omega}(2^{\log^{1-\epsilon}n})$.

Bomze et al. [2010] proposed a two-stage branch-and-cut algorithm that consists of a semi-directed ILP model with integer L-shaped cuts, that is stronger than the undirected ILP model proposed by Gupta et al.. Bomze et al. were the first to report computational results for the SSTP, showing optimal solutions for instances up to $50$ scenarios and $274$ edges.

A BRKGA based heuristic, which we call MH, was proposed by Hokama et al. [2014] specifically for the SSTP, from which the first non-trivial solutions for instances from the 11th DIMACS Implementation Challenge [DIMACS, 2014] were obtained. To the best of our knowledge, this is the only study proposing a heuristic approach for the SSTP. Four major improvements of the EvFW with respect to the MH are described next:

The EvFW uses a local search algorithm to decide which resources are bought in the first stage and it only uses the BRKGA inside each scenario of the second stage metaheuristic, while the MH is a straightforward implementation of the BRKGA, which uses a single call, with arbitrary cut and perturbation values, to decide both which edges are bought in the first stage and in each scenario, respectively. Moreover, the MH uses a local search procedure, but just to generate one initial chromosome. 2. 2.

The BRKGA is applied independently to each scenario which led to solutions with better quality in a shorter time, as it allowed EvFW to combine the solutions obtained in each scenario. We highlight that the standard application of BRKGA involves representing the entire solution by a single chromosome. The decomposition was possible in this case due to the independence among scenarios. 3. 3.

Using several short cycles, instead of having one long first step followed by one long second step, helps to verify progress more frequently. This allowed the EvFW to finish much earlier for most instances and also enabled it to spend more time on instances which could benefit from the additional computational effort. 4. 4.

Using feedback from the second step solution to better inform the following first step decisions. EvFW uses this feedback to bias the first step in selecting “shortcuts” drawn by the previous second step. By “shortcuts” it should be understood a set of resources with consistently low chromosome keys, indicating that they are frequently used among the scenarios. This same mechanism allows the algorithm to avoid bad sets of resources that would otherwise be selected due to the greedy nature of the first step.

5.1 STP as a resource allocation problem

In this subsection, we formally describe the (non-stochastic) STP as a resource allocation problem, defined in Section 2 as P, and show a classical approximation algorithm for the STP. Moreover, we give an example on how the BRKGA perturbed costs, proposed in Section 2.2, help to improve solutions for the STP.

Let $G=(V,E)$ be a graph, with the edges in $E$ being the resources (as defined in Section 2); $c:E\rightarrow\mathbb{R}^{+}$ be an edge cost function; and $D\subseteq V$ be a set of terminals, that corresponds to the demands. We define $I=(G,c,D)$ as an instance for the STP. A solution for this problem is a tree $T\subseteq E$ that spans $D$, and the goal is to find such a tree with the minimum cost. Therefore, the STP can be formulated as

[TABLE]

Notice that in this problem, the side constraints correspond to restricting solutions to those representing a tree over the graph.

Both our method to solve a resource allocation problem P (presented in Section 2.2) and our framework to solve the related stochastic problem SP (presented in Section 4) rely on an algorithm $\textrm{A}_{\textrm{P}}$ for P. For the STP, we use the minimum spanning tree $2$-approximation algorithm [Vazirani, 2003], called MST-approx, as algorithm $\textrm{A}_{\textrm{P}}$. The MST-approx creates a complete graph $G^{\prime}=\{D,E^{\prime}\}$, where each edge $(i,j)\in E^{\prime}$ has a cost equal to the shortest path between $i$ and $j$ in $G$. Then, it computes a minimum spanning tree $T^{\prime}$ of $G^{\prime}$. Finally, a Steiner tree $T$ for $G$ is derived from the union of the shortest paths represented by the edges of $T^{\prime}$. All steps of this algorithm can be performed in polynomial time. More precisely, the time complexity to compute the shortest paths between all the terminals is $\mathrm{O}(|D||E|\log|V|)$, the time complexity to compute a minimum spanning tree in $G^{\prime}$ is $\mathrm{O}(|E^{\prime}|\log|D|)=\mathrm{O}(|D|^{2}\log|D|)$, and the time complexity to translate a minimum spanning tree in $G^{\prime}$ to a tree in $G$ is $\mathrm{O}(|D||E|)$. Thus, the MST-approx runs in $\mathrm{O}(|D|(|E|\log|V|+|D|\log|D|+|E|))=\mathrm{O}(|D||E|\log|V|)$.

As described in Section 2.2, we use perturbed costs in the decoding process of BRKGA to solve resource allocation problems. Figure 4 illustrates the advantage of using these perturbed costs for the STP. Consider the instance illustrated in Figure 4(a), in which the edge set is $E=\{a,b,c,d,e,f\}$, the edge costs given by $c:E\rightarrow\mathbb{R}^{+}$ are equal to $[9,5,9,5,5,9]$, respectively, and the terminals are represented by red nodes. Figure 4(b) shows a solution with cost $18$, returned when the MST-approx considers the original edge costs. Supposing a chromosome $Q=[0.7,0.4,0.5,0.5,0.3,0.6]$, we have that the perturbed edge costs, computed by $c^{\prime}(e)=(1-\alpha+2\alpha Q(e))\cdot c(e)$ with $\alpha=0.5$, are $[10.8,4.5,9,5,4,9.9]$. When the MST-approx considers the perturbed edge costs, it returns an improved solution, represented by Figure 4(c), with original cost $15$.

5.2 SSTP as a two-stage stochastic resource allocation problem

In this subsection, we formally describe the SSTP as a two-stage stochastic resource allocation problem, defined in Section 3.

Let ${\cal I}=(S,Pr,G,C,{\cal D})$ be an instance for the SSTP, where $S$ is a scenario set; $Pr=\{p_{s}:s\in S\}$, where $p_{s}$ is the occurrence probability for scenario $s$; $G=(V,E)$ is a graph; $C=\{c_{0},c_{s}:s\in S\}$, where $c_{0}$ is the edge cost function for the first stage and $c_{s}$ is the edge cost function for scenario $s$; and ${\cal D}=\{D_{s}:s\in S\}$, where $D_{s}$ is the terminal set for scenario $s$.

A solution for the SSTP is defined by a set of edges $E_{0}\subseteq E$ to be acquired in the first stage and, for each $s\in S$, a set of edges $E_{s}\subseteq E\setminus E_{0}$, such that $E_{0}\cup E_{s}$ contains a tree that spans $D_{s}$. The goal is to find a solution that minimizes the cost

[TABLE]

After reducing the STP to a resource allocation problem and the SSTP to a stochastic resource allocation problem, the application of the EvFW is straightforward.

5.3 Computational results

In this subsection, we show our computational results for the application of EvFW to the SSTP tested with two sets of instances. The first set (benchmark 1), extracted from Bomze et al. [2010], contains 24 instances with $5-50$ scenarios, $80-274$ edges and inflation ratio $\gamma\leq 0.5$. The optimal solutions are known for all but one of these instances. The second set (benchmark 2), extracted from the 11th DIMACS Implementation Challenge [DIMACS, 2014], contains 560 instances, with $5-1000$ scenarios and $64-613$ edges555Instances available at: http://dimacs11.zib.de/downloads.html .. These instances are divided into four types, K, Lin, P and Wrp, with inflation ratio $\gamma$ bounded by $0.3$, $0.5$, $0.3$ and $1.0$, respectively. Since our framework is non-deterministic, each instance tested in this section is executed with 20 different seeds (ranging from 1 to 20) and for each instance, we obtained the average and the standard deviation, both for cost values and time consumption.

Tables 1 and 2 show the default parameter settings for the EvFW and for the BRKGA, respectively. These parameters were chosen after extensive computational tests.

Following we show some results for parameter tests which were executed over the smaller half of benchmark 2 instances (280 instances ranging from 5 to 150 scenarios).

First, we iteratively tested different combinations of parameters perturbation intensity ($\alpha$) and elite crossover probability ($\rho_{e}$), until these converged to $\alpha=0.7$ and $\rho_{e}=0.4$. These are shown in Figures 5(a) and 5(b), respectively.

The Improvement(%) of each data point is the average improvement over all instances, which is better explained during the upcoming analysis of benchmark 2. For all points in Figure 5, the average standard deviation over all instances is less than $0.19$ in the $y$-axis scale, which we omitted from the charts for clearance reasons.

We verified the behavior of EvFW applied to the SSTP when the population size ($p$) ranged over the values in $\{12,25,50,100\}$, and we show these results in Figure 6(a).

We define a time ratio per pair (instance, population size) by dividing its average running time by the average running time for the same instance with population size $p=25$. The $x$-axis corresponds to the average time ratio over all instances. We may see that while a larger population size leads to better results, the cost efficiency with respect to the time ratio decreases and the Improvement(%) tends to asymptotically stabilize.

Moreover, we observed the behavior of EvFW when the parameters $b$, $l$ and $t$ (respectively, max iterations since best solution, max iterations since last improvement, and tail generations factor) range over the triples in $\{(0,0,0),(1,1,1),(3,2,3),(6,4,6),(10,6,10)\}$. These results are shown in Figure 6(b) and their analysis is quite similar to the previous one.

For all points in Figure 6, the average standard deviation is less than $0.19$ in the $y$-axis scale and less than $0.18$ in the $x$-axis scale, which we omitted from the charts for clearance reasons.

Our computational experiments were executed on an Intel Xeon CPU E5 V3 2.30GHz with 57,6 GB RAM, under Ubuntu 16.04. All codes were implemented in C++ using the Lemon Graph Library [LEMON, 2017] as the framework for graph data structures.

Benchmark 1

Bomze et al. [2010] reported the best solutions obtained by their branch-and-cut algorithms for benchmark 1. In their paper, only one instance (lin05_160_269, $|S|=20$) remained without an optimal solution, given the time limit of two hours. Table 3 compares our results for benchmark 1 with those of exact methods Extensive Form ($EF$) and 2-stage Branch-and-Cut ($2BC^{*}$) from Bomze et al. [2010]. For each instance, we report the average cost over the 20 tested seeds. Since the instances for this benchmark are relatively small, we ran it with more permissive parameters than those from Tables 1 and 2, i.e., $p=100$, $b=10$, $l=6$ and $t=10$. The standard deviation for the solution costs is, on average, less than $0.5\%$ of the solution cost of each instance.

These results show that the EvFW presented a good performance for instances with known optimums, achieving small optimality gaps with an average of $1.17\%$. For the instance with unknown optimum, the EvFW has found a solution which is $2.3\%$ ($0.8\%$ on average) cheaper than the previous best known. Moreover, the EvFW required an average of $197.1$ seconds per instance, while $EF$ required on average $1879.7$ seconds and $2BC^{*}$ required on average $1482.0$ seconds, which means an overall convergence significantly faster for our approach. We highlight that these time comparisons are fair since the experiments from Bomze et al. [2010] used an Intel Core-i7 2.67GHz Quad Core machine with 12 GB RAM, whose single core speed is slightly faster than that from the Intel Xeon CPU E5 V3 2.30GHz used in our experiments.

Benchmark 2

Table LABEL:tab:Dimacs shows our summarized results for benchmark 2, displaying average values for each combination of instance type and number of scenarios666Detailed results at: http://www.ic.unicamp.br/~fusberti/problems/sstp/ .. Let buy_none be the upper bound $\textrm{F}(\emptyset,\textrm{MST-approx},{\cal I})$, described in Section 3, in which no edge is acquired in the first stage and each scenario of the second stage is solved using the algorithm MST-approx. Since we do not know the cost of the optimal solutions for the instances in this benchmark, we have used the buy_none upper bound to determine the relative cost reduction obtained by MH, the heuristic from Hokama et al. [2014], and by the EvFW. This comparison shows how much it is expected that each heuristic saves by anticipating future demands and acquiring cheaper edges in the first stage. More precisely, $\delta c$ (%) is the average of the improvement ratio achieved on each instance, which corresponds to one minus the ratio between the heuristic cost over the buy_none cost. Therefore, higher $\delta c$ (%) indicates better solutions.

For the smaller half of this benchmark, i.e., instances with $5$ to $150$ scenarios, we ran the tests with more permissive parameters than those from Tables 1 and 2, i.e., $p=100$, $b=10$, $l=6$ and $t=10$. For the larger half, we used the parameters from those tables. Moreover, to promote a fair comparison among the execution times of MH and EvFW, we multiplied the MH times by a $1.6$ time ratio. We ran an experiment with the smaller half of the instances on the same machine used for the original MH experiments and the $1.6$ was obtained as a lower bound for the resulting time ratio.

The results show that the EvFW is able to find non-trivial solutions for instances with number of scenarios and overall size well beyond what was possible for the exact branch-and-cut algorithms from Bomze et al. [2010]. We also observe that for sets of instances with 50 or more scenarios, in general, EvFW achieves higher improvements in significantly less computational time than the previous approach from Hokama et al. [2014]. For the smaller half of the benchmark, the average cost reduction achieved by the EvFW, relative to the buy_none upper bound, was $4.01\%$ and took, on average, $1233.6$ seconds per instance. For the larger half, the average cost reduction was $3.59\%$ and took, on average, $1397.9$ seconds per instance. Furthermore, the average standard deviation of $\delta c$ (%) is $0.17$ for the smaller half and $0.11$ for the larger half of benchmark 2.

We use Figure 7 to analyze how the EvFW splits its processing time among its steps. As shown in Figure 7(a), when solving the smaller instances with more permissive parameters, i.e., $p=100$, $b=10$, $l=6$ and $t=10$, we have that EvFW spent $9\%$, $45\%$ and $46\%$ of its running time on first step, second step and tail step, respectively. Similarly, Figure 7(b) shows that when solving the larger instances with standard parameters, i.e., $p=25$, $b=3$, $l=2$ and $t=3$, EvFW spent $29\%$, $40\%$ and $31\%$ of its running time on each of those steps. Notice that the first step corresponds to the Local Search (LS) and that both the second and tail steps correspond to the Second Stage Metaheuristc (SSM), albeit with a different number of generations.

We analyze that the different distribution of time among the framework steps in these experiments is due to the change in parameters $p$, $b$, $l$ and $t$. Notice that $p$ affects both the time spent on second and tail steps, $b$ and $l$ affects the time spent on first and second steps, and finally $t$ affects the time spent on tail step. Thus, the time spent on second and tail steps is affected by a greater number of parameters.

Furthermore, each inner cycle of Figure 7 shows that EvFW spent more than $90\%$ of its time solving $\textrm{A}_{\textrm{P}}$, i.e., MST-approx. This suggests that the EvFW is heavily dependent on an efficient $\textrm{A}_{\textrm{P}}$ algorithm. However, for some problems it may be hard to find fast heuristics, or one may want to use a particularly good algorithm, even though it is not really fast. A useful feature of EvFW, which can come in handy in these situations, is that it is easy to adapt the framework to parallel computation. In particular, it is possible to distribute the calls for $\textrm{A}_{\textrm{P}}$, in any step, for up to $|S|$ different cores.

It is interesting to notice how the number of calls to $\textrm{A}_{\textrm{P}}$ relates to the input parameters and to the number of cycles ($n$) which the main loop executes. This relationship per step of the framework is shown by the following inequalities:

[TABLE]

Moreover, $n$ is closely related to other input parameters, like $i$, $b$ and $l$.

We use the instance K100 with 1000 scenarios to illustrate, in Figure 8, how better solutions are obtained through the cycles and steps. In the beginning, both the first and second steps find significantly better solutions. After some cycles, the improvement obtained by the first step tends to zero, which we interpret as all edges worth acquiring in the first stage have already been chosen. Meanwhile, the improvements from the second step are still significant, albeit smaller than those from the first cycles. Eventually, the overall cycle improvement stops being significant, and then the tail step refines the best solution found, in pursuit of some final gain.

6 Final remarks

This work provides an evolutionary framework (EvFW) that aims at solving hard two-stage stochastic resource allocation problems emerging from real-life uncertainties. The EvFW uses stage decomposition and supports the exchange of data between stages: the first stage transfers resources that were acquired in advance, while the second stage indicates resources that are frequently present among the scenarios best solutions.

The EvFW was case studied using the two-stage stochastic Steiner tree problem with two sets of instances. The first set contains 24 small instances, up to 50 scenarios, previously solved by an exact algorithm [Bomze et al., 2010]. The results have shown that the EvFW achieved near-optimal solutions, with an average gap of $1.17\%$, in a very short execution time. The second set complies 560 instances with up to 1000 scenarios [DIMACS, 2014]. For these instances, the EvFW achieved an average cost reduction of $3.8\%$ from reference solutions for which no resources are acquired in the first stage. The results attest the effectiveness of the proposed methodology in obtaining good solutions for large instances within suitable execution time.

Many sectors of modern society, such as companies, governments and academia, demand efficient solution methodologies to tackle the growing size and complexity of stochastic resource allocation problems. We believe that the EvFW attends this demand by providing an efficient methodology capable of solving instances that are comparable, in size and complexity, with real-life decision-making problems.

There are numerous two-stage stochastic resource allocation problems for which the EvFW can be applied, for example, the two-stage stochastic set cover problem. The application of the EvFW can be accomplished by simply implementing a heuristic for the underlying (non-stochastic) problem. Future research could investigate special-purpose improvements (regarding the problem) or even general improvements to the framework (e.g., alternative local searches). 777The complete code is available at http://www.ic.unicamp.br/~fusberti/problems/sstp/ and does not require any commercial ILP solver.