Dynamic Demes parallel genetic algorithm

Dynamic Demes is a new method for the parallelisation of evolutionary algorithms. It was derived as a combination of two other parallelisation algorithms: the master-slave distributed fitness evaluation model and the static subpopulation model. In this paper we present the algorithm, perform a theoretical analysis of its performance and present experimental results where we compared Dynamic Demes with other algorithms. I. PARALLEL GENETIC ALGORITHMS Sequential GAs have been shown to be very successful in many applications and in very different domains. However, there exist some problems in their utilisation which can all be addressed with some form of Parallel GA (PGA): For some kind of problems, the population needs to be very large and the memory required to store each individual may be considerable (for example in genetic programming [1]). In some cases this makes it impossible to run an application efficiently using a single machine, so some parallel form of GA is necessary. Fitness evaluation is usually very time-consuming. In the literature computation times of more than 1 CPU year have been reported for a single run in complex domains (e.g. see [2]). It stands to reason that the only practical way of provide this CPU power is the use of parallel processing. Sequential GAs may get trapped in a sub-optimal region of the search space thus becoming unable to find better quality solutions. PGAs can search different subspaces of the search space in parallel, thus making it less likely to become trapped by low-quality subspaces. For the first two reasons PGAs are studied and used for applications on massively parallel machines [3], transputers [4], and also on distributed systems [5]. However, the most important advantage of PGAs is that in many cases they provide better solutions than single population-based algorithms, even when the parallelism is simulated on conventional machines. The reason is that multiple populations allow speciation, a process by which different populations evolve in different directions (i.e. toward different optima) [6]. For this reason Parallel GAs are not only an extension of the traditional GA sequential model, but they represent a new class of algorithms in that they search the space of solutions differently. The way in which GAs can be parallelised depends on the following elements: How fitness is evaluated and mutation is applied If single or multiple subpopulations (demes) are used If multiple populations are used, how individuals are exchanged How selection is applied (globally or locally) Depending on how each of these elements is implemented, several different methods of parallelising GAs can be obtained. These can be classified into eight classes: 1. Master-Slave parallelisation (also known as distributed fitness evaluation) 2. Static subpopulations with migration 3. Static overlapping subpopulations (without migration) 4. Massively parallel genetic algorithms 5. Dynamic demes (dynamic overlapping subpopulations) 6. Parallel steady-state genetic algorithms 7. Parallel messy genetic algorithms 8. Hybrid methods (e.g. static subpopulations with migration, with distributed fitness evaluation within each subpopulation) In the following subsections we provide a short description of two parallelisation methods on which dynamic demes is based and to which it will be compared later on in the paper. A. Master-Slave parallelisation In this parallelisation method, also known as distributed fitness evaluation, the algorithm uses a single population and the evaluation of the individuals and/or the application of genetic operators are performed in parallel. Selection and mating are done globally, hence each individual may compete and mate with all the others. The operation that is most commonly parallelised is the evaluation of the fitness function. This is usually implemented by master-slave programs, where the master stores the population and the slaves evaluate the fitness, apply mutation, and sometimes exchange bits of the genome (as part of crossover). The algorithm is said to be synchronous, if the master stops and waits to receive the fitness values for all the population before proceeding with the next generation. A synchronous master-slave GA has exactly the same properties as a simple GA, except its speed, i.e. this form of parallel GA carries out exactly the same search as a simple GA. An asynchronous version of the master-slave GA is also possible. In this case the algorithm does not stop to wait for any slow processors. For this reason the asynchronous master-slave PGA does not work exactly like a simple GA, but is more similar to parallel steadystate GAs. The difference lies only in the selection operator. DYNAMIC DEMES PARALLEL GENETIC ALGORITHM 2 In an asynchronous master-slave algorithm selection waits until a fraction of the population has been processed, while in a steady-state GA selection does not wait, but operates on the existing population. B. Static Subpopulations With Migration The important characteristics of the class of static subpopulations with migration parallel algorithms are the use of multiple demes and the presence of a migration operator. Multipledeme GAs are one of the most popular parallelisation methods, and many papers have been written describing details of their implementation [7]. This parallelisation method requires the division of a population into some number of demes (subpopulations). Demes are separated from one another (geographic isolation), and individuals compete only within a deme. An additional operator called migration is introduced: from time to time, some individuals are moved (copied) from one deme to another. II. DYNAMIC DEMES MODEL The idea of parallelising GAs using dynamic demes (DDs) was first proposed in preliminary form in [8], and then developed and briefly evaluated in [9]. The main advantages of dynamic demes are: High scalability and flexibility (DDs can be used to implement a broad range of algorithms from coarse grained to highly fine grained models) Fault tolerance (some of the processors can crash, but the algorithm will correctly continue) Dynamic load balancing Easy monitoring DDs are implemented in an object oriented library called MPGA developed in C++ with PVM. The library also contains other parallel GA models. The library is publicly available from http://studentweb.cs.bham.ac.uk/ ̃mxn/ cirrus. The DD algorithm is relatively simple. The population is divided into subpopulations (demes). Selection and mating are applied to the demes similarly to other parallelisation methods for GAs. However, in DDs the subpopulations are created dynamically after each processing cycle, and so the demes are not fixed. A more detailed description of the algorithm will be given in the following sections. A. Features Both the master-slave parallel GA and the static subpopulation GA suffer from some problems. DDs overcome these problems by combining the best features of these methods. DDs is a combination of global parallelism (the algorithm can work as a simple master-slave distributed GA) with a coarsegrained GA (overlapping subpopulations model). In DDs the population is treated as a collection of separated demes. There is no migration operator as such, but individuals are exchanged via a dynamic reorganisation of the demes at each processing cycle. The main reason for reorganising the demes is to cut down the waiting time for the last (slowest) individuals in the master-slave model. This happens because new demes are created and executed as soon as enough individuals have been evaluated. From the parallel processing point of view the dynamic demes approach fits perfectly into the MIMD category (Flyn classification) as an asynchronous multiple master-slave algorithm. The algorithm is fully scalable. Starting from global parallelism with fitness-processing distribution, one can scale up the algorithm up to a fine grained version, with a few individuals within each deme and a large number of demes i.e. thanks to its scalability it can be run efficiently in systems with several Processing Elements (PEs) as well as in massively parallel systems with large number of PEs. The algorithm can be run on sharedand distributed-memory parallel machines. B. Algorithm Description Each individual is represented by a separate process (which we call a slave), which is capable of performing the following: 1. Fitness evaluation 2. Applying mutation to itself (with a predefined mutation rate) 3. Doing crossover with another individual (this is done by passing to each individual the process ID of another individual with which it should perform crossover) All the individuals run concurrently. The ideal case is when a single processing element processes a single individual. When this is not the case parallelism is simulated by the operating system or, like in our case, by a parallel virtual machine (thanks to the PVM library). There are additional processes, called masters, which are responsible for selection and mating. Masters handle a fixed fraction of the population and apply selection and mating on it. Therefore, each master represents a separate deme. However, unlike other PGAs, as explained below, in DDs the individuals belonging to each deme change dynamically. The number of masters is a parameter of the algorithm. If there is only one master DDs is actually a classic distributed fitness evaluation algorithm. Each master process performs selection and mating concurrently with the other master. Mating requires sending the appropriate slave ID to the individuals chosen for crossing over. When the slaves receive a partner ID they perform crossover, and then proceed with fitness evaluation and mutation. In addition to masters and slaves there is also a process (possibly more) responsible for load balancing, called counter. After crossover, fitness evaluation and mutation each individual is dynamically assigned to a deme (possibly different from the one it belonged to previously). This happens when the individual notifies the counter process. The counter process knows which master processes are currently idle waiting for their subpopulation to be filled and it sends to the individual the process ID of one such master. The last process within the system is called sorter. This process is informed by all of the individuals finishing their evaluation, takes their genotype and fitness, and saves them in DYNAMIC DEMES PARALLEL GENETIC ALGORITHM 3 appropriate log files. The sorter process is also responsible for stopping the search when a termination criterion is met (e.g. when a solution of sufficient quality is found or when a fixed number of individuals has been processed). Because the algorithm was developed in a heterogeneous multiuser environment,1 normally there was no need for introducing a strategy to pass information between demes (like for example the idea of having partially overlapping demes). The differences in speed of the processing elements was enough for disturbing the regularities in the processing cycles, thus allowing the mixing of the individuals in different demes. Usually in our experiments with heterogeneous environments the algorithm was configured so that each master was in charge of a fraction of the population including