mhl 0.1.0 → 0.2.0

data/lib/mhl/genetic_algorithm_solver.rb

@@ -1,6 +1,5 @@
 require 'concurrent'
 require 'erv'
-require 'facter'
 require 'logger'
 
 require 'mhl/bitstring_genotype_space'
@@ -57,7 +56,7 @@ module MHL
 
       @controller = opts[:controller]
 
-      @pool = Concurrent::FixedThreadPool.new(Facter.value(:processorcount).to_i * 4)
+      @pool = Concurrent::FixedThreadPool.new(Concurrent::processor_count * 4)
 
       case opts[:logger]
       when :stdout

data/lib/mhl/multiswarm_qpso_solver.rb

@@ -1,7 +1,5 @@
 require 'concurrent'
-require 'facter'
 require 'logger'
-require 'matrix'
 
 require 'mhl/charged_swarm'
 
@@ -16,24 +14,26 @@ module MHL
   # 489-500, Springer, 2004. DOI: 10.1007/978-3-540-24653-4_50
   class MultiSwarmQPSOSolver
 
+    DEFAULT_SWARM_SIZE = 20
+
     def initialize(opts={})
-      @swarm_size = opts[:swarm_size].to_i
-      unless @swarm_size
-        raise ArgumentError, 'Swarm size is a required parameter!'
-      end
+      @swarm_size = opts[:swarm_size].try(:to_i) || DEFAULT_SWARM_SIZE
 
       @num_swarms = opts[:num_swarms].to_i
       unless @num_swarms
         raise ArgumentError, 'Number of swarms is a required parameter!'
       end
 
+      @constraints = opts[:constraints]
+
       @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)
+      @pool = Concurrent::FixedThreadPool.new(Concurrent::processor_count * 4)
 
       case opts[:logger]
       when :stdout
@@ -58,29 +58,67 @@ module MHL
     # 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)
+      swarms = Array.new(@num_swarms) do |index|
+        # initialize particle positions
+        init_pos = if @start_positions
+          # start positions have the highest priority
+          @start_positions[index * @swarm_size, @swarm_size]
+        elsif @random_position_func
+          # random_position_func has the second highest priority
+          Array.new(@swarm_size) { @random_position_func.call }
+        elsif @constraints
+          # constraints were given, so we use them to initialize particle
+          # positions. to this end, we adopt the SPSO 2006-2011 random position
+          # initialization algorithm [CLERC12].
+          Array.new(@swarm_size) do
+            min = @constraints[:min]
+            max = @constraints[:max]
+            # randomization is independent along each dimension
+            min.zip(max).map do |min_i,max_i|
+              min_i + SecureRandom.random_number * (max_i - min_i)
+            end
+          end
+        else
+          raise ArgumentError, "Not enough information to initialize particle positions!"
+        end
+
+        # initialize particle velocities
+        init_vel = if @start_velocities
+          # start velocities have the highest priority
+          @start_velocities[index * @swarm_size / 2, @swarm_size / 2]
+        elsif @random_velocity_func
+          # random_velocity_func has the second highest priority
+          Array.new(@swarm_size / 2) { @random_velocity_func.call }
+        elsif @constraints
+          # constraints were given, so we use them to initialize particle
+          # velocities. to this end, we adopt the SPSO 2011 random velocity
+          # initialization algorithm [CLERC12].
+          init_pos.map do |p|
+            min = @constraints[:min]
+            max = @constraints[:max]
+            # randomization is independent along each dimension
+            p.zip(min,max).map do |p_i,min_i,max_i|
+              min_vel = min_i - p_i
+              max_vel = max_i - p_i
+              min_vel + SecureRandom.random_number * (max_vel - min_vel)
+            end
+          end
+        else
+          raise ArgumentError, "Not enough information to initialize particle velocities!"
         end
-      else
-        raise 'Unimplemented yet!'
-        # particles = @start_positions.each_slice(2).map do |pos,vel|
-        #   { position: Vector[*pos] }
-        # end
+
+        ChargedSwarm.new(@swarm_size, init_pos, init_vel,
+                         params.merge(constraints: @constraints))
       end
 
       # initialize variables
-      gen = 0
+      iter = 0
       overall_best = nil
 
       # default behavior is to loop forever
       begin
-        gen += 1
-        @logger.info "MSQPSO - Starting generation #{gen}" if @logger
+        iter += 1
+        @logger.info "MultiSwarm QPSO - Starting iteration #{iter}" if @logger
 
         # create latch to control program termination
         latch = Concurrent::CountDownLatch.new(@num_swarms * @swarm_size)
@@ -106,7 +144,7 @@ module MHL
         best_attractor = swarm_attractors.max_by {|x| x[:height] }
 
         # print results
-        puts "> gen #{gen}, best: #{best_attractor[:position]}, #{best_attractor[:height]}" unless @quiet
+        puts "> iter #{iter}, best: #{best_attractor[:position]}, #{best_attractor[:height]}" unless @quiet
 
         # calculate overall best
         if overall_best.nil?
@@ -130,7 +168,7 @@ module MHL
         # mutate swarms
         swarms.each {|s| s.mutate }
 
-      end while @exit_condition.nil? or !@exit_condition.call(gen, overall_best)
+      end while @exit_condition.nil? or !@exit_condition.call(iter, overall_best)
 
       overall_best
     end

data/lib/mhl/particle.rb

@@ -10,23 +10,58 @@ module MHL
     end
 
     # move particle and update attractor
-    def move(omega, c1, c2, swarm_attractor)
+    def move(chi, c1, c2, swarm_attractor)
       raise 'Particle attractor is nil!' if @attractor.nil?
-      # raise 'Swarm attractor is nil!' if swarm_attractor.nil?
+
+      # update particle velocity and position according to the Constrained PSO
+      # variant of the Particle Swarm Optimization algorithm:
+      #
+      # V_{i,j}(t+1) = \chi [ V_{i,j}(t) + \\
+      #                       C_1 * r_{i,j}(t) * (P_{i,j}(t) - X_{i,j}(t)) + \\
+      #                       C_2 * R_{i,j}(t) * (G_j(t) - X_{i,j}(t)) ] \\
+      # X_{i,j}(t+1) = X_{i,j}(t) + V_{i,j}(t+1)
+      #
+      # see equation 4.30 of [SUN11].
 
       # update velocity
-      @velocity =
-        # previous velocity is damped by inertia weight omega
-        omega * @velocity +
-        # "memory" component (linear attraction towards the best position
-        # that this particle encountered so far)
-        c1 * SecureRandom.random_number * (attractor[:position] - @position) +
-        # "social" component (linear attraction towards the best position
-        # that the entire swarm encountered so far)
-        c2 * SecureRandom.random_number * (swarm_attractor[:position] - @position)
+      @velocity = @velocity.zip(@position, @attractor[:position], swarm_attractor[:position]).map do |v_j,x_j,p_j,g_j|
+        # everything is damped by inertia weight chi
+        chi *
+          #previous velocity
+          (v_j +
+          # "memory" component (linear attraction towards the best position
+          # that this particle encountered so far)
+          c1 * SecureRandom.random_number * (p_j - x_j) +
+          # "social" component (linear attraction towards the best position
+          # that the entire swarm encountered so far)
+          c2 * SecureRandom.random_number * (g_j - x_j))
+      end
 
       # update position
-      @position = @position + @velocity
+      @position = @position.zip(@velocity).map do |x_j,v_j|
+        x_j + v_j
+      end
+    end
+
+    # implement confinement à la SPSO 2011. for more information, see equations
+    # 3.14 and 3.15 of [CLERC12].
+    def remain_within(constraints)
+      @position = @position.map.with_index do |x_j,j|
+        d_max = constraints[:max][j]
+        d_min = constraints[:min][j]
+        if x_j > d_max
+          # puts "resetting #{j}-th position component #{x_j} to #{d_max}"
+          x_j = d_max
+          # puts "resetting #{j}-th velocity component #{@velocity[j]} to #{-0.5 * @velocity[j]}"
+          @velocity[j] = -0.5 * @velocity[j]
+        elsif x_j < d_min
+          # puts "resetting #{j}-th position component #{x_j} to #{d_min}"
+          x_j = d_min
+          # puts "resetting #{j}-th velocity component #{@velocity[j]} to #{-0.5 * @velocity[j]}"
+          @velocity[j] = -0.5 * @velocity[j]
+        end
+        x_j
+      end
     end
 
   end

data/lib/mhl/particle_swarm_optimization_solver.rb

@@ -1,5 +1,4 @@
 require 'concurrent'
-require 'facter'
 require 'logger'
 
 require 'mhl/pso_swarm'
@@ -7,28 +6,27 @@ require 'mhl/pso_swarm'
 
 module MHL
 
-  # This solver implements the PSO with inertia weight variant algorithm.
-  #
-  # For more information, refer to equation 4 of:
-  # [REZAEEJORDEHI13] A. Rezaee Jordehi & J. Jasni (2013) Parameter selection
-  # in particle swarm optimisation: a survey, Journal of Experimental &
-  # Theoretical Artificial Intelligence, 25:4, pp. 527-542, DOI:
-  # 10.1080/0952813X.2013.782348
+  # This solver implements the "canonical" variant of PSO called Constrained
+  # PSO. For more information, refer to equation 4.30 of [SUN11].
   class ParticleSwarmOptimizationSolver
 
+    # This is the default swarm size recommended by SPSO 2011 [CLERC12].
+    DEFAULT_SWARM_SIZE = 40
+
     def initialize(opts={})
-      @swarm_size = opts[:swarm_size].to_i
-      unless @swarm_size
-        raise ArgumentError, 'Swarm size is a required parameter!'
-      end
+      @swarm_size = opts[:swarm_size].try(:to_i) || DEFAULT_SWARM_SIZE
+
+      @constraints = opts[:constraints]
 
       @random_position_func = opts[:random_position_func]
       @random_velocity_func = opts[:random_velocity_func]
 
-      @start_positions = opts[:start_positions]
+      @start_positions  = opts[:start_positions]
+      @start_velocities = opts[:start_velocities]
+
       @exit_condition  = opts[:exit_condition]
 
-      @pool = Concurrent::FixedThreadPool.new(Facter.value(:processorcount).to_i * 4)
+      @pool = Concurrent::FixedThreadPool.new(Concurrent::processor_count * 4)
 
       case opts[:logger]
       when :stdout
@@ -52,31 +50,67 @@ module MHL
     # 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?
-        swarm = PSOSwarm.new(@swarm_size,
-                             Array.new(@swarm_size) { Vector[*@random_position_func.call] },
-                             Array.new(@swarm_size) { Vector[*@random_velocity_func.call] },
-                             params)
+
+      # initialize particle positions
+      init_pos = if @start_positions
+        # start positions have the highest priority
+        @start_positions
+      elsif @random_position_func
+        # random_position_func has the second highest priority
+        Array.new(@swarm_size) { @random_position_func.call }
+      elsif @constraints
+        # constraints were given, so we use them to initialize particle
+        # positions. to this end, we adopt the SPSO 2006-2011 random position
+        # initialization algorithm [CLERC12].
+        Array.new(@swarm_size) do
+          min = @constraints[:min]
+          max = @constraints[:max]
+          # randomization is independent along each dimension
+          min.zip(max).map do |min_i,max_i|
+            min_i + SecureRandom.random_number * (max_i - min_i)
+          end
+        end
       else
-        # we only support the definition of start positions - not velocities
-        swarm = PSOSwarm.new(@swarm_size,
-                             @start_positions.map {|x| Vector[*x] },
-                             Array.new(@swarm_size) { Vector[*@random_velocity_func.call] },
-                             params)
-        # particles = @start_positions.each_slice(2).map do |pos,vel|
-        #   { position: Vector[*pos], velocity: Vector[*vel] }
-        # end
+        raise ArgumentError, "Not enough information to initialize particle positions!"
       end
 
+      # initialize particle velocities
+      init_vel = if @start_velocities
+        # start velocities have the highest priority
+        @start_velocities
+      elsif @random_velocity_func
+        # random_velocity_func has the second highest priority
+        Array.new(@swarm_size) { @random_velocity_func.call }
+      elsif @constraints
+        # constraints were given, so we use them to initialize particle
+        # velocities. to this end, we adopt the SPSO 2011 random velocity
+        # initialization algorithm [CLERC12].
+        init_pos.map do |p|
+          min = @constraints[:min]
+          max = @constraints[:max]
+          # randomization is independent along each dimension
+          p.zip(min,max).map do |p_i,min_i,max_i|
+            min_vel = min_i - p_i
+            max_vel = max_i - p_i
+            min_vel + SecureRandom.random_number * (max_vel - min_vel)
+          end
+        end
+      else
+        raise ArgumentError, "Not enough information to initialize particle velocities!"
+      end
+
+      # setup particles
+      swarm = PSOSwarm.new(@swarm_size, init_pos, init_vel,
+                           params.merge(constraints: @constraints))
+
       # initialize variables
-      gen = 0
+      iter = 0
       overall_best = nil
 
       # default behavior is to loop forever
       begin
-        gen += 1
-        @logger.info("PSO - Starting generation #{gen}") if @logger
+        iter += 1
+        @logger.info("PSO - Starting iteration #{iter}") if @logger
 
         # create latch to control program termination
         latch = Concurrent::CountDownLatch.new(@swarm_size)
@@ -98,7 +132,7 @@ module MHL
         swarm_attractor = swarm.update_attractor
 
         # print results
-        puts "> gen #{gen}, best: #{swarm_attractor[:position]}, #{swarm_attractor[:height]}" unless @quiet
+        puts "> iter #{iter}, best: #{swarm_attractor[:position]}, #{swarm_attractor[:height]}" unless @quiet
 
         # calculate overall best (that plays the role of swarm attractor)
         if overall_best.nil?
@@ -110,7 +144,7 @@ module MHL
         # mutate swarm
         swarm.mutate
 
-      end while @exit_condition.nil? or !@exit_condition.call(gen, overall_best)
+      end while @exit_condition.nil? or !@exit_condition.call(iter, overall_best)
 
       overall_best
     end

data/lib/mhl/pso_swarm.rb

@@ -1,6 +1,3 @@
-require 'matrix'
-require 'securerandom'
-
 require 'mhl/generic_swarm'
 require 'mhl/particle'
 
@@ -14,39 +11,39 @@ module MHL
         Particle.new(initial_positions[index], initial_velocities[index])
       end
 
-      @generation = 1
+      @iteration = 1
 
       # 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]
+      # define procedure to get dynamic value for chi
+      @get_chi = if params.has_key? :chi and params[:chi].respond_to? :call
+        params[:chi]
       else
-        ->(gen) { (params[:omega] || DEFAULT_OMEGA).to_f }
+        ->(iter) { (params[:chi] || DEFAULT_CHI).to_f }
       end
 
       if params.has_key? :constraints
-        puts "PSOSwarm called w/ :constraints => #{params[:constraints]}"
+        puts "PSOSwarm called w/ constraints: #{params[:constraints]}"
       end
 
       @constraints = params[:constraints]
     end
 
     def mutate(params={})
-      # get omega parameter
-      omega = @get_omega.call(@generation)
+      # get chi parameter
+      chi = @get_chi.call(@iteration)
 
       # move particles
-      @particles.each_with_index do |p,i| 
-        p.move(omega, @c1, @c2, @swarm_attractor)
+      @particles.each_with_index do |p,i|
+        p.move(chi, @c1, @c2, @swarm_attractor)
         if @constraints
           p.remain_within(@constraints)
         end
       end
 
-      @generation += 1
+      @iteration += 1
     end
   end
 end

data/lib/mhl/qpso_swarm.rb

@@ -1,6 +1,3 @@
-require 'matrix'
-require 'securerandom'
-
 require 'mhl/generic_swarm'
 require 'mhl/quantum_particle'
 
@@ -17,28 +14,42 @@ module MHL
       # find problem dimension
       @dimension  = initial_positions[0].size
 
-      @generation = 1
+      @iteration = 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 }
+        ->(it) { (params[:alpha] || DEFAULT_ALPHA).to_f }
+      end
+
+      if params.has_key? :constraints
+        puts "QPSOSwarm called w/ constraints: #{params[:constraints]}"
       end
+
+      @constraints = params[:constraints]
     end
 
     def mutate
       # get alpha parameter
-      alpha = @get_alpha.call(@generation)
+      alpha = @get_alpha.call(@iteration)
 
-      # this calculates the C_n parameter (basically, the centroid of the set
-      # of all the particle attractors) as defined in [SUN11], formulae 4.81
-      # and 4.82
-      c_n = @particles.inject(Vector[*[0]*@dimension]) {|s,p| s += p.attractor[:position] } / @size.to_f
+      # this calculates the C_n parameter (the centroid of the set of all the
+      # particle attractors) as defined in equations 4.81 and 4.82 of [SUN11].
+      attractors = @particles.map {|p| p.attractor[:position] }
+      c_n = 0.upto(@dimension-1).map do |j|
+        attractors.inject(0.0) {|s,attr| s += attr[j] } / @size.to_f
+      end
 
-      @particles.each { |p| p.move(alpha, c_n, @swarm_attractor) }
+      # move particles
+      @particles.each do |p|
+        p.move(alpha, c_n, @swarm_attractor)
+        if @constraints
+          p.remain_within(@constraints)
+        end
+      end
 
-      @generation += 1
+      @iteration += 1
     end
 
   end