Faster Evolutionary Algorithms by Superior Graph Representation

Transcription

1 Faster Eolutionary Algorithms by Superior Graph Representation Benjamin Doerr Max-Planck-Institut für Informatik Stuhlsatzenhausweg Saarbrücken, Germany Christian Klein Max-Planck-Institut für Informatik Stuhlsatzenhausweg Saarbrücken, Germany Tobias Storch Department of Computer Science Uniersity of Dortmund Otto-Hahn-Str Dortmund, Germany Abstract We present a new representation for indiiduals in problems that hae cyclic permutations as solutions. To demonstrate its usefulness, we analyze a simple randomized local search and a(+) eolutionary algorithm for the Eulerian cycle problem utilizing this representation. Both hae an expected runtimeof Θ(m log(m)),where mdenotesthenumberofedges of the input graph. This clearly beats preious solutions, which all hae an expected optimization time of Θ(m 3 ) or worse (PPSN 06, CEC 04). We are optimistic that our representation also allows superior solutions for other cyclic permutation problems. For NP-complete ones like the TSP, howeer, other means than theoretical run-time analyses are necessary. I. INTRODUCTION Randomized search heuristics not only hae many applications but also a high ariety. The probably best-known heuristics belonging to this broad class of optimizers are randomized local search(rls) and eolutionary algorithms(eas)(cf.[]). For a wide range of applications a remarkable experimental success of such heuristics(and hybrid algorithms) is reported (see, for example,[8] for the traeling salesman problem). From a theoretical point of iew, howeer, only little is known about randomized search heuristics. The first rigorous probabilistic runtime analyses of EAs inestigated the behaior of simple ariants thereof on simple classes of functions(see [4]). Een less is known for the behaior of randomized search heuristics in combinatorial optimization. Only recently, analyses of simple EAs on combinatorial optimization problems were presented(see, for example,[3] for the partition problem and[] for the minimum spanning tree problem). Most of these EAs are intended to optimize pseudo-boolean objectiefunctions f : {0, } n Rorfunctions f : S n R on the set of all permutations. Nonetheless, it is well-known in eolutionary computation that the appropriate choice of the objectie function describing the gien problem and thereby, in particular the choice of the search space is of huge importance(see[] for the minimum spanning tree problem). Many combinatorial optimization problems deal with graphs and subclasses thereof, such as trees. We deelop an edgebased representation for graphs which is quite simple and natural and efficient to handle. Moreoer, an appropriate mutation operator for our representation is gien. We examine how simple randomized search heuristics for the Eulerian cycle problem benefit from our representation to illustrate its adantages. A. The Eulerian Cycle Problem The Eulerian cycle problem is a prototypical problem on graphs. It is the generalization of the well-known problem of the Seen Bridges of Königsberg presented by Leonard Euler in736,oneofthefirstconsiderationsofgraphtheory(see [6]). Furthermore, the Eulerian cycle problem is not only an interesting theoretical problem, it is also a subroutine for many established algorithms such as Christofides approximation algorithm for the metric traeling salesman problem[]. Gien anundirectedconnectedgraph G = (V, E)asolutiontothe Eulerian cycle problem is a tour that uses eery edge exactly once.euleralreadyproedthatsuchatourexistsifandonlyif the degree of each ertex is een. Graphs containing an Eulerian cycle are called Eulerian(graphs). Optimal deterministic algorithms for the Eulerian cycle problem compute such a tour intime O( V + E )(see[7]). Since randomized search heuristics are not problem-specific, it is doubted that they can outperform algorithms specifically tailored for a problem. They are, howeer, typically easy to implement and thus quite popular for real-world applications. Randomized search heuristics for a specific problem may also be able to sole generalizations of the problem. They canalsobeeasilyappliedtoawiderangeofnotsowell understood problems. Inestigating them can help to increase the knowledge about such problems or their generalizations and may thus een lead to better problem-specific algorithms (see[5] for generalizations of the Eulerian cycle problem). B. Preious Work Neumann[0] inestigated the Eulerian cycle problem for the search space of all permutations of the edges. He considers two mutation operators; the exchange -operator, which swaps two elements of the permutation and the jump -operator, which inserts an element of the permutation at a new position. His objectie function counts how many of the leading elementsofthepermutationstilldescribeapathinthegraph.for the exchange-operator, he proes that the RLS and the (+)- EA hae an infinite resp. exponential expected optimization time. Using the jump-operator, both RLS and the ( + )- EAhaeapolynomialexpectedruntimeof O( E 5 ).Doerr, Hebbinghaus, and Neumann[3] analyzed a restricted ersion of the jump operator. Their modification improes the expected

2 e e = {, w} Fig.. Theedge e = {, w}anditstwoassociatedpointers. optimizationtimeto O( E 3 )forbothrlsandthe ( + )- EA.Theyalsogieaclassofgraphsforwhichbothheuristics haeoptimizationtime Ω( E 3 )withhighprobability. C. Our Contribution In this paper, we improe the optimization time to O( E ln E )fortherlsandthe ( + )-EA.Toachiee this significant improement, we do not tweak the mutation operator as in the aboe mentioned papers, but design a better graph representation for the heuristics to use. We also show that our analysis is tight by giing graphs that exhibit an expectedoptimizationtimeof Ω( E ln E ). In order to concentrate on the effects of our newly deeloped graph representation, we only consider two simple randomized search heuristics; the RLS, which just performs local changes, and the so-called ( + )-EA, which also performs global changes. This aoids unnecessary complications in the analysis due to the effects of other components of randomized search heuristics. For some optimization problems, a representation dualtotheonepresentedinthispaper,i.e.,withtherolesof ertices and edges exchanged, may be more suitable. In Section II we introduce our new graph representation for eolutionary computation together with an appropriate mutation operator. We also gie a natural and easy ealuable objectie function for the Eulerian cycle problem. In SectionIIIwedefineandanalyzeaRLSforthisrepresentation. Thisanalysisisextendedtothe (+)-EAinSectionIV.We finish with a summary and some conclusions in Section V. II. REPRESENTATION In this section we propose a new representation of indiiduals that in particular allows faster computation of an Eulerian cycle. A. The Search Space Gienanundirectedgraph G = (V, E)let,..., n bethe nerticesand e,..., e m bethe medgesinanarbitrarybut fixed order. In preious works indiiduals are represented as permutation of the edges. This permutation-based representation, howeer, leads to arious problems, for example if a graph consists of multiple cycles(cf.[3],[0]). A representation of paths used in classical graph theory is tonametheedgesintheordertraersedandforeachpairof edgesnametheertextheyshare.basedonthiswegiean edge-based representation that represents a graph as sequence ofpaths.foreachedge,wewanttostoreitstwoneighboring w e w edgesinapath.inotherwords,foranedge e = {, w} E,, w V weneedtostoreitsneighboringedgeincidentto anditsneighboringedgeincidentto w. Technically, an indiidual is represented by an array of m pointers, two of them associated with each edge, one for each ertex incident to the edge. More precisely, let e i = { j, k }, i [..m], j, k [..n], j < k n. We associatethe (i )standthe ithpointerwiththeedge e i.thefirstpointer,denoted e j i,isassociatedwithertex j ofedge e i,andthesecondpointer,denoted e k i, is associated withertex k ofedge e i.figureshowsthesituationfor oneedge e = {, w}. Apointer e w ofanedge e Eshouldalwayspointtoan edge f Eforwhich w f holds.otherwisethepointer pointstoaspecialalue.inthefirstcasewewrite e w f, inthesecondcasewewrite e w. Fortwoedges e, f Ewewrite e = f,if V : ( e) ( f) (e f) (f e). Inotherwords,wewrite e = fiftheedges eand fhaea commonertex andeachofthemhasapointertotheother edge. The initial indiidual has all pointers pointing to. Hence thefirstindiidualisjustacollectionof mconnectedcomponents(the edges). An indiidual representing an Eulerian cycleontheotherhandhasjustoneconnectedcomponentof size m.thesetofallindiiduals(ofsize m)iscalledthe searchspaceanddenotedby I m. B. The Mutation Operator Haing characterized the search space, we now gie a canonical mutation operator for it. We denote this mutation operatoron I m by.theoperatorwillconnecttworandom edges by adjusting their pointers accordingly(see Figure ). A formal definition follows. Definition:Let e, f Eand e, f E {}suchthat e e and f w f.ifboth e, f and = wthen e f w changesthepointersofthosefouredgesasfollows: e := f ; f w := e e := f ; f w := e If = wbut e, f =,thenonly e := f; f w := ewillbe changed,as hasnopointers.if w,thenthe -operator willsetallpointersto. Fromthedefinitionofthe -operatorandthefactthatthe initial indiidual has only -pointers, the following Lemma easily follows. Lemma:Assume that an arbitrary number of - operations is applied to the indiidual with all pointers set to.thenthefollowingholdsforanyedge e Econtaininga ertex e. ) If e thenthereexistsanedge f Ewith f and f. ) If e fand f then f e.

3 e e e e f e f f f f Fig.. The -Operator e f onfouredgesincidenttoacommonertex. The pointers are depicted as arrows. e e e f f f RANDOMIZED LOCAL SEARCH Initialize pointers of indiidual I to. repeat 3 I I 4 Choosepointers e, f w u.a.r. 5 Apply e f w to I. 6 if f(i ) f(i) 7 then I I 8 until false Fig. 4. Randomized Local Search. (a) Fig.3. Twocyclesmeetinginacommonertex mayposeaproblemfor simplefitnessfunctions.incase(a)thefitnessfunction f ptrwillfail,incase (b) f compcannotincrease.dashedellipsesmarkconnectededge-pointers. Proof: This follow from the fact that if the -operator changesapointer e := fitalsochanges f := e. BythisLemmaitimmediatelyfollowsthatif e f then e = fholds. C. A Fitness Function for the Eulerian Cycle Problem We hae designed the search space and the mutation operator without using any knowledge about the specific problem at hand. To allow randomized search heuristics to sole a gien problem, we need to find a good objectie function f : I m R that assigns to each element of the search space a alue. This alue should somehow reflect how close anelementofthesearchspaceistobeingasolutiontoour problem. Such a function is called fitness function, since it tellsushowfitacertainelementof I m is.wenowgiea fitness function for the Eulerian cycle problem whose alue willbesmallforelementsclosetoasolution.thegoalof a randomized search heuristic is then to to minimize this function. Two possible functions seem to be candidates for the fitness function.oneisthenumberofpointersto,denoted f ptr,as aneuleriancyclehasno -pointers.theotheristhenumber ofconnectedcomponentsintheindiidual,denoted f comp,as an Eulerian cycle is just one connected component. Unfortunately, they both don t work as expected. To see this,consideragraphconsistingofmultiplecycles.for f ptr, an indiidual where each cycle forms its own component will haethesamefitnessasaneuleriancycle(seefigure3(a) foranexample).asearchheuristicusing f comp mayalsofail, although an indiidual consisting of just one component is an Euleriantourandiceersa.Toseethis,againconsidera graph consisting of multiple cycles and an indiidual where each cycle forms its own component. If each component has exactly one pair of -pointers, then, no matter what operation (b) isdone,thenumberofcomponentswillstaythesame.this is illustrated in Figure 3(b). Although the aboe examples look quite similar, the fitness functions fail for different reasons. Indeed, the fitness function wewilluseissimplythesumofbothfunctions,i.e. f := f ptr +f comp.forthisfitnessfunctionwewillproethatboth aariantofrlsandasimpleeawillsuccessfullygenerate an Eulerian cycle. SinceanEuleriantourhasnopointersto andconsists ofjustonecomponent, fwillassignafitnessof toit.the initialindiidualhasfitness 3m,aseachofthe medgesisits owncomponentandhastwopointersto.ifagraphisnot Eulerian,ithasafitnessofmorethan.Hencewewillonly consider Eulerian graphs as input. Note that if we consider multi-graphs, the aboe gien representation and fitness function still work. III. RANDOMIZED LOCAL SEARCH Randomized local search is one of the simplest randomized search heuristics. It considers a population of size one and produces a single new indiidual in each generation. To generate the new indiidual, a single mutation is applied to the current indiidual. If the fitness of the newly generated indiidualisnotworsethanthatoftheoldindiidual,the new indiidual replaces the old one. As we are minimizing, thishappensifthealueassignedtotheoldindiidualby fis notlowerthanthealueassignedtothenewindiidual.the mutation and selection is then repeated foreer. In the mutation step, two array elements i, j [..m], corresponding to two pointers e, f w,arechosenuniformlyatrandom.themutation appliedtogetthenewindiidualis e f w.figure4shows thepseudo-codefortheariantofrlsconsideredbyus.in practice, a stopping criterion is needed, as we cannot run the algorithm foreer. Hence, we are interested in the expected number of fitness ealuations until the indiidual I represents an Eulerian cycle. A.AnUpperBoundontheOptimizationTimeofRLS We first analyze the probability that a random mutation will improe the fitness of an indiidual. Lemma3:Theprobabilityforamutationtoimproethe fitnessofanindiidualwithfitness k > is Ω( k m ).

4 Proof: First obsere that each component in the representation of an indiidual contributes at least to its fitness. Ontheotherhand,eachcomponentcancontributeatmost 3 (foritbeingacomponentandfortwo -pointersifitis notacyclebutapath)tothefitness.henceanindiidualof fitness k has Θ(k) components. Wenowshowthatforeachcomponentthereisatleastone fitness-increasingmutation e f,where eisanedgeofthe component. This and the fact that there are Θ(k) components proes the Lemma. Case:Thecomponentisacycle. Since k >, this cannot be the only component of the indiidual. Hence there exists a ertex which is incident with bothanedgeofthecomponentandanedgenotbelongingto thecomponent.let eand e betwoedgesofthecomponent containingtheertex forwhich e = e holds.sinceeach ertexhaseendegree,thereareatleasttwoedges f, f not belonging to the component and adjacent to such that either oneofthem,say f,isthefirstedgeofacomponent,orthey bothbelongtothesamecomponentand f = f.inbothcases themutation e f willmergethetwocomponents eand f belong to. Hence, the number of components decreases and thus the fitness of the indiidual improes under this mutation. Case:Thecomponentisnotacycle. Thentheremustbeanedge ewith e = inthecomponent. Let ebetheertexof eforwhich e.bylemma, thereexistsanotheredge f with f and f.but then e f willdecreasethenumberof -pointersandthus improethefitness.obserethateither eand fcanbeedgesof the same components, in which case the mutation will change thecomponenttoacycle,or fbelongstoanothercomponent, inwhichcasethecomponentof eisenlarged. Since RLS will not accept mutations that decrease the fitness of an indiidual,lemma3tells us how long we need to wait in expectation until a fitness-increasing mutation happens. Becausethefitnessoftheinitialindiidualisknowntobe 3m,thisallowsustogieanupperboundontheexpected optimization time. Theorem 4: Randomized Local Search will produce an Euleriancycleafteranexpectednumberofatmost O(m log m) steps. Proof: According to Lemma 3 it takes an expected number of ( m ) m O = O(m log m) k k= steps until the indiidual consist of only one connected component. If this component forms an Eulerian cycle, we are done. Ifnot,wecanapplycasefromtheproofofLemma3toget aneuleriancycleafteranexpectednumberof m additional steps. B.ALowerBoundontheOptimizationTimeofRLS Toproethatouranalysisistight,let C m bethegraph consistingofasinglecycleof m = nedges.forthisgraphthe ( + ) EVOLUTIONARY ALGORITHM Initialize pointers of indiidual I to. repeat 3 s Pois(λ = ). 4 I I. 5 for i to s + 6 do 7 Choosepointers e, f w u.a.r. 8 Apply e f w to I. 9 if f(i ) f(i) 0 then I I until false Fig. 5. The ( + ) Eolutionary Algorithm. expected optimization time can be calculated exactly. Define the mthharmonicnumberas H m := m i= i. Theorem 5: The expected optimization time of Randomized LocalSearchon C m equals m H m Θ(m log m). Proof: The first indiidual consists of the m single edges andallpointerssetto andthushasafitnessof 3m.As long as the indiidual does not represent an Eulerian cycle, itsfitnessisamultipleof 3,namely 3timesthenumberof components, as it cannot contain any sub-cycles. Aslongasthefitnessis 3m,thereexistsexactlyonepointer f foranyfixedpointer e,suchthat e f improesthe fitnessoftheindiidual.hencewithprobability m thefitness willimproeby 3. Nowassumethatthecurrentindiidualconsistsof < k < m connected components, hence haing fitness 3k. Then there are k pointers (namely the first and last of each indiidual) which can be used to improe the fitness. Oneofthoseispickedwithprobability k m.ifthishappens, then the probability that the second pointer is such that the fitness improes is m,sincethereisonlyonesuchpointer. Hence,withprobability k 4m thefitnessimproesby 3ina single mutation. We conclude that the expected time for this improementis m k. Thus,toreachfitness 3,weneedanexpectednumberof m k= m k steps.forthelaststep,thereareonlytwounused pointers left. The probability to pick one of them as first pointeris m,andtheprobabilitytopicktheotherunused pointerassecondpointeris m.henceweneedanother m steps in expectation to complete the cycle. In summary, RLS needs an expected number of steps. m m k= k = m H m Θ(m log m) IV. THE(+)-EA The perhaps simplest eolutionary algorithm is the ( + )- EA. In contrast to RLS, it allows for more than one - operation in each mutation step. The classical ( + )-EA

5 on bit-strings of length n independently flips each bit with probability /n. When using more complex representations, for example permutations[0], this behaior must be simulated.todothis,anumber sischosenatrandomaccording toapoissondistribution Pois(λ = )withparameter λ =. Then the mutation step of RLS, namely choosing two pointers uniformly at random and applying the -operation, is done s+timesinsteadofjustonce.thereasonwhy s+insteadof s mutations are performed is to preent steps in which nothing happens.figure5showsthepseudo-codeofthe ( + )-EA. A.AnUpperBoundontheOptimizationTimeofthe ( + )- EA Wenowshowthatthe (+)-EAisatleastasfastasRLS. Todothis,wesimplyanalyzethetimeittakesto simulate RLS,i.e.,weignoreallmutationsthatdomorethanone - operation. Theorem6:The (+)-EAwillproduceanEuleriancycle afteranexpectednumberofatmost O(m log m)steps. Proof: A mutation applying the -operator more than oncewillonlybeacceptedifitdoesnotworsenthefitness oftheindiidual.sincewearelookingforanupperbound on the expected optimization time, we can thus safely ignore all mutations that apply more than one -operation to the indiidual. If s = 0,thenthe -operatorwillbeappliedexactlyonce. 0 Thisoccurswithaconstantprobability,namely e 0! = e by definition of the Poisson distribution(cf.[9]). Hence, in expectation each eth step exactly one mutation is performed. With this the proof of Theorem 4 can be applied. It follows that the expectedoptimizationtime is at most e O(m log m) = O(m log m). B.ALowerBoundontheOptimizationTimeofthe (+)-EA While Theorem 6 shows that the expected optimization time ofthe (+)-EAisnotworsethanthatofRLS,wewillnow showthatonthegraph C m itindeedneedsanexpectednumber of Ω(m log m)steps. Theorem7:Theexpectedoptimizationtimeofthe (+)- EAon C m is Θ(m log m). Proof: This proof loosely follows a proof of Droste, Jansen and Wegener [4]. They show that the ( + )-EA needs an expected optimization time of Ω(n log n) to optimize any linear function with non-negatieweights on {0, } n. Some arguments are similar to the coupon collector s problem (cf. Motwani and Raghaan[9]). Let T denote the random ariable describing the number of stepsneededbythe (+)-EA.Theexpectedalueof Tcan thenbeboundedby E(T) = ip(t = i) tp(t t) i= forafixed t.theprobability P(T t)thatthe (+)-EA needsatleasttsteps,howeeristhesameastheprobability ThePoissondistributionwith λ = isusedbecauseitisthelimitofthe Binomialdistributionfor ntrialswithprobability n each. thatthe ( + )-EAwillnotfinishafter t steps.henceif wecanboundthisprobabilitybysomealue pfrombelowfor agien t,wegetalowerboundontheexpectedoptimization time. Togetthisbound,firstconsideraertex of C m andthe twoedges e, f containing. Thenthepointers e and f haetobechosenatleastonceforaparticular -operationto construct an Eulerian cycle. The probability that exactly this mutation happens is m m = m. The probability that during a single step exactly s + -operationsareperformedis s es! by the definition of the Poisson distribution(cf. [9]). Since each of the s + - operations are done independently, the probability that a fixed s+ -operationisperformedinacertainstepisatmost m. Hence the probability that a fixed -operation is performed in onemutationisatmost s=0 e s! s + m m since s=0 s+ s! = e. The probability that a fixed combination was not chosen at allduring t stepsisthenatleast ( m ) t.butthen the probability that the combination is chosen at least once inthe t stepsconsideredisatmost ( m ) t. Since we hae m different combinations, the probability that allcombinationsareconsideredisatmost ( ( m ) t ) m. Hence, the probability that at least one of the combinations isneerchosenduringthe t stepsconsideredisatleast ( ( m ) t ) m.wenowchoose t := +(m )logm to obtain ( ( m ) ) (m m )log m e. Hence,forthisalueof twehae p e. Thus the expected number of steps needed is bounded from below by ( e ) ( + (m )log m) = Ω(m log m). V. CONCLUSIONS We hae gien a new edge-based representation for graphs together with a canonical mutation operator. To show the benefits of this representation we hae rigorously analyzed a ariantof RLS andasimpleea forthe Euleriancycle problem. Our representation yields much faster randomized search heuristics than preiously studied representations for this problem(cf. [3], [0]).We expect this type of graph representation to be useful for other problems as well. REFERENCES [] T. Bäck, D. Fogel, and Z. Michalewicz, Eds., Handbook of Eolutionary Computation. Oxford Uniersity Press, New York, and Institute of Physics Publishing, Bristol, 997. [] N. Christofides, Worst-case analysis of a new heuristic for the traelling salesman problem, in Algorithms and complexity: New directions and recent results, J. Traub, Ed. Academic Press, Inc., 976, p. 44.

6 [3] B. Doerr, N. Hebbinghaus, and F. Neumann, Speeding up eolutionary algorithms through restricted mutation operators, in Proceedings of the 9th International Conference on Parallel Problem Soling From Nature (PPSN), ser. Lecture Notes in Computer Science, ol Springer, 006, pp [4] S.Droste,T.Jansen,andI.Wegener, Ontheanalysisofthe(+) eolutionary algorithm, Theoretical Computer Science, ol. 76, pp. 5 8, 00. [5] J.EdmondsandE.L.Johnson, Matching,eulertoursandthechinese postman, Mathematical Programming, ol. 5, pp. 88 4, 973. [6] L. Euler, Solutio problematis ad geometriam situs pertinentis, Commentarii academiae scientiarum Petropolitanae, ol. 8, pp. 8 40, 74. [7] C. Hierholzer, Ueber die Möglichkeit, einen Linenzug ohne Wiederholung und ohne Unterbrechung zu umfahren, Mathematische Annalen, ol.6,pp.30 3,873. [8] P.Larrañaga,C.M.H.Kuijpers,R.H.Murga,I.Inza,andS.Dizdareic, Genetic algorithms for the traelling salesman problem: A reiew of representations and operators, Artificial Intelligence Reiew, ol. 3, pp. 9 70, 999. [9] R. Motwani and P. Raghaan, Randomized Algorithms. Cambridge Uniersity Press, 995. [0] F. Neumann, Expected runtimes of eolutionary algorithms for the Eulerian cycle problem, in Proceedings of the 004 IEEE Congress on Eolutionary Computation(CEC). IEEE Press, 004, pp [] F. Neumann and I. Wegener, Randomized local search, eolutionary algorithms, and the minimum spanning tree problem, in Proceedings of the Genetic and Eolutionary Computation Conference (GECCO), ser. Lecture Notes in Computer Science, ol. 30. Springer, 004, pp [] G. R. Raidl and B. A. Julstrom, Edge sets: an effectie eolutionary coding of spanning trees. IEEE Trans. Eolutionary Computation, ol. 7, pp. 5 39, 003. [3] C. Witt, Worst-case and aerage-case approximations by simple randomized search heuristics, in Proceedings of the nd Annual Symposium on Theoretical Aspects of Computer Science(STACS), ser. Lecture Notes in Computer Science, ol Springer, 005, pp