Self-Learning Gene Expression Programming

Self-Learning Gene Expression Programming Jinghui Zhong,Yew-Soon Ong,and Wentong Cai
Abstract—In this paper,a novel self-learning gene expression programming(GEP)methodology named SL-GEP is proposed to improve the search accuracy and efficiency of GEP.In contrast to the existing GEP variants,the proposed SL-GEP features a novel chromosome representation where each chromosome is embedded with subfunctions that can be deployed to construct thefinal solution.As part of the chromosome,the subfunctions are self-learned or self-evolved by the proposed algorithm during the evolutionary search.By encompassing subfunctions or any partial solution as input arguments of another subfunction, the proposed SL-GEP facilitates the formation of sophisticated, higher-order,and constructive subfunctions that improve the accuracy and efficiency of the search.Further,a novel search mechanism based on differential evolution is proposed for the evolution of chromosomes in the SL-GEP.The proposed SL-GEP is simple,generic and has much fewer control parameters than the traditional GEP variants.The proposed SL-GEP is validated on15symbolic regression problems and six even parity problems. Experimental results show that the proposed SL-GEP offers enhanced performances over several state-of-the-art algorithms in terms of accuracy and search efficiency.
Index Terms—Even Parity Problem,Evolutionary Compu-tation,Gene Expression Programming,Genetic Programming, Symbolic Regression Problem.
I.I NTRODUCTION
G ENETIC programming(GP)is an evolutionary compu-
tation technique that has been proven to be useful for automating the design of computer programs that solve user-defined tasks[1],[2].Since its inception by Koza in1992[1], many variants of GP have been developed[3]–[6].One of the notable variants is Gene Expression Programming(GEP), which was introduced by Ferreira[5]in early2000.The distinct feature of GEP is that it adopts a gene expression representation,which models after computer programs by usingfixed-length strings instead of using parse trees as in the traditional GP.With a gene expression representation, GEP is shown to provide more concise and readable solutions than GP[7].In the last decade,GEP has been widely used in many applications including classification problems,time series predictions and others[7]–[11].However,due to its iter-ative nature,the GEP can be quite computationally intensive, especially when dealing with large scale problems.Besides, GEP contains a number of control parameters in the algorithm which require time-consumingfine tuning.
To enhance the performance of GPs on large scale and complex applications,an effective approach is to incorporate Jinghui Zhong,Yew-Soon Ong,and Wentong Cai are with the School of Computer Engineering,Nanyang Technological University,Singapore, 639798(e-mail:jinghuizhong@;ASYSOng@.sg;ASWT-CAI@.sg;).
Copyright(c)2012IEEE.Personal use of this material is permitted. However,permission to use this material for any other purposes must be obtained from the IEEE by sending a request to pubs-permissions@.high order knowledge that can accelerate the search[12]–[18].Considering the classical10-bit even parity problem for example,it is extremely difficult for the traditional GP to solve this problem with only primitives“AND”,“OR”and “NOT”.Nevertheless,if the“XOR”function is introduced as a new primitive,the complexity of the problem can be largely reduced and thus the search process can be significantly ac-celerated[12].To define such high order knowledge,however, is often domain-specific and can be non-trivial.
In the GP community,some efforts to automate the ac-quisition of high order knowledge have been reported.For example,Angeline and Pollack[19],as well as Kameya[16], tried to mine for promising partial solutions as high order knowledge from historical search information,and then ensure their survival during the evolutionary process.Meanwhile, Koza[15]considered the high order knowledge as forms of Automatically Defined Functions(ADFs)and proposed to evolve ADFs automatically by GP during the evolutionary process.The ADFs are subfunctions that provide subsolutions to specific subproblems.The ADFs can then be combined to provide solutions to larger problems.Thus far,ADFs have been shown to be very effective for improving the performances of GP on a series of problems[15],[20],[21]. Recently,Walker and Miller[22]also considered the use of ADFs in an Embedded Cartesian Genetic Programming (ECGP),which reportedly outperformed GP and GP with ADFs on a variety of problems.
In contrast to the previous studies,little research on in-corporating high order knowledge such as ADFs to enhance GEP have been reported to date.Ferreira[23]had conducted a preliminary research on the use of ADFs to arrive at an enhanced GEP(named GEP-ADF).However,the mechanisms of GEP-ADF make it inefficient or non-scalable to large scale complex problems.Besides,GEP-ADF has many more new operators and control parameters than the traditional GEP, which makes it inconvenient for practical usage.
To address the above mentioned issues,this paper presents a novel Self-Learning GEP(SL-GEP)methodology.In the proposed SL-GEP,each chromosome is designed to comprise a main program and a set of ADFs,all of which are represented using a gene expression approach.Each ADF is then a subfunction for solving a subproblem,and is combined in the main program to solve the given problem of interest. Being part of the chromosome,the ADFs self-learn and are thus automatically designed in the SL-GEP along with the search as evolution progresses online.In the initialization step, all ADFs encoded in each chromosome have been randomly generated.Then in each generation,the evolutionary operators including mutation and crossover shall evolve the ADFs of the chromosomes accordingly.Through the selection operator, ADFs that lead to high quality solutions are more likely to
survive across generations.In this manner,high quality ADFs are evolved along with the evolutionary search process.A distinct feature of our SL-GEP is that our ADFs encompass other ADFs and/or any subtree of the main program as input arguments,resulting in the formation of complex ADFs or C-ADFs.This feature offers significant flexibility over the classical GEP search as well as the GEP-ADF in the design of sophisticated and constructive ADFs that showcases enhanced accuracy and search efficiency in the search.In addition,a novel
search mechanism based on differential evolution (DE)[24]is presented for the effective and efficient evolution of the solution population.The proposed SL-GEP is easy to implement,generic,and contains much fewer control param-eters than GEP and GEP-ADF.In the experimental section,the proposed SL-GEP is comprehensively validated using 15symbolic regression benchmarks and six even-parity problems.Results obtained demonstrate that the SL-GEP outperforms several state-of-the-art GP variants,in terms of accuracy and search efficiency.
The rest of the paper is organized as follows:Section II describes related background techniques.Section III describes the proposed SL-GEP.Section IV presents the experimental studies.At last,Section V draws the conclusions.
II.P RELIMINARIES
This section provides a brief introduction and some back-ground knowledge on the techniques considered in the paper.In general,GP has been widely used in various applications and one of the most common application areas is symbolic regression [25],[26].Thus,a formal definition of the symbolic regression problem is presented here to aid readers in compre-hending our proposed methodology better.Then the traditional gene expression approach of GEP [5]is presented,followed by a description of the extended gene expression approach that incorporates ADFs as introduced in GEP-ADF [23].Finally,other related GEP variants are discussed.
A.Symbolic Regression Problem
Given a set of measurement data which consist of input variable values and output responses,the symbolic regression problem involves finding a mathematical formula S (·)to describe the relationships between input variables and the outputs.The mathematical formula S (·)derived can provide insights into the system that generates the data and thus can be subsequently used for predicting the output of new input variables.
Formally,the i -th sample data can be expressed as:
[v i,1,v i,2,...,v i,n ,o i ]
(1)
where n is the number of input variables,v i,j is the j -th variable value of the i -th sample data,and o i is the corre-sponding output.The formula S (·)is comprised of function symbols (e.g.,+,×,sin ),variables and constants.The quality of a S (·)is evaluated by its fitting accuracy for given data.This is commonly achieved using the root-mean-square-error (RMSE ):f (S (·))=
N
i =1(y i −o i )2
N
(2)where y i is the output of S (·)for the i -th input data,o i is the true output of the i -th input data,and N is the number of data to be fitted.Therefore,given a function set and variable set as building blocks,the task to solve for a symbolic regression problem is to find the optimal formula S (·)∗that minimizes the RMSE for the given data:
S (·)∗=arg min S (·)
f (S (·))
(3)
B.Traditional Gene Expression Approach of GEP
Fig.1.The structure of traditional gene expression chromosome.
In traditional GP,the mathematical formula S (·)is repre-sented by tree structures that comprise of two types of nodes:function and terminal.A function node has one or multiple children (e.g.,+,sin ),while a terminal node is a leaf node without any child (e.g.,variables,constants).Instead of using parse trees as in the traditional GP,GEP uses fixed-length strings to represent mathematical formulas.As shown in Fig.1,a chromosome is represented by a string of symbols that comprises of two parts,namely Head and Tail .Each element of Head is a function or a terminal,while each element of Tail can only represent a terminal.For example,given a function set
Ψ={+,−,∗,/,cos,exp }(4)and a terminal set
Γ={x,y }
(5)
a typical gene expression chromosome of length 17can be
represented as:
X =[+,−,cos,∗,x,−,exp,+,y,x,x,x,x,y,x,y,x ]
(6)
Each gene expression chromosome can be converted to an equivalent expression tree (ET)using a breadth first traversal scheme.For example,the chromosome depicted in (6)can be converted to the ET form shown in Fig.2(a),which can be expressed mathematically as
(exp (x )∗(x +x )−x )+cos (y −x )
(7)
The lengths of both the Head (h )portion and the Tail (l )por-tion are kept as fixed.In order to ensure that any chromosome can be properly converted into a valid ET,h and l are imposed with the following constraint:
l =h ·(u −1)+1
(8)
where u is the maximum number of children in the functions.For example,if u =2,then we have l =h +1.
Note that in each chromosome,there may exist redundant elements in the Tail section,which are not used in the con-struction of ET in the current search generation.Nevertheless,it is worth noting that these unused elements may become useful in subsequent generations as the search evolves.For
+x
‐x
+cos ‐*x
x x exp y +x
‐
+
+
cos ‐
*
x
y x exp x
x
y (a)(b)
Fig.2.Examples of two ETs.(a)the original ET.(b)the modified ET after mutating a symbol of the original ET.
instance,referring once again to (6),if the fifth symbol in this chromosome (i.e.,x )evolves to +,the 14-th and 15-th elements (i.e.,y and x )change from being deemed as redundant to become useful for constructing the converged ET,which is illustrated in Fig.2(b).In addition,since the number of nodes in the final ET never exceeds the predefined length of the chromosomes,the gene expression approach has a tendency of producing short programs,thus avoiding the bloating limitation of GP.
In the classic GEP,the evolutionary operators include ini-tialization,evaluation,elitist,selection,mutation,inversion,IS-Transposition,Root-Transposition,one-point crossover and two-point crossover.The readers are referred to [5],[8]for the implementation details of GEP.
C.Extended Gene Expression Technique Used in GEP-ADF In [23],Ferreira
combined ADF with GEP to arrive at the GEP-ADF.In GEP-ADF,each chromosome consists of a number of conventional genes and a homeotic gene,as illustrated in Fig.3.All of the conventional genes and the homeotic gene are represented using gene expression.Each conventional gene encodes a sub ET,and serves as an ADF.The homeotic gene fuses different ADFs via linking functions (e.g.,+,∗),and encodes the main program that generates the final output.The function set and terminal set of ADFs are the same as in the traditional gene expression approach.The function set of the homeotic gene,on the other hand,comprises of the linking functions,while the terminal set of homeotic gene contains only ADFs.
Fig.3.The structure of the gene expression chromosome in GEP-ADF.
For example,consider the following chromosome:
[∗,+,−,y,x,x,z,+,/,−,x,y,z,x,
∗,∗,sin,2,+,1,2,1,2,1,2]
(9)
This chromosome encodes two ADFs and one homeotic gene (i.e.,the main program).An example ET of the GEP-ADF is illustrated in Fig.4.It can be observed that both ADF 1and ADF 2are used twice in the homeotic gene.Further,it should
Fig.4.An example chromosome of GEP-ADF and the corresponding ET.
be noted with this chromosome representation,ADFs can only be used as terminals of the homeotic gene and contain no input argument.
D.Other Related GEP variants
Since the first introduction of GEP,various enhanced GEP variants have been proposed.Existing works mainly focus on hybridizing new operations or adaptive parameter controlling strategies with GEP to improve the search efficiency.For example,Liu et al.[27]proposed an extended GEP which adaptively replaces worse individuals with randomly generated individuals,so as to increase the population diversity.A hybrid selection method was also adopted to improve the search efficiency.Similarly,Zhang and Xiao [28]proposed a modified GEP that dynamically changes the population size as a way to avoid local stagnation.Instead of first building a tree and then traversing the tree for fitness evaluation,Peng et al.[29]proposed a new method to evaluate fitness of gene expression chromosomes without building the expression tree.This method was reported to be capable of reducing the computational efforts of the GEP.Elena et al.[30]presented an adaptive GEP that adaptively adjusts the number of genes used in the chromosomes.Huang studied the schema theory of GEP and developed some theorems that describe the propagation of schema from one generation to another.
In contrast to previous works,this paper extends the canon-ical GEP with ADFs as part of the chromosome representation that self-evolve or self-learn along with search evolution,while at the same time deploying them for acceleration of the search.Further,this paper develops novel DE-based operators in the GEP.The proposed DE-based search mechanism not only contains much fewer control parameters,but also offers improved search performance.
III.S ELF -L EARNING G ENE E XPRESSION P ROGRAMMING This section describes the proposed SL-GEP methodology,which is an enhanced version of the classical GEP as well as the GEP-ADF.In contrast to the existing GEP approaches,SL-GEP introduces a novel chromosome representation that facil-itates the formation of C-ADFs which embodies sophisticated and constructive high-order knowledge concisely.Further,a novel evolutionary search mechanism is proposed to simplify the evolution of chromosomes in SL-GEP.Since the ADFs and C-ADFs are self-learned along with the GEP search evolution,we label the proposed algorithm as Self-Learning GEP (SL-GEP).
A.Proposed Chromosome Representation
In the proposed SL-GEP,each chromosome comprises of a “main program”and several ADFs,as illustrated in Fig.5.The main program is the compressed expression of the solution,which provides the final output.Meanwhile,each ADF is a subfunction,which can be combined to solve the larger problem in the main program.Both the main program and ADFs are represented using a gene expression representation.But the main program and ADFs have different function sets and terminal sets.For the main program,the function set consists of not only functions (e.g.,+,−,and sin )but also ADFs defined in the chromosome,while the terminal set consists of variables and constants (e.g.,x ,y ,π).For ADFs,the function set consists of functions,while the terminal set consists of input arguments.Table I compares and contrasts the function sets and the terminal sets of the three gene expression approaches considered in this study.
Fig.5.
The structure of the proposed chromosome representation.
*
*
+
a
b
G G
G x G sin G G x
x z y * + * a b a b ADF 1Main program
x
z sin a
b
G (sin(G (x , z )),G (x , ))
G (a, b ) = (a + b ) ∗ (a ∗ b )
(sin((x + z ) ∗ (x ∗ z )) + (x +
) ∗ (x ∗ ))) ∗ sin((x + z ) ∗ (x ∗ z )) ∗ (x + ) ∗ (x ∗ ))*
*
+
x x **+x
z
x z sin *
*
+x x *
*+x
z
x
z sin *
*
+
(a)
(b)
ππMain program : ADF 1:π
πππ
πππππFig.6.An example chromosome of SL-GEP and related ETs.(a)An example chromosome of SL-GEP and the corresponding ET using ADFs.(b)The decoded ET without using ADFs.
Figure 6shows an example chromosome of the proposed representation in SL-GEP.Suppose the value of u in (8)is 2,and h and l are set to be:h =4,l =5;the head length (h )and tail length (l )of ADFs are set to be:h =3,l =4.A typical chromosome with one ADF can be expressed as:
[G,sin,G,G,x,π,x,z,y,∗,+,∗,a,b,a,b ]
(10)
TABLE I
T HE FUNCTION SETS AND TERMINAL SETS IN THREE GENE EXPRESSION
TECHNIQUES .Method Position Function set Terminal set GEP Head and T ail functions variables,constants
GEP-ADF Main Program
linking functions
ADFs
ADFs functions variables,constants SL-GEP
Main Program
functions,ADFs variables,constants ADFs
functions
input arguments
where {+,∗,sin }is the function set,G is the ADF,{x,z,π}is the terminal set,and {a,b }is the set of input arguments.As shown in Fig.6,the main program can be decoded as
G (sin (G (x,z )),G (x,π))
(11)
and the ADF can be decoded as
G (a,b )=(a +b )∗(a ∗b )
(12)Inserting (12)into (11),we then obtain the final expression (S ):
S =G (sin (G (x,z )),G (x,π))
=G (sin ((x +z )∗(x ∗z )),(x +π)∗(x ∗π))= sin ((x +z )∗(x ∗z ))+(x +π)∗(x ∗π)) ∗ sin ((x +z )∗(x ∗z ))∗(x +π)∗(x ∗π))
(13)
In this way,an ET with 33nodes can be concisely represented by two ETs with a total of only 15nodes.Through this simple example,we hope to demonstrate the benefit of the proposed chromosome representation in terms of effectively compressing complex expressions concisely.
In addition,as can be seen in the above example,a distinct feature of the SL-GEP that differs from GEP-ADF [23]is that our approach introduces C-ADFs that have input arguments that can come in the form of variables (e.g.,x,z ),constants (e.g.,π),ADFs,or any subtree of the main program.For example,in Fig.6(a),the root node of the main program is an ADF with two input arguments.The first input argument is a subtree of the main program (i.e.,sin (G (x,z ))),while the second input argument is an ADF (i.e.,G (x,π)).This feature significantly improves the capabilities of chromosomes to represent sophisticated high-order expressions concisely.Specifically,the expression x 100can be represented as G ∗G ∗G ∗G ∗G ∗G ∗G ∗G ∗G ∗G ,when G =x 10and ∗are defined as the ADF and linking function,respectively,in the GEP-ADF.In contrast,the same expression can be more concisely represented as G (G (x ))in our proposed SL-GEP by simply defining a C-ADF with G (a )=a 10.This is not only more concise but also more human readable.B.Proposed Algorithm
The chromosome representation of SL-GEP is of fixed length and structurally similar to the traditional gene ex-pression.Thus,the search mechanism of GEP can be easily integrated to evolve chromosomes with the proposed repre-sentation.However,the GEP contains a number of operations and control parameters that need to be carefully tuned.To
TABLE II
T HE BASIC NOTATIONS.
Name Summary
NP The size of population.
X i The i-th target vector in the population.
Y i The mutant vector of X i.
U i The trial vector of X i.
D The number of elements in each chromosome.
x i,j The j-th element of X i.
y i,j The j-th element of Y i.
u i,j The j-th element of U i.
F The scaling factors in mutation operation.
CR The crossover rate.
ϕThe mutation probability.
p a The selection probability of element a.
E max The maximum number offitness evaluations.
c rate The probability of an element being a constant.
H1The Head of main program in a chromosome.
T1The T ail of main program in a chromosome.
H2The Heads of ADFs in a chromosome.
T2The T ails of ADFs in a chromosome.
h The length of H1.
l The length of T1.
K The number of ADFs in each chromosome.
h The head length of ADFs.
l The tail length of ADFs.
θThe proportion of functions and ADFs in H1of all
chromosomes in the population.
Rand(A)Randomly choose an element from A.
Route-wheel(A)Use Route-wheel selection to choose an element
from A based on the selection probabilities of el-
ements in A.
solve this problem and further improve the performance,this subsection proposes a novel search mechanism based on DE operations.The procedure of the proposed SL-GEP is given in Algorithm1,which consists of four main steps,namely initialization,mutation,crossover,and selection.The basic notations are listed in Table II.
1)Step1-Initialization:Thefirst step is to generate NP random chromosomes to form an initial population.As defined in Section III-A,each chromosome can be represented by a vector of symbols labeled here as target vector:
X i=[x i,1,x i,2,...,x i,D](14)
where i is the index of the chromosome in the population,D is the length of the chromosome,and x i,j is the j-th element of X i.The value of D is computed by:
D=h+l+K∗(h +l )(15)
where K is the number of ADFs in each chromosome.Note that in this paper,the maximum number of input arguments for all functions and ADFs is two,thus we have l=h+1, and l =h +1.The value of x i,j is assigned by a“random assignment”scheme which contains two phases.Thefirst phase is to configure the type as a function,ADF,terminal, or input argument,randomly.Nevertheless,the assigned type must be feasible.For example,if x i,j belongs to the Tail of a main program,then x i,j can only be of a terminal type. Denoting the set of feasible values of the assigned type as E, the second phase thus involves a random selection of a feasible value from E as the value of x i,j.
Algorithm1:SL-GEP.
1Begin:
2for i=1to NP do
3for j=1to D do
4x i,j←“random assignment”
5Evaluate the initial population
6while termination condition is not met do
7Update the frequencies of functions and variables
8for i=1to NP do
/*mutation and crossover*/ 9F=rand(0,1);CR=rand(0,1)
10Randomly choose two individuals X r1=X i,and X r2=X i=X r1from current population
11Set k to be a random integer between1and D
12for j=1to D do
13Calculate the mutation probabilityϕby(28) 14if(rand(0,1)<CR or j=k)and
(rand(0,1)<ϕ)then
15u i,j←“frequency-based assignment”
16else
17u i,j=x i,j
/*Selection*/ 18if f(U i)<f(X i)then
19X i=U i;
20End
It should be noted that the initialization step randomly initializes the chromosomes,including the ADFs.The chromo-somes are then evolved iteratively via the mutation,crossover and selection evolutionary operations.Hence,the ADFs will self-learn along with the SL-GEP search,without a priori knowledge or manual configuration.
2)Step2-Mutation:In the second step,a mutation operation is performed on each target vector to generate a mutant vector.The traditional DE mutation is expressed as
Y i=X r1+F·(X r2−X r3)(16) where F is the scaling factor,r1,r2,r3and i are four distinct individual indices.
However,since the elements in the chromosomes are dis-crete symbols,the numerical operations of the traditional DE cannot be directly used.To address this issue,we decompose the DE mutation into three phases.Thefirst phase is to obtain a difference(∆)of two random target vectors in the current population(named Distance Measuring):
∆=(X r2−X r3)(17) The second phase is to scale the difference by a coefficient F (named Distance Scaling):
∆ =F·∆(18) The third phase is to add the scaled difference to another ran-dom target vector to create a mutant vector(named Distance
Adding ):
Y i =X r 1+∆
(19)
In the search space of tree structure computer programs,the above three phases are implemented as follows.
Distance Measuring :In the discrete domain,the distance between two elements can be zero (i.e.,two elements are the same)or none zero.Here we use a “don’t care”symbol “*”to represent a nonzero distance:
x i,j −x k,j =
0,if x i,j is the same as x k,j
∗,otherwise (20)
where x i,j and x k,j are the j -th element value of X i and the j -the element value of X k respectively.For example,sin −exp =∗;sin −sin =0.In this way,we can obtain the ∆in (17)using a binary difference vector.Each dimension of the difference vector is then computed using (20).
Distance Adding :We describe the third phase before the second phase to facilitate the understanding.The third phase adds a difference vector to a target vector,so as to create a mutant vector.Clearly,an element will remain unchanged if it is added to a zero distance:
x i,j +0=x i,j
(21)
If x i,j is added to a nonzero distance,it will evolve into a new value:
x i,j +∗=a,a ∈Ωj (22)where Ωj is the set of feasible values for the j -th dimension
of X i .The new value a is selected with a “frequency-based assignment”scheme,as described in Algorithm 2.In the “frequency-based assignment”scheme,if x i,j ∈ADF ,it will be assigned in the same way as in the “random assignment”scheme.Otherwise,the type is chosen based on the frequencies of the feasible types that appear in the population.Particularly,feasible types that appear more often in the population are more likely to be selected when using the “frequency-based assignment”scheme.The selection probability of a is
p a =c a +c 0
b ∈Ωj (
c b +c 0)
(23)
where c a is the frequency of a in the main programs of all chromosomes in the population,and c 0is a small constant (e.g.,c 0=1).We introduce c 0to ensure that each feasible value has at least a small selection probability even though its frequency is near to zero or equals zero.
Distance Scaling :In the second phase,the difference vector is scaled by a coefficient factor F .To achieve this,we make x i,j evolve into a new value at a mutation probability of ϕ,if it is added to a nonzero distance.The mutation probability is determined by
ϕ= a ∈Ωj
(F ·(c a +c 0) b ∈Ωj (c b
+c 0))=F (24)
In this way,a small F translates to a small mutation proba-bility,which has the effect of making the mutant vector more
similar to the base target vector.
Algorithm 2:Frequency-based assignment Input :The element to be mutated (I ).Output :The mutated element (I ).
1Begin :
2if I ∈H 1then
3if rand (0,1)<θthen 4I =Roulette-wheel(function set
ADF set).
5else
6I =Roulette-wheel(terminal set)7else if I ∈T 1then
8I =Roulette-wheel(terminal set)9else if I ∈H 2then
10type =Rand ({function,input argument })11if type =function then
12I =Rand (function set)
13else
14I =Rand(input argument set)15else if I ∈T 2then
16I =Rand(input argument set)17
End
To summarize,the above three phases enable the DE mutation to generate mutant vectors in a discrete space.In the SL-GEP,we use the commonly used “DE/current-to-best/1”mutation scheme as expressed by
Y i =X i +F ·(X best −X i )+F ·(X r 1−X r 2)
(25)
where X best is the best individual in the population.The above mechanism can be easily extended to implement the “DE/current-to-best/1”.The computation process of (25)can be decomposed into two substeps,i.e.,T i =X i +F ·(X best −X i )and Y i =T i +F ·(X r 1−X r 2),where T i =[t i,1,t i,2,...,t i,n ]is a temporary vector.The probabilities of x i,j and t i,j remaining unchanged in the first and second substep are 1−F ·ψ(x pbest,j ,x i,j )and 1−F ·ψ(x r 1,j ,x r 2,j )respectively,where ψ(a,b )is defined as
ψ(a,b )=
1,if a =b
0,otherwise (26)
Therefore,the probability of x i,j remaining unchanged after performing the two substeps is:
(1−F ·ψ(x best,j ,x i,j ))∗(1−F ·ψ(x r 1,j ,x r 2,j ))(27)
Hence,the mutation probability of x i,j is
ϕ=1−(1−F ·ψ(x best,j ,x i,j ))∗(1−F ·ψ(x r 1,j ,x r 2,j ))(28)To improve the robustness of the algorithm and reduce the number of control parameters,we also adopt a random scheme to set the values of F in the “DE/current-to-best/1”mutation scheme:
F =rand (0,1)(29)where rand (a,b )returns a random value uniformly distributed
within [a,b ].。