charlie 0.6.0 → 0.7.0

data/examples/{money.rb → permutation.rb}

@@ -1,5 +1,10 @@
+begin
+  require '../lib/charlie'
+rescue LoadError
+  require 'rubygems'
+  require 'charlie'
+end
 
-require '../lib/charlie'
 
 module MoneyBase
   def words
@@ -17,19 +22,26 @@ module MoneyBase
   end
 end
 
-# send+more=money problem as a string genotype
+puts "send+more=money problem as a permutation genotype"
+
+class MoneyP < PermutationGenotype(10) # send+more=money problem as a permutation
+  include MoneyBase
+end
+
+Population.new(MoneyP).evolve_on_console
+
+
+=begin
+# can also be done with StringGenotype, more effectively too.
 # remember, string genotypes are just arrays with elements from some set, not necessarily chars.
+
 class Money < StringGenotype(8,0..9) 
   include MoneyBase
   def fitness # no permutation, so need to have a penalty for reusing chars
     super - 100*(8 - genes.uniq.size)
   end
 end
-Population.new(Money).evolve_on_console
-
-class MoneyP < PermutationGenotype(10) # send+more=money problem as a permutation
-  include MoneyBase
-end
 
-Population.new(MoneyP).evolve_on_console
+Population.new(Money).evolve_on_console
 
+=end

data/examples/string.rb

@@ -0,0 +1,98 @@
+begin
+  require '../lib/charlie'
+rescue LoadError
+  require 'rubygems'
+  require 'charlie'
+end
+
+
+if ARGV[0].nil?
+  puts "Several examples for string genotypes."
+  puts "Usage: ruby string.rb weasel|gridwalk"
+
+
+
+
+elsif ARGV[0].downcase.gsub(/[^a-z]/,'') == 'weasel'
+
+
+
+
+STR = 'methinks it is like a weasel'
+Schars = ('a'..'z').to_a << ' '
+
+puts "A version of the weasel program. Fitness is # of characters that match '#{STR}'."
+puts "Useful as a simple test for convergence speed."
+
+
+class Weasel <  StringGenotype(STR.size,Schars)
+  def fitness
+    genes.zip(STR.chars).find_all{|a,b|a==b}.size
+  end
+
+  def to_s
+    genes.join.inspect
+  end
+  use BestOnlySelection, UniformCrossover, ListMutator(:single_point,:replace[*Schars])
+end
+
+Population.new(Weasel).evolve_on_console(200)
+
+
+output_file = 'output/string_weasel.html'
+
+puts "Running benchmark. Takes about a minute on Ruby 1.9. Output in #{output_file}"
+puts "Press [Enter] to continue, or Ctrl-C to abort."
+STDIN.gets
+
+GABenchmark.benchmark(Weasel,output_file){
+  selection TruncationSelection(0.2), BestOnlySelection, Elitism(ScaledRouletteSelection)
+  crossover NullCrossover, SinglePointCrossover, UniformCrossover
+  mutator   *(1..4).map{|n| ListMutator(:n_point[n],:replace[*Schars]) }
+  generations  100
+}
+
+
+
+
+
+elsif ARGV[0].downcase.gsub(/[^a-z]/,'') == 'gridwalk'
+
+
+
+
+
+
+puts "This example tries to find a tour through a grid, in such a way that each square is visited only once."
+puts "Often needs to restart multiple times, each time getting stuck in a local maximum, before finding the full solution."
+
+DIRS = [[-1,0],[1,0],[0,-1],[0,1]]
+class Walk <  StringGenotype(25,DIRS)  # Walk with steps in 4 directions
+
+  def fitness 
+    grid = Array.new(5){Array.new(5)}
+    x,y=0,0
+    genes.each{|dx,dy|
+      grid[x][y] = :visited
+      nx,ny = x+dx,y+dy
+      x,y=nx,ny if (0..4)===nx && (0..4)===ny && grid[nx][ny].nil? # on grid and haven't been there before
+    }
+    grid[x][y] = :visited
+    grid.flatten.compact.size
+  end
+  use TournamentSelection(4)
+end
+
+# multiple runs of 100 generations until a solution is found. This is better for problems that get stuck in local maxima a lot
+pop = gen = nil
+loop{
+  pop, gen = Population.new(Walk,20).evolve_until(100){|b| b.fitness == 25 } 
+  break if gen
+  puts "Did not converge in 100 generations, length = #{pop.max.fitness}/25"
+}
+puts 'Found walk of length 25:', pop[-1].genes.inspect
+
+
+
+
+end

data/examples/tree.rb

@@ -1,28 +1,44 @@
+begin
+  require '../lib/charlie'
+rescue LoadError
+  require 'rubygems'
+  require 'charlie'
+end
 require 'pp'
-require '../lib/charlie'
 
 # several examples of genetic programming
 
 if ARGV[0]=='cos'
 
+$size_fac = 0.0
 # approximate cos(x) by a polynomial.on [0,3]. usually results in some kind of linear approximation.like 1.3-0.8x
-class Cos < TreeGenotype([proc{3*rand-1.5},:x], [:+,:*,:-], [:-@])
+class Cos < TreeGenotype([proc{3*rand-1.5},:x], [:-@], [:+,:*,:-])
   def fitness
-   -(0..10).map{|x| (eval_genes(:x=>0.3*x) - Math.cos(0.3 * x) ).abs }.sum - 0.1*size  # last term used to counter bloat
+   #-(0..10).map{|x| (eval_genes(:x=>0.3*x) - Math.cos(0.3 * x) ).abs }.sum - 0.1*size  # last term used to counter bloat
    # also possible, use infinity norm instead of L1 norm
    #-(0..10).map{|x| (eval_genes(:x=>0.3*x) - Math.cos(0.3 * x) ).abs }.max
 
    # smaller range [0,1.5] and inf norm give higher order approximations
-   #-(0..10).map{|x| (eval_genes(:x=>0.1*x) - Math.cos(0.1 * x) ).abs }.max
+   -(0..10).map{|x| (eval_genes(:x=>0.1*x) - Math.cos(0.1 * x) ).abs }.max
   end
+  use PMutate(0.5,TreeReplaceMutator.dup,TreeNumTerminalMutator.dup)
 end
 
-pop = Population.new(Cos).evolve_on_console(500)
-pp pop.max.genes
+pop = Population.new(Cos)
+
+loop{
+ pop.evolve_on_console(500)
+ pp pop.best.genes
+ puts "q to quit, enter to continue"
+ break if $stdin.gets =~ /q/
+}
+
+
 
 elsif ARGV[0]=='pors'
 
-# plus one recall store, generate the number ARGV[1] || 32 using +, 1 and recall/store operations (as few ops as possible).
+
+# plus one recall store, generate the number ARGV[1] || 31 using +, 1 and recall/store operations (as few ops as possible).
 
 class Fixnum
   def sto
@@ -30,7 +46,7 @@ class Fixnum
   end
 end
 
-class PORS < TreeGenotype([1,:rec], [:+], [:sto])
+class PORS < TreeGenotype([1,:rec], [:sto], [:+])
   N = (ARGV[1] || 32).to_i
   def fitness
     $pors_store = 0 # reset store
@@ -41,8 +57,13 @@ end
 pop = Population.new(PORS).evolve_on_console(500)
 pp pop.max.genes
 
+# n=31  1 + sto(sto(sto(1+1) + rec + 1) + rec + rec) + rec        , size 18
+
+
 elsif ARGV[0]=='porsx'
 
+
+
 # variant on pors, multiply T by some N, with only one access to T allowed
 
 class Fixnum
@@ -51,7 +72,7 @@ class Fixnum
   end
 end
 
-class PORS < TreeGenotype([:rec,:T], [:+], [:sto])
+class PORS < TreeGenotype([:rec,:T], [:sto], [:+])
   N = (ARGV[1] || 31).to_i #  quite complicated optimal tree for 31
   def fitness
     -(0..5).map{|t| 
@@ -73,8 +94,11 @@ pp pop.max.genes
 
 
 elsif ARGV[0]=='bloat'
+
+
+
 # just generates huge trees.
-class Bloat < TreeGenotype([1], [:+], [:+@])
+class Bloat < TreeGenotype([1], [:+@], [:+])
   def fitness
     size
   end
@@ -86,5 +110,6 @@ end
 pop = Population.new(Bloat).evolve_on_console(200)
 
 else
-  puts "choose a test :  cos, pors, porsx, bloat"
-end
+  puts "Several examples for tree genotypes."
+  puts "Usage: ruby tree.rb cos|pors|porsx|bloat"
+end

data/examples/tsp.rb

@@ -1,15 +1,14 @@
-require '../lib/charlie'
-# Travelling salesperson problem
-
-N=5
-
-# N cities in a circle
-#CITIES = (0...N).map{|i| th = i * 2 * Math::PI / N; [Math.cos(th),Math.sin(th)] }
+begin
+  require '../lib/charlie'
+rescue LoadError
+  require 'rubygems'
+  require 'charlie'
+end
 
-# .. or on a line
-#CITIES = (0...N).map{|i| [0,i] }  
+puts "Travelling salesperson problem."
 
-# .. or NxN cities on a grid
+N=7
+# NxN cities on a grid
 CITIES = (0...N).map{|i| (0...N).map{|j| [i,j] } }.inject{|a,b|a+b}
 
 class TSP < PermutationGenotype(CITIES.size)
@@ -21,22 +20,35 @@ class TSP < PermutationGenotype(CITIES.size)
      }
     -d # higher (less negative) fitness is better. This breaks RouletteSelection (use 1.0/d instead), but most other methods can handle this
   end
+  use TournamentSelection(4), PCross(0.01,EdgeRecombinationCrossover), PMutateN(InversionMutator=>0.4,InsertionMutator=>0.4)
+ 
   cache_fitness # benchmark ~ 20% faster, tournament selection 25+% faster
 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?
+puts "Fitness: #{pop.max.fitness}"
+puts "Generations needed: #{gen.inspect}"
+p pop.max.genes.map{|a| CITIES[a]}
+
+
+puts "Running benchmark. Output in output/tsp.html. Takes about 50 minutes on Ruby 1.9."
+puts "Press [Enter] to continue, or Ctrl-C to abort."
+STDIN.gets
 
-pop = Population.new(TSP,20).evolve_on_console(50)
-#p pop[-1].genes.map{|a| CITIES[a]}
-# 49              -6.18033988749895               [2, 3, 4, 5, 6, 7, 8, 9, 0, 1]  for the circle
+GABenchmark.benchmark(TSP,'output/tsp.html') {
+  selection TruncationSelection(1), Elitism(ScaledRouletteSelection), TournamentSelection(4)
+  crossover EdgeRecombinationCrossover, PermutationCrossover,
+            PCross(0.5,EdgeRecombinationCrossover,PermutationCrossover),
+            PCross(0.01,EdgeRecombinationCrossover), NullCrossover 
 
+  mutator   TranspositionMutator, InversionMutator, InsertionMutator,
+            PMutateN(InversionMutator=>0.4,InsertionMutator=>0.4),
+            PMutateN(InversionMutator=>0.4,InsertionMutator=>0.4,RotationMutator=>0.2)
 
-Population.benchmark(TSP,'output/tsp.html') {
-  selection TruncationSelection(1), TruncationSelection(0.3), Elitism(ScaledRouletteSelection,1), TournamentSelection(4), TournamentSelection(3)
-  crossover EdgeRecombinationCrossover, PermutationCrossover, PCross(0.5,PermutationCrossover),                                NullCrossover, PCross(0.5,EdgeRecombinationCrossover,PermutationCrossover)
-  mutator   PermutationMutator, PMutate(0.5,PermutationMutator),
-            InversionMutator, PMutate(0.5,InversionMutator,PermutationMutator)
-  self.generations = 30
-  self.repeat = 25
-  self.population_size = 20
-} if ARGV[0]=='bm' # takes about 7 minutes on ruby 1.9. lower the repeat number for a quicker run
+  generations      400
+  repeat           8
+  population_size  20
+}
 

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.6.0'
+  VERSION = '0.7.0'
 end
 
 require 'charlie/etc/monkey'
@@ -28,5 +28,9 @@ require 'charlie/permutation/permutation'
 
 require 'charlie/tree/tree'
 
+require 'charlie/gabenchmark'
 
+if RUBY_VERSION >= '1.9'
+  require 'charlie/1.9fixes'
+end
 

data/lib/charlie/1.9fixes.rb

@@ -0,0 +1,46 @@
+#1.9 versions of some functions, to avoid bug #16493. 
+#TODO: remove on bugfix/1.9.1
+
+
+
+def Elitism(sel_module,elite_n=1) # :nodoc:
+ ng_name = sel_module.to_s.gsub(/[^A-Za-z0-9]/,'_')
+ Module.new{
+  include sel_module
+  alias_method ng_name, :next_generation
+  @@elite_n = elite_n
+  define_method :next_generation, ->(population,&block){
+    population = population.sort_by(&:fitness)
+    best = population[-@@elite_n..-1]
+    population = send(ng_name,population,&block)
+    # 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
+  }
+  self.name= "Elitism(#{sel_module.to_s},#{elite_n})"
+ }
+end
+
+
+def SingleChild(crossover_module) # :nodoc:
+  crs_name =  '_cross_' + crossover_module.to_s.gsub(/[^A-Za-z0-9]/,'')
+  Module.new{
+    include crossover_module
+    alias_method crs_name, :cross
+
+    define_method(:cross){|*args| send(crs_name,*args).at_rand }
+    self.name= "SingleChild(#{crossover_module})"
+  }
+end
+
+module Enumerable
+  undef_method :sum
+  def sum # faster than both r=0; each; r and {|a,b|a+b}
+    inject(0,:+)
+  end
+
+  undef_method :zip_with
+  def zip_with(a2) # avoid Enumerable#zip in 1.9
+    r=[]; each_with_index{|e,i| r << yield(e,a2[i]) }; r
+  end
+end

data/lib/charlie/crossover.rb

@@ -23,27 +23,44 @@ end
 
 # Takes crossover c1 with probability p, and crossover c2 with probability 1-p
 def PCross(p,c1,c2=NullCrossover)
+  return c1 if c1==c2
+  c1_name, c2_name = [c1,c2].map{|c| '_cross_' + c.to_s.gsub(/[^A-Za-z0-9]/,'') }
   Module.new{
-    @@p = p
-    include c2
-    alias :cross2 :cross
-    include c1
-    def cross(*args)
-      rand < @@p ? super(*args) : cross2(*args)
-    end
+    include c1.dup # dup to avoid bugs on use PCross(..,c1) .. use c1
+    alias_method c1_name, :cross
+    include c2.dup
+    alias_method c2_name, :cross
+
+    define_method(:cross) {|*args|
+      rand < p ? send(c1_name,*args) : send(c2_name,*args)
+    }
     self.name= "PCross(#{p},#{c1},#{c2})"
   }
 end
 
-=begin
-#a bit nicer, but needs parent1.class.from_genes(x) everywhere instead of just from_genes(x)
-def PCross(p,c1,c2=NullCrossover)
-  [c1,c2].each{|m| m.module_eval{extend self} }
+# Variant of PCross for more than 2 crossovers.
+# * Pass a hash of Module=>probability pairs. If sum(probability) < 1, NullCrossover will be used for the remaining probability.
+# * example: PCrossN(SinglePointCrossover=>0.33,UniformCrossover=>0.33) for NullCrossover/SinglePointCrossover/UniformCrossover all with probability 1/3
+def PCrossN(hash)
+  tot_p = hash.inject(0){|s,(m,p)| s+p }
+  if (tot_p - 1.0).abs > 0.01 # close to 1?
+    raise ArgumentError, "PCrossN: sum of probabilities > 1.0" if tot_p > 1.0
+    hash[NullCrossover] = (hash[NullCrossover] || 0.0) + (1.0 - tot_p)
+  end
+  partial_sums = hash.sort_by{|m,p| -p } # max probability first
+  s = 0.0
+  partial_sums.map!{|m,p| ['_cross_' + m.to_s.gsub(/[^A-Za-z0-9]/,'') , s+=p, m] }
+
   Module.new{
+    partial_sums.each{|name,p,mod|
+      include mod.dup
+      alias_method name, :cross
+    }
     define_method(:cross) {|*args|
-      (rand < p ? c1 : c2).cross(*args)
+      r = rand
+      c_name = partial_sums.find{|name,p,mod| p >= r }.first
+      send(c_name,*args)
     }
-    self.name= "PCross(#{p},#{c1},#{c2})"
+    self.name= "PCrossN(#{hash.inspect})"
   }
 end
-=end

data/lib/charlie/etc/minireport.rb

@@ -16,7 +16,7 @@ class Table < Array
   def to_html
     "<table>\n" +
       "<tr>" + @colnames.map{|t| "<th>#{t}</th>" }.join + "</tr>\n" +
-	map{|r| "<tr>\n" + r.map{|e| "\t<td>#{e.gsub('<','&lt;')}</td>\n"  }.join + "</tr>\n" }.join +
+	map{|r| "<tr>\n" + r.map{|e| "\t<td>#{e.gsub('<','&lt;').gsub("\r\n",'<br>')}</td>\n"  }.join + "</tr>\n" }.join +
     "</table>"
   end
 
@@ -25,12 +25,13 @@ class Table < Array
   end
 
   def to_s(csz=nil)
-    rsz = at(0).size    
-    csz ||= [(80-rsz) / rsz]*rsz
+    console_size = 80
+    rsz = at(0).size
+    csz ||= [(console_size-rsz) / rsz]*rsz
     pad = ' ' * csz.max
     sep = csz.map{|x|'-'*x}.join('+')
     ([sep,@colnames.zip_with(csz){|str,sz| (str+pad)[0...sz] }.join('|'),sep]+
-    map{|r| r.zip_with(csz){|str,sz| (str+pad)[0...sz] }.join('|') } << sep).join("\n")
+    map{|r| r.zip_with(csz){|str,sz| (str.gsub("\r\n","\\")+pad)[0...sz] }.join('|') } << sep).join("\n")
   end
 
 end