https://doi.org/10.1007/s12293-020-00307-4 R E G U L A R R E S E A R C H P A P E R
A PSO-inspired architecture to hybridise multi-objective
metaheuristics
I. F. C. Fernandes1 · I. R. M. Silva2· E. F. G. Goldbarg1· S. M. D. M. Maia1· M. C. Goldbarg1 Received: 12 June 2019 / Accepted: 11 June 2020
© Springer-Verlag GmbH Germany, part of Springer Nature 2020
Abstract
Hybridisation is a technique that exploits and unites the best features of individual algorithms. The literature includes several hybridisation methodologies, among which there are general procedures, termed architectures, that provide generic function-alities and features for solving optimisation problems. Successful hybridisation methodologies have applied concepts of the multi-agent paradigm, such as cooperation and agent intelligence. However, there is still a lack concerning architectures for the hybridisation of multi-objective metaheuristics that fully explore these concepts. This study proposes a new architecture, named MO-MAHM, based on concepts from Particle Swarm Optimisation, to hybridise multi-objective metaheuristics. We apply the MO-MAHM to the Bi-objective Spanning Tree Problem. Four algorithms were hybridised within the MO-MAHM: three evolutionary algorithms and a local search method. We report the results of experiments with 180 instances, analyse the behaviour of the MO-MAHM, and compare to the results produced by algorithms proposed for the Bi-objective Spanning Tree Problem.
Keywords Multi-objective optimisation· Hybridisation of metaheuristics · Bi-objective spanning tree
1 Introduction
Metaheuristics are well-known high-level strategies able to perform robust heuristic searches, overcoming the difficulty of tackling NP-hard problems. Over the last decades, sev-eral works have proposed algorithms that combine different metaheuristic concepts and procedures, referred to as hybrid metaheuristics. Those approaches consist of exploiting and
B
I. F. C. Fernandes [email protected] I. R. M. Silva [email protected] E. F. G. Goldbarg [email protected] S. M. D. M. Maia [email protected] M. C. Goldbarg [email protected]1 Department of Informatics and Applied Mathematics,
Universidade Federal do Rio Grande do Norte, Campus Universitário Lagoa Nova, Natal, Brazil
2 School of Sciences and Technology, Universidade Federal do
Rio Grande do Norte, Campus Universitário Lagoa Nova, Natal, Brazil
uniting the best features of individual strategies and have obtained high-quality results for many optimisation prob-lems, including multi-objective ones. For example, recent works applied successful hybrid metaheuristics to multi-objective models for facial analysis [21] and data mining [12].
Silva et al. [23] presented an extensive survey and a comparative analysis of architectures that provide generic functionalities and features for solving problems using metaheuristics hybridisation. Architectures also referred in literature to as frameworks, can be understood in two ways. First, a tool that provides general classes, interfaces and soft-ware components, which can be customised for developing new optimisation problems applications through characteris-tics such as code reuse, flexibility, and portability. Second, a general procedure for implementing new algorithms capable of tackling arbitrary optimisation problems. In this paper, the word “architecture” is related to the latter meaning.
Among the features provided by architectures, Silva et al. [23] addressed the concept of agent intelligence and multi-agent paradigm. In this paradigm, multi-agents can learn from their past experiences and collaborate to achieve individual or col-lective goals [3]. Although several methods for metaheuristic hybridisation exist, there is still a lack in the literature
concerning architectures for multi-objective metaheuristics hybridisation that fully explore concepts from the multi-agent paradigm, as observed by [23]. Moreover, according to our best knowledge, it is not available in literature a general procedure for implementing hybrid multi-objective algorithms.
This article presents and analyses a Multi-agent Archi-tecture for Hybridisation of Multi-objective Metaheuristics (MO-MAHM). To accomplish this task, we extend the MAHM [24], an architecture for hybridisation of single-objective metaheuristics. The Particle Swarm Optimisation (PSO) metaheuristic was the inspiration for the MAHM in which particles are intelligent and autonomous agents able to learn, cooperate, make decisions, and move in the search space of an optimisation problem. To extend MAHM to the multi-objective context, we redefine some concepts such as particle position and velocity operator. MO-MAHM maintains the PSO inspiration and concepts of cooper-ation and agent intelligence from MAHM. Both MAHM and MO-MAHM can be viewed as general procedures for implementing hybrid metaheuristics for tackling an arbitrary optimisation problem. The first version of MO-MAHM, pre-sented by [22], was applied to the multi-objective Travelling Salesman Problem. We extend that work and test the MO-MAHM on the Bi-objective Spanning Tree Problem (BiST ). Spanning trees can be viewed as a model or topology that connects a set of entities without redundancy. The BiST is an NP-hard extension [1] of the Minimum Spanning Tree (MST ), in which two conflicting objectives are minimised simultaneously.
Investigations of this research concern MO-MAHM fea-tures, such as operators, cooperation among agents, and intrinsic parallelism. The architecture hybridised four algo-rithms: the transgenetic algorithm proposed by [16], NSGA-II [7], SPEA2 [28] and Anytime-PLS [8]. Experiments included 180 instances. Analyses took into consideration the impact of parallelism, cooperation and velocity operator, as well as the contribution of each metaheuristic hybridised. We com-pared the results produced by the MO-MAHM with those from classical hybridisations. Comparisons also concerned two algorithms proposed for multi-objective spanning trees: the non-generational genetic algorithm proposed by [5] and the GRASP from [2]. Analyses regarded the quality and diver-sity of solutions.
Section2 presents MO-MAHM. Section 3 presents the BiST. Section4presents the heuristics hybridised within MO-MAHM. Section5presents the application of MO-MAHM to the BiST. Section6reports experimental results and discus-sions. Finally, Sect.7presents conclusions and future works.
2
MO-MAHM: a multi-agent architecture for
hybridisation of multi-objective
metaheuristics
MO-MAHM is a generalisation for multi-objective problems of the MAHM (Multi-agent Architecture for Hybridisation of Metaheuristics) which was presented by [24] and designed to deal with single-objective problems. Particle Swarm Opti-misation (PSO) and intelligent agents were the concepts that inspired the creation of MAHM.
In MAHM, a population, P, of agents (particles) moves in the solution space of an optimisation problem to look for near-optimum solutions. Each particle is an autonomous and cooperative agent. The environment is the search space of the optimisation problem, the position of a particle is a feasible solution, and the quality of a position is the value of the objec-tive function. Each particle has a memory, where it maintains proprietary and acquired information. Proprietary informa-tion concerns procedures previously implemented for each particle. Acquired information concerns procedures learned from other agents or the environment. Each particle knows its current position and its best position achieved so far ( pbest). Besides, particles may know the best positions achieved so far by other particles. The implementations reported by [24] considered a social neighbourhood defined by the whole swarm. So, particles know the best position achieved so far by any other particle, denoted by gbest. pbest and gbest are acquired information.
Particles learn and make decisions about which action to take to move in the search space. They can learn from experience, along with the execution of the general algo-rithm (architecture), or from information about the problem or instance. For example, they can learn from improvements in their positions, parameters, statistics of success and fail-ure. Decision strategies are methods to select actions. Those strategies may be simple procedures, such as a roulette-wheel method, or enhanced by artificial intelligence techniques for decision support. Action strategies are exact or metaheuris-tic algorithms. There is a set of action strategies available for the swarm. Decision and action strategies are proprietary information. Different particles can use different strategies to learn and make decisions about which actions to take.
Cooperation among particles can occur in several ways. For example, they can share information about qualitative and quantitative parameters of the metaheuristics, successes and failures, and improvements of their positions. They may also exchange or donate solutions to other particles. They can choose between staying where they are or going to another position. If a particle chooses to go to another position, they do it employing a velocity operator. This operator can be any method that transforms a position (solution) into another. For example, a natural choice for this operator is a path-relinking procedure. Path-relinking is a metaheuristic proposed by [10]
that generates a path (a sequence of solutions) between two solutions: origin and destination.
According to the taxonomy presented by [26], MAHM is a general procedure for designing heterogeneous high-level teamwork hybrid algorithms for mono-objective problems. It involves different self-contained mono-objective algo-rithms that cooperate to find an optimum solution. There is no assumption about which algorithms to hybridise. MO-MAHM maintains the general framework from MO-MAHM, but some concepts and operators needed redefinition to fit the multi-objective context. The main differences between the single and multi-objective architectures concern the positions of the particles, the method to evaluate the positions and the velocity operator. In MO-MAHM, the position of a particle is a set of solutions. Since pbest and gbest are positions, they are also sets of solutions. The architecture uses a set of quality indicators designed to multi-objective problems to evaluate the positions of the particles. The velocity operator is any procedure that receives two or more sets of solutions and produces one set.
Algorithm 1 presents the pseudo-code of MO-MAHM. The algorithm loads the action, decision and learning strate-gies (lines1–3). The next step consists in defining the set of neighbours of each particle. In this study, we also consid-ered a social neighbourhood for all particles that consists of the best position achieved so far by any particle, gbest. The initial swarm, denoted by P, contains #num Par t agents. Procedure createParticles generates the initial population of particles. Subsets of decision, learning and action strategies are assigned to each particle. A metaheuristic chosen at ran-dom (uniformly) from the set of action strategies (line7) creates the initial position of each particle and assigns it to pbest (line7). MO-MAHM executes the search in the run-Particles procedure (pseudo-code shown in Algorithm2).
In Algorithm2, p selects learning, decision and action strategies (lines1–3) from the subsets assigned to it. Then, p executes an action strategy (line4). The set of solutions outputted by the action strategy becomes p’s current position. It occurs even if the new position is worse (regarding a quality indicator) than the original one. Since the position changes, the algorithm checks if it is necessary to update pbest and gbest (lines 5 and 8, respectively). If p decides to move to another position (line11), it chooses a destination among pbest and gbest. The algorithm applies the velocity operator (line13) and updates the learning strategy chosen by p (line
15).
Algorithm 1 The MO-MAHM Procedure
Input: #num Par t: int
1: AS← loadActionStrategies() 2: D S← loadDecisionStrategies() 3: L S← loadLearningStrategies() 4: gbest← {}
5: P← createParticles(#num Part, DS, LS, AS, gbest) 6: for all p∈ P do 7: initialise p.current_position 8: p.pbest ← p.current_position 9: end for 10: repeat 11: for all p∈ P do 12: runParticles( p) 13: end for
14: until a stopping criterion is satisfied 15: return gbest
Algorithm 2 runParticle procedure
Input: p: Particle
1: ls← p.selectLearningStrategy()
2: ds← p.selectDecisionStrategy()
3: as← p.selectActionStrategy(ls, ds)
4: p.current_position ← as.runActionStategy()
5: if p.current_position is better than p.pbest then 6: p.pbest ← p.current_position
7: end if
8: if p.current_position is better than gbest then 9: gbest← p.current_position
10: end if
11: if p moves then
12: dest← chooseFrom(p.pbest, gbest) 13: p.current_position ←
velocityOperator(p.current_position, dest) 14: end if
15: p.runLearningStrategy()
The hybridisation of algorithms in MO-MAHM occurs in two stages: action strategies and velocity operator. First, there is the application of different methods to the set of solutions that represent the position of a particle. Those methods are action strategies. Different paradigms can be the base for those methods, such as Pareto domination, decomposition, goal programming, and mathematical programming. Second, two (or more) sets of solutions can be combined by some heuristic when particles move from a position to another using the velocity operator.
3 Bi-objective spanning tree problem
Let G = (V , E) be an undirected connected graph, where V = {v1, v2, . . . , vn} is the set of vertices and E = {(vi, vj) | vi, vj ∈ V }, |E| = m, is the set of edges. We denote by w : E → q the function that assigns a vec-torwi j = (w1i j, wi j2, . . . , wqi j), q ≥ 2, of non-negative real weights to edge(vi, vj) ∈ E. A spanning tree T = (V , ET) of G is an acyclic spanning subgraph, ET ⊆ E. Let X be the set of all spanning trees of G, Z the objective space, and f : X → Z the function that associates T ∈ X to vector z = f (T ) ∈ Z. The Multi-objective Spanning Tree Problem (MoST ) aims at minimising z = f (T ), such that each element fk(T ), k ∈ {1, . . . , q}, of vector f (T ) = ( f1(T ), f2(T ), . . . , fq(T )), is defined by Eq. (1). fk(T ) = (i, j)∈ET wk i j (1)
The “minimisation” has to be understood in the context of multi-objective problems. In this study, this meaning refers to Pareto optimality. Let x1, x2 ∈ X be two feasible solutions and z1 = f (x1) and z2 = f (x2) their objective vectors. Vector z1weakly dominates z2, denoted by z1 z2, if and only if fk(x1) ≤ fk(x2), ∀k ∈ {1, . . . , q}. Vector z1 dom-inates z2, denoted by z1 ≺ z2, if and only if z1 z2and ∃k ∈ {1, . . . , q} such that fk(x1) < fk(x2). Vectors z1and z2are incomparable, denoted by z1||z2, if and only if z1 z2 and z2 z1. By abuse of language, the concepts of Pareto dominance extend to X , such that, for a dominance relation r el, x1r el x2⇔ z1r el z2. A solution x1is said efficient or Pareto optimal if and only ifx2∈ X such that x2≺ x1. The set X∗⊆ X of all efficient solutions is called Pareto optimal set and the minimal set Z∗ = f (X∗) ⊆ Z is called Pareto optimal front [14].
The goal of the MoST is to find the Pareto optimal set X∗ or the Pareto optimal front Z∗. The literature for the MoST includes exact and heuristic methods. Ruzika and Hamacher [19] reviewed the literature on minimum spanning tree prob-lems with two or more objective functions. Fernandes et al. [9] presented an experimental analysis of exact methods for the multi-objective spanning tree problem. The MoST is called Bi-objective Spanning Tree Problem (BiST ) when q = 2. The BiST is NP-hard [1] and the proof consists of a polynomial-time reduction of the 0/1 knapsack problem to the BiST.
4 Action strategies for the
BiST
We implemented four multi-objective metaheuristics for the BiST : a transgenetic algorithm, an NSGA-II, a SPEA2 and
the Anytime-PLS local search. We present these algorithms in the following sections.
4.1 TLP
The TLP is a transgenetic algorithm proposed by [16] for the BiST. Transgenetic algorithms are evolutionary techniques inspired by biological processes of horizontal gene transfer and endosymbiosis [11]. The transgenetic metaphor simu-lates endosymbiotic interactions between a genetic informa-tion repository (host cell) and a populainforma-tion of endosymbionts (solutions) by the action of agents called transgenetic vectors. These agents carry genetic information and manipulation rules to modify the endosymbionts. An endosymbiont is a solution (represented by a list of edges). The TLP maintains a population with # popSi ze endosymbionts. There is a global archive of non-dominated solutions, G_ A, that plays the role of the host’s repository. G_ A is limited to # popSi ze ele-ments and, in the implementation reported in this study, its filtering uses the adaptive grid technique proposed by [13] to update it.
The procedure to create the initial population consists of two methods: rmcPrim [13] and RandomWalk [18]. 90% of the initial population consists of solutions generated by the rmcPrim, and 10% consists of solutions generated by the RandomWalk method. The rmcPrim is a multi-objective greedy randomised extension of Prim’s algorithm [17], adapted from [13]. By using a scalarizing vector, the rmcPrim builds a solution likewise the Prim’s algorithm, except that the rmcPrim considers a restricted candidate list of edges (RCL). The RCL is a list of edges whose scalarized costs are at most(1 + #tol Perc%)c(e), where #tol Perc% ∈ [0, 1] is a parameter, e is the edge that would be chosen by the Prim’s algorithm, and c(e) is the scalarized cost of e. Every iteration, the rmcPrim selects from the RCL, with uniform probabil-ity, an edge that does not induce a cycle when inserted into the partial solution. The rmcPrim iterates up to building a spanning tree. Each solution, T , generated by the rmcPrim, is checked for insertion in G_ A. If T is non-dominated regarding the elements of G_ A, then T is inserted into the population and G_ A. Otherwise, the probability of inserting T in the population is 60%. The RandomWalk method iter-atively includes edges, at random, according to a uniform distribution, into an, initially, empty solution, up to building a spanning tree.
There are two types of transgenetic vectors: plasmids and transposons. A plasmid consists of genetic information and a method to insert the information into the endosymbionts. The information can come from the host’s repository (sim-ple plasmids) or a heuristic method (recombinant plasmids). The genetic information of a simple plasmid consists of a subtree obtained from a solution whose objective vector is in the least crowded cell of G_ A. The genetic information
of a recombinant plasmid comes from a partial solution built by the rmcPrim method. The length of the genetic informa-tion of both plasmid types is randomly chosen in the interval [0.25n, 0.50n]. Let s be an endosymbiont from the current population and p a (simple or recombinant) plasmid whose information is the string st. st is a set of edges that do not form cycles. Let s be an empty solution. p inserts st into s and continues including edges from s into s up to build a spanning tree or to have examined all edges from s. Edges from s that induce a cycle in s are discarded. If s is not a span-ning tree, p inserts edges from the original graph, at random, into s up to create a spanning tree.
Transposons are transgenetic vectors that disturb a restrict-ed area of an endosymbiont. There are two transposons: rem-Transp and primrem-Transp. Remrem-Transp removes, iteratively, one edge from s and replaces it by the best edge that recon-nects the tree. It executes #si ze Rem iterations. To compute edge costs, we scalarize the weights of the edge. Each edge removal/addition operation generates a new tree. There is a local archive of non-dominated solutions related to each endosymbiont. If a newly generated tree is non-dominated regarding the solutions in the local archive, it is added to the archive. RemTransp returns a solution randomly cho-sen from the local archive. PrimTransp removesμ edges from endosymbiont s,μ ∈ [0.9n,0.95n]. The higher the scalarized cost of an edge, the higher the probability to be removed. Then, primTransp rebuilds the solution with the rmcPrim method.
An endosymbiont s resulting from the manipulation of a plasmid or transposon replaces the original solution s in the current population if s ≺ s or if s in the G_ A such that s≺ s. Every iteration, a plasmid or a transposon manipulates each endosymbiont. The # pr ob Plasm parameter defines the probability of choosing a plasmid (1− # probPlasm, a transposon). The value of # pr ob Plasm remains fixed for #i nt Ger Set iterations, and then it is increased by a factor # pr obFactor . There is a set of #num Plas plasmids avail-able every iteration. A plasmid is chosen at random from that set. The algorithm randomly chooses between simple or recombinant plasmids with uniform probability. The algo-rithm also chooses between remTransp and primTransp at random. The probability associated to the remTransp trans-poson is # pr ob RemT r ansp (and 1− # probRemT ransp associated to primTransp).
4.2 NSGA-II
The Non-Dominated Sorting Genetic Algorithm (NSGA-II), introduced by [7], has been widely used for tackling multi-objective problems. It maintains a population, Pop, with # popSi ze individuals. Pop is submitted, every iteration, to genetic operators (mating selection, recombination, and mutation) for creating an offspring population, Pop. An
elitist scheme concerning Pareto dominance selects from Pop∪ Pop the individuals for the next generation. Every iteration, the algorithm splits the individuals from Pop∪Pop into different fronts according to the Pareto dominance rela-tion, creating dominance levels. The algorithm selects the best # popSi ze individuals from Pop∪ Pop to be the par-ents of the next generation.
The NSGA-II applied to the BiST creates the initial pop-ulation with the methods presented in Sect. 4.1. We used the list of edges data structure to encode the spanning trees. The mating selection scheme consists of a variation of the binary tournament presented by [20]. The algorithm ran-domly selects two pairs of individuals from Pop: the first pair competes in the first objective and the second one in the sec-ond objective. We adopted the recombination and mutation operators presented by [18]. The recombination operator uses the randomWalk method to build a tree from the union of the parental edge sets. The mutation adds a new edge to the tree and removes another randomly chosen from cycle created. Every iteration, the probabilities of applying the recombina-tion and mutarecombina-tion operators are defined, respectively, by the #r ateCr oss and #r ateMut parameters.
4.3 SPEA2
The Strength Pareto Evolutionary Algorithm (SPEA2), pro-posed by [28], employs a fitness assignment strategy, a nearest neighbour density estimation and an archive trun-cation method. Let Popi and E_ Ai be, respectively, the population and the external archive in the it h iteration of the SPEA2. Individuals in Popi and E_ Ai are associated with fitness values, which are calculated based on the concept of Pareto dominance and density estimation. In the stan-dard SPEA2, the density estimation is based on the nearest neighbour method. The next step copies all non-dominated solutions in Popi∪ E_Aito E_ Ai+1. If E_ Ai+1is less than the predefined archive size, then E_ Ai+1is filled with the dominated solutions with the best fitness. A truncation oper-ator is applied if the size of E_ Ai+1exceeds the predefined archive size, by iteratively removing from E_ Ai+1an indi-vidual with the minimum distance to its nearest neighbours on the objective space. When a stopping criterion is satisfied, the SPEA2 returns the non-dominated solutions in E_ Ai+1. The SPEA2 algorithm implemented for the BiST uses the method described in Sect.4.1to generate the initial popula-tion with size # popSi ze. It uses the same mating selecpopula-tion, recombination and mutation operators described in Sect.4.2.
4.4 Anytime-PLS
The Pareto Local Search (PLS) is a local search method based on Pareto dominance for multi-objective combina-torial optimisation problems. The anytime variation of the
PLS, proposed by [8], tailors the local search method to be effective at any termination time. Given an initial set of non-dominated solutions, S, the PLS iteratively selects at random a solution s∈ S, explores the neighbourhood of s, updates S with the non-dominated neighbours of s and removes dom-inated solutions from S. It stops when all solutions in S have been explored. However, since the neighbourhood may contain an exponential number of solutions, the PLS may require an extensive computational effort. Furthermore, the PLS presents a poor anytime behaviour, i.e., it does not guar-antee that S has high quality at any time during its execution [8]. The Anytime-PLS algorithm aims to obtain a high-quality approximation set regardless of when it finishes.
The Anytime-PLS implemented for the BiST executes until the exploration of all solutions finishes or until reaching the maximum number of iterations given by #max I ter , a user-defined parameter. Every iteration, the algorithm selects solution s ∈ S with the highest potential of improving the hypervolume of S. The optimistic hypervolume contribution (ohvc), defined by Eq. (2) for the bi-objective case, is the potential contribution to the hypervolume of S by the local ideal point defined by f(s) and f (s) [8], s, s ∈ S. Equa-tion (3) computes the Optimistic Hypervolume Improvement (OHI). Equations (4) and (5) calculate sinfand ssup, respec-tively. Every iteration, the algorithm selects to explore s∈ S, such that O H I(s) is maximum. Solutions s and sare neigh-bours if they share n−2 edges. The algorithm adds neighbour sto S if sdominates s and is non-dominated regarding the solutions in S. The exploration of s stops as soon as the pro-cedure accepts a neighbouring solution for inclusion in S. For the sake of simplicity, henceforth the Anytime-PLS is called APLS. ohvc(s, s) = ( f1(s) − f1(s)) ∗ ( f2(s) − f2(s)) (2) O H I(s) = ⎧ ⎪ ⎨ ⎪ ⎩
2∗ ohvc(ssup, s) i f sinf 2∗ ohvc(s, sinf) i f ssup
ohvc(ssup, s) + ohvc(s, sinf) otherwise (3)
sinf= arg max s∈S
{ f2(s) | f2(s) < f2(s)} (4) ssup= arg min
s∈S
{ f2(s) | f2(s) > f2(s)} (5)
5 A simple
MO-MAHM implementation for
the
BiST
This section presents a MO-MAHM implementation for the BiST. Section5.1presents the algorithm. Section5.2 intro-duces the learning, decision and action strategies. Section
5.3 presents an implementation of the velocity operator. Section5.4discusses issues regarding cooperation and par-allelism.
5.1 The general algorithm
MO-MAHM implementation maintains a set of particles (agents) that move in the search space (environment) and aim at finding near-optimum positions. The position of a particle is a set of non-dominated solutions, i.e., an approximation set. Any method used to assess the quality of non-dominated sets, for example, quality indicators, can be used to evaluate the set that represents the position of a particle. The imple-mentation for the BiST used the hypervolume (HV ) unary indicator proposed by [27]. The HV indicator measures the area of the bi-objective space dominated by an approximation set. It needs a reference point to bound the area. To obtain that reference point, we used the method described by [14]. That method normalises each objective in the range [1, 2] and uses(2.1, 2.1) as the reference point. Each particle has a memory that stores the information described in Sect.2. The pbest position related to particle p is the best approximation set achieved by p. The gbest is the best approximation set achieved by any particle.
Algorithm 3 MO-MAHM for the BiST
Input: #num Par t: int
1: AS← {TLP, NSGA-II, SPEA2, APLS} 2: for all a∈ AS hvi(a) ← 0 and count(a) ← 1 3: gbest← {}
4: P← createParticles(#num Part, AS, hvi, gbest) 5: for all p∈ P do 6: p.current_position = {} 7: p.pbest ← p.current_position 8: end for 9: repeat 10: for all p∈ P do 11: runParticles( p) 12: end for
13: until stop criterion 14: return (gbest)
Algorithm 3 presents the general pseudo-code of MO-MAHM for the BiST. The action strategies were the TLP, NSGA-II, SPEA2 and APLS (line 1). Variables hvi(a) and count(a) are associated to action strategy, a. These variables are indicators for the learning strategy (line2). The cr eate-Par ti cles procedure creates a set, P, of #num eate-Par t particles (line4). The sets that represent the position and the pbest of a particle are, initially, empty (lines6and7). The particles are processed (lines9–13) until a stop criterion is satisfied. For the investigation reported in this study, the stop criterion was 106evaluations of the objective function. The following section presents the description of the r un Par ti cles pro-cedure. The algorithm returns the set of solutions stored in gbest .
5.2 Learning, decision and action strategies
Each particle decides which strategy to use based on the benefit learnt about each metaheuristic. In the MO-MAHM implementation described in this study, particles learn from improvements of the unary HV indicator. The hvi variable associated with an action strategy reflects the HV improve-ment of the positions of the particles obtained by using that action strategy. Let H V(posp) and H V (posp) be the hyper-volumes of the position of particle p, respectively, before and after applying action strategy a. If H V(posp) > H V (posp), hvi(a) is incremented by H V (pos
p) − H V (posp). The count variable associated with action strategy a stores the number of times that a was applied so far along with the algo-rithm execution. The average improvement of action strategy a is given by Eq. (6).
hviav(a) = hvi(a)
count(a) (6)
Particles, in this MO-MAHM implementation, use the same decision method, described as follows. If the last action strategy executed by particle p resulted in a set better (concerning the hypervolume) than p.pbest or gbest, then p chooses that action for the next iteration. Otherwise, p randomly selects an action from the set of strategies. The roulette-wheel method based on the hviav indicator is the selection method used by p. Action strategies with higher hviavare more likely to be chosen.
Algorithm 4 presents the pseudo-code of the runParti-cles procedure. It computes the hypervolume of p’s position (line1), selects an action strategy (line2), and executes it (line3). The set outputted by that action becomes the current position of p. It occurs even if the set is worse than the original position of p. The goal is to diversify the search. The position of p is the input for the action strategy. In the first iteration, the position is an empty set. In this case, the procedure builds the initial set with the metaheuristic related to the action strat-egy. The count variable is updated. If p’s position improved, concerning the hypervolume, variable hvi is updated as well. If p’s position is better, regarding the H V indicator, than pbest or gbest, the latter sets are updated (lines9and12, respectively). Action strategies TLP, NSGA-II and SPEA2 iterate up to #max Gen generations. The APLS executes up to #max I ter iterations. #max Gen and #max I ter are user-defined parameters. Finally, p moves towards a destination chosen in the chooseFrom procedure (line14). The veloc-ity operator, described in Sect.5.3, executes the movement (line15). Initially, the probability of selecting pbest is 0.9 for all particles. When p achieves a better position after run-ning an action strategy, the probability of selecting pbest, assigned to p, increases in 0.1 (limited to 1.0). Otherwise, it
decreases by 0.1 (limited to 0.0). The probability of selecting gbest is the complement.
Algorithm 4 runParticle procedure for the BiST
Input: p: Particle
1: H V(posp) ← H V (p.current_position)
2: a← p.selectActionStrategy(hviav)
3: p.current_position ← a.runActionStategy() 4: count(a) ← count(a) + 1
5: if H V(p.current_position) > H V (posp) then
6: update hvi(a) 7: end if
8: if H V(p.current_position) is better than H V (p.pbest) then 9: p.pbest ← p.current_position
10: end if
11: if H V(p.current_position) is better than H V (gbest) then 12: gbest← p.current_position
13: end if
14: dest← chooseFrom(p.pbest, gbest) 15: p.current_position ←
velocityOperator(p.current_position, dest)
5.3 Velocity operator
Since the positions of the particles are sets of solutions, the velocity operator can be any method that receives two (or more) sets of solutions and produces a new set. In our exper-iments for the BiST, we applied a multi-objective version of the path-relinking metaheuristic. In this version, two sets of solutions, A and B, are the input for the velocity operator that outputs a third set, appr oxi mati on Set of non-dominated solutions. One of these sets, for example, A, contains the ori-gin solutions, and the other, B, the destinations. Let s and s be solutions from A and B, respectively. The path-relinking executes from s to s. The number of velocity operator exe-cutions is the minimum between the cardinalities of A and B.
Algorithm 5 velocityOperator procedure
Input: A, B : approximation sets
1: sort A and B by the first objective value 2: appr oxi mati on Set← {}
3: for i← 1 to min(|A|, |B|) do
4: set O f Soluti on← path Relinking(A[i], B[i]) 5: appr oxi mati on Set.insert(set O f Solution) 6: end for
7: return appr oxi mati on Set
Algorithm5presents the pseudo-code of the velocity oper-ator for the BiST. Sets A and B are the input. The output is appr oxi mati on Set. First, the algorithm sorts the solu-tions of A and B (line 1) in non-decreasing order of the first objective. The main loop iterates up to the size of the
smallest set among A and B. The path-relinking proce-dure (line4) creates a trajectory between solutions A[i] and B[i]. The set O f Solution set stores the solutions created in this trajectory (lines4–5). The appr oxi mati on Set.insert procedure updates appr oxi mati on Set filtering pairwise non-dominated solutions from appr oxi mati on Set∪set O f Soluti on. Let s ∈ A and s ∈ B be, respectively, the ori-gin and destination solution. The path-relinking trajectory between s and sis as follows. Let Es be the set of edges of solution s. Every iteration, the path-relinking procedure adds a random edge efrom Es − Es to s. This operation creates a cycle within s. The algorithm randomly picks up an edge e from that cycle, such that e /∈ Es, and removes it. The procedure stops when s= s.
5.4 Cooperation and parallelism
Researches on hybrid techniques have shown that the com-bination of different paradigms can lead to better search methods than those based on a sole metaheuristic [23]. In this sense, cooperation and parallelism play an essential role since methods based on these concepts can achieve more efficient behaviour when dealing with different types of problems and instances [3].
In the approach presented in this study, particles cooper-ate sharing information about the search. The best position achieved by the swarm, gbest, can be updated by any par-ticle and that information is available to all of them. The use of information about the best position can lead to better positions of individual particles. The swarm also shares the improvement of the hypervolume of the sets processed by each action strategy. When a particle employs some action strategy, a, and its position is improved, the value of variable hvi(a) increases. Also, the number of executions of each strategy is available for the swarm. The implementation of MO-MAHM can be sequential or parallel. The interaction of the particles can be easily parallelised. Each particle can be assigned to a processor or virtual thread.
6 Computational experiments and results
In this section, we report the results of experiments carried out to investigate the potential of the architecture pro-posed. Section 6.1 presents the assessment methodology. Section6.2shows the contribution of each action strategy for the search. Section6.3presents results from the investigation of the benefit of the velocity operator. Since the architec-ture is intrinsically parallel, Sect.6.4presents results from a comparison of the sequential and parallel versions of MO-MAHM. Section6.5presents the comparison of the results produced by the MO-MAHM with those obtained by hybridi-sations of the evolutionary algorithms and the local searchprocedure implemented in the architecture. This investiga-tion aimed at verifying whether results produced by some hybridisation were as good as the ones produced by the architecture. Those hybridisations, named HTLP, HNSGA-II and HSPEA2, concerned the TLP, NSGA-HNSGA-II and SPEA2, respectively with the APLS. Every iteration, after applying the evolutionary operators, the algorithm executes the APLS with the population as the input archive. Finally, Sect. 6.6
presents the results of the comparison between the architec-ture proposed and two algorithms presented in the literaarchitec-ture for the BiST : the GRASP presented by [2], and the genetic algorithm presented by [5]. The genetic algorithm is referred to as CHEN.
6.1 Methodology
The algorithms were implemented with C++ and GNU g++ 7.1 compiler. Experiments were carried out on cores of Intel Xeon processors E5-2698v3 with 2.3 GHz and 4Gb of RAM per core, running CentOS 6.5, 64 bits, which were pro-vided by the High Performance Computing Center at UFRN (NPAD/UFRN). There were 180 instances, divided into two sets, termed KNW and AVV. The results for each instance concern thirty independent executions of each algorithm. The tests comprised 165 complete graphs built with the method-ology proposed by [13], from 50 to 1000 vertices. Those instances are the KNW set. There are three classes of KNW instances: correlated, anti-correlated and concave. Each class contains 55 instances identified by n.I D, where n is the num-ber of vertices and I D = 1, 2, 3, 4, 5, refers to instances with similar features. Correlated instances identified with I D = 1, 2, 3, 4, 5 were generated with correlation factors 0.1, 0.3, 0.5, 0.7, 0.9, respectively. Anti-correlated instances I D = 1, 2, 3, 4, 5 were generated with correlation factors −0.1, −0.3, −0.5, −0.7, −0.9, respectively. Table1presents theη and ζ parameters used to generate the set of concave instances. Instances proposed by [2], termed AVV, were also tested. They are 15 complete graphs with n = 20, 30, 50 and edge weights uniformly distributed in ranges[30, 200] and[20, 100]. These instances are also identified by n.I D, I D= 1, 2, 3, 4, 5. There are five instances for each value of n.
The quality indicators used to assess the results were the hypervolume (HV ) [27], and the inverted generational distance (IGD) [29]. The computation of these indicators requires a reference set, R. It was computed, for each instance, by filtering the non-dominated vectors from the union of all approximation sets generated by all algorithms tested. The value of the HV quality indicator concerns the dif-ference between the approximation set and R, i.e., the lower the value, the better. The IGD measures diversity among the points of the approximation set. It computes the gap between approximation set Z∗ and R. Equation (7) computes the
Table 1 Parameters of concave instances ID 1 2 3 n η ζ η ζ η ζ 50 0.04000 0.01000 0.15000 0.01000 0.12500 0.02000 100 0.04000 0.00700 0.09000 0.00850 0.07000 0.01000 200 0.01250 0.00100 0.01300 0.00500 0.07000 0.00500 300 0.00100 0.00090 0.01500 0.00200 0.01000 0.00300 400 0.00850 0.00010 0.01000 0.00150 0.01700 0.00250 500 0.09000 0.00100 0.05000 0.00200 0.09000 0.00500 600 0.05000 0.00070 0.10000 0.00160 0.02000 0.00200 700 0.02000 0.00075 0.00800 0.00100 0.03000 0.00140 800 0.01000 0.00090 0.03500 0.00125 0.03000 0.00150 900 0.00500 0.00060 0.00900 0.00110 0.01000 0.00200 1000 0.10000 0.00030 0.15000 0.00060 0.20000 0.00100 4 5 η ζ η ζ 50 0.15000 0.00350 0.20000 0.00490 100 0.10000 0.02000 0.20000 0.03000 200 0.05600 0.00850 0.12000 0.01000 300 0.01500 0.00470 0.02000 0.00650 400 0.05000 0.00400 0.09000 0.00600 500 0.06000 0.00700 0.10000 0.01000 600 0.15000 0.00270 0.07000 0.00350 700 0.10000 0.00270 0.01000 0.00340 800 0.04500 0.00200 0.07000 0.00400 900 0.04500 0.00300 0.03000 0.00350 1000 0.25000 0.00300 0.30000 0.00700
IGD, where ds(r, Z∗) is the distance between r ∈ R and the nearest objective vector in Z∗.
I G D(Z∗, R) =
r∈Rds(r, Z∗)
|R| (7)
To check statistical differences among the results from the techniques implemented, we applied the Mann-Whitney test for experiments with two algorithmic versions (Sects.6.3
and 6.4) and the Kruskal-Wallis [6] for multiple testing (Sects.6.2,6.5and6.6), both with significance level 0.05. The codes for those tests are available in the PISA framework [4]. The Kruskal-Wallis test has two phases. The first phase verifies differences among the values of the indicators com-puted for the approximation sets produced by the algorithms. If the first test points out a significant difference, the second phase executes one-tailed pairwise comparisons between the results provided by the MO-MAHM and those from the other methods. Some results present percentages of instances for which an algorithmic version was better (worse) than others. To check whether there are significant differences in those percentages, we applied the one-tailed proportion test pre-sented by [25], with significance level 0.05.
Table 2 Parameter settings for TLP, NSGA-II, SPEA2 and APLS
Algorithm Parameter TLP #maxGen = 30 #popSize = 300 #numPlas = 10 #probPlasm = 0.5 #probFactor = 0.1 #intGerSet = 4 #probRemTransp = 0.3 #sizeRem = 0.05n #tolPerc% = 0.03 NSGA-II #popSize = 300 #maxGen = 40 #rateCross = 0.97 #rateMut = 0.04 SPEA2 #popSize = 300 #maxGen = 38 #rateCross = 0.98 #rateMut = 0.03 APLS #maxIter = 23
Table2shows the parameters of the action strategies. The parameters of the TLP came from the original work presented by [16]. Except for # popSi ze, we used the irace package [15] to tune the parameters of the NSGA-II, SPEA2 and APLS. The APLS deals with an archive limited to 300 solutions. The technique used to update that set was the adaptive grid archiv-ing [13]. The value for the # popSi ze parameter is the same used in the work presented by [16], # popSi ze= 300, and stands for the size of the sets representing particle positions (as explained in Sect.5). The irace also tuned the num-ber of particles of MO-MAHM: #num Par t = 8. Except for #max Gen, the values of the parameters of the HTLP, HNSGA-II and HSPEA2 are those shown in Table2. Theα parameter used in the GRASP applied to the AVV instances was the one presented by [2]:α = 0.08, 0.03, 0.01 for graphs with n = 20, 30, 50, respectively. The irace tuned the α parameter used in the application of the GRASP to the KNW instances: α = 0.03. Except for the population size, the CHEN algorithm used the parameters defined by [5]. The stop criterion for the algorithms was 106evaluations of the objective function. The number of evaluations was equally distributed among the particles.
6.2 Impact of action strategies
The elements for the analysis consist of statistics of suc-cesses, failures, and HV improvement. Success (failure), in this context, means to improve (worsen) the position of a particle regarding the HV indicator. The results were similar among the instances from the same KNW class (correlated, anti-correlated, and concave). Figures1,2 and3illustrate those results for the ID=2 group of each class. There are two y-axes in Figs.1,2and3. The bars are related to the first (left) y-axis that shows the average number of executions in which the action strategy in the x-axis succeeded or failed in improving the current positions of the particles. The line is related to the second y-axis that shows the average HV improvement.
Results for the correlated instances showed that parti-cles selected more frequently the SPEA2. The statistical test showed that the SPEA2 was more successful than the TLP for 34.55% of the correlated instances, NSGA-II for 25.45%, and APLS for 100.00%. The NSGA-II was the second most suc-cessful action strategy, followed by the TLP. Statistical tests showed that for 61.82% correlated instances, the SPEA2 and the NSGA-II behaved similarly regarding the number of suc-cessful executions. Figure1shows that, although the SPEA2 was the most selected technique, the HV improvement pro-duced by the NSGA-II was slightly better.
One could expect the average HV improvement directly correlated to the average number of successes or executions of each strategy. As Fig.1 illustrates (and also Figs. 2,3
), it is not always the case. Figure1 shows that the
aver-Fig. 1 Average number of successes, failures and average hypervolume
improvement for the ID = 2 correlated instances
Fig. 2 Average number of successes, failures and average hypervolume
improvement for the ID = 2 anti-correlated instances
Fig. 3 Average number of successes, failures and average hypervolume
improvement for the ID = 2 concave instances
age number of TLP and NSGA-II executions (successes + failures) is similar; however, the values of their HV are not. That figure also shows that, although the SPEA2 executes (and succeeds) more than the NSGA-II, the latter presents the best HV improvement. During execution, the HV contri-bution of each strategy varies, and maybe, for example, the case that one strategy executes more and is more successful than another. Still, at some point, the latter makes a signif-icant contribution to the variation of the HV. The tendency that the better the HV improvement, the more the strategy is executed confirms for the cases in which there are significant differences (2 decimal places) between the HV values. This observation proceeds, for example, in the comparison of the
evolutionary strategies and the APLS, for the three instance classes.
In the case of the anti-correlated class, the TLP was the action strategy most selected by the particles. The statistical test showed that the TLP was significantly more successful than the NSGA-II for 65.45% of the anti-correlated instances, than the SPEA2 for 54.55%, and than the APLS for and 100.00%. The SPEA2 was the second more preferred strategy in this case, followed by the NSGA-II. The SPEA2 suc-ceeded more than the NSGA-II for 52.73% of anti-correlated instances. Figure2shows that the TLP achieves the best HV improvement and, as expected, succeeds and executes more than the other strategies for instances of the ID=2 group. Although the SPEA2 executes and succeeds more than the NSGA-II, the HV improvement does not reflect this fact.
Particles preferred the SPEA2 for the concave instances. It was followed by the NSGA-II, TLP, and APLS. SPEA2 was more successful than the TLP for 89.09% of the concave instances, than the NSGA-II for 34.55%, and than the APLS for 100.00%. Figure3shows that particles chose the APLS strategy for concave instances more than for the other classes. However, the number of failures of that strategy surpasses the number of successes. It can be the case that the APLS pro-duced a significant HV improvement at some points, yielding an associated probability value good enough to be chosen on future iterations.
The TLP was the most effective action strategy in improv-ing the HV for the n.1 and n.5 correlated groups, the n.1, n.2 and n.3 anti-correlated groups, and the n.4 concave one. The NSGA-II was the most effective action strategy for the n.2 and n.4 correlated groups, for the n.4 and n.5 anti-correlated groups and for the n.1 and n.5 concave ones.
These results show that all action strategies contribute to the search. Besides, the particles tend to learn the best behaviours and select the best strategies regarding the qual-ity indicator implemented.
6.3 Experiments concerning the velocity operator
This section presents results from the investigation of the ben-efit of using the velocity operator described in Sect.5.3. That investigation concerned the KNW instances and the H V and I G D indicators. We compared the architecture behaviour with and without the velocity operator and investigated the number of instances for which that operator was advanta-geous. Figure4shows the percentage of instances on which each version produced conclusively better results than the other for each instance class. It also presents the percentage of cases on which the test was inconclusive. Those results show that both indicators agree regarding the correlated class, i.e., the velocity operator is advantageous concerning the qual-ity and diversqual-ity of solutions. There is significant differences since the p values computed from the proportion test were
0.00 for both indicators. Similar results occurred for the con-cave class. In this case, the p values from the proportion test were 0.00 and 0.000004 regarding the HV and the IGD indi-cator, respectively. The proportion test also showed that the version without the velocity operator was the best one for the anti-correlated class. The p values for the HV and IGD were 0.974 and 1, respectively.
Concerning the velocity operator, the experiments showed that the benefit that comes from its use depends on the instances or problem features. The correlation factor influ-enced the results. Regarding the HV, for increasing cor-relation factors, the velocity operator promoted increasing improvements in the search process. This fact may be related to the number of non-dominated solutions and the method implemented in the operator. As the correlation factor decreases, the number of non-dominated solutions increases. Recall that path-relinking builds a trajectory between two solutions. Thus, it plays the role of a type of local search in the space near the input solutions. The results showed that for the KNW instances with a high number of non-dominated solutions, the anti-correlated class, the type of local search promoted by the path-relinking drained the search resources to small areas of the space of solutions. So, the version with-out that operator, was able to spread more the solutions, since the evolutionary algorithms tend to explore different areas of the search space.
6.4 Experiments concerning parallelism
This section presents results from tests of parallel and sequen-tial versions of the architecture applied to the KNW instances. As explained in Sect.5.4, the cooperation can be more robust in parallelism. The goal of this test was to investigate whether cooperation between agents could improve by parallel pro-cessing. The parallel version assigns each particle to a virtual thread. Figure5presents the results. The graphics show the percentage of instances for which those versions achieved the best results. They also show the percentage of instances for which results were inconclusive, i.e., the statistical test did not point out significant differences.
The graphics show that the parallel version was signif-icantly better than the sequential one for the three instance classes, regarding both quality indicators. The statistical pro-portion test produced p values= 0.00 for all comparisons. These results show that cooperation among the agents was conclusively beneficial for the search. It occurred since, in the parallel version, agents access information shared by the swarm more promptly than in the sequential version. In the latter, agents starve other agents’ information in the sequence of execution. So, the more widespread access to information in the parallel version benefited the search.
Fig. 4 Impact of the velocity operator on KNW instances
Fig. 5 Impact of the parallelism on KNW instances
6.5 Comparison with hybrid versions of the
algorithms implemented in the
MO-MAHM
This section presents the results of comparisons between the MO-MAHM and the hybrid versions of algorithms imple-mented within the architecture. Sections 6.5.1 and 6.5.2
present the results for the KNW and AVV instances, respec-tively.
6.5.1 Investigation of the potential of the MO-MAHM concerning the KNW instances
The first phase of the Kruskal–Wallis test pointed out sig-nificant differences regarding the HV and IGD indicators for all KNW instances. According to the pairwise test, the MO-MAHM produced better HV and IGD values than the hybrid algorithms for most KNW instances. Figures6,7and
8 summarise the results for the correlated, anti-correlated and concave instances, respectively. The bars show the per-centage of instances for which the MO-MAHM achieved significantly better or worse results than the algorithm shown
in the x-axis. A third bar shows the percentage of instances for which the results were not conclusive in favour of one tech-nique (from the two tested). The results shown in Figs.6,7
and8reinforce the fact that the good behaviour of the MO-MAHM does not come from a well-suited hybridisation of an evolutionary algorithm and a local search. It comes from the cooperation of the agents. The p values from the proportion test were 0.00 for all comparisons.
6.5.2 Investigation of the potential of theMO-MAHM concerning the AVV instances
The first phase of the Kruskal–Wallis test showed signifi-cantly different results for all AVV instances. The pairwise test showed that the MO-MAHM behaved significantly better than the HNSGA-II and HSPEA2 for all instances, regard-ing both quality indicators. Significant differences were not pointed out by the pairwise test between the MO-MAHM and the HTLP regarding both indicators for AVV instances with n = 30. Table3shows the results of the comparison. Values less than 0.05 indicate best results for the MO-MAHM, higher
Fig. 6 Percentage of correlated instances for which the MO-MAHM was significantly better than the hybrid algorithms
Fig. 7 Percentage of anti-correlated instances for which the MO-MAHM was significantly better than the hybrid algorithms
Table 3 One-tailed p values from the Kruskal–Wallis pairwise test for
the MO-MAHM and the HTLP
ID/n 20 30 50
HV IGD HV IGD HV IGD
1 0.000 0.000 0.704 0.621 0.039 0.004
2 0.000 0.000 0.065 0.226 0.892 0.072
3 0.000 0.000 0.634 0.459 0.435 0.004
4 0.020 0.007 0.171 0.456 0.021 0.000
5 0.000 0.000 0.433 0.311 0.414 0.001
Fig. 9 Percentage of KNW instances for which the MO-MAHM was
significantly better than the GRASP regarding both HV and IGD
than 0.95 indicate best results for the HTLP, and the result is not conclusive for values between 0.05 and 0.95. The results show that the HTLP does not outperform the MO-MAHM on any instance.
6.6 Comparison with algorithms proposed for the
multi-objective spanning tree
The report in this section concerns comparisons with the non-generational genetic algorithm and the GRASP proposed by [2] and [5], respectively. The Kruskal–Wallis test pointed out significant differences regarding both indicators for all KNW and AVV instances. The p values from the pairwise test, the MO-MAHM behaved significantly better than the genetic algorithm for all KNW and AVV instances. That test calculated p values less than 0.05, for all instances. Concern-ing the comparison with the GRASP, the pairwise test did not indicate significant difference between the results from the MO-MAHM and GRASP for the 300.1 KNW instance. Except for that instance, MO-MAHM produced conclusively better H V and I G D values than the GRASP for all instances. Fig-ure9summarises the results from the comparison between the MO-MAHM and the GRASP. It shows the percentage of KNW instances for which the results from MO-MAHM were better or worse than those from GRASP. The graphic was the same for both indicators.
7 Conclusion
This study presented a new architecture for hybridising algo-rithms for multi-objective problems. The architecture, named MO-MAHM, is inspired by Particle Swarm Optimisation and multi-agent systems. It bridges a lack in the multi-objective hybridisation literature concerning architectures that explore cooperation and agent intelligence. According to the taxon-omy proposed by [26], MO-MAHM is a general procedure for designing heterogeneous high-level teamwork hybrid multi-objective algorithms.
To illustrate the potential of the architecture proposed, we presented a simplified implementation of MO-MAHM for the bi-objective spanning tree. The architecture hybridised three evolutionary algorithms and a local search. Tests com-prised 180 complete graphs from 20 to 1000 vertices. We investigated features of the architecture, such as cooperation of the agents, which is a reflex of their learning, decision and action strategies, an operator that moves the agent in the search space, and the potential for parallelism. We also inves-tigated the potential of the architecture regarding the heuristic algorithms implemented within it. Besides, we compared the results of MO-MAHM to those produced by two algorithms from the literature proposed for the multi-objective spanning tree: a GRASP [2] and a genetic algorithm [5]. The analyses concerned two quality indicators widely used in the multi-objective optimisation literature: the hypervolume and the inverted generational distance. Statistical tests pointed out that, regarding both indicators, in general, the MO-MAHM yielded high quality and diverse approximation sets.
Many design issues motivate an in-depth investigation. Future works can investigate enhancing MO-MAHM with the use of Artificial Intelligence techniques for learning and decision support, hybridisation of other metaheuristics and methods, including decomposition-based techniques, preference-based methods, and mathematical programming, and the extension of the architecture to many-objective prob-lems.
Acknowledgements We thank Arroyo, Vieira and Viana who kindly
provided us the instances used to test the GRASP algorithm. This research was partially supported by the High Performance Computing Center at Universidade Federal do Rio Grande do Norte (NPAD/UFRN), by the Coordination for the Improvement of Higher Education Personnel (CAPES), and by the National Council for Scientific and Technolog-ical Development (CNPq), Brazil, under Grants 302387/2016-1 and 306702/2017-7.
References
1. Aggarwal V, Aneja Y, Nair K (1982) Minimal spanning tree subject to a side constraint. Comput Oper Res 9(4):287–296
2. Arroyo JEC, Vieira PS, Vianna DS (2008) A GRASP algorithm for the multi-criteria minimum spanning tree problem. Ann Oper Res 159(1):125–133
3. Aydin ME (2012) Coordinating metaheuristic agents with swarm intelligence. J Intell Manuf 23(4):991–999
4. Bleuler A, Laumanns M, Thiele L, Zitzler E (2003) PISA—a plat-form and programming language independent interface for search algorithms. In: Fonseca CM, Fleming PJ, Zitzler E, Deb K, Thiele L (eds) Evolutionary multi-criterion optimization (EMO 2003). Springer, Berlin, pp 494–508
5. Chen G, Chen S, Guo W, Chen H (2007) The multi-criteria min-imum spanning tree problem based genetic algorithm. Inf Sci 117(22):5050–5063
6. Conover WJ (1980) Practical nonparametric statistics. Wiley, New York
7. Deb K, Pratap A, Agarwal S, Meyarivan T (2002) A fast and eli-tist multiobjective genetic algorithm: NSGA-II. IEEE Trans Evol Comput 6(2):182–197
8. Dubois-Lacoste J, López-Ibáñez M, Stützle T (2015) Anytime pareto local search. Eur J Oper Res 243(2):369–385
9. Fernandes IFC, Goldbarg EFG, Maia SMDM, Goldbarg MC (2020) Empirical study of exact algorithms for the multi-objective span-ning tree. Comput Optim Appl 75(2):561–605
10. Glover F, Laguna M, Marti R (2000) Fundamentals of scatter search and path relinking. Control Cybern 29(3):653–684
11. Goldbarg EFG, Goldbarg MC (2009) Transgenetic algorithm: a new endosymbiotic approach for evolutionary algorithms. In: Abraham A et al (eds) Foundations of computational intelligence, vol 3. Springer, Berlin, pp 425–460
12. Hammami M, Bechikh S, Hung C, Said LB (2019) A multi-objective hybrid filter-wrapper evolutionary approach for feature selection. Memet Comput 11(2):193–208
13. Knowles JD (2002) Local-search and hybrid evolutionary algo-rithms for Pareto optimization. Ph.D. Thesis, Unpublished Ph.D. Thesis, Department of Computer Science, University of Reading, Reading, UK
14. Knowles JD, Thiele L, Zitzler E (2005) A tutorial on the perfor-mance assessment of stochastic multiobjective optimizers, Com-puter Engineering and Networks Laboratory (TIK), Swiss Federal Institute of Technology (ETH) Zurich, Swiss, vol 214
15. López-Ibáñez M, Dubois-Lacoste J, Cáceres LP, Birattari M, Stüt-zle T (2016) The irace package: iterated racing for automatic algorithm configuration. Oper Res Perspect 3:43–58
16. Monteiro SMD, Goldbarg EFG, Goldbarg MC (2010) A new trans-genetic approach for the biobjective spanning tree problem. In: IEEE CEC 2010: proceedings of IEEE congress on evolutionary computation Barcelona, Spain, pp 519–526
17. Prim RC (1957) Shortest connection networks and some general-izations. Bell Syst Techn J 36(6):1389–1401
18. Raidl GR, Julstrom BA (2003) Edge sets: an effective evolutionary coding of spanning trees. IEEE Trans Evol Comput 7(3):225–239
19. Ruzika S, Hamacher HW (2009) A survey on multiple objective minimum spanning tree problems. In: Lerner J et al (eds) Algo-rithmics of large and complex networks. Springer, Heidelberg, pp 104–116
20. Rocha DAM, Goldbarg EFG, Goldbarg MC (2006) A memetic algorithm for the biobjective minimum spanning tree problem. In: EvoCOP 2006: proceedings of 6th European conference on evo-lutionary computation in combinatorial optimization. Budapest, Hungary, pp 222–233
21. Sattar A, Seguier R (2010) HMOAM: hybrid multi-objective genetic optimization for facial analysis by appearance model. Memet Comput 2(1):25–46
22. Silva IRM, Goldbarg EFG, Carvalho EB, Goldbarg MC (2017) A parallel Multi-agent Architecture for Hybridization of metaheuris-tics for multi-objective problems. In: IEEE CEC 2017: proceedings of IEEE congress on evolutionary computation. San Sebastián, Spain, pp 580–587
23. Silva MAL, Souza SR, Souza MJF, França Filho MF (2018) Hybrid metaheuristics and multi-agent systems for solving optimization problems: a review of frameworks and a comparative analysis. Appl Soft Comput 71:433–459
24. Souza GR, Goldbarg EFG, Canuto AMP, Goldbarg MC, Ramos ICO (2018) MAHM: a PSO-based multiagent architecture for hybridisation of metaheuristics. In: Tan Y (ed) Swarm intelligence—volume 1: principles, current algorithms and meth-ods, pp 237–264
25. Taillard ÉD, Waelti P, Zuber J (2008) Few statistical tests for pro-portions comparison. Eur J Oper Res 185(3):1336–1350 26. Talbi E (2015) Hybrid metaheuristics for multi-objective
optimiza-tion. J Algorithms Comput Technol 9(1):41–63
27. Zitzler E, Thiele L (1998) Multiobjective optimization using evolu-tionary algorithms—a comparative case study. In: Parallel problem solving from nature, PPSN V: 5th international conference. The Netherlands, Amsterdam, pp 292–301
28. Zitzler E, Laumanns M, Thiele L (2001) SPEA2: improving the strength Pareto evolutionary algorithm, TIK-report, Eidgenössis-che TechnisEidgenössis-che Hochschule Zürich (ETH), Institut für TechnisEidgenössis-che Informatik und Kommunikationsnetze (TIK), vol 103
29. Zitzler E, Thiele L, Laumanns M, Fonseca CM, Da Fonseca VG (2003) Performance assessment of multiobjective optimizers: an analysis and review. IEEE Trans Evol Comput 7(2):117–132
Publisher’s Note Springer Nature remains neutral with regard to
