mhl 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 3e0490b924de2e42d7fd0935673abd7d232b07ed
-  data.tar.gz: 51076e97078fc49710f9b6d86dc236e09cac5d99
+SHA256:
+  metadata.gz: 36fae082a93b3e25f96b3157a62e8c6d5d95e63379fc6790a2628abcc1c7d754
+  data.tar.gz: 23a0d3730c592f7209d95db64f4843fef6d9e220c76ecf68240dfd0d0d917d63
 SHA512:
-  metadata.gz: a1aac62bdff38e7c43d0bd58c06703ccf0df63a365b9c9e004b8f1a2a8f2cba59d2772a6e37c2dbba2c928e3ce5dffad6fd8b7c258c40979789a09217fdde090
-  data.tar.gz: 383e9ce734b17fbb47f843ff91e487b53dfed05a1df65bb70a09678b61eb98948b542eff2f3b45f9435d030ae5f7cbc816dc12ac2ba4447ad86e704469a1db97
+  metadata.gz: eb0309f4908366b7940ad7d0b160a9aac5a2e2b7c2fe20affaf8176e3f5859bb695ed5182d273c6ebd382325fbd97984d945d9d8063dd2dc47428353ec8572b7
+  data.tar.gz: f2ed2cb5eb6f0e00dd0ec4d22153510c19b77746e14278664146ebcc2bb04e9b30a7f061c0c0bc6dfbc395dd164b9ce55ab862cb9d5e51940f42cc8a01b0cf84

data/.projections.json

@@ -0,0 +1,12 @@
+{
+  "*": {"make": "bundle exec rake test"},
+  "*.rb": {"path": "lib"},
+  "lib/mhl/*.rb": {
+    "type": "source",
+    "alternate": "test/mhl/{}_test.rb"
+  },
+  "test/mhl/*_test.rb": {
+    "type": "test",
+    "alternate": "lib/mhl/{}.rb"
+  }
+}

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+ - 2.3
+ - jruby
+ - rbx-3
+script: bundle exec rake test

data/README.md

@@ -1,5 +1,9 @@
 # ruby-mhl - A Ruby metaheuristics library
 
+[![Gem Version](https://badge.fury.io/rb/mhl.svg)](https://badge.fury.io/rb/mhl)
+[![Build Status](https://travis-ci.org/mtortonesi/ruby-mhl.png?branch=master)](https://travis-ci.org/mtortonesi/ruby-mhl)
+[![Code Climate](https://codeclimate.com/github/mtortonesi/ruby-mhl.png)](https://codeclimate.com/github/mtortonesi/ruby-mhl)
+
 ruby-mhl is a scientific library that provides a fairly large array of advanced
 computational intelligence methods for continuous optimization solutions.
 
@@ -9,26 +13,19 @@ Particle Swarm Optimization (constrained PSO, quantum-inspired PSO, and a
 multi-swarm version of quantum-inspired PSO), extended with adaptation 
 mechanisms to provide support for dynamic optimization problems.
 
-ruby-mhl was designed for _high duty_ target functions, whose evaluation
-typically involves one or more simulation runs, possibly defined on very
-complex domains (or search spaces), and implemented in JRuby for performance
-reasons. To this end, ruby-mhl automatically takes advantage of the parallelism
-provided by the processor.
+ruby-mhl was designed for _heavy duty_ target functions, whose evaluation
+typically involves one or more long simulation runs, possibly defined on very
+complex domains (or search spaces). To this end, ruby-mhl allows to evaluate
+the target function in a concurrent fashion, automatically taking advantage of
+the full amount of parallelism offered by the processor if the application is
+running on a Ruby interpreter that does not have a GIL, such as JRuby.
+(ruby-mhl will work with any Ruby interpreter, but the adoption of JRuby is
+strongly recommended for performance reasons.)
 
 
 ## Installation
 
-To install ruby-mhl you first have to install Java and JRuby. This is a system
-dependent step, so I won't show you how to do it. However, if you are on Linux
-or OS X I recommend you to use [rbenv](https://github.com/rbenv/rbenv) to
-install and manage your Ruby installations.
-
-Once you have JRuby installed, you need to install bundler:
-
-    gem install bundler
-
-
-### Stable version
+### Stable version (recommended)
 
 You can get the stable version of ruby-mhl by installing the mhl gem from
 RubyGems:
@@ -74,16 +71,16 @@ x<sub>2</sub><sup>2</sup>_ equation with a genetic algorithm:
 require 'mhl'
 
 solver = MHL::GeneticAlgorithmSolver.new(
-  :population_size           => 80,
-  :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(100) } }
+  population_size: 80,
+  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(100) } }
   },
-  :exit_condition => lambda {|generation,best| best[:fitness] == 0}
+  exit_condition: lambda {|generation,best| best[:fitness] == 0}
 )
 solver.solve(Proc.new{|x| -(x[0] ** 2 + x[1] ** 2) })
 ```
@@ -148,12 +145,12 @@ x<sub>2</sub><sup>2</sup>_ equation with PSO:
 require 'mhl'
 
 solver = MHL::ParticleSwarmOptimizationSolver.new(
-  :swarm_size     => 40, # 40 is the default swarm size
-  :constraints    => {
-    :min => [ -100, -100 ],
-    :max => [  100,  100 ],
+  swarm_size: 40, # 40 is the default swarm size
+  constraints: {
+    min: [ -100, -100 ],
+    max: [  100,  100 ],
   },
-  :exit_condition => lambda {|iteration,best| best[:height].abs < 0.001 },
+  exit_condition: lambda {|iteration,best| best[:height].abs < 0.001 },
 )
 solver.solve(Proc.new{|x| -(x[0] ** 2 + x[1] ** 2) })
 ```
@@ -198,12 +195,12 @@ x<sub>2</sub><sup>2</sup>_ equation with PSO:
 require 'mhl'
 
 solver = MHL::QuantumPSOSolver.new(
-  :swarm_size     => 40, # 40 is the default swarm size
-  :constraints    => {
-    :min => [ -100, -100 ],
-    :max => [  100,  100 ],
+  swarm_size: 40, # 40 is the default swarm size
+  constraints: {
+    min: [ -100, -100 ],
+    max: [  100,  100 ],
   },
-  :exit_condition => lambda {|iteration,best| best[:height].abs < 0.001 },
+  exit_condition: lambda {|iteration,best| best[:height].abs < 0.001 },
 )
 solver.solve(Proc.new{|x| -(x[0] ** 2 + x[1] ** 2) })
 ```
@@ -240,17 +237,32 @@ IFIP/IEEE International Workshop on Business-driven IT Management (BDIM 2013),
 If you are interested in ruby-mhl, please consider reading and citing them.
 
 
+## Acknowledgements
+
+The research work that led to the development of ruby-mhl was supported in part by
+the [DICET - INMOTO - ORganization of Cultural HEritage for Smart
+Tourism and Real-time Accessibility (OR.C.HE.S.T.R.A.)](http://www.ponrec.it/open-data/progetti/scheda-progetto?ProgettoID=5835)
+project, funded by the Italian Ministry of University and Research on Axis II
+of the National operative programme (PON) for Research and Competitiveness
+2007-13 within the call 'Smart Cities and Communities and Social Innovation'
+(D.D. n.84/Ric., 2 March 2012).
+
+
 ## References
 
-[SUN11] Jun Sun, Choi-Hong Lai, Xiao-Jun Wu, "Particle Swarm Optimisation:
-Classical and Quantum Perspectives", CRC Press, 2011.
+[MUHLENBEIN93] H. Mühlenbein, D. Schlierkamp-Voosen, "Predictive Models for the
+Breeder Genetic Algorithm - I. Continuous Parameter Optimization", Journal of
+Evolutionary Computation, Vol. 1, No. 1, pp. 25-49, March 1993.
+
+[SUN11] J. Sun, C.-H. Lai, X.-J. Wu, "Particle Swarm Optimisation: Classical
+and Quantum Perspectives", CRC Press, 2011.
 
 [CLERC02] M. Clerc, J. Kennedy, "The particle swarm - explosion,
 stability, and convergence in a multidimensional complex space", IEEE
 Transactions on Evolutionary Computation, Vol. 6, No. 1, pp. 58-73,
 2002, DOI: 10.1109/4235.985692
 
-[BLACKWELL04] Tim Blackwell, Jürgen Branke, "Multi-swarm Optimization in
+[BLACKWELL04] T. Blackwell, J. 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
 
@@ -260,3 +272,11 @@ Intelligence, Vol. 25, No. 4, pp. 527-542, 2013. DOI: 10.1080/0952813X.2013.7823
 
 [CLERC12] M. Clerc, "Standard Particle Swarm Optimisation - From 2006 to 2011",
 available at: [http://clerc.maurice.free.fr/pso/SPSO\_descriptions.pdf](http://clerc.maurice.free.fr/pso/SPSO_descriptions.pdf)
+
+[LUKE15] S. Luke, "Essentials of Metaheuristics", 2nd Edition, available at:
+[https://cs.gmu.edu/~sean/book/metaheuristics/](https://cs.gmu.edu/~sean/book/metaheuristics/),
+Online Version 2.2, October 2015.
+
+[DEEP07] K. Deep, M. Thakur, "A new mutation operator for real coded genetic
+algorithms", Applied Mathematics and Computation, Vol. 193, No. 1, pp. 211-230,
+October 2007.

data/Rakefile

@@ -1,5 +1,6 @@
 require 'bundler/gem_tasks'
 
+require 'dotenv/tasks'
 require 'rake/testtask'
 
 Rake::TestTask.new do |t|
@@ -7,3 +8,5 @@ Rake::TestTask.new do |t|
   t.test_files = Dir.glob('test/**/*_test.rb').sort
   t.verbose = true
 end
+
+task :test => :dotenv

data/TODO

@@ -0,0 +1,24 @@
+IMPORTANT
+
+* improve tournament selection (with default value of k=3)
+* improve real-valued array chromosome representation support for GA
+* implement measure of population diversity
+* survey methods for increasing population diversity
+* improve implementation of continuous optimization
+  - can we introduce the notion of "mutation intensity" in GAs?
+  - what about PSO variants?
+* implement support for easy definition of memetic algorithms
+* implement SPSO (in PSO movement update, do not use the global best as informant but use
+  "links" from neighboring particles)
+* improve documentation
+* add specs
+
+
+MAYBE
+
+* in random initialization, try using Sobol sequences (or non-linear simplex
+  method or plowing method)?
+* implement CLONALG?
+* implement CMA-ES?
+* implement biased random key genetic algorithms?
+* implement more rigorous constraint management according to CoelloCoello11?

data/extra/process_ga_solver_output.awk

@@ -0,0 +1,2 @@
+BEGIN { print "Generation,Value" }
+/> gen*/ { print $3 $NF }

data/extra/process_pso_solver_output.awk

@@ -0,0 +1,2 @@
+BEGIN { print "Iteration,Value" }
+/> iter*/ { print $3 $NF }

data/lib/mhl/charged_swarm.rb

@@ -8,11 +8,13 @@ module MHL
     # traditional PSO (with inertia), swarms
     DEFAULT_CHARGED_TO_NEUTRAL_RATIO = 1.0
 
-    def initialize(size, initial_positions, initial_velocities, params={})
+    def initialize(size:, initial_positions:, initial_velocities:,
+                   charged_to_neutral_ratio: nil, alpha: nil, c1: nil, c2: nil,
+                   chi: nil, constraints: nil, logger: nil)
       @size = size
 
       # retrieve ratio between charged (QPSO) and neutral (constrained PSO) particles
-      ratio = (params[:charged_to_neutral_ratio] || DEFAULT_CHARGED_TO_NEUTRAL_RATIO).to_f
+      ratio = (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
@@ -36,28 +38,29 @@ module MHL
       @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]
+      @get_alpha = if alpha and alpha.respond_to? :call
+        alpha
       else
-        ->(it) { (params[:alpha] || DEFAULT_ALPHA).to_f }
+        ->(it) { (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
+      @c1 = (c1 || DEFAULT_C1).to_f
+      @c2 = (c2 || DEFAULT_C2).to_f
 
       # define procedure to get dynamic value for chi
-      @get_chi = if params.has_key? :chi and params[:chi].respond_to? :call
-        params[:chi]
+      @get_chi = if chi and chi.respond_to? :call
+        chi
       else
-        ->(it) { (params[:chi] || DEFAULT_CHI).to_f }
+        ->(it) { (chi || DEFAULT_CHI).to_f }
       end
 
-      if params.has_key? :constraints
-        puts "ChargedSwarm called w/ constraints: #{params[:constraints]}"
-      end
+      @constraints = constraints
+      @logger = logger
 
-      @constraints = params[:constraints]
+      if @constraints and @logger
+        @logger.info "ChargedSwarm called w/ constraints: #{@constraints}"
+      end
     end
 
     def mutate

data/lib/mhl/genetic_algorithm_solver.rb

@@ -3,7 +3,8 @@ require 'erv'
 require 'logger'
 
 require 'mhl/bitstring_genotype_space'
-require 'mhl/integer_genotype_space'
+require 'mhl/integer_vector_genotype_space'
+require 'mhl/real_vector_genotype_space'
 
 
 module MHL
@@ -18,16 +19,36 @@ module MHL
         raise ArgumentError, 'Even population size required!'
       end
 
+      @exit_condition   = opts[:exit_condition]
+      @start_population = opts[:genotype_space_conf][:start_population]
+
+      @controller = opts[:controller]
+
+      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 :warn)
+      end
+
       # perform genotype space-specific configuration
       case opts[:genotype_space_type]
       when :integer
-        @genotype_space = IntegerVectorGenotypeSpace.new(opts[:genotype_space_conf])
+        @genotype_space = IntegerVectorGenotypeSpace.new(opts[:genotype_space_conf], @logger)
 
         begin
           @mutation_probability = opts[:mutation_probability].to_f
           @mutation_rv = \
-            ERV::RandomVariable.new(:distribution           => :geometric,
-                                    :probability_of_success => @mutation_probability)
+            ERV::RandomVariable.new(distribution: :geometric,
+                                    args: { probability_of_success: @mutation_probability })
         rescue
           raise ArgumentError, 'Mutation probability configuration is wrong.'
         end
@@ -35,43 +56,35 @@ module MHL
         begin
           p_r = opts[:recombination_probability].to_f
           @recombination_rv = \
-            ERV::RandomVariable.new(:distribution => :uniform,
-                                    :min_value    => -p_r,
-                                    :max_value    => 1.0 + p_r)
+            ERV::RandomVariable.new(distribution: :uniform,
+                                    args: { min_value: -p_r, max_value: 1.0 + p_r })
         rescue
           raise ArgumentError, 'Recombination probability configuration is wrong.'
         end
 
-      when :bitstring
-        @genotype_space   = BitstringGenotypeSpace.new(opts[:genotype_space_conf])
-        @recombination_rv = ERV::RandomVariable.new(:distribution => :uniform, :max_value => 1.0)
-        @mutation_rv      = ERV::RandomVariable.new(:distribution => :uniform, :max_value => 1.0)
-
-      else
-        raise ArgumentError, 'Only integer and bitstring genotype representations are supported!'
-      end
-
-      @exit_condition   = opts[:exit_condition]
-      @start_population = opts[:genotype_space_conf][:start_population]
+      when :real
+        @genotype_space = RealVectorGenotypeSpace.new(opts[:genotype_space_conf], @logger)
 
-      @controller = opts[:controller]
+        # we have no mutation probability related parameters
+        @mutation_rv = ERV::RandomVariable.new(distribution: :uniform, args: { max_value: 1.0 })
 
-      @pool = Concurrent::FixedThreadPool.new(Concurrent::processor_count * 4)
+        begin
+          p_r = opts[:recombination_probability].to_f
+          @recombination_rv = \
+            ERV::RandomVariable.new(distribution: :uniform,
+                                    args: { min_value: -p_r, max_value: 1.0 + p_r })
+        rescue
+          raise ArgumentError, 'Recombination probability configuration is wrong.'
+        end
 
-      case opts[:logger]
-      when :stdout
-        @logger = Logger.new(STDOUT)
-      when :stderr
-        @logger = Logger.new(STDERR)
+      when :bitstring
+        @genotype_space   = BitstringGenotypeSpace.new(opts[:genotype_space_conf])
+        @recombination_rv = ERV::RandomVariable.new(distribution: :uniform, args: { max_value: 1.0 })
+        @mutation_rv      = ERV::RandomVariable.new(distribution: :uniform, args: { max_value: 1.0 })
       else
-        @logger = opts[:logger]
+        raise ArgumentError, 'Only integer and bitstring genotype representations are supported!'
       end
 
-      @quiet = opts[:quiet]
-
-      if @logger
-        @logger.level = (opts[:log_level] or Logger::WARN)
-      end
     end
 
     def mutation_probability=(new_mp)
@@ -80,8 +93,8 @@ module MHL
       end
       @mutation_probability = new_mp
       @mutation_rv = \
-        ERV::RandomVariable.new(:distribution           => :geometric,
-                                :probability_of_success => @mutation_probability)
+        ERV::RandomVariable.new(distribution: :geometric,
+                                args: { :probability_of_success => @mutation_probability })
     end
 
     # This is the method that solves the optimization problem
@@ -89,16 +102,16 @@ 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 population
       if @start_population.nil?
         population = Array.new(@population_size) do
           # generate random genotype according to the chromosome type
-          { :genotype => @genotype_space.get_random }
+          { genotype: @genotype_space.get_random }
         end
       else
         population = @start_population.map do |x|
-          { :genotype => x }
+          { genotype: x }
         end
       end
 
@@ -113,34 +126,45 @@ module MHL
         gen += 1
         @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|
-          @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
+        if params[:concurrent]
+          # the function to optimize is thread safe: call it multiple times in
+          # a concurrent fashion
+          # to this end, we use the high level promise-based construct
+          # recommended by the authors of ruby's (fantastic) concurrent gem
+          promises = population.map do |member|
+            Concurrent::Promise.execute do
+              # evaluate target function
+              # do we need to syncronize this call through population_mutex?
+              # probably not.
+              ret = func.call(member[:genotype])
+
+              # protect write access to population struct using mutex
+              population_mutex.synchronize do
+                # update fitness
+                member[:fitness] = ret
+              end
             end
+          end
 
-            # update latch
-            latch.count_down
+          # wait for all the spawned threads to finish
+          promises.map(&:wait)
+        else
+          # the function to optimize is not thread safe: call it multiple times
+          # in a sequential fashion
+          population.each do |member|
+            # evaluate target function
+            ret = func.call(member[:genotype])
+            # update fitness
+            member[:fitness] = ret
           end
         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
+        @logger.info "> gen #{gen}, best: #{population_best[:genotype]}, #{population_best[:fitness]}" unless @quiet
 
         # calculate overall best
         if overall_best.nil?