Skip to content

D
dlib
Commit e273f515 authored by Davis King's avatar Davis King
Browse files
Options

Added find_min_global() overloads.

parent 3284f575
Show whitespace changes
Inline Side-by-side
Showing with 392 additions and 15 deletions
dlib/global_optimization/find_max_global.h
View file @ e273f515
......@@ -112,6 +112,8 @@ template <typename T> static auto go(T&& f, const matrix<double, 0, 1>& a) -> de
// ----------------------------------------------------------------------------------------
namespace impl
{
template <
typename funct
>
......@@ -119,8 +121,9 @@ template <typename T> static auto go(T&& f, const matrix<double, 0, 1>& a) -> de
std::vector<funct>& functions,
std::vector<function_spec> specs,
const max_function_calls num,
const std::chrono::nanoseconds max_runtime = FOREVER,
double solver_epsilon = 0
const std::chrono::nanoseconds max_runtime,
double solver_epsilon,
double ymult
)
{
// Decide which parameters should be searched on a log scale. Basically, it's
......@@ -165,7 +168,7 @@ template <typename T> static auto go(T&& f, const matrix<double, 0, 1>& a) -> de
if (log_scale[next.function_idx()][j])
x(j) = std::exp(x(j));
}
double y = call_function_and_expand_args(functions[next.function_idx()], x);
double y = ymult*call_function_and_expand_args(functions[next.function_idx()], x);
next.set(y);
}
......@@ -180,7 +183,38 @@ template <typename T> static auto go(T&& f, const matrix<double, 0, 1>& a) -> de
if (log_scale[function_idx][j])
x(j) = std::exp(x(j));
}
return std::make_pair(function_idx, function_evaluation(x,std::move(y)));
return std::make_pair(function_idx, function_evaluation(x,y/ymult));
}
}
// ----------------------------------------------------------------------------------------
template <
typename funct
>
std::pair<size_t,function_evaluation> find_max_global (
std::vector<funct>& functions,
std::vector<function_spec> specs,
const max_function_calls num,
const std::chrono::nanoseconds max_runtime = FOREVER,
double solver_epsilon = 0
)
{
return impl::find_max_global(functions, std::move(specs), num, max_runtime, solver_epsilon, +1);
}
template <
typename funct
>
std::pair<size_t,function_evaluation> find_min_global (
std::vector<funct>& functions,
std::vector<function_spec> specs,
const max_function_calls num,
const std::chrono::nanoseconds max_runtime = FOREVER,
double solver_epsilon = 0
)
{
return impl::find_max_global(functions, std::move(specs), num, max_runtime, solver_epsilon, -1);
}
// ----------------------------------------------------------------------------------------
......@@ -203,6 +237,24 @@ template <typename T> static auto go(T&& f, const matrix<double, 0, 1>& a) -> de
return find_max_global(functions, std::move(specs), num, max_runtime, solver_epsilon).second;
}
template <
typename funct
>
function_evaluation find_min_global (
funct f,
const matrix<double,0,1>& bound1,
const matrix<double,0,1>& bound2,
const std::vector<bool>& is_integer_variable,
const max_function_calls num,
const std::chrono::nanoseconds max_runtime = FOREVER,
double solver_epsilon = 0
)
{
std::vector<funct> functions(1,std::move(f));
std::vector<function_spec> specs(1, function_spec(bound1, bound2, is_integer_variable));
return find_min_global(functions, std::move(specs), num, max_runtime, solver_epsilon).second;
}
// ----------------------------------------------------------------------------------------
template <
......@@ -220,6 +272,21 @@ template <typename T> static auto go(T&& f, const matrix<double, 0, 1>& a) -> de
return find_max_global(std::move(f), bound1, bound2, is_integer_variable, num, FOREVER, solver_epsilon);
}
template <
typename funct
>
function_evaluation find_min_global (
funct f,
const matrix<double,0,1>& bound1,
const matrix<double,0,1>& bound2,
const std::vector<bool>& is_integer_variable,
const max_function_calls num,
double solver_epsilon
)
{
return find_min_global(std::move(f), bound1, bound2, is_integer_variable, num, FOREVER, solver_epsilon);
}
// ----------------------------------------------------------------------------------------
template <
......@@ -237,6 +304,21 @@ template <typename T> static auto go(T&& f, const matrix<double, 0, 1>& a) -> de
return find_max_global(std::move(f), bound1, bound2, std::vector<bool>(bound1.size(),false), num, max_runtime, solver_epsilon);
}
template <
typename funct
>
function_evaluation find_min_global (
funct f,
const matrix<double,0,1>& bound1,
const matrix<double,0,1>& bound2,
const max_function_calls num,
const std::chrono::nanoseconds max_runtime = FOREVER,
double solver_epsilon = 0
)
{
return find_min_global(std::move(f), bound1, bound2, std::vector<bool>(bound1.size(),false), num, max_runtime, solver_epsilon);
}
// ----------------------------------------------------------------------------------------
template <
......@@ -253,6 +335,20 @@ template <typename T> static auto go(T&& f, const matrix<double, 0, 1>& a) -> de
return find_max_global(std::move(f), bound1, bound2, std::vector<bool>(bound1.size(),false), num, FOREVER, solver_epsilon);
}
template <
typename funct
>
function_evaluation find_min_global (
funct f,
const matrix<double,0,1>& bound1,
const matrix<double,0,1>& bound2,
const max_function_calls num,
double solver_epsilon
)
{
return find_min_global(std::move(f), bound1, bound2, std::vector<bool>(bound1.size(),false), num, FOREVER, solver_epsilon);
}
// ----------------------------------------------------------------------------------------
template <
......@@ -270,6 +366,21 @@ template <typename T> static auto go(T&& f, const matrix<double, 0, 1>& a) -> de
return find_max_global(std::move(f), matrix<double,0,1>({bound1}), matrix<double,0,1>({bound2}), num, max_runtime, solver_epsilon);
}
template <
typename funct
>
function_evaluation find_min_global (
funct f,
const double bound1,
const double bound2,
const max_function_calls num,
const std::chrono::nanoseconds max_runtime = FOREVER,
double solver_epsilon = 0
)
{
return find_min_global(std::move(f), matrix<double,0,1>({bound1}), matrix<double,0,1>({bound2}), num, max_runtime, solver_epsilon);
}
// ----------------------------------------------------------------------------------------
template <
......@@ -286,6 +397,20 @@ template <typename T> static auto go(T&& f, const matrix<double, 0, 1>& a) -> de
return find_max_global(std::move(f), matrix<double,0,1>({bound1}), matrix<double,0,1>({bound2}), num, FOREVER, solver_epsilon);
}
template <
typename funct
>
function_evaluation find_min_global (
funct f,
const double bound1,
const double bound2,
const max_function_calls num,
double solver_epsilon
)
{
return find_min_global(std::move(f), matrix<double,0,1>({bound1}), matrix<double,0,1>({bound2}), num, FOREVER, solver_epsilon);
}
// ----------------------------------------------------------------------------------------
template <
......@@ -302,6 +427,20 @@ template <typename T> static auto go(T&& f, const matrix<double, 0, 1>& a) -> de
return find_max_global(std::move(f), bound1, bound2, max_function_calls(), max_runtime, solver_epsilon);
}
template <
typename funct
>
function_evaluation find_min_global (
funct f,
const matrix<double,0,1>& bound1,
const matrix<double,0,1>& bound2,
const std::chrono::nanoseconds max_runtime,
double solver_epsilon = 0
)
{
return find_min_global(std::move(f), bound1, bound2, max_function_calls(), max_runtime, solver_epsilon);
}
// ----------------------------------------------------------------------------------------
template <
......@@ -318,6 +457,20 @@ template <typename T> static auto go(T&& f, const matrix<double, 0, 1>& a) -> de
return find_max_global(std::move(f), bound1, bound2, max_function_calls(), max_runtime, solver_epsilon);
}
template <
typename funct
>
function_evaluation find_min_global (
funct f,
const double bound1,
const double bound2,
const std::chrono::nanoseconds max_runtime,
double solver_epsilon = 0
)
{
return find_min_global(std::move(f), bound1, bound2, max_function_calls(), max_runtime, solver_epsilon);
}
// ----------------------------------------------------------------------------------------
template <
......@@ -335,6 +488,21 @@ template <typename T> static auto go(T&& f, const matrix<double, 0, 1>& a) -> de
return find_max_global(std::move(f), bound1, bound2, is_integer_variable, max_function_calls(), max_runtime, solver_epsilon);
}
template <
typename funct
>
function_evaluation find_min_global (
funct f,
const matrix<double,0,1>& bound1,
const matrix<double,0,1>& bound2,
const std::vector<bool>& is_integer_variable,
const std::chrono::nanoseconds max_runtime,
double solver_epsilon = 0
)
{
return find_min_global(std::move(f), bound1, bound2, is_integer_variable, max_function_calls(), max_runtime, solver_epsilon);
}
// ----------------------------------------------------------------------------------------
}
......
dlib/global_optimization/find_max_global_abstract.h
View file @ e273f515
......@@ -53,7 +53,7 @@ namespace dlib
/*!
WHAT THIS OBJECT REPRESENTS
This is a simple typed integer class used to strongly type the "max number
of function calls" argument to find_max_global().
of function calls" argument to find_max_global() and find_min_global().
!*/
......@@ -136,6 +136,21 @@ namespace dlib
optimizer.
!*/
template <
typename funct
>
std::pair<size_t,function_evaluation> find_min_global (
std::vector<funct>& functions,
const std::vector<function_spec>& specs,
const max_function_calls num,
const std::chrono::nanoseconds max_runtime = FOREVER,
double solver_epsilon = 0
);
/*!
This function is identical to the find_max_global() defined immediately above,
except that we perform minimization rather than maximization.
!*/
// ----------------------------------------------------------------------------------------
template <
......@@ -204,9 +219,26 @@ namespace dlib
optimizer.
!*/
template <
typename funct
>
function_evaluation find_min_global (
funct f,
const matrix<double,0,1>& bound1,
const matrix<double,0,1>& bound2,
const std::vector<bool>& is_integer_variable,
const max_function_calls num,
const std::chrono::nanoseconds max_runtime = FOREVER,
double solver_epsilon = 0
);
/*!
This function is identical to the find_max_global() defined immediately above,
except that we perform minimization rather than maximization.
!*/
// ----------------------------------------------------------------------------------------
// The following functions are just convenient overloads for calling the above defined
// find_max_global() routines.
// find_max_global() and find_min_global() routines.
// ----------------------------------------------------------------------------------------
template <
......@@ -224,6 +256,21 @@ namespace dlib
return find_max_global(std::move(f), bound1, bound2, std::vector<bool>(bound1.size(),false), num, FOREVER, solver_epsilon);
}
template <
typename funct
>
function_evaluation find_min_global (
funct f,
const matrix<double,0,1>& bound1,
const matrix<double,0,1>& bound2,
const std::vector<bool>& is_integer_variable,
const max_function_calls num,
double solver_epsilon
)
{
return find_min_global(std::move(f), bound1, bound2, std::vector<bool>(bound1.size(),false), num, FOREVER, solver_epsilon);
}
// ----------------------------------------------------------------------------------------
template <
......@@ -241,6 +288,21 @@ namespace dlib
return find_max_global(std::move(f), bound1, bound2, std::vector<bool>(bound1.size(),false), num, max_runtime, solver_epsilon);
}
template <
typename funct
>
function_evaluation find_min_global (
funct f,
const matrix<double,0,1>& bound1,
const matrix<double,0,1>& bound2,
const max_function_calls num,
const std::chrono::nanoseconds max_runtime = FOREVER,
double solver_epsilon = 0
)
{
return find_min_global(std::move(f), bound1, bound2, std::vector<bool>(bound1.size(),false), num, max_runtime, solver_epsilon);
}
// ----------------------------------------------------------------------------------------
template <
......@@ -257,6 +319,20 @@ namespace dlib
return find_max_global(std::move(f), bound1, bound2, std::vector<bool>(bound1.size(),false), num, FOREVER, solver_epsilon);
}
template <
typename funct
>
function_evaluation find_min_global (
funct f,
const matrix<double,0,1>& bound1,
const matrix<double,0,1>& bound2,
const max_function_calls num,
double solver_epsilon
)
{
return find_min_global(std::move(f), bound1, bound2, std::vector<bool>(bound1.size(),false), num, FOREVER, solver_epsilon);
}
// ----------------------------------------------------------------------------------------
template <
......@@ -274,6 +350,21 @@ namespace dlib
return find_max_global(std::move(f), matrix<double,0,1>({bound1}), matrix<double,0,1>({bound2}), num, max_runtime, solver_epsilon);
}
template <
typename funct
>
function_evaluation find_min_global (
funct f,
const double bound1,
const double bound2,
const max_function_calls num,
const std::chrono::nanoseconds max_runtime = FOREVER,
double solver_epsilon = 0
)
{
return find_min_global(std::move(f), matrix<double,0,1>({bound1}), matrix<double,0,1>({bound2}), num, max_runtime, solver_epsilon);
}
// ----------------------------------------------------------------------------------------
template <
......@@ -290,6 +381,20 @@ namespace dlib
return find_max_global(std::move(f), matrix<double,0,1>({bound1}), matrix<double,0,1>({bound2}), num, FOREVER, solver_epsilon);
}
template <
typename funct
>
function_evaluation find_min_global (
funct f,
const double bound1,
const double bound2,
const max_function_calls num,
double solver_epsilon
)
{
return find_min_global(std::move(f), matrix<double,0,1>({bound1}), matrix<double,0,1>({bound2}), num, FOREVER, solver_epsilon);
}
// ----------------------------------------------------------------------------------------
template <
......@@ -306,6 +411,20 @@ namespace dlib
return find_max_global(std::move(f), bound1, bound2, max_function_calls(), max_runtime, solver_epsilon);
}
template <
typename funct
>
function_evaluation find_min_global (
funct f,
const matrix<double,0,1>& bound1,
const matrix<double,0,1>& bound2,
const std::chrono::nanoseconds max_runtime,
double solver_epsilon = 0
)
{
return find_min_global(std::move(f), bound1, bound2, max_function_calls(), max_runtime, solver_epsilon);
}
// ----------------------------------------------------------------------------------------
template <
......@@ -322,6 +441,20 @@ namespace dlib
return find_max_global(std::move(f), bound1, bound2, max_function_calls(), max_runtime, solver_epsilon);
}
template <
typename funct
>
function_evaluation find_min_global (
funct f,
const double bound1,
const double bound2,
const std::chrono::nanoseconds max_runtime,
double solver_epsilon = 0
)
{
return find_min_global(std::move(f), bound1, bound2, max_function_calls(), max_runtime, solver_epsilon);
}
// ----------------------------------------------------------------------------------------
template <
......@@ -339,6 +472,21 @@ namespace dlib
return find_max_global(std::move(f), bound1, bound2, is_integer_variable, max_function_calls(), max_runtime, solver_epsilon);
}
template <
typename funct
>
function_evaluation find_min_global (
funct f,
const matrix<double,0,1>& bound1,
const matrix<double,0,1>& bound2,
const std::vector<bool>& is_integer_variable,
const std::chrono::nanoseconds max_runtime,
double solver_epsilon = 0
)
{
return find_min_global(std::move(f), bound1, bound2, is_integer_variable, max_function_calls(), max_runtime, solver_epsilon);
}
// ----------------------------------------------------------------------------------------
}
......
dlib/test/global_optimization.cpp
View file @ e273f515
......@@ -213,6 +213,66 @@ namespace
DLIB_TEST_MSG(std::abs(result.y - 21.9210397) < 0.0001, std::abs(result.y - 21.9210397));
}
// ----------------------------------------------------------------------------------------
void test_find_min_global(
)
{
print_spinner();
auto rosen = [](const matrix<double,0,1>& x) { return +1*( 100*std::pow(x(1) - x(0)*x(0),2.0) + std::pow(1 - x(0),2)); };
auto result = find_min_global(rosen, {0, 0}, {2, 2}, max_function_calls(100), 0);
matrix<double,0,1> true_x = {1,1};
dlog << LINFO << "rosen: " << trans(result.x);
DLIB_TEST_MSG(min(abs(true_x-result.x)) < 1e-5, min(abs(true_x-result.x)));
print_spinner();
result = find_min_global(rosen, {0, 0}, {2, 2}, max_function_calls(100));
dlog << LINFO << "rosen: " << trans(result.x);
DLIB_TEST_MSG(min(abs(true_x-result.x)) < 1e-5, min(abs(true_x-result.x)));
print_spinner();
result = find_min_global(rosen, {0, 0}, {2, 2}, std::chrono::seconds(5));
dlog << LINFO << "rosen: " << trans(result.x);
DLIB_TEST_MSG(min(abs(true_x-result.x)) < 1e-5, min(abs(true_x-result.x)));
print_spinner();
result = find_min_global(rosen, {0, 0}, {2, 2}, {false,false}, max_function_calls(100));
dlog << LINFO << "rosen: " << trans(result.x);
DLIB_TEST_MSG(min(abs(true_x-result.x)) < 1e-5, min(abs(true_x-result.x)));
print_spinner();
result = find_min_global(rosen, {0, 0}, {0.9, 0.9}, {false,false}, max_function_calls(100));
true_x = {0.9, 0.81};
dlog << LINFO << "rosen, bounded at 0.9: " << trans(result.x);
DLIB_TEST_MSG(min(abs(true_x-result.x)) < 1e-5, min(abs(true_x-result.x)));
print_spinner();
result = find_min_global([](double x){ return std::pow(x-2,2.0); }, -10, 10, max_function_calls(10), 0);
dlog << LINFO << "(x-2)^2: " << trans(result.x);
DLIB_TEST(result.x.size()==1);
DLIB_TEST(std::abs(result.x - 2) < 1e-9);
print_spinner();
result = find_min_global([](double x){ return std::pow(x-2,2.0); }, -10, 1, max_function_calls(10));
dlog << LINFO << "(x-2)^2, bound at 1: " << trans(result.x);
DLIB_TEST(result.x.size()==1);
DLIB_TEST(std::abs(result.x - 1) < 1e-9);
print_spinner();
result = find_min_global([](double x){ return std::pow(x-2,2.0); }, -10, 1, std::chrono::seconds(2));
dlog << LINFO << "(x-2)^2, bound at 1: " << trans(result.x);
DLIB_TEST(result.x.size()==1);
DLIB_TEST(std::abs(result.x - 1) < 1e-9);
print_spinner();
result = find_min_global([](double a, double b){ return complex_holder_table(a,b);},
{-10, -10}, {10, 10}, max_function_calls(300), 0);
dlog << LINFO << "complex_holder_table y: "<< result.y;
DLIB_TEST_MSG(std::abs(result.y + 21.9210397) < 0.0001, std::abs(result.y + 21.9210397));
}
// ----------------------------------------------------------------------------------------
......@@ -233,6 +293,7 @@ namespace
test_upper_bound_function(0.0, 1e-1);
test_global_function_search();
test_find_max_global();
test_find_min_global();
}
} a;
......
examples/optimization_ex.cpp
View file @ e273f515
......@@ -263,14 +263,14 @@ int main() try
// Finally, let's try the find_max_global() routine. Like find_min_bobyqa(),
// this technique is specially designed to optimize a function in the absence
// Finally, let's try the find_min_global() routine. Like find_min_bobyqa(),
// this technique is specially designed to minimize a function in the absence
// of derivative information. However, it is also designed to handle
// functions with many local optima. Where BOBYQA would get stuck at the
// nearest local optima, find_max_global() won't. find_max_global() uses a
// nearest local optima, find_min_global() won't. find_min_global() uses a
// global optimization method based on a combination of non-parametric global
// function modeling and BOBYQA style quadratic trust region modeling to
// efficiently find a global maximizer. It usually does a good job with a
// efficiently find a global minimizer. It usually does a good job with a
// relatively small number of calls to the function being optimized.
//
// You also don't have to give it a starting point or set any parameters,
......@@ -296,20 +296,20 @@ int main() try
}
// Holder table function tilted towards 10,10 and with additional
// high frequency terms to add more local optima.
return std::abs(sin(x0)*cos(x1)*exp(std::abs(1-std::sqrt(x0*x0+x1*x1)/pi))) -(x0+x1)/10 - sin(x0*10)*cos(x1*10);
return -( std::abs(sin(x0)*cos(x1)*exp(std::abs(1-std::sqrt(x0*x0+x1*x1)/pi))) -(x0+x1)/10 - sin(x0*10)*cos(x1*10));
};
// To optimize this difficult function all we need to do is call
// find_max_global()
auto result = find_max_global(complex_holder_table,
// find_min_global()
auto result = find_min_global(complex_holder_table,
{-10,-10}, // lower bounds
{10,10}, // upper bounds
max_function_calls(300));
cout.precision(9);
// These cout statements will show that find_max_global() found the
// These cout statements will show that find_min_global() found the
// globally optimal solution to 9 digits of precision:
cout << "complex holder table function solution y (should be 21.9210397): " << result.y << endl;
cout << "complex holder table function solution y (should be -21.9210397): " << result.y << endl;
cout << "complex holder table function solution x:\n" << result.x << endl;
}
catch (std::exception& e)
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment