feldtruby 0.3.16 → 0.3.18

data/lib/feldtruby/optimize/differential_evolution.rb

@@ -1,11 +1,12 @@
 require 'feldtruby/optimize/optimizer'
 require 'feldtruby/math/rand'
 require 'feldtruby/vector'
+require 'feldtruby/logger'
 
 module FeldtRuby::Optimize
 
 # Common to many Evolutionary Computation optimizers
-class EvolutionaryOptimizer < PopulationBasedOptimizer; end
+class EvolutionaryOptimizer < FeldtRuby::Optimize::PopulationBasedOptimizer; end
 
 # Base class for Differential Evolution (DE) for continuous, real-valued optimization.
 # Since there are many different DE variants this is the base class
@@ -57,12 +58,13 @@ class DEOptimizerBase < EvolutionaryOptimizer
 	def optimization_step()
 		trial, target, target_index = generate_trial_candidate_and_target()
 
-		# We get [candidate, qualityValue, subQualityValues] for each vector
 		best, worst = objective.rank_candidates([target, trial])
 
 		# Supplant the target vector with the trial vector if better
-		if best.first != target
-			@logger.note_new_better("Trial vector was better", *best)
+		if best != target
+			logger.log_data :better_candidate_found, {
+				:better => best, 
+				:quality => @objective.quality_of(best)}, "Trial vector was better"
 			trial_better = true
 			update_candidate_in_population(target_index, trial)
 		else
@@ -72,7 +74,7 @@ class DEOptimizerBase < EvolutionaryOptimizer
 		# Give feedback to strategy since some strategies use this to self-adapt
 		feedback_on_trial_vs_target(trial, target, trial_better)
 
-		[best.first]
+		[best]
 	end
 
 	#####################################
@@ -183,4 +185,26 @@ class DEOptimizer < DEOptimizerBase
 	include DE_MutationStrategy_Rand_1
 end
 
+# Optimize the _numVariables_ between the _min_ and _max_ values given _costFunction_.
+# Default is to minimize.
+def self.optimize(min, max, options = {:verbose => true}, 
+	objectiveFuncClass = FeldtRuby::Optimize::ObjectiveMinimizeBlock, &costFunction)
+	objective = objectiveFuncClass.new(&costFunction)
+	num_vars = costFunction.arity
+	search_space = SearchSpace.new_from_min_max(num_vars, min, max)
+	optimizer = DEOptimizer.new(objective, search_space, options)
+	optimizer.optimize()
+	optimizer.best.to_a
+end
+
+# Short hand wrapper for function minimization.
+def self.minimize(min, max, options = {}, &costFunction)
+	optimize(min, max, options, &costFunction)
+end
+
+# Short hand wrapper for function maximization.
+def self.maximize(min, max, options = {}, &costFunction)
+	optimize(min, max, options, FeldtRuby::Optimize::ObjectiveMaximizeBlock, &costFunction)
+end
+
 end

data/lib/feldtruby/optimize/elite_archive.rb

@@ -0,0 +1,91 @@
+require 'feldtruby/optimize'
+
+module FeldtRuby::Optimize
+
+# This keeps a record of the best/elite candidate solutions found during
+# an optimization search. It keeps separate top lists per goal being optimized
+# as well as for the aggregate quality value (fitness) itself. The top lists
+# are all sorted to allow for fast checks and insertion.
+class EliteArchive
+  DefaultParams = {
+    :NumTopPerGoal => 10,
+    :NumTopAggregate => 25
+  }
+
+  attr_reader :objective, :top_per_goal, :best
+
+  def initialize(objective, options = DefaultParams.clone)
+    @objective = objective
+    @options = options
+    init_top_lists
+  end
+
+  # A top list is an array of a fixed size that saves the top candidates
+  # based on their quality values.
+  class GlobalTopList
+    def initialize(maxSize, objective)
+      @max_size =maxSize
+      @top_list = Array.new
+      @objective = objective
+    end
+    def length; @top_list.length; end
+
+    def [](index)
+      @top_list[index]
+    end
+
+    def add(candidate)
+      last = @top_list.last
+      #puts "In #{self},\nlast = #{last}, candidate = #{candidate}, top_list = #{@top_list}"
+      if @top_list.length < @max_size || last.nil? || is_better_than?(candidate, last)
+        @top_list.pop if @top_list.length >= @max_size
+        @top_list << candidate
+        @top_list = sort_top_list
+      end
+      #puts "top_list = #{@top_list}"
+    end
+
+    def is_better_than?(candidate1, candidate2)
+      @objective.is_better_than?(candidate1, candidate2)
+    end
+
+    def sort_top_list
+      @top_list.sort_by {|c| @objective.quality_of(c).value}
+    end
+
+    def inspect
+      self.class.inspect + @top_list.inspect
+    end
+  end
+
+  class GoalTopList < GlobalTopList
+    def initialize(maxSize, objective, goalIndex)
+      super(maxSize, objective)
+      @index = goalIndex
+    end
+    def is_better_than?(candidate1, candidate2)
+      @objective.is_better_than_for_goal?(@index, candidate1, candidate2)
+    end
+    def sort_top_list
+      @top_list.sort_by {|c| 
+        qv = @objective.quality_of(c)
+        qv.sub_quality(@index, true) # We want the sub quality value posed as a minimization goal regardless of whether it is a min or max goal
+      }
+    end
+  end
+
+  def init_top_lists
+    @top_per_goal = Array.new
+    @objective.num_goals.times do |i|
+      @top_per_goal << GoalTopList.new(@options[:NumTopPerGoal], @objective, i)
+    end
+    @best = GlobalTopList.new(@options[:NumTopAggregate], @objective)
+  end
+
+  def add(candidate)
+    @best.add candidate
+    @top_per_goal.each {|tl| tl.add(candidate)}
+  end
+end
+
+end

data/lib/feldtruby/optimize/max_steps_termination_criterion.rb

@@ -15,7 +15,7 @@ end
 class FeldtRuby::Optimize::MaxStepsTerminationCriterion < FeldtRuby::Optimize::TerminationCriterion
 	attr_accessor :max_steps
 
-	def initialize(maxSteps = 1000)
+	def initialize(maxSteps = 10_000)
 		@max_steps = maxSteps
 	end
 	def terminate?(optimizer)