charlie 0.5.0 → 0.6.0

data/lib/charlie/permutation/permutation.rb

@@ -22,7 +22,6 @@ end
 
 # Transposition mutator for PermutationGenotype
 module PermutationMutator
-
   # Transposes two elements
   def mutate!
     i1, i2 = @genes.rand_index,@genes.rand_index 
@@ -31,6 +30,24 @@ module PermutationMutator
   end
 end
 
+# Inversion mutator for PermutationGenotype. May work on other array/string-based genotypes as well, but this is untested.
+# Takes two random indices, and reverses the elements in between (includes possible wrapping if index2 < index1)
+module InversionMutator
+  # Inverts parts of the genes
+  def mutate!
+    i1, i2 = @genes.rand_index,@genes.rand_index 
+    if i2 >= i1
+      @genes[i1..i2] = @genes[i1..i2].reverse unless i1==i2
+    else
+      reversed = (@genes[i1..-1] + @genes[0..i2]).reverse
+      @genes[i1..-1] = reversed.slice!(0,@genes.size-i1)
+      @genes[0..i2] = reversed
+    end
+    self
+  end
+end
+
+
 # One point partial preservation crossover for PermutationGenotype
 # Child 1 is identical to parent 1 up to the cross point, and contains the remaining elements in the same order as parent 2.
 module PermutationCrossover
@@ -44,4 +61,38 @@ module PermutationCrossover
 end
 
 
+# Edge recombination operator (http://en.wikipedia.org/wiki/Edge_recombination_operator)
+# * Useful in permutations representing a path, e.g. travelling salesperson.
+# * Returns a single child.
+# * Permutations of 0...n only, i.e. default second parameter to PermutationGenotype
+# * Rather slow.
+module EdgeRecombinationCrossover
+  def cross(parent1,parent2)
+    p1, p2 = parent1.genes, parent2.genes
+   
+    nb = Array.new(parent1.size){[]}
+    (p1 + p1[0..1]).each_cons(3){|l,m,r| nb[m] += [l,r] } # build neighbour lists
+    (p2 + p2[0..1]).each_cons(3){|l,m,r| nb[m] += [l,r] } # build neighbour lists
+    nb.map(&:uniq!)
+
+    n = (rand < 0.5 ? p1.first : p2.first)
+    child = [n]
+    (nb.size-1).times{
+      nb.each{|l| l.delete n unless l==:done }  # remove n from the lists
+
+      if nb[n].empty?  # nb[n] empty, pick random next
+        nb[n] = :done
+        n = (0...nb.size).find_all{|x| nb[x] != :done }.at_rand # no neighbors left, pick random
+      else # pick neighbour with minimal degree, random tie-breaking
+        min_deg = nb[n].map{|x| nb[x].size }.min
+        next_n = nb[n].find_all{|x| nb[x].size == min_deg }.at_rand # pick random neighbor with min. degree
+        nb[n] = :done
+        n = next_n
+      end 
+      child << n  # add new n to path
+    }
+    
+    return from_genes(child)
+  end
+end
 

data/lib/charlie/population.rb

@@ -4,6 +4,8 @@
 # The population class represents an array of genotypes.
 # Create an instance of this, and call one of the evolve functions to run the genetic algorithm.
 class Population
+  DEFAULT_MAX_GENS = 100
+
   attr_reader :size, :population
   def initialize(genotype_class,population_size=20)
     @size = population_size
@@ -11,36 +13,66 @@ class Population
     @population = Array.new(population_size){ genotype_class.new } 
   end
 
-  # Runs the genetic algorithm with some stats on the console. Returns the population sorted by fitness.
-  def evolve_on_console(generations=100)
-    puts "Generation\tBest Fitness\t\tBest Individual"
-    generations.times{|g|
-      best = @population.max
-      puts "#{g}\t\t#{best.fitness}\t\t#{best.to_s}"
+  # yields population and generation number to block each generation, for a maximum of max_generations.
+  def evolve_block(max_generations=DEFAULT_MAX_GENS)
+    yield @population, 0
+    (max_generations || DEFAULT_MAX_GENS).times {|generation|
       @population = @genotype_class.next_generation(@population){|*parents|
         ch = [*@genotype_class.cross(*parents)]
         ch.each{|c| c.mutate! }
         ch
       }
+      yield @population, generation+1
+    }
+    @population
+  end
+
+  # Runs the genetic algorithm without any output. Returns the population sorted by fitness (unsorted for co-evolution).
+  def evolve_silent(generations=DEFAULT_MAX_GENS)
+    evolve_block(generations){}
+    @population.sort_by{|x|x.fitness} rescue @population
+  end
+ 
+  # Runs the genetic algorithm with some stats on the console. Returns the population sorted by fitness.
+  def evolve_on_console(generations=DEFAULT_MAX_GENS)
+    puts "Generation\tBest Fitness\t\tBest Individual"
+    evolve_block(generations) {|p,g|
+      best = p.max
+      puts "#{g}\t\t#{best.fitness}\t\t#{best.to_s}"
     }
     @population = @population.sort_by{|x|x.fitness}
     puts "Finished: Best fitness = #{@population[-1].fitness}"
     @population
   end
+  alias :evolve :evolve_on_console
 
-  # Runs the genetic algorithm without any output. Returns the population sorted by fitness (unsorted for co-evolution).
-  def evolve_silent(generations=100)
-    generations.times{|g|
-      @population = @genotype_class.next_generation(@population){|*parents|
-        ch = [*@genotype_class.cross(*parents)]
-        ch.each{|c| c.mutate! }
-        ch
-      }
+  # breaks if the block (which is passed the population each generation) returns true.
+  # returns an array [population, generations needed]. generations needed==nil for no convergence.
+  def evolve_until_population(generations=DEFAULT_MAX_GENS)
+    tot_gens = nil
+    evolve_block(generations) {|p,g|
+      if yield(p)
+        tot_gens = g
+        break
+      end
     }
-    @population.sort_by{|x|x.fitness} rescue @population
+    [@population, tot_gens]
   end
 
-  alias :evolve :evolve_on_console
+  # breaks if the block (which is passed the best individual each generation) returns true.
+  # returns an array [population, generations needed]. generations needed==nil for no convergence.
+  def evolve_until_best(generations=DEFAULT_MAX_GENS)
+    tot_gens = nil
+    evolve_block(generations)  {|p,g|
+      if yield(p.max)
+        tot_gens = g
+        break 
+      end
+    }
+    [@population, tot_gens]
+  end
+  alias :evolve_until :evolve_until_best
+
 
   class << self
 
@@ -105,7 +137,7 @@ INFO
       File.open(html_outfile,'w'){|f| f << File.read(File.dirname(__FILE__)+"/../../data/template.html").sub('{{CONTENT}}',html_tables) } if html_outfile
 
       # write csv file, contains raw stats
-      File.open(csv_outfile,'w'){|f| f << data.map{|r|r[0..-2] << r[-1].join(', ') }.to_table.to_csv } if csv_outfile
+      File.open(csv_outfile,'w'){|f| f << data.map{|r|r[0..2] << r[-1].join(', ') }.to_table.to_csv } if csv_outfile
 
       puts '',tbl.to_s
       data
@@ -140,9 +172,15 @@ class StrategiesDSL
   # Get all the tests. Basically a cartesian product of all selection, crossover and mutation methods.
   def get_tests
     t = []
-    raise 'No selection modules defined' unless @s
-    raise 'No crossover modules defined' unless @c
-    raise 'No mutation modules defined' unless @m  
+
+    defmod = Module.new{self.name='default'}
+    @s ||= [defmod]
+    @c ||= [defmod]
+    @m ||= [defmod]
+
+    #raise 'No selection modules defined' unless @s
+    #raise 'No crossover modules defined' unless @c
+    #raise 'No mutation modules defined' unless @m  
     @s.each{|s|
      @c.each{|c| 
       @m.each{|m|

data/lib/charlie/selection.rb

@@ -15,7 +15,7 @@ end
 # and crosses them randomly to replace all the others.
 # +best+ can be an float < 1 (fraction of population size), or a number >=1 (number of individuals)
 def TruncationSelection(best=0.3)
-  Module::new{
+  Module.new{
     @@best = best
     def next_generation(population)
       k = if @@best >= 1  # best is an integer >= 1 -> select this much

data/lib/charlie/tree/tree.rb

@@ -0,0 +1,128 @@
+#Tree genotype, crossover, mutation etc.
+
+# some general helper functions, which are independant of the operator arrays
+module GPTreeHelper
+  def dup_tree(t)
+    if t.first==:term
+      t.clone # avoid inf recursion here
+    else
+      t.map{|st| st.is_a?(Symbol) ? st : dup_tree(st) }
+    end
+  end
+
+  def tree_size(t)
+    if t.first==:term
+      1
+    else
+      t[1..-1].inject(1){|sum,st| sum + tree_size(st) }
+    end
+  end
+
+  def all_subtrees(t)
+    if t.first==:term
+      [t]
+    else
+      t[1..-1].map{|st| all_subtrees(st) }.inject{|a,b|a+b} << t
+    end
+  end
+ 
+  def random_subtree(t=@genes)
+    all_subtrees(t).at_rand
+  end
+
+  def eval_tree(tree,values_hash)
+    if tree.first == :term
+      termval = tree[1]
+      if termval.is_a?(Symbol) # look up symbols in the hash
+        termval = values_hash[termval]
+        termval = termval.call if termval.is_a?(Proc) # and if hash value is a proc, evaluate it
+      end
+      termval
+    else # tree.first is an operator
+      eval_tree(tree[1],values_hash).send(tree.first, *tree[2..-1].map{|t| eval_tree(t,values_hash) } )
+    end
+  end
+ 
+  extend self
+end
+
+# Tree genotype, for genetic programming etc.
+# * Pass arrays of terminals/binary operators and unary operators to this function to generate a class.
+# * terminals can be procs (eval'd on initialization), symbols (replaced by values in calls to eval_genes) or anything else (not changed, so make sure all operators are defined for these)
+# * This needs more options. Depth of initial trees, etc. Also needs a better mutator.
+def TreeGenotype(terminals = [proc{rand},:x], binary_ops = [:+,:*,:-,:/], unary_ops = nil)
+  Class.new(Genotype) {
+    @@terms      = terminals
+    @@binary_ops = binary_ops
+    @@unary_ops  = unary_ops
+
+    def initialize
+      self.genes = random_tree(3)
+    end
+
+    def genes=(g)
+      class << g # ensures a genes.dup call is a deep copy
+        def dup
+          GPTreeHelper.dup_tree(self)
+        end
+      end
+      @genes = g
+    end
+
+    def size
+      tree_size(@genes)
+    end
+
+    def random_tree(d)
+      if d == 0 || rand < 1.0 / 3
+        e = @@terms.at_rand
+        [:term, e.is_a?(Proc) ? e.call : e]
+      else
+        if @@unary_ops.nil? || rand < 0.5
+          [@@binary_ops.at_rand,random_tree(d-1),random_tree(d-1)]
+        else
+          [@@unary_ops.at_rand,random_tree(d-1)]
+        end
+       end
+    end
+
+    def eval_genes(terminals_value_hash = {})
+      eval_tree(@genes,terminals_value_hash)
+    end
+
+    def to_s
+      @genes.inspect
+    end
+
+    use PCross(0.7,TreeCrossover), PMutate(0.5,TreeMutator) # TODO: test what probabilities are best
+
+    # make helper functions available at both class and instance level
+    include GPTreeHelper
+    class << self
+      include GPTreeHelper
+    end
+  }
+end
+
+# TreeCrossover does a standard subtree swapping crossover for trees.
+module TreeCrossover
+  def cross(parent1,parent2)
+    child1 = parent1.dup
+    child2 = parent2.dup
+    c1_st = child1.random_subtree
+    c2_st = child1.random_subtree
+    c1_copy = dup_tree(c1_st) 
+    c1_st.replace dup_tree(c2_st)
+    c2_st.replace c1_copy
+    [child1,child2]
+  end
+end
+
+# TreeMutator replaces a randomly chosen subtree with a new, randomly generated, subtree of depth <= 2.
+module TreeMutator
+  def mutate!
+    random_subtree.replace random_tree(2)
+    self
+  end
+end
+

data/lib/charlie.rb

@@ -4,7 +4,7 @@ $:.unshift File.dirname(__FILE__)
 
 # This is just a dummy module to avoid making the VERSION constant a global.
 module Charlie
-  VERSION = '0.5.0'
+  VERSION = '0.6.0'
 end
 
 require 'charlie/etc/monkey'
@@ -26,10 +26,7 @@ require 'charlie/list/list_genotype'
 
 require 'charlie/permutation/permutation'
 
-
-
-
-
+require 'charlie/tree/tree'
 
 
 

data/test/t_common.rb

@@ -1,7 +1,5 @@
 
 
-
-
 require File.dirname(__FILE__) + '/../lib/charlie' unless Object.const_defined?('Charlie')
 require 'test/unit'
 
@@ -30,3 +28,21 @@ class StringA <  StringGenotype(20,'a'..'d')
   end
   use UniformCrossover
 end
+
+class RRTest <  BitStringGenotype(8) # easier convergence, fitness 0 at max. for testing evolve_until, etc.
+  def fitness 
+    genes.enum_slice(2).find_all{|e| e.all?{|x|x==1} }.size - 4
+  end
+  use ListMutator(:expected_n[1],:flip), TruncationSelection(0.3), UniformCrossover
+end
+
+class TestTest < Test::Unit::TestCase
+  def test_testclass
+    assert_nothing_raised{
+     Population.new(TestClass(Module::new),10).evolve_silent(2)
+     Population.new(TestClass(UniformCrossover),10).evolve_silent(2)
+     Population.new(TestClass(ListMutator(:single_point,:gaussian) ),10).evolve_silent(2)
+     Population.new(TestClass(TournamentSelection(4)),10).evolve_silent(2)
+    }
+  end
+end

data/test/test_benchmark.rb

@@ -4,6 +4,7 @@ CDIR = File.dirname(__FILE__)
 
 class BMTest < Test::Unit::TestCase
  def setup
+  Dir.mkdir(CDIR+'/output/') rescue nil
   Dir[CDIR+'/output/*'].each{|f| File.unlink f}
  end
 
@@ -33,23 +34,24 @@ class BMTest < Test::Unit::TestCase
    assert( File.readlines(CDIR+'/output/test_benchmark.csv').size == 4, 'Output file not generated.')
  end
 
- def test_raise
-   assert_raises(RuntimeError) {
-     Population.benchmark(StringA,nil,nil){
-       selection TruncationSelection(0.2)
+ def test_defaults
+   assert_nothing_raised {
+     r = Population.benchmark(StringA,nil,nil){
+       selection TruncationSelection(0.2), TournamentSelection(3)
        # no crossover, etc specified.
      }
+     assert_equal 2,r.size
    }
-   assert_raises(RuntimeError) {
-     Population.benchmark(StringA,nil,nil){
+   assert_nothing_raised {
+     r=Population.benchmark(StringA,nil,nil){
        crossover NullCrossover
      }
+     assert_equal 1,r.size
    }
-   assert_raises(RuntimeError) {
-     Population.benchmark(StringA,nil,nil){
-       mutation Module.new
-       selection Module.new
+   assert_nothing_raised {
+     r=Population.benchmark(StringA,nil,nil){
      }
+     assert_equal 1,r.size
    }
  end
 

data/test/test_evolve.rb

@@ -0,0 +1,87 @@
+require 't_common'
+
+class EvolveTest < Test::Unit::TestCase
+  def test_console
+    r = Population.new(TestProblem,10).evolve_on_console(10)
+    assert_respond_to r, :[]
+    assert_respond_to r[-1], :fitness
+  end
+
+  def test_silent
+    r = Population.new(TestProblem,10).evolve_silent(10)
+    assert_respond_to r, :[]
+    assert_respond_to r[-1], :fitness
+  end
+
+  def test_continue # test if calling evolve twice does not reset the population
+    5.times{
+     p = Population.new(TestProblem,10)
+     best3  = p.evolve_silent(3)[-1].fitness
+     best6  = p.evolve_silent(3)[-1].fitness
+     assert( best6 >= best3 )
+     best36  = p.evolve_silent(30)[-1].fitness
+     # Not true for all problems, but in this case the probability of failure is negligible
+     assert( best36 > best6, "test_continue failed. Please rerun test to make sure this isn't just extremely bad luck.")
+    }
+  end
+
+  def test_until_best  # test evolve_until_best
+    start = Time.now
+    r,g = Population.new(RRTest,10).evolve_until_best(1000_000_000){|b| b.fitness == 0}
+    assert_not_nil g
+    assert g >= 0 && g < 1000, "test_until_pop failed to converge within 1000 generations"
+    assert( (Time.now - start < 1), "test_until failed to converge within 1 second.")
+    assert_equal r.max.fitness, 0 # actually converged
+    assert_respond_to r, :[]
+    assert_respond_to r[-1], :fitness
+    # test on failure to converge
+    r,g = Population.new(RRTest,10).evolve_until_best(13){|b|  false }
+    assert_nil g # did not converge
+    assert_respond_to r, :[]
+    assert_respond_to r[-1], :fitness
+    # alias
+    Population.new(RRTest,10).evolve_until{|b| b.fitness == 0}
+  end
+
+
+  def test_until_pop  # test evolve_until_population
+    start = Time.now
+    r,g = Population.new(RRTest,10).evolve_until_population(1000_000_000){|p| p.count{|x| x.fitness == 0 } > 3}
+    assert_not_nil g
+    assert g >= 0 && g < 1000, "test_until_pop failed to converge within 1000 generations"
+    assert( (Time.now - start < 1), "test_until_pop failed to converge within 1 second.")
+    assert r.count{|x| x.fitness == 0 } > 3  # actually converged to > 3 clones of best solution
+    assert_respond_to r, :[]
+    assert_respond_to r[-1], :fitness
+    # test on failure to converge
+    r,g = Population.new(RRTest,10).evolve_until_population(13){|b|  false }
+    assert_nil g # did not converge
+    assert_respond_to r, :[]
+    assert_respond_to r[-1], :fitness
+  end
+
+  # doesn't really belong here, and should be moved...eventually
+  def test_cache
+    klass_r  = Class.new(TestProblem){ def fitness; rand; end }
+    
+    # test cache in random fitness
+    e = klass_r.new; 
+    assert_not_equal e.fitness, e.fitness
+    klass_r.class_eval{ cache_fitness }
+    assert_equal e.fitness, e.fitness
+    # test performance gain of cache. using tournamentselection(3) and sleep for maximum effect
+    klass_nc = Class.new(TestProblem){ def fitness; sleep(0.01); rand; end; use TournamentSelection(3)  }
+    klass_c  = Class.new(klass_nc){ cache_fitness }
+    3.times { # consistently
+     s = Time.now
+     Population.new(klass_nc,5).evolve_silent(2)
+     t_nc = Time.now - s
+
+     s = Time.now
+     Population.new(klass_c,5).evolve_silent(2)
+     t_c = Time.now - s
+     assert t_c < t_nc # 3x as fast, so fairly safe test
+    }
+  end
+
+end

data/test/test_permutation.rb

@@ -2,15 +2,21 @@ require 't_common'
 
 N=10
 
-#CITIES = (0...N).map{|i| th = i * 2 * Math::PI / N; [Math.cos(th),Math.sin(th)] }
-#p CITIES
-
 class PermutationTest < PermutationGenotype(N)
   def fitness
     (0...N).zip_with(genes){|a,b| a==b ? 1 : 0}.sum
   end
 end
 
+class PermutationTestERO < PermutationTest
+  use EdgeRecombinationCrossover
+  use PMutate(0.5,PermutationMutator)
+end
+
+class PermutationTestInvert < PermutationTest
+  use InversionMutator, RandomSelection
+end
+
 
 class PermTests < Test::Unit::TestCase
   def test_evolve
@@ -20,4 +26,32 @@ class PermTests < Test::Unit::TestCase
     }
     p.each{|s| assert_equal s.genes.sort, (0...N).to_a }
   end
+
+
+  def test_edge_recombination
+    p=nil
+    assert_nothing_raised{
+      p=Population.new(PermutationTestERO,20).evolve_silent(20)
+    }
+    p.each{|s| assert_equal s.genes.sort, (0...N).to_a }
+  end
+
+  def test_edge_recombination_rand # test if permutation doesn't just stay preserved because of fitness
+    p=nil
+    assert_nothing_raised{
+      klass = Class.new(PermutationTestERO){ use RandomSelection } 
+      p=Population.new(klass,20).evolve_silent(20)
+    }
+    p.each{|s| assert_equal s.genes.sort, (0...N).to_a }
+  end
+
+  def test_inversion_mutator # test if inversion mutator works
+    p=nil
+    assert_nothing_raised{
+      p=Population.new(PermutationTestInvert,20).evolve_silent(20)
+    }
+    p.each{|s| assert_equal s.genes.sort, (0...N).to_a }
+  end
+
+
 end

data/test/test_tree.rb

@@ -0,0 +1,57 @@
+require 't_common'
+
+class TreeTest < TreeGenotype([1,:x,proc{rand}], [:+], [:+@])
+  def fitness
+    - (eval_genes(:x=>1) - 5).abs
+  end
+end
+
+class BloatTest < TreeTest
+  def fitness
+    size
+  end
+end
+
+# hard to test, also see examples/tree.rb
+class TreeTests < Test::Unit::TestCase
+  def test_evolve
+    p=nil
+    assert_nothing_raised{
+      p=Population.new(TreeTest,20).evolve_silent(20)
+    }
+    p.each{|s| assert s.genes.is_a?(Array) }
+  end
+
+  def test_eval
+    p=TreeTest.new
+    p.genes = [:term,5]
+    assert_equal 0, p.fitness
+    p.genes = [:+, [:term,:x], [:term,:x]]
+    assert_equal  2, p.eval_genes(:x=>1)
+    assert_equal  6, p.eval_genes(:x=>3)
+    assert_equal( -3, p.fitness)
+    p.genes = [:term,:x]
+    assert_not_equal p.eval_genes(:x=>proc{rand}), p.eval_genes(:x=>proc{rand})
+    assert           p.eval_genes(:x=>proc{rand}).is_a?(Float)
+  end
+
+  def test_size
+    p=TreeTest.new
+    p.genes = [:term,5]
+    assert_equal 1, p.size
+    p.genes = [:+, [:term,:x], [:term,:x]]
+    assert_equal 3, p.size
+  end
+
+  def test_bloat
+    p=nil
+    assert_nothing_raised{
+      p=Population.new(BloatTest,20).evolve_silent(50)
+    }
+    p.each{|s| assert s.genes.is_a?(Array) }
+    assert p.max.size > 20, "tree bloat test failed, please rerun to check if this isn't just extremely bad luck"
+  end
+
+
+
+end