mhl 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fd67377b3670dfd8f235044614d2f4b9965ead18
-  data.tar.gz: a3a98c4c0a8ead65030715cbf0e0f9f24f1d0a3c
+  metadata.gz: 6451520f742d76561c0caf54cde03a7da4643898
+  data.tar.gz: f37fb25a97bb1b718c5ab2e7078f6853574b3749
 SHA512:
-  metadata.gz: a7dfe8e770e05c0bae580e3e0f21cb9da2accc690b05d19d6e1ce330dcae0e6a54ee3c95630809aabec34c9cc0af8a9befeb7ee1faabbbb87356e809522f2f46
-  data.tar.gz: cd3bb8ce03f86c22250d549251908d7ff2c7eb88b70a9108fe258213686afa7b9024eb0888607feb24031f912769e2073b6436c53ad7af059b90e78b462c8137
+  metadata.gz: aa0d5beb542b0889e042486421d8d878b427042c046d8c72b9cea1c4913d9bb01a5ec0f9d38bb34c6d48de49723346c2f9430d30a593bf1eb01d9786292270ea
+  data.tar.gz: a848727a22034af0a4a59bd58c3db415af71715e3e9fce35d17305312d4649cbecf93d2ee78eee157e3d5dcfc8b158a6ba7b85901e2236c87ce82d159878b7ad

data/Rakefile

@@ -1 +1,9 @@
 require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.test_files = Dir.glob('test/**/*_test.rb').sort
+  t.verbose = true
+end

data/lib/mhl.rb

@@ -1,3 +1,5 @@
 require 'mhl/version'
 require 'mhl/genetic_algorithm_solver'
 require 'mhl/particle_swarm_optimization_solver'
+require 'mhl/quantum_particle_swarm_optimization_solver'
+require 'mhl/multiswarm_qpso_solver'

data/lib/mhl/charged_swarm.rb

@@ -0,0 +1,85 @@
+require 'matrix'
+
+require 'mhl/generic_swarm'
+
+
+module MHL
+  class ChargedSwarm < GenericSwarmBehavior
+
+    # default composition is half charged, i.e., QPSO, and half neutral, i.e.,
+    # traditional PSO (with inertia), swarms
+    DEFAULT_CHARGED_TO_NEUTRAL_RATIO = 1.0
+
+    def initialize(size, initial_positions, initial_velocities, params={})
+      @size = size
+
+      # retrieve ratio between charged (QPSO) and neutral (PSO w/ inertia) particles
+      ratio = (params[:charged_to_neutral_ratio] || DEFAULT_CHARGED_TO_NEUTRAL_RATIO).to_f
+      unless ratio > 0.0
+        raise ArgumentError, 'Parameter :charged_to_neutral_ratio should be a real greater than zero!'
+      end
+
+      num_charged_particles = (@size * ratio).round
+      @num_neutral_particles = @size - num_charged_particles
+
+      # the particles are ordered, with neutral (PSO w/ inertia) particles
+      # first and charged (QPSO) particles later
+      @particles = Array.new(@size) do |index|
+        if index < @num_neutral_particles
+          Particle.new(initial_positions[index], initial_velocities[index])
+        else
+          QuantumParticle.new(initial_positions[index])
+        end
+      end
+
+      # find problem dimension
+      @dimension  = initial_positions[0].size
+
+      @generation = 1
+
+      # define procedure to get dynamic value for alpha
+      @get_alpha = if params.has_key? :alpha and params[:alpha].respond_to? :call
+        params[:alpha]
+      else
+        ->(gen) { (params[:alpha] || DEFAULT_ALPHA).to_f }
+      end
+
+      # get values for parameters C1 and C2
+      @c1 = (params[:c1] || DEFAULT_C1).to_f
+      @c2 = (params[:c1] || DEFAULT_C2).to_f
+
+      # define procedure to get dynamic value for omega
+      @get_omega = if params.has_key? :omega and params[:omega].respond_to? :call
+        params[:omega]
+      else
+        ->(gen) { (params[:omega] || DEFAULT_OMEGA).to_f }
+      end
+    end
+
+    def mutate
+      # get alpha parameter
+      alpha = @get_alpha.call(@generation)
+
+      # get omega parameter
+      omega = @get_omega.call(@generation)
+
+      # this calculates the C_n parameter (basically, the centroid of particle
+      # attractors) as defined in [SUN11], formulae 4.81 and 4.82
+      #
+      # (note: the neutral particles influence the behavior of the charged ones
+      # not only by defining the swarm attractor, but also by forming this centroid)
+      c_n = @particles.inject(Vector[*[0]*@dimension]) {|s,p| s += p.attractor[:position] } / @size.to_f
+
+      @particles.each_with_index do |p,i|
+        # remember: the particles are kept in a PSO-first and QPSO-last order
+        if i < @num_neutral_particles
+          p.move(omega, @c1, @c2, @swarm_attractor)
+        else
+          p.move(alpha, c_n, @swarm_attractor)
+        end
+      end
+
+      @generation += 1
+    end
+  end
+end

data/lib/mhl/generic_particle.rb

@@ -0,0 +1,52 @@
+module MHL
+
+  class GenericParticle
+
+    attr_reader :attractor
+
+    def initialize(initial_position)
+      @position  = initial_position
+      @attractor = nil
+    end
+
+    def evaluate(func)
+      # calculate particle height
+      @height = func.call(@position)
+
+      # update particle attractor (if needed)
+      if @attractor.nil? or @height > @attractor[:height]
+        @attractor = { height: @height, position: @position }
+      end
+    end
+
+    def remain_within(constraints)
+      new_pos = @position.map.with_index do |x,i|
+        puts "resetting #{x} within #{constraints[:min][i]} and #{constraints[:max][i]}"
+        d_max = constraints[:max][i]
+        d_min = constraints[:min][i]
+        d_size = d_max - d_min
+        if x > d_max
+          while x > d_max + d_size
+            x -= d_size
+          end
+          if x > d_max
+            x = 2 * d_max - x
+          end
+        elsif x < d_min
+          while x < d_min - d_size
+            x += d_size
+          end
+          if x < d_min
+            x = 2 * d_min - x
+          end
+        end
+        puts "now x is #{x}"
+        x
+      end
+      puts "new_pos: #{new_pos}"
+      @position = new_pos # Vector[new_pos]
+    end
+
+  end
+
+end

data/lib/mhl/generic_swarm.rb

@@ -0,0 +1,41 @@
+require 'forwardable'
+
+module MHL
+  class GenericSwarmBehavior
+
+    # The following values were taken from [BLACKWELLBRANKE04] Tim Blackwell,
+    # Jürgen Branke, "Multi-swarm Optimization in Dynamic Environments",
+    # Applications of Evolutionary Computing, pp.  489-500, Springer, 2004.
+    # DOI: 10.1007/978-3-540-24653-4_50
+    # C_1 is the cognitive acceleration coefficient
+    DEFAULT_C1 = 2.05
+    # C_2 is the social acceleration coefficient
+    DEFAULT_C2 = 2.05
+    PHI = DEFAULT_C1 + DEFAULT_C2
+    # \omega is the inertia weight
+    DEFAULT_OMEGA = 2.0 / (2 - PHI - Math.sqrt(PHI ** 2 - 4.0 * PHI)).abs
+
+    # \alpha is the inertia weight
+    # According to [SUN11], this looks like a sensible default parameter
+    DEFAULT_ALPHA = 0.75
+
+    extend Forwardable
+    def_delegators :@particles, :each
+
+    include Enumerable
+
+    def update_attractor
+      # get the particle attractors
+      particle_attractors = @particles.map { |p| p.attractor }
+
+      # update swarm attractor (if needed)
+      if @swarm_attractor.nil?
+        @swarm_attractor = particle_attractors.max_by {|p| p[:height] }
+      else
+        @swarm_attractor = [ @swarm_attractor, *particle_attractors ].max_by {|p| p[:height] }
+      end
+
+      @swarm_attractor
+    end
+  end
+end

data/lib/mhl/genetic_algorithm_solver.rb

@@ -1,5 +1,7 @@
 require 'concurrent'
 require 'erv'
+require 'facter'
+require 'logger'
 
 require 'mhl/bitstring_genotype_space'
 require 'mhl/integer_genotype_space'
@@ -8,6 +10,9 @@ require 'mhl/integer_genotype_space'
 module MHL
 
   class GeneticAlgorithmSolver
+    # mutation_probability is the parameter that controls the intensity of mutation
+    attr_reader :mutation_probability
+
     def initialize(opts)
       @population_size = opts[:population_size].to_i
       unless @population_size and @population_size.even?
@@ -20,10 +25,10 @@ module MHL
         @genotype_space = IntegerVectorGenotypeSpace.new(opts[:genotype_space_conf])
 
         begin
-          p_m = opts[:mutation_probability].to_f
+          @mutation_probability = opts[:mutation_probability].to_f
           @mutation_rv = \
             ERV::RandomVariable.new(:distribution           => :geometric,
-                                    :probability_of_success => p_m)
+                                    :probability_of_success => @mutation_probability)
         rescue
           raise ArgumentError, 'Mutation probability configuration is wrong.'
         end
@@ -49,8 +54,36 @@ module MHL
 
       @exit_condition   = opts[:exit_condition]
       @start_population = opts[:genotype_space_conf][:start_population]
+
+      @controller = opts[:controller]
+
+      @pool = Concurrent::FixedThreadPool.new(Facter.value(:processorcount).to_i * 4)
+
+      case opts[:logger]
+      when :stdout
+        @logger = Logger.new(STDOUT)
+      when :stderr
+        @logger = Logger.new(STDERR)
+      else
+        @logger = opts[:logger]
+      end
+
+      @quiet = opts[:quiet]
+
+      if @logger
+        @logger.level = (opts[:log_level] or Logger::WARN)
+      end
     end
 
+    def mutation_probability=(new_mp)
+      unless new_mp > 0.0 and new_mp < 1.0
+        raise ArgumentError, 'Mutation probability needs to be > 0 and < 1'
+      end
+      @mutation_probability = new_mp
+      @mutation_rv = \
+        ERV::RandomVariable.new(:distribution           => :geometric,
+                                :probability_of_success => @mutation_probability)
+    end
 
     # This is the method that solves the optimization problem
     #
@@ -74,24 +107,42 @@ module MHL
       gen = 0
       overall_best = nil
 
+      population_mutex = Mutex.new
+
       # default behavior is to loop forever
       begin
         gen += 1
-        puts "Starting generation #{gen} at #{Time.now}"
+        @logger.info("GA - Starting generation #{gen}") if @logger
+
+        # create latch to control program termination
+        latch = Concurrent::CountDownLatch.new(@population_size)
 
         # assess fitness for every member of the population
         population.each do |s|
-          s[:task] = Concurrent::Future.new { func.call(s[:genotype]) }
+          @pool.post do
+            # do we need to syncronize this call through population_mutex?
+            # probably not.
+            ret = func.call(s[:genotype])
+
+            # protect write access to population struct using mutex
+            population_mutex.synchronize do
+              s[:fitness] = ret
+            end
+
+            # update latch
+            latch.count_down
+          end
         end
 
-        # wait for all the evaluations to end
-        population.each do |s|
-          s[:fitness] = s[:task].value
-        end
+        # wait for all the threads to terminate
+        latch.wait
 
         # find fittest member
         population_best = population.max_by {|x| x[:fitness] }
 
+        # print results
+        puts "> gen #{gen}, best: #{population_best[:genotype]}, #{population_best[:fitness]}" unless @quiet
+
         # calculate overall best
         if overall_best.nil?
           overall_best = population_best
@@ -99,8 +150,8 @@ module MHL
           overall_best = [ overall_best, population_best ].max_by {|x| x[:fitness] }
         end
 
-        # print results
-        puts "> gen #{gen}, best: #{overall_best[:genotype]}, #{overall_best[:fitness]}"
+        # execute controller
+        @controller.call(self, overall_best) if @controller
 
         # selection by binary tournament
         children = new_generation(population)
@@ -108,6 +159,9 @@ module MHL
         # update population and generation number
         population = children
       end while @exit_condition.nil? or !@exit_condition.call(gen, overall_best)
+
+      # return best sample
+      overall_best
     end
 
 

data/lib/mhl/integer_genotype_space.rb

@@ -19,13 +19,24 @@ module MHL
       else
         raise ArgumentError, 'Recombination function must be either line or intermediate!'
       end
+
+      @constraints = opts[:constraints]
+      if @constraints and @constraints.size != @dimensions
+        raise ArgumentError, 'Constraints must be provided for every dimension!'
+      end
+
+      @logger = opts[:logger]
     end
 
     def get_random
       if @random_func
         @random_func.call
       else
-        # TODO: implement this
+        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
 
@@ -38,22 +49,25 @@ module MHL
       c2 = { :genotype => p2[:genotype].dup }
 
       # mutation comes first
-      random_geometric_mutation(c1[:genotype], mutation_rv)
-      random_geometric_mutation(c2[:genotype], mutation_rv)
+      random_delta_mutation(c1[:genotype], mutation_rv)
+      random_delta_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
 
-      def random_geometric_mutation(g, mutation_rv)
+      def random_delta_mutation(g, mutation_rv)
         g.each_index do |i|
-          # being sampled from a geometric distribution, delta will always
-          # be a non-negative integer (that is, 0 or greater)
           delta = mutation_rv.next
 
           if rand() >= 0.5
@@ -77,7 +91,7 @@ module MHL
             beta  = recombination_rv.next
             t = (alpha * g1[i] + (1.0 - alpha) * g2[i] + 0.5).floor
             s = ( beta * g2[i] + (1.0 -  beta) * g1[i] + 0.5).floor
-          end # until t >= 0 and s >= 0 # TODO: implement within-bounds condition checking
+          end
           g1[i] = t
           g2[i] = s
         end
@@ -94,10 +108,24 @@ module MHL
         g1.each_index do |i|
           t = (alpha * g1[i] + (1.0 - alpha) * g2[i] + 0.5).floor
           s = ( beta * g2[i] + (1.0 -  beta) * g1[i] + 0.5).floor
-          # if t >= 0 and s >= 0 # TODO: implement within-bounds condition checking
-            g1[i] = t
-            g2[i] = s
-          # end
+          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
 

data/lib/mhl/multiswarm_qpso_solver.rb

@@ -0,0 +1,140 @@
+require 'concurrent'
+require 'facter'
+require 'logger'
+require 'matrix'
+
+require 'mhl/charged_swarm'
+
+
+module MHL
+  # This solver implements the multiswarm QPSO algorithm, based on a number of
+  # charged (QPSO Type 2) and neutral (PSO) swarms.
+  #
+  # For more information, refer to:
+  # [BLACKWELLBRANKE04] Tim Blackwell, Jürgen Branke, "Multi-swarm Optimization
+  # in Dynamic Environments", Applications of Evolutionary Computing, pp.
+  # 489-500, Springer, 2004. DOI: 10.1007/978-3-540-24653-4_50
+  class MultiSwarmQPSOSolver
+
+    def initialize(opts={})
+      @swarm_size = opts[:swarm_size].to_i
+      unless @swarm_size
+        raise ArgumentError, 'Swarm size is a required parameter!'
+      end
+
+      @num_swarms = opts[:num_swarms].to_i
+      unless @num_swarms
+        raise ArgumentError, 'Number of swarms is a required parameter!'
+      end
+
+      @random_position_func = opts[:random_position_func]
+      @random_velocity_func = opts[:random_velocity_func]
+
+      @start_positions = opts[:start_positions]
+      @exit_condition  = opts[:exit_condition]
+
+      @pool = Concurrent::FixedThreadPool.new(Facter.value(:processorcount).to_i * 4)
+
+      case opts[:logger]
+      when :stdout
+        @logger = Logger.new(STDOUT)
+      when :stderr
+        @logger = Logger.new(STDERR)
+      else
+        @logger = opts[:logger]
+      end
+
+      @quiet = opts[:quiet]
+
+      if @logger
+        @logger.level = opts[:log_level] or Logger::WARN
+      end
+    end
+
+    # This is the method that solves the optimization problem
+    #
+    # Parameter func is supposed to be a method (or a Proc, a lambda, or any callable
+    # object) that accepts the genotype as argument (that is, the set of
+    # parameters) and returns the phenotype (that is, the function result)
+    def solve(func, params={})
+
+      # setup particles
+      if @start_positions.nil?
+        swarms = Array.new(@num_swarms) do |index|
+          ChargedSwarm.new(@swarm_size,
+                           Array.new(@swarm_size)     { Vector[*@random_position_func.call] },
+                           Array.new(@swarm_size / 2) { Vector[*@random_velocity_func.call] },
+                           params)
+        end
+      else
+        raise 'Unimplemented yet!'
+        # particles = @start_positions.each_slice(2).map do |pos,vel|
+        #   { position: Vector[*pos] }
+        # end
+      end
+
+      # initialize variables
+      gen = 0
+      overall_best = nil
+
+      # default behavior is to loop forever
+      begin
+        gen += 1
+        @logger.info "MSQPSO - Starting generation #{gen}" if @logger
+
+        # create latch to control program termination
+        latch = Concurrent::CountDownLatch.new(@num_swarms * @swarm_size)
+
+        # assess height for every particle
+        swarms.each do |s|
+          s.each do |particle|
+            @pool.post do
+              # evaluate target function
+              particle.evaluate(func)
+              # update latch
+              latch.count_down
+            end
+          end
+        end
+
+        # wait for all the evaluations to end
+        latch.wait
+
+        # update attractors (the highest particle in each swarm)
+        swarm_attractors = swarms.map {|s| s.update_attractor }
+
+        best_attractor = swarm_attractors.max_by {|x| x[:height] }
+
+        # print results
+        puts "> gen #{gen}, best: #{best_attractor[:position]}, #{best_attractor[:height]}" unless @quiet
+
+        # calculate overall best
+        if overall_best.nil?
+          overall_best = best_attractor
+        else
+          overall_best = [ overall_best, best_attractor ].max_by {|x| x[:height] }
+        end
+
+        # exclusion phase
+        # this phase is necessary to preserve diversity between swarms. we need
+        # to ensure that swarm attractors are distant at least r_{excl} units
+        # from each other. if the attractors of two swarms are closer than
+        # r_{excl}, we randomly reinitialize the worst of those swarms.
+        # TODO: IMPLEMENT
+
+        # anti-convergence phase
+        # this phase is necessary to ensure that a swarm is "spread" enough to
+        # effectively follow the movements of a "peak" in the solution space.
+        # TODO: IMPLEMENT
+
+        # mutate swarms
+        swarms.each {|s| s.mutate }
+
+      end while @exit_condition.nil? or !@exit_condition.call(gen, overall_best)
+
+      overall_best
+    end
+
+  end
+
+end