A Hybrid Evolutionary Algorithm With Simplex Local Search

A Hybrid Evolutionary Algorithm With Simplex Local Search A. Isaacs, T. Ray, W. Smith Abstract— Presented in this paper is a hybrid algorithm simplex search enabled evolutionary algorithm (SSEA) which is fundamentally an evolutionary algorithm (EA) embedded with a local simplex search for unconstrained optimization problems. Evolutionary algorithms have been quite successful in solving a wide class of intractable problems and the Non-dominated Sorting Genetic Algorithm (NSGA-II) is a popular choice. However, like any other evolutionary algorithms, the rate of convergence of NSGA-II slows down with generations and often there is no improvement in the best candidate solution over a number of generations. The simplex search component comes into effect once the basic evolutionary algorithm encounters a slow rate of convergence. To allow exploitation around multiple promising regions, the simplex search is invoked from multiple promising regions of the variable space identified using hierarchical agglomerative clustering. In this paper, results are presented for a series of unconstrained optimization test problems that cover problems with a single minimum, a few minima and a large number of minima. Provided is a comparison of results with NSGA-II, Fast Evolutionary Strategy (FES), Fast Evolutionary Programming (FEP) and Improved Fast Evolutionary Programming (IFEP) where it’s clear that SSEA outperforms all other algorithms for unimodal problems. On the suite of problems with large number of minima, SSEA performs better on some of them. For problems with fewer minima, SSEA performs better than FES, FEP and IFEP while demonstrating comparable performance to NSGA-II.

I. I NTRODUCTION The general unconstrained optimization problem can be formulated as minimize

f (x),

x = (x1 , . . . , xn ) ∈ Rn

where x ∈ S ⊂ Rn defines the search space which is the n-dimensional bounded space xi ≤ xi ≤ xi ,

i = 1, . . . , n.

The global minimum solution f ∗ at x∗ is defined as f ∗ = f (x∗ ) ≤ f (x),

∀x ∈ S.

There is a large number of evolutionary algorithms (EAs) that can solve single and multiple objective, unconstrained and constrained optimization problems. These algorithms can be categorized in three major classes, i.e. genetic algorithms (GA), evolutionary programming (EP), and evolutionary strategy (ES). Genetic Algorithms mimic the evolution process through selection, recombination and mutation [1]. Evolutionary programming and evolutionary strategy make use of mutation operators, but not recombination for the evolution process [2].

Most of the evolutionary algorithms are population based and use various operators to traverse the search space. The elite preservation mechanism within EAs allow it to retain good candidate solutions and give them a higher chance of survival than other candidate solutions. One of the main drawbacks of these evolutionary algorithms is that the rate of convergence slows down after a few generations and often there is no improvement in the best candidate solution across multiple generations. Modifications to evolutionary strategy and evolutionary programming algorithms have been suggested to improve the rate of convergence [3], [4]. One of the commonly used local search techniques is the Nelder-Mead simplex search [5]. Durand and Alliot [6] have used a simplex based representation scheme. Each individual of the population is represented using p ≤ n+1 points. They have also defined crossover and mutation operators for the simplex representation. Tsutsui, Yamamura and Higuchi [7] have proposed a simplex crossover (SPX) operator for multiparent recombination. A simplex is formed using p (2 ≤ p ≤ n + 1) parents. A new child is created by a uniform sampling along the line obtained by joining the centroid of the simplex and one of the parents forming the simplex. Yen et al [8] proposed a hybrid GA and simplex method that uses combination of elite preservation, concurrent simplex search and crossover to generate the offspring population. In concurrent simplex search, n + Ω (where Ω is usually much larger than 1) points are used; centroid of the best n points is calculated and the other Ω points are reflected across the centroid to obtain new Ω points. Alternatively, Chelouh and Siarry [9] have proposed a continuous hybrid algorithm (CHA) in which selection, crossover and mutation operators are used to find the promising area (based on the average distance between the best solution in the population and the rest of the solutions). Then a simplex search is started with the best n + 1 points forming the initial simplex. We suggest the use of the simplex search only when there is no improvement in the last few generations. This approach will improve the rate of convergence of the evolutionary algorithm by invoking local search when the evolutionary exploration is unable to find better solutions. Presented in this paper is a simplex search enabled evolutionary algorithm (SSEA) to speed up the convergence process. The proposed algorithm is compared to other evolutionary algorithms on a number of test functions and SSEA performs much better than the other algorithms. II. P ROPOSED A LGORITHM

University of New South Wales at Australian Defence Force Academy, Northcott Drive, Canberra, ACT 2600, Australia (email: {A.Isaacs,T.Ray, W.Smith}@adfa.edu.au).

Depicted in Algorithm 1 are the main steps of SSEA. The algorithm starts with a randomly generated initial population

1701 c 1-4244-1340-0/07$25.00 2007 IEEE

P1 . SSEA is an iterative algorithm with the following steps: • Evaluate - For all the individuals of the population calculate the objective functions. • Rank - Rank all the candidate solutions in a generation to identify better candidate solutions. • Evolve - Using recombination and mutation operators evolve a child generation from the parent generation. If there is no progress for last p generations, invoke multiple simplex searches to generate q children. • Reduce - From a parent population and child population select better candidate solutions to form the next generation of candidate solutions. Algorithm 1 SSEA Toplevel Algorithm 1: Ecounter ← 0 {Function Evaluations Counter} 2: Elimit {Function Evaluations Budget} 3: P1 = Initialize() 4: Evaluate(P1 ) 5: while Ecounter < Elimit do 6: Rank(Pi ) 7: Ci = Evolve(Pi ) 8: Evaluate(Ci ) 9: Pi+1 = Reduce(Pi + Ci ) 10: end while A. Initialization The initialization of a population is based on the random generation of N candidate solutions using uniform random generator sampling in the range 0 to 1 (U [0, 1]) and the variable bounds, such that xi = xi + U [0, 1] × (xi − xi ). B. Ranking Ranking is used to identify better individuals in the population and it is based on the value of the objective function. An individual with a better (smaller for minimization problems) objective value has higher rank. If the objective function is the same then the individuals get the same rank. C. Evolution Strategy The Evolution Strategy encapsulates the evolution process. Most often an evolution process includes selection, recombination and mutation schemes. Selection is used to choose parents that undergo recombination; offspring are generated by recombination and may undergo mutation. The proposed algorithm follows the above evolution process till there is no improvement in the best objective value in the last p generations. To improve the local search, the simplex search method of Nelder-Mead [5] is invoked. The Nelder-Mead method essentially uses n-dimensional simplex to traverse the design space in the direction of improvement. If a starting point is in the valley of attraction of an optimum, Nelder-Mead marches along the direction of that optimum. To ensure that multiple minima are tracked and improved upon, simplex search is started from various points in the

1702

design space. These points are identified as the best points in different regions of the design space. Different regions are identified using Hierarchical Agglomerative Clustering. The Hierarchical Agglomerative Clustering method groups points which are similar or close (using the Euclidean distance measure). This ensures that multiple regions of design space are searched by the Nelder-Mead simplex search. Outlined in Algorithm 2 are all the steps of the simplexsearch enabled evolution process of SSEA. Algorithm 2 SSEA Evolution Strategy 1: Pi ← Population of ith Generation 2: N = Number of generations 3: fbest (Pi ) ← Best objective in ith Generation 4: use simplex = 0 5: if Feasible(Pi ) and fbest (Pi−p )-fbest (Pi ) <  then 6: use simplex = 1 7: end if 8: if use simplex = 1 then 9: clusters[] = HierarchicalCluster(Pi , q) 10: for j = 1 to q do 11: Ci [j] = NelderMead(clusters[j]) 12: end for 13: else 14: q=0 15: end if 16: for j = q to N step 2 do 17: p1, p2, p3, p4 = Sample(Pi , 4) 18: parent1 = Winner(p1, p2) 19: parent2 = Winner(p3, p4) 20: Ci [j], Ci [j + 1] = Recombine(parent1, parent2) 21: Mutate(Ci [j]) 22: Mutate(Ci [j + 1]) 23: end for 1) Selection: In the evolution phase, selection of parents is based on binary tournament. Four distinct individuals (p1 , p2 , p3 , p4 ) are selected randomly from the population. Two parents are selected from these individuals by binary tournament. The first parent is the better ranked individual between p1 and p2 . The second parent is better ranking individual between p3 and p4 . 2) Recombination: For recombination, a simulated binary crossover (SBX) operator is used [10]. It works with two parents and creates two offsprings. A uniform random number is chosen ui ∈ [0, 1). A term βqi is calculated as, ⎧ ⎨(2ui )1/ηc +1 , if ui ≤ 0.5, βqi =  1 1/ηc +1 ⎩ if ui > 0.5. 2(1−ui ) where ηc is the user defined parameter Recombination Distribution Index. The offsprings y1 and y2 are created from parents x1 and x2 as, yi1 =0.5 [(1 + βqi ) x1i + (1 − βqi ) x2i ] yi2 =0.5 [(1 − βqi ) x1i + (1 + βqi ) x2i ]

2007 IEEE Congress on Evolutionary Computation (CEC 2007)

3) Mutation: For Mutation, a polynomial mutation operator [11] is used. Each element of y is obtained from a corresponding element of x by mutation; yi = xi + (xi − xi ) δ¯i where δ¯i is calculated from the polynomial probability density function P (δ) = 0.5(ηm + 1)(1 − |δ|)ηm , and ηm is the user defined parameter Mutation Distribution Index.  (2ri )1/(ηm +1) − 1, if ri < 0.5, ¯ δi = 1 − [2(1 − ri )]1/(ηm +1) , if ri ≥ 0.5. D. Nelder-Mead Simplex Search Algorithm The simplex search algorithm due to Nelder and Mead [5] has been widely used as an optimization algorithm for unconstrained real functions. It is based on the comparison of values at the vertices of a simplex. A simplex is a set of n+1 points in Rn . It is a triangle in R2 , a tetrahedron in R3 , etc. A simplex possesses a very useful property that a new simplex can be formed on any face of a given simplex by the addition of only a single new point. The Nelder-Mead method defines three operations for simplexes viz. reflection, contraction, and expansion (Fig. 1). As depicted in Algorithm 3 a search for favorable points is made using reflection. Another step in the the same direction is made using an expansion operation. If the new point is better, then it is retained, else the previous point is used for reflection. On the other hand if the reflection produces a worse point, contraction is tried. If that fails the simplex size is reduced by shrinking. The original Nelder-Mead algorithm was designed for unbounded variable space problems. With bounded variables, the points can leave the search space after a reflection or an expansion operation. Luersen, Riche and Guyon [12] proposed a method to handle the parameter bounds by projection, such that  if(xi < xi ), xi = xi if(xi > xi ), xi = xi . Pe

Pr

Pr

Pr

P2

P2

P2 P

P P3 Reflection

P3 P1

Expansion

Fig. 1.

P P3

P1

P1

Pc

Contraction

Nelder-Mead Simplex Operators

The algorithm stops when the function values at the vertices of the simplex are close, which is measured by the inequality,  n+1 n+1 1  1 

(fi − f )2 < , f = fi , n i=1 n + 1 i=1

where  is a small positive scalar [12]. Algorithm 3 Nelder-Mead Simplex Method Require: α > 0, β > 0, 0 < γ < 1 1: Set initial simplex Pi , and fi = f (Pi ) 2: repeat 3: fh = maxi (fi ) = f (Ph ) {Ph has best objective} 4: P is the centroid of the opposite face 5: fl = mini (fi ) = f (Pl ) {Pl has worst objective} 6: Pr = P + α(P − Ph ), fr = f (Pr ) {Reflection} 7: if fr < fl then 8: Pe = P + β(Pr − P ), fe = f (Pe ) {Expansion} 9: if fe < fl then 10: Replace Ph by Pe 11: else 12: Replace Ph by Pr 13: end if 14: else 15: if fr > fi , i = h then 16: if fr ≤ fh then 17: Replace Ph by Pr 18: end if 19: Pc = P + γ(Pr − P ), yc = f (Pc ) {Contraction} 20: if fc > fh then 21: Replace all Pi ’s by (Pi + Pl )/2 {Shrinking} 22: else 23: Replace Ph by Pc 24: end if 25: else 26: Replace Ph by Pr 27: end if 28: end if 29: until simplex size is smaller than prescribed limit.

E. Hierarchical Agglomerative Clustering Clustering is used to describe methods for grouping unlabeled data [13], [14]. For SSEA the unlabeled data represents the population of individual candidate solutions. Agglomerative clustering begins with each individual of the population as a cluster, and successively merges clusters together, until the stopping criterion is satisfied. Hierarchical clustering generates a dendogram representing a nested grouping of individuals. Shown in Figure 2 is a dendogram obtained after clustering of 13 data points. It shows that data points 1 and 2 are merged to form a cluster and they are in turn merged with another cluster formed by data points 3, 4, 5 and 6. The algorithm for hierarchical agglomerative clustering consists of computing the proximity matrix based on the euclidean distance measure and forming clusters based on the proximity of points or already merged clusters. Distance between two already merged clusters is taken as the distance between the centroids of the two clusters. The steps of the hierarchical agglomerative clustering algorithms are as follows:

2007 IEEE Congress on Evolutionary Computation (CEC 2007)

1703

TABLE I T EST FUNCTIONS

Fig. 2.

Sample Dendogram

1) Compute the proximity matrix containing distance between each pair of samples. Treat each sample as a cluster. 2) Find the most similar pair of clusters using the proximity matrix. Merge these two clusters into one cluster and calculate the new cluster centroid. Update the proximity matrix to reflex this merge operation. 3) If the required number of clusters are obtained stop. Otherwise, go to step 2. III. E XPERIMENTAL S TUDIES A. Test Problems A set of 23 known functions [3] are used as test functions (f1 , . . ., f23 ). The test function are described in Table I. The number of design variables is given by n. Functions f1 to f7 are unimodal functions. Function f6 is a step function with single minima and is discontinuous. Function f7 is a noisy quartic function. Functions f8 to f13 are multimodal functions with a large number of local minima (the number of local minima increases exponentially with problem dimension). Functions f14 to f23 are multimodal functions with a few local minima.

description

n

Shpere Model Schwefel’s Problem 2.22 Schwefel’s Problem 1.2 Schwefel’s Problem 2.21 Generalized Rosenbrock’s Function Step Function Quartic Function with Noise

30 30 30 30 30 30 30

f8 f9 f10 f11 f12 f13

Generalized Schwefel’s Problem 2.26 Generalized Rastrigin’s Function Ackley’s Function Generalized Griewank Function Generalized Penalized Function (1) Generalized Penalized Function (2)

30 30 30 30 30 30

f14 f15 f16 f17 f18 f19 f20 f21 f22 f23

Shekel’s Foxholes Function Kowalik’s Function Six-hump Camel-Back Function Branin Function Goldstein-Price Function Hartman Function (1) Hartman Function (2) Schekel’s Function (1) Schekel’s Function (2) Schekel’s Function (3)

2 4 2 2 2 3 6 5 7 10

TABLE II E XPERIMENTAL PARAMETERS Random Seed

0.5, 0.9

Recombination Probability

0.8, 0.9

Recombination Distribution Index

10, 20

Mutation Probability

0.1, 0.2

Mutation Distribution Index

10, 20

IV. R ESULTS

B. Experimental Setup For all experiments, a population size of 100 was used. All the problems were repeated for 32 (25 ) runs with the variations in random seed, mutation and recombination probability, and distribution indices. For each parameter two values were used as given in Table II. For each run, the maximum number of function evaluations allowed were 100,000. If the function value did not improve for the previous 3 generations (p = 3), simplex search was invoked. Before simplex search, the candidate solutions were clustered into 4 clusters (q = 4) and simplex search was started from the best candidate solution in each cluster. For simplex search, the reflection parameter (α) is 1.0, the expansion parameter (β) is 2.0, and the contraction parameter (γ) is 0.5. Simplex search is allowed to run till the convergence criterion is met ( = 1.e − 6) or for a maximum of 50 iterations. The test problems are also solved by NSGA-II, with a population size of 100 for 1000 generations corresponding to 100,000 function evaluations.

1704

fn f1 f2 f3 f4 f5 f6 f7

The results of the optimization of the 23 test functions by SSEA and NSGA-II are shown in Table III. As seen from examining Table III, SSEA outperforms NSGA-II for problems with a single minima. SSEA is able to get very close to the optimum for the functions f1 − f7 . For problems with a large number of minima, SSEA performs better for problems f10 , f11 , and f13 . For the other problems NSGA-II performs better. For problems with fewer number of minima (f14 − f23 ), SSEA performance is similar to that of NSGA-II. The convergence of SSEA and NSGA-II (using the run in which the best objective value was obtained) for problems with single minima is shown in Figures 3 and 4, for problems with a large number of local minima is shown in Figures 5 and 6, and for problems with fewer number of local minima is shown in Figures 7 and 8. It can be seen from Figures 7 and 8 that even though both SSEA and NSGA-II both reach the optimum objective value, SSEA converges to the optimum value faster than NSGA-II.

2007 IEEE Congress on Evolutionary Computation (CEC 2007)

1e+06

10000

SSEA NSGA-II

10000

SSEA NSGA-II

100

100 1 Best Objective

Best Objective

1 0.01 1e-04

0.01 1e-04

1e-06 1e-06 1e-08 1e-08

1e-10 1e-12

1e-10 0

20000

Fig. 3.

40000 60000 Function Evaluations

80000

100000

0

Convergence of problem f1

1e+14

Fig. 6.

40000 60000 Function Evaluations

80000

100000

Convergence of problem f11

100

SSEA NSGA-II

1e+12

20000

SSEA NSGA-II

1e+10 10 Best Objective

Best Objective

1e+08 1e+06 10000 100

1

1 0.01 1e-04 1e-06

0.1 0

20000

40000

60000

80000

100000

0

20000

Function Evaluations

Fig. 4.

Convergence of problem f2

100

40000

60000

80000

100000

Function Evaluations

Fig. 7.

Convergence of problem f14

1

SSEA NSGA-II

SSEA NSGA-II

10 1 Best Objective

Best Objective

0.1 0.1 0.01 0.001

0.01 1e-04 1e-05 1e-06

0.001 0

20000

Fig. 5.

40000 60000 Function Evaluations

Convergence of problem f10

80000

100000

0

20000

Fig. 8.

40000 60000 Function Evaluations

80000

100000

Convergence of problem f15

2007 IEEE Congress on Evolutionary Computation (CEC 2007)

1705

TABLE III R ESULTS OF 23 UNCONSTRAINED PROBLEMS BY SSEA AND NSGA-II fn

optimum

SSEA best

SSEA std. dev.

NSGA-II best

NSGA-II std. dev.

f1 f2 f3 f4 f5 f6 f7

0.0 0.0 0.0 0.0 0.0 0.0 0.0

4.37e-11 2.48e-6 4.13e-10 1.01e-4 1.12e-2 0.0 1.30e-21

1.50e-8 1.97e-6 1.27e-7 3.82e-3 2.28 0.0 9.67-14

0.198 8.98e-2 178.49 9.52e-1 26.49 0.0 0.0

f8 f9 f10 f11 f12 f13

-12569.5 0.0 0.0 0.0 0.0 0.0

-12173.8 17.74 1.01e-6 5.13e-10 0.10 1.70e-4

543.11 22.11 1.41e-5 0.12 0.15 3.03e-3

f14 f15 f16 f17 f18 f19 f20 f21 f22 f23

1.0 3.075e-4 -1.0316285 0.398 3.0 -3.86 -3.32 -10.1532 -10.4029 -10.5364

0.998 4.36e-3 -1.03163 0.3979 3.0 -3.863 -3.322 -10.1532 -10.4029 -10.5364

7.90e-16 8.16e-3 0.0 7.62e-7 0.0 4.51e-16 3.52e-2 5.41e-15 2.46 2.95

fn

Gen.

Nf

NfP S

NP S

NfP S /Nf (%)

30.74 9.89e-1 504.04 1.96 707.93 0.0 1.61e-4

f1 f2 f3 f4 f5 f6 f7

426 178 403 224 205 439 428

99855 98499 99889 99595 99504 99921 99946

57255 80699 59589 77195 79004 56021 57146

295 56 276 95 58 436 391

57.3 81.9 59.7 77.5 79.4 56.1 57.2

-12450.09 9.90e-2 0.11 0.24 9.56e-2 5.97e-3

319.36 9.45 1.39 0.53 0.11 1.49

f8 f9 f10 f11 f12 f13

100 119 394 296 228 213

98700 99978 99780 99908 99690 99155

88700 88078 60380 70308 76890 77855

26 28 255 164 94 63

89.9 88.1 60.5 70.4 77.1 78.5

0.998 4.36e-3 -1.031628 0.3979 3.0 -3.863 -3.322 -10.1532 -10.4029 -10.5364

7.89e-16 6.94e-3 4.51e-16 7.01e-7 9.31e-7 1.80e-15 5.599e-2 5.41e-15 2.81 1.98

f14 f15 f16 f17 f18 f19 f20 f21 f22 f23

777 659 777 772 778 734 617 671 671 667

99914 99880 99922 99910 99972 99894 99959 99916 99986 99968

22214 33980 22222 22710 22172 26494 38259 32816 32886 33268

761 413 759 742 758 711 561 639 624 606

22.2 34.0 22.2 22.7 22.2 26.5 38.3 32.8 32.9 33.3

Listed in Table IV are the number of generations (Gen.) the SSEA algorithm ran for each problem and the number of function evaluations used in simplex search for all the test problems. The numbers are reported for one of the experimental runs. The number of function evaluations in the simplex search step are not fixed but depend on the number of iterations of simplex search and how soon the convergence criterion is met. Hence the number of generations the algorithm ran for is different for each problem. Nf is the number of total function evaluations (max is 100,000), NfP S is the number of function evaluations used in the simplex search step. NP S is the number of times the simplex search was invoked. The last column in the table gives the percentage fraction of the total function evaluations used for simplex search. As seen from Table IV for optimization problems with single minima and a large number of minima, simplex search uses up most of the function evaluations budget even though it is called fewer times indicating that the simplex search is able to progress in the direction of the optimum and runs for maximum iterations of simplex search, whereas, for problems with fewer minima, simplex search is called a large number of times indicating the evolutionary steps (recombination and mutation) are not able to improve on the best candidate solution. As simplex search steps use up a small fraction of function evaluations, simplex search does find a small improvement. The results are compared also with those obtained by

1706

TABLE IV S UMMARY OF F UNCTION E VALUATIONS FOR A SINGLE RUN OF SSEA

TABLE V SSEA AND FES R ESULTS FOR 23 UNCONSTRAINED PROBLEMS fn

SSEA best

SSEA std. dev.

FES best

FES std. dev.

FES Gen.

f1 f2 f3 f4 f5 f6 f7

4.37e-11 2.48e-6 4.13e-10 1.01e-4 1.12e-2 0.0 1.30e-21

1.50e-8 1.97e-6 1.27e-7 3.82e-3 2.28 0.0 9.67e-14

2.5e-4 6.0e-2 1.4e-3 5.5e-3 33.28 0.0 1.2e-2

6.8e-5 9.6e-3 5.3e-4 6.5e-4 43.13 0.0 5.8e-3

750 1000 2500 2500 7500 750 1500

f8 f9 f10 f11 f12 f13

-12173.8 17.74 1.01e-6 5.13e-10 0.10 1.70e-4

543.11 22.11 1.41e-5 0.12 0.15 3.03e-3

-12556.4 0.16 1.2e-2 3.7e-2 2.8e-6 4.7e-5

32.53 0.33 1.8e-3 5.0e-2 8.1e-7 1.5e-5

4500 2500 750 1000 750 750

f14 f15 f16 f17 f18 f19 f20 f21 f22 f23

0.998 3.075e-4 -1.03163 0.3979 3.0 -3.863 -3.322 -10.1532 -10.4029 -10.5364

7.90e-16 4.36e-3 0.0 7.62e-7 0.0 4.51e-16 3.52e-2 5.41e-15 2.46 2.95

1.20 9.7e-4 -1.0316 0.398 3.0 -3.86 -3.23 -5.54 -6.76 -7.63

0.63 4.2e-4 6.0e-7 6.0e-8 0.0 4.0e-3 0.12 1.82 3.01 3.27

50 2000 50 50 50 50 100 50 50 50

2007 IEEE Congress on Evolutionary Computation (CEC 2007)

the Fast Evolutionary Strategy (FES) by Yao and Liu [3]. Shown in Table V are FES results averaged over 50-runs of (30,200)-ES as compared to SSEA results. For FES, the population size is 30 and the number of offsprings is 200 in each generation. For functions with a single minima, FES requires a minimum of 150,000 function evaluations (corresponding to 750 generations) for f1 and 1,500,000 function evaluations (corresponding to 7500 generations) for f5 . Compared to that the SSEA uses maximum of 100,000 function evaluations and performs much better at reaching the optimum. For problems with a large number of minima SSEA performs better than FES for f10 and f11 . FES uses a large number of function evaluations from 150,000 function evaluations (corresponding to 750 generations) for f10 , f12 and f13 to 900,000 function evaluations (corresponding to 4500 generations) for f8 . For problems with fewer minima, SSEA and FES both reach the optimum for problems f16 − f19 . For f15 , FES uses a large number of function evaluations (400,000 corresponding to 2000 generations), but still falls short of reaching the optimum objective value. For problems f21 − f23 , the results reported use only 10,000 function evaluations but the best values achieved are far from the optima. As FES results reported for f14 , f16 −f23 are with function evaluations less than 100,000, corresponding performance of SSEA is shown for comparison in Table VI. Test problems f14 , f16 −f19 , f21 −f23 use 10,000 function evaluations (corresponding to 50 generations) and f20 uses 20,000 function evaluations (corresponding to 100 generations). TABLE VI R ESULTS OF SSEA, FES AND FEP ON PROBLEMS f14 , f16 − f23 WITH 10,000 FUNCTION EVALUATIONS (20,000 IN CASE OF f20 ) fn f14 f16 f17 f18 f19 f20 f21 f22 f23

SSEA best 0.998004 -1.03163 0.39789 3.0 -3.86278 -3.322 -10.1532 -10.4029 -10.5364

SSEA std. dev. 3.062-4 5.30e-6 5.65e-5 4.77 1.07-5 3.52e-2 1.04e-4 2.464 2.948

FES best 1.20 -1.03163 0.398 3.0 -3.86 -3.23 -5.54 -6.76 -7.63

FES std. dev. 0.63 6.0e-7 6.0e-8 0.0 4.0e-3 0.12 1.82 3.01 3.27

FEP best 1.22 -1.03 0.398 3.02 -3.86 -3.27 -5.52 -5.52 -6.57

FEP std. dev 0.56 4.9e-7 1.5e-7 0.11 1.4e-5 5.9e-2 1.59 2.12 3.14

Further comparisons have been made with Fast Evolutionary programming (FEP) results by Yao and Liu [4]. Shown in Table VII are FEP results averaged over 50-runs of with the population size μ = 100, the tournament (fitness based) size q = 10 for selection as compared to SSEA results. Fast Evolutionary Programming (FEP) results are available for all the 23 test problems. As seen from Table VII, FEP uses a large number of function evaluations (maximum of 2,000,000 corresponding to 20,000 generations for f5 ). For problems with single minima SSEA outperforms FEP. For problems with large number of minima, SSEA performs better than FEP for f10 and f11 , whereas FEP comes closer to the optimums values for problems f8 − f10 , and f13

TABLE VII SSEA AND FEP R ESULTS FOR 23 UNCONSTRAINED PROBLEMS fn

SSEA best

SSEA std. dev.

FEP best

FEP std. dev.

FEP Gen.

f1 f2 f3 f4 f5 f6 f7

4.37e-11 2.48e-6 4.13e-10 1.01e-4 1.12e-2 0.0 1.30e-21

1.50e-8 1.97e-6 1.27e-7 3.82e-3 2.28 0.0 9.67e-14

5.7e-4 8.1e-3 1.6e-2 0.3 5.06 0.0 7.6e-3

1.3e-4 7.7e-2 1.4e-2 0.5 5.87 0.0 2.6e-3

1500 2000 5000 5000 20000 1500 3000

f8 f9 f10 f11 f12 f13

-12173.8 17.74 1.01e-6 5.13e-10 0.10 1.70e-4

543.11 22.11 1.41e-5 0.12 0.15 3.03e-3

-12554.5 4.6e-2 1.8e-2 1.6e-2 9.2e-6 1.6e-4

52.6 1.2e-2 2.1e-3 2.2e-2 3.6e-6 7.3e-5

9000 5000 1500 2000 1500 1500

f14 f15 f16 f17 f18 f19 f20 f21 f22 f23

0.998 3.075e-4 -1.03163 0.3979 3.0 -3.863 -3.322 -10.1532 -10.4029 -10.5364

7.90e-16 4.36e-3 0.0 7.62e-7 0.0 4.51e-16 3.52e-2 5.14e-2 2.46 2.95

1.22 5.0e-4 -1.03 0.398 3.02 -3.86 -3.27 -5.52 -5.52 -6.57

0.56 3.2e-4 4.9e-7 1.5e-7 0.11 1.4e-5 5.9e-2 1.59 2.12 3.14

100 4000 100 100 100 100 200 100 100 100

at the expense of much larger function evaluations. For test problems with fewer minima, SSEA performance is as good as the performance of FEP for problems f14 − f20 , and for problems f21 − f23 SSEA reaches the optimum, outperforming FEP. The FEP results for problems f14 , f16 − f23 are reported with 10,000 function evaluations corresponding to 100 generations (for f20 , 20,000 function evaluations are used corresponding to 200 generations). SSEA performance using the same number of function evaluations (as used by FEP) for functions f14 , f16 − f23 is listed in Table VI. SSEA comes very close to the optimum with fewer number of function evaluations as compared to the FEP. Along with FEP, Yao and Liu [4] have suggested the Improved Fast Evolutionary Programming (IFEP) algorithm, and the IFEP results are available for representative problems in each category. Table VIII lists the best results obtained by IFEP and SSEA. SSEA outperforms IFEP for all the test problems (f1 , f2 , f10 , f11 , f21 − f23 ) while using a lesser number of function evaluations for problems f1 , f2 , f10 , and f11 . V. C ONCLUSION Proposed in this paper is a simplex search enabled evolutionary algorithm (SSEA) for unconstrained optimization problems. Performance of this algorithm is tested on a number of benchmark problems. The algorithm outperforms

2007 IEEE Congress on Evolutionary Computation (CEC 2007)

1707

TABLE VIII SSEA AND IFEP RESULTS FOR FEW TEST PROBLEMS fn

SSEA best

IFEP mean best

IFEP Gen.

f1 f2

4.37e-11 2.48e-6

4.16e-5 2.44e-2

1500 2000

f10 f11

1.01e-6 5.13e-10

4.83e-3 4.54e-2

1500 2000

f21 f22 f23

-10.1532 -10.4029 -10.5364

-6.46 -7.10 -7.80

100 100 100

NSGA-II, FES and FEP for unimodal functions. For optimization problems with a large number of minima, SSEA performs better than NSGA-II, FES and FEP for some of the problems. Better results obtained by FES and FEP are at the cost of a large number of extra function evaluations. For optimization problems with fewer minima, SSEA reaches the optimum faster as compared to the other algorithms. Introduction of a simplex search step in an evolutionary algorithm improves the convergence rate. Once a candidate solution moves in to the basin of attraction of an optimum, simplex search advances the candidate solution towards the optimum rapidly. Presence of the candidate solutions in the neighborhood of the optimum is dictated by the number of clusters. For problems with a large number of local minima it might be beneficial to use a large number of clusters resulting in more simplex searches. More simplex searches will result in an increased number of function evaluations each generation. There is then a trade-off between the number of clusters and number of generations for which the algorithm will run.

1708

R EFERENCES [1] D. E. Goldberg, Genetic Algorithms for Search, Optimization, and Machine Learning. Addison-Wesley, 1989. [2] K. Deb, Multi-Objective Optimization using Evolutionary Algorithms. John Wiley and Sons Pvt. Ltd., 2001. [3] X. Yao and Y. Liu, “Fast evolutionary strategies,” in Evolutionary Programming VI, P. J. Angeline, R. G. Reynolds, J. R. McDonnell, and R. Eberhart, Eds. Berlin: Springer, 1997, pp. 151–161. [4] X. Yao, Y. Liu, and G. Lin, “Evolutionary programming made faster,” IEEE Transactions on Evolutionary Computation, vol. 3, no. 2, pp. 82–102, 7 1999. [5] J. A. Nelder and R. Mead, “A simplex method for function minimization,” Computer Journal, vol. 7, pp. 308–313, 1965. [6] N. Durand and J. M. Alliot, “A combined nelder-mead simplex and genetic algorithm,” Proceedings of the Genetic and Evolutionary Computation Conference GECCO, vol. 99, pp. 1–7, 1999. [7] S. Tsutsui, M. Yamamura, and T. Higuchi, “Multi-parent recombination with simplex crossover in real coded genetic algorithms,” Proc. of the Genetic and Evolutionary Computation Conference (GECCO-99), pp. 657–664, 1999. [8] J. Yen, J. C. Liao, B. Lee, and D. Randolph, “A hybrid approach to modeling metabolic systems using a genetic algorithm and simplex method,” IEEE Transactions on Systems, Man, and Cybernetics - PART B: Cybernetics, vol. 28, no. 2, p. 173, 1998. [9] R. Chelouah and P. Siarry, “Genetic and nelder-mead algorithms hybridized for a more accurate global optimization of continuous multiminima functions,” European Journal of Operational Research, vol. 148, no. 2, pp. 335–348, 2003. [10] K. Deb and S. Agrawal, “Simulated binary crossover for continuous search space,” Complex Systems, vol. 9, no. 2, pp. 115–148, 1995. [11] K. Deb and M. Goyal, “A combined genetic adaptive search (geneas) for engineering design,” Computer Science and Informatics, vol. 26, no. 4, pp. 30–45, 1996. [12] M. A. Luersen, R. L. Riche, and F. Guyon, “A constrained, globalized, and bounded neldermead method for engineering optimization,” Structural and Multidisciplinary Optimization, vol. 27, no. 1-2, pp. 43–54, 2004. [13] A. D. Gordon, “A review of hierarchical classification,” Journal of the Royal Statistical Society, vol. 150, no. 2, pp. 119–137, 1987. [14] A. K. Jain, M. N. Murty, and P. J. Flynn, “Data clustering: A review,” ACM Computing Surveys, vol. 31, no. 3, pp. 265–323, 1999.

2007 IEEE Congress on Evolutionary Computation (CEC 2007)