mhl 0.0.1 → 0.1.0

data/lib/mhl/particle.rb

@@ -0,0 +1,33 @@
+require 'securerandom'
+
+require 'mhl/generic_particle'
+
+module MHL
+  class Particle < GenericParticle
+    def initialize(initial_position, initial_velocity)
+      super(initial_position)
+      @velocity = initial_velocity
+    end
+
+    # move particle and update attractor
+    def move(omega, c1, c2, swarm_attractor)
+      raise 'Particle attractor is nil!' if @attractor.nil?
+      # raise 'Swarm attractor is nil!' if swarm_attractor.nil?
+
+      # 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)
+
+      # update position
+      @position = @position + @velocity
+    end
+
+  end
+end

data/lib/mhl/particle_swarm_optimization_solver.rb

@@ -1,8 +1,19 @@
-require 'matrix'
-require 'securerandom'
+require 'concurrent'
+require 'facter'
+require 'logger'
+
+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
   class ParticleSwarmOptimizationSolver
 
     def initialize(opts={})
@@ -16,6 +27,23 @@ module MHL
 
       @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
@@ -23,99 +51,69 @@ module MHL
     # 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)
+    def solve(func, params={})
       # setup particles
       if @start_positions.nil?
-        particles = Array.new(@swarm_size) do
-          { position: Vector[*@random_position_func.call], velocity: Vector[*@random_velocity_func.call] }
-        end
+        swarm = PSOSwarm.new(@swarm_size,
+                             Array.new(@swarm_size) { Vector[*@random_position_func.call] },
+                             Array.new(@swarm_size) { Vector[*@random_velocity_func.call] },
+                             params)
       else
-        particles = @start_positions.each_slice(2).map do |pos,vel|
-          { position: Vector[*pos], velocity: Vector[*vel] }
-        end
+        # 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
       end
 
       # initialize variables
       gen = 0
       overall_best = nil
 
-      # completely made up values
-      alpha   = 0.5
-      beta    = 0.3
-      gamma   = 0.7
-      delta   = 0.5
-      epsilon = 0.6
-
       # default behavior is to loop forever
       begin
         gen += 1
-        puts "Starting generation #{gen} at #{Time.now}"
+        @logger.info("PSO - Starting generation #{gen}") if @logger
 
-        # assess height for every particle
-        particles.each do |p|
-          p[:task] = Concurrent::Future.new { func.call(p[:position]) }
-        end
+        # create latch to control program termination
+        latch = Concurrent::CountDownLatch.new(@swarm_size)
 
-        # wait for all the evaluations to end
-        particles.each_with_index do |p,i|
-          p[:height] = p[:task].value
-          if p[:highest_value].nil? or p[:height] > p[:highest_value]
-            p[:highest_value]    = p[:height]
-            p[:highest_position] = p[:position]
+        # assess height for every particle
+        swarm.each do |particle|
+          @pool.post do
+            # evaluate target function
+            particle.evaluate(func)
+            # update latch
+            latch.count_down
           end
         end
 
-        # find highest particle
-        highest_particle = particles.max_by {|x| x[:height] }
+        # wait for all the threads to terminate
+        latch.wait
 
-        # calculate overall best
+        # get swarm attractor (the highest particle)
+        swarm_attractor = swarm.update_attractor
+
+        # print results
+        puts "> gen #{gen}, best: #{swarm_attractor[:position]}, #{swarm_attractor[:height]}" unless @quiet
+
+        # calculate overall best (that plays the role of swarm attractor)
         if overall_best.nil?
-          overall_best = highest_particle
+          overall_best = swarm_attractor
         else
-          overall_best = [ overall_best, highest_particle ].max_by {|x| x[:height] }
+          overall_best = [ overall_best, swarm_attractor ].max_by {|x| x[:height] }
         end
 
         # mutate swarm
-        particles.each do |p|
-          # randomly sample particles and use them as informants
-          informants = random_portion(particles)
-
-          # make sure that p is included among the informants
-          informants << p unless informants.include? p
-
-          # get fittest informant
-          fittest_informant = informants.max_by {|x| x[:height] }
-
-          # update velocity
-          p[:velocity] =
-            alpha * p[:velocity] +
-            beta  * (p[:highest_position] - p[:position]) +
-            gamma * (fittest_informant[:highest_position] - p[:position]) +
-            delta * (overall_best[:highest_position] - p[:position])
-
-          # update position
-          p[:position] = p[:position] + epsilon * p[:velocity]
-        end
+        swarm.mutate
 
       end while @exit_condition.nil? or !@exit_condition.call(gen, overall_best)
-    end
-
-    private
-
-      def random_portion(array, ratio=0.1)
-        # get size of random array to return
-        size = (ratio * array.size).ceil
-
-        (1..size).inject([]) do |acc,i|
-          # randomly sample a new element
-          begin
-            new_element = array[SecureRandom.random_number(array.size)]
-          end while acc.include? new_element
 
-          # insert element in the accumulator
-          acc << new_element
-        end
-      end
+      overall_best
+    end
 
   end
 

data/lib/mhl/pso_swarm.rb

@@ -0,0 +1,52 @@
+require 'matrix'
+require 'securerandom'
+
+require 'mhl/generic_swarm'
+require 'mhl/particle'
+
+
+module MHL
+  class PSOSwarm < GenericSwarmBehavior
+
+    def initialize(size, initial_positions, initial_velocities, params={})
+      @size      = size
+      @particles = Array.new(@size) do |index|
+        Particle.new(initial_positions[index], initial_velocities[index])
+      end
+
+      @generation = 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]
+      else
+        ->(gen) { (params[:omega] || DEFAULT_OMEGA).to_f }
+      end
+
+      if params.has_key? :constraints
+        puts "PSOSwarm called w/ :constraints => #{params[:constraints]}"
+      end
+
+      @constraints = params[:constraints]
+    end
+
+    def mutate(params={})
+      # get omega parameter
+      omega = @get_omega.call(@generation)
+
+      # move particles
+      @particles.each_with_index do |p,i| 
+        p.move(omega, @c1, @c2, @swarm_attractor)
+        if @constraints
+          p.remain_within(@constraints)
+        end
+      end
+
+      @generation += 1
+    end
+  end
+end

data/lib/mhl/qpso_swarm.rb

@@ -0,0 +1,45 @@
+require 'matrix'
+require 'securerandom'
+
+require 'mhl/generic_swarm'
+require 'mhl/quantum_particle'
+
+
+module MHL
+  class QPSOSwarm < GenericSwarmBehavior
+
+    def initialize(size, initial_positions, params={})
+      @size      = size
+      @particles = Array.new(@size) do |index|
+        QuantumParticle.new(initial_positions[index])
+      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
+    end
+
+    def mutate
+      # get alpha parameter
+      alpha = @get_alpha.call(@generation)
+
+      # 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
+
+      @particles.each { |p| p.move(alpha, c_n, @swarm_attractor) }
+
+      @generation += 1
+    end
+
+  end
+end

data/lib/mhl/quantum_particle.rb

@@ -0,0 +1,40 @@
+require 'matrix'
+require 'securerandom'
+
+require 'mhl/generic_particle'
+
+module MHL
+  class QuantumParticle < GenericParticle
+    attr_reader :position
+
+    # move particle using QPSO - Type II algorithm
+    def move(alpha, mean_best, swarm_attractor)
+      raise 'Particle attractor is nil!' if @attractor.nil?
+      # raise 'Swarm attractor is nil!' if swarm_attractor.nil?
+
+      dimension = @position.size
+
+      # phi represents the \phi_{i,n} parameter in [SUN11], formula 4.83
+      phi = Array.new(dimension) { SecureRandom.random_number }
+
+      # p_i represents the p_{i,n} parameter in [SUN11], formulae 4.82 and 4.83
+      p_i =
+        Vector[*phi.zip(@attractor[:position]).map {|phi_j,p_j| phi_j * p_j }] +
+        Vector[*phi.zip(swarm_attractor[:position]).map {|phi_j,g_j| (1.0 - phi_j) * g_j }]
+
+      # delta represents the displacement for the current position.
+      # See [SUN11], formula 4.82
+      delta =
+        @position.zip(mean_best).map {|x,y| alpha * (x-y).abs }.  # \alpha * | X_{i,n} - C_n |
+        map {|x| x * Math.log(1.0 / SecureRandom.random_number) } # log(\frac{1}{u_{i,n+1}})
+
+      # update position
+      if SecureRandom.random_number < 0.5
+        @position = p_i + Vector[*delta]
+      else
+        @position = p_i - Vector[*delta]
+      end
+    end
+
+  end
+end

data/lib/mhl/quantum_particle_swarm_optimization_solver.rb

@@ -0,0 +1,113 @@
+require 'concurrent'
+require 'facter'
+require 'logger'
+require 'matrix'
+require 'securerandom'
+
+require 'mhl/qpso_swarm'
+
+
+module MHL
+
+  # This solver implements the QPSO Type 2 algorithm.
+  #
+  # For more information, refer to equation 4.82 of:
+  # [SUN11] Jun Sun, Choi-Hong Lai, Xiao-Jun Wu, "Particle Swarm Optimisation:
+  # Classical and Quantum Perspectives", CRC Press, 2011
+  class QuantumPSOSolver
+
+    def initialize(opts={})
+      @swarm_size = opts[:swarm_size].to_i
+      unless @swarm_size
+        raise ArgumentError, 'Swarm size is a required parameter!'
+      end
+
+      @random_position_func = opts[:random_position_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 swarm
+      if @start_positions.nil?
+        swarm = QPSOSwarm.new(@swarm_size,
+                              Array.new(@swarm_size) { Vector[*@random_position_func.call] },
+                              params)
+      else
+        raise 'Unimplemented yet!'
+        # particles = @start_positions.map do |pos|
+        #   { position: Vector[*pos] }
+        # end
+      end
+
+      # initialize variables
+      gen = 0
+      overall_best = nil
+
+      # default behavior is to loop forever
+      begin
+        gen += 1
+        @logger.info "QPSO - Starting generation #{gen}" if @logger
+
+        # create latch to control program termination
+        latch = Concurrent::CountDownLatch.new(@swarm_size)
+
+        swarm.each do |particle|
+          @pool.post do
+            # evaluate target function
+            particle.evaluate(func)
+            # update latch
+            latch.count_down
+          end
+        end
+
+        # wait for all the evaluations to end
+        latch.wait
+
+        # get swarm attractor (the highest particle)
+        swarm_attractor = swarm.update_attractor
+
+        # print results
+        puts "> gen #{gen}, best: #{swarm_attractor[:position]}, #{swarm_attractor[:height]}" unless @quiet
+
+        # calculate overall best (that plays the role of swarm attractor)
+        if overall_best.nil?
+          overall_best = swarm_attractor
+        else
+          overall_best = [ overall_best, swarm_attractor ].max_by {|x| x[:height] }
+        end
+
+        # mutate swarm
+        swarm.mutate
+
+      end while @exit_condition.nil? or !@exit_condition.call(gen, overall_best)
+
+      overall_best
+    end
+
+  end
+
+end