charlie 0.7.1 → 0.8.0

data/lib/charlie/mutate.rb

@@ -8,6 +8,7 @@ end
 
 # Takes mutator m1 with probability p, and mutator m2 with probability 1-p
 def PMutate(p,m1,m2=NullMutator)
+  raise ArgumentError, "first argument to PMutate should be numeric (probability)." unless p.is_a?(Numeric)
   return m1 if m1==m2
   m1_name, m2_name = [m1,m2].map{|c| '_mutate_' + c.to_s.gsub(/[^A-Za-z0-9]/,'') + '!' }
   Module.new{

data/lib/charlie/population.rb

@@ -3,34 +3,34 @@
 
 # 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
+class Population < Array
   DEFAULT_MAX_GENS = 100
-
-  attr_reader :size, :population, :genotype_class
-  def initialize(genotype_class,population_size=20)
-    @size = population_size
+  DEFAULT_POP_SIZE = 20
+  attr_reader :genotype_class
+  def initialize(genotype_class,population_size=DEFAULT_POP_SIZE)
     @genotype_class = genotype_class
-    @population = Array.new(population_size){ genotype_class.new } 
+    replace Array.new(population_size){ genotype_class.new } 
   end
 
   # 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
+    yield self, 0
     (max_generations || DEFAULT_MAX_GENS).times {|generation|
-      @population = @genotype_class.next_generation(@population){|*parents|
+      self.population = @genotype_class.next_generation(self){|*parents|
         ch = [*@genotype_class.cross(*parents)]
         ch.each{|c| c.mutate! }
         ch
       }
-      yield @population, generation+1
+      yield self, generation+1
     }
-    @population
+    self
   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
+    sort_by!{|x|x.fitness} rescue nil
+    self
   end
  
   # Runs the genetic algorithm with some stats on the console. Returns the population sorted by fitness.
@@ -40,9 +40,9 @@ class Population
       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
+    self.population = self.sort_by{|x|x.fitness}
+    puts "Finished: Best fitness = #{self[-1].fitness}"
+    self
   end
   alias :evolve :evolve_on_console
 
@@ -56,7 +56,7 @@ class Population
         break
       end
     }
-    [@population, tot_gens]
+    [self, tot_gens]
   end
 
   # breaks if the block (which is passed the best individual each "check_every" generations) returns true.
@@ -69,16 +69,79 @@ class Population
         break 
       end
     }
-    [@population, tot_gens]
+    [self, tot_gens]
   end
   alias :evolve_until :evolve_until_best
+  alias :best :max
 
+  # backwards compatibility, returns self
+  def population; self; end
+  # backwards compatibility, replaces population array
+  alias :population= :replace
 
-  # accessors for population
-  [:[],:max,:min].each{|m|
-     define_method(m){|*args| population.send(m,*args) }
-  }
-  alias :best :max
 
+  # Effectively runs Population#evolve_block <tt>n_runs</tt> times.
+  # Returns the entire population of all results (<tt>n_runs * population_size</tt> elements)
+  def self.evolve_multiple(genotype_class,population_size=DEFAULT_POP_SIZE,
+                           n_runs=25,
+                           generations=DEFAULT_MAX_GENS)
+    r = evolve_multiple_until_population(genotype_class,population_size, n_runs, generations, 10000) {|pop| false }
+    r.first
+  end
+
+  # Effectively runs Population#evolve_until_best  multiple times.
+  # * See Population.evolve_multiple_until_population for arguments
+  def self.evolve_multiple_until_best(*args,&b)
+    evolve_multiple_until_population(*args) {|pop| b.call(pop.max) }
+  end
+
+  # Runs Population#evolve_until_population  multiple times.
+  # * genotype_class,population_size are arguments for Population.new
+  # * max_tries is the maximum number of restarts.
+  # * Returns [population, generations needed] on success where population is the population of the successful run.
+  # * Returns [population_all, nil] on failure, where population_all is the combined population of all runs.
+  def self.evolve_multiple_until_population(genotype_class,population_size=DEFAULT_POP_SIZE,
+                                            max_tries=25,
+                                            generations=DEFAULT_MAX_GENS,check_every=10)
+    tot_gens = 0
+    all_pop = []
+    max_tries.times{
+      pop, gens = Population.new(genotype_class,population_size).evolve_until_population(generations,check_every){|p|
+        yield(p)
+      }
+      all_pop  += pop
+      tot_gens += gens || generations
+      if gens
+        return [pop, tot_gens]
+      end
+    }
+    [all_pop, nil]
+  end
+  class << self;   alias :evolve_multiple_until :evolve_multiple_until_best; end
+
+end
+
+
+# Uses GP-style evolution (i.e. crossover OR mutation instead of crossover AND mutation) with a selection method.
+# * Works by discarding and replacing the block given to next_generation in Population#evolve_block
+# * Is not mandatory for GP, and can just as easily be used for GA or not used in GP.
+# * Bit of a strange place to do this, but works nicely with the benchmarking
+def GP(sel_module,crossover_probability=0.75)
+ ng_name = sel_module.to_s.gsub(/[^A-Za-z0-9]/,'_')
+ Module.new{
+  include sel_module.dup
+  alias_method ng_name, :next_generation
+  define_method(:next_generation){|population|
+    send(ng_name,population){|*parents|
+      if rand < crossover_probability
+        [*parents[0].class.cross(*parents)]
+      else
+        parents.map{|c| c.mutate }
+      end
+    }
+  }
+  self.name= "GP(#{sel_module.to_s},#{crossover_probability})"
+ }
 end
 
+

data/lib/charlie/selection.rb

@@ -37,28 +37,44 @@ def TruncationSelection(best=0.3)
   }
 end
 
+TruncationSelection = TruncationSelection()
+
 # 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 }
+    sum = 0
+    population.each{|e| partial_sum << (sum += e.fitness) }
 
+    n = population.size
     new_pop = []
-    while new_pop.size < population.size
-      i1 = i2 = nil
-      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])
+    i = [0,0]
+    while new_pop.size < n
+      i[0] = i[1]
+      until i[0]!=i[1]
+        i.map!{ # binary search
+          r = rand * sum
+          l = 0; u = n-1;
+          while l!=u
+           m = (l+u)/2
+           if partial_sum[m] < r
+            l = m+1
+           else
+            u = m
+           end
+          end
+          l
+        }
+      end
+      new_pop += yield(population[i[0]],population[i[1]])
     end
     new_pop.pop until new_pop.size == population.size
     new_pop
   end
-
 end
 
 # Scaled Roulette selection without replacement.
@@ -78,16 +94,20 @@ def ScaledRouletteSelection(&block)
      @@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 = nil
-      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
+   population = population.sort_by(&:fitness)
+
+   new_pop = []
+   index = @@index
+   while new_pop.size < population.size
+     i1 = index.at_rand
+     i2 = index.at_rand
+     if i1==i2
+       i1,i2 = @@index.at_rand, @@index.at_rand until i1!=i2 # no replacement
+     end
+     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(',')},...]"
@@ -95,7 +115,7 @@ def ScaledRouletteSelection(&block)
 end
 
 ScaledRouletteSelection = ScaledRouletteSelection()
-
+RankSelection = 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.
@@ -121,18 +141,16 @@ end
 # 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
+def TournamentSelection(group_size=4,n_times=nil)
   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 }
+      psz = population.size
+      n_times = @@n_times || (psz / (@@group_size-2))
+      n_times.times{
+        population.shuffle!
+        ix = (0...@@group_size).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
@@ -146,8 +164,7 @@ end
 TournamentSelection = TournamentSelection()
 
 
-
-# Direct competition (gladiatorial) selection
+# Co-evolution: Direct competition (gladiatorial) selection. Define a Genotype#fight function to use this
 module GladiatorialSelection
   def next_generation(population)
     (population.size/2).times{
@@ -163,3 +180,44 @@ module GladiatorialSelection
   end
 end
 
+#  Co-evolution: competition in tournaments selection.
+# * Define a fight_points(other) function in your genotype to use this. The function should return [points for self,points for other]
+# * Point-proportial selection is used within tournaments. Entire groups are replaced.
+# * full_tournament = true calls both fight_points(population[i],population[j]) AND fight_points(population[j],population[i]) instead of only i < j
+# Does this n_times. n_times==nil takes population size / group_size , i.e. about the same number of new individuals as roulette selection etc.
+def CoTournamentSelection(group_size=4,full_tournament=false,n_times=nil)
+  Module::new{
+    @@group_size = group_size
+    @@full_tournament = full_tournament
+    @@n_times    = n_times
+    def next_generation(population)
+      psz = population.size
+      n_times = @@n_times || (psz / @@group_size)     #(psz / (@@group_size-2))
+      n_times.times{
+        population.shuffle!
+        points = Array.new(@@group_size,0.0)
+        for i in 0...@@group_size
+         for j in 0...@@group_size
+          next if j==i || (i > j && !@@full_tournament)
+          r = population[i].fight_points(population[j])
+          points[i] += r[0]
+          points[j] += r[1]
+         end
+        end
+       # points-proportional selection, with replacement b.c. 1 individual with 100% of the points is not implausible.
+
+        partial_sum = []; sum = 0; points.each{|p| partial_sum << (sum += p) }
+        partial_sum.map!{|x|x+1} if sum.abs < 1e-10 # sum==0 -> random
+        newgroup = [];
+        (@@group_size / 2.0).ceil.times{ 
+          sel_ix = [0,0].map{ r=rand*sum; partial_sum.find_index{|ps| ps >= r } }
+          newgroup += yield(population[sel_ix[0]],population[sel_ix[1]])
+        }
+        population[0...@@group_size] = newgroup[0...@@group_size]
+      }
+      population
+    end
+    self.name= "CoTournamentSelection(#{group_size},#{full_tournament},#{n_times.inspect})"
+  }
+end
+CoTournamentSelection = CoTournamentSelection()

data/lib/charlie/tree/tree.rb

@@ -278,6 +278,7 @@ 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{
+  self.name = "TreeEvalMutator(#{value_hash.inspect})"
   define_method(:mutate!) {
     st = random_subtree
     st.replace [:term,eval_tree(st,value_hash)]

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, NPointCrossover(1), NPointCrossover(2), NPointCrossover(24)]
+$crs_mth = [NullCrossover, SinglePointCrossover, UniformCrossover, NPointCrossover(1), NPointCrossover(2), NPointCrossover(24),BlendingCrossover(0.1,:line),BlendingCrossover(1.3,:cube)]
 
 
 class TestProblem <  FloatListGenotype(2,0..1)

data/test/test_benchmark.rb

@@ -69,4 +69,22 @@ class BMTest < Test::Unit::TestCase
    assert_equal 11,d[0][-1].size
    assert d.all?{|r| r[-1].all?{|e| e.size==2 } }
  end
+
+
+ def test_setup_teardown
+   d = nil
+   s = t = 0 # count setup/teardown calls/args
+   assert_nothing_raised {
+     d = GABenchmark.benchmark(StringA,nil,nil){
+       selection TruncationSelection, TournamentSelection
+       setup{ s+=1 }
+       teardown{|p| t += p.size }
+       population_size 7
+       repeat 10
+     }
+   }
+   assert_equal 2, d.size
+   assert_equal 10 * 7 * 2,t
+   assert_equal 10 * 2, s
+ end
 end

data/test/test_cross.rb

@@ -8,6 +8,26 @@ class TestCrossover < Test::Unit::TestCase
     }
   end
 
+  def test_blend
+    klass = FloatListGenotype(100)
+    klass.use BlendingCrossover(0.0)
+    p = Array.new(2){klass.new}
+    p[0].genes.map!{0.0}
+    p[1].genes.map!{1.0}
+    10.times{
+      ch = klass.cross(p[0],p[1])
+      assert ch.all?{|c| c.genes.all?{|g| g > 0.0 && g < 1.0 } }
+    }
+    assert p[0].genes.all?{|g|g==0.0}
+    assert p[1].genes.all?{|g|g==1.0}
+    klass.use BlendingCrossover(0.0,:line)
+    3.times{
+      ch = klass.cross(p[0],p[1])
+      assert ch.all?{|c| gn = c.genes; gn[0] > 0.0 && gn[0] < 1.0 && gn.all?{|g| g==gn[0] } }
+    }
+    assert_raises(ArgumentError) { BlendingCrossover(0.0,:foo) }
+  end
+
   def test_singlechild
     $crs_mth.map{|c| SingleChild(c) }.each{|s|
       klass = TestClass(s)

data/test/test_evolve.rb

@@ -91,10 +91,34 @@ class EvolveTest < Test::Unit::TestCase
   end
 
 
-  def test_acc  # test accessors
+  def test_acc  # test accessors. backward compatibility
     p = Population.new(RRTest,10)
     assert_equal p.max, p.population.max
     assert_equal p.max, p.best
     assert_equal p[6], p.population[6]
   end
+
+
+
+ def test_multiple_until_best  # test evolve_multiple_until
+    r,g = Population.evolve_multiple_until(RRTest,5,5){false}
+    assert_equal 5*5, r.size
+    assert_nil g
+
+    r,g = Population.evolve_multiple_until(RRTest,10,500){|b| b.fitness == 0}
+    assert_equal 10, r.size
+    assert_not_nil g
+    assert_equal r.max.fitness, 0 # actually converged
+    assert_respond_to r, :[]
+    assert_respond_to r[-1], :fitness
+  end
+
+
+ def test_multiple  # test evolve_multiple_until
+    r = Population.evolve_multiple(RRTest,5,5)
+    assert_equal 5*5, r.size
+    assert_respond_to r, :[]
+    assert_respond_to r[-1], :fitness
+  end
+
 end

data/test/test_matrix.rb

@@ -0,0 +1,36 @@
+require 't_common'
+
+class BMatrixTest < BitMatrixGenotype(16,4)
+  def fitness
+    genes.flatten.count{|b| b==1 }
+  end
+end
+
+class MatrixTests < Test::Unit::TestCase
+  def test_evolve
+    p=nil
+    assert_nothing_raised{
+      p=Population.new(BMatrixTest,20).evolve_silent(20)
+    }
+    assert p.all?{|s| s.fitness > 32 }, "Insufficient fitness gain, can be extremely bad luck but probably a sign of a bug in the dup code"
+    p.each{|s|
+     assert s.genes.is_a?(Array) && s.genes.size == 16
+     assert s.genes[0].is_a?(Array) && s.genes.all?{|a| a.size==4 }
+    }
+  end
+
+  def test_listxover
+    p=nil
+    klass = Class.new(BMatrixTest) {use NPointCrossover(3) }
+    assert_nothing_raised{
+      p=Population.new(klass,20).evolve_silent(20)
+    }
+    assert p.all?{|s| s.fitness > 32 }, "Insufficient fitness gain, can be extremely bad luck but probably a sign of a bug in the dup code"
+    p.each{|s|
+     assert s.genes.is_a?(Array) && s.genes.size == 16
+     assert s.genes[0].is_a?(Array) && s.genes.all?{|a| a.size==4 }
+    }
+
+  end
+
+end