API References
Metaheuristics.optimize
— Function optimize(
f::Function, # objective function
bounds::AbstractMatrix,
method::AbstractAlgorithm = ECA();
logger::Function = (status) -> nothing,
)
Minimize a n-dimensional function f
with domain bounds
(2×n matrix) using method = ECA()
by default.
Example
Minimize f(x) = Σx² where x ∈ [-10, 10]³.
Solution:
julia> f(x) = sum(x.^2)
f (generic function with 1 method)
julia> bounds = [ -10.0 -10 -10; # lower bounds
10.0 10 10 ] # upper bounds
2×3 Array{Float64,2}:
-10.0 -10.0 -10.0
10.0 10.0 10.0
julia> result = optimize(f, bounds)
+=========== RESULT ==========+
| Iter.: 1008
| f(x) = 6.48646e-163
| solution.x = [-4.054471688602619e-82, 4.2565448859996416e-82, 5.505242086898758e-82]
| f calls: 21187
| Total time: 0.1231 s
+============================+
Metaheuristics.State
— TypeState datatype
State is used to store the current metaheuristic status. In fact, the optimize
function returns a State
.
best_sol
Stores the best solution found so far.population
is an Array{typeof(best_sol)} for population-based algorithms.f_calls
is the number of objective functions evaluations.g_calls
is the number of inequality constraints evaluations.h_calls
is the number of equality constraints evaluations.iteration
is the current iteration.success_rate
percentage of new generated solutions better that their parents.convergence
used save theState
at each iteration.start_time
saves thetime()
before the optimization proccess.final_time
saves thetime()
after the optimization proccess.stop
if true, then stops the optimization proccess.
Example
julia> f(x) = sum(x.^2)
f (generic function with 1 method)
julia> bounds = [ -10.0 -10 -10; # lower bounds
10.0 10 10 ] # upper bounds
2×3 Array{Float64,2}:
-10.0 -10.0 -10.0
10.0 10.0 10.0
julia> state = optimize(f, bounds)
+=========== RESULT ==========+
| Iter.: 1009
| f(x) = 7.16271e-163
| solution.x = [-7.691251412064516e-83, 1.0826961235605951e-82, -8.358428300092186e-82]
| f calls: 21190
| Total time: 0.2526 s
+============================+
julia> minimum(state)
7.162710802659093e-163
julia> minimizer(state)
3-element Array{Float64,1}:
-7.691251412064516e-83
1.0826961235605951e-82
-8.358428300092186e-82
Metaheuristics.Information
— TypeInformation Structure
Information
can be used to store the true optimum in order to stop a metaheuristic early.
Properties:
f_optimum
known minimum.x_optimum
known minimizer.
If Options
is provided, then optimize
will stop when |f(x) - f(x_optimum)| < Options.f_tol
or ‖ x - x_optimum ‖ < Options.x_tol
(euclidean distance).
Example
If you want an approximation to the minimum with accuracy of 1e-3
(|f(x) - f(x*)| < 1e-3), then you may use Information
.
julia> f(x) = sum(x.^2)
f (generic function with 1 method)
julia> bounds = [ -10.0 -10 -10; # lower bounds
10.0 10 10 ] # upper bounds
2×3 Array{Float64,2}:
-10.0 -10.0 -10.0
10.0 10.0 10.0
julia> information = Information(f_optimum = 0.0)
Information(0.0, Float64[])
julia> options = Options(f_tol = 1e-3)
Options(0.0, 0.001, 0.0, 0.0, 1000.0, 0.0, 0.0, 0, false, true, false, :minimize)
julia> state = optimize(f, bounds, ECA(information=information, options=options))
+=========== RESULT ==========+
| Iter.: 22
| f(x) = 0.000650243
| solution.x = [0.022811671589729583, 0.007052331140376011, -0.008951836265056107]
| f calls: 474
| Total time: 0.0106 s
+============================+
Metaheuristics.Options
— TypeOptions(;
x_tol::Real = 0.0,
f_tol::Real = 0.0,
g_tol::Real = 0.0,
h_tol::Real = 0.0,
f_calls_limit::Real = 0,
g_calls_limit::Real = 0,
h_calls_limit::Real = 0,
time_limit::Real = Inf,
iterations::Int = 0,
store_convergence::Bool = false,
debug::Bool = false,
seed = rand(UInt)
)
Options
stores common settings for metaheuristics such as the maximum number of iterations debug options, maximum number of function evaluations, etc.
Main properties:
x_tol
tolerance to the true minimizer if specified inInformation
.f_tol
tolerance to the true minimum if specified inInformation
.f_calls_limit
is the maximum number of function evaluations limit.time_limit
is the maximum time thatoptimize
can spend in seconds.iterations
is the maximum number iterationn permited.store_convergence
iftrue
, then push the currentState
inState.convergence
at each generation/iterationdebug
iftrue
, thenoptimize
function reports the currentState
(and interest information) for each iterations.seed
non-negative integer for the random generator seed.
Example
julia> options = Options(f_calls_limit = 1000, debug=true, seed=1)
Options(0.0, 0.0, 0.0, 0.0, 1000.0, 0.0, 0.0, 0, false, true, true, :minimize, 0x0000000000000001)
julia> f(x) = sum(x.^2)
f (generic function with 1 method)
julia> bounds = [ -10.0 -10 -10; # lower bounds
10.0 10 10 ] # upper bounds
2×3 Array{Float64,2}:
-10.0 -10.0 -10.0
10.0 10.0 10.0
julia> state = optimize(f, bounds, ECA(options=options))
[ Info: Initializing population...
[ Info: Starting main loop...
+=========== RESULT ==========+
| Iter.: 1
| f(x) = 6.97287
| solution.x = [-2.3628796262231875, -0.6781207370770752, -0.9642728360479853]
| f calls: 42
| Total time: 0.0004 s
+============================+
...
[ Info: Stopped since call_limit was met.
+=========== RESULT ==========+
| Iter.: 47
| f(x) = 1.56768e-08
| solution.x = [-2.2626761322304715e-5, -9.838697194048792e-5, 7.405966506272336e-5]
| f calls: 1000
| Total time: 0.0313 s
+============================+
Metaheuristics.convergence
— Functionconvergence(state)
get the data (touple with the number of function evaluations and fuction values) to plot the convergence graph.
Example
julia> f(x) = sum(x.^2)
f (generic function with 1 method)
julia> bounds = [ -10.0 -10 -10; # lower bounds
10.0 10 10 ] # upper bounds
2×3 Array{Float64,2}:
-10.0 -10.0 -10.0
10.0 10.0 10.0
julia> state = optimize(f, bounds, ECA(options=Options(store_convergence=true)))
+=========== RESULT ==========+
| Iter.: 1022
| f(x) = 7.95324e-163
| solution.x = [-7.782044850211721e-82, 3.590044165897827e-82, -2.4665318114710003e-82]
| f calls: 21469
| Total time: 0.3300 s
+============================+
julia> n_fes, fxs = convergence(state);
Metaheuristics.minimizer
— Functionminimizer(state)
Returns the approximation to the minimizer (argmin f(x)) stored in state
.
Base.minimum
— Methodminimum(state::Metaheuristics.State)
Returns the approximation to the minimum (min f(x)) stored in state
.
Metaheuristics.positions
— Functionpositions(state)
If state.population
has N
solutions, then returns a N
×d Matrix
.
Metaheuristics.fvals
— Functionfvals(state)
If state.population
has N
solutions, then returns a Vector
with the objective function values from items in state.population
.
Metaheuristics.nfes
— Functionnfes(state)
get the number of function evaluations.
Metaheuristics.pareto_front
— Methodpareto_front(state::State)
Returns the non-dominated solutions in state.population.
Metaheuristics.pareto_front
— Methodpareto_front(population::Array)
Returns non-dominated solutions.
Metaheuristics.create_child
— FunctionMetaheuristics.create_child(x, fx)
Constructor for a solution depending on the result of fx
.
Example
julia> import Metaheuristics
julia> Metaheuristics.create_child(rand(3), 1.0)
| f(x) = 1
| solution.x = [0.2700437125780806, 0.5233263210622989, 0.12871108215859772]
julia> Metaheuristics.create_child(rand(3), (1.0, [2.0, 0.2], [3.0, 0.3]))
| f(x) = 1
| g(x) = [2.0, 0.2]
| h(x) = [3.0, 0.3]
| x = [0.9881102595664819, 0.4816273348099591, 0.7742585077942159]
julia> Metaheuristics.create_child(rand(3), ([-1, -2.0], [2.0, 0.2], [3.0, 0.3]))
| f(x) = [-1.0, -2.0]
| g(x) = [2.0, 0.2]
| h(x) = [3.0, 0.3]
| x = [0.23983577719146854, 0.3611544510766811, 0.7998754930109109]
julia> population = [ Metaheuristics.create_child(rand(2), (randn(2), randn(2), rand(2))) for i = 1:100 ]
F space
┌────────────────────────────────────────┐
2 │⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀│
│⠀⠀⠀⠀⠀⠀⠀⠀⠄⠀⠀⠂⠀⠀⠀⠀⠀⡇⠈⡀⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀│
│⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠘⠀⡇⠀⠀⠘⠀⠄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀│
│⠀⠀⠀⠀⠀⠀⠀⠀⠂⠀⠂⠀⠀⢀⠠⠐⠀⡇⠄⠁⠀⠀⠀⡀⠀⢁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀│
│⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠁⠂⢈⠀⠈⡇⠀⡐⠃⠀⠄⠄⠀⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡀⠀⠀│
│⠀⠀⠀⠀⠀⠀⠀⠀⠀⡀⠄⢐⠠⠀⡄⠀⠀⡇⠀⠂⠈⠀⠐⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀│
│⠉⠉⠉⠉⠋⠉⠉⠉⠉⠉⠉⠙⢉⠉⠙⠉⠉⡏⠉⠉⠩⠋⠉⠩⠉⠉⠉⡉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉│
f_2 │⠀⠀⠀⠀⠀⡀⠀⠀⠀⠄⠀⠀⡀⠀⠀⠂⠀⡇⠀⠀⠀⠐⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀│
│⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠄⠀⠀⠐⡇⠠⠀⠀⠀⠈⢀⠄⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀│
│⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠂⠀⠄⠀⡀⠀⠂⡇⠐⠘⠈⠂⠀⠈⡀⠀⠀⠀⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀│
│⠀⠀⠀⠀⠀⠀⠄⠀⠀⠀⠀⠀⠂⠀⠂⠀⠀⡇⠀⠈⢀⠐⠀⠈⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀│
│⠀⠀⠀⠀⠀⠀⠀⠀⠀⠁⠀⠀⠀⠀⠀⢁⠀⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀│
│⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀│
│⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡇⠀⠀⠠⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀│
-3 │⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀│
└────────────────────────────────────────┘
-3 4
f_1