ga 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 161e6fb4eb2a3a87700d4f28cc470bb86b41c125
-  data.tar.gz: 84fe707139234f68d4d8b6b1f5361f57e1a78d85
+  metadata.gz: 2831b4e765ee161b47cbfd96efa977e635443047
+  data.tar.gz: '09022f90fcf17f9892e576534648b48f49703ab1'
 SHA512:
-  metadata.gz: 188f11a56b7cfbe1c4d0fa3a5ae523e5001864d506835d2d72c076855e656f6e75e393c238b9dcacb12d741e5ca89e8f645911078573e5855ed0df32a31733d0
-  data.tar.gz: 64515b0363b31205feba5f7e55ba458ccb810784241a0952b9221bef939c136bff8a048b8469cc9ae564bd20ff09e5022c47082bc3408ef5009d61b3f2b9f454
+  metadata.gz: b5a0c7db9d6a018b65816060a1da1d9544da8fe3dbc44ef06174797abec42e50e407ecfa1ba115b0763b0cb95ac6812df91ac34d2ecd7ae5a2562db539e4bc34
+  data.tar.gz: 335144415a50aef9a3afa65dfc5e71dbc3e67d0a4bc69592940c43357be95470f60c03706eb985f6dec145c07dc49b546761ca0cc6fd7a2a787170ca26326a46

data/.gitignore

@@ -6,7 +6,11 @@
 /doc/
 /pkg/
 /spec/reports/
+/spec/examples.txt
 /tmp/
 
 *.swp
 *.gem
+
+/examples/*.o
+/examples/*.so

data/Gemfile

@@ -4,4 +4,5 @@ source 'https://gems.ruby-china.org'
 gemspec
 
 gem 'parallel'
+gem 'ffi'
 

data/examples/01bag.rb

@@ -82,7 +82,9 @@ Benchmark.bm do |x|
   x.report('a') do
     puts 'start'
     100.times do
-      units = Unit.evolve(32, 100, 0.8, 0.15)
+      ga = Unit.new_ga_zoo
+      ga.elite_policy!
+      units = ga.evolve(20, 100, 0.8, 0.15)
       unit = units.max
       print unit.inspect + "\r"
       r[unit.fitness] ||= 0

data/examples/Makefile

@@ -0,0 +1,17 @@
+
+test: clean test.o robot_tester.o
+	g++ -o test test.o robot_tester.o
+	./test
+
+sharedlib: clean robot_tester.o
+	g++ -shared -Wall -o librt.so robot_tester.o
+
+clean:
+	rm -f *.o *.so test
+
+robot_tester.o: robot_tester.cpp
+	g++ -Wall -c robot_tester.cpp
+
+test.o: test.cpp
+	g++ -c test.cpp
+

data/examples/robot.rb

@@ -1,81 +1,35 @@
-require 'bundler/setup'
 require 'ga'
-
+require 'pry'
 require 'parallel'
+require 'ffi'
 
-MAP_SIZE = 7
-
-
-# 0 empty 1 dust 2 wall
-# [x][y]
-def new_map
-  MAP_SIZE.times.map { [0] * MAP_SIZE }
-end
-
-def rand_map(map, dust_rate = 0.5)
-  map.each do |cols|
-    cols.length.times {|i| cols[i] = rand() <= dust_rate ? 1 : 0 }
-  end
-end
-
-def show_map(map, bx = nil, by = nil)
-  puts('-' * 20)
-  MAP_SIZE.times do |y|
-    MAP_SIZE.times do |x|
-      if bx == x and by == y then
-        print(map[x][y], '* ')
-      else
-        print(map[x][y], '  ')
-      end
-    end
-    print("\n")
-  end
-  puts('-' * 20)
-end
-
-
-# 0 random move
-# 9 clear
-# 1 2 3
-# 4   5
-# 6 7 8
-ACTIONS_DATA = {
-  0 => nil,
-  9 => nil,
-
-  # 1 => [-1, -1],
-  2 => [0, -1],
-  # 3 => [1, -1],
-
-  4 => [-1, 0],
-  # 5 => [1, 0],
+system 'make sharedlib'
 
-  6 => [-1, 1],
-  # 7 => [0, 1],
-  8 => [1, 1]
-}
+# env:
+# '12001'
+#   1
+# 2 3 4
+#   5
 
-ACTIONS = ACTIONS_DATA.keys
-MOVE_ACTIONS = [2, 4, 6, 8]
+# actions:
+#   1
+# 2   3
+#   4
+# 1 2 3 4 move
+# 0 rand move
+# 5 clean
+ACTIONS = [0, 1, 2, 3, 4, 5]
 
 class Robot
   include GA
 
-  # genome
-  #
   # {env => action}
-  #
-  # env: '10122'
-  #     1
-  #   2 3 4
-  #     5
-  # action:
-
   attr_accessor :genome, :fitness
-  TOTAL_VALUE_TEST = 150
+  TOTAL_TEST_TIMES = 100
 
   def self.random_new
-    self.new({})
+    genome = {}
+    self.new(genome)
   end
 
   def initialize(genome)
@@ -83,37 +37,22 @@ class Robot
   end
 
   def fitness
-    tester = RobotTester.new(self)
-    @fitness ||= TOTAL_VALUE_TEST.times.map { tester.test }.reduce(&:+) / TOTAL_VALUE_TEST
-  end
-
-  def <=>(target)
-    fitness <=> target.fitness
+    @fitness ||= RobotTester.test(TOTAL_TEST_TIMES, 200, self)
   end
 
   def analyse_env(env)
-    @genome[env] ||= if env[2] == '1' then
-      9
-    elsif env == '00000' then
-      0
-    else
-      MOVE_ACTIONS.sample
-    end
+    @genome[env] ||= ACTIONS.sample
   end
 
   def cross!(target)
     all_genome = (genome.keys + target.genome.keys).uniq
     len = all_genome.length
-    min_robot = [self, target].min
 
-    rand(len).times do
+    (len / 4 + rand(len / 4)).times do
       gene = all_genome[rand(len)]
-
-      if genome[gene] == target.genome[gene] and rand() < 0.3 then
-        min_robot.genome[gene] = ACTIONS.sample
-      else
-        genome[gene], target.genome[gene] = target.genome[gene], genome[gene]
-      end
+      genome[gene] ||= ACTIONS.sample
+      target.genome[gene] ||= ACTIONS.sample
+      genome[gene], target.genome[gene] = target.genome[gene], genome[gene]
     end
   end
 
@@ -121,94 +60,43 @@ class Robot
     all_genome = genome.keys
     len = all_genome.length
 
-    (rand(len) + 1).times do
+    (len / 4 + rand(len / 2)).times do
       gene = all_genome[rand(len)]
-      genome[gene] = ACTIONS.sample
+      genome[gene] = (ACTIONS - [genome[gene]]).sample
     end
   end
 end
 
-class RobotTester
-  attr_reader :map, :robot
-
-  def initialize(robot)
-    @map = new_map
-    @robot = robot
-  end
+module RobotTester
+  extend FFI::Library
 
-  def test(step = 70, show = false)
-    rand_map(map)
-    x = rand(map.length)
-    y = rand(map.length)
-    @total_value = 0
-
-    step.times do
-      env = scan_env(x, y)
-      action = robot.analyse_env(env)
-      rx, ry = execute_action(x, y, action)
-
-      x += rx
-      y += ry
-
-      if x < 0 or y < 0 or x >= MAP_SIZE or y >= MAP_SIZE then
-        x -= rx
-        y -= ry
-        @total_value -= 10
-      elsif map[x][y] == 1
-        @total_value += 1
-      end
-
-      if show then
-        show_map(map, x, y)
-        sleep 0.2
-      end
-    end
+  ffi_lib File.expand_path('../librt.so', __FILE__)
+  callback :analyse_cb, [:string], :int
+  attach_function :robot_test, [:int, :int, :pointer, :pointer, :int, :analyse_cb], :int
 
-    @total_value
-  end
+  def self.test(times, step, robot)
+    genome = robot.genome
+    len = genome.length
+    env_pointer = FFI::MemoryPointer.new(:pointer, len)
+    action_pointer = FFI::MemoryPointer.new(:int, len)
 
-  def execute_action(x, y, action)
-    case action
-    when 9 then
-      if map[x][y] == 1 then
-        map[x][y] = 0
-        @total_value += 10
-      else
-        @total_value -= 10
-      end
-
-      [0, 0]
-    when 0 then
-      @total_value -= 1
-      ACTIONS_DATA[MOVE_ACTIONS.sample]
-    else
-      @total_value -= 1
-      ACTIONS_DATA[action]
-    end
-  end
+    eps = genome.keys.map {|k| FFI::MemoryPointer.from_string(k) }
+    env_pointer.write_array_of_pointer eps
+    action_pointer.write_array_of_int genome.values
 
-  SCAN_COORDS = [
-    [0, -1], [-1, 0], [0, 0], [1, 0], [0, 1]
-  ]
-  def scan_env(x, y)
-    SCAN_COORDS.map do |sx, sy|
-      rx = x + sx
-      ry = y + sy
-
-      if rx < 0 || ry < 0 || rx >= MAP_SIZE || ry >= MAP_SIZE then
-        2
-      else
-        map[rx][ry]
-      end
-    end.join
+    robot_test(
+      times, step,
+      env_pointer, action_pointer, len,
+      robot.method(:analyse_env)
+    )
   end
 end
 
-
 ga_zoo = Robot.new_ga_zoo
 ga_zoo.debug!
+# ga_zoo.cataclysm(10, 1)
 
-ga_zoo.before_init_fitness do |units|
+ga_zoo.before_init_fitness do |units, generation|
   vs = Parallel.map(units, in_processes: 8) do |unit|
     [unit.fitness, unit.genome]
   end
@@ -217,13 +105,14 @@ ga_zoo.before_init_fitness do |units|
   end
 end
 
-robots = ga_zoo.evolve(256, 300)
+srand(Time.now.to_i)
+robots = ga_zoo.evolve(200, 1000, 0.9, 0.2)
 robot = robots.max
 
-RobotTester.new(robot).test(100, true)
-
 puts "========= result ============="
 puts "fitness: #{robot.fitness}"
 puts robot.genome
-
+puts "score: %i" % RobotTester.test(1, 200, robot)
+binding.pry
+puts 'end'
 

data/examples/robot_tester.cpp

@@ -0,0 +1,150 @@
+#include "robot_tester.h"
+
+#include <cstdio>
+#include <cstdlib>
+#include <ctime>
+#include <unistd.h>
+
+RobotTester::RobotTester(int map_size, env_map* p_em) {
+  size = map_size;
+  p_env_action = p_em;
+  map = new int*[size];
+  x = 0; y = 0;
+  for (int i = 0; i < size; i++) {
+    map[i] = new int[size];
+  }
+}
+
+RobotTester::~RobotTester() {
+  for (int i = 0; i < size; i++) {
+    delete map[i];
+  }
+}
+
+int RobotTester::test(int step, analyse_callback cb, bool play = false) {
+  int score = 0;
+  char env[6] = {0, 0, 0, 0, 0, 0};
+  int action;
+  env_map::iterator em_itor;
+  x = 0; y = 0;
+
+  rand_map();
+
+  for (int i = 0; i < step; i++) {
+    scan_env(env);
+    em_itor = p_env_action->find(env);
+    if (em_itor != p_env_action->end()) {
+      action = em_itor->second;
+    } else {
+      action = cb(env);
+      p_env_action->insert(env_map::value_type(env, action));
+    }
+
+    score = score + execute_action(action == 0 ? (rand() % 4 + 1) : action);
+    if (play) {
+      show_map();
+      usleep(100 * 1000);
+    }
+  }
+
+  return score;
+}
+
+void RobotTester::rand_map() {
+  for (int i = 0; i < size; i++) {
+    for (int j = 0; j < size; j++) {
+      map[i][j] = rand() % 2;
+    }
+  }
+}
+
+const int scan_len = 5;
+const int scan_points[scan_len][2] = {
+  {0, -1},
+  {-1, 0}, {0, 0}, {1, 0},
+  {0, 1}
+};
+void RobotTester::scan_env(char* env) {
+  int sx, sy;
+  for (int i = 0; i < scan_len; i++) {
+    sx = x + scan_points[i][0];
+    sy = y + scan_points[i][1];
+
+    if (sx < 0 || sx >= size || sy < 0 || sy >= size) {
+      env[i] = '2';
+      continue;
+    }
+    env[i] = char(map[sx][sy] + 48);
+  }
+}
+
+void RobotTester::show_map() {
+  for (int i = 0; i < size; i++) {
+    for (int j = 0; j < size; j++) {
+      printf(" %i%c", map[j][i], (x == j and y == i) ? '*' : ' ');
+    }
+    printf("\n");
+  }
+  printf("\n");
+}
+
+// 1 2 3 4 move
+// 5 take
+//   1
+// 2 5 3
+//   4  
+const int actions[5][2] = {
+  {0, 0}, {0, -1}, {-1, 0}, {1, 0}, {0, 1}
+};
+int RobotTester::execute_action(int action) {
+  switch(action) {
+  case 5: {
+    if (map[x][y] == 1) {
+      map[x][y] = 0;
+      return 10;
+    } else {
+      return -1;
+    }
+  }
+  case 1:
+  case 2:
+  case 3:
+  case 4: {
+    int mx = x + actions[action][0];
+    int my = y + actions[action][1];
+    if (mx < 0 || mx >= size || my < 0 || my >= size) {
+      return -5;
+    } else {
+      x = mx; y = my;
+      return 0;
+    }
+  }
+  default:
+    printf("Invalid action %i\n", action);
+    throw("Invalid action\n");
+  }
+}
+
+typedef std::unordered_map<std::string, short> env_map;
+
+
+extern "C" {
+  int robot_test(int times, int step, char** envs, short* actions, int elen, analyse_callback cb) {
+    srand(time(0));
+
+    env_map emap;
+    for (int i = 0; i < elen; i++) {
+      emap.insert(env_map::value_type(envs[i], actions[i]));
+    }
+
+    RobotTester rt = RobotTester(10, &emap);
+    int total_score = 0;
+    
+    for (int i = 0; i < times; i++) {
+      total_score = total_score + rt.test(step, cb, times == 1);
+    }
+
+    return total_score / times;
+  }
+}
+

data/examples/robot_tester.h

@@ -0,0 +1,36 @@
+#ifndef  ROBOT_TESTER_H
+#define ROBOT_TESTER_H
+
+#include <unordered_map>
+#include <string>
+
+typedef int(*analyse_callback)(const char* const);
+typedef std::unordered_map<std::string, short> env_map;
+
+class RobotTester {
+public:
+  RobotTester(int, env_map*);
+  ~RobotTester();
+  int test(int, analyse_callback, bool play);
+
+  void rand_map();
+  void show_map();
+
+private:
+  env_map* p_env_action;
+  int size;
+  int **map;
+  int x;
+  int y;
+
+  void scan_env(char[5]);
+  int execute_action(int);
+};
+
+
+extern "C" {
+  int robot_test(int times, int step, char** envs, short* action, int elen, analyse_callback);
+}
+
+#endif
+

data/examples/test.cpp

@@ -0,0 +1,35 @@
+#include "robot_tester.h"
+
+#include <cstdio>
+#include <cstdlib>
+
+#include <unordered_map>
+#include <string>
+
+int analyse_env(const char* const env) {
+  return rand() % 6;
+}
+
+typedef std::unordered_map<std::string, short> env_hash;
+
+int main() {
+  env_hash eh;
+  int step = 200;
+  int times = 200;
+
+  printf("'robot_test' avg score: %i\n", robot_test(times, step, NULL, NULL, 0, analyse_env));
+
+  RobotTester rt = RobotTester(10, &eh);
+  int total_score = 0;
+  printf("env_hash size: %i\n", (int)eh.size());
+    
+  for (int i = 0; i < times; i++) {
+    total_score = total_score + rt.test(step, analyse_env, false);
+  }
+
+  printf("env_hash size: %i\n", (int)eh.size());
+  printf("'RobotTester#test' avg score: %i\n", total_score / times);
+
+  return 0;
+}
+

data/lib/ga/version.rb

@@ -1,3 +1,3 @@
 module GA
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

data/lib/ga/zoo.rb

@@ -1,21 +1,27 @@
 module GA
   class Zoo
-    attr_reader :unit_cls
+    attr_reader :unit_cls, :before_fitness_callback, :after_select_callback
 
     def initialize(unit_cls)
       @unit_cls = unit_cls
       @debug = false
       @before_fitness_callback = nil
+      @after_select_callback = nil
+      @elite_policy = false
+      @select_sample = 2
     end
 
     def evolve(units = 32, generations = 100, crossover_rate = 0.8, mutation_rate = 0.15)
       units = units.times.map { unit_cls.random_new } if units.is_a?(Fixnum)
+      @start_at = Time.now
 
       generations.times do |i|
         @before_fitness_callback.call(units, i + 1) if @before_fitness_callback
         output_debug_info(units, generations, i + 1) if @debug
 
         units = select_units(units)
+        @after_select_callback.call(units, i + 1) if @after_select_callback
+
         cross(units, crossover_rate)
         mutate(units, mutation_rate)
       end
@@ -27,25 +33,40 @@ module GA
       @debug = true
     end
 
+    def set_select_sample(val)
+      @select_sample = val
+    end
+
+    def elite_policy!
+      @elite_policy = true
+    end
+
     def before_init_fitness(&block)
       @before_fitness_callback = block
     end
 
+    def after_select(&block)
+      @after_select_callback = block
+    end
+
 
     private
 
     def select_units(units)
       new_units = units.map do
-        ou = units.sample(3).max
+        ou = units.sample(@select_sample).max
         unit_cls.new(ou.genome).tap {|u| u.fitness = ou.fitness }
       end
 
-      # Elite policy
-      min_index = new_units.index(new_units.min)
-      if min_index != 0 then
-        new_units[min_index], new_units[0] = new_units[0], new_units[min_index]
+      if @elite_policy
+        min_index = new_units.index(new_units.min)
+        if min_index != 0 then
+          new_units[min_index], new_units[0] = new_units[0], new_units[min_index]
+        end
+        max_unit = units.max
+        new_units[0] = unit_cls.new(max_unit.genome)
       end
-      new_units[0] = unit_cls.new(units.max.genome)
+
       new_units
     end
 
@@ -53,7 +74,7 @@ module GA
       last_index = nil
 
       units.each_with_index do |unit, index|
-        next if index == 0
+        next if @elite_policy && index == 0
         next if rand() >= rate
 
         if last_index
@@ -69,7 +90,7 @@ module GA
 
     def mutate(units, rate)
       units.each_with_index do |unit, index|
-        next if index == 0
+        next if @elite_policy && index == 0
         next if rand() >= rate
         unit.mutate!
         # recalculate fitness
@@ -80,6 +101,7 @@ module GA
     def output_debug_info(units, generations, generation)
       units.sort!
       info = [
+        "[#{(Time.now - @start_at).to_f}]",
         "GA-#{generation}/#{generations} #{units.count}-#{units[-1].genome.length}",
         ' fitness: '
       ]
@@ -88,6 +110,7 @@ module GA
         info << units.map(&:fitness).join(', ')
       else
         info << "#{units[0..2].map(&:fitness).join(', ')}"
+        info << " ... #{units[units.length / 2].fitness}"
         info << " ... #{units[-5..-1].map(&:fitness).join(', ')}"
       end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ga
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - jiangzhi.xie
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-02-23 00:00:00.000000000 Z
+date: 2017-03-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -83,7 +83,11 @@ files:
 - bin/console
 - bin/setup
 - examples/01bag.rb
+- examples/Makefile
 - examples/robot.rb
+- examples/robot_tester.cpp
+- examples/robot_tester.h
+- examples/test.cpp
 - ga.gemspec
 - lib/ga.rb
 - lib/ga/version.rb