Merge pull request #30 from alyst/tli_enh2

Misc enhancements

Author: robertfeldt

src/BlackBoxOptim.jl

@@ -1,3 +1,5 @@
+VERSION >= v"0.4.0-dev+6521" && __precompile__(true)
+
 module BlackBoxOptim
 
 using Distributions, StatsBase, Compat
@@ -45,10 +47,10 @@ export  Optimizer, AskTellOptimizer, SteppingOptimizer, PopulationOptimizer,
         width_of_confidence_interval, fitness_improvement_potential,
 
         # OptimizationResults
-        minimum, f_minimum, iteration_converged, parameters,
+        minimum, f_minimum, iteration_converged, parameters, population,
 
         # OptController
-        numruns,
+        numruns, lastrun, problem,
 
         # Search spaces
         ParamBounds, Individual, SearchSpace, FixedDimensionSearchSpace, ContinuousSearchSpace,

src/opt_controller.jl

@@ -220,15 +220,17 @@ type OptController{O<:Optimizer, P<:OptimizationProblem}
   optimizer::O   # optimization algorithm
   problem::P     # opt problem
   parameters::ParamsDictChain
-  runcontrollers::Vector{Any}
+  runcontrollers::Vector{OptRunController{O}}
 end
 
 function OptController{O<:Optimizer, P<:OptimizationProblem}(optimizer::O, problem::P,
   params::ParamsDictChain)
-  OptController{O,P}(optimizer, problem, params, Any[])
+  OptController{O, P}(optimizer, problem, params, OptRunController{O}[])
 end
 
+problem(oc::OptController) = oc.problem
 numruns(oc::OptController) = length(oc.runcontrollers)
+lastrun(oc::OptController) = oc.runcontrollers[end]
 
 function update_parameters!{O<:Optimizer, P<:OptimizationProblem}(oc::OptController{O,P},
   parameters::Associative = @compat(Dict{Any,Any}()))
@@ -239,7 +241,7 @@ function update_parameters!{O<:Optimizer, P<:OptimizationProblem}(oc::OptControl
   # been setup.
   for k in keys(parameters)
     if k ∉ [:MaxTime, :MaxSteps, :MaxFuncEvals, :ShowTrace]
-      throw("It is currently not supported to change parameters that can affect the original opt problem or optimizer (here: $(k))")
+      throw(ArgumentError("It is currently not supported to change parameters that can affect the original opt problem or optimizer (here: $(k))"))
     end
   end
 
@@ -250,7 +252,14 @@ function update_parameters!{O<:Optimizer, P<:OptimizationProblem}(oc::OptControl
   end
 end
 
-# Start a new optimization run, possibly with new parameters.
+function init_rng!(parameters::Parameters)
+  if parameters[:RandomizeRngSeed]
+    parameters[:RngSeed] = rand(1:1_000_000)
+    srand(parameters[:RngSeed])
+  end
+end
+
+# Start a new optimization run, possibly with new parameters and report on results.
 function run!{O<:Optimizer, P<:OptimizationProblem}(oc::OptController{O,P})
   ctrl = OptRunController(oc.optimizer, oc.problem, oc.parameters)
   push!(oc.runcontrollers, ctrl)
@@ -260,49 +269,50 @@ function run!{O<:Optimizer, P<:OptimizationProblem}(oc::OptController{O,P})
     init_rng!(oc.parameters)
   end
 
-  run_optimization(ctrl, oc.parameters)
-end
-
-function init_rng!(parameters::Parameters)
-  if parameters[:RandomizeRngSeed]
-    parameters[:RngSeed] = rand(1:1_000_000)
-    srand(parameters[:RngSeed])
-  end
-end
-
-# Run one optimization run and report on results.
-function run_optimization(ctrl::OptRunController, params::Associative)
-  # Run the optimization. Try to return something sensible
-  # even if interrupted with Ctrl-C.
   try
     run!(ctrl)
     show_report(ctrl)
 
-    if params[:SaveFitnessTraceToCsv]
+    if oc.parameters[:SaveFitnessTraceToCsv]
       write_results(ctrl)
     end
 
-    return make_opt_result(ctrl, params)
+    return make_opt_results(ctrl, oc)
   catch ex
     # If it was a ctrl-c interrupt we try to make a result and return it...
     if isa(ex, InterruptException)
-      return make_opt_result(ctrl, params)
+      warn("Optimization interrupted, recovering intermediate results...")
+      return make_opt_results(ctrl, oc)
     else
       rethrow(ex)
     end
   end
 end
 
-function make_opt_result(ctrl::OptRunController, params::Associative)
-  SingleObjectiveOptimizationResults{Vector{Float64},Float64}(
-    string(params[:Method]),
-    best_candidate(ctrl),
+make_opt_results{O<:Optimizer}(ctrl::OptRunController{O}, oc::OptController{O}) =
+  SimpleOptimizationResults{fitness_type(problem(ctrl)), Individual}(
+    string(oc.parameters[:Method]),
     best_fitness(ctrl),
+    best_candidate(ctrl),
     stop_reason(ctrl),
     num_steps(ctrl),
     start_time(ctrl),
     elapsed_time(ctrl),
-    params,
+    oc.parameters,
     num_func_evals(ctrl)
   )
-end
+
+make_opt_results{O<:PopulationOptimizer}(ctrl::OptRunController{O}, oc::OptController{O}) =
+  PopulationOptimizationResults{fitness_type(problem(ctrl)), Individual,
+                                typeof(population(ctrl.optimizer))}(
+    string(oc.parameters[:Method]),
+    best_fitness(ctrl),
+    best_candidate(ctrl),
+    stop_reason(ctrl),
+    num_steps(ctrl),
+    start_time(ctrl),
+    elapsed_time(ctrl),
+    oc.parameters,
+    num_func_evals(ctrl),
+    population(ctrl.optimizer)
+  )

src/optimization_result.jl

@@ -1,9 +1,9 @@
-abstract OptimizationResults
+abstract OptimizationResults{F}
 
-immutable SingleObjectiveOptimizationResults{RT,FT} <: OptimizationResults
+immutable SimpleOptimizationResults{F,RT} <: OptimizationResults{F}
   method::ASCIIString # Symbol instead or flexible?
+  best_fitness::F
   best_candidate::RT
-  best_fitness::FT
   stop_reason::ASCIIString # FIXME turn into type hierarchy of immutable reasons with their attached info
   iterations::Int
   start_time::Float64
@@ -22,7 +22,24 @@ parameters(or::OptimizationResults) = or.parameters
 f_calls(or::OptimizationResults) = or.f_calls
 
 # Alternative nomenclature that mimics Optim.jl more closely.
-import Base.minimum
-Base.minimum(or::OptimizationResults) = or.best_candidate
-f_minimum(or::OptimizationResults) = or.best_fitness
+# FIXME should be it be enabled only for MinimizingFitnessScheme?
+Base.minimum(or::OptimizationResults) = best_candidate(or)
+f_minimum(or::OptimizationResults) = best_fitness(or)
+# FIXME lookup stop_reason
 iteration_converged(or::OptimizationResults) = iterations(or) >= parameters(or)[:MaxSteps]
+
+# optimization results for PopulationOptimizer storing the final population
+immutable PopulationOptimizationResults{F,RT,P} <: OptimizationResults{F}
+  method::ASCIIString # Symbol instead or flexible?
+  best_fitness::F
+  best_candidate::RT
+  stop_reason::ASCIIString # FIXME turn into type hierarchy of immutable reasons with their attached info
+  iterations::Int
+  start_time::Float64
+  elasped_time::Float64 # seconds
+  parameters::Parameters
+  f_calls::Int
+  population::P
+end
+
+population(or::PopulationOptimizationResults) = or.population

src/population.jl

@@ -42,9 +42,19 @@ params_std(pop::FitPopulation) = std(pop.individuals, 1)
 
 fitness(pop::FitPopulation, ix::Int) = pop.fitness[ix]
 
-getindex(pop::FitPopulation, rows, cols) = pop.individuals[rows, cols]
-getindex(pop::FitPopulation, ::Colon, cols) = pop.individuals[:, cols] # FIXME remove v0.3 workaround
-getindex(pop::FitPopulation, indi_ixs) = pop.individuals[:, indi_ixs]
+Base.getindex(pop::FitPopulation, rows, cols) = pop.individuals[rows, cols]
+Base.getindex(pop::FitPopulation, ::Colon, cols) = pop.individuals[:, cols] # FIXME remove v0.3 workaround
+Base.getindex(pop::FitPopulation, indi_ixs) = pop.individuals[:, indi_ixs]
+
+function Base.append!{F}(pop::FitPopulation{F}, extra_pop::FitPopulation{F})
+  numdims(pop) == numdims(extra_pop) ||
+    throw(DimensionMismatch("Cannot append population, "*
+                            "the number of parameters differs "*
+                            "($(numdims(pop)) vs $(numdims(extra_pop)))"))
+  pop.individuals = hcat(pop.individuals, extra_pop.individuals)
+  append!(pop.fitness, extra_pop.fitness)
+  return pop
+end
 
 fitness_type{F}(pop::FitPopulation{F}) = F
 candidate_type{F}(pop::FitPopulation{F}) = Candidate{F}

test/test_differential_evolution.jl

@@ -17,7 +17,7 @@ context("SimpleSelector") do
     @fact length(sampled) => numSamples
 
     # All sampled indices are indices into the population
-    @fact all([in(index, 1:popsize(DE)) for index in sampled]) => true
+    @fact all(index -> in(index, 1:popsize(DE)), sampled) => true
   end
 end
 
@@ -37,7 +37,7 @@ context("RadiusLimitedSelector") do
     @fact length(sampled) => numSamples
 
     # All sampled indices are indices into the population
-    @fact all([in(index, 1:popsize(DE)) for index in sampled]) => true
+    @fact all(index -> in(index, 1:popsize(DE)), sampled) => true
 
     mini, maxi = minimum(sampled), maximum(sampled)
     if (maxi - mini) > max(numSamples+2, sel.radius)

test/test_population.jl

@@ -11,24 +11,44 @@ facts("Population") do
     @fact isnafitness(fitness(p1, 1), fs) => true
     @fact isnafitness(fitness(p1, 4), fs) => true
 
-    @fact BlackBoxOptim.candi_pool_size(p1) => 0
-    candi1 = BlackBoxOptim.acquire_candi(p1, 1)
-    @fact BlackBoxOptim.candi_pool_size(p1) => 0
-    @fact candi1.index => 1
-    @fact isnafitness(candi1.fitness, fs) => true
-
-    candi2 = BlackBoxOptim.acquire_candi(p1, 2)
-    @fact BlackBoxOptim.candi_pool_size(p1) => 0
-    @fact candi2.index => 2
-    @fact isnafitness(candi2.fitness, fs) => true
-
-    BlackBoxOptim.release_candi(p1, candi2)
-    @fact BlackBoxOptim.candi_pool_size(p1) => 1
-
-    candi1.fitness = 5.0
-    BlackBoxOptim.accept_candi!(p1, candi1)
-    @fact BlackBoxOptim.candi_pool_size(p1) => 2
-    @fact fitness(p1, 1) => 5.0
+    context("candidates pool") do
+      @fact BlackBoxOptim.candi_pool_size(p1) => 0
+      candi1 = BlackBoxOptim.acquire_candi(p1, 1)
+      @fact BlackBoxOptim.candi_pool_size(p1) => 0
+      @fact candi1.index => 1
+      @fact isnafitness(candi1.fitness, fs) => true
+
+      candi2 = BlackBoxOptim.acquire_candi(p1, 2)
+      @fact BlackBoxOptim.candi_pool_size(p1) => 0
+      @fact candi2.index => 2
+      @fact isnafitness(candi2.fitness, fs) => true
+
+      BlackBoxOptim.release_candi(p1, candi2)
+      @fact BlackBoxOptim.candi_pool_size(p1) => 1
+
+      candi1.fitness = 5.0
+      BlackBoxOptim.accept_candi!(p1, candi1)
+      @fact BlackBoxOptim.candi_pool_size(p1) => 2
+      @fact fitness(p1, 1) => 5.0
+    end
+
+    context("append!()") do
+      p2 = FitPopulation(fs, 5, 2)
+      @fact isa(p2, FitPopulation) => true
+
+      candi22 = BlackBoxOptim.acquire_candi(p2, 2)
+      candi22.fitness = 4.0
+      BlackBoxOptim.accept_candi!(p2, candi22)
+
+      append!(p1, p2)
+      @fact numdims(p1) --> 2
+      @fact popsize(p1) --> 15
+      @fact p1[11] --> p2[1]
+      @fact fitness(p1, 12) --> 4.0
+
+      p3 = FitPopulation(fs, 5, 1)
+      @fact_throws DimensionMismatch append!(p1, p3)
+    end
   end
 
 end

test/test_toplevel_bboptimize.jl

@@ -3,18 +3,57 @@ facts("Top-level interface") do
     return( sum( 100*( x[2:end] - x[1:end-1].^2 ).^2 + ( x[1:end-1] - 1 ).^2 ) )
   end
 
-  context("run a simple optimization with mostly defaults") do
-    res = bboptimize(rosenbrock; SearchRange = (-5.0, 5.0), NumDimensions = 2,
-      MaxSteps = 2000, ShowTrace = false)
-    @fact best_fitness(res) => less_than(0.1)
-    xbest = best_candidate(res)
-    @fact typeof(xbest) => Vector{Float64}
-    @fact length(xbest) => 2
-
-    # We also mimic some of the Optim.jl api (although it is a bit strange...)
-    @fact f_minimum(res) => less_than(0.1)
-    @fact minimum(res) => xbest
-    @fact iteration_converged(res) => true
+  context("run a simple optimization") do
+    context("using bboptimize() with mostly defaults") do
+      res = bboptimize(rosenbrock; SearchRange = (-5.0, 5.0), NumDimensions = 2,
+        MaxSteps = 2000, ShowTrace = false)
+      @fact best_fitness(res) => less_than(0.1)
+      xbest = best_candidate(res)
+      @fact typeof(xbest) => Vector{Float64}
+      @fact length(xbest) => 2
+
+      # We also mimic some of the Optim.jl api (although it is a bit strange...)
+      @fact f_minimum(res) => less_than(0.1)
+      @fact minimum(res) => xbest
+      @fact iteration_converged(res) => true
+    end
+
+    context("using bbsetup()/bboptimize() with mostly defaults") do
+      opt = bbsetup(rosenbrock; SearchRange = (-5.0, 5.0), NumDimensions = 2,
+        MaxSteps = 2000, ShowTrace = false)
+      @fact numruns(opt) --> 0
+      @fact isa(problem(opt), BlackBoxOptim.FunctionBasedProblem) --> true
+      res = bboptimize(opt)
+      @fact numruns(opt) --> 1
+      @fact isa(lastrun(opt), BlackBoxOptim.OptRunController) --> true
+
+      @fact best_fitness(res) => less_than(0.1)
+      xbest = best_candidate(res)
+    end
+
+    context("using non-population optimizer") do
+      res = bboptimize(rosenbrock; Method=:generating_set_search,
+                       SearchRange = (-5.0, 5.0), NumDimensions = 2,
+                       MaxSteps = 2000, ShowTrace = false)
+      @fact isa(res, BlackBoxOptim.SimpleOptimizationResults) --> true
+      @fact best_fitness(res) => less_than(1.0)
+      xbest = best_candidate(res)
+      @fact typeof(xbest) => Vector{Float64}
+    end
+
+    context("using population optimizer") do
+      res = bboptimize(rosenbrock; Method=:adaptive_de_rand_1_bin,
+                       SearchRange = (-5.0, 5.0), NumDimensions = 2,
+                       MaxSteps = 2000, ShowTrace = false)
+      @fact isa(res, BlackBoxOptim.PopulationOptimizationResults) --> true
+      @fact best_fitness(res) => less_than(0.1)
+      xbest = best_candidate(res)
+      @fact typeof(xbest) => Vector{Float64}
+      xpop = population(res)
+      @fact isa(xpop, BlackBoxOptim.Population) --> true
+      @fact popsize(xpop) --> greater_than(0)
+      @fact numdims(xpop) --> 2
+    end
   end
 
   context("continue running an optimization after it finished") do