charlie 0.6.0 → 0.7.0

data/lib/charlie/population.rb

@@ -6,7 +6,7 @@
 class Population
   DEFAULT_MAX_GENS = 100
 
-  attr_reader :size, :population
+  attr_reader :size, :population, :genotype_class
   def initialize(genotype_class,population_size=20)
     @size = population_size
     @genotype_class = genotype_class
@@ -46,12 +46,12 @@ class Population
   end
   alias :evolve :evolve_on_console
 
-  # breaks if the block (which is passed the population each generation) returns true.
+  # breaks if the block (which is passed the population each "check_every" generations) returns true.
   # returns an array [population, generations needed]. generations needed==nil for no convergence.
-  def evolve_until_population(generations=DEFAULT_MAX_GENS)
+  def evolve_until_population(generations=DEFAULT_MAX_GENS,check_every=10)
     tot_gens = nil
     evolve_block(generations) {|p,g|
-      if yield(p)
+      if (g % check_every).zero? && yield(p)
         tot_gens = g
         break
       end
@@ -59,12 +59,12 @@ class Population
     [@population, tot_gens]
   end
 
-  # breaks if the block (which is passed the best individual each generation) returns true.
+  # breaks if the block (which is passed the best individual each "check_every" generations) returns true.
   # returns an array [population, generations needed]. generations needed==nil for no convergence.
-  def evolve_until_best(generations=DEFAULT_MAX_GENS)
+  def evolve_until_best(generations=DEFAULT_MAX_GENS,check_every=10)
     tot_gens = nil
     evolve_block(generations)  {|p,g|
-      if yield(p.max)
+      if (g % check_every).zero? && yield(p.max)
         tot_gens = g
         break 
       end
@@ -74,121 +74,11 @@ class Population
   alias :evolve_until :evolve_until_best
 
 
-  class << self
+  # accessors for population
+  [:[],:max,:min].each{|m|
+     define_method(m){|*args| population.send(m,*args) }
+  }
+  alias :best :max
 
-    # 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 = []
-
-    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|
-       t << [s,c,m]
-      }
-     }
-    }
-    t
-  end
 end
 

data/lib/charlie/selection.rb

@@ -94,6 +94,7 @@ 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)

data/lib/charlie/tree/tree.rb

@@ -18,7 +18,15 @@ module GPTreeHelper
     end
   end
 
-  def all_subtrees(t)
+  def tree_depth(t)
+    if t.first==:term
+      0
+    else
+      1 + t[1..-1].map{|st| tree_depth(st) }.max
+    end
+  end
+
+  def all_subtrees(t=@genes)
     if t.first==:term
       [t]
     else
@@ -30,6 +38,18 @@ module GPTreeHelper
     all_subtrees(t).at_rand
   end
 
+  def all_terminals(t=@genes)
+    if t.first==:term
+      [t]
+    else
+      t[1..-1].map{|st| all_terminals(st) }.inject{|a,b|a+b}
+    end
+  end
+
+  def random_terminal(t=@genes)
+    all_terminals(t).at_rand
+  end
+
   def eval_tree(tree,values_hash)
     if tree.first == :term
       termval = tree[1]
@@ -47,17 +67,21 @@ module GPTreeHelper
 end
 
 # Tree genotype, for genetic programming etc.
-# * Pass arrays of terminals/binary operators and unary operators to this function to generate a class.
+# * Pass arrays of terminals/unary operators/binary 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)
+def TreeGenotype(terminals, unary_ops, binary_ops, init_depth = 3, init_type = :half)
+  unary_ops  = nil if unary_ops.empty?
   Class.new(Genotype) {
-    @@terms      = terminals
-    @@binary_ops = binary_ops
-    @@unary_ops  = unary_ops
+
+    define_method(:unary_ops)  {unary_ops }
+    define_method(:binary_ops) {binary_ops}
+    define_method(:terminals)  {terminals }
+    define_method(:init_depth) {init_depth}
+    define_method(:init_type)  {init_type }
 
     def initialize
-      self.genes = random_tree(3)
+      self.genes = generate_random_tree(init_depth,init_type)
     end
 
     def genes=(g)
@@ -73,15 +97,48 @@ def TreeGenotype(terminals = [proc{rand},:x], binary_ops = [:+,:*,:-,:/], unary_
       tree_size(@genes)
     end
 
-    def random_tree(d)
-      if d == 0 || rand < 1.0 / 3
-        e = @@terms.at_rand
+    def depth
+      tree_depth(@genes)
+    end
+
+
+    # Generates a random tree.
+    # * type = grow uses generate_random_tree_grow
+    # * type = full uses generate_random_tree_full
+    # * type = half uses one of them, with 50% probability each.
+    def generate_random_tree(depth, type=:half)
+      if type==:full || ( type == :half && rand < 0.5 )
+        generate_random_tree_full(depth)
+      else
+        generate_random_tree_grow(depth,true)
+      end
+    end
+
+    # Generates a random tree of a certain maximum depth.
+    # * <tt>no_term=true</tt> makes sure the root node is a function.
+    def generate_random_tree_grow(depth,no_term=nil)
+      if depth.zero? || (rand(3).zero?  && !no_term)
+        e = terminals.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)]
+        if unary_ops.nil? || rand(2).zero?
+          [binary_ops.at_rand,generate_random_tree_grow(depth-1),generate_random_tree_grow(depth-1)]
         else
-          [@@unary_ops.at_rand,random_tree(d-1)]
+          [unary_ops.at_rand,generate_random_tree_grow(depth-1)]
+        end
+       end
+    end
+
+    # Generates a random tree, with all terminals at 'depth'.
+    def generate_random_tree_full(depth)
+      if depth.zero?
+        e = terminals.at_rand
+        [:term, e.is_a?(Proc) ? e.call : e]
+      else
+        if unary_ops.nil? || rand(2).zero?
+          [binary_ops.at_rand,generate_random_tree_full(depth-1),generate_random_tree_full(depth-1)]
+        else
+          [unary_ops.at_rand,generate_random_tree_full(depth-1)]
         end
        end
     end
@@ -94,7 +151,7 @@ def TreeGenotype(terminals = [proc{rand},:x], binary_ops = [:+,:*,:-,:/], unary_
       @genes.inspect
     end
 
-    use PCross(0.7,TreeCrossover), PMutate(0.5,TreeMutator) # TODO: test what probabilities are best
+    use PCross(0.7,TreeCrossover), PMutate(0.5,TreeReplaceMutator) # TODO: test what options are best -- benchmark show that these are ok for simple settings.
 
     # make helper functions available at both class and instance level
     include GPTreeHelper
@@ -118,11 +175,116 @@ module TreeCrossover
   end
 end
 
-# TreeMutator replaces a randomly chosen subtree with a new, randomly generated, subtree of depth <= 2.
-module TreeMutator
+# TreeReplaceMutator replaces a randomly chosen subtree with a new, randomly generated, subtree.
+# * depth and type are arguments for TreeGenotype#generate_random_tree
+# * depth == [1,2,3,..] or depth==(1..3) uses one of the elements in the range for the depth.
+# * depth == :same to use the depth of the replaced subtree.
+# * depth == :same[min,max] for depth of the replaced subtree plus a random offset between min and max.
+def TreeReplaceMutator(depth=2,type=:half)
+  Module.new{
+     self.name = "TreeReplaceMutator(#{depth.inspect},#{type.inspect})"
+    if depth.is_a? Numeric
+      define_method(:mutate!) {
+        random_subtree.replace generate_random_tree(depth,type)
+        self
+      }
+    elsif depth==:same || (depth.is_a?(Array) && depth[0]==:same)
+      s, dd_min, dd_max = *depth
+      possible_deltas = (dd_min||0..dd_max||0).to_a
+      define_method(:mutate!) {
+        st = random_subtree
+        st.replace generate_random_tree([tree_depth(st) + possible_deltas.at_rand,0].max, type)
+        self
+      }
+    elsif depth.respond_to?(:to_a)
+      possible_depths = depth.to_a
+      define_method(:mutate!) {
+        random_subtree.replace generate_random_tree(possible_depths.at_rand,type)
+        self
+      }
+    else
+      raise ArgumentError, "invalid option for depth"
+    end
+  }
+end
+
+TreeReplaceMutator = TreeReplaceMutator()
+TreePruneMutator   = TreeReplaceMutator(0)
+
+# replace root by one of its children, i.e. TreeRemoveNodeMutator with the root instead of a random node.
+module TreeChopMutator
+  def mutate!
+    return self if genes.first==:term
+    genes.replace genes[1..-1].at_rand # replace root with child
+    self
+  end
+end
+
+# replaces a random node by one of its children. does nothing if the randomly chosen node is a terminal.
+module TreeRemoveNodeMutator
   def mutate!
-    random_subtree.replace random_tree(2)
+    st = random_subtree
+    return self if st.first==:term
+    st.replace st[1..-1].at_rand
     self
   end
 end
 
+# replaces a random node x by a new operator node having x as one of its children. When inserting a binary operator the other node will be a terminal.
+module TreeInsertNodeMutator
+  def mutate!
+    st = random_subtree
+    if rand < 0.5 || unary_ops.nil?
+      st.replace [binary_ops.at_rand, st.dup, generate_random_tree_full(0)]
+    else
+      st.replace [unary_ops.at_rand, st.dup]
+    end
+    self
+  end
+end
+
+# replaces a random terminal by a new one.
+module TreeTerminalMutator
+  def mutate!
+    random_terminal.replace generate_random_tree(0)
+    self
+  end
+end
+
+# mutates a random numeric terminal using a point mutator (cf. ListMutator) or a block (e.g. {|x| x-rand+0.5}
+def TreeNumTerminalMutator(mutate=:uniform[0.1], &b)
+ if block_given?
+   mutate_proc = b
+ else
+  mut_name, *mut_arg = mutate
+  mut_fn = PointMutators[mut_name]
+  mutate_proc = proc{|x| mut_fn.call(x,*mut_arg) }
+ end
+
+ Module.new{
+  self.name = "TreeNumTerminalMutator(#{mutate.inspect})"
+  define_method(:mutate!) {
+    numterms = all_terminals.select{|x| x[1].is_a? Numeric }
+    unless numterms.empty?
+      random_term = numterms.at_rand
+      random_term[1] = mutate_proc.call(random_term[1])
+    end
+    self
+  }
+ }
+end
+TreeNumTerminalMutator = TreeNumTerminalMutator()
+
+# Replaces a random subtree by the result of its evaluation. value_hash is passed to eval_tree.
+def TreeEvalMutator(value_hash=Hash.new{0})
+ Module.new{
+  define_method(:mutate!) {
+    st = random_subtree
+    st.replace [:term,eval_tree(st,value_hash)]
+    self
+  }
+ }
+end
+TreeEvalMutator = TreeEvalMutator()
+
+

data/test/t_common.rb

@@ -3,7 +3,7 @@
 require File.dirname(__FILE__) + '/../lib/charlie' unless Object.const_defined?('Charlie')
 require 'test/unit'
 
-$crs_mth = [NullCrossover, SinglePointCrossover, UniformCrossover]
+$crs_mth = [NullCrossover, SinglePointCrossover, UniformCrossover, NPointCrossover(1), NPointCrossover(2), NPointCrossover(24)]
 
 
 class TestProblem <  FloatListGenotype(2,0..1)

data/test/test_benchmark.rb

@@ -10,7 +10,7 @@ class BMTest < Test::Unit::TestCase
 
  def test_basic_bm
    assert_nothing_raised {
-     Population.benchmark(RoyalRoad,CDIR+'/output/test_benchmark.html'){
+     GABenchmark.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)
@@ -25,7 +25,7 @@ class BMTest < Test::Unit::TestCase
 
  def test_csv
    assert_nothing_raised {
-     Population.benchmark(StringA,nil,CDIR+'/output/test_benchmark.csv'){
+     GABenchmark.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
@@ -36,23 +36,37 @@ class BMTest < Test::Unit::TestCase
 
  def test_defaults
    assert_nothing_raised {
-     r = Population.benchmark(StringA,nil,nil){
+     r = GABenchmark.benchmark(StringA,nil,nil){
        selection TruncationSelection(0.2), TournamentSelection(3)
        # no crossover, etc specified.
      }
      assert_equal 2,r.size
    }
    assert_nothing_raised {
-     r=Population.benchmark(StringA,nil,nil){
+     r=GABenchmark.benchmark(StringA,nil,nil){
        crossover NullCrossover
      }
      assert_equal 1,r.size
    }
    assert_nothing_raised {
-     r=Population.benchmark(StringA,nil,nil){
+     r=GABenchmark.benchmark(StringA,nil,nil){
      }
      assert_equal 1,r.size
    }
  end
 
+
+ def test_multiple_stats
+   d = nil
+   assert_nothing_raised {
+     d = GABenchmark.benchmark(StringA,nil,nil){
+       track_stats{|b| [0,1] }
+       repeat 11
+       generations 17
+     }
+   }
+   assert_equal 1,d.size
+   assert_equal 11,d[0][-1].size
+   assert d.all?{|r| r[-1].all?{|e| e.size==2 } }
+ end
 end