Package 'mlr3mbo'

Description

A modern and flexible approach to Bayesian Optimization / Model Based Optimization building on the 'bbotk' package. 'mlr3mbo' is a toolbox providing both ready-to-use optimization algorithms as well as their fundamental building blocks allowing for straightforward implementation of custom algorithms. Single- and multi-objective optimization is supported as well as mixed continuous, categorical and conditional search spaces. Moreover, using 'mlr3mbo' for hyperparameter optimization of machine learning models within the 'mlr3' ecosystem is straightforward via 'mlr3tuning'. Examples of ready-to-use optimization algorithms include Efficient Global Optimization by Jones et al. (1998) doi:10.1023/A:1008306431147, ParEGO by Knowles (2006) doi:10.1109/TEVC.2005.851274 and SMS-EGO by Ponweiser et al. (2008) doi:10.1007/978-3-540-87700-4_78.

Author(s)

Maintainer: Lennart Schneider [email protected] (ORCID)

Authors:

• Jakob Richter [email protected] (ORCID)

• Marc Becker [email protected] (ORCID)

• Michel Lang [email protected] (ORCID)

• Bernd Bischl [email protected] (ORCID)

• Florian Pfisterer [email protected] (ORCID)

• Martin Binder [email protected]

• Sebastian Fischer [email protected] (ORCID)

Other contributors:

• Michael H. Buselli [copyright holder]

• Wessel Dankers [copyright holder]

• Carlos Fonseca [copyright holder]

• Manuel Lopez-Ibanez [copyright holder]

• Luis Paquete [copyright holder]

See Also

Useful links:

• https://mlr3mbo.mlr-org.com

• https://github.com/mlr-org/mlr3mbo

• Report bugs at https://github.com/mlr-org/mlr3mbo/issues

Description

This function complements mlr_acqfunctions with functions in the spirit of mlr_sugar from mlr3.

Usage

acqf(.key, ...)

Arguments

Value

AcqFunction

Examples

acqf("ei")

Description

This function complements mlr_acqfunctions with functions in the spirit of mlr_sugar from mlr3.

Usage

acqfs(.keys, ...)

Arguments

Value

List of AcqFunctions

Examples

acqfs(c("ei", "pi", "cb"))

Description

Abstract acquisition function class.

Based on the predictions of a Surrogate, the acquisition function encodes the preference to evaluate a new point.

Super class

bbotk::Objective -> AcqFunction

Active bindings

Methods

Public methods

• AcqFunction$new()

• AcqFunction$update()

• AcqFunction$reset()

• AcqFunction$eval_many()

• AcqFunction$eval_dt()

• AcqFunction$clone()

Method new()

Creates a new instance of this R6 class.

Note that the surrogate can be initialized lazy and can later be set via the active binding ⁠$surrogate⁠.

Usage

AcqFunction$new(
  id,
  constants = ParamSet$new(),
  surrogate,
  requires_predict_type_se,
  direction,
  packages = NULL,
  label = NA_character_,
  man = NA_character_
)

Arguments

Method update()

Update the acquisition function.

Can be implemented by subclasses.

Usage

AcqFunction$update()

Method reset()

Reset the acquisition function.

Can be implemented by subclasses.

Usage

AcqFunction$reset()

Method eval_many()

Evaluates multiple input values on the objective function.

Usage

AcqFunction$eval_many(xss)

Arguments

Returns

data.table::data.table() that contains one y-column for single-objective functions and multiple y-columns for multi-objective functions, e.g. data.table(y = 1:2) or data.table(y1 = 1:2, y2 = 3:4).

Method eval_dt()

Evaluates multiple input values on the objective function

Usage

AcqFunction$eval_dt(xdt)

Arguments

Returns

data.table::data.table() that contains one y-column for single-objective functions and multiple y-columns for multi-objective functions, e.g. data.table(y = 1:2) or data.table(y1 = 1:2, y2 = 3:4).

Method clone()

The objects of this class are cloneable with this method.

Usage

AcqFunction$clone(deep = FALSE)

Arguments

See Also

Other Acquisition Function: mlr_acqfunctions, mlr_acqfunctions_aei, mlr_acqfunctions_cb, mlr_acqfunctions_ehvi, mlr_acqfunctions_ehvigh, mlr_acqfunctions_ei, mlr_acqfunctions_eips, mlr_acqfunctions_mean, mlr_acqfunctions_multi, mlr_acqfunctions_pi, mlr_acqfunctions_sd, mlr_acqfunctions_smsego, mlr_acqfunctions_stochastic_cb, mlr_acqfunctions_stochastic_ei

Description

This function allows to construct an AcqOptimizer in the spirit of mlr_sugar from mlr3.

Usage

acqo(optimizer, terminator, acq_function = NULL, callbacks = NULL, ...)

Arguments

Value

AcqOptimizer

Examples

library(bbotk)
acqo(opt("random_search"), trm("evals"), catch_errors = FALSE)

Description

Optimizer for AcqFunctions which performs the acquisition function optimization. Wraps an bbotk::OptimizerBatch and bbotk::Terminator.

Parameters

n_candidates

integer(1)
Number of candidate points to propose. Note that this does not affect how the acquisition function itself is calculated (e.g., setting n_candidates > 1 will not result in computing the q- or multi-Expected Improvement) but rather the top n_candidates are selected from the bbotk::ArchiveBatch of the acquisition function bbotk::OptimInstanceBatch. Note that setting n_candidates > 1 is usually not a sensible idea but it is still supported for experimental reasons. Note that in the case of the acquisition function bbotk::OptimInstanceBatch being multi-criteria, due to using an AcqFunctionMulti, selection of the best candidates is performed via non-dominated-sorting. Default is 1.

logging_level

character(1)
Logging level during the acquisition function optimization. Can be "fatal", "error", "warn", "info", "debug" or "trace". Default is "warn", i.e., only warnings are logged.

warmstart

logical(1)
Should the acquisition function optimization be warm-started by evaluating the best point(s) present in the bbotk::Archive of the actual bbotk::OptimInstance (which is contained in the archive of the AcqFunction)? This is sensible when using a population based acquisition function optimizer, e.g., local search or mutation. Default is FALSE. Note that in the case of the bbotk::OptimInstance being multi-criteria, selection of the best point(s) is performed via non-dominated-sorting.

warmstart_size

integer(1) | "all"
Number of best points selected from the bbotk::Archive of the actual bbotk::OptimInstance that are to be used for warm starting. Can either be an integer or "all" to use all available points. Only relevant if warmstart = TRUE. Default is 1.

skip_already_evaluated

logical(1)
It can happen that the candidate(s) resulting of the acquisition function optimization were already evaluated on the actual bbotk::OptimInstance. Should such candidate proposals be ignored and only candidates that were yet not evaluated be considered? Default is TRUE.

catch_errors

logical(1)
Should errors during the acquisition function optimization be caught and propagated to the loop_function which can then handle the failed acquisition function optimization appropriately by, e.g., proposing a randomly sampled point for evaluation? Setting this to FALSE can be helpful for debugging. Default is TRUE.

Public fields

Active bindings

Methods

Public methods

• AcqOptimizer$new()

• AcqOptimizer$format()

• AcqOptimizer$print()

• AcqOptimizer$optimize()

• AcqOptimizer$reset()

• AcqOptimizer$clone()

Method new()

Creates a new instance of this R6 class.

Usage

AcqOptimizer$new(optimizer, terminator, acq_function = NULL, callbacks = NULL)

Arguments

Method format()

Helper for print outputs.

Usage

AcqOptimizer$format()

Returns

(character(1)).

Method print()

Print method.

Usage

AcqOptimizer$print()

Returns

(character()).

Method optimize()

Optimize the acquisition function.

Usage

AcqOptimizer$optimize()

Returns

data.table::data.table() with 1 row per candidate.

Method reset()

Reset the acquisition function optimizer.

Currently not used.

Usage

AcqOptimizer$reset()

Method clone()

The objects of this class are cloneable with this method.

Usage

AcqOptimizer$clone(deep = FALSE)

Arguments

Examples

if (requireNamespace("mlr3learners") &
    requireNamespace("DiceKriging") &
    requireNamespace("rgenoud")) {
  library(bbotk)
  library(paradox)
  library(mlr3learners)
  library(data.table)

  fun = function(xs) {
    list(y = xs$x ^ 2)
  }
  domain = ps(x = p_dbl(lower = -10, upper = 10))
  codomain = ps(y = p_dbl(tags = "minimize"))
  objective = ObjectiveRFun$new(fun = fun, domain = domain, codomain = codomain)

  instance = OptimInstanceBatchSingleCrit$new(
    objective = objective,
    terminator = trm("evals", n_evals = 5))

  instance$eval_batch(data.table(x = c(-6, -5, 3, 9)))

  learner = default_gp()

  surrogate = srlrn(learner, archive = instance$archive)

  acq_function = acqf("ei", surrogate = surrogate)

  acq_function$surrogate$update()
  acq_function$update()

  acq_optimizer = acqo(
    optimizer = opt("random_search", batch_size = 1000),
    terminator = trm("evals", n_evals = 1000),
    acq_function = acq_function)

  acq_optimizer$optimize()
}

Description

Chooses a default acquisition function, i.e. the criterion used to propose future points. For synchronous single-objective optimization, defaults to mlr_acqfunctions_ei. For synchronous multi-objective optimization, defaults to mlr_acqfunctions_smsego. For asynchronous single-objective optimization, defaults to mlr_acqfunctions_stochastic_cb.

Usage

default_acqfunction(instance)

Arguments

Value

AcqFunction

See Also

Other mbo_defaults: default_acqoptimizer(), default_gp(), default_loop_function(), default_result_assigner(), default_rf(), default_surrogate(), mbo_defaults

Description

Chooses a default acquisition function optimizer. Defaults to wrapping bbotk::OptimizerBatchRandomSearch allowing 10000 function evaluations (with a batch size of 1000) via a bbotk::TerminatorEvals.

Usage

default_acqoptimizer(acq_function)

Arguments

Value

AcqOptimizer

See Also

Other mbo_defaults: default_acqfunction(), default_gp(), default_loop_function(), default_result_assigner(), default_rf(), default_surrogate(), mbo_defaults

Description

This is a helper function that constructs a default Gaussian Process mlr3::LearnerRegr which is for example used in default_surrogate.

Constructs a Kriging learner “"regr.km"” with kernel “"matern5_2"”. If noisy = FALSE (default) a small nugget effect is added nugget.stability = 10^-8 to increase numerical stability to hopefully prevent crashes of DiceKriging. If noisy = TRUE the nugget effect will be estimated with nugget.estim = TRUE. If noisy = TRUE jitter is set to TRUE to circumvent a problem with DiceKriging where already trained input values produce the exact trained output. In general, instead of the default "BFGS" optimization method we use rgenoud ("gen"), which is a hybrid algorithm, to combine global search based on genetic algorithms and local search based on gradients. This may improve the model fit and will less frequently produce a constant model prediction.

Usage

default_gp(noisy = FALSE)

Arguments

Value

mlr3::LearnerRegr

See Also

Other mbo_defaults: default_acqfunction(), default_acqoptimizer(), default_loop_function(), default_result_assigner(), default_rf(), default_surrogate(), mbo_defaults

Description

Chooses a default loop_function, i.e. the Bayesian Optimization flavor to be used for optimization. For single-objective optimization, defaults to bayesopt_ego. For multi-objective optimization, defaults to bayesopt_smsego.

Usage

default_loop_function(instance)

Arguments

Value

loop_function

See Also

Other mbo_defaults: default_acqfunction(), default_acqoptimizer(), default_gp(), default_result_assigner(), default_rf(), default_surrogate(), mbo_defaults

Description

Chooses a default result assigner. Defaults to ResultAssignerArchive.

Usage

default_result_assigner(instance)

Arguments

Value

ResultAssigner

See Also

Other mbo_defaults: default_acqfunction(), default_acqoptimizer(), default_gp(), default_loop_function(), default_rf(), default_surrogate(), mbo_defaults

Description

This is a helper function that constructs a default random forest mlr3::LearnerRegr which is for example used in default_surrogate.

Constructs a ranger learner “"regr.ranger"” with num.trees = 100, keep.inbag = TRUE and se.method = "jack".

Usage

default_rf(noisy = FALSE)

Arguments

Value

mlr3::LearnerRegr

See Also

Other mbo_defaults: default_acqfunction(), default_acqoptimizer(), default_gp(), default_loop_function(), default_result_assigner(), default_surrogate(), mbo_defaults

Description

This is a helper function that constructs a default Surrogate based on properties of the bbotk::OptimInstance.

For numeric-only (including integers) parameter spaces without any dependencies a Gaussian Process is constricted via default_gp(). For mixed numeric-categorical parameter spaces, or spaces with conditional parameters a random forest is constructed via default_rf().

In any case, learners are encapsulated using “"evaluate"”, and a fallback learner is set, in cases where the surrogate learner errors. Currently, the following learner is used as a fallback: lrn("regr.ranger", num.trees = 10L, keep.inbag = TRUE, se.method = "jack").

If additionally dependencies are present in the parameter space, inactive conditional parameters are represented by missing NA values in the training design data. We simply handle those with an imputation method, added to the random forest, more concretely we use po("imputesample") (for logicals) and po("imputeoor") (for anything else) from package mlr3pipelines. Characters are always encoded as factors via po("colapply"). Out of range imputation makes sense for tree-based methods and is usually hard to beat, see Ding et al. (2010). In the case of dependencies, the following learner is used as a fallback: lrn("regr.featureless").

If n_learner is 1, the learner is wrapped as a SurrogateLearner. Otherwise, if n_learner is larger than 1, multiple deep clones of the learner are wrapped as a SurrogateLearnerCollection.

Usage

default_surrogate(
  instance,
  learner = NULL,
  n_learner = NULL,
  force_random_forest = FALSE
)

Arguments

Value

Surrogate

References

• Ding, Yufeng, Simonoff, S J (2010). “An Investigation of Missing Data Methods for Classification Trees Applied to Binary Response Data.” Journal of Machine Learning Research, 11(1), 131–170.

See Also

Other mbo_defaults: default_acqfunction(), default_acqoptimizer(), default_gp(), default_loop_function(), default_result_assigner(), default_rf(), mbo_defaults

Description

Loop functions determine the behavior of the Bayesian Optimization algorithm on a global level. For an overview of readily available loop functions, see as.data.table(mlr_loop_functions).

In general, a loop function is simply a decorated member of the S3 class loop_function. Attributes must include: id (id of the loop function), label (brief description), instance ("single-crit" and or "multi_crit"), and man (link to the manual page).

As an example, see, e.g., bayesopt_ego.

See Also

Other Loop Function: mlr_loop_functions, mlr_loop_functions_ego, mlr_loop_functions_emo, mlr_loop_functions_mpcl, mlr_loop_functions_parego, mlr_loop_functions_smsego

Description

The following defaults are set for OptimizerMbo during optimization if the respective fields are not set during initialization.

• Optimization Loop: default_loop_function
  

• Surrogate: default_surrogate
  

• Acquisition Function: default_acqfunction
  

• Acqfun Optimizer: default_acqoptimizer
  

• Result Assigner: default_result_assigner
  

See Also

Other mbo_defaults: default_acqfunction(), default_acqoptimizer(), default_gp(), default_loop_function(), default_result_assigner(), default_rf(), default_surrogate()

Description

A simple mlr3misc::Dictionary storing objects of class AcqFunction. Each acquisition function has an associated help page, see mlr_acqfunctions_[id].

For a more convenient way to retrieve and construct an acquisition function, see acqf() and acqfs().

Format

R6::R6Class object inheriting from mlr3misc::Dictionary.

Methods

See mlr3misc::Dictionary.

See Also

Sugar functions: acqf(), acqfs()

Other Dictionary: mlr_loop_functions, mlr_result_assigners

Other Acquisition Function: AcqFunction, mlr_acqfunctions_aei, mlr_acqfunctions_cb, mlr_acqfunctions_ehvi, mlr_acqfunctions_ehvigh, mlr_acqfunctions_ei, mlr_acqfunctions_eips, mlr_acqfunctions_mean, mlr_acqfunctions_multi, mlr_acqfunctions_pi, mlr_acqfunctions_sd, mlr_acqfunctions_smsego, mlr_acqfunctions_stochastic_cb, mlr_acqfunctions_stochastic_ei

Examples

library(data.table)
as.data.table(mlr_acqfunctions)
acqf("ei")

Description

Augmented Expected Improvement. Useful when working with noisy objectives. Currently only works correctly with "regr.km" as surrogate model and nugget.estim = TRUE or given.

Dictionary

This AcqFunction can be instantiated via the dictionary mlr_acqfunctions or with the associated sugar function acqf():

mlr_acqfunctions$get("aei")
acqf("aei")

Parameters

• "c" (numeric(1))
  Constant $c$ as used in Formula (14) of Huang (2012) to reflect the degree of risk aversion. Defaults to 1.

Super classes

bbotk::Objective -> mlr3mbo::AcqFunction -> AcqFunctionAEI

Public fields

Methods

Public methods

• AcqFunctionAEI$new()

• AcqFunctionAEI$update()

• AcqFunctionAEI$clone()

Method new()

Creates a new instance of this R6 class.

Usage

AcqFunctionAEI$new(surrogate = NULL, c = 1)

Arguments

Method update()

Update the acquisition function and set y_effective_best and noise_var.

Usage

AcqFunctionAEI$update()

Method clone()

The objects of this class are cloneable with this method.

Usage

AcqFunctionAEI$clone(deep = FALSE)

Arguments

References

• Huang D, Allen TT, Notz WI, Zheng N (2012). “Erratum To: Global Optimization of Stochastic Black-box Systems via Sequential Kriging Meta-Models.” Journal of Global Optimization, 54(2), 431–431.

See Also

Other Acquisition Function: AcqFunction, mlr_acqfunctions, mlr_acqfunctions_cb, mlr_acqfunctions_ehvi, mlr_acqfunctions_ehvigh, mlr_acqfunctions_ei, mlr_acqfunctions_eips, mlr_acqfunctions_mean, mlr_acqfunctions_multi, mlr_acqfunctions_pi, mlr_acqfunctions_sd, mlr_acqfunctions_smsego, mlr_acqfunctions_stochastic_cb, mlr_acqfunctions_stochastic_ei

Examples

if (requireNamespace("mlr3learners") &
    requireNamespace("DiceKriging") &
    requireNamespace("rgenoud")) {
  library(bbotk)
  library(paradox)
  library(mlr3learners)
  library(data.table)

  set.seed(2906)
  fun = function(xs) {
    list(y = xs$x ^ 2 + rnorm(length(xs$x), mean = 0, sd = 1))
  }
  domain = ps(x = p_dbl(lower = -10, upper = 10))
  codomain = ps(y = p_dbl(tags = "minimize"))
  objective = ObjectiveRFun$new(fun = fun,
    domain = domain,
    codomain = codomain,
    properties = "noisy")

  instance = OptimInstanceBatchSingleCrit$new(
    objective = objective,
    terminator = trm("evals", n_evals = 5))

  instance$eval_batch(data.table(x = c(-6, -5, 3, 9)))

  learner = lrn("regr.km",
    covtype = "matern5_2",
    optim.method = "gen",
    nugget.estim = TRUE,
    jitter = 1e-12,
    control = list(trace = FALSE))

  surrogate = srlrn(learner, archive = instance$archive)

  acq_function = acqf("aei", surrogate = surrogate)

  acq_function$surrogate$update()
  acq_function$update()
  acq_function$eval_dt(data.table(x = c(-1, 0, 1)))
}

Description

Lower / Upper Confidence Bound.

Dictionary

This AcqFunction can be instantiated via the dictionary mlr_acqfunctions or with the associated sugar function acqf():

mlr_acqfunctions$get("cb")
acqf("cb")

Parameters

• "lambda" (numeric(1))
  $\lambda$ value used for the confidence bound. Defaults to 2.

Super classes

bbotk::Objective -> mlr3mbo::AcqFunction -> AcqFunctionCB

Methods

Public methods

• AcqFunctionCB$new()

• AcqFunctionCB$clone()

Method new()

Creates a new instance of this R6 class.

Usage

AcqFunctionCB$new(surrogate = NULL, lambda = 2)

Arguments

Method clone()

The objects of this class are cloneable with this method.

Usage

AcqFunctionCB$clone(deep = FALSE)

Arguments

References

• Snoek, Jasper, Larochelle, Hugo, Adams, P R (2012). “Practical Bayesian Optimization of Machine Learning Algorithms.” In Pereira F, Burges CJC, Bottou L, Weinberger KQ (eds.), Advances in Neural Information Processing Systems, volume 25, 2951–2959.

See Also

Other Acquisition Function: AcqFunction, mlr_acqfunctions, mlr_acqfunctions_aei, mlr_acqfunctions_ehvi, mlr_acqfunctions_ehvigh, mlr_acqfunctions_ei, mlr_acqfunctions_eips, mlr_acqfunctions_mean, mlr_acqfunctions_multi, mlr_acqfunctions_pi, mlr_acqfunctions_sd, mlr_acqfunctions_smsego, mlr_acqfunctions_stochastic_cb, mlr_acqfunctions_stochastic_ei

Examples

if (requireNamespace("mlr3learners") &
    requireNamespace("DiceKriging") &
    requireNamespace("rgenoud")) {
  library(bbotk)
  library(paradox)
  library(mlr3learners)
  library(data.table)

  fun = function(xs) {
    list(y = xs$x ^ 2)
  }
  domain = ps(x = p_dbl(lower = -10, upper = 10))
  codomain = ps(y = p_dbl(tags = "minimize"))
  objective = ObjectiveRFun$new(fun = fun, domain = domain, codomain = codomain)

  instance = OptimInstanceBatchSingleCrit$new(
    objective = objective,
    terminator = trm("evals", n_evals = 5))

  instance$eval_batch(data.table(x = c(-6, -5, 3, 9)))

  learner = default_gp()

  surrogate = srlrn(learner, archive = instance$archive)

  acq_function = acqf("cb", surrogate = surrogate, lambda = 3)

  acq_function$surrogate$update()
  acq_function$eval_dt(data.table(x = c(-1, 0, 1)))
}

Description

Exact Expected Hypervolume Improvement. Calculates the exact expected hypervolume improvement in the case of two objectives. In the case of optimizing more than two objective functions, AcqFunctionEHVIGH can be used. See Emmerich et al. (2016) for details.

Super classes

bbotk::Objective -> mlr3mbo::AcqFunction -> AcqFunctionEHVI

Public fields

Methods

Public methods

• AcqFunctionEHVI$new()

• AcqFunctionEHVI$update()

• AcqFunctionEHVI$clone()

Method new()

Creates a new instance of this R6 class.

Usage

AcqFunctionEHVI$new(surrogate = NULL)

Arguments

Method update()

Update the acquisition function and set ys_front and ref_point.

Usage

AcqFunctionEHVI$update()

Method clone()

The objects of this class are cloneable with this method.

Usage

AcqFunctionEHVI$clone(deep = FALSE)

Arguments

References

• Emmerich, Michael, Yang, Kaifeng, Deutz, André, Wang, Hao, Fonseca, M. C (2016). “A Multicriteria Generalization of Bayesian Global Optimization.” In Pardalos, M. P, Zhigljavsky, Anatoly, Žilinskas, Julius (eds.), Advances in Stochastic and Deterministic Global Optimization, 229–242. Springer International Publishing, Cham.

See Also

Other Acquisition Function: AcqFunction, mlr_acqfunctions, mlr_acqfunctions_aei, mlr_acqfunctions_cb, mlr_acqfunctions_ehvigh, mlr_acqfunctions_ei, mlr_acqfunctions_eips, mlr_acqfunctions_mean, mlr_acqfunctions_multi, mlr_acqfunctions_pi, mlr_acqfunctions_sd, mlr_acqfunctions_smsego, mlr_acqfunctions_stochastic_cb, mlr_acqfunctions_stochastic_ei

Examples

if (requireNamespace("mlr3learners") &
    requireNamespace("DiceKriging") &
    requireNamespace("rgenoud")) {
  library(bbotk)
  library(paradox)
  library(mlr3learners)
  library(data.table)

  fun = function(xs) {
    list(y1 = xs$x^2, y2 = (xs$x - 2) ^ 2)
  }
  domain = ps(x = p_dbl(lower = -10, upper = 10))
  codomain = ps(y1 = p_dbl(tags = "minimize"), y2 = p_dbl(tags = "minimize"))
  objective = ObjectiveRFun$new(fun = fun, domain = domain, codomain = codomain)

  instance = OptimInstanceBatchMultiCrit$new(
    objective = objective,
    terminator = trm("evals", n_evals = 5))

  instance$eval_batch(data.table(x = c(-6, -5, 3, 9)))

  learner = default_gp()

  surrogate = srlrn(list(learner, learner$clone(deep = TRUE)), archive = instance$archive)

  acq_function = acqf("ehvi", surrogate = surrogate)

  acq_function$surrogate$update()
  acq_function$update()
  acq_function$eval_dt(data.table(x = c(-1, 0, 1)))
}

Description

Expected Hypervolume Improvement. Computed via Gauss-Hermite quadrature.

In the case of optimizing only two objective functions AcqFunctionEHVI is to be preferred.

Parameters

• "k" (integer(1))
  Number of nodes per objective used for the numerical integration via Gauss-Hermite quadrature. Defaults to 15. For example, if two objectives are to be optimized, the total number of nodes will therefore be 225 per default. Changing this value after construction requires a call to ⁠$update()⁠ to update the ⁠$gh_data⁠ field.

• "r" (numeric(1))
  Pruning rate between 0 and 1 that determines the fraction of nodes of the Gauss-Hermite quadrature rule that are ignored based on their weight value (the nodes with the lowest weights being ignored). Default is 0.2. Changing this value after construction does not require a call to ⁠$update()⁠.

Super classes

bbotk::Objective -> mlr3mbo::AcqFunction -> AcqFunctionEHVIGH

Public fields

Methods

Public methods

• AcqFunctionEHVIGH$new()

• AcqFunctionEHVIGH$update()

• AcqFunctionEHVIGH$clone()

Method new()

Creates a new instance of this R6 class.

Usage

AcqFunctionEHVIGH$new(surrogate = NULL, k = 15L, r = 0.2)

Arguments

Method update()

Update the acquisition function and set ys_front, ref_point, hypervolume and gh_data.

Usage

AcqFunctionEHVIGH$update()

Method clone()

The objects of this class are cloneable with this method.

Usage

AcqFunctionEHVIGH$clone(deep = FALSE)

Arguments

References

• Rahat, Alma, Chugh, Tinkle, Fieldsend, Jonathan, Allmendinger, Richard, Miettinen, Kaisa (2022). “Efficient Approximation of Expected Hypervolume Improvement using Gauss-Hermit Quadrature.” In Rudolph, Günter, Kononova, V. A, Aguirre, Hernán, Kerschke, Pascal, Ochoa, Gabriela, Tušar, Tea (eds.), Parallel Problem Solving from Nature – PPSN XVII, 90–103.

See Also

Other Acquisition Function: AcqFunction, mlr_acqfunctions, mlr_acqfunctions_aei, mlr_acqfunctions_cb, mlr_acqfunctions_ehvi, mlr_acqfunctions_ei, mlr_acqfunctions_eips, mlr_acqfunctions_mean, mlr_acqfunctions_multi, mlr_acqfunctions_pi, mlr_acqfunctions_sd, mlr_acqfunctions_smsego, mlr_acqfunctions_stochastic_cb, mlr_acqfunctions_stochastic_ei

Examples

if (requireNamespace("mlr3learners") &
    requireNamespace("DiceKriging") &
    requireNamespace("rgenoud")) {
  library(bbotk)
  library(paradox)
  library(mlr3learners)
  library(data.table)

  fun = function(xs) {
    list(y1 = xs$x^2, y2 = (xs$x - 2) ^ 2)
  }
  domain = ps(x = p_dbl(lower = -10, upper = 10))
  codomain = ps(y1 = p_dbl(tags = "minimize"), y2 = p_dbl(tags = "minimize"))
  objective = ObjectiveRFun$new(fun = fun, domain = domain, codomain = codomain)

  instance = OptimInstanceBatchMultiCrit$new(
    objective = objective,
    terminator = trm("evals", n_evals = 5))

  instance$eval_batch(data.table(x = c(-6, -5, 3, 9)))

  learner = default_gp()

  surrogate = srlrn(list(learner, learner$clone(deep = TRUE)), archive = instance$archive)

  acq_function = acqf("ehvigh", surrogate = surrogate)

  acq_function$surrogate$update()
  acq_function$update()
  acq_function$eval_dt(data.table(x = c(-1, 0, 1)))
}

Description

Expected Improvement.

Dictionary

This AcqFunction can be instantiated via the dictionary mlr_acqfunctions or with the associated sugar function acqf():

mlr_acqfunctions$get("ei")
acqf("ei")

Parameters

• "epsilon" (numeric(1))
  $\epsilon$ value used to determine the amount of exploration. Higher values result in the importance of improvements predicted by the posterior mean decreasing relative to the importance of potential improvements in regions of high predictive uncertainty. Defaults to 0 (standard Expected Improvement).

Super classes

bbotk::Objective -> mlr3mbo::AcqFunction -> AcqFunctionEI

Public fields

Methods

Public methods

• AcqFunctionEI$new()

• AcqFunctionEI$update()

• AcqFunctionEI$clone()

Method new()

Creates a new instance of this R6 class.

Usage

AcqFunctionEI$new(surrogate = NULL, epsilon = 0)

Arguments

Method update()

Update the acquisition function and set y_best.

Usage

AcqFunctionEI$update()

Method clone()

The objects of this class are cloneable with this method.

Usage

AcqFunctionEI$clone(deep = FALSE)

Arguments

References

• Jones, R. D, Schonlau, Matthias, Welch, J. W (1998). “Efficient Global Optimization of Expensive Black-Box Functions.” Journal of Global optimization, 13(4), 455–492.

See Also

Other Acquisition Function: AcqFunction, mlr_acqfunctions, mlr_acqfunctions_aei, mlr_acqfunctions_cb, mlr_acqfunctions_ehvi, mlr_acqfunctions_ehvigh, mlr_acqfunctions_eips, mlr_acqfunctions_mean, mlr_acqfunctions_multi, mlr_acqfunctions_pi, mlr_acqfunctions_sd, mlr_acqfunctions_smsego, mlr_acqfunctions_stochastic_cb, mlr_acqfunctions_stochastic_ei

Examples

if (requireNamespace("mlr3learners") &
    requireNamespace("DiceKriging") &
    requireNamespace("rgenoud")) {
  library(bbotk)
  library(paradox)
  library(mlr3learners)
  library(data.table)

  fun = function(xs) {
    list(y = xs$x ^ 2)
  }
  domain = ps(x = p_dbl(lower = -10, upper = 10))
  codomain = ps(y = p_dbl(tags = "minimize"))
  objective = ObjectiveRFun$new(fun = fun, domain = domain, codomain = codomain)

  instance = OptimInstanceBatchSingleCrit$new(
    objective = objective,
    terminator = trm("evals", n_evals = 5))

  instance$eval_batch(data.table(x = c(-6, -5, 3, 9)))

  learner = default_gp()

  surrogate = srlrn(learner, archive = instance$archive)

  acq_function = acqf("ei", surrogate = surrogate)

  acq_function$surrogate$update()
  acq_function$update()
  acq_function$eval_dt(data.table(x = c(-1, 0, 1)))
}

Description

Expected Improvement per Second.

It is assumed that calculations are performed on an bbotk::OptimInstanceBatchSingleCrit. Additionally to target values of the codomain that should be minimized or maximized, the bbotk::Objective of the bbotk::OptimInstanceBatchSingleCrit should return time values. The column names of the target variable and time variable must be passed as cols_y in the order ⁠(target, time)⁠ when constructing the SurrogateLearnerCollection that is being used as a surrogate.

Dictionary

This AcqFunction can be instantiated via the dictionary mlr_acqfunctions or with the associated sugar function acqf():

mlr_acqfunctions$get("eips")
acqf("eips")

Super classes

bbotk::Objective -> mlr3mbo::AcqFunction -> AcqFunctionEIPS

Public fields

Active bindings

Methods

Public methods

• AcqFunctionEIPS$new()

• AcqFunctionEIPS$update()

• AcqFunctionEIPS$clone()

Method new()

Creates a new instance of this R6 class.

Usage

AcqFunctionEIPS$new(surrogate = NULL)

Arguments

Method update()

Update the acquisition function and set y_best.

Usage

AcqFunctionEIPS$update()

Method clone()

The objects of this class are cloneable with this method.

Usage

AcqFunctionEIPS$clone(deep = FALSE)

Arguments

References

• Snoek, Jasper, Larochelle, Hugo, Adams, P R (2012). “Practical Bayesian Optimization of Machine Learning Algorithms.” In Pereira F, Burges CJC, Bottou L, Weinberger KQ (eds.), Advances in Neural Information Processing Systems, volume 25, 2951–2959.

See Also

Other Acquisition Function: AcqFunction, mlr_acqfunctions, mlr_acqfunctions_aei, mlr_acqfunctions_cb, mlr_acqfunctions_ehvi, mlr_acqfunctions_ehvigh, mlr_acqfunctions_ei, mlr_acqfunctions_mean, mlr_acqfunctions_multi, mlr_acqfunctions_pi, mlr_acqfunctions_sd, mlr_acqfunctions_smsego, mlr_acqfunctions_stochastic_cb, mlr_acqfunctions_stochastic_ei

Examples

if (requireNamespace("mlr3learners") &
    requireNamespace("DiceKriging") &
    requireNamespace("rgenoud")) {
  library(bbotk)
  library(paradox)
  library(mlr3learners)
  library(data.table)

  fun = function(xs) {
    list(y = xs$x ^ 2, time = abs(xs$x))
  }
  domain = ps(x = p_dbl(lower = -10, upper = 10))
  codomain = ps(y = p_dbl(tags = "minimize"), time = p_dbl(tags = "time"))
  objective = ObjectiveRFun$new(fun = fun, domain = domain, codomain = codomain)

  instance = OptimInstanceBatchSingleCrit$new(
    objective = objective,
    terminator = trm("evals", n_evals = 5))

  instance$eval_batch(data.table(x = c(-6, -5, 3, 9)))

  learner = default_gp()

  surrogate = srlrn(list(learner, learner$clone(deep = TRUE)), archive = instance$archive)
  surrogate$cols_y = c("y", "time")

  acq_function = acqf("eips", surrogate = surrogate)

  acq_function$surrogate$update()
  acq_function$update()
  acq_function$eval_dt(data.table(x = c(-1, 0, 1)))
}

Description

Posterior Mean.

Dictionary

This AcqFunction can be instantiated via the dictionary mlr_acqfunctions or with the associated sugar function acqf():

mlr_acqfunctions$get("mean")
acqf("mean")

Super classes

bbotk::Objective -> mlr3mbo::AcqFunction -> AcqFunctionMean

Methods

Public methods

• AcqFunctionMean$new()

• AcqFunctionMean$clone()

Method new()

Creates a new instance of this R6 class.

Usage

AcqFunctionMean$new(surrogate = NULL)

Arguments

Method clone()

The objects of this class are cloneable with this method.

Usage

AcqFunctionMean$clone(deep = FALSE)

Arguments

See Also

Other Acquisition Function: AcqFunction, mlr_acqfunctions, mlr_acqfunctions_aei, mlr_acqfunctions_cb, mlr_acqfunctions_ehvi, mlr_acqfunctions_ehvigh, mlr_acqfunctions_ei, mlr_acqfunctions_eips, mlr_acqfunctions_multi, mlr_acqfunctions_pi, mlr_acqfunctions_sd, mlr_acqfunctions_smsego, mlr_acqfunctions_stochastic_cb, mlr_acqfunctions_stochastic_ei

Examples

if (requireNamespace("mlr3learners") &
    requireNamespace("DiceKriging") &
    requireNamespace("rgenoud")) {
  library(bbotk)
  library(paradox)
  library(mlr3learners)
  library(data.table)

  fun = function(xs) {
    list(y = xs$x ^ 2)
  }
  domain = ps(x = p_dbl(lower = -10, upper = 10))
  codomain = ps(y = p_dbl(tags = "minimize"))
  objective = ObjectiveRFun$new(fun = fun, domain = domain, codomain = codomain)

  instance = OptimInstanceBatchSingleCrit$new(
    objective = objective,
    terminator = trm("evals", n_evals = 5))

  instance$eval_batch(data.table(x = c(-6, -5, 3, 9)))

  learner = default_gp()

  surrogate = srlrn(learner, archive = instance$archive)

  acq_function = acqf("mean", surrogate = surrogate)

  acq_function$surrogate$update()
  acq_function$update()
  acq_function$eval_dt(data.table(x = c(-1, 0, 1)))
}

Description

Wrapping multiple AcqFunctions resulting in a multi-objective acquisition function composed of the individual ones. Note that the optimization direction of each wrapped acquisition function is corrected for maximization.

For each acquisition function, the same Surrogate must be used. If acquisition functions passed during construction already have been initialized with a surrogate, it is checked whether the surrogate is the same for all acquisition functions. If acquisition functions have not been initialized with a surrogate, the surrogate passed during construction or lazy initialization will be used for all acquisition functions.

For optimization, AcqOptimizer can be used as for any other AcqFunction, however, the bbotk::OptimizerBatch wrapped within the AcqOptimizer must support multi-objective optimization as indicated via the multi-crit property.

Dictionary

This AcqFunction can be instantiated via the dictionary mlr_acqfunctions or with the associated sugar function acqf():

mlr_acqfunctions$get("multi")
acqf("multi")

Super classes

bbotk::Objective -> mlr3mbo::AcqFunction -> AcqFunctionMulti

Active bindings

Methods

Public methods

• AcqFunctionMulti$new()

• AcqFunctionMulti$update()

• AcqFunctionMulti$clone()

Method new()

Creates a new instance of this R6 class.

Usage

AcqFunctionMulti$new(acq_functions, surrogate = NULL)

Arguments

Method update()

Update each of the wrapped acquisition functions.

Usage

AcqFunctionMulti$update()

Method clone()

The objects of this class are cloneable with this method.

Usage

AcqFunctionMulti$clone(deep = FALSE)

Arguments

See Also

Other Acquisition Function: AcqFunction, mlr_acqfunctions, mlr_acqfunctions_aei, mlr_acqfunctions_cb, mlr_acqfunctions_ehvi, mlr_acqfunctions_ehvigh, mlr_acqfunctions_ei, mlr_acqfunctions_eips, mlr_acqfunctions_mean, mlr_acqfunctions_pi, mlr_acqfunctions_sd, mlr_acqfunctions_smsego, mlr_acqfunctions_stochastic_cb, mlr_acqfunctions_stochastic_ei

Examples

if (requireNamespace("mlr3learners") &
    requireNamespace("DiceKriging") &
    requireNamespace("rgenoud")) {
  library(bbotk)
  library(paradox)
  library(mlr3learners)
  library(data.table)

  fun = function(xs) {
    list(y = xs$x ^ 2)
  }
  domain = ps(x = p_dbl(lower = -10, upper = 10))
  codomain = ps(y = p_dbl(tags = "minimize"))
  objective = ObjectiveRFun$new(fun = fun, domain = domain, codomain = codomain)

  instance = OptimInstanceBatchSingleCrit$new(
    objective = objective,
    terminator = trm("evals", n_evals = 5))

  instance$eval_batch(data.table(x = c(-6, -5, 3, 9)))

  learner = default_gp()

  surrogate = srlrn(learner, archive = instance$archive)

  acq_function = acqf("multi",
    acq_functions = acqfs(c("ei", "pi", "cb")),
    surrogate = surrogate
  )

  acq_function$surrogate$update()
  acq_function$update()
  acq_function$eval_dt(data.table(x = c(-1, 0, 1)))
}

Description

Probability of Improvement.

Dictionary

This AcqFunction can be instantiated via the dictionary mlr_acqfunctions or with the associated sugar function acqf():

mlr_acqfunctions$get("pi")
acqf("pi")

Super classes

bbotk::Objective -> mlr3mbo::AcqFunction -> AcqFunctionPI

Public fields

Methods

Public methods

• AcqFunctionPI$new()

• AcqFunctionPI$update()

• AcqFunctionPI$clone()

Method new()

Creates a new instance of this R6 class.

Usage

AcqFunctionPI$new(surrogate = NULL)

Arguments

Method update()

Update the acquisition function and set y_best.

Usage

AcqFunctionPI$update()

Method clone()

The objects of this class are cloneable with this method.

Usage

AcqFunctionPI$clone(deep = FALSE)

Arguments

References

• Kushner, J. H (1964). “A New Method of Locating the Maximum Point of an Arbitrary Multipeak Curve in the Presence of Noise.” Journal of Basic Engineering, 86(1), 97–106.

See Also

Other Acquisition Function: AcqFunction, mlr_acqfunctions, mlr_acqfunctions_aei, mlr_acqfunctions_cb, mlr_acqfunctions_ehvi, mlr_acqfunctions_ehvigh, mlr_acqfunctions_ei, mlr_acqfunctions_eips, mlr_acqfunctions_mean, mlr_acqfunctions_multi, mlr_acqfunctions_sd, mlr_acqfunctions_smsego, mlr_acqfunctions_stochastic_cb, mlr_acqfunctions_stochastic_ei

Examples

if (requireNamespace("mlr3learners") &
    requireNamespace("DiceKriging") &
    requireNamespace("rgenoud")) {
  library(bbotk)
  library(paradox)
  library(mlr3learners)
  library(data.table)

  fun = function(xs) {
    list(y = xs$x ^ 2)
  }
  domain = ps(x = p_dbl(lower = -10, upper = 10))
  codomain = ps(y = p_dbl(tags = "minimize"))
  objective = ObjectiveRFun$new(fun = fun, domain = domain, codomain = codomain)

  instance = OptimInstanceBatchSingleCrit$new(
    objective = objective,
    terminator = trm("evals", n_evals = 5))

  instance$eval_batch(data.table(x = c(-6, -5, 3, 9)))

  learner = default_gp()

  surrogate = srlrn(learner, archive = instance$archive)

  acq_function = acqf("pi", surrogate = surrogate)

  acq_function$surrogate$update()
  acq_function$update()
  acq_function$eval_dt(data.table(x = c(-1, 0, 1)))
}

Description

Posterior Standard Deviation.

Dictionary

This AcqFunction can be instantiated via the dictionary mlr_acqfunctions or with the associated sugar function acqf():

mlr_acqfunctions$get("sd")
acqf("sd")

Super classes

bbotk::Objective -> mlr3mbo::AcqFunction -> AcqFunctionSD

Methods

Public methods

• AcqFunctionSD$new()

• AcqFunctionSD$clone()

Method new()

Creates a new instance of this R6 class.

Usage

AcqFunctionSD$new(surrogate = NULL)

Arguments

Method clone()

The objects of this class are cloneable with this method.

Usage

AcqFunctionSD$clone(deep = FALSE)

Arguments

See Also

Other Acquisition Function: AcqFunction, mlr_acqfunctions, mlr_acqfunctions_aei, mlr_acqfunctions_cb, mlr_acqfunctions_ehvi, mlr_acqfunctions_ehvigh, mlr_acqfunctions_ei, mlr_acqfunctions_eips, mlr_acqfunctions_mean, mlr_acqfunctions_multi, mlr_acqfunctions_pi, mlr_acqfunctions_smsego, mlr_acqfunctions_stochastic_cb, mlr_acqfunctions_stochastic_ei

Examples

if (requireNamespace("mlr3learners") &
    requireNamespace("DiceKriging") &
    requireNamespace("rgenoud")) {
  library(bbotk)
  library(paradox)
  library(mlr3learners)
  library(data.table)

  fun = function(xs) {
    list(y = xs$x ^ 2)
  }
  domain = ps(x = p_dbl(lower = -10, upper = 10))
  codomain = ps(y = p_dbl(tags = "minimize"))
  objective = ObjectiveRFun$new(fun = fun, domain = domain, codomain = codomain)

  instance = OptimInstanceBatchSingleCrit$new(
    objective = objective,
    terminator = trm("evals", n_evals = 5))

  instance$eval_batch(data.table(x = c(-6, -5, 3, 9)))

  learner = default_gp()

  surrogate = srlrn(learner, archive = instance$archive)

  acq_function = acqf("sd", surrogate = surrogate)

  acq_function$surrogate$update()
  acq_function$update()
  acq_function$eval_dt(data.table(x = c(-1, 0, 1)))
}

Description

S-Metric Selection Evolutionary Multi-Objective Optimization Algorithm Acquisition Function.

Parameters

• "lambda" (numeric(1))
  $\lambda$ value used for the confidence bound. Defaults to 1. Based on confidence = (1 - 2 * dnorm(lambda)) ^ m you can calculate a lambda for a given confidence level, see Ponweiser et al. (2008).

• "epsilon" (numeric(1))
  $\epsilon$ used for the additive epsilon dominance. Can either be a single numeric value > 0 or NULL (default). In the case of being NULL, an epsilon vector is maintained dynamically as described in Horn et al. (2015).

Note

• This acquisition function always also returns its current epsilon values in a list column (acq_epsilon). These values will be logged into the bbotk::ArchiveBatch of the bbotk::OptimInstanceBatch of the AcqOptimizer and therefore also in the bbotk::Archive of the actual bbotk::OptimInstance that is to be optimized.

Super classes

bbotk::Objective -> mlr3mbo::AcqFunction -> AcqFunctionSmsEgo

Public fields

Methods

Public methods

• AcqFunctionSmsEgo$new()

• AcqFunctionSmsEgo$update()

• AcqFunctionSmsEgo$reset()

• AcqFunctionSmsEgo$clone()

Method new()

Creates a new instance of this R6 class.

Usage

AcqFunctionSmsEgo$new(surrogate = NULL, lambda = 1, epsilon = NULL)

Arguments

Method update()

Update the acquisition function and set ys_front, ref_point and epsilon.

Usage

AcqFunctionSmsEgo$update()

Method reset()

Reset the acquisition function. Resets epsilon.

Usage

AcqFunctionSmsEgo$reset()

Method clone()

The objects of this class are cloneable with this method.

Usage

AcqFunctionSmsEgo$clone(deep = FALSE)

Arguments

References

• Ponweiser, Wolfgang, Wagner, Tobias, Biermann, Dirk, Vincze, Markus (2008). “Multiobjective Optimization on a Limited Budget of Evaluations Using Model-Assisted S-Metric Selection.” In Proceedings of the 10th International Conference on Parallel Problem Solving from Nature, 784–794.

• Horn, Daniel, Wagner, Tobias, Biermann, Dirk, Weihs, Claus, Bischl, Bernd (2015). “Model-Based Multi-objective Optimization: Taxonomy, Multi-Point Proposal, Toolbox and Benchmark.” In International Conference on Evolutionary Multi-Criterion Optimization, 64–78.

See Also

Other Acquisition Function: AcqFunction, mlr_acqfunctions, mlr_acqfunctions_aei, mlr_acqfunctions_cb, mlr_acqfunctions_ehvi, mlr_acqfunctions_ehvigh, mlr_acqfunctions_ei, mlr_acqfunctions_eips, mlr_acqfunctions_mean, mlr_acqfunctions_multi, mlr_acqfunctions_pi, mlr_acqfunctions_sd, mlr_acqfunctions_stochastic_cb, mlr_acqfunctions_stochastic_ei

Examples

if (requireNamespace("mlr3learners") &
    requireNamespace("DiceKriging") &
    requireNamespace("rgenoud")) {
  library(bbotk)
  library(paradox)
  library(mlr3learners)
  library(data.table)

  fun = function(xs) {
    list(y1 = xs$x^2, y2 = (xs$x - 2) ^ 2)
  }
  domain = ps(x = p_dbl(lower = -10, upper = 10))
  codomain = ps(y1 = p_dbl(tags = "minimize"), y2 = p_dbl(tags = "minimize"))
  objective = ObjectiveRFun$new(fun = fun, domain = domain, codomain = codomain)

  instance = OptimInstanceBatchMultiCrit$new(
    objective = objective,
    terminator = trm("evals", n_evals = 5))

  instance$eval_batch(data.table(x = c(-6, -5, 3, 9)))

  learner = default_gp()

  surrogate = srlrn(list(learner, learner$clone(deep = TRUE)), archive = instance$archive)

  acq_function = acqf("smsego", surrogate = surrogate)

  acq_function$surrogate$update()
  acq_function$progress = 5 - 4 # n_evals = 5 and 4 points already evaluated
  acq_function$update()
  acq_function$eval_dt(data.table(x = c(-1, 0, 1)))
}

Description

Lower / Upper Confidence Bound with lambda sampling and decay. The initial $\lambda$ is drawn from an uniform distribution between min_lambda and max_lambda or from an exponential distribution with rate 1 / lambda. $\lambda$ is updated after each update by the formula lambda * exp(-rate * (t %% period)), where t is the number of times the acquisition function has been updated.

While this acquisition function usually would be used within an asynchronous optimizer, e.g., OptimizerAsyncMbo, it can in principle also be used in synchronous optimizers, e.g., OptimizerMbo.

Dictionary

This AcqFunction can be instantiated via the dictionary mlr_acqfunctions or with the associated sugar function acqf():

mlr_acqfunctions$get("stochastic_cb")
acqf("stochastic_cb")

Parameters

• "lambda" (numeric(1))
  $\lambda$ value for sampling from the exponential distribution. Defaults to 1.96.

• "min_lambda" (numeric(1))
  Minimum value of $\lambda$for sampling from the uniform distribution. Defaults to 0.01.

• "max_lambda" (numeric(1))
  Maximum value of $\lambda$ for sampling from the uniform distribution. Defaults to 10.

• "distribution" (character(1))
  Distribution to sample $\lambda$ from. One of c("uniform", "exponential"). Defaults to uniform.

• "rate" (numeric(1))
  Rate of the exponential decay. Defaults to 0 i.e. no decay.

• "period" (integer(1))
  Period of the exponential decay. Defaults to NULL, i.e., the decay has no period.

Note

• This acquisition function always also returns its current (acq_lambda) and original (acq_lambda_0) $\lambda$. These values will be logged into the bbotk::ArchiveBatch of the bbotk::OptimInstanceBatch of the AcqOptimizer and therefore also in the bbotk::Archive of the actual bbotk::OptimInstance that is to be optimized.

Super classes

bbotk::Objective -> mlr3mbo::AcqFunction -> AcqFunctionStochasticCB

Methods

Public methods

• AcqFunctionStochasticCB$new()

• AcqFunctionStochasticCB$update()

• AcqFunctionStochasticCB$reset()

• AcqFunctionStochasticCB$clone()

Method new()

Creates a new instance of this R6 class.

Usage

AcqFunctionStochasticCB$new(
  surrogate = NULL,
  lambda = 1.96,
  min_lambda = 0.01,
  max_lambda = 10,
  distribution = "uniform",
  rate = 0,
  period = NULL
)

Arguments

Method update()

Update the acquisition function. Samples and decays lambda.

Usage

AcqFunctionStochasticCB$update()

Method reset()

Reset the acquisition function. Resets the private update counter .t used within the epsilon decay.

Usage

AcqFunctionStochasticCB$reset()

Method clone()

The objects of this class are cloneable with this method.

Usage

AcqFunctionStochasticCB$clone(deep = FALSE)

Arguments

References

• Snoek, Jasper, Larochelle, Hugo, Adams, P R (2012). “Practical Bayesian Optimization of Machine Learning Algorithms.” In Pereira F, Burges CJC, Bottou L, Weinberger KQ (eds.), Advances in Neural Information Processing Systems, volume 25, 2951–2959.

• Egelé, Romain, Guyon, Isabelle, Vishwanath, Venkatram, Balaprakash, Prasanna (2023). “Asynchronous Decentralized Bayesian Optimization for Large Scale Hyperparameter Optimization.” In 2023 IEEE 19th International Conference on e-Science (e-Science), 1–10.

See Also

Other Acquisition Function: AcqFunction, mlr_acqfunctions, mlr_acqfunctions_aei, mlr_acqfunctions_cb, mlr_acqfunctions_ehvi, mlr_acqfunctions_ehvigh, mlr_acqfunctions_ei, mlr_acqfunctions_eips, mlr_acqfunctions_mean, mlr_acqfunctions_multi, mlr_acqfunctions_pi, mlr_acqfunctions_sd, mlr_acqfunctions_smsego, mlr_acqfunctions_stochastic_ei

Examples

if (requireNamespace("mlr3learners") &
    requireNamespace("DiceKriging") &
    requireNamespace("rgenoud")) {
  library(bbotk)
  library(paradox)
  library(mlr3learners)
  library(data.table)

  fun = function(xs) {
    list(y = xs$x ^ 2)
  }
  domain = ps(x = p_dbl(lower = -10, upper = 10))
  codomain = ps(y = p_dbl(tags = "minimize"))
  objective = ObjectiveRFun$new(fun = fun, domain = domain, codomain = codomain)

  instance = OptimInstanceBatchSingleCrit$new(
    objective = objective,
    terminator = trm("evals", n_evals = 5))

  instance$eval_batch(data.table(x = c(-6, -5, 3, 9)))

  learner = default_gp()

  surrogate = srlrn(learner, archive = instance$archive)

  acq_function = acqf("stochastic_cb", surrogate = surrogate, lambda = 3)

  acq_function$surrogate$update()
  acq_function$update()
  acq_function$eval_dt(data.table(x = c(-1, 0, 1)))
}

Description

Expected Improvement with epsilon decay. $\epsilon$ is updated after each update by the formula epsilon * exp(-rate * (t %% period)) where t is the number of times the acquisition function has been updated.

While this acquisition function usually would be used within an asynchronous optimizer, e.g., OptimizerAsyncMbo, it can in principle also be used in synchronous optimizers, e.g., OptimizerMbo.

Dictionary

This AcqFunction can be instantiated via the dictionary mlr_acqfunctions or with the associated sugar function acqf():

mlr_acqfunctions$get("stochastic_ei")
acqf("stochastic_ei")

Parameters

• "epsilon" (numeric(1))
  $\epsilon$ value used to determine the amount of exploration. Higher values result in the importance of improvements predicted by the posterior mean decreasing relative to the importance of potential improvements in regions of high predictive uncertainty. Defaults to 0.1.

• "rate" (numeric(1))
  Defaults to 0.05.

• "period" (integer(1))
  Period of the exponential decay. Defaults to NULL, i.e., the decay has no period.

Note

• This acquisition function always also returns its current (acq_epsilon) and original (acq_epsilon_0) $\epsilon$. These values will be logged into the bbotk::ArchiveBatch of the bbotk::OptimInstanceBatch of the AcqOptimizer and therefore also in the bbotk::Archive of the actual bbotk::OptimInstance that is to be optimized.

Super classes

bbotk::Objective -> mlr3mbo::AcqFunction -> AcqFunctionStochasticEI

Public fields

Methods

Public methods

• AcqFunctionStochasticEI$new()

• AcqFunctionStochasticEI$update()

• AcqFunctionStochasticEI$reset()

• AcqFunctionStochasticEI$clone()

Method new()

Creates a new instance of this R6 class.

Usage

AcqFunctionStochasticEI$new(
  surrogate = NULL,
  epsilon = 0.1,
  rate = 0.05,
  period = NULL
)

Arguments

Method update()

Update the acquisition function. Sets y_best to the best observed objective function value. Decays epsilon.

Usage

AcqFunctionStochasticEI$update()

Method reset()

Reset the acquisition function. Resets the private update counter .t used within the epsilon decay.

Usage

AcqFunctionStochasticEI$reset()

Method clone()

The objects of this class are cloneable with this method.

Usage

AcqFunctionStochasticEI$clone(deep = FALSE)

Arguments

References

• Jones, R. D, Schonlau, Matthias, Welch, J. W (1998). “Efficient Global Optimization of Expensive Black-Box Functions.” Journal of Global optimization, 13(4), 455–492.

See Also

Other Acquisition Function: AcqFunction, mlr_acqfunctions, mlr_acqfunctions_aei, mlr_acqfunctions_cb, mlr_acqfunctions_ehvi, mlr_acqfunctions_ehvigh, mlr_acqfunctions_ei, mlr_acqfunctions_eips, mlr_acqfunctions_mean, mlr_acqfunctions_multi, mlr_acqfunctions_pi, mlr_acqfunctions_sd, mlr_acqfunctions_smsego, mlr_acqfunctions_stochastic_cb

Examples

if (requireNamespace("mlr3learners") &
    requireNamespace("DiceKriging") &
    requireNamespace("rgenoud")) {
  library(bbotk)
  library(paradox)
  library(mlr3learners)
  library(data.table)

  fun = function(xs) {
    list(y = xs$x ^ 2)
  }
  domain = ps(x = p_dbl(lower = -10, upper = 10))
  codomain = ps(y = p_dbl(tags = "minimize"))
  objective = ObjectiveRFun$new(fun = fun, domain = domain, codomain = codomain)

  instance = OptimInstanceBatchSingleCrit$new(
    objective = objective,
    terminator = trm("evals", n_evals = 5))

  instance$eval_batch(data.table(x = c(-6, -5, 3, 9)))

  learner = default_gp()

  surrogate = srlrn(learner, archive = instance$archive)

  acq_function = acqf("stochastic_ei", surrogate = surrogate)

  acq_function$surrogate$update()
  acq_function$update()
  acq_function$eval_dt(data.table(x = c(-1, 0, 1)))
}

Description

A simple mlr3misc::Dictionary storing objects of class loop_function. Each loop function has an associated help page, see mlr_loop_functions_[id].

Retrieves object with key key from the dictionary. Additional arguments must be named and are passed to the constructor of the stored object.

Arguments

Format

R6::R6Class object inheriting from mlr3misc::Dictionary.

Value

Object with corresponding key.

Methods

See mlr3misc::Dictionary.

See Also

Other Dictionary: mlr_acqfunctions, mlr_result_assigners

Other Loop Function: loop_function, mlr_loop_functions_ego, mlr_loop_functions_emo, mlr_loop_functions_mpcl, mlr_loop_functions_parego, mlr_loop_functions_smsego

Examples

library(data.table)
as.data.table(mlr_loop_functions)

Description

Loop function for sequential single-objective Bayesian Optimization. Normally used inside an OptimizerMbo.

In each iteration after the initial design, the surrogate and acquisition function are updated and the next candidate is chosen based on optimizing the acquisition function.

Usage

bayesopt_ego(
  instance,
  surrogate,
  acq_function,
  acq_optimizer,
  init_design_size = NULL,
  random_interleave_iter = 0L
)

Arguments

Value

invisible(instance)
The original instance is modified in-place and returned invisible.

Note

• The acq_function$surrogate, even if already populated, will always be overwritten by the surrogate.

• The acq_optimizer$acq_function, even if already populated, will always be overwritten by acq_function.

• The surrogate$archive, even if already populated, will always be overwritten by the bbotk::ArchiveBatch of the bbotk::OptimInstanceBatchSingleCrit.

References

• Jones, R. D, Schonlau, Matthias, Welch, J. W (1998). “Efficient Global Optimization of Expensive Black-Box Functions.” Journal of Global optimization, 13(4), 455–492.

• Snoek, Jasper, Larochelle, Hugo, Adams, P R (2012). “Practical Bayesian Optimization of Machine Learning Algorithms.” In Pereira F, Burges CJC, Bottou L, Weinberger KQ (eds.), Advances in Neural Information Processing Systems, volume 25, 2951–2959.

See Also

Other Loop Function: loop_function, mlr_loop_functions, mlr_loop_functions_emo, mlr_loop_functions_mpcl, mlr_loop_functions_parego, mlr_loop_functions_smsego

Examples

if (requireNamespace("mlr3learners") &
    requireNamespace("DiceKriging") &
    requireNamespace("rgenoud")) {

  library(bbotk)
  library(paradox)
  library(mlr3learners)

  fun = function(xs) {
    list(y = xs$x ^ 2)
  }
  domain = ps(x = p_dbl(lower = -10, upper = 10))
  codomain = ps(y = p_dbl(tags = "minimize"))
  objective = ObjectiveRFun$new(fun = fun, domain = domain, codomain = codomain)

  instance = OptimInstanceBatchSingleCrit$new(
    objective = objective,
    terminator = trm("evals", n_evals = 5))

  surrogate = default_surrogate(instance)

  acq_function = acqf("ei")

  acq_optimizer = acqo(
    optimizer = opt("random_search", batch_size = 100),
    terminator = trm("evals", n_evals = 100))

  optimizer = opt("mbo",
    loop_function = bayesopt_ego,
    surrogate = surrogate,
    acq_function = acq_function,
    acq_optimizer = acq_optimizer)

  optimizer$optimize(instance)

  # expected improvement per second example
  fun = function(xs) {
    list(y = xs$x ^ 2, time = abs(xs$x))
  }
  domain = ps(x = p_dbl(lower = -10, upper = 10))
  codomain = ps(y = p_dbl(tags = "minimize"), time = p_dbl(tags = "time"))
  objective = ObjectiveRFun$new(fun = fun, domain = domain, codomain = codomain)

  instance = OptimInstanceBatchSingleCrit$new(
    objective = objective,
    terminator = trm("evals", n_evals = 5))

  surrogate = default_surrogate(instance, n_learner = 2)
  surrogate$cols_y = c("y", "time")

  optimizer = opt("mbo",
    loop_function = bayesopt_ego,
    surrogate = surrogate,
    acq_function = acqf("eips"),
    acq_optimizer = acq_optimizer)

  optimizer$optimize(instance)
}

Description

Loop function for sequential multi-objective Bayesian Optimization. Normally used inside an OptimizerMbo. The conceptual counterpart to mlr_loop_functions_ego.

In each iteration after the initial design, the surrogate and acquisition function are updated and the next candidate is chosen based on optimizing the acquisition function.

Usage

bayesopt_emo(
  instance,
  surrogate,
  acq_function,
  acq_optimizer,
  init_design_size = NULL,
  random_interleave_iter = 0L
)

Arguments

Value

invisible(instance)
The original instance is modified in-place and returned invisible.

Note

• The acq_function$surrogate, even if already populated, will always be overwritten by the surrogate.

• The acq_optimizer$acq_function, even if already populated, will always be overwritten by acq_function.

• The surrogate$archive, even if already populated, will always be overwritten by the bbotk::ArchiveBatch of the bbotk::OptimInstanceBatchMultiCrit.

See Also

Other Loop Function: loop_function, mlr_loop_functions, mlr_loop_functions_ego, mlr_loop_functions_mpcl, mlr_loop_functions_parego, mlr_loop_functions_smsego

Examples

if (requireNamespace("mlr3learners") &
    requireNamespace("DiceKriging") &
    requireNamespace("rgenoud")) {

  library(bbotk)
  library(paradox)
  library(mlr3learners)

  fun = function(xs) {
    list(y1 = xs$x^2, y2 = (xs$x - 2) ^ 2)
  }
  domain = ps(x = p_dbl(lower = -10, upper = 10))
  codomain = ps(y1 = p_dbl(tags = "minimize"), y2 = p_dbl(tags = "minimize"))
  objective = ObjectiveRFun$new(fun = fun, domain = domain, codomain = codomain)

  instance = OptimInstanceBatchMultiCrit$new(
    objective = objective,
    terminator = trm("evals", n_evals = 5))

  surrogate = default_surrogate(instance)

  acq_function = acqf("ehvi")

  acq_optimizer = acqo(
    optimizer = opt("random_search", batch_size = 100),
    terminator = trm("evals", n_evals = 100))

  optimizer = opt("mbo",
    loop_function = bayesopt_emo,
    surrogate = surrogate,
    acq_function = acq_function,
    acq_optimizer = acq_optimizer)

  optimizer$optimize(instance)
}

Description

Loop function for single-objective Bayesian Optimization via multipoint constant liar. Normally used inside an OptimizerMbo.

In each iteration after the initial design, the surrogate and acquisition function are updated. The acquisition function is then optimized, to find a candidate but instead of evaluating this candidate, the objective function value is obtained by applying the liar function to all previously obtained objective function values. This is repeated q - 1 times to obtain a total of q candidates that are then evaluated in a single batch.

Usage

bayesopt_mpcl(
  instance,
  surrogate,
  acq_function,
  acq_optimizer,
  init_design_size = NULL,
  q = 2L,
  liar = mean,
  random_interleave_iter = 0L
)

Arguments

Value

invisible(instance)
The original instance is modified in-place and returned invisible.

Note

• The acq_function$surrogate, even if already populated, will always be overwritten by the surrogate.

• The acq_optimizer$acq_function, even if already populated, will always be overwritten by acq_function.

• The surrogate$archive, even if already populated, will always be overwritten by the bbotk::ArchiveBatch of the bbotk::OptimInstanceBatchSingleCrit.

• To make use of parallel evaluations in the case of 'q > 1, the objective function of the bbotk::OptimInstanceBatchSingleCrit must be implemented accordingly.

References

• Ginsbourger, David, Le Riche, Rodolphe, Carraro, Laurent (2008). “A Multi-Points Criterion for Deterministic Parallel Global Optimization Based on Gaussian Processes.”

• Wang, Jialei, Clark, C. S, Liu, Eric, Frazier, I. P (2020). “Parallel Bayesian Global Optimization of Expensive Functions.” Operations Research, 68(6), 1850–1865.

See Also

Other Loop Function: loop_function, mlr_loop_functions, mlr_loop_functions_ego, mlr_loop_functions_emo, mlr_loop_functions_parego, mlr_loop_functions_smsego

Examples

if (requireNamespace("mlr3learners") &
    requireNamespace("DiceKriging") &
    requireNamespace("rgenoud")) {

  library(bbotk)
  library(paradox)
  library(mlr3learners)

  fun = function(xs) {
    list(y = xs$x ^ 2)
  }
  domain = ps(x = p_dbl(lower = -10, upper = 10))
  codomain = ps(y = p_dbl(tags = "minimize"))
  objective = ObjectiveRFun$new(fun = fun, domain = domain, codomain = codomain)

  instance = OptimInstanceBatchSingleCrit$new(
    objective = objective,
    terminator = trm("evals", n_evals = 7))

  surrogate = default_surrogate(instance)

  acq_function = acqf("ei")

  acq_optimizer = acqo(
    optimizer = opt("random_search", batch_size = 100),
    terminator = trm("evals", n_evals = 100))

  optimizer = opt("mbo",
    loop_function = bayesopt_mpcl,
    surrogate = surrogate,
    acq_function = acq_function,
    acq_optimizer = acq_optimizer,
    args = list(q = 3))

  optimizer$optimize(instance)
}

Description

Loop function for multi-objective Bayesian Optimization via ParEGO. Normally used inside an OptimizerMbo.

In each iteration after the initial design, the observed objective function values are normalized and q candidates are obtained by scalarizing these values via the augmented Tchebycheff function, updating the surrogate with respect to these scalarized values and optimizing the acquisition function.

Usage

bayesopt_parego(
  instance,
  surrogate,
  acq_function,
  acq_optimizer,
  init_design_size = NULL,
  q = 1L,
  s = 100L,
  rho = 0.05,
  random_interleave_iter = 0L
)

Arguments

Value

invisible(instance)
The original instance is modified in-place and returned invisible.

Note

• The acq_function$surrogate, even if already populated, will always be overwritten by the surrogate.

• The acq_optimizer$acq_function, even if already populated, will always be overwritten by acq_function.

• The surrogate$archive, even if already populated, will always be overwritten by the bbotk::ArchiveBatch of the bbotk::OptimInstanceBatchMultiCrit.

• The scalarizations of the objective function values are stored as the y_scal column in the bbotk::ArchiveBatch of the bbotk::OptimInstanceBatchMultiCrit.

• To make use of parallel evaluations in the case of 'q > 1, the objective function of the bbotk::OptimInstanceBatchMultiCrit must be implemented accordingly.

References

• Knowles, Joshua (2006). “ParEGO: A Hybrid Algorithm With On-Line Landscape Approximation for Expensive Multiobjective Optimization Problems.” IEEE Transactions on Evolutionary Computation, 10(1), 50–66.

See Also

Other Loop Function: loop_function, mlr_loop_functions, mlr_loop_functions_ego, mlr_loop_functions_emo, mlr_loop_functions_mpcl, mlr_loop_functions_smsego

Examples

if (requireNamespace("mlr3learners") &
    requireNamespace("DiceKriging") &
    requireNamespace("rgenoud")) {

  library(bbotk)
  library(paradox)
  library(mlr3learners)

  fun = function(xs) {
    list(y1 = xs$x^2, y2 = (xs$x - 2) ^ 2)
  }
  domain = ps(x = p_dbl(lower = -10, upper = 10))
  codomain = ps(y1 = p_dbl(tags = "minimize"), y2 = p_dbl(tags = "minimize"))
  objective = ObjectiveRFun$new(fun = fun, domain = domain, codomain = codomain)

  instance = OptimInstanceBatchMultiCrit$new(
    objective = objective,
    terminator = trm("evals", n_evals = 5))

  surrogate = default_surrogate(instance, n_learner = 1)

  acq_function = acqf("ei")

  acq_optimizer = acqo(
    optimizer = opt("random_search", batch_size = 100),
    terminator = trm("evals", n_evals = 100))

  optimizer = opt("mbo",
    loop_function = bayesopt_parego,
    surrogate = surrogate,
    acq_function = acq_function,
    acq_optimizer = acq_optimizer)

  optimizer$optimize(instance)
}

Description

Loop function for sequential multi-objective Bayesian Optimization via SMS-EGO. Normally used inside an OptimizerMbo.

In each iteration after the initial design, the surrogate and acquisition function (mlr_acqfunctions_smsego) are updated and the next candidate is chosen based on optimizing the acquisition function.

Usage

bayesopt_smsego(
  instance,
  surrogate,
  acq_function,
  acq_optimizer,
  init_design_size = NULL,
  random_interleave_iter = 0L
)

Arguments

Value

invisible(instance)
The original instance is modified in-place and returned invisible.

Note

• The acq_function$surrogate, even if already populated, will always be overwritten by the surrogate.

• The acq_optimizer$acq_function, even if already populated, will always be overwritten by acq_function.

• The surrogate$archive, even if already populated, will always be overwritten by the bbotk::ArchiveBatch of the bbotk::OptimInstanceBatchMultiCrit.

• Due to the iterative computation of the epsilon within the mlr_acqfunctions_smsego, requires the bbotk::Terminator of the bbotk::OptimInstanceBatchMultiCrit to be a bbotk::TerminatorEvals.

References

• Beume N, Naujoks B, Emmerich M (2007). “SMS-EMOA: Multiobjective selection based on dominated hypervolume.” European Journal of Operational Research, 181(3), 1653–1669.

• Ponweiser, Wolfgang, Wagner, Tobias, Biermann, Dirk, Vincze, Markus (2008). “Multiobjective Optimization on a Limited Budget of Evaluations Using Model-Assisted S-Metric Selection.” In Proceedings of the 10th International Conference on Parallel Problem Solving from Nature, 784–794.

See Also

Other Loop Function: loop_function, mlr_loop_functions, mlr_loop_functions_ego, mlr_loop_functions_emo, mlr_loop_functions_mpcl, mlr_loop_functions_parego

Examples

if (requireNamespace("mlr3learners") &
    requireNamespace("DiceKriging") &
    requireNamespace("rgenoud")) {

  library(bbotk)
  library(paradox)
  library(mlr3learners)

  fun = function(xs) {
    list(y1 = xs$x^2, y2 = (xs$x - 2) ^ 2)
  }
  domain = ps(x = p_dbl(lower = -10, upper = 10))
  codomain = ps(y1 = p_dbl(tags = "minimize"), y2 = p_dbl(tags = "minimize"))
  objective = ObjectiveRFun$new(fun = fun, domain = domain, codomain = codomain)

  instance = OptimInstanceBatchMultiCrit$new(
    objective = objective,
    terminator = trm("evals", n_evals = 5))

  surrogate = default_surrogate(instance)

  acq_function = acqf("smsego")

  acq_optimizer = acqo(
    optimizer = opt("random_search", batch_size = 100),
    terminator = trm("evals", n_evals = 100))

  optimizer = opt("mbo",
    loop_function = bayesopt_smsego,
    surrogate = surrogate,
    acq_function = acq_function,
    acq_optimizer = acq_optimizer)

  optimizer$optimize(instance)
}

Description

OptimizerADBO class that implements Asynchronous Decentralized Bayesian Optimization (ADBO). ADBO is a variant of Asynchronous Model Based Optimization (AMBO) that uses AcqFunctionStochasticCB with exponential lambda decay.

Currently, only single-objective optimization is supported and OptimizerADBO is considered an experimental feature and API might be subject to changes.

Parameters

lambda

numeric(1)
Value used for sampling the lambda for each worker from an exponential distribution.

rate

numeric(1)
Rate of the exponential decay.

period

integer(1)
Period of the exponential decay.

initial_design

data.table::data.table()
Initial design of the optimization. If NULL, a design of size design_size is generated with the specified design_function. Default is NULL.

design_size

integer(1)
Size of the initial design if it is to be generated. Default is 100.

design_function

character(1)
Sampling function to generate the initial design. Can be random paradox::generate_design_random, lhs paradox::generate_design_lhs, or sobol paradox::generate_design_sobol. Default is sobol.

n_workers

integer(1)
Number of parallel workers. If NULL, all rush workers specified via rush::rush_plan() are used. Default is NULL.

Super classes

bbotk::Optimizer -> bbotk::OptimizerAsync -> mlr3mbo::OptimizerAsyncMbo -> OptimizerADBO

Methods

Public methods

• OptimizerADBO$new()

• OptimizerADBO$optimize()

• OptimizerADBO$clone()

Method new()

Creates a new instance of this R6 class.

Usage

OptimizerADBO$new()

Method optimize()

Performs the optimization on an bbotk::OptimInstanceAsyncSingleCrit until termination. The single evaluations will be written into the bbotk::ArchiveAsync. The result will be written into the instance object.

Usage

OptimizerADBO$optimize(inst)

Arguments

Returns

data.table::data.table()

Method clone()

The objects of this class are cloneable with this method.

Usage

OptimizerADBO$clone(deep = FALSE)

Arguments

Note

The lambda parameter of the confidence bound acquisition function controls the trade-off between exploration and exploitation. A large lambda value leads to more exploration, while a small lambda value leads to more exploitation. The initial lambda value of the acquisition function used on each worker is drawn from an exponential distribution with rate 1 / lambda. ADBO can use periodic exponential decay to reduce lambda periodically for a given time step t with the formula lambda * exp(-rate * (t %% period)). The SurrogateLearner is configured to use a random forest and the AcqOptimizer is a random search with a batch size of 1000 and a budget of 10000 evaluations.

References

• Egelé, Romain, Guyon, Isabelle, Vishwanath, Venkatram, Balaprakash, Prasanna (2023). “Asynchronous Decentralized Bayesian Optimization for Large Scale Hyperparameter Optimization.” In 2023 IEEE 19th International Conference on e-Science (e-Science), 1–10.

Examples

if (requireNamespace("rush") &
    requireNamespace("mlr3learners") &
    requireNamespace("DiceKriging") &
    requireNamespace("rgenoud")) {

  if (redis_available()) {

    library(bbotk)
    library(paradox)
    library(mlr3learners)

    fun = function(xs) {
      list(y = xs$x ^ 2)
    }
    domain = ps(x = p_dbl(lower = -10, upper = 10))
    codomain = ps(y = p_dbl(tags = "minimize"))
    objective = ObjectiveRFun$new(fun = fun, domain = domain, codomain = codomain)

    instance = OptimInstanceAsyncSingleCrit$new(
      objective = objective,
      terminator = trm("evals", n_evals = 10))

    rush::rush_plan(n_workers=2)

    optimizer = opt("adbo", design_size = 4, n_workers = 2)

    optimizer$optimize(instance)
  } else {
    message("Redis server is not available.\nPlease set up Redis prior to running the example.")
  }
}

Description

OptimizerAsyncMbo class that implements Asynchronous Model Based Optimization (AMBO). AMBO starts multiple sequential MBO runs on different workers. The worker communicate asynchronously through a shared archive relying on the rush package. The optimizer follows a modular layout in which the surrogate model, acquisition function, and acquisition optimizer can be changed. The SurrogateLearner will impute missing values due to pending evaluations. A stochastic AcqFunction, e.g., AcqFunctionStochasticEI or AcqFunctionStochasticCB is used to create varying versions of the acquisition function on each worker, promoting different exploration-exploitation trade-offs. The AcqOptimizer class remains consistent with the one used in synchronous MBO.

In contrast to OptimizerMbo, no loop_function can be specified that determines the AMBO flavor as OptimizerAsyncMbo simply relies on a surrogate update, acquisition function update and acquisition function optimization step as an internal loop.

Currently, only single-objective optimization is supported and OptimizerAsyncMbo is considered an experimental feature and API might be subject to changes.

Note that in general the SurrogateLearner is updated one final time on all available data after the optimization process has terminated. However, in certain scenarios this is not always possible or meaningful. It is therefore recommended to manually inspect the SurrogateLearner after optimization if it is to be used, e.g., for visualization purposes to make sure that it has been properly updated on all available data. If this final update of the SurrogateLearner could not be performed successfully, a warning will be logged.

By specifying a ResultAssigner, one can alter how the final result is determined after optimization, e.g., simply based on the evaluations logged in the archive ResultAssignerArchive or based on the Surrogate via ResultAssignerSurrogate.

Archive

The bbotk::ArchiveAsync holds the following additional columns that are specific to AMBO algorithms:

• acq_function$id (numeric(1))
  The value of the acquisition function.

• ".already_evaluated" (⁠logical(1))⁠
  Whether this point was already evaluated. Depends on the skip_already_evaluated parameter of the AcqOptimizer.

If the bbotk::ArchiveAsync does not contain any evaluations prior to optimization, an initial design is needed. If the initial_design parameter is specified to be a data.table, this data will be used. Otherwise, if it is NULL, an initial design of size design_size will be generated based on the generate_design sampling function. See also the parameters below.

Parameters

initial_design

data.table::data.table()
Initial design of the optimization. If NULL, a design of size design_size is generated with the specified design_function. Default is NULL.

design_size

integer(1)
Size of the initial design if it is to be generated. Default is 100.

design_function

character(1)
Sampling function to generate the initial design. Can be random paradox::generate_design_random, lhs paradox::generate_design_lhs, or sobol paradox::generate_design_sobol. Default is sobol.

n_workers

integer(1)
Number of parallel workers. If NULL, all rush workers specified via rush::rush_plan() are used. Default is NULL.

Super classes

bbotk::Optimizer -> bbotk::OptimizerAsync -> OptimizerAsyncMbo

Active bindings

Methods

Public methods

• OptimizerAsyncMbo$new()

• OptimizerAsyncMbo$print()

• OptimizerAsyncMbo$reset()

• OptimizerAsyncMbo$optimize()

• OptimizerAsyncMbo$clone()

Method new()

Creates a new instance of this R6 class.

If surrogate is NULL and the acq_function$surrogate field is populated, this SurrogateLearner is used. Otherwise, default_surrogate(instance) is used. If acq_function is NULL and the acq_optimizer$acq_function field is populated, this AcqFunction is used (and therefore its ⁠$surrogate⁠ if populated; see above). Otherwise default_acqfunction(instance) is used. If acq_optimizer is NULL, default_acqoptimizer(instance) is used.

Even if already initialized, the surrogate$archive field will always be overwritten by the bbotk::ArchiveAsync of the current bbotk::OptimInstanceAsyncSingleCrit to be optimized.