mhl 0.2.0 → 0.3.0

data/lib/mhl/real_vector_genotype_space.rb

@@ -0,0 +1,142 @@
+module MHL
+
+  # This class implements a genotype with real space representation
+  class RealVectorGenotypeSpace
+    def initialize(opts, logger)
+      @random_func = opts[:random_func]
+
+      @dimensions = opts[:dimensions].to_i
+      unless @dimensions and @dimensions > 0
+        raise ArgumentError, 'The number of dimensions must be a positive integer!'
+      end
+
+      # TODO: enable to choose which recombination function to use
+      case opts[:recombination_type].to_s
+      when /intermediate/i
+        @recombination_func = :extended_intermediate_recombination
+      when /line/i
+        @recombination_func = :extended_line_recombination
+      else
+        raise ArgumentError, 'Recombination function must be either line or intermediate!'
+      end
+
+      @constraints = opts[:constraints]
+      if !@constraints or @constraints.size != @dimensions
+        raise ArgumentError, 'Real-valued GA variants require constraints!'
+      end
+
+      @logger = logger
+    end
+
+    def get_random
+      if @random_func
+        @random_func.call
+      else
+        if @constraints
+          @constraints.map{|x| x[:from] + SecureRandom.random_number(x[:to] - x[:from]) }
+        else
+          raise 'Automated random genotype generation when no constraints are provided is not implemented yet!'
+        end
+      end
+    end
+
+    # reproduction with power mutation and line or intermediate recombination
+    def reproduce_from(p1, p2, mutation_rv, recombination_rv)
+      # make copies of p1 and p2
+      # (we're only interested in the :genotype key)
+      c1 = { genotype: p1[:genotype].dup }
+      c2 = { genotype: p2[:genotype].dup }
+
+      # mutation comes first
+      power_mutation(c1[:genotype], mutation_rv)
+      power_mutation(c2[:genotype], mutation_rv)
+
+      # and then recombination
+      send(@recombination_func, c1[:genotype], c2[:genotype], recombination_rv)
+
+      if @constraints
+        repair_chromosome(c1[:genotype])
+        repair_chromosome(c2[:genotype])
+      end
+
+      return c1, c2
+    end
+
+
+    private
+
+      # power mutation [DEEP07]
+      # NOTE: this mutation operator won't work unless constraints are given
+      def power_mutation(parent, mutation_rv)
+        s = mutation_rv.next ** 10.0
+
+        min = @constraints.map{|x| x[:from] }
+        max = @constraints.map{|x| x[:to] }
+
+        parent.each_index do |i|
+          t_i = (parent[i] - min[i]) / (max[i]-min[i])
+
+          if rand() >= t_i
+            # sometimes the variation will be positive ...
+            parent[i] += s * (max[i] - parent[i])
+          else
+            # ... and sometimes it will be negative
+            parent[i] -= s * (parent[i] - min[i])
+          end
+        end
+      end
+
+      # extended intermediate recombination [MUHLENBEIN93] (see [LUKE15] page 42)
+      def extended_intermediate_recombination(g1, g2, recombination_rv)
+        # TODO: disable this check in non-debugging mode
+        raise ArgumentError, 'g1 and g2 must have the same dimension' unless g1.size == g2.size
+
+        # recombination
+        g1.each_index do |i|
+          begin
+            alpha = recombination_rv.next
+            beta  = recombination_rv.next
+            t = alpha * g1[i] + (1.0 - alpha) * g2[i]
+            s =  beta * g2[i] + (1.0 -  beta) * g1[i]
+          end
+          g1[i] = t
+          g2[i] = s
+        end
+      end
+
+      # extended line recombination [MUHLENBEIN93] (see [LUKE15] page 42)
+      def extended_line_recombination(g1, g2, recombination_rv)
+        # TODO: disable this check in non-debugging mode
+        raise ArgumentError, 'g1 and g2 must have the same dimension' unless g1.size == g2.size
+
+        alpha = recombination_rv.next
+        beta  = recombination_rv.next
+
+        # recombination
+        g1.each_index do |i|
+          t = alpha * g1[i] + (1.0 - alpha) * g2[i]
+          s =  beta * g2[i] + (1.0 -  beta) * g1[i]
+          g1[i] = t
+          g2[i] = s
+        end
+      end
+
+      def repair_chromosome(g)
+        g.each_index do |i|
+          if g[i] < @constraints[i][:from]
+            range = "[#{@constraints[i][:from]},#{@constraints[i][:to]}]"
+            @logger.debug "repairing g[#{i}] #{g[i]} to fit within #{range}" if @logger
+            g[i] = @constraints[i][:from]
+            @logger.debug "g[#{i}] repaired as: #{g[i]}" if @logger
+          elsif g[i] > @constraints[i][:to]
+            range = "[#{@constraints[i][:from]},#{@constraints[i][:to]}]"
+            @logger.debug "repairing g[#{i}] #{g[i]} to fit within #{range}" if @logger
+            g[i] = @constraints[i][:to]
+            @logger.debug "g[#{i}] repaired as: #{g[i]}" if @logger
+          end
+        end
+      end
+
+  end
+
+end

data/lib/mhl/rechenberg_controller.rb

@@ -0,0 +1,49 @@
+module MHL
+  class RechenbergController
+
+    DEFAULT_THRESHOLD = 1.0/5.0
+    TAU = 1.10
+    P_M_MAX = 0.99
+    P_M_MIN = 0.01
+
+    attr_reader :threshold, :generations
+
+    def initialize(generations=5, threshold=DEFAULT_THRESHOLD, logger=nil)
+      unless threshold > 0.0 and threshold < 1.0
+        raise ArgumentError, "The threshold parameter must be in the (0.0,1.0) range!"
+      end
+      @generations = generations
+      @threshold   = threshold
+      @logger      = logger
+      @history     = []
+    end
+
+    def call(solver, best)
+      @history << best
+
+      if @history.size > @generations
+        # calculate improvement ratio
+        res = @history.each_cons(2).inject(0) {|s,x| s += 1 if x[1][:fitness] > x[0][:fitness]; s } / (@history.size - 1).to_f
+        if res > @threshold
+          # we had enough improvements - decrease impact of mutation
+          # increase mutation probability by 5% or to P_M_MAX
+          old_p_m = solver.mutation_probability
+          new_p_m = [ old_p_m * TAU, P_M_MAX ].min
+          @logger.info "increasing mutation_probability from #{old_p_m} to #{new_p_m}" if @logger
+          solver.mutation_probability = new_p_m
+        else
+          # we didn't have enough improvements - increase impact of mutation
+          # decrease mutation probability by 5% or to P_M_MAX
+          old_p_m = solver.mutation_probability
+          new_p_m = [ old_p_m / TAU, P_M_MIN ].max
+          @logger.info "decreasing mutation_probability from #{old_p_m} to #{new_p_m}" if @logger
+          solver.mutation_probability = new_p_m
+        end
+
+        # reset
+        @history.shift(@history.size-1)
+      end
+    end
+  end
+
+end

data/lib/mhl/version.rb

@@ -1,3 +1,3 @@
 module MHL
-  VERSION = '0.2.0'
+  VERSION = '0.3.0'
 end

data/mhl.gemspec

@@ -20,8 +20,11 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency 'bitstring'
   spec.add_dependency 'concurrent-ruby', '~> 1.0'
-  spec.add_dependency 'erv'
+  spec.add_dependency 'erv', '>= 0.3.4'
 
   spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'dotenv', '~> 2.5.0'
   spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'minitest'
+  spec.add_development_dependency 'minitest-spec-context', '~> 0.0.3'
 end

data/test/mhl/genetic_algorithm_solver_test.rb

@@ -2,51 +2,89 @@ require 'test_helper'
 
 describe MHL::GeneticAlgorithmSolver do
 
+  let :logger do
+    :stderr
+  end
+
+  let :log_level do
+    ENV['DEBUG'] ? :debug : :warn
+  end
+
   it 'should accept bitstring representation genotypes' do
     MHL::GeneticAlgorithmSolver.new(
-      :population_size           => 128,
-      :genotype_space_type       => :bitstring,
-      :mutation_threshold        => 0.5,
-      :recombination_threshold   => 0.5,
-      :genotype_space_conf       => {
-        :bitstring_length => 120,
+      population_size: 128,
+      genotype_space_type: :bitstring,
+      mutation_threshold: 0.5,
+      recombination_threshold: 0.5,
+      genotype_space_conf: {
+        bitstring_length: 120,
       },
-      :logger                    => :stderr,
-      :log_level                 => ENV['DEBUG'] ? Logger::DEBUG : Logger::WARN,
+      logger: logger,
+      log_level: log_level,
     )
   end
 
   it 'should accept integer representation genotypes' do
     MHL::GeneticAlgorithmSolver.new(
-      :population_size           => 128,
-      :genotype_space_type       => :integer,
-      :mutation_probability      => 0.5,
-      :recombination_probability => 0.5,
-      :genotype_space_conf       => {
-        :dimensions         => 6,
-        :recombination_type => :intermediate,
+      population_size: 128,
+      genotype_space_type: :integer,
+      mutation_probability: 0.5,
+      recombination_probability: 0.5,
+      genotype_space_conf: {
+        dimensions: 6,
+        recombination_type: :intermediate,
       },
-      :logger                    => :stderr,
-      :log_level                 => ENV['DEBUG'] ? Logger::DEBUG : Logger::WARN,
+      logger: logger,
+      log_level: log_level,
     )
   end
 
-  it 'should solve a 2-dimension parabola in integer space' do
-    solver = MHL::GeneticAlgorithmSolver.new(
-      :population_size           => 40,
-      :genotype_space_type       => :integer,
-      :mutation_probability      => 0.5,
-      :recombination_probability => 0.5,
-      :genotype_space_conf       => {
-        :dimensions         => 2,
-        :recombination_type => :intermediate,
-        :random_func        => lambda { Array.new(2) { rand(20) } }
+  let :solver do
+    MHL::GeneticAlgorithmSolver.new(
+      population_size: 40,
+      genotype_space_type: :integer,
+      mutation_probability: 0.5,
+      recombination_probability: 0.5,
+      genotype_space_conf: {
+        dimensions: 2,
+        recombination_type: :intermediate,
+        random_func: lambda { Array.new(2) { rand(20) } }
       },
-      :exit_condition => lambda {|generation,best_sample| best_sample[:fitness] == 0},
-      :logger                    => :stderr,
-      :log_level                 => ENV['DEBUG'] ? Logger::DEBUG : Logger::WARN,
+      exit_condition: lambda {|generation,best_sample| best_sample[:fitness] == 0},
+      logger: logger,
+      log_level: log_level,
     )
-    solver.solve(Proc.new{|genotype| -(genotype[0]**2 + genotype[1]**2) })
+  end
+
+  context 'concurrent' do
+
+    it 'should solve a thread-safe function concurrently' do
+      func = -> position do
+        -(position.inject(0.0) {|s,x| s += x**2 })
+      end
+
+      solver.solve(func, concurrent: true)
+    end
+
+  end
+
+  context 'sequential' do
+
+    it 'should solve a non-thread safe function sequentially' do
+      # here we create a specially modified version of the function to optimize
+      # that raises an error if called concurrently
+      mx = Mutex.new
+      func = -> position do
+        raise "Sequential call check failed" if mx.locked?
+        mx.synchronize do
+          sleep 0.005
+          -(position.inject(0.0) {|s,x| s += x**2 })
+        end
+      end
+
+      solver.solve(func)
+    end
+
   end
 
 end

data/test/mhl/{integer_genotype_space_test.rb → integer_vector_genotype_space_test.rb}

@@ -1,19 +1,22 @@
 require 'test_helper'
 
 describe MHL::IntegerVectorGenotypeSpace do
+
   let :logger do
-    l = Logger.new(STDOUT)
-    l.level = ENV['DEBUG'] ? Logger::DEBUG : Logger::WARN
+    l = Logger.new(STDERR)
+    l.level = ENV['DEBUG'] ? :debug : :warn
     l
   end
 
   it 'should refuse to work with non-positive dimensions' do
     assert_raises(ArgumentError) do
       MHL::IntegerVectorGenotypeSpace.new(
-        :dimensions         => -rand(100),
-        :recombination_type => :intermediate,
-        :logger             => logger,
-        # :random_func        => lambda { Array.new(2) { rand(20) } }
+        {
+          dimensions: -rand(100),
+          recombination_type: :intermediate,
+          # random_func: lambda { Array.new(2) { rand(20) } }
+        },
+        logger
       )
     end
   end
@@ -21,9 +24,11 @@ describe MHL::IntegerVectorGenotypeSpace do
   it 'should refuse to work with non- line or intermediate recombination' do
     assert_raises(ArgumentError) do
       MHL::IntegerVectorGenotypeSpace.new(
-        :dimensions         => 2,
-        :recombination_type => :something,
-        :logger             => logger,
+        {
+          dimensions: 2,
+          recombination_type: :something,
+        },
+        logger
       )
     end
   end
@@ -33,11 +38,13 @@ describe MHL::IntegerVectorGenotypeSpace do
       x1 =  rand(100); x2 = x1 + rand(200)
       y1 = -rand(100); y2 = y1 + rand(200)
       is = MHL::IntegerVectorGenotypeSpace.new(
-        :dimensions         => 2,
-        :recombination_type => :intermediate,
-        :constraints => [ { :from => x1, :to => x2 },
-                          { :from => y1, :to => y2 } ],
-        :logger             => logger,
+        {
+          dimensions: 2,
+          recombination_type: :intermediate,
+          constraints: [ { from: x1, to: x2 },
+                         { from: y1, to: y2 } ],
+        },
+        logger
       )
       genotype = is.get_random
       genotype.size.must_equal 2
@@ -51,21 +58,22 @@ describe MHL::IntegerVectorGenotypeSpace do
       x1 =  rand(100); x2 = x1 + rand(200)
       y1 = -rand(100); y2 = y1 + rand(200)
       is = MHL::IntegerVectorGenotypeSpace.new(
-        :dimensions         => 2,
-        :recombination_type => :intermediate,
-        :constraints => [ { :from => x1, :to => x2 },
-                          { :from => y1, :to => y2 } ],
-        :logger             => logger,
+        {
+          dimensions: 2,
+          recombination_type: :intermediate,
+          constraints: [ { from: x1, to: x2 },
+                         { from: y1, to: y2 } ],
+        },
+        logger
       )
-      g1 = { :genotype => [ x1, y1 ] }
-      g2 = { :genotype => [ x2, y2 ] }
+      g1 = { genotype: [ x1, y1 ] }
+      g2 = { genotype: [ x2, y2 ] }
       a, b = is.reproduce_from(
         g1, g2,
-        ERV::RandomVariable.new(:distribution           => :geometric,
-                                :probability_of_success => 0.05),
-        ERV::RandomVariable.new(:distribution => :uniform,
-                                :min_value    => -0.25,
-                                :max_value    =>  1.25)
+        ERV::RandomVariable.new(distribution: :geometric,
+                                args: { probability_of_success: 0.05 }),
+        ERV::RandomVariable.new(distribution: :uniform,
+                                args: { min_value: -0.25, max_value: 1.25 })
       )
       a[:genotype][0].must_be :>=, x1
       a[:genotype][0].must_be :<=, x2

data/test/mhl/multiswarm_qpso_solver_test.rb

@@ -2,18 +2,56 @@ require 'test_helper'
 
 describe MHL::MultiSwarmQPSOSolver do
 
-  it 'should solve a 2-dimension parabola in real space' do
-    solver = MHL::MultiSwarmQPSOSolver.new(
-      :num_swarms           => 4,
-      :constraints          => {
-        :min => [ -100, -100 ],
-        :max => [  100,  100 ],
+  let :logger do
+    :stderr
+  end
+
+  let :log_level do
+    ENV['DEBUG'] ? :debug : :warn
+  end
+
+  let :solver do
+    MHL::MultiSwarmQPSOSolver.new(
+      num_swarms: 4,
+      constraints: {
+        min: [ -100, -100, -100, -100, -100 ],
+        max: [  100,  100,  100,  100,  100 ],
       },
-      :exit_condition       => lambda {|iteration,best| best[:height].abs < 0.001 },
-      :logger               => :stdout,
-      :log_level            => ENV['DEBUG'] ? Logger::DEBUG : Logger::WARN,
+      exit_condition: lambda {|iteration,best| best[:height].abs < 0.001 },
+      logger: logger,
+      log_level: log_level,
     )
-    solver.solve(Proc.new{|position| -(position[0]**2 + position[1]**2) })
+  end
+
+  context 'concurrent' do
+
+    it 'should solve a thread-safe function concurrently' do
+      func = -> position do
+        -(position.inject(0.0) {|s,x| s += x**2 })
+      end
+
+      solver.solve(func, concurrent: true)
+    end
+
+  end
+
+  context 'sequential' do
+
+    it 'should solve a non-thread safe function sequentially' do
+      # here we create a specially modified version of the function to optimize
+      # that raises an error if called concurrently
+      mx = Mutex.new
+      func = -> position do
+        raise "Sequential call check failed" if mx.locked?
+        mx.synchronize do
+          sleep 0.005
+          -(position.inject(0.0) {|s,x| s += x**2 })
+        end
+      end
+
+      solver.solve(func)
+    end
+
   end
 
 end