I covered the basics of genetic algorithms in my post on genetic programming, but I didn’t go into detail about how the algorithm is implemented. It’s quite a simple and elegant algorithm, so I thought it would be fun to explain and demonstrate every step in detail.
The simple genetic algorithm is actually very easy to implement—in a sufficiently expressive language like Scheme it can easily fit in around a hundred lines—so I wrote up a straightforward implementation of the SGA algorithm in Scheme to help me explain it here in this blog post. All of this code has been tested in Racket, and you should be able to copy it into DrRacket and run it if you want to. To see an example of a more sophisticated genetic algorithm library running in Racket, my racket-ga library follows the same basic principles seen in this blog article, but it extends it (for example, it uses vectors rather than lists, and it spawns multiple Racket processes which split up the work across multiple CPUs).
High-Level Overview
Genetic algorithms start with randomly generated data. In a loop, each iteration of which acts like a generation, this data metaphorically reproduces and mutates as part of a process inspired by natural selection. Each individual piece of data is evaluated to determine how “fit” it is (how close it is to a correct answer, or how useful it is as a candidate solution), and data that is more fit is more likely to pass on some of its material to the next generation. Eventually, this process will produce more and more fit pieces of data. Additionally, the possibility of mutation allows for the algorithm to (attempt to) avoid falling into local optima, which occur when there seems to be no immediate improvement but there are other possible better answers.
There are many problem domains to which genetic algorithms are applicable: optimization, scheduling, and even generating art or music. While it is possible to successfully apply it to many problems, it’s generally not the fastest way to solve those problems. A famous joke about genetic algorithms goes as follows: of all the processes in nature computer scientists would want to emulate, why would they pick one that takes millions of years to do anything useful? Putting that aside, the fact that genetic algorithms can be successful in so many different situations (plus they’re pretty neat) make them a topic worthy of interest.
Basic Data Structures
In genetic algorithms, there’s generally a population full of pieces of data. The pieces of data tend to be a string of some kind, often a binary string. Initially, the program will fill the population with randomly generated strings. It builds strings by randomly selecting elements from an alphabet set; for example, a program that evolves binary strings would have an alphabet of 0 and 1.
(define (generate-strings domain size num)
(map (lambda (x)
(map (lambda (x)
(car (shuffle domain))) (range size)))
(range num)))To invoke generate-strings and generate some random binary strings, our domain (alphabet) needs to be a list containing 0 and 1. The size is how large the strings should be, and the num is the number of strings to generate. There’s no law that we have to use an alphabet of 0 and 1, so we should design our code to allow for more general use. Of all the possible types of strings, however, I want to primarily focus on binary strings, so here’s a helper function to convert binary strings (which, in our program, are lists of 0’s and 1’s) into numbers:
(define (binary-to-num lst)
(let loop ((i 0) (sum 0) (lst (reverse lst)))
(cond [(null? lst) sum]
[(zero? (car lst)) (loop (+ i 1) sum (cdr lst))]
[else (loop (+ i 1) (+ sum (expt 2 i)) (cdr lst))])))
Crossover
When the individuals in our population go to reproduce, they are ranked from best to worst according to a fitness function.
(define (rank-pop pop func) (map (lambda (str) (cons (func str) (list str))) pop))
This returns a list of lists, of the form (fitness string). The pop parameter is the population, and the func parameter is the fitness function, which will presumably return a number rating for the string. At this point in the program we don’t really have to decide the characteristics of the fitness function exactly, but I’ll just ruin the suspense and tell you I will have it return small numbers for good solutions and big numbers for bad solutions. In other words, the program is going to attempt to minimize the number returned from the fitness evaluation function.
(define (rank-compare a b) (< (car a) (car b))) (define (get-best ranked-pop) (argmin car ranked-pop))
These are functions we will use later to handle the (fitness string) lists. The first one compares the score of two individuals, while the second one finds the individual with the lowest score.
(define (crossover a b)
(let* [(size (max (length a) (length b)))
(point (random size))]
(append (take a point)
(take (reverse b) (- size point)))))This function is the heart of the crossover phase, as you might expect from the name. Crossover of two strings involves combining their data in some way to produce a new string. There are lots of ways to do this, but the simplest is to break each string in two and concatenate together a chunk from each to produce a new string. To do this, the function chooses a crossover point randomly, and returns a new string consisting of elements from string a before this point and elements from string b after the point. Now we need a way of selecting fit strings and using crossover to generate the next generation.
(define (select-two ranked-pop size)
(take (sort (take (shuffle ranked-pop) size) rank-compare) 2))
(define (tournament-selection ranked-pop size)
(map (lambda (e)
(apply crossover
(map cadr (select-two ranked-pop size))))
(range (length ranked-pop))))Here the code is doing something called tournament selection. It goes like this: you randomly pick a few individuals, then you pick the best two out of that random selection to cross over. This is better than just picking the best two individuals every time, because then we’d be stuck with strings that don’t change very much and might not ever generate the best answer (more on that in the mutation section). In the tournament-selection function, the ranked-pop parameter is the list of (fitness string) lists, and the size parameter is the size of the tournament. If size is five, for example, the program would randomly pick five strings from the population and choose the best two of those five for crossover.
Tournament selection is not the only way to do selection, but I like it because it’s effective and simple. Another famous selection method is called fitness proportionate selection, which involves using the fitness scores of individuals to determine selection probability.
Mutation
We need to balance the random parts of the process with the directed parts; these two aspects of algorithms like this are sometimes called exploration and exploitation, respectively. If we only do crossover over and over again, we are in danger of ending up in a local optima. We can reach a situation where none of the possible combinations of our strings improve on our current best, but there are still better strings as yet undiscovered. To balance out this directed (exploitation) aspect, we need to bring in more chaos (exploration). Mutation adds another element of randomness to the process, which could help kick us out of a local optima.
(define (mutate-string str domain rate)
(let [(len (length domain))]
(map (lambda (e)
(if (< (random) rate)
(list-ref domain (random len)) e)) str)))
(define (mutation pop domain rate)
(map (lambda (str) (mutate-string str domain rate)) pop))This is a very simple form of mutation. Iterate over the elements in a string, and for each element generate a random number. If the random number is in a certain range, replace that element with another element randomly selected from the domain. To increase the amount of mutation (leading to more exploration), we can tweak the range that the random number must be in. This is done by specifying a number between 0 and 1. If the random number generated during the mutation loop is below the number we specify, mutation happens on that element. So, specifying a very low number (close to 0) would lead to more exploitation and less exploration, because mutation would be less likely to happen. Similarly, specifying a high number (close to 1) would lead to more exploration and less exploitation, because mutation would be more likely to happen. Setting the number way too high would obviously be bad, because it would end up just churning out random strings, but, as mentioned before, a mutation rate that is too low can also sometimes cause problems. I usually like to experiment with a bunch of different rates to see which number works best for a given problem.
Islands
All of the above functions operate on a single population. It’s often a good idea, however, to have multiple different populations evolving independently. Imagine these different populations as islands. Every once in a while, a bunch of data from one island gets on a boat and sails to another island. This way, we get the benefit of having independent populations (the chances of multiple populations getting stuck in the same place is low), but they can also share some data and benefit from collaboration. The “world” is the set of all islands. To generate a world, we just need to generate a bunch of populations and put them in a list.
(define (build-world domain string-size pop-size islands)
(map (lambda (e)
(generate-strings domain string-size pop-size))
(range islands)))
Inner Loop
As short as it is, the code above covers quite a bit of the SGA algorithm, but we still have a ways to go. The inner loop is actually going to be a tail-recursive function that calls the functions above in order to process “generations.”
(define (run-island n pop func domain mutation-rate
tournament-size best)
(if (zero? n) (list pop best)
(let* [(elite-pop (if (null? best) pop
(cons (cadr best) (cdr pop))))
(ranked-pop (rank-pop elite-pop func))
(selected-pop (tournament-selection
ranked-pop tournament-size))
(mutated-pop (mutation selected-pop
domain mutation-rate))
(best (get-best ranked-pop))]
(run-island (- n 1) mutated-pop func domain
mutation-rate tournament-size best))))The parameters for this function should be obvious. n is the number of generations to run, pop is the initial population, func is the evaluation function, mutation-rate is the probability of mutation, tournament-size is the size of the tournament, and best is the best individual so far (which can be null).
One new concept was introduced here: elitism. We want to make sure we hold on to the best solution we’ve seen so far, so we pass along the best seen solution as a parameter to the tail-recursive function and always cons it onto the population at the start of the function.
For the rest of the function, we call the functions defined above. First, rank-pop produces the list of solutions with scores, then tournament-selection produces the new strings resulting from crossover, then mutation mutates these strings, and we find the best string and do the recursive call.
As you might be able to guess from the function name, this function only handles a single island. To process all the islands, we need another function.
(define (run-world n1 n2 world func domain mutation-rate
tournament-size best logger)
(define (inner-world pop)
(run-island n2 pop func domain mutation-rate tournament-size best))
(if (zero? n1) (list world best)
(let* [(world (map inner-world world))
(best (cadr (argmin caadr world)))]
(logger world)
(run-world (- n1 1) n2 (map car world)
func domain mutation-rate
tournament-size best logger))))This function looks scary but it’s pretty straightforward. There’s an internal function definition, but it’s just to call run-island with the closed-over parameters of run-world. And that’s basically all run-world does—it calls run-island for each island, calls the logger, and recurses. There’s a little bit of list work done to extract the best solution found so far and pass it as a parameter when recursing.
Running it
Now all that is out of the way, we’re close to actually being able to run it.
I’ll test it by defining functions that use the SGA to find the minimum of the sinbowl function:
(define (sinbowl value) (- (* (abs value) 0.1) (sin value))) (define (eval-sinbowl str) (sinbowl (scale-num (binary-to-num str) 0 1023 -60 120))) (define (scale-num x min max a b) (+ (/ (* (- b a) (- x min)) (- max min)) a)) (define (log-sinbowl world) (display (cadr (argmin caadr world))) (newline)) (define (test-sinbowl n) (run-world n 1 (build-world '(1 0) 10 3 2) eval-sinbowl '(1 0) 0.3 3 '() log-sinbowl))
This should all be self-explanatory now. The sinbowl function is the actual function we’re optimizing. eval-sinbowl takes a binary string (actually a list), converts it to a number and passes it to sinbowl. There’s also a function to print intermediary results to the screen, and a function to launch everything.
You should be able to paste all the above code into Racket and run test-sinbowl to run the algorithm.
; result of test-sinbowl
(-0.7646825274674613 (0 1 0 1 0 1 1 0 1 1))
(-0.8198790260396563 (0 1 0 1 0 1 1 1 0 0))
(-0.8198790260396563 (0 1 0 1 0 1 1 1 0 0))
(-0.8198790260396563 (0 1 0 1 0 1 1 1 0 0))
(-0.8415605479393091 (0 1 0 1 0 1 1 1 1 0))
(-0.8415605479393091 (0 1 0 1 0 1 1 1 1 0))
(-0.8415605479393091 (0 1 0 1 0 1 1 1 1 0))
(-0.8459545468102923 (0 1 0 1 0 1 1 1 0 1))
(-0.8459545468102923 (0 1 0 1 0 1 1 1 0 1))
(-0.8459545468102923 (0 1 0 1 0 1 1 1 0 1))
'((((1 0 1 1 1 1 1 0 1 0)
(0 1 0 0 1 1 1 1 0 1)
(1 1 1 1 0 1 1 0 1 1))
((0 1 0 1 1 1 0 0 0 1)
(0 1 1 0 1 0 0 1 0 1)
(0 1 0 1 0 1 1 1 0 1)))
(-0.8459545468102923 (0 1 0 1 0 1 1 1 0 1)))That’s all I have for today.