Online Parallel Portfolio Selection with Heterogeneous Island Model

Online Parallel Portfolio Selection with Heterogeneous Island Model

Abstract

We present an online parallel portfolio selection algorithm based on the island model commonly used for parallelization of evolutionary algorithms. In our case each of the islands runs a different optimization algorithm. The distributed computation is managed by a central planner which periodically changes the running methods during the execution of the algorithm – less successful methods are removed while new instances of more successful methods are added.

We compare different types of planners in the heterogeneous island model among themselves and also to the traditional homogeneous model on a wide set of problems. The tests include experiments with different representations of the individuals and different duration of fitness function evaluations. The results show that heterogeneous models are a more general and universal computational tool compared to homogeneous models.

online portfolio selection, re-planning, hybrid algorithms

I Introduction

In the past decades many different optimization methods have been proposed to solve various types of problems, including hill-climbing [1], random search [2], simulated annealing [3], tabu search [4], evolutionary algorithms [5], and differential evolution [6]. The methods are based on various paradigms and some of them are better for one problem, while others are better for another. In fact, the most suitable method can even be different in different phases of the optimization. In the beginning of the optimization run, very often methods that are based on the exploration are preferred, while in the later phases, exploitation of already found areas of the search space may be more beneficial.

The algorithm selection problem has been defined by Rice several decades ago as the problem of selecting the best algorithm for each problem instance from a set of instances such that the overall optimization cost is minimized [7]. Similar types of problems are also solved in the area of machine learning, with the goal to select the best machine-learning method for a given dataset. In this case, the problem is called meta-learning [8].

In the recent years, computers with multiple CPU cores have become more common, and that brings an alternative option, how to deal with the problem of algorithm selection. In such a case the so called portfolio algorithms [9] can be used. The portfolio algorithms run multiple (more or less) independent instances of different algorithms in parallel (or sequentially on a single CPU) with the goal to find better solution. Sometimes the instances differ only in random initialization of the algorithm parameters. Quite recently, Lindenauer et al. [10] studied the problem of portfolio selection as an extension of the problem of algorithm selection.

In this paper, we combine some of the ideas mentioned above and provide in essence an online algorithm for parallel portfolio selection. The algorithm is based on a heterogeneous island model, which is derived from the homogeneous island model commonly used for the parallelization of evolutionary algorithms. The island model [11] is based on the idea of the life of several isolated populations on different islands evolving in parallel. The islands cooperate with each other in the computation by exchanging the individuals from local populations, thus accelerating the convergence.

In homogeneous island models, each of the islands runs the same algorithm with the same settings, while in the heterogeneous model, the methods used on each island are somehow different. For example, Gong and Fukunaga [12] proposed a heterogeneous model where each island runs an evolutionary algorithm with different settings as an alternative adaptive approach to the manual parameter setting. Pilát and Neruda [13] introduced a heterogeneous models in the context of multi-objective optimization. Some of the islands run multi-objective algorithm, while the others run only a single-objective one. The single-objective islands help to improve the solutions of the multi-objective problem. The heterogeneity in this case actually serves as a way of creating a new hybrid evolutionary algorithm.

The method we discuss in this paper combines several techniques mentioned above – it uses the heterogeneous island model. The model runs a number of different stochastic optimization methods that periodically exchange some of the solutions they found. Apart from the optimization methods, there is also a planner that adaptively replaces the under-performing methods by better-performing ones and thus changes the set of algorithms used in the model online. The described system can thus be also considered an online parallel portfolio selection algorithm. From the point of view of evolutionary algorithms, the system is a way how to hybridize the evolutionary algorithm with other optimization methods in a general and modular way.

In this paper, we compare a number of different planners that decide which methods run in the heterogeneous island model at any point in time. The main goal of the paper is to provide a parallel system based on the idea that combines a number of general stochastic optimization methods in order to create a more general method with a better performance. In an ideal case, the performance of the combined method is better than the performance of each of the constituting methods separately, but even in case the performance is the same, the algorithm can be useful, if the same method can be run for multiple different types of problems. In such a case, it removes the need to select the correct algorithm for the problem at hand. The proposed method is evaluated on a wide range of problems including combinatorial optimization, continuous optimization and the hyper-parameter tuning of a machine-learning method.

Some of the results presented in this paper have already be presented in a short paper [14], namely the results of the P-QI and P-BM planners on the TSP and bin-packing problems. Here, we add eight new different planners, provide more detailed results of the baseline methods, and also present the results on seven new test instances from different fields – vertex cover, continuous optimization, and hyper-parameter tuning in machine learning.

Ii Heterogeneous Island Model

1:Initialize the methods uniformly on the islands
2:
3:while termination condition not met do
4:      obtain information about running methods
5:     if there is a method that has not run then
6:          the least useful method
7:         
8:     else
9:          select a method to kill using a planner-spec. rule
10:          select a method to start using a planner-spec. rule
11:     end if
12:     Kill method and start method
13:     
14:     Sleep until next planning iteration
15:end while
Algorithm 1 General overview

In this section, we describe the heterogeneous island model with the re-planning of the methods. In the model, we assume a parallel computational environment with multiple CPU cores. Each CPU core corresponds to (and executes) a single island. Each island then executes a single optimization method. The methods running on different islands can be different, but they need to share the encoding of the candidate solutions as they share their solution among themselves.

During the run of the optimization, the system logs and processes information regarding the performance of various methods, like the quality of the solutions the methods share, how often the method improves the overall best solution or the number of distinct solutions it provided to other methods. The whole system is controller by a planner, that uses data measured during the execution of the methods in order to find a set of methods that would perform the best for the optimization problem at hand and for the current phase of the optimization.

An overview of the system from the point of view of the planner is given in Algorithm 1. The planner first initializes the island with different methods. Unless otherwise specified bellow (only for the random planner), the methods are assigned to the island in a round-robin manner, i.e. each method is executed the same amount of times (if possible). In case the number of different types of methods is larger than the number of islands, those methods that were not executed are given a preference to be executed first in re-planning.

After the initialization, the planner runs in a loop. In each iteration of the planner (planning iteration), the planner first obtains the information about the performance from the system and the methods themselves (line 4). If there is a method that has not been executed, an instance of the least useful method (according to planner philosophy, i.e. selected in the same way as on line 9 bellow) is removed and replaced by an instance of this method (lines 5-7, 12). Otherwise, the method that shall be removed and the method that shall be started in the given planning iteration are selected in a planner-specific way (lines 8-12). At the end of the planner iteration, the planner first removes the instance of the method that was selected to be removed and starts a new instance of the method selected to start. The planner then sleeps and waits for the start of the next iteration.

In the implementation, both the length of each planning iteration and the frequency of communication are time-based. While this makes the results of the experiments dependent on the hardware and on the implementation of the method (compared to an implementation that would be based on e.g. the number of function evaluations), the various optimization methods can run completely independently of the planner and the other methods in a fully asynchronous way and do not need to wait for the other methods to finish their evaluations. It also simplifies the implementation.

We also do not consider the parameters of the optimization methods in any way. While different settings of e.g. and evolutionary algorithm could be considered a different optimization method, it may actually make sense to work with the parameters more explicitly. This is however left for a future work.

1:Create the initial (set of) solutions
2:
3:while termination condition not met do
4:     Generate new solution(s) based on the current state
5:     Receive solutions from the other methods in the system
6:     Incorporate received solution into own set of solutions
7:     Share the best solution
8:     Update information for the planners
9:end while
Algorithm 2 General Optimization Method

Ii-a Modification of Methods

As we already indicated, the common optimization methods must be slightly modified before they can be used in the heterogeneous island model. First of all, the methods must be able to share their best individuals with other methods present in the system, and they must also be able to receive individuals created by other methods and incorporate them into their optimization loop.

We assume the optimization methods used in the heterogeneous island model contain a main loop (e.g. the generational loop in evolutionary algorithm). In such a case, modification of the method is simple (cf. Algorithm 2) – at the end of the optimization loop (line 5) new individuals are received from the other methods in the system and they are incorporated into the optimization (line 6). Then, the best individuals are shared with the rest of the system (line 7).

For all the methods we tested, the addition of the new solution is made in the same way as if the solution was generated by the methods. For example, in hill-climbing the solution is accepted if it is better than the current best solution for the method. In such a case, it replaces the solution of this methods and the method continues from it. In evolutionary algorithms, the received solutions are added to the population and it is up to the selection, if they survive or not.

The generating of the initial (set of) solutions (line 1) and of the new candidate solutions (line 4) is completely method-specific and can range from simple random sampling in random search to a complex combination of various genetic operators in evolutionary algorithms.

Apart from the communication, the methods also must be able to provide information to the planner (line 8). Specifically, each method counts how many times other methods provided it with a better solution (for the helper planner described bellow). Each individual in the system also carries the history of methods that modified it in any way, and this information must be kept updated.

While the modifications (and especially the book-keeping of the information for planners) seem tedious, they can be implemented in a general way and most of the code can be shared by most of the methods.

Ii-B Planners

For the experiments in this paper, we designed a number of planners, that follow (with the exception of the random planner) the general template given in Algorithm 1. All the planners first initialize all the islands with the available methods uniformly, i.e. each method is executed the same number of times. In case there are more methods than islands, the methods that have not been executed have a higher priority to be executed during re-planning. The planners also observe the system and in case new islands are added during the run of the algorithm, they initialize them with a method.

From the observation of the system, that planner obtains the following features that can be used during re-planning:

  1. quantity of improvement – the number of times the given method improved the quality of the best solution,

  2. average fitness – the average fitness of solutions shared by the method with other methods,

  3. quantity of material – the number of distinct individuals each method shared with the rest of the methods,

  4. quality of material – the number of times the method created a solution that is among the best solutions for a pre-defined ,

  5. helper number – the number of times the method improved the quality of the current best solution of another method, and

  6. best solution contribution – the number of times the given method was used in the history of the best solution.

Features 1-3 can be computed directly by observing the solutions shared by the methods in the system. The helper number is computed by each of the methods and the planner can request this information. In order to compute the best solution contribution feature each individual contains its history that lists all the methods that were used to create it.

In the rest of this section, we describe the details of the planners we propose in this paper.

Random (P-R)

planner is the simplest planner and also serves as a baseline. It initializes the methods randomly and in each planning iteration, it randomly eliminates one method and replaces it with a new randomly chosen method.

Random with Guaranteed Chance (P-RG)

planner is a more sophisticated random planner – it ensures each method is executed at least once and at the same time, it ensures that there are always at least different types of methods. In case the number of different running methods drops under the threshold, a random method is killed and replaced by the method that have not run recently. If there are methods that have not yet run, the planner chooses the method that has the least quantity of improvement and replaces it with a random method that has not run. Otherwise, the planner acts as the random planner.

Method Description (P-MD)

is based on the idea that in the initial phases of the optimization, exploration is more important than exploitation. Therefore, it divides the optimization methods into two sets – exploitation and exploration ones. During the initialization, only exploration methods are used and during the computation, these are gradually replaced by the exploitation methods. Let be the number of exploration methods in the system, and be the number of all methods in the system. Let be the number of the current iteration and be the maximum number of iterations. If then the exploration method that achieved the least quantity of improvement is killed and replaced by the exploitation method that achieved the best average of fitness so far. In the last iterations of the planner only exploration methods are used. Newly added method is protected and cannot be killed for the first iterations. The division of the methods into the two groups is done manually.

Best Helper (P-BH)

planner is a planner based on the number of times a method helped another method to improve its solution since the last iteration of the planner. A method helped another method if the solution received by from is better than the currently best solution of method . In each planning iteration, the planner removes the method that helps the least and replaces is by the method, that helps the most. This planner does nothing in few first iterations, in order to wait for the performance of methods to stabilize.

Best Average Fitness (P-AF)

planner uses the history of distributed computing and removes the method that has sent individuals with the worst average fitness during the last planing iteration, while the method with the best average fitness value of outgoing individuals is duplicated. Newly added methods are protected and ensured to run for at least iterations.

Quantity of Improvement (P-QI)

planner uses the number of times each method produces a solution that is better than the current best one. During the initialization, methods are spread uniformly, and in each planning iteration, the method that produced the least number of improvements since the last re-planning is replaced by the method that produced the most improvements since the last re-planning. New methods are also protected for planning iterations.

Quantity Of Material (P-QM)

planner uses the information on the amount of distinct individuals sent by each method. During re-planning, the planner replaces the method that sent the smallest number of different individuals, by the method that created the largest number of different individuals. This planner also protects the newly started method for iterations.

Best Material (P-BM)

planner uses the information on the number of times the method provided a solution that is among the top solutions overall. In each planning iteration, the planner removes the method with the least number of top solutions since the last re-planning and replaces it with the method with the most top solutions.

Best Solution Contribution (P-BC)

planner determines the importance of computational methods using the history of the operations applied to create the best individual. From this history, the planner uses the information about the methods that helped to create the best solution. In each re-planning iteration, the method that is most common in the history of the best individual replaces the method that contributed the least. The planner does nothing in the first iterations.

Lazy Quantity Of Improvement (P-LQI)

planner is similar to the quantity of improvement planner, but removes the methods only in case they are not beneficial, i.e. it replaces a method only in case it did not make any improvement to the best solution during the last planning iterations. Such method is replaced with the one which achieved the greatest number of improvements during the last planner iteration. Newly added methods are protected for iterations.

Iii Experiment settings

In order to test the proposed portfolio selection algorithm, we ran a set of experiments where we compare the different planners to homogeneous island model running each of the optimization methods and to heterogeneous island model running all the methods, each in two instances, without re-planning (we also performed the same experiments with the single methods, which are equivalent to the homogeneous case without communication, but the results are generally worse than those with communication, therefore we do not present them here). The experiments are performed on five types of problems – traveling salesman problem, bin packing problem, continuous optimization problem, vertex cover problem, and tuning of machine-learning hyper-parameters. These problems use a wide range of encodings and different genetic operators.

In all of the experiments, the parameters of the planners are set the same and they are given in Table I. We used these values of the parameters based on some preliminary experiments. Based on the settings, we can see that each run of the optimization takes approximately 50 minutes on 16 CPUs. The optimization methods share the individuals every 5 seconds. The island model uses a fully connected topology, i.e. each method can directly communicate with any other method. The runs are repeated nine times for each combination of a problem and a planner.

Parameter Value
Number of iterations 50
Iteration length 60 s
Number of runs 9
Number of islands 16
5
3
3
3
TABLE I: The values of parameters shared by all the experiments (some of them are used by some planners only)

We have implemented seven different optimization methods – random search (RS), tabu search (TS), hill climbing (HC), simulated annealing (SA), evolutionary algorithm (EA), differential evolution (DE), and a brute force (BF) algorithm that performs a systematic search. All these share the following basic operators:

  • generate random solution – used by random search and in initialization of EA and DE,

  • generate next solution – used by the brute force method to generate the next solution systematically,

  • unary “mutation” operator – used as a mutation in the EA and also by the hill climbing, simulated annealing and tabu search to generate the next solution,

  • binary “crossover” operator – used by the EA as a crossover, and

  • ternary operator – used in the DE by the differential mutation.

There is no natural implementation of the last ternary operator in some cases, but we created an implementation nonetheless for the sake of completeness. We still call the resulting method “differential evolution”, although the only feature common to this method and the differential evolution is the use of the ternary operator.

Some parameters of the optimization methods are also set the same for all the experiments, these are given in Table II. The other parameters depend on the particular optimization problem and are discussed in the rest of this section.

Algorithm Parameter Value
Hill Climbing # of neighbors 10
Random Search
Evolution population size 10
mutation rate 0.9
crossover rate 0.1
selection bin. tourn.
Brute Force
Tabu Search tabuModelSize 50
Simulated Annealing temperature 10,000
coolingRate 0.002
Differential Evolution popSize 50
F 1
TABLE II: Parameters of the optimization methods

Iii-a Traveling Salesman Problem

The goal in the traveling salesman problem (TSP) is to find the shortest Hamiltonian cycle in a complete graph. For the experiments, we used two instances of the problem from the VLSI dataset1. One of them contains 1,083 cities (denoted as TSP1083 in the rest of this paper) and the other contains 662 cities (TSP662).

The TSP is a typical example of a problem, where the solutions are encoded as permutations. The permutation gives the order, in which the vertices of the graph should be visited.

In this case, the hill climbing, tabu search and simulated annealing use the 2-opt operator [15] to generate new solutions. The random search method generates new permutations randomly and the brute force algorithm generates the next permutation in each step. The evolutionary algorithm uses the 2-opt operator as a mutation and it additionally uses a single-point crossover [16] – a random crossover point is selected, the initial parts of the individuals are swapped and the rest of the individuals is filled by the rest of the numbers from the other parent in the order in which they appear in that parent.

We also wanted to use the differential evolution and therefore we created a special ternary operator: first, the two permutations are subtracted and their difference is added to a third permutation. Then, for each value in the vector, we remember the index of the vector component on which it is located and the pairs are sorted by values. The sequence of indices then forms a new permutation.

The optimization objective (and the values shown in the the results) is the length of the Hamiltonian cycle and should be minimized.

Iii-B Bin-packing Problem

In the bin-packing problem (BPP), objects of various volumes are packed into bins of limited volume. The goal is to minimize the number of bins used. The solution of such problems is also commonly represented by a permutation that is decoded using the First Fit algorithm [17] in order to compute the number of objectives. For the experiments, we generated a random instance of the BPP with 1,000 objects with volumes between 0 and 1 and bins with the volume of 1.

The random search, brute force and differential evolution methods generate the individuals in the same way as in the TSP problem. The hill climbing, tabu search, and simulated annealing use a displacement operator that moves a randomly selected number of consecutive values to the end of the permutation, the number of moved values is determined adaptively and is always less than 0.5 percent of all the values in the solution.

The evolutionary algorithm uses the order crossover [16] and a shift mutation that moves a random object to the end of the permutation.

The optimization objective is the number of bins and should be minimized.

Iii-C Continuous Optimization

The goal of continuous optimization (CO) is to find the minimum of a function in a multi-dimensional interval . The solution is thus encoded as a vector of numbers from this interval. For the experiments in this paper we selected four functions from the BBOB benchmark2 – the Büche-Rastrigin function (COf04), the Rosenbrock function (COf08), the Different Powers function (COf14) and the Schaffers function (COf17), all of them in 10-dimensional space. These specific functions were selected in order to evaluate the performance of the algorithm under different conditions regarding the multi-modality and separability of the functions.

The tabu search, hill climbing, and simulated annealing methods generate the new individuals by adding a random number between -0.0025 and 0.0025 to each coordinate in the vector. The evolutionary algorithm uses the same operator as a mutation and additionally uses the weighted average of the coordinates of the vectors with weights randomly generated between 0 and 1. The random search generates random vectors from the whole multi-dimensional interval. The differential evolution uses the common implementation with parameters given in Table II. Finally, the brute force algorithm performs a grid search in the whole multi-dimensional interval – it adds 0.005 to one of the coordinates in every step.

The optimization objective is directly the value of the function and should be minimized.

Iii-D Vertex Cover

In the vertex cover (VC) problem, a graph is given and the goal is to find the smallest set of vertices of the graph, such that all the edges are covered. The solution is thus represented by a subset of vertices forming a valid coverage. The objective is to minimize the number of vertices in the cover. In this case, we used two benchmarks from the BHOSLIB3, one with 1534 vertices (VCfrb59265) and the other with 4000 vertices (VCfrb10040).

The coverage is generally generated by starting from a smaller set of vertices and adding vertices until a coverage is created. In case of random search, the start is random and the vertices are also added randomly. In the hill climbing, tabu search and simulated annealing methods, five randomly selected vertices are removed and the cover is completed by adding (some of) their neighbors. The brute force algorithm generates all the subsets of the vertices and for subset that do not cover the whole graph, the cover is filled by adding random vertices. The evolutionary algorithm uses a mutation that removes three random vertices and finishes the cover by adding (some of) their neighbors. Finally, the differential evolution computes an intersection of two individuals and adds vertices from the third one until a valid cover is formed.

The optimization objective is the number of vertices in the cover and should be minimized.

Iii-E Hyper-parameter Tuning in ML

The final type of problem we investigate in this paper is the tuning of the hyper-parameters of the machine learning methods (ML), i.e. we are searching for a set of hyper-parameters, such that the error rate of the model is minimized. To this end, we used the random forest model as implemented in the Weka framework [18] and optimize its parameters for the wilt dataset from the UCI machine learning repository [19]. The goal of this dataset is a classification into two classes based on five attributes. The particular implementation of the random forest has the following parameters and we search their optimal values in the given range: , , , , , , , and .

The tabu search, simulated annealing, and hill climbing use an operator that changes a value by adding in case the parameter is an integer one and a random number less than 0.005 if the parameter is a real number. The random search generates a random set of the parameters, while the brute force method performs a grid search of the parameters. Evolution uses the operator used in simulated annealing as a mutation and additionally uses a one-point crossover. As all the arguments are numerical, the differential evolution works in the classical sense, the values just need to be rounded for the integer parameters after the operator is applied.

The optimization objective is the error rate of the model and should be minimized.

Iv Results

Optimization Method TSP1083 TSP662 BPP1000 VCfrb59265 VCfrb10040
Brute force
Differential evolution
Evolution
Hill Climbing
Random Search
Simulated annealing
Tabu search
Hetero - Static
Hetero - P-R
Hetero - P-RC
Hetero - P-MD
Hetero - P-LQI
Hetero - P-AF
Hetero - P-BH
Hetero - P-BM
Hetero - P-QI
Hetero - P-QM
Hetero - P-BC
Optimization method COf04 COf08 COf14 COf17 MLWilt
Brute force
Differential evolution
Evolution
Hill Climbing
Random Search
Simulated annealing
Tabu search
Hetero - Static
Hetero - P-R
Hetero - P-RG
Hetero - P-MD
Hetero - P-LQI
Hetero - P-AF
Hetero - P-BH
Hetero - P-BM
Hetero - P-QI
Hetero - P-QM
Hetero - P-BC
TABLE III: Results of the planners. The numbers represent the average value of the objective over nine independent runs. The numbers in subscript and superscript show the minimum and maximum value of the objective achieved in the experiments.

In order to run the experiments, all the above described methods were implemented in the JADE [20] multi-agent framework. It allows for simple implementation of distributed systems. Each of the islands corresponds to a single container running (apart from a few management agents) the optimization method, which is again implemented as another agent. The infrastructure provided by the JADE system makes the implementation of the communication and sharing in the system simple.

The results of the experiments are provided in Table III. It shows, for each of the problems and for each different setting of both homogeneous and heterogeneous islands the average objective value as well as the minimum and maximum objective over nine independent runs.

We can immediately see that, rather unsurprisingly, for the homogeneous models, different methods work better for different optimization problems. For the TSP and VC problems, the tabu search and hill climbing provide the best results, for the BPP, the best methods are tabu search and evolutionary algorithm. In continuous optimization, the differential evolution and evolutionary algorithm provide good results, and in some cases also hill climbing and tabu search work well. Finally, with the ML problem, the difference between the methods is rather small, still, evolution and differential evolution have the best average of the nine runs.

If we compare the static heterogeneous island where each method has two instances without re-planning, we can already see one of the advantages of the heterogeneous models – the results are always close the results of the best homogeneous method, in some cases (COf04 and ML) the results are even slightly better. This means that even without re-planning it may make sense to run heterogeneous models instead of the homogeneous ones, in case multiple CPUs are available and parallel optimization is desired. The use of heterogeneous islands seems to remove the need to select the correct optimization algorithm and can be in fact considered an algorithm selection method.

The different planners significantly influence the results. In all cases the best planner (for given problem) is better than the static case without re-planning. In fact, the heterogeneous model with the P-BM (best genetic material) planner has at least the same performance as the static heterogeneous model in most cases (except COf08, ML). A similar observation holds for the P-QI (quantity of improvement) planner.

The heterogeneous island model with re-planning also provides better results than the best homogeneous island model in six of the ten cases (one TSP benchmark, the bin-packing benchmark, and all four of the CO benchmarks). In the other cases, the homogeneous tabu search was better for the other TSP benchmark and for both the vertex cover benchmarks. The differential evolution and the evolutionary algorithms were better for the hyper-parameter tuning benchmark. However, in the latter case, the differences between the methods are negligible. In the cases where the homogeneous islands provided the best results, the difference between the homogeneous island and the best heterogeneous one were small. For example, in the TSP662 benchmark, the tabu search found on average solution of length 2997, while the P-QI found a solution of length 3005. The biggest difference between the homogeneous islands and the heterogeneous islands was observed on the VCfrb10040 benchmark, where the tabu search got a solution with average objective of 64.55 compared to the 68.44 for the best heterogeneous model.

TSP BP CO VCfrb ML Sum
Planner 1083 662 1000 f04 f08 f14 f17 10040 59265 Wilt
Static 0 1 0 0 0 1 2 0 1 4 9
P-R 0 2 0 1 7 3 3 1 0 1 18
P-RG 0 3 0 3 4 2 3 0 0 0 15
P-MD 0 0 8 6 1 0 3 0 1 3 22
P-LQI 4 5 4 2 1 3 0 2 1 1 23
P-AF 5 3 0 4 0 3 1 3 2 1 22
P-BH 0 1 0 1 3 4 4 2 0 3 18
P-BM 9 4 5 4 0 3 3 0 1 1 30
P-QI 6 3 2 2 4 5 3 3 0 1 29
P-QM 0 0 0 0 3 0 0 0 2 1 6
P-BC 0 2 2 1 1 0 2 4 0 2 14
TABLE IV: The number of times the given planner found a solution in the top quartile of the solutions found by all the methods.

In order to compare the various planners among themselves, we also computed how many times each planner found a results that is among the top results found overall. We define a results to be top if it is the top quartile of all the results found by all the methods. The results of this experiment are displayed in Table IV. As we made nine independent runs, the best a planner can achieve is to have all the nine results among the top overall. This happened only once for the P-BM planner in the TSP1083 benchmark. Overall, the P-BM planner and the P-QI planner provide the best results, with the former finding a top result in 30 cases and the latter providing such results in 29 cases. For comparison, the static heterogeneous islands found a top solution only in 9 runs.

Interestingly, the random planners provide quite good results for the CO benchmarks, where in one case the P-R planner found solution in the top quartile in 7 of the 9 runs. On the other hand, the random methods failed in most of the other benchmarks. The P-MD planner based on the method description obtained good results in the BP benchmark and in the COf04 benchmark (with 8 and 6 top results respectively), but in the rest of the benchmark its performance was rather poor. The P-BC planner is based on the history of the best individual and thus requires the most complex changes in the optimization methods. However, its performance is not very good (comparable to the random planners) and thus it does not seem to be worth the more complex implementation.

V Conclusion and Future Work

We presented an algorithm for online portfolio selection. The presented model is a generalization of the homogeneous island model to cases, where each island runs a different optimization method. As such, it can be considered a way how to create hybrid optimization algorithms. Thanks to the modular implementation, methods can be hybridized easily and the only requirement is that they share the encoding of the solution.

We have shown that the heterogeneous island model provides better or comparable results compared to the best method executed in the homogeneous island model. It means that if multiple CPU cores should be used for optimization and the method needs to be selected, it is better to use the heterogeneous model that selects the method automatically than using the homogeneous model and selecting the best method in multiple runs. As such, the heterogeneous models can also be consider and algorithm selection method without any interaction with the user.

So far, we have experimented with only seven different optimization methods with fixed parameters. However, in principle, we could used much more methods or different sets of their parameters. While methods with different parameters could be considered a completely different method and used in the same way as described in this paper. It may make sense to define a similarity between the methods and take it into account during the planning. Such extensions are left for future work.

Acknowledgment

Martin Pilát has been supported by Czech Science Foundation project number 17-17125Y. Štěpán Balcar has been supported by SVV project number SVV-2018-260451.

Footnotes

  1. http://www.math.uwaterloo.ca/tsp/vlsi/
  2. http://coco.gforge.inria.fr
  3. http://www.nlsde.buaa.edu.cn/k̃exu/benchmarks/graph-benchmarks.htm

References

  1. C.J. Colbourn and M.J. Colbourn. Algorithms in Combinatorial Design Theory. North-Holland Mathematics Studies. Elsevier Science, 1985.
  2. L. A. Rastrigin. About convergence of random search method in extremal control of multi-parameter systems. Avtomat. i Telemekh, 24:1467–1473, 1963.
  3. Christopher C. Skiścim and Bruce L. Golden. Optimization by simulated annealing: A preliminary computational study for the tsp. In Proceedings of the 15th Conference on Winter Simulation - Volume 2, WSC ’83, pages 523–535, Piscataway, NJ, USA, 1983. IEEE Press.
  4. Fred Glover. Future paths for integer programming and links to artificial intelligence. Comput. Oper. Res., 13(5):533–549, May 1986.
  5. John H. Holland. Adaptation in Natural and Artificial Systems: An Introductory Analysis with Applications to Biology, Control and Artificial Intelligence. MIT Press, Cambridge, MA, USA, 1992.
  6. Kenneth Price, Rainer M. Storn, and Jouni A. Lampinen. Differential Evolution: A Practical Approach to Global Optimization (Natural Computing Series). Springer-Verlag New York, Inc., Secaucus, NJ, USA, 2005.
  7. John R Rice. The algorithm selection problem. In Advances in computers, volume 15, pages 65–118. Elsevier, 1976.
  8. Pavel Brazdil, Christophe Giraud-Carrier, Carlos Soares, and Ricardo Vilalta. Metalearning: Applications to Data Mining. Springer Publishing Company, Incorporated, 1 edition, 2008.
  9. Carla P. Gomes and Bart Selman. Algorithm portfolios. Artificial Intelligence, 126(1):43 – 62, 2001.
  10. M Lindauer, H Hoos, and Frank Hutter. From sequential algorithm selection to parallel portfolio selection. In International Conference on Learning and Intelligent Optimization, pages 1–16. Springer, 2015.
  11. J. Kacprzyk and W. Pedrycz. Springer Handbook of Computational Intelligence. Springer Handbooks. Springer Berlin Heidelberg, 2015.
  12. Y. Gong and A. Fukunaga. Distributed island-model genetic algorithms using heterogeneous parameter settings. In 2011 IEEE Congress of Evolutionary Computation (CEC), pages 820–827, June 2011.
  13. M. Pilât and R. Neruda. Combining multiobjective and single-objective genetic algorithms in heterogeneous island model. In IEEE Congress on Evolutionary Computation, pages 1–8, July 2010.
  14. Štěpán Balcar and Martin Pilát. Heterogeneous island model with re-planning of methods. In GECCO 2018 (Companion), pages 1–2. ACM, 2018. accepted.
  15. Shen Lin. Computer solutions of the traveling salesman problem. The Bell System Technical Journal, 1965.
  16. A. E. Eiben and James E. Smith. Introduction to Evolutionary Computing. Springer Publishing Company, Incorporated, 2nd edition, 2015.
  17. J.D. Ullman. The Performance of a Memory Allocation Algorithm. Technical report (Princeton University. Dept. of Electrical Engineering. Computer Sciences Laboratory). Princeton University, 1971.
  18. Mark Hall, Eibe Frank, Geoffrey Holmes, Bernhard Pfahringer, Peter Reutemann, and Ian H. Witten. The weka data mining software: An update. SIGKDD Explor. Newsl., 11(1):10–18, November 2009.
  19. M. Lichman. UCI machine learning repository, 2013.
  20. Fabio Luigi Bellifemine, Giovanni Caire, and Dominic Greenwood. Developing multi-agent systems with JADE, volume 7. John Wiley & Sons, 2007.
202868
This is a comment super asjknd jkasnjk adsnkj
Upvote
Downvote
Edit
-  
Unpublish
""
The feedback must be of minumum 40 characters
The feedback must be of minumum 40 characters
Submit
Cancel
Comments 0
""
The feedback must be of minumum 40 characters
Add comment
Cancel

You are asking your first question!
How to quickly get a good answer:
  • Keep your question short and to the point
  • Check for grammar or spelling errors.
  • Phrase it like a question