charlie 0.7.1 → 0.8.0

data/examples/string.rb

@@ -92,7 +92,10 @@ loop{
 }
 puts 'Found walk of length 25:', pop[-1].genes.inspect
 
+puts "Second try, no output but shorter code."
+pop, gens = Population.evolve_multiple_until(Walk,20,1000){|b| b.fitness == 25 } 
 
+puts "Found walk of length 25 in #{gens} generations:", pop.best.genes.inspect
 
 
 end

data/examples/tree.rb

@@ -92,6 +92,20 @@ solutions found for N=31:
 pop = Population.new(PORS).evolve_on_console(500)
 pp pop.max.genes
 
+elsif ARGV[0]=='xor'
+class Object; def not; !self; end;end
+
+class XOR < TreeGenotype([:A,:B,true,false],[:not], [:&,:|])
+  def fitness
+    [[false,false],[false,true],[true,false],[true,true]].count{|a,b| eval_genes(:A=>a,:B=>b) == a^b } - $size_fac * size
+  end
+  cache_fitness
+end
+$size_fac = 0.01
+pop, gen = Population.new(XOR).evolve_until(2000){|best| best.fitness > 3.9 }
+puts "Generations needed (nil=no convergence) : #{gen}"
+puts "Solution: #{pop.best}, fitness  #{pop.best.fitness}"
+
 
 elsif ARGV[0]=='bloat'
 
@@ -111,5 +125,5 @@ pop = Population.new(Bloat).evolve_on_console(200)
 
 else
   puts "Several examples for tree genotypes."
-  puts "Usage: ruby tree.rb cos|pors|porsx|bloat"
+  puts "Usage: ruby tree.rb cos|pors|porsx|xor|parity6|bloat"
 end

data/examples/tsp.rb

@@ -26,8 +26,7 @@ class TSP < PermutationGenotype(CITIES.size)
 end
 
 puts "Running GA until the optimal solution has been found."
-gen = nil
-pop, gen = Population.new(TSP,30).evolve_until(1000,100){|b| puts b.fitness; b.fitness > -(N*N+1) } while gen.nil?
+pop, gen = Population.evolve_multiple_until(TSP,30,100,1000,100){|b| puts b.fitness; b.fitness > -(N*N+1) }
 puts "Fitness: #{pop.max.fitness}"
 puts "Generations needed: #{gen.inspect}"
 p pop.max.genes.map{|a| CITIES[a]}

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.7.1'
+  VERSION = '0.8.0'
 end
 
 require 'charlie/etc/monkey'
@@ -24,6 +24,10 @@ require 'charlie/list/list_mutate'
 require 'charlie/list/list_crossover'
 require 'charlie/list/list_genotype'
 
+require 'charlie/list/matrix'
+
+require 'charlie/list/neural'
+
 require 'charlie/permutation/permutation'
 
 require 'charlie/tree/tree'

data/lib/charlie/crossover.rb

@@ -23,6 +23,7 @@ end
 
 # Takes crossover c1 with probability p, and crossover c2 with probability 1-p
 def PCross(p,c1,c2=NullCrossover)
+  raise ArgumentError, "first argument to PCross should be numeric (probability)." unless p.is_a?(Numeric)
   return c1 if c1==c2
   c1_name, c2_name = [c1,c2].map{|c| '_cross_' + c.to_s.gsub(/[^A-Za-z0-9]/,'') }
   Module.new{

data/lib/charlie/etc/monkey.rb

@@ -32,10 +32,11 @@ module Enumerable
 end
 
 class Array
-
-  def shuffle
-    sort_by{ rand }
-  end if RUBY_VERSION < '1.9'
+ if RUBY_VERSION < '1.9'
+  def shuffle ; sort_by { rand }; end
+  def shuffle!; replace shuffle; end
+  def find_index(&b); index find(&b); end
+ end
 
   def dot_product(v)
     r=0.0

data/lib/charlie/gabenchmark.rb

@@ -12,7 +12,9 @@ module GABenchmark
     generations      = dsl_obj.generations
     population_size  = dsl_obj.population_size
     repeat_tests     = dsl_obj.repeat
-  
+    setup_proc       = dsl_obj.setup
+    teardown_proc    = dsl_obj.teardown
+
     track_stat  = dsl_obj.track_stat
 
     n_tests = all_tests.size
@@ -30,8 +32,14 @@ module GABenchmark
 
       test_stats = (0...repeat_tests).map{
         print '.'; $stdout.flush
-        best = Population.new(gclass,population_size).evolve_silent(generations).last  
+
+        population = Population.new(gclass,population_size)
+        setup_proc.call(population)
+        best = population.evolve_silent(generations).last
+
         stat = track_stat.call(best)
+        teardown_proc.call(population)
+
         overall_best = [best, stat] if overall_best[0].nil? || (overall_best[1] <=> stat) < 0 # use <=> to allow arrays
         stat
       }
@@ -159,7 +167,8 @@ class StrategiesDSL
   def initialize
     @repeat          = 10
     @population_size = 20 
-    @generations     = 50
+    @generations     = 50 
+    @setup = @teardown = proc{}
     selection []
     crossover []
     mutator   []
@@ -176,6 +185,18 @@ class StrategiesDSL
   end
   alias :track_stats :track_stat
 
+  # Pass a block that does the setup. Rarely needed. The proc is passes the population before each test (i.e. between Population.new and #evolve_silent)
+  def setup(&b)
+    return @setup unless block_given?
+    @setup = b
+  end
+
+  # Pass a block that does the setup. Rarely needed. Called with the population as argument AFTER track_stats.
+  def teardown(&b)
+    return @teardown unless block_given?
+    @teardown = b
+  end
+
   # Get all the tests. Basically a cartesian product of all selection, crossover and mutation methods.
   def get_tests
     t = []

data/lib/charlie/genotype.rb

@@ -36,7 +36,7 @@ class Genotype
 
     # Creates a new instance of your genotype class given its genes.
     def from_genes(g)
-      r = allocate # r = new  # how to avoid initialize here? -- fixed
+      r = allocate
       r.genes = g
       r
     end
@@ -52,6 +52,9 @@ class Genotype
     end
   end
  
+  def clear_cache
+    @fitness_cache = nil
+  end
   # Used by Genotype.cache_fitness. This accessor can be used to clear the cache.
   # Also could be used by niche selection, etc. as a place to change the effective fitness w/o changing the actual selection algorithms.
   attr_accessor :fitness_cache 
@@ -61,13 +64,27 @@ class Genotype
   end
 
   def mutate
-    dup.mutate!
+    cp = dup
+    cp.mutate!
+    cp
   end
 
   def to_s
     @genes.to_s
   end
 
+  # Defines fight in terms of fight_points (self wins if it has at least as many points as other). Used in co-evolution.
+  #def fight(other)
+  #  r = fight_points(other)
+  #  return r[0]>=r[1]
+  #end
+
+  # Defines fight_points in terms of fight (1 point for the winner, 0 for the loser). Used in co-evolution.
+  ##def fight_points(other)
+  #  fight(other) ? [1,0] : [0,1]
+  #end
+
+
   include Comparable
   def <=>(b)
     fitness <=> b.fitness

data/lib/charlie/list/list_crossover.rb

@@ -29,6 +29,8 @@ def NPointCrossover(n=2)
   }
  }
 end
+TwoPointCrossover   = NPointCrossover(2)
+ThreePointCrossover = NPointCrossover(2)
 
 # Uniform crossover, returns two children.
 module UniformCrossover
@@ -47,4 +49,42 @@ module UniformCrossover
 end
 
 
+# Blending crossover, common in evolutionary strategies.
+# * Given two parents x1(i), x2(i)
+# * Returns two children with as i'th elements  y(i)x1(i)+(1-y(i))x2(i)  and  y(i)x2(i)+(1-y(i))x1(i)
+# * type=:cube takes y(i) independent, so children roughly within the hypercube spanned by the parents.
+# * type=:line takes y(i)=y(1), so children roughly on the line between the parents.
+# * <tt>exploration_alpha</tt> defines how far outside the hypercube/line spanned by the parents the children can be. (more specifically, y(i) = (1+2*alpha)*rand - alpha)
+def BlendingCrossover(exploration_alpha=0.1,type=:cube)
+  sz_rand = 1 + 2 * exploration_alpha
+  Module.new{
+    self.name = "BlendingCrossover(#{exploration_alpha},#{type})"
+    if(type==:cube) 
+      define_method(:cross){|parent1,parent2|
+        c1 = []; c2=[]; g1 = parent1.genes; g2 = parent2.genes
+        g1.each_with_index{|e,i|
+          y  = rand*sz_rand - exploration_alpha 
+          x2 = g2[i]
+          c1 << y*e  + (1-y)*x2
+          c2 << y*x2 + (1-y)*e
+        }
+        [c1,c2].map{|x| from_genes(x) }
+      }
+    elsif(type==:line) 
+      define_method(:cross){|parent1,parent2|
+        c1 = []; c2=[]; g1 = parent1.genes; g2 = parent2.genes
+        y  = rand*sz_rand - exploration_alpha 
+        g1.each_with_index{|e,i|
+          x2 = g2[i]
+          c1 << y*e  + (1-y)*x2
+          c2 << y*x2 + (1-y)*e
+        } 
+        [c1,c2].map{|x| from_genes(x) }
+      }
+    else 
+      raise ArgumentError,"Invalid BlendingCrossover type #{type}"
+    end
+  }
+end
+BlendingCrossover=BlendingCrossover()
 

data/lib/charlie/list/list_genotype.rb

@@ -8,7 +8,9 @@
 def FloatListGenotype(n,range=0..1)
  Class.new(Genotype) {
   @@range = range
-  define_method(:size){ n }
+  [self,metaclass].each{|c| c.class_eval{ # include both in class and metaclass
+   define_method(:size){ n }
+  }}
   def initialize
     @genes = Array.new(size){ rand * (@@range.end - @@range.begin) + @@range.begin }
   end
@@ -23,7 +25,9 @@ end
 # Individuals are initialized as an array of +n+ random bits.
 def BitStringGenotype(n)
  Class.new(Genotype) {
-  define_method(:size){ n }
+  [self,metaclass].each{|c| c.class_eval{ # include both in class and metaclass
+   define_method(:size){ n }
+  }}
   def initialize
     @genes = Array.new(size){ rand(2) }
   end

data/lib/charlie/list/matrix.rb

@@ -0,0 +1,121 @@
+
+
+
+# Generic ancestor for matrix genotypes
+def MatrixGenotype(rows,columns=rows)
+ Class.new(Genotype) {
+  [self,metaclass].each{|c| c.class_eval{
+   define_method(:rows)    { rows }
+   define_method(:columns) { columns }
+   define_method(:size)    { rows * columns }
+  }}
+  def genes=(g)
+    @genes = g.map(&:dup)
+  end
+  use MatrixUniformCrossover.dup
+ }
+end
+
+# Genotype for a 2D array of floats.
+def FloatMatrixGenotype(rows,columns=rows,range=0..1)
+ Class.new(MatrixGenotype(rows,columns)) {
+  @@range = range
+  def initialize
+    self.genes = Array.new(rows){ Array.new(columns){  rand * (@@range.end - @@range.begin) + @@range.begin } }
+  end
+  def to_s
+    @genes.inspect
+  end
+  use MatrixMutator()
+ }
+end
+
+# Genotype for a 2D array of bits, for example: connection matrices for graphs
+def BitMatrixGenotype(rows,columns=rows)
+ Class.new(MatrixGenotype(rows,columns)) {
+  def initialize
+    self.genes = Array.new(rows){ Array.new(columns){  rand(2) } }
+  end
+  def to_s
+    @genes.map{|r| r.map(&:to_s).join }.join("\n")
+  end
+  use MatrixMutator(:expected_n,:flip)
+ }
+end
+
+# Uniform crossover for matrices
+module MatrixUniformCrossover
+  def cross(parent1,parent2)
+    tc1 = []; tc2=[]
+    g1 = parent1.genes; g2 = parent2.genes
+    g1.each_with_index{|rg1,ri|
+      tc1 << (r1=[]); tc2 << (r2=[])
+      rg2 = g2[ri];
+      rg1.each_with_index{|e,i|
+        if rand(2).zero?
+          r1 << e; r2 << rg2[i]
+        else
+          r2 << e; r1 << rg2[i]
+        end
+      }
+    }
+    [tc1,tc2].map{|x| from_genes(x) }
+  end
+end
+
+# The mutation strategies for MatrixMutator
+# * :n_point[n=3] : Mutates a single element, n times.     Example: :n_point, :n_point[2]
+# * :probability[ p=0.05 ] : Mutates each element with probability p
+# * :expected_n[n=3]     : Mutates each element with probability n/genes.size, i.e. such that the expected # of mutations is n
+# * :expected_n_per_row[n=3], :expected_n_per_column[n=3] : Likewise
+MatrixMutationStrategies = {
+  :probability => MMSPRB = Proc.new{|genes,pointmut,p| 
+    p ||= 0.05
+    genes.map!{|r| r.map!{|e| rand < p ? pointmut.call(e) : e } }
+  },
+  :expected_n => Proc.new{|genes,pointmut,n|             n ||= 3
+    MMSPRB.call(genes,pointmut,n.to_f / (genes.size * genes[0].size))
+  },
+  :expected_n_per_row => Proc.new{|genes,pointmut,n|     n ||= 3
+    MMSPRB.call(genes,pointmut,n.to_f / genes[0].size)
+  },
+  :expected_n_per_column => Proc.new{|genes,pointmut,n|  n ||= 3
+    MMSPRB.call(genes,pointmut,n.to_f / genes.size)
+  },
+  :n_point => Proc.new{|genes,pointmut,n|
+    n ||= 3
+    s, r = genes.size, genes.rows;
+    n.times{ i,j = rand(s).divmod(r); genes[i][j] = pointmut.call(genes[i][j]) }
+  }
+}
+
+# Generates a module which can be used as a mutator for matrix-based genotypes like FloatMatrixGenotype and BitMatrixGenotype
+# * strategy      should be one of the MatrixMutationStrategies, or a proc
+# * point_mutator should be one of the PointMutators (like in ListMutator), or a proc
+# * nil is equivalent to proc{} for the point mutator
+def MatrixMutator(strategy=:expected_n ,point_mutator=:uniform)
+  strat, *strat_args = *strategy
+  pm   , *pm_args    = *point_mutator
+
+  pm ||= proc{}
+
+  strat = MatrixMutationStrategies[strat.intern] unless strat.is_a? Proc
+  pm    = PointMutators[pm.intern]         unless pm.is_a? Proc
+  
+  raise ArgumentError,"Invalid mutation strategy" if strat.nil?
+  raise ArgumentError,"Invalid point mutator"     if point_mutator.nil?
+
+  if pm_args.empty?
+    point_mutator_with_args = pm    
+  else
+    point_mutator_with_args = proc{|*args| pm.call(*(args+pm_args) ) }
+  end
+
+  Module.new{
+    define_method(:mutate!) {
+      strat.call(@genes,point_mutator_with_args,*strat_args)
+      self
+    }
+    self.name= "MatrixMutator(#{strategy.inspect},#{point_mutator.inspect})"
+  }
+end

data/lib/charlie/list/neural.rb

@@ -0,0 +1,52 @@
+# This file contains everything related to neural network genotypes
+
+# The tanh function is the default
+NN_TANH = proc{|x| Math.tanh x }
+# The sign function is also commonly used
+NN_SIGN = proc{|x| x>=0?1:-1 }
+
+# Genotype for neural networks with a single hidden layer.
+# * Inherits FloatListGenotype
+# * input_n, hidden_n, output_n are the number of neurons at each layer
+# * scaling determines how the floats in genes relate to the weights of the links (important for mutation size, initial values).
+#   * input to hidden  weights are (list element) multiplied by scaling / input_n
+#   * hidden to output weights are (list element) multiplied by scaling / hidden_n
+# * hidden_f, output_f are the (usually sigmoidal) functions to determine the output of nodes.
+#   * Output of hidden node i is  hidden_f( weights . input - threshold)
+# ----------------------------------------------------
+# functions of the returned class:
+# * output(input) - runs the neural network in some input
+def NeuralNetworkGenotype(input_n,hidden_n,output_n=1,scaling=1.0,hidden_f=NN_TANH,output_f=NN_TANH)
+  links_n = hidden_n * (input_n + output_n)
+  thr_n = hidden_n  + output_n
+  Class.new(FloatListGenotype(links_n+thr_n, -1..1 )) {
+    define_method(:output){|input|
+      raise ArgumentError unless input.size==input_n
+      si = scaling / input_n
+      sh = scaling / hidden_n
+
+      wts = genes
+      input = input.map{|i| i * si } # scale inputs instead of weights: same effect, but faster
+
+      hidden_val = Array.new(hidden_n,0.0)
+      output_val = Array.new(output_n,0.0)
+      (0...hidden_n).each{|i|
+        wi    = i * input_n
+        thr = wts[links_n + i]
+        v = 0.0
+        (0...input_n).each{|j| v += input[j] * wts[wi + j] }
+        hidden_val[i] = hidden_f.call(v - thr) * sh # again, scale this instead of hidden->output weights
+      }
+      oi = hidden_n * input_n
+      (0...output_n).each{|i|
+        wi = oi + i * hidden_n
+        thr = wts[links_n + hidden_n + i]
+        v = 0.0
+        (0...hidden_n).each{|j| v +=  hidden_val[j] * wts[wi + j] }
+        output_val[i] = output_f.call(v - thr)
+      }
+      output_val
+    }
+    use UniformCrossover.dup
+  }
+end