Watchmaker Framework The Watchmaker Framework for Evolutionary Computation is an extensible, high-performance, object-oriented framework for implementing platform-independent evolutionary algorithms in Java. It is freely available under a permissive Open Source licence. It can be downloaded from http://watchmaker.uncommons.org. This chapter introduces the core components of the Watchmaker Framework and shows how they can be used to implement simple evolutionary algorithms such as the "Hello World" example outlined in the previous chapter.

GenerationalEvolutionEngine EvolutionEngine The central object of an evolutionary program built with the Watchmaker Framework is the evolution engine. The framework provides multiple implementations of the EvolutionEngine interface, but the one that you will usually want to use is GenerationalEvolutionEngine. This is a general-purpose implementation of the evolutionary algorithm outline from chapter 1. An EvolutionEngine has a single generic type parameter that indicates the type of object that it can evolve. For the "Hello World" program we need to be able to evolve Java strings. Code that creates an engine that can evolve strings would look something like this: engine = new GenerationalEvolutionEngine(candidateFactory, evolutionaryOperator, fitnessEvaluator, selectionStrategy, rng);]]> Once you have created an EvolutionEngine, your program is as simple as calling the evolve method with appropriate arguments. However, as you can see from the code snippet above, there is a little bit of work to be done first in order to create an EvolutionEngine that is configured appropriately for the given problem. The constructor of the GenerationalEvolutionEngine class requires five objects. These are: A Candidate Factory An Evolutionary Operator A Fitness Evaluator A Selection Strategy A Random Number Generator

CandidateFactory The first object that needs to be plugged into the evolution engine is a candidate factory. Every evolutionary simulation must start with an initial population of candidate solutions and the CandidateFactory interface is the mechanism by which the evolution engine creates this population. A candidate factory implementation has an associated type. It can only create objects of that type. The type must match the type of the evolution engine that it is plugged into. You can write your own implementation of CandidateFactory for your program or, if you are using a common type such as strings, lists or arrays, you may be able to use a ready-made factory from the org.uncommons.watchmaker.framework.factories package. StringFactory For our "Hello World" program, we can use the provided StringFactory: factory = new StringFactory(chars, 11);]]> AbstractCandidateFactory When writing your own CandidateFactory implementations, it is easiest to extend the provided AbstractCandidateFactory base class since there is then only a single method that must be implemented.

EvolutionaryOperator Evolutionary operators are the components that perform the actual evolution of a population. Cross-over is an evolutionary operator, as is mutation. In the Watchmaker Framework, evolutionary operators are defined in terms of the EvolutionaryOperator interface. This interface declares a single method that takes a list of selected individuals and returns a list of evolved individuals. Some operators (i.e. mutation) will process one individual at a time, whereas others will process individuals in groups (cross-over processes two individuals at a time). StringCrossover StringMutation As with candidate factories, evolutionary operators have associated types that must be compatible with the type of the evolution engine that they are used with. And, as with candidate factories, the framework provides several ready-made operators for common types. These can be found in the org.uncommons.watchmaker.framework.operators package. The cross-over and mutation operators that we need for our "Hello World" program are provided by the StringCrossover and StringMutation classes.

EvolutionPipeline Alert readers will have noticed that the evolution engine constructor only accepts a single evolutionary operator. So how can we use both cross-over and mutation? The answer is provided by the EvolutionPipeline operator. This is a compound evolutionary operator that chains together multiple operators of the same type. > operators = new LinkedList>(); operators.add(new StringCrossover()); operators.add(new StringMutation(chars, new Probability(0.02))); EvolutionaryOperator pipeline = new EvolutionPipeline(operators);]]> The evolution pipeline is just one of many useful operators included in the org.uncommons.watchmaker.framework.operators package. Elaborate evolution schemes can be constructed from combinations of these operators. Users of the Watchmaker Framework should take a few minutes to browse the API documentation and familiarise themselves with the available classes.

FitnessEvaluator So far we've been able to build our evolutionary program by simply combining instances of classes provided by the framework. There is one part of the program that we will always have to write for ourselves though and that is the fitness function, which is necessarily different for every program. In the Watchmaker Framework, a fitness function is written by implementing the FitnessEvaluator interface. The getFitness method of this interface takes a candidate solution and returns its fitness score as a Java double. The method actually takes two arguments, but we can ignore the second for now. The listing below is a fitness evaluator for the "Hello World" program. It simply assigns one point for each character in the candidate string that matches the corresponding position in the target string. { private final String targetString = "HELLO WORLD"; /** * Assigns one "fitness point" for every character in the * candidate String that matches the corresponding position in * the target string. */ public double getFitness(String candidate, List population) { int matches = 0; for (int i = 0; i < candidate.length(); i++) { if (candidate.charAt(i) == targetString.charAt(i)) { ++matches; } } return matches; } public boolean isNatural() { return true; } }]]> fitness functionnatural natural fitness By some fitness measures, a higher value indicates a fitter solution. In other cases a lower value is better. The isNatural method of a fitness evaluator simply specifies which scenario applies. In Watchmaker Framework terminology, a natural fitness function is one that returns higher values for fitter individuals.

selection SelectionStrategy Selection is a key ingredient in any evolutionary algorithm. It's what determines which individuals survive to reproduce and which are discarded. All we've said about selection so far is that it should favour fitter individuals. This definition permits several different implementations. The Watchmaker Framework includes all of the most common selection strategies in the org.uncommons.watchmaker.framework.selection package. These are sufficient for most evolutionary algorithms but, if necessary, it is straightforward to write your own implementation of the SelectionStrategy interface. RouletteWheelSelection Some selection strategies work better than others for certain problems. Often a little trial-and-error is required to pick the best option. We will delve into the details of various selection strategies in , but for now we will just create an instance of the RouletteWheelSelection class and use that for our "Hello World" application. fitness-proportionate selection roulette wheel selection selectionfitness-proportionate selectionroulette wheel Roulette wheel selection is the most common type of fitness-proportionate selection. It gives all individuals a chance of being selected but favours the fitter individuals since an individual's selection probability is derived from its fitness score.

random number generator Random RNG SecureRandom The final dependency that must be satisfied in order to create an evolution engine is the random number generator (RNG). An evolution engine has a single RNG that it passes to its candidate factory, evolutionary operator and selection strategy. An ideal RNG is both fast and statistically random. We could use the standard Java RNG, java.util.Random, but its output is not as random as it should be. The other RNG in the standard library, java.security.SecureRandom is much better in this respect but can be slow. MersenneTwisterRNG Fortunately, the Watchmaker Framework provides alternatives. The org.uncommons.maths.random.MersenneTwisterRNG random number generator is both fast and statistically sound. It is usually the best choice when creating an evolution engine.

We've now got all of the necessary pieces to complete the "Hello World" example application. Assuming that you've already created the StringEvaluator class (defined above) in a separate file, the code needed to create the evolution engine looks like this: factory = new StringFactory(chars, 11); // Create a pipeline that applies cross-over then mutation. List> operators = new LinkedList>(); operators.add(new StringCrossover()) operators.add(new StringMutation(chars, new Probability(0.02))); EvolutionaryOperator pipeline = new EvolutionPipeline(operators); FitnessEvaluator fitnessEvaluator = new StringEvaluator(); SelectionStrategy