A bi-level encoding scheme for the clustered shortest-path tree problem in multifactorial optimization
Huynh Thi Thanh Binh, Ta Bao Thang, Nguyen Duc Thai, Pham Dinh Thanh
AA bi-level encoding scheme for the clustered shortest-path tree problem inmultifactorial optimization
Huynh Thi Thanh Binh a , Ta Bao Thang a , Nguyen Duc Thai a , Pham Dinh Thanh b, ∗ a School of Information and Communication Technology, Hanoi University of Science and Technology, Vietnam b Faculty of Natural Science and Technology, Taybac University, Vietnam
Abstract
The Clustered Shortest-Path Tree Problem (CluSPT) plays an important role in various types of optimiza-tion problems in real-life. Recently, some Multifactorial Evolutionary Algorithms (MFEAs) have been in-troduced to deal with the CluSPT, but these researches still have some shortcomings, such as evolutionoperators only perform on complete graphs and huge resource consumption for finding the solution on largesearch spaces. To overcome these limitations, this paper describes an MFEA-based approach to solve theCluSPT. The proposed algorithm utilizes Dijkstra’s algorithm to construct the spanning trees in clusterswhile using evolutionary operators for building the spanning tree connecting clusters. This approach takesadvantage of both exact and approximate algorithms, so it enables the algorithm to function e ffi ciently oncomplete and sparse graphs alike. Furthermore, evolutionary operators such as individual encoding and de-coding methods are also designed with great consideration regarding performance and memory usage. Wehave included proof of the repairing method’s e ffi cacy in ensuring all solutions are valid. We have conductedtests on various types of Euclidean instances to assess the e ff ectiveness of the proposed algorithm and meth-ods. Experiment results point out the e ff ectiveness of the proposed algorithm existing heuristic algorithmsin most of the test cases. The impact of the proposed MFEA was analyzed, and a possible influential factorthat may be useful for further study was also pointed out. Keywords:
Multifactorial Evolutionary Algorithm, Clustered Shortest-Path Tree Problem, EvolutionaryAlgorithms, Multifactorial Optimization
1. Introduction
In the years following massive globalization e ff orts, clustered problems have found great interest, notonly within the confinement of research communities but even more so from members of governments,international enterprises, or streaming services. This need for an ordered structure in a world that growsincreasingly closer in proximity comes about as a natural consequence, and so too arises the need to solvea problem whose ever-present trace can be found in this internationalized age. Evidently, there are moreobvious examples of goods delivery within metropolitan areas and large-scale shipments between countries.There is also the problem of schedule planning for public transportation, optimization of the distribution ∗ Corresponding author.
Email addresses: [email protected] (Huynh Thi Thanh Binh), [email protected] (Ta Bao Thang), [email protected] (Nguyen Duc Thai), [email protected], [email protected] (Pham Dinh Thanh )
Preprint submitted to Journal of L A TEX Templates February 22, 2021 a r X i v : . [ c s . A I] F e b etwork for streaming services, the arrangement of stores within shopping malls, and on the more abstract,conceptual side, structuring human resources of a project. One of the better known clustered tree problems isa variant of the shortest path tree problem, named Clustered Shortest-Path Tree Problem (CluSPT) [1]. BeingNP-Hard, the preferred method to tackle this problem has mainly by means of approximation algorithms,as solving a large instance of the CluSPT using exact approaches is unfeasible and quite literally a waste oftime.A family of global optimization algorithms that has found considerable success in dealing with NP-Hardproblems are Evolutionary Algorithms (EAs) [2, 3]. These algorithms based their mechanisms on Darwin’stheory of evolution and natural selection. Essentially, a multitude of solutions will first be randomized,encoded in a way that the solutions are susceptible to changes by evolution operators, namely mutationand crossover, which will be further elaborated later on in this paper. The quality of solutions, henceforth becalled as individuals, should increase upon subsequent generation. While EAs themselves have been subjectsof research since the 1990s or, if one were to consider their more remote conception, the 1970s, this paper isbased on a recent variation of the algorithm, the Multifactorial Evolutionary Algorithm (MFEA) [4, 5]. TheMFEA operates on the same principle as the EA, but with a few adjustments to let it solve multiple problemsat once as opposed to the EA. This fundamental change di ff ers the MFEA greatly from its ancestor, usingthe fitness landscapes of multiple problems to help complement each problem’s solution, a concept knownas cultural transmission, whereas the EA has to navigate this fitness landscape alone and thus more prone tostuck in local optimal. The MFEA has found great success in solving di ff erent types of problems due to thisimplicit genetic transfer between tasks in a multitasking environment [6–8].Accordingly, the MFEA has been used in many research dealing with the CluSPT [9–12], applyingdi ff erent evolutionary operators and mechanisms to the base algorithm. However, because the MFEA solvesmultiple problems concurrently, each one with their own restrictions and distinct search space, many of theseresearches could not confidently satisfy all these restrictions, even if all the problems the MFEA has to solveis the same type with di ff erent inputs. As a result, the final solution sometimes turns out to be an invalid one,incompatible with the original search space. This paper introduces an approach that is capable of remedyingthis fatal drawback. Furthermore, as this approach combines both the approximation aspect of the MFEAand the exact aspect of Dijkstra’s algorithm [13], it also improves the ultimate solutions, when compared topast algorithms on the CluSPT. Finally, we test the algorithm’s e ff ectiveness when using multiple parents inthe crossover process instead of the default two.The major contributions of this work are as follows: • Develop a new solution representation for the CluSPT, thus reducing resource consumption. Thisenhancement becomes especially more noticeable for instances of large proportion, whose populationgrows exponentially with size to ensure randomness and diversity. • Devise a novel two-level scheme to solve the nested structure of the CluSPT: tree containing sub-trees.This scheme divides the CluSPT into an approximation problem and an exact problem, resulting inbetter solutions compared to pure approximation approaches while reducing the computational timeas opposed to exact approaches. • Propose a method to repair invalid individuals, ensuring that proposed evolutionary operators alwaysproduce a valid solution. The maximum number of fixes on an individual is also provided and proven. • Design a crossover operator that can work with multiple parents. • Propose an e ff ective memory-based method to calculate the cost of CluSPT solution to increase thealgorithm’s performance. 2 Analyze the experimental results on a diverse range of test instances, with additional comparison toother algorithms, to demonstrate this proposed algorithm’s e ffi cacy.The rest of this paper is organized as follows. Section 2 presents the notations and definitions used forformulating problem. Section 3 introduced related works. The proposed MFEA for the CluSPT is elaboratedin Section 4. Section 5 explains the setup of our experiments and analyzes the computed results. The paperconcludes in Section 6 with discussions on the future extension of this research.
2. Problem definition and notations
The CluSPT is defined on a simple, connected and undirected graph G ( V , E , C , w , s ) with a set of vertices V , a set of edges E , a set of clusters C , a weight matrix w , and a source vertex s , respectively. Set of verticesV is divided into m clusters C j , j = ... m , V = C ∪ C ∪ ... ∪ C m and set of clusters C = { C , C , ..., C m } .A solution to this problem is a spanning tree T whose sum of routing cost from the source vertex s to allvertices in V is minimum and the subgraph induced by all vertices in each cluster is also a spanning tree.Given a spanning tree T of G , let d T ( u , v ) denotes the shortest path length between u and v on T . TheCluSPT is defined as following: Clustered Shortest-Path Tree ProblemInput : - A weighted undirected graph G = ( V , E , w ).- Vertex set V is partitioned into k clusters V , V , ..., V k .- A source vertex s . Output : - A spanning tree T of G - Sub-graph T [ V i ]( i = , . . . , k ) is a connected graph. Objective : (cid:88) v ∈ V d T ( s , v ) → minwhere d T ( u , v ) is the cost of shortest path from vertex u to vertex v on T . Definition 2.1.
For each cluster C j in G , C j ∗ denotes the set of vertices connecting directly to vertices inother clusters. We call it the inter-vertices set of that cluster. An example is shown in Figure 1. Figure 1(a)presents an initial input graph G has 14 vertices and 3 clusters. Figure 1(b) presents the set of inter-verticesof the corresponding cluster in G . Definition 2.2.
In the spanning tree T obtained from the CluSPT problem, we denote a cluster’s level by itsproximity to the root cluster. The level of the cluster that contains the source vertex s is 0, the cluster directlyconnected to it is level 1, the cluster directly connected to a level 1 cluster is level 2,...etc. It is obvious thateach non-root cluster has a single vertex serving as the entrance from a lower level cluster. We call this thelocal root of the cluster. Lemma 2.1.
Each cluster in the spanning tree T has only one local root.Proof.
Assume that a cluster has more than one local root. Without loss of generality, we consider two localroots r and r of this cluster. There must exist a path p s , r from the source vertex s of T to r without goingthrough r and a path p s , r from source vertex s of T to r without going through r . In addition, the vertices r , r belonging to the same cluster, so they will connect with each other, i.e there exists a path p r , r from r to r . As a result, a cycle exists on T illustrated in Figure 2. This contradicts the requirement of T being3 a) (b) Figure 1: Sets of inter-vertices of the corresponding clusters in graph Figure 2: A spanning tree if exits a clus-ter having two local roots a spanning tree. The assumption is thus proven wrong. Therefore, each cluster in T has only one local rootmeaning that every path from source vertex s to vertices in a cluster in T must go through its local root.Also, starting from s , a local root must be the first vertex to be visited within its own cluster. Because alocal root is connected to a cluster of the lower level, the vertices selected as the local root of a cluster are inthe cluster’s inter-vertices set. It is for this reason that we have deemed only the inter-vertices necessary forbeing encoded.
3. Related works
Researches on cluster problems could be traced back to the 1970s [14]. One of the earliest related studiesis the Clustered Traveling Salesman Problem [15, 16], whose objective is to determine the Hamiltonian pathwith a minimum length such that all vertices in each cluster are visited consecutively. As a cluster problem,the CluSPT [1] has just recently been explored but has already attracted much interest from the researchcommunity. Because CluSPT is NP-Hard, exact algorithms for such problems require exponential executiontime and are only suitable for small instances. Therefore the approximation approaches are more suitable todeal with the CluSPT.In recent literature, MFEA [17] has been emerging as an e ff ective framework to solve a wide range ofoptimization problems. MFEA surpasses traditional EA [18] in its ability to simultaneously solve multipleproblems, especially for systems with limited computational resources. Some preliminary works have beencarried out, suggesting that MFEA is able to utilize the knowledge exchanging across relevant tasks tofacilitate finding optimal solutions for multiple problems at the same time [19].Consider Parting Ways [20], the authors proposed a new mechanism to reallocate resources within theprocess of MFEA. This mechanism has stemmed from the observation that while exchanging genetic ma-terial across tasks is beneficial to the evolutionary algorithm’s performance, but it can at times weakenexploitation and consume needless resources. More specifically, it is noted that the o ff spring generated fromparents with di ff erent skill factors (called divergents) may help with the preservation of diversity within the4opulation and allow information sharing to occur between tasks. However, as the population begins con-verging toward the optima of tasks, such contributions are irrelevant and, in cases, become obstacles for theconvergence process. Therefore, a new measure ASRD, or Accumulated Survival Rate of divergents, wasproposed to detect the point where information sharing is no longer desirable. In each generation, a ratio ofdivergents is created and survives to the next generation. The ASRD is the total of this ratio observed in asliding window manner over several generations. Once ASRD is lower than a parameter value, the algorithmis set to never produce any divergent for the remaining duration.According to Group-based [21], the authors aimed to improve the MFEA by mean of a clustering-basedapproach. It was discovered that in MFEA, the closer the global optima of two tasks are, or in general, themore similar the landscapes of two tasks are, the more likely it is for information sharing to have a positiveimpact. A new mechanism is built upon this discovery to maximize the advantage of information sharing inMFEA. More specifically, while the landscapes of tasks are mostly unknown, they can be roughly estimatedby the distribution of the fittest individuals for each task. The new MFEA picks a representative for eachtask before comparing them using Manhattan distance, e ff ectively clustering these representatives based ontheir likeness in genetic structure. Some representatives are further tested by exploring other clusters withregard to their skill factors. Should any cluster proved fruitful for the representatives, and more broadlyfor the task at which the representative is best at, improvement, then the representatives will be reassignedto such groups. Within one group, mating is only permitted if it could create better o ff spring. In addition,the authors also proposed a selection criterion to balance fitness value and diversity both in the mating andenvironmental selection (choosing individuals for the next generation) stage. This criterion is determined bythe individual normalized fitness value and its crowding distance from its neighbors, together monitored bya balancing factor α .In Dynamic Resource Allocation [6], the authors designed a way of dynamically reallocating resourcesfor each task in MFEA and a method to control information sharing inside a particular task and across tasks.It is a fact that in solving multiple tasks, rarely comes the case where each task is of approximately equalhardness. Thus, it appears counter-intuitive to distribute computational resources equally among the tasks.The new mechanism split the population into subpopulation, each specializing in one task. A subpopulationconsists of a specific number of fittest individuals for that task along with some random individuals, thenumber of whom monitored by a learning parameter that updates itself every iteration, whose participationserves to introduce cross-domain genetic information. All subpopulations then run through several genera-tions to record the improvement of population ω k . This measurement is the ratio of change between a task’sbest fitness value of this generation and the one some generation before. The greater the ratio, that is, themore the best fitness value improves, the better the chance of a task being selected for resource allocation,denoted by Index of Improvement, or IoI. The IoI of a task is its improvement of the population over thetotal of all improvement of population. Thus, an IoI exists in the range of [0,1], and the selecting process isa Roulette one.Yuan Yuan et al. [22] investigated the use of MFEA, specifically on Permutation-based CombinatorialOptimization Problems. The authors noted that the use of random key encoding for chromosomes provedine ff ective for this kind of problem and suggested another unified representation scheme and a new survivorselection method. Since the chromosome for each task is always a permutation sequence, the new represen-tation has the unified chromosome be a sequence of the task with the highest dimension. For each task, itsimply removes genes with values greater than the task’s dimension while keeping the remaining genes inthe same order. The introduced survivor selection method, dubbed as Level-based Selection, or LBS, sortthe population into K lists corresponding to K optimization tasks. After the mating stage and all o ff springhave been put into the lists with regard to their skill factor, the list is sorted in ascending order (assuming,without loss of generality, that the tasks are minimization tasks), and an individual position in its list denotes5ts level. The population of the next generation is chosen from across all lists, and an individual can neverbe chosen if there is still another individual with a lower level in one of the lists.Improvements upon the original MFEA have been met with considerable success. MFEA-II [19], fromthe same authors, tackled the centralizing idea of the algorithm itself: the knowledge transfer between tasks.While individuals excelling in the same task can reproduce freely, on the intra-task crossover, MFEA allowsonly a fixed percentage of the population (this percentage denoted by random mating probability, or rmp ).This paper thus described in detail a probability-based system to measure the e ff ectiveness of this knowledgetransfer. In essence, as each task still exists individually, that is, separated into their own solution spaces(and by mean of MFEA can they find a common representation), the intra-task learning process may proveitself an obstacle for reaching optimal solutions. This is where MFEA-II comes into play, an algorithmthat can adapt and change accordingly the rmp and, if need be, cut o ff knowledge transfer altogether. Ifprevious MFEA algorithms have depended on a fixed rmp (commonly 0.5), MFEA-II formulates rmp as a n × n matrix, assuming the number of tasks is n . This matrix reflects the relationship between tasks, with rmp a , b denotes how well task a and task b influence each other. Naturally, the matrix is symmetrical, as therelation between task a and task b is the same as task b and task a . As each task corresponds perfectly toitself, the main diagonal line is all 1. This rmp matrix changes itself upon each iteration, each generation,eventually erasing bad relationships while promoting good ones. The MFEA-II has found great success onmany di ff erent implementations, surpassing state-of-the-art strategies like separable natural evolutionarystrategy or exponential natural evolutionary strategy .In recent years, some approximation approaches were developed for solving CluSPT. In [9], the authorsproposed MFEA (hereinafter E-MFEA) with new genetic operator algorithm. The major idea of this novelgenetic operators is that first comes the construction of a spanning tree for the smallest sub-graph, afterwardspanning trees for larger sub-graphs are created from the spanning tree of smaller sub-graphs. In [10], theauthors took advantage of the Cayley code to encode the solution of CluSPT and proposed genetic opera-tors. The genetic operators introduced here are, conceptually, similar to the genetic operator for binary andpermutation representations. However, it limits its application to complete graphs only. Therefore, the novelMFEA, too, is suitable exclusively for complete graphs. Binh at.el. [23] discussed a new algorithm based onthe EA and Dijkstra’s Algorithm. In a divide and conquer fashion, the proposed algorithm decomposes theCluSPT problem into two sub-problems. The first sub-problem’s solution is found by an EA, while Dijk-stra’s Algorithm solves the second sub-problem. The goal of the first sub-problem is to determine a spanningtree that connects among the clusters, while that of the second sub-problem is to determine the best-spanningtree for each cluster. In [12], the authors described a method of applying MFEA based on deconstructing anoriginal problem into two problems. In the proposed MFEA, the second task plays a role as a local searchmethod for improving the solutions that are determined in the first task.Although some MFEA algorithms were proposed for solving CluSPT problem in practice, they haverevealed multiple drawbacks, i.e., only applicable on complete graphs, ine ffi cient for finding the solutionon large search spaces, each task only finds the solution of a di ff erent problem (di ff erences in problemformulation or dimensionality) or the proposed evolution operators are only suitable for the CluSPT problem.Therefore, to overcome these drawbacks, a new MFEA based approach is henceforth introduced to solveCluSPT problems.
4. Proposed Algorithm
In this section, we introduce an approach based on MFEA with new encoding, decoding, and repairingschemes as well as new evolutionary operators to solve multiple CluSPT problems simultaneously. Eachproblem is interpreted as a single task in the multitasking environment. The i th CluSPT task is performed6n a input graph G i = ( V i , E i , w i , s i ) , i = , . . . , K where V i , E i , w i , s i are set of vertices, set of edges, weightmatrix and source vertex, respectively. V i is divided into m i clusters. The j th cluster of the i th task is denotedby C ji , j = , . . . , m i and C i = { C i , C i , . . . , C m i i } . The local root of the j th cluster of the i th task is denotedby r ji . The proposed algorithm’s structure is presented in Algorithm 1, and the implementation steps of thealgorithm are discussed in detail in the following subsections. The traditional EA process has typically been focused on e ffi ciently solving a single optimization prob-lem at a time. Each solution for a problem has a private representation separately. In MFEA, the representa-tions of solutions in particular problems are combined into the unified representation to reduce computationaltime and take advantage of the transfer of knowledge among tasks when solving them simultaneously.The Unified Search Space (USS) for K tasks of the CluSPT is a graph G u ( V , C , m ) where: • The set of vertices V of G u is partitioned into m clusters where m = max( m , m , . . . , m K ) and m i , i = , . . . , K is the number of clusters of the i th task. • The j th cluster of G u is denoted by C j , and C j = C j ∗ ∪ C j ∗ ∪ . . . ∪ C j ∗ K where C j ∗ i is the set of inter-verticesof the j th cluster in the i th task. • The set of clusters C = { C , C , . . . , C m } .Figure 3 illustrates steps to construct a graph G u ( V , C , m ) of the USS from the graphs of two tasks T and T . Figure 3(a) and Figure 3(c) describe the input graphs of the two tasks where graph G contains 14 verticeswhile graph G consists of 19 vertices. From the input graph of each task, we remove all vertices that donot directly connect to another cluster, leaving each cluster only with inter-vertices and their correspondingedges, resulting in the graphs G (cid:48) and G (cid:48) , as shown in the Figure 3(b) and Figure 3(d), respectively. Theremaining vertices all fulfill the requirement of a local root. Next, we group vertices from di ff erent tasksby the index of their respective cluster. It should be noted that a vertex could potentially exist in di ff erentclusters of the graph G u because it represents a local root belonging to completely di ff erent tasks. Figure 3(e)shows a graph of the USS obtained, and the red area in each cluster denotes the vertices used for the firsttask while the orange area marked the vertices for the second task.An individual in the USS is an array of vertices whose the i th element is a vertex belonging the i th clusterin G u . Figure 4 illustrate an individual in the USS which is created from the graph G u in Figure 3(e).From this unified representation, we construct solutions for tasks through three main phases. Initially, adecoding phase is applied to find the private representation of the individual for each task. Afterward, therepairing phase will be conducted if needed in tasks so that a spanning tree can be built. Finally, a two-levelconstruction strategy is conducted to build a CluSPT solution on the representation obtained after the above2 phases. We will provide in-depth descriptions of the three phases in subsections 4.3, 4.4 and 4.5. With the advantage of the individual representation in the form of an array of integers, as shown insubsection 4.1, the initialization, crossover, and mutation methods can be done easily and e ff ectively. Eachelement in the individual is selected randomly from the cluster of the graph G u ( V , C , m ) built in the previoussection. The initialization method details are presented in Algorithm 2 with time complexity of O ( m ).7 lgorithm 1: Proposed Algorithm to solve multiple the CluSPT problems begin t ← /* Initialize initial population */ P (0) ← Randomly generate N individuals from USS (cid:46) Refer to Algorithm 2; foreach individual p i ∈ P (0) do Assign skill factor τ i = i % N + Construct the private representation sr i of individual p i in task τ i (cid:46) Refer to Algorithm 3; if p i doesn’t have a valid representation then Perform the Repairing Individual Method on sr i (cid:46) Refer to Algorithm 4; Construct a two-level solution of the CluSPT p (cid:48) i based on sr i (cid:46) Refer to Algorithm 5; Evaluate p i based on the CluSPT solution p (cid:48) i for task τ i only; end Update scalar fitness of each individual in P (0); while stopping conditions are not satisfied do O ff spring population P c ( t ) ← ∅ ; while | P c ( t ) | < N do Choose k individuals p i ( i = , . . . , k ) randomly from P ( t ); /* Perform crossover operator */ if (All selected individuals have same a skill factor) or (rand < rmp) then o i ( i = , . . . , k ) ← Perform the multi-parent crossover on p i ( i = , . . . , k ) (cid:46) Refer toAlgorithm 6; The skill factor of o i ← Select randomly the skill factor of the parent; else /* Perform mutation operator */ o i ← Perform mutation on each individual p i ( i = , . . . , k ) (cid:46) Refer to Algorithm 7; The skill factor of o i ← the skill factor of the individual p i ( i = , . . . , k ); end /* Construct the CluSPT solution and evaluate the offspring */ Decode the private representation sr i of each individual o i (cid:46) Refer to Algorithm 3; if sr i is invalid then Repair sr i (cid:46) Refer to Algorithm 4; Construct the CluSPT solution based on the sr i (cid:46) Refer to Algorithm 5; Evaluate o i for task corresponding to assigned skill factor only; P c ( t ) ← P c ( t ) ∪ { o i } , i = , . . . , k ; end P B ( t ) ← the top 50% best individuals from P ( t ); R ( t ) ← P c ( t ) ∪ P B ( t ); Update scalar fitness of each individual in R ( t ); P ( t + ← Get N fittest individuals from R ( t ); t ← t + end end a) (b)(c) (d) (e) Figure 3: An example of a graph of the USS for MFEA with two tasks
This section describes a decoding method to construct an individual in each task from an individual inUSS.Each task’s individual is an integer array whose dimension equals the number of clusters in that task.The i th element is used to determine the local root of the i th cluster unless said cluster contains the sourcevertex of the input graph, in which case that source vertex will be the local root of the cluster. In all othercases, let l be the vertex corresponding to the i th element. If l can be found within the cluster, we make itthe local root. Otherwise, we locate the maximum index of vertex l among the i th clusters of all tasks. Thisis a guarantee due to the way we initialize the chromosome. We then take the vertex whose index is theremainder of the division between the maximum index found earlier and the cluster’s size. The method isdescribed in Algorithm 3 with time complexity of O ( m ), where m is the number of clusters. Figure 4: An example of an individual in the USS lgorithm 2: Initialization Individual Method
Input:
Graph G u ( V , C , m ) Output:
An individual in the USS begin I ← {} ; for k ← do h ← Random a vertex in C k ; I ← I ∪ { h } ; end return I; endAlgorithm 3: Proposed Decoding Method
Input: • An input graph of the i th task G i ( V i , E i , C i , C ∗ i , s i , m i ), C i = { C i , C i , ..., C m i i } and C ∗ i = { C ∗ i , C ∗ i , ..., C m i ∗ i } . • A graph G u ( V , E , C , m ). • An individual in the USS I = { r , r , ..., r m } Output:
An representation of individual in space search of the i th task begin Genes ← []; for j ← to m i do l ← r j (cid:46) Value of the j th element in genes of individual I ; if vertex l doesn’t appear in C j ∗ i of G i then p ← find maximum index of vertex l in C j ∗ h , ∀ h ∈ [1 , . . . , K ] and ( h (cid:44) i ); size j ← the number of elements in C j ∗ i ; p ← p mod size j ; l ← value of the p th element in C j ∗ i ; end Genes .append( l ); end return Genes ; end a) (b) Figure 5: An example of steps of the decoding method to generate individuals for the tasks from an individual in USS
Figure 5 illustrates how the decoding method constructs the individuals in tasks 1 and 2 from the unifiedrepresentation. Figure 5(a) provides a graph of the USS G u = ( V , C , m ) with 4 clusters ( m = C ∗ = { , , } , C ∗ = { , , } , C ∗ = { , , } and in Task 2 are C ∗ = { , , } , C ∗ = { , , } , C ∗ = { , , , } , C ∗ = { , , , , } , respectively. The decodingprocess for Task 1 is as follow. Vertex 7 doesn’t appear in C ∗ and the maximum index of vertex 7 in cluster1 of other tasks (Task 2) is 2, so we choose a corresponding vertex to vertex 7 in the representation of Task1. Vertex 5 is chosen since it has index 2 ( = C ∗ . Vertex 14 appears in C ∗ , and thusit is added directly into the chromosome of Task 1. Vertex 6 doesn’t exist within C ∗ and its maximumindex in cluster 3 of the other task is 0, therefore vertex 9 having index 0 ( = Although the individual representation as the proposed encoding method has many advantages in storing,calculating, and executing evolutionary operators, it contains a weakness that can be exploited in incompletegraphs. Because the inter-vertices that are elected as the root of clusters are randomly selected, they maynot guarantee connectivity between clusters and violate the local root properties. An example is depicted inFigure 6(a).In this example, Figure 6(a) presents the input graph of the task, Figure 6(b) shows a representation of anindividual obtained after the first decoding stage, which doesn’t guarantee local root properties of clusters.As shown in Figure 6(b), vertex 12, 8, and 19 are assigned to be the local root of clusters 2, 3, and 4,respectively. However, in the input graph, there is no path from 1 (source vertex) to 8 and 19, such that theymust be the first visited vertices of their corresponding clusters, i.e., the local root property of the selectedvertices cannot be guaranteed.Therefore, a Repairing Individual Method (RIM) is introduced to fix this errors. Steps of RIM are asfollows: 11 tep 1 : Add the cluster containing the source vertex to the closed set V (cid:48) . Step 2 : Among the remaining clusters, RIM adds into V (cid:48) all those whose local roots are connected to anyvertex in V (cid:48) . Step 3 : If there are still clusters outside of V’ after step 2 then do:(a) Randomize an edge ( u , v ) with v ∈ V (cid:48) and u (cid:60) V (cid:48) .(b) Determine the cluster containing u and change the local root of that cluster into u .(c) Add vertices of that cluster to set V (cid:48) . Step 4 : Repeat step 2 and step 3 until all clusters are added to V (cid:48) . (a) (b) (c)(d) (e) (f) Figure 6: An example of steps to repair a individual representation lgorithm 4: Repairing Individual Method
Input:
An input graph of the i th task G i ( V i , E i , C i , C ∗ i , s i , m i ) where C i = { C i , C i , ..., C m i i } , C ∗ i = { C ∗ i , C ∗ i , ..., C m i ∗ i } .An individual representation of the i th task I = { r , r , ..., r m i } . Output:
A valid representation of I begin C mi ← Determine the cluster containing the source vertex s i of G i ; I [ m ] ← s i ; C (cid:48) ← { C ∗ i ∪ C ∗ i ∪ . . . ∪ C m i ∗ i } ; V (cid:48) ← C m ∗ i (cid:46) Add the cluster containing source vertex to set V (cid:48) ; visited [ r j ] ← f alse ∀ r j ∈ I ; visited [ s i ] ← true ; dem ← m i − while dem > do existsEdge ← false; /* Add clusters whose local root connects directly to at least one vertex inV’ to V’ */ foreach r ∈ I do if (visited [ r ] (cid:44) true) and ( ∃ an edge e = ( r , k ) , k ∈ V (cid:48) ) then Determine cluster C j ∗ i containing vertex r ; V (cid:48) ← V (cid:48) ∪ C j ∗ i ; dem ← dem − visited [ r ] ← true; existsEdge ← true; break; end end /* If no remaining cluster has an explicit connection to at least one vertexin V’ through their local root, change the local root of a remaining randomcluster */ if existsEdge = f alse then Select randomly an edge e = ( h , k ), h ∈ V (cid:48) and k ∈ C (cid:48) \ V (cid:48) ; Determine cluster C j ∗ i containing vertex k ; V (cid:48) ← C j ∗ i ; dem ← dem − Replace the local root of cluster C ji in I by the vertex k ; visited [ k ] ← true; end return I ; end end O ( m ∗| C (cid:48) | ) where m , C (cid:48) are the number of clusters and vertices set of the graph in the USS.Figures 6(c)–6(f) describe how the RIM is carried out. The chromosome has been decoded for this task,and the designated local roots are 3, 12, 8, and 19. As vertex 3 is in the same cluster as the source vertex1, 1 is chosen as the first cluster’s local root. In Figure 6(c), we add cluster 1 into V (cid:48) and now only cluster2 is directly connected to V (cid:48) through the edge (1,12) (highlighted in red). Thus, cluster 2 is added into V (cid:48) ,as shown in Figure 6(d). Next, since both cluster 3 and 4 lack an explicit connection to V (cid:48) from their localroots, we instead randomize an edge satisfies this condition. It can be seen that the edges (3, 6), (3, 9), (6,11), (18, 13), (14, 7), (14, 13) and (11, 14) are eligible for selection. Let the edge (11, 14) be chosen, wechange the local root of cluster 4 into 14 and add cluster 4 into V (cid:48) (Figure 6(e)). Finally, we run throughthe clusters outside of V (cid:48) again, in this case only cluster 3, and find that it is connected to V (cid:48) using (8, 19).Cluster 3 is now added into V (cid:48) , and the resulting local roots are now guaranteed to produce a spanning tree.Furthermore, to show RIM ’s e ffi cacy, we have provided and proven a lemma about the maximum numberof positions to be fixed on the representation of each individual in Lemma 4.1. Lemma 4.1.
The maximum number of positions that must be fixed on the genes is (cid:98) m / (cid:99) with m is the sizeof genes.Proof. Assume that we construct a graph G by considering a cluster as a vertex. An edge between twovertices v and v exists in G if cluster 1 connects to cluster 2 via its local root or vice versa. Because eachelement in representation is an inter-vertex that always has at least an edge connecting to another cluster’svertex (local root’s property), each vertex in G is always connecting to another vertex. Therefore, in theworst case, G is a forest with (cid:98) m / (cid:99) connected components. To connect these connected components, it isnecessary to modify one cluster’s local root in each component. For that reason, the maximum number ofpositions in the representation that need to be corrected is (cid:98) m / (cid:99) . To evaluate an individual in a task, we need to construct a CluSPT solution based on that individual.Therefore, this section describes a method (called (CSC)), which builds a CluSPT solution e ff ectively fromthe corresponding individual in the task. The CSC method consists of two levels as follows:Level 1: We will build the shortest path tree in each cluster of the graph from the local root of each cluster. Theset of edges obtained is added to the set of edges of the solution in the task.Level 2: We will build the connecting edges between the clusters by using a customized version of Dijkstra’salgorithm. First, we add the entire set of vertices of the cluster containing the source vertex into aclosed set V . Then we browse through the local root of the remaining clusters. Among the clustersconnected to V through their local roots, we search for the minimum route between a local root andthe source vertex of the input graph. The cluster containing that root is then added to V , and theconnecting edge is added to the edge set of the solution. Repeat until all clusters have been added to V .The steps of the CSC is described in Algorithm 5. The Dijkstra’s algorithm in the paper is implementedusing the Binary Heap structure and its complexity when running on the input graph G ( V , E ) is O ( E + V ∗ logV ). So for m i runs on m i clusters of graph will cost O ( m i ∗ ( E (cid:48) + V (cid:48) ∗ log ( V (cid:48) ))) where E (cid:48) , V (cid:48) are edgesand vertices set of the largest cluster in the graph. In addition, the cost to build inter-cluster edges in T is O ( m i ∗ V (cid:48) ). Therefore, the complexity of the whole Algorithm 5 is O ( m i ∗ ( E (cid:48) + V (cid:48) + V (cid:48) log ( V (cid:48) ))).14 a) (b) (c)(d) (e) (f) Figure 7: Steps to construct a solution from the private individual representation in the task lgorithm 5: Construct the Solution of CluSPT
Input:
An input graph of the i th task G i ( V i , E i , C i , s i , m i ), C i = { C i , C i , ..., C m i i } and C ∗ i = { C ∗ i , C ∗ i , ..., C m i ∗ i } .An individual I = { r , r , .., r m i } Output:
A spanning tree T ( V , E ) and sum of routing cost ( sum ) begin C mi ← Determine the cluster containing source vertex s i of G i ; V ← V i ; E ← ∅ ; sum ← (cid:46) the total routing cost from source vertex s i to all vertices in T; /* Construct the shortest path tree in each cluster from its local root byDijsktra Algorithm */ foreach cluster C ji ∈ C i do T j ← Determine the shortest path tree for G i [ C ji ] from local root r j ; d r j k ← the cost of path from the local root r j to a vertex k ∈ C ji in T j ; sum ← sum + (cid:80) d r j k , ∀ k ∈ C ji ; E ← E ∪ E ( T j ); end /* Construct edges connecting among clusters in T */ V (cid:48) ← C m ∗ i ; visited [ r j ] ← false; cost [ r j ] ← ∞ , ∀ r j ∈ I (cid:46) cost [ r i ] is the minimum cost to join the j th cluster into T through itslocal root r i ; visited [ s i ] ← true ; dem ← m i − /* Join cluster having the smallest additional cost */ while dem > do min ← ∞ ; v , u ← null ; foreach r ∈ I do if visited [ r ] (cid:44) true then foreach edge e = (r, k), k ∈ V’ do n cr ← the number of vertices in the cluster contain r ; cost [ r ] ← min( cost [ r ], ( d s i k + c ( k , r )) ∗ n cr ); if cost [ r ] < min then min ← cost [ r ]; u ← r; v ← arg min ( cost [ r ]); end end end end sum ← sum + cost [ u ] (cid:46) Update the total routing cost; Determine cluster C ji containing vertex v and update routing cost from source vertex s i tovertices in C ji ; V (cid:48) ← C j ∗ i ; E ← E ∪ ( u , v ); dem ← dem − visited [ u ] ← true; end return T(V, E), sum; end T . Figure 7(a) shows the clusters of a task within the MFEA and in the Figure 7(b), we see itsindividual representation. Vertex 1 is the source vertex of the input graph. Going through the chromosome,we get the three local roots: 1, 12, and 3. In the Figure 7(c) internal trees are created inside the clusters.We add the cluster containing source vertex 1 into V , as shown in Figure 7(d). Next, we consider all theclusters that connect directly to V , in this case, both local roots 12 (through vertex 1) and 3 (through vertex6). Comparing these two routes, we see that routing from 12 to 1 is closer than from 3 to 1, and thus cluster2 is added to V (figure 7(e)). Finally, cluster 3 is connected to V through both 6 and 11. Since the path3 → → → →
1, we add cluster 3 into V and the edge (3, 6) into the set ofedges. In traditional MFEA, the new children are produced from two parents who have the same skill factor orsatisfy a random probability. In our proposed crossover operator (New Multi-Parent Crossover (N-MPCX)),the parents have the same choice, but their children are produced from more parents in the hope that theycould inherit much more characteristics of trees of their parent. This is similar to how farmers breed newcrops that inherit the good traits of more than two-parent trees: good pest resistance of plant A, high yieldof plant B, good fruit quality of plant C, etc.The N-MPCX as shown in Algorithm 6 and its time complexity is O ( N ∗ m ) with N , m are number ofparents and the number of genes.Figure 8 shows o ff springs obtained after performing N-MPCX ’s steps. Figure 8(a) presents 4 ( N = N − = − = i th o ff spring preserves two segmentsof genes which are from the ( i − th cut point to i th cut point and ( N − th = rd cut point to the end ofits corresponding parent. Other segments of the o ff springs is determined by the gene segment of their nextparents in order. If the segment selected is from ( i − th cut point to i th cut point of the i th parent then changeit to the next parent’s gene segment in the same position. Figure 8(b) shows 4 o ff springs obtained. (a) (b) Figure 8: An example for the proposed crossover operator lgorithm 6: Proposed crossover operator
Input: N parents P i = { p i , p i , ..., p im } , i = , . . . , N , 2 ≤ N ≤ m . Output: N o ff springs O i , i = , . . . , N begin if N = then cp i ← Select randomly two cut points where 1 ≤ cp i ≤ m ( i = , cp < cp ; O i ← P i , i = , Swap genes from cp to cp of two o ff springs O , O for each other; else cp , . . . , cp N − ← Select randomly N − ≤ cp i < cp i + ≤ m − idx ← for i ← do for j ← do h ← j ; if j mod N + = i then h ← ( j +
1) mod N + if j (cid:44) i then h ← j mod N + Copy the gene segment from index idx to cp i in parent P h and append them intoO ff spring O j ; end idx ← cp i + end for j ← do Copy the gene segment from index idx to m in parent P j and append them into O ff spring O j ; end end return O i , i = , . . . , N ; end The mutation operator is performed by randomly selecting a cluster and replacing its local root withanother inter-cluster vertex in that cluster. The mutation method is described in Algorithm 7 with timecomplexity is O (1). 18 lgorithm 7: Proposed mutation operator
Input:
The Graph G u ( V , C , m ) where C = { C , C , .., C m } ,An individual I = { r , r , .., r m } . Output:
A new individual I ∗ = { r ∗ , r ∗ , .., r ∗ m } begin I ∗ ← I ; k ← Choose a random position in I ; r (cid:48) k ← Choose a random vertex in cluster C k ; r ∗ k ← r (cid:48) k ; return I ∗ ; end Given a spanning tree T is a solution of the CluSPT problem, the cost of the solution as defined is thesum of the shortest path distances from the source vertex s to all the vertices in the tree: cost ( T ) = (cid:88) u ∈ V d T ( s , u ) = m (cid:88) i = (cid:88) v ∈ C i d T ( s , v ) = m (cid:88) i = (cid:88) v ∈ C i ( d T ( s , r i ) + d T ( r i , v )) = m (cid:88) i = | C i | ∗ d T ( s , r i ) + (cid:88) v ∈ C i d T ( r i , v ) (1)From the above formula after decomposition, it can be easily seen that to calculate the cost of the solu-tion, we need to calculate two components: • The cost of path from source vertex s to the local root vertices of clusters r i : d T ( s , r i ) , i = , . . . , m . • The sum of costs of the path from the local root r i of each cluster to all vertices in that cluster (cid:80) v ∈ C i d T ( r i , v ).In the above equation, the second component (cid:80) v ∈ C i d T ( r i , v ) does not depend on the source vertex s , but onlyon the local root and the subgraph of that cluster. And the result of this component can be determined byDijkstra’s algorithm once we know the local root r i of that cluster. Therefore, to increase the algorithm’sspeed, we only calculate this value of each cluster for each local root only once on the first calculation andsave it to memory. When later calculation with the same local root is called, the corresponding memory cell’svalue will be retrieved. This saves a lot of computational costs because the cost of each Dijkstra’s algorithmimplementation is quite expensive. And this is also the reason why the idea of the encoding method is onlybased on the local root of each cluster in this paper is generated.19 . Computational results To the best of our knowledge, there have been no instances of the CluSPT made available to the public.For this reason, a set of test instances based on the MOM [24] (called MOM-lib) is generated. Variousalgorithms are utilized in the MOM-lib [25], resulting in six distinct types of instances. They are categorizedinto two kinds regarding dimensionality: small instances, each of which has between 30 and 120 vertices,and large instances, each of which has over 262 vertices. The instances are suitable for evaluating clusterproblems [24].However, to test the proposed algorithms’ e ff ectiveness in solving the CluSPT, it is necessary to addinformation about a source vertex to each instance. Therefore, a random vertex is selected as the sourcevertex for each instance.For evaluation of the proposed algorithms, instances with dimensionality from 30 to 500 are selected.All problem instances are available via [26]. Criteria for assessing the quality of the output of the algorithms are presented in Table 1.
Table 1: Criterias for assessing the quality of the output of the algorithm
Average (Avg) The average function value over allBest-found (BF) Best function value achieved over all runsRelative Percentage Di ff erences (RPD) The di ff erence between the average costs of two algorithmsIn order to compare the quality of the CluSPT solutions received from distinct algorithms, RPD [27] isused to calculate the di ff erence between the average costs of two algorithms. The RPD is calculated by thefollowing formula: RPD = S olution − BestBest ∗ Best is the average cost of the solution obtained from the proposed algorithm,
S olution is the averagecost of the solution obtained from existing algorithms, including Heuristic Based on Randomized GreedyAlgorithm (HB-RGA) and a strategy for using multifactorial optimization (G-MFEA).The experimental results were recorded in tables given at the end of this paper. Each table was labeledwith the numbers on the instances’ types.
To evaluate the performance of new MFEA for the CluSPT, two sets of experiments are implemented. • On the first set, two recent algorithms, G-MFEA [12] and HB-RGA [28] were implemented. • On the second set, since the performance of the proposed MFEA were contributed by parameter: therelation between the number of vertices and the number of clusters, R-experiment is conducted toevaluate the e ff ect of these parameters.Each scenario was simulated 30 times on the computer (Intel Core i7 - 4790 - 3.60GHz, 16GB RAM),with a population size of 100 individuals evolving through 500 generations, which means the total numbersof task evaluations are 50000, the random mating probability is 0.5, and the mutation rate is 0.05. The sourcecodes were installed by Java language. 20 able 2: Results of the Friedman and Iman-Davenport test ( α = Friedman Value Value in X p -value Iman-Davenport Value Value in F F p -value . ∗ − . ∗ − Table 3: Average rankings achiedved by the Friedman, Friednman Aligned, and Quade tests
Algorithms Friedman Friednman Aligned QuadeHB-RGA 2.669 273.831 2.600G-MFEA 2.209 230.939 2.323K-MFEA 1.122 122.230 1.076
To demonstrate the e ff ectiveness of the proposed algorithm, we perform three analyses on the receivedresults: • Statistical tests that have become a widespread technique in computational intelligence are first usedto analyze the algorithms’ performance. • The details of comparison on each type of instance is discussed in the second analysis. • In the third analysis, we point out factors that impact the performance of the proposed algorithm incomparison with existing algorithms.
In order to examine the e ff ect of the algorithms New Multifactorial Evolutionary Algorithm (K-MFEA),HB-RGA, and G-MFEA on the obtained results, we use Non-parametric for analyzing the received results.This study has two main steps: • The first step uses statistical methods such as Friedman, Aligned Friedman, Quade [29, 30] to test thedi ff erences among the results obtained by each algorithm. • The second step is performed when the test in the first step rejects the hypothesis of equivalence ofmeans, the detection of concrete di ff erences among the algorithms can be made with the applicationof post-hoc statistical procedures [29, 30], which are methods used for comparing a control algorithmwith remaining algorithms.Tables 9-12 present the results obtained in the competition organized by types of instances and threealgorithms. In these tables, the italic, red cells on a column in an algorithm denote instances where thisalgorithm outperforms two other algorithms.The result of applying Friedman’s and Iman-Davenport’s tests is presented in Table 2. Given that thestatistics of Friedman and Iman-Davenport are greater than their associated critical values, there are signifi-cant di ff erences among the observed results with a probability error of p ≤ . ff erences among the algorithms considered.The results in Table 3 show that the rank of the K-MFEA algorithm is the smallest, so we choose K-MFEA as the control algorithm. After that, we will apply more powerful procedures, such as Holm’s and21olland’s, to compare the control algorithm with the other algorithms. Table 4 shows all the possible hy-potheses of comparison between the control algorithm and the remaining ones, ordered by their p -value andassociated with their level of significance. Table 4: The z-values and p-values of the Friedman Aliged, Quade procedures (K-MFEA is the control algorithm)
Friedman Quade i algorithms z p Holm Holland z p
Holm Holland2 HB-RGA 12.89 4 . ∗ − . ∗ − . ∗ − . ∗ − p values for each comparison which involves the controlalgorithm. The p value is indicated in each comparison, and we stress in bold the algorithms which areworse than the control algorithm, considering a level of significance α = . Table 5: Adjusted p-values for the Friedman test (K-MFEA is the control method) i Algorithms Unadjusted p p
Bon f p Holm p Hochberg p Pli HB-RGA . ∗ − . ∗ − . ∗ − . ∗ − . ∗ − G-MFEA . ∗ − . ∗ − . ∗ − . ∗ − . ∗ − Table 6: Adjusted p-values for the QUADE test (K-MFEA is the control method) i Algorithms Unadjusted p p
Bon f p Holm p Hochberg p Pli HB-RGA . ∗ − . ∗ − . ∗ − . ∗ − . ∗ − G-MFEA . ∗ − . ∗ − . ∗ − . ∗ − . ∗ − Tables 7 summarize the results obtained in comparison with two other algorithms. The results show thatK-MFEA is significantly superior to HB-RGA. K-MFEA exceeds HB-RGA on most instances in all types,while the result received by HB-RGA is equal to one received by K-MFEA on only an instance in Type 5small. Between G-MFEA and K-MFEA, there are 29 test cases where the two algorithms’ performance isequally matched. Combined with the results on Tables 9-12, we can see that a highlight in those test casesis the dimension of instances are often small, i.e., the dimension of instances in Type 1, Type 5, and Type6 are less than 76, 65 and 76, respectively. G-MFEA outperforms K-MFEA on two instances which areinstance 5i500-304 in Type 5 Large and instance 9pr439-3x3 in Type 6 Large. However, K-MFEA surpassesG-MFEA on 108 out of 139 instances. Particularly, results obtained by the proposed algorithm are betterthan ones obtained by G-MFEA in all instances in Type 1 Large and Type 3.The average RPD and the maximum RPD of K-MFEA in comparison with G-MFEA and HB-RGA ontypes are presented in Figure 9, in which the labels G-MFEA and HB-RGA mean RPD(K-MFEA, G-MFEA)and RPD(K-MFEA, HB-RGA) respectively.In Figure 9(a), we can observe the average RPD(K-MFEA, G-MFEA) is larger than the average RPD(K-MFEA, HB-RGA) on Type 6 small, Type 4 and both small and large instances on Type 1, and the biggestdi ff erence is on Type 4. The average RPD(K-MFEA, G-MFEA) in those types are of 4.4%, 2.4% and 4.1%22 able 7: Summary of comparison of results obtained by K-MFEA and the existing algorithms. K-MFEA outperformsG-MFEA is equal to G-MFEA outperformsHB-RGA is equal toHB-RGA
TotalType 1
Small 18 8 26 0 26Large 15 0 15 0 15
Type 3
Type 4
Type 5
Small 10 10 19 1 20Large 14 0 15 0 15
Type 6
Small 28 7 35 0 35Large 12 0 13 0 13respectively. Conversely, the average RPD(K-MFEA, G-MFEA) is smaller than the average RPD(K-MFEA,HB-RGA) on other types, in which the average RPD(K-MFEA, HB-RGA) reaches its highest on Type 3with the value of 2.2% and its lowest on Type 5 small with the value of 1.1%. Another remarkable pointin Figure 9(a) is that on Type 5 Small, the average RPD(K-MFEA, G-MFEA) is very low with the valueof 0.04%. It mean that on this type, the improvement of performance of K-MFEA is significantly small incomparison with G-MFEA. The reason behind this is that the dimension of instances on this type is small,leading to the di ff erence between the two algorithms not being large.Figure 9(b) indicates that the biggest gap between K-MFEA and G-MFEA is significantly larger than onebetween K-MFEA and HB-RGA, and the maximum RPD(K-MFEA, G-MFEA) peaked at 18.6% on Type 4.A notable point in this figure is that the smallest gaps also belong to RPD(K-MFEA, G-MFEA) with valueof 0.32% (Type 3), 0.3196% (Type 5 small) and 0.334% (Type 6 large). Smaller di ff erence in this scenedenotes that in comparison with K-MFEA, the results obtained by G-MFEA are closer than ones obtainedby HB-RGA. In other words, in comparison with G-MFEA, the solution quality produced by K-MFEA isnot significantly improvement on these types. *) The aspect of running time. Figure 10 depicts the average running time, in minutes, of the three algorithms. It can be seen quiteclearly that G-MFEA is the inferior algorithm in this regard, compare to both HB-RGA and K-MFEA. Assuch, the focus should be shifted to a comparison between HB-RGA and K-MFEA, represented by Figure 11.For the small instances (Type 1 Small, Type 5 Small, Type 6 Small), K-MFEA achieves an execution timeabout 1.4-2 times faster than HB-RGA. Excluding those types, however, K-MFEA has proven itself to be thesuperior method as HB-RGA runs at least 6 times slower. This di ff erence cannot be attributed alone to thenature of the K-MFEA and MFEA algorithms, which solve multiple problems at once, because G-MFEAtoo utilizes the MFEA model and loses out horribly on running time. A better explanation for this is thespeed up method covered in this paper (section 4.8), which massively reduces computational stress. As mentioned in the previous subsection, the number of vertices may a ff ect the performance of the K-MFEA. Therefore, In this subsection, the influence of the input graph’s dimension (the number of vertices)23 a) Average RPD (b) Maximum RPD Figure 9: Average RPD and maximum RPD of K-MFEA in comparison with G-MFEA and HB-RGA on typesFigure 10: Running time of K-MFEA, G-MFEA and HB-RGA on types igure 11: Running time of K-MFEA in comparison with HB-RGA on types on the performance of K-MFEA is analyzed. Because K-MFEA outperforms both G-MFEA and HB-RGAon all instances of Type 3 and the number of instances in Type 4 is also very small, this study only considersthe instances of Type 1, Type 5, and Type 6.In the previous subsection, the results have proven that K-MFEA surpasses HB-RGA in most test cases,i.e., on 138 out of 139 instances, so we only focus on analyzing the performance of K-MFEA in comparisonwith G-MFEA.To determine the correlation between the number of vertices, the scatter plots of the relationship betweenthe number of vertices and the comparison between two algorithms K-MFEA and G-MFEA for each type aregraphed, and then this study tries to find the correlation coe ffi cient in that relationship as shown in Figure 12.In these Figures, circle symbols represent the performance of K-MFEA over G-MFEA, triangle means thatthe performance of G-MFEA outperforms K-MFEA, and square symbols illustrate the performance of thetwo algorithms when they are equal.Figure 12 describes the relationship between the number of clusters and the performance comparisonbetween K-MFEA and G-MFEA. A common feature of these figures is that the results from two algorithmsare equal when the number of vertices is small, i.e., Type 1, Type 5, Type 6 is smaller than 76, 30, and 76,respectively. When the number of vertices is greater than 76 (for Type 1 and Type 6) and 30 (for Type 5),G-MFEA exceeds K-MFEA on only two test cases, which are on instance 5i500-304 in Type 5 and instance9pr439-3x3 in Type 6. These lead to the conclusion that when the input graph’s dimension increases, theperformance of K-MFEA tends to increase. In order to better understand the improved performance as a result of the proposed algorithm, we analyzethe convergence performance of two algorithms G-MFEA and K-MFEA by using the functions in [17] forcomputing the normalized objectives and averaged normalized objectives of the algorithms. In each type, apair of instances are randomly selected for performing the analysis.Figure 13 illustrates the main convergence trends during the initial stages of K-MFEA and G-MFEAfor instances 10pr439 and 25a280 in Type 1; instances 5i300-108 and 5i400-205 in Type 5, and instances9pcb442-3x3 and 9pr439-3x3 in Type 6. From Figure 13 it can be noted that in general, the convergence25 a) Type 1(b) Type 5(c) Type 6
Figure 12: The scatter of the number of vertices and the comparison between K-MFEA with G-MFEA in the Types 1, 5 and 6 • The convergence trend of K-MFEA also surpassed that of G-MFEA on all generators as in Fig-ure 13(a). • The convergence trend of K-MFEA surpasses that of G-MFEA on the last generators but on the firstgenerators, the convergence of G-MFEA was often faster than that of K-MFEA. This trend is illustratein Figure 13(b) and Figure 13(c).One other remark in Figure 13 is the average normalized objective values di ff erence between K-MFEAand G-MFEA at start time. The cause of this di ff erence is that two algorithms encode the CluSPT solution bytwo di ff erent methods, so initial individuals of an algorithm di ff er from initial solutions of the rest algorithm.These observations led to the conclusion that the CluSPT solution produced by K-MFEA was often betterthan ones produced by G-MFEA in most generators. In other words, the evolution methods in K-MFEAmay help to improve the quality of solution of the CluSPT in comparison with the methods in G-MFEA. (a) Type 1 (b) Type 5 (c) Type 6 Figure 13: Convergence trends of ˜ f in multi-tasks and serial single task for instances 10pr439 and 25a280 in Type 1; instances 5i300-108 and 5i400-205 in Type 5; instances 9pcb442-3x3 and 9pr439-3x3 in Type 6. In this part, we consider the influence of the number of parents of N-MPCX on the performance ofK-MFEA. We have conducted experiments in the range of 2 to 10 parents, and the results obtained thatare di ff erent from running with the two parents are shown in Table 13. In this table, red values indicatebetter results than values on the left. As shown in the table, the di ff erent results are only obtained in largeinstances and using three or more parents always results in an equal or better experimental result (a betterperformance is recorded in 12 instances). Besides, the results also show that N-MPCX work most e ff ectivelyon the parents of 3. The more vertices and clusters a graph has, the better result a multi-parent crossovermethod brings about. Otherwise, using multiple parents in a smaller set is likely unnecessary because a two-parent crossover operator is su ffi cient to reach the optimal value. From the above analysis, the N-MPCX isquite suitable in solving large-scale CluSPT problems. In this part, we compare the performance of the proposed algorithm on aspect running time when it usesand does not use (called K-MFEA ∗ ) the speed-up method in subsection 4.8.Table 8 presents the computational time of algorithms K-MFEA and K-MFEA ∗ with Min (Max) andAvg are minimum (maximum) and average computational time of algorithms on instances of each type,27espectively. Results in this table point out that K-MFEA is faster than K-MFEA ∗ on all types of instances.On small types, K-MFEA’s average running time is 6.9 to 9.9 times smaller. Whereas on large types, K-MFEA o ff ers 12.8 to 18.8 times less average running time than K-MFEA ∗ . In particular, K-MFEA’s averagerunning time is reduced by 54.7 to 80 times compared to K-MFEA ∗ on Type 3 and 4 where the averagenumber of vertices per cluster is high. The method in subsection 4.8, thus, has demonstrated its ability toreduce the computational time of the proposed algorithm. Table 8: Running time of the proposed algorithm when uses and does not use the speed-up evaluation method
K-MFEA ∗ K-MFEA
Min Max Avg Min Max AvgType 1 Small 0.167 0.317 0.219 0.001 0.080 0.030Type 1 Large 0.417 2.067 1.038 0.030 0.150 0.081Type 3 2.533 2.867 2.720 0.030 0.050 0.034Type 4 1.267 2.667 1.860 0.030 0.050 0.034Type 5 Small 0.117 0.300 0.208 0.020 0.030 0.021Type 5 Large 0.800 2.567 1.409 0.020 0.600 0.075Type 6 Small 0.117 0.250 0.193 0.020 0.070 0.028Type 6 Large 0.450 3.650 1.319 0.020 0.470 0.094
6. Conclusion
This paper described a new approach based on MFEA to solve the CluSPT. In the proposed algorithm,the solution encoding method is focused on inter-vertices, while the solution evaluation method uses a mech-anism that allows reusing the cost of each cluster to be calculated. Therefore, those help to reduce consumingresources on both computation time and memory space. Furthermore, the crossover, mutation, and decodingoperators, as well as a method for repairing invalid individuals, are described to enhance the performance ofthe proposed MFEA. To evaluate the proposed algorithm, multiple types of Euclidean instances are selected.The results received from the proposed algorithm are state of the art in most test cases in solving CluSPTwhich strongly proven the e ffi ciency of this approach.To enhance the performance of the novel algorithm, in the future, the authors will look for evolutionaryoperators with less complexity. Acknowledgements
This work is funded by Vingroup Joint Stock Company and supported by the Domestic Master / PhDScholarship Programme of Vingroup Innovation Foundation (VINIF), Vingroup Big Data Institute (VIN-BIGDATA) for Ta Bao Thang. This research is funded by the Ministry of Education and Training, Vietnamfor the research project: evolutionary multitasking algorithm for the path computation problem in multi-domain networks for Pham Dinh Thanh. This research was sponsored by the U.S. Army Combat Capabili-ties Development Command (CCDC) Pacific and CCDC Army Research Laboratory (ARL) under ContractNumber W90GQZ-93290007 for Huynh Thi Thanh Binh.28 eferences [1] M. D’Emidio, L. Forlizzi, D. Frigioni, S. Leucci, G. Proietti, Hardness, approximability, and fixed-parameter tractability of the clustered shortest-path tree problem, Journal of Combinatorial Optimiza-tion 38 (1) (2019) 165–184.[2] A. E. Eiben, J. E. Smith, Introduction to evolutionary computing, Springer, 2015.[3] P. D. Thanh, H. T. T. Binh, B. T. Lam, New Mechanism of Combination Crossover Operators in GeneticAlgorithm for Solving the Traveling Salesman Problem, in: Knowledge and Systems Engineering,Springer, 2015, pp. 367–379.[4] T. T. B. Huynh, D. T. Pham, B. T. Tran, C. T. Le, M. H. P. Le, A. Swami, T. L. Bui, A multifactorialoptimization paradigm for linkage tree genetic algorithm, Information Sciences 540 (2020) 325–344.[5] P. T. H. Hanh, P. D. Thanh, H. T. T. Binh, Evolutionary algorithm and multifactorial evolutionaryalgorithm on clustered shortest-path tree problem, Information Sciences (2020).[6] M. Gong, Z. Tang, H. Li, J. Zhang, Evolutionary multitasking with dynamic resource allocating strat-egy, IEEE Transactions on Evolutionary Computation 23 (5) (2019) 858–869.[7] L. Feng, Y. Huang, L. Zhou, J. Zhong, A. Gupta, K. Tang, K. C. Tan, Explicit evolutionary multi-tasking for combinatorial optimization: A case study on capacitated vehicle routing problem, IEEETransactions on Cybernetics (2020).[8] L. Zhou, L. Feng, K. C. Tan, J. Zhong, Z. Zhu, K. Liu, C. Chen, Toward adaptive knowledge transferin multifactorial evolutionary computation, IEEE Transactions on Cybernetics (2020).[9] H. T. Binh, P. D. Thanh, T. B. Trung, et al., E ff ective multifactorial evolutionary algorithm for solvingthe cluster shortest path tree problem, in: 2018 IEEE Congress on Evolutionary Computation (CEC),IEEE, 2018, pp. 1–8.[10] P. D. Thanh, D. A. Dung, T. N. Tien, H. T. T. Binh, An e ff ective representation scheme in multifactorialevolutionary algorithm for solving cluster shortest-path tree problem, in: 2018 IEEE Congress onEvolutionary Computation (CEC), IEEE, 2018, pp. 1–8.[11] B. H. T. Thanh, T. P. Dinh, Two levels approach based on multifactorial optimization to solve theclustered shortest path tree problem, Evolutionary Intelligence (2020) 1–29.[12] P. D. Thanh, H. T. T. Binh, T. B. Trung, An e ffi cient strategy for using multifactorial optimization tosolve the clustered shortest path tree problem, Applied Intelligence 50 (4) (2020) 1233–1258.[13] M. Xu, Y. Liu, Q. Huang, Y. Zhang, G. Luan, An improved dijkstra’s shortest path algorithm for sparsenetwork, Applied Mathematics and Computation 185 (1) (2007) 247–254.[14] J. A. Chisman, The clustered traveling salesman problem, Computers & Operations Research 2 (2)(1975) 115–119.[15] X. Bao, Z. Liu, An improved approximation algorithm for the clustered traveling salesman problem,Information Processing Letters 112 (23) (2012) 908–910.2916] K. Helsgaun, Solving the bottleneck traveling salesman problem using the Lin-Kernighan-Helsgaunalgorithm, Computer Science Research Report (143) (2011) 1–45.[17] A. Gupta, Y.-S. Ong, L. Feng, Multifactorial evolution: toward evolutionary multitasking, IEEE Trans-actions on Evolutionary Computation 20 (3) (2015) 343–357.[18] D. T. Pham, T. T. B. Huynh, An e ff ective combination of genetic algorithms and the variable neigh-borhood search for solving travelling salesman problem, in: 2015 Conference on Technologies andApplications of Artificial Intelligence (TAAI), IEEE, 2015, pp. 142–149.[19] K. K. Bali, Y.-S. Ong, A. Gupta, P. S. Tan, Multifactorial evolutionary algorithm with online transferparameter estimation: MFEA-II, IEEE Transactions on Evolutionary Computation 24 (1) (2019) 69–83.[20] Y.-W. Wen, C.-K. Ting, Parting ways and reallocating resources in evolutionary multitasking, in: 2017IEEE Congress on Evolutionary Computation (CEC), IEEE, 2017, pp. 2404–2411.[21] J. Tang, Y. Chen, Z. Deng, Y. Xiang, C. P. Joy, A group-based approach to improve multifactorialevolutionary algorithm., in: IJCAI, 2018, pp. 3870–3876.[22] Y. Yuan, Y.-S. Ong, A. Gupta, P. S. Tan, H. Xu, Evolutionary multitasking in permutation-based com-binatorial optimization problems: Realization with tsp, qap, lop, and jsp, in: 2016 IEEE Region 10Conference (TENCON), IEEE, 2016, pp. 3157–3164.[23] H. T. T. Binh, P. D. Thanh, T. B. Thang, New approach to solving the clustered shortest-path treeproblem based on reducing the search space of evolutionary algorithm, Knowledge-Based Systems180 (2019) 12–25.[24] M. Mestria, L. S. Ochi, S. de Lima Martins, GRASP with path relinking for the symmetric euclideanclustered traveling salesman problem, Computers & Operations Research 40 (12) (2013) 3218–3229.[25] M. D’Emidio, L. Forlizzi, D. Frigioni, S. Leucci, G. Proietti, On the clustered shortest-path tree prob-lem., in: ICTCS, 2016, pp. 263–268.[26] P. D. Thanh, CluSPT instances, Mendeley Data v3, 2019. doi:http://dx.doi.org/10.17632/b4gcgybvt6.3 .[27] P. C. Pop, O. Matei, C. Sabo, A. Petrovan, A two-level solution approach for solving the generalizedminimum spanning tree problem, European Journal of Operational Research 265 (2) (2018) 478–487.[28] P. D. Thanh, H. T. T. Binh, N. B. Long, A heuristic based on randomized greedy algorithms for theclustered shortest-path tree problem, in: 2019 IEEE Congress on Evolutionary Computation (CEC),IEEE, 2019, pp. 2915–2922.[29] J. Derrac, S. Garc´ıa, D. Molina, F. Herrera, A practical tutorial on the use of nonparametric statisticaltests as a methodology for comparing evolutionary and swarm intelligence algorithms, Swarm andEvolutionary Computation 1 (1) (2011) 3–18.[30] J. Carrasco, S. Garc´ıa, M. M. Rueda, S. Das, F. Herrera, Recent trends in the use of statistical tests forcomparing swarm and evolutionary computing algorithms: Practical guidelines and a critical review,Swarm and Evolutionary Computation (2020) 100665.30 able 9: Results obtained by G-MFEA, HB-RGA and K-MFEA on instances in Type 1. HB-RGA G-MFEA K-MFEA
Instances BF Avg Time BF Avg Time BF Avg Time10berlin52 43738.6 43971 0.04 43724.1 43724.1 0.67 43724.1 43724.1 0.0210eil51 1713.2 1723.2 0.04 1713.2 1713.2 0.92 1713.2 1713.2 0.0210eil76 2203.3 2208.4 0.05 2203.3 2203.3 1.60 2203.3 2203.3 0.0210kroB100 140635.1 141951.4 0.06 140551.2 140597.9 2.35 140522.2 S m a lli n s t a n ce s L a r g e i n s t a n ce s Table 10: Results obtained by G-MFEA, HB-RGA and K-MFEA on instances in Types 3 and 4.
HB-RGA G-MFEA K-MFEA
Instances BF Avg Time BF Avg Time BF Avg Time6i300 19461.1 19836.6 0.55 19286.3 19320.3 23.42 19264.5 ype 4 4i400z 221460.6 224677.4 2.22 234203.3 244894.6 36.95 221423.9 Table 11: Results obtained by G-MFEA, HB-RGA and K-MFEA on instances in Type 5.
HB-RGA G-MFEA K-MFEA
Instances BF Avg Time BF Avg Time BF Avg Time10i120-46 94055.2 94596.7 0.08 93956.9 94034.3 2.77 93925.0 S m a lli n s t a n ce s L a r g e i n s t a n ce s Table 12: Results obtained by G-MFEA, HB-RGA and K-MFEA on instances in Type 6.
HB-RGA G-MFEA K-MFEA
Instances BF Avg Time BF Avg Time BF Avg Time10berlin52-2x5 27472.4 27723.2 0.04 27471.4 27473 0.83 27471.4 S m a lli n s t a n ce s L a r g e i n s t a n ce s able 13: The di ff erent results obtained by K-MFEA when running with the number of parents in range 2 to 10 Instances The number of parents
Type 1 large
Type 3
Type 5 Large