paref.moo_algorithms.minimizer.gpr_minimizer

Functions

calculate_optimal_scaling_g(fun, g, ...[, ...])
calculate_optimal_scaling_x(fun, ...[, ...])

Classes

DifferentialEvolution([display])
GPRMinimizer([max_iter_minimizer, ...])	Minimize any function by approximating it with a GPR and minimize the (computationally cheap) GPR

class paref.moo_algorithms.minimizer.gpr_minimizer.DifferentialEvolution(display=False)

Bases: object

__call__(function: Callable, upper_bounds: ndarray, lower_bounds: ndarray, max_iter: int = 300) → ndarray

property number_evaluations_last_call

class paref.moo_algorithms.minimizer.gpr_minimizer.GPRMinimizer(max_iter_minimizer: int = 500, training_iter: int = 2000, learning_rate: float = 0.05, min_distance_to_evaluated_points: float = 0.02)

Bases: ParefMOO

Minimize any function by approximating it with a GPR and minimize the (computationally cheap) GPR

Note

This minimizer should be used in setups where the blackbox function is computationally expensive and only a few initial samples are available.

How it works

A GPR is trained on the evaluations of the blackbox function. Then, the trained GPR is minimized by a differential evolution algorithm.

If a multi-dimensional blackbox is composed with a (scalar valued) Pareto reflection, then, for each component a GPR is trained and the composition of the trained GPRs with the Pareto reflection is minimized.

Warning

This minimizer requires a number of initial evaluations in order to perform well. If the number of evaluations is below some threshold (default: 20), a latin hypercube sampling is performed before the optimizer starts. Per construction a minimum number of 20 initial evaluations is required. In addition, this minimizer requires the design space to be a cube, i.e. characterized by bounds.

Initialize the algorithms hyperparameters

param max_iter_minimizer:

maximum number of iterations of the differential evolution algorithm

type max_iter_minimizer:

int default 100

param training_iter:

maximum training iterations of the GPR(s)

type training_iter:

int default 2000

param learning_rate:

learning rate of the training of the GPR(s)

type learning_rate:

float default 0.05

param min_required_evaluations:

minimum number of evaluations required for the training (must be greater or equal than 20)

type min_required_evaluations:

int default 20

param min_distance_to_evaluated_points:

required minimum distance to already evaluated points

type min_distance_to_evaluated_points:

float default 2e-2

apply_moo_operation(blackbox_function: BlackboxFunction) → None

Apply moo operation constructed as above

Parameters:

blackbox_function (BlackboxFunction) – blackbox function to which algorithm is applied

property supported_codomain_dimensions: int

paref.moo_algorithms.minimizer.gpr_minimizer.calculate_optimal_scaling_g(fun, g, blackbox_function, max_iter_minimizer: int = 500)

paref.moo_algorithms.minimizer.gpr_minimizer.calculate_optimal_scaling_x(fun, blackbox_function, max_iter_minimizer: int = 500)