charlie 0.5.0

data/lib/charlie/population.rb

@@ -0,0 +1,156 @@
+# Contains the Population class
+
+
+# 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
+  attr_reader :size, :population
+  def initialize(genotype_class,population_size=20)
+    @size = population_size
+    @genotype_class = genotype_class
+    @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}"
+      @population = @genotype_class.next_generation(@population){|*parents|
+        ch = [*@genotype_class.cross(*parents)]
+        ch.each{|c| c.mutate! }
+        ch
+      }
+    }
+    @population = @population.sort_by{|x|x.fitness}
+    puts "Finished: Best fitness = #{@population[-1].fitness}"
+    @population
+  end
+
+  # 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
+      }
+    }
+    @population.sort_by{|x|x.fitness} rescue @population
+  end
+
+  alias :evolve :evolve_on_console
+
+  class << self
+
+    # This method generates reports comparing several selection/crossover/mutation methods. Check the examples directory for several examples. See the BENCHMARK documentation file for more information.
+    def benchmark(genotype_class, html_outfile='report.html', csv_outfile=nil, &b)
+      start = Time.now
+
+      d = StrategiesDSL.new; d.instance_eval(&b)
+      tries = d.get_tests
+      gens  = d.generations
+      pop_size  = d.population_size
+      rep = d.repeat
+      puts "#{tries.size} Total tests:"; done=0
+
+      data = tries.map{|s,c,m|
+        print "\nRunning test #{done+=1}/#{tries.size} : #{s} / #{c} / #{m}\t"
+        gclass = Class.new(genotype_class) { use s,c,m }
+        start_try = Time.now
+        bestf = (0...rep).map{
+          print '.'; $stdout.flush
+          Population.new(gclass,pop_size).evolve_silent(gens)[-1].fitness  # todo: generations
+        }
+        [s,c,m, (Time.now-start_try) / rep,  bestf]
+      }
+
+      # Generate HTML
+      html_tables = <<INFO
+        <h1>Information</h1>\n
+        <table>
+          <tr><td>Genotype class</td><td>#{genotype_class}</td></tr>
+          <tr><td>Population size</td><td>#{pop_size}</td></tr>
+          <tr><td># of generations per run</td><td>#{gens}</td></tr>
+          <tr><td>Number of tests </td><td>#{tries.size}</td></tr> 
+          <tr><td>Tests repeated </td><td>#{rep} times</td></tr> 
+          <tr><td>Number of runs </td><td>#{tries.size*rep}</td></tr> 
+          <tr><td>Total number of generations </td><td>#{tries.size*rep*gens}</td></tr> 
+          <tr><td>Total time</td><td>#{'%.2f' % (Time.now-start)} seconds</td></tr>
+        </table
+INFO
+
+      # - combined stats
+      joined   = data.map(&:last).flatten
+      avg_time = data.map{|r| r[-2] }.average
+      
+      html_tables << "<h1>Stats for all</h1>"
+      html_tables << [["All"] + (joined.stats << avg_time).map{|f| '%.5f' % f } ].to_table(%w[. min max avg stddev avg-time]).to_html
+      # - stats grouped by selection, crossover, mutation methods
+      ["selection","crossover","mutation"].each_with_index{|title,i|
+        data_grp = data.group_by{|x|x[i]}.map{|k,a|
+          joined = a.map(&:last).flatten
+          avg_time = a.map{|r| r[-2] }.average
+          [k] + (joined.stats << avg_time).map{|f| '%.5f' % f }
+        }.sort_by{|row| -row[-3].to_f } # sort by average
+        html_tables << "<h1>Stats for #{title}</h1>"
+        html_tables << data_grp.to_table([title]+%w[min max avg stddev avg-time]).to_html
+      }
+      # - detailed stats
+
+      tbl = data.map{|s,c,m,t,a| [s,c,m] + (a.stats << t).map{|f| '%.5f' % f } }.sort_by{|row| -row[-3].to_f }.to_table(%w[selection crossover mutation min max avg stddev avg-time])
+      html_tables << '<h1>Raw Stats</h1>' << tbl.to_html
+      # write HTML stats
+      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
+
+      puts '',tbl.to_s
+      data
+    end
+  end
+ 
+end
+
+
+# Used in the Population#benchmark function.
+class StrategiesDSL
+  # Number of generations run in each test.
+  attr_accessor :generations
+  # Population size used.
+  attr_accessor :population_size
+  # Number of times all tests are run. Default=10. Increase for more accuracy on the benchmark.
+  attr_accessor:repeat
+
+  def initialize
+    @repeat = 10
+    @population_size = 20 
+    @generations = 50
+  end
+
+  # Pass several modules to this to test these selection methods.
+  def selection(*s); @s=s; end
+  # Pass several modules to this to test these crossover methods.
+  def crossover(*c); @c=c; end
+  # Pass several modules to this to test these mutation methods.
+  def mutator(*m)  ; @m=m; end
+  alias :mutation :mutator
+  # 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  
+    @s.each{|s|
+     @c.each{|c| 
+      @m.each{|m|
+       t << [s,c,m]
+      }
+     }
+    }
+    t
+  end
+end
+

data/lib/charlie/selection.rb

@@ -0,0 +1,162 @@
+# Contains the selection methods.
+
+
+# Random selection. May be useful in benchmarks, but otherwise useless.
+module RandomSelection
+  def next_generation(population)
+    new_pop = []
+    new_pop += yield(population.at_rand,population.at_rand) while new_pop.size < population.size
+    new_pop.pop until new_pop.size == population.size
+    new_pop
+  end
+end
+
+# Truncation selection takes the +best+ invididuals with the highest fitness
+# 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{
+    @@best = best
+    def next_generation(population)
+      k = if @@best >= 1  # best is an integer >= 1 -> select this much
+            @@best.round
+          else             # best is a float < 1 -> select this percentage
+            [1,(@@best * population.size).round].max
+          end
+      n_new = population.size - k
+
+      population = population.sort_by(&:fitness)
+      best = population[-k..-1]
+      new_pop = []
+      new_pop += yield(best.at_rand,best.at_rand) while new_pop.size < n_new
+      new_pop.pop until new_pop.size == n_new
+
+      new_pop + best
+    end
+    self.name = "TruncationSelection(#{best})"
+  }
+end
+
+# This selection algorithm is basically randomized hill climbing.
+BestOnlySelection = TruncationSelection(1)
+
+# Roulette selection without replacement. Probability of individual i being selected is fitness(i) / sum fitness(1..population size)
+module RouletteSelection
+  def next_generation(population)
+    partial_sum = []
+    sum = population.inject(0){|a,b| cs = a + b.fitness; partial_sum << cs; cs }
+
+    new_pop = []
+    while new_pop.size < population.size
+      i1,i2 = [0,0].map{ 
+        r = rand * sum
+        partial_sum.index partial_sum.find{|x| x > r }
+      } until i1!=i2  # no replacement, except when this fails
+      new_pop += yield(population[i1],population[i2])
+    end
+    new_pop.pop until new_pop.size == population.size
+    new_pop
+  end
+
+end
+
+# Scaled Roulette selection without replacement.
+# Sorts by fitness, scales fitness by the values the given block yields for its index, then applies Roulette selection to the resulting fitness values.
+# Default is Rank selection:   {|x| x+1 }
+def ScaledRouletteSelection(&block)
+ Module.new{
+  block = proc{|x|x+1} if block.nil?
+  @@block = block
+  @@index = nil
+  @@index_size = 0 # population size used to generate index
+
+  def next_generation(population)
+ 
+   if @@index_size != population.size # build index, cache for constant population size
+     @@index_size = population.size
+     @@index = []
+     (0...population.size).map(&@@block).each_with_index{|e,i| @@index += Array.new(e.round,i)  }
+   end
+
+    population = population.sort_by(&:fitness)
+    new_pop = []
+    while new_pop.size < population.size
+      i1,i2 = @@index.at_rand, @@index.at_rand until i1!=i2 # no replacement
+      new_pop += yield(population[i1],population[i2])
+    end
+    new_pop.pop until new_pop.size == population.size
+    new_pop
+  end
+
+  self.name= "ScaledRouletteSelection[#{(0..3).map(&block).map(&:to_s).join(',')},...]"
+ }
+end
+
+ScaledRouletteSelection = ScaledRouletteSelection()
+
+# Generates a selection module with elitism from a normal selection module.
+# Elitism is saving the best +elite_n+ individuals each generation, to ensure the best solutions are never lost.
+def Elitism(sel_module,elite_n=1)
+ Module.new{
+  include sel_module
+  @@elite_n = elite_n
+  def next_generation(population)
+    population = population.sort_by(&:fitness)
+    best = population[-@@elite_n..-1]
+    population = super
+    # reset old best elite_n, but don't overwrite better ones
+    population[-@@elite_n..-1] = best.zip_with(population[-@@elite_n..-1]){|old,new| [old,new].max }
+    population
+  end
+  self.name= "Elitism(#{sel_module.to_s},#{elite_n})"
+ }
+end
+
+
+
+# Tournament selection.
+# Default: select the 2 individuals with the highest fitness out of a random population with size group_size
+# and replaces the others with offspring of these 2.
+# Does this n_times. n_times==nil takes population size / (group_size-2)  , i.e. about the same number of new individuals as roulette selection etc.
+def TournamentSelection(group_size=4,n_times=nil) # TODO: maybe expand for probabilistic selection(?) Or in a new module
+  Module::new{
+    @@group_size = group_size
+    @@n_times    = n_times
+    def next_generation(population)
+      @@n_times ||= population.size / (@@group_size-2)
+      @@n_times.times{
+        ix=[]
+        begin
+          ix = (0...@@group_size).map{ population.rand_index }
+        end while ix.uniq.size != @@group_size
+        ix=ix.sort_by{|i| population[i].fitness }
+        p1,p2 = population[ix[-1]],population[ix[-2]]
+        nw = []; 
+        nw +=  yield(p1,p2) while nw.size < @@group_size-2
+        (@@group_size-2).times{|i| population[ix[i]] = nw[i] }
+      }
+      population
+    end
+    self.name= "TournamentSelection(#{group_size},#{n_times.inspect})"
+  }
+end
+TournamentSelection = TournamentSelection()
+
+
+
+# Direct competition (gladiatorial) selection
+module GladiatorialSelection
+  def next_generation(population)
+    (population.size/2).times{
+      ix=[0,0,0,0]
+      ix=(0..3).map{population.rand_index} while ix.uniq.size < 4
+      ix[0],ix[1] = ix[1],ix[0] unless population[ix[0]].fight(population[ix[1]])  # 0 and 2 hold winners
+      ix[2],ix[3] = ix[3],ix[2] unless population[ix[2]].fight(population[ix[3]])
+      nw = []; 
+      nw +=  yield(population[ix[0]],population[ix[2]]) while nw.size < 2
+      population[ix[1]],population[ix[3]] = *nw
+    }
+    population
+  end
+end
+

data/test/t_common.rb

@@ -0,0 +1,32 @@
+
+
+
+
+require File.dirname(__FILE__) + '/../lib/charlie' unless Object.const_defined?('Charlie')
+require 'test/unit'
+
+$crs_mth = [NullCrossover, SinglePointCrossover, UniformCrossover]
+
+
+class TestProblem <  FloatListGenotype(2,0..1)
+  def fitness
+    genes.map{|x| [x,10].min }.sum
+  end
+end
+
+def TestClass(mod,klass=TestProblem)
+  Class.new(klass){use mod}
+end
+
+class RoyalRoad <  BitStringGenotype(64)
+  def fitness
+    genes.enum_slice(8).find_all{|e| e.all?{|x|x==1} }.size
+  end
+end
+
+class StringA <  StringGenotype(20,'a'..'d')
+  def fitness
+    genes.find_all{|c| c=='a'}.size
+  end
+  use UniformCrossover
+end

data/test/test_basic.rb

@@ -0,0 +1,32 @@
+require 't_common'
+
+class BasicTest < 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
+    p = Population.new(TestProblem,10)
+    best3  = p.evolve_silent(3)[-1].fitness
+    best33 = p.evolve_silent(30)[-1].fitness
+    # Not true for all problems, but in this case the probability of failure is negligible
+    assert( best33 > best3, "test_continue failed. Please rerun test to make sure this isn't just extremely bad luck.")
+  end
+
+  def test_testclass
+    assert_nothing_raised{
+     Population.new(TestClass(Module::new),10).evolve_silent(10)
+     Population.new(TestClass(UniformCrossover),10).evolve_silent(10)
+     Population.new(TestClass(ListMutator(:single_point,:gaussian) ),10).evolve_silent(10)
+     Population.new(TestClass(TournamentSelection(4)),10).evolve_silent(10)
+    }
+  end
+end

data/test/test_benchmark.rb

@@ -0,0 +1,56 @@
+require 't_common'
+
+CDIR = File.dirname(__FILE__)
+
+class BMTest < Test::Unit::TestCase
+ def setup
+  Dir[CDIR+'/output/*'].each{|f| File.unlink f}
+ end
+
+ def test_basic_bm
+   assert_nothing_raised {
+     Population.benchmark(RoyalRoad,CDIR+'/output/test_benchmark.html'){
+       selection TruncationSelection(0.2), Elitism(ScaledRouletteSelection(),1)
+       crossover NullCrossover, UniformCrossover
+       mutator   ListMutator(:single_point,:flip), ListMutator(:expected_n[4],:flip)
+       self.repeat          = 5
+       self.generations     = 40
+       self.population_size = 10
+     }
+   }
+   assert( File.read(CDIR+'/output/test_benchmark.html').size > 1000, 'Output file not generated.')
+ end
+
+
+ def test_csv
+   assert_nothing_raised {
+     Population.benchmark(StringA,nil,CDIR+'/output/test_benchmark.csv'){
+       selection TruncationSelection(0.2)
+       crossover NullCrossover, Module.new{self.name='default'}
+       mutation  ListMutator(:expected_n[1],:replace[*'a'..'d']), NullMutator
+     }
+   }
+   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)
+       # no crossover, etc specified.
+     }
+   }
+   assert_raises(RuntimeError) {
+     Population.benchmark(StringA,nil,nil){
+       crossover NullCrossover
+     }
+   }
+   assert_raises(RuntimeError) {
+     Population.benchmark(StringA,nil,nil){
+       mutation Module.new
+       selection Module.new
+     }
+   }
+ end
+
+end

data/test/test_cross.rb

@@ -0,0 +1,28 @@
+require 't_common'
+
+class TestCrossover < Test::Unit::TestCase
+  def test_cross
+    $crs_mth.each{|s|
+      klass = TestClass(s)
+      assert_nothing_raised{ Population.new(klass,10).evolve_silent(10) }
+    }
+  end
+
+  def test_singlechild
+    $crs_mth.map{|c| SingleChild(c) }.each{|s|
+      klass = TestClass(s)
+      assert_nothing_raised{ Population.new(klass,10).evolve_silent(10) }
+    }
+  end
+
+  def test_pcross
+    $crs_mth.map{|c| PCross(0.5,c) }.each{|s|
+      klass = TestClass(s)
+      assert_nothing_raised{ Population.new(klass,10).evolve_silent(10) }
+    }
+    $crs_mth.map{|c| PCross(0.5,c,$crs_mth[-2]) }.each{|s|
+      klass = TestClass(s)
+      assert_nothing_raised{ Population.new(klass,10).evolve_silent(10) }
+    }
+  end
+end