Introduction to Evolutionary Computation

1
Introduction to Evolutionary Computation
Eastern Michigan University

• Matthew Evett

2
Evolutionary Computation is.

• Umbrella term for machine learning techniques
  that are modeled on the processes of
  neo-Darwinian evolution.
• Genetic algorithms, genetic programming,
  artificial life, evolutionary programming
• Survival of the fittest, evolutionary pressure
• Techniques for automatically finding solutions,
  or near solutions, to very difficult problems.

3
Why is EC Cool?

• EC techniques have found solutions better than
  any previously known for many domains
• Electronic circuit design, scheduling,
  pharmaceutical design
• Autonomous solution discovery is fun
• Look Ma! No hands!

4
Darwinian Evolution

• Works on population scale, not individual
• Chance plays a part
• Variation affects viability
• Fittest dont always survive!
• Heredity of traits
• Finite resources to yield competition

5
EC is not...

• Real evolution, or real genetics
• It is modeled on natural genetic systems only in
  a simple sense.
• Term genetic is really used to mean heredity
• Real genetics is much more complicated

6
Overview of the Talk

• Well look at two related techniques...
• genetic algorithms
• genetic programming
• Well look at some demos of evolutionary systems.

7
History of EC

• Friedbergs induced compilers (1958)
• Evolutionary Programming (1965)
• Fogel, Owens Walsh
• Evolutionary Strategies (Recehenberg 72)
• Genetic Algorithms (Holland 75)
• Genetic Programming
• Tree-based GA (Cramer 85, Koza 89)
• True GP (Koza 92)

8
Basic evolutionary algorithm

• Population of individuals, each representing a
  potential solution to the problem in question.

9
Genetic Algorithms (GA)

• Population individuals are (fixed-length) binary
  strings (genome)
• Start with a population of random strings.
• Measure fitness of individuals.
• Each generation forms a new population from old
  via recombination and mutation.
• Solutions improve over generations.

10
Three steps to setting up a GA

• 1) Devise a binary encoding representing the
  potential solutions to a problem.
• 2) Define a fitness function.
• Objective measure of quality of individual
• 3) Set control parameters.
• population size
• maximum number of generations
• probability of mutation and crossover, etc.

11
Example Designing a Truss

• 10 members
• 16 diameters avail.
• Different costs
• Different strengths
• Find cheapest that is strong enough
• 40-bit genome
• Each 4 bit sequence reps. diam. of 1 member

12
Running a GA

• Generate an initial population of random binary
  strings
• Calculate fitness of each individual
• Fitness is cost of design, penalty for fails
• Create next generation
• Select on the basis of fitness
• Recombination/mating
• Select some elements for mutation.
• Typically one or two random bits will be flipped
  

13
Crossover in GA

• Single-point crossover
• There are many other forms
• Randomly select crossover point
• Swap crossover fragments
• Offspring will have a combination of randomly
  selected parts of both parents

Parents
Children
14
Running a GA (continued)

• Repeatedly create new generations
• Calculate fitness
• Terminate when an acceptable solution is been
  found or when the specified maximum number of
  generations is reached.

15
Running a GA/GP

• Major phases of evolutionary algorithms

16
Results of Truss Example

• Optimal solution is known, but rare
• Number of possible designs is 240
• Typical run
• 200 individuals/pop. 40 generations
• Yields answer within 1 of optimal
• but examines only 8000 individuals! (.0000007
  of designs)

17
Genetic Programming (GP)

• GP is a domain-independent method for inducing
  programs by searching a space of S-expressions.
• GPs search technique is similar to GAs.
• The elements of a population are programs,
  encoded as s-expressions.
• The Lisp programming language is based on
  s-expressions.
• Original GP work was done in Lisp.

18
Genetic Programming Elements

• S-expressions
• Prefix notation
• Programs, encoded as trees, evaluated via
  post-order traversal
• Ex tree corresponding to the S-expression
• (sqrt ( / ( a b) 2.0 ) )

19
Representation of a Program

• S-expressions can be converted to C.

float treeFunc(float a) if ( a gt 10.0)
return 20.0 else return
a/2.0
Looping constructs and subroutine calls are also
possible.
20
Three steps to setting up a GP

• Define appropriate set of functions and
  terminals.
• Must have closure.
• Functions and Terminals must be sufficient.
• Define a fitness function.
• Set control parameters.
• GA population size,
• maximum size or depth of the individual trees
• size and the shape of the original trees, etc.

terminal set a, b, c, 0, 1, 2 function set
, -, , /, SQRT
21
Starting a GP

• Generate an initial population of random
  S-expression trees.
• Calculate fitness value for each individual
• Often over a set of test cases.

22
Running a GP

• Create the next generation (population)
• Select elements for reproduction
• Random, fitness-proportionate, tournament.
• Reproduce
• Direct reproduction (cloning)
• Mating
• Mating method differs from GAs.
• Mutation
• Also differs from GAs.

23
GP Crossover

• Randomly choose crossover points.
• Swap rooted subtrees.
• Closure property guarantees viability of
  offspring

24
Mutation with GP

• Elements that are selected for mutation will have
  some randomly selected node (and any subtree
  under it) replaced with a randomly generated
  subtree.
• Point mutation
• Tree growth (shown here)

25
Running a GP (continued)

• Repeatedly create new generations.
• Terminate when an acceptable solution is found or
  when a specified maximum number of generations is
  reached.
• The termination criteria is often based on a
  number of hits, where a hit is defined as the
  successful completion of some subgoal.

26
Example Santa Fe Trail

• Ant animats, acquiring food.
• Some gaps in trail
• 89 food pellets
• Evolve control strategy to consume all pellets
• In acceptable time

27
Representing Ants
T ahead, left, right F if-food-ahead,
progn2, progn3

• Terminals are functions, whose evaluation
  causes ant to move.
• Fitness of pellets consumed in 400 terminal
  evaluations.
• Prevents infinite runs, and weak solutions.

(if-food-ahead (move) (progn2 (left) (move)))
28
Demo Santa Fe Ant

• During run, shows path of
• best-of-generation, best-of-run
• Chong, 1998

29
Santa Fe Ant Demo (done)

• http//studentweb.cs.bham.ac.uk/fsc/DGP.html
• The applet

30
GP Generated Military Tactics

• Squadron has a destination
• Ordered either to evade or attack
• Porto, Fogel Fogel, 1998
• Population of strategies

31
Generating tactics

• Every 20 seconds of real time, do GP run, 40
  generations.
• Predicts 20 mins ahead.
• Allows adaptation to changing situation.
• Here, order is changed from evade to attack.

32
Co-evolution

• Simulation uses GP-developed strategy for both
  squadrons.

33
Real-time success

• Platform Sparc 20
• Actual Pentagon military simulation.
• Blue squad fires on red.

34
Learning to Walk with GP

• Evolve control strategies for movement of
  arbitrarily articulated animats.
• Karl Sims, 1995
• Fitness is rate of travel
• physics model
• LOTS of CPU cycles!

35
GA-learned bipedal motion

• Individual strategies can be observed on the
  applet. (http//www.jsh.net/andy/gat/environ.html
  )
• User can view all trials, or just the
  best-of-generation.
• Constrained skeletons.
• Dick, 1998

36
Financial Symbolic Regression

• The goal is time series prediction, where the
  target points are a financial time series.
• In this case we are using a target time series
  derived from the daily closing prices of the SP
  500 from the years 1994 and 1995.
• Uses 33 independent variables taken from time
  series that that are derived from the SP 500
  itself and from the closing daily prices of 32
  Fidelity Select Mutual Funds.
• Evett Fernandez, 1996, 1997.

37
Solving Financial Problems

• The top line in the graph is the daily closing
  price of the SP 500. The solid line below it is
  the graph of the target time series after
  preprocessing.
• The dotted line is a function evolved using GP.
  It is included here only as an example to
  illustrate that criterion for success does not
  require a great deal of accuracy.

38
The Example Evolved Function

• y (((0.38)-((-0.20923)-(FSPTX-(((-0.79706)
  /(0.38))((FSUTX-FSCSX)(FSCGX-(-0.34247)))))))
  (SPX((0.82794)/(0.54431))))
• The independent variables that were used by this
  evolved function are derived from the following
  time series.
• FSPTX Fidelity select Technology Portfolio.
• FSUTX Fidelity Select Utility Portfolio
• FSCSX Fidelity Select Software Portfolio
• FSCGX Fidelity Select Capital Goods Portfolio
• SPX SP 500 Index

39
Conclusions

• Evolutionary algorithms are a powerful technique
  for problem solving in domains that
• are variable
• difficult, if not impossible to optimize
• GP is especially useful for problems for which
  the form of the solution is not known.
• Evolutionary techniques are becoming widespread.

40
Overview of the Software

• Object Oriented
• C.
• Windows 95 (MS Visual C 5.0)
• Ported to UNIX. (GNU C)
• Extended to run cooperatively on multiple
  machines using MPI.

41
Thank You! Are there any Questions?