mlr3mbo

https://mlr3mbo.mlr-org.com
Admin
mlr3mbo is a modular R package for single and multi-objective Bayesian Optimization with...
Tokens:84,709
Snippets:666
Trust Score:7.5
Update:5 months ago
Show doc for...
Tokens:
Raw
### EIPS Acquisition Function Example

Source: https://mlr3mbo.mlr-org.com/reference/mlr_acqfunctions_eips.html

Provides a complete example of setting up an objective function with time, an optimization instance, a surrogate model, and then calculating EIPS. Ensure necessary packages are installed and loaded.

```R
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)))
}
#>    acq_eips
#>       <num>
#> 1: 4.401295
#> 2: 4.864705
#> 3: 5.297184
```

--------------------------------

### Async MBO Optimization Example

Source: https://mlr3mbo.mlr-org.com/reference/mlr_optimizers_async_mbo.html

This snippet demonstrates the setup and execution of an asynchronous multi-objective Bayesian optimization task. It requires several packages to be installed and a Redis server to be available for communication between workers. The optimization is configured with a specific design size and number of workers.

```R
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))

    mirai::daemons(2)
    rush::rush_plan(n_workers=2, worker_type = "mirai")

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

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

--------------------------------

### Example Usage

Source: https://mlr3mbo.mlr-org.com/reference/mlr_tuners_adbo.html

Example demonstrating how to use TunerADBO for single-objective optimization.

```APIDOC
## Examples
__```
# \donttest{
if (requireNamespace("rush") &
    requireNamespace("mlr3learners") &
    requireNamespace("DiceKriging") &
    requireNamespace("rgenoud")) {
  if (redis_available()) {

    library(mlr3)
    library(mlr3tuning)

    # single-objective
    task = tsk("wine")
    learner = lrn("classif.rpart", cp = to_tune(lower = 1e-4, upper = 1, logscale = TRUE))
    resampling = rsmp("cv", folds = 3)
    measure = msr("classif.acc")

    instance = TuningInstanceAsyncSingleCrit$new(
      task = task,
      learner = learner,
      resampling = resampling,
      measure = measure,
      terminator = trm("evals", n_evals = 10))

    mirai::daemons(2)
    rush::rush_plan(n_workers=2, worker_type = "mirai")

    tnr("adbo", design_size = 4, n_workers = 2)$optimize(instance)
    mirai::daemons(0)
  } else {
    message("Redis server is not available.\nPlease set up Redis prior to running the example.")
  }
}
# }
```
```

--------------------------------

### AEI Example Usage

Source: https://mlr3mbo.mlr-org.com/reference/mlr_acqfunctions_aei.html

This example demonstrates how to set up an objective function, an optimization instance, a surrogate model (using `regr.km`), and then instantiate and use the AEI acquisition function.

```APIDOC
## 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)))
}
#>     acq_aei
#>       <num>
#> 1: 7.583607
#> 2: 7.583607
#> 3: 7.583607

```
```

--------------------------------

### AcqFunctionPI Example

Source: https://mlr3mbo.mlr-org.com/reference/mlr_acqfunctions_pi.html

Example usage of the AcqFunctionPI, demonstrating its instantiation and evaluation.

```APIDOC
## Examples

```R
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)))
}
#>       acq_pi
#>        <num>
#> 1: 0.2666835
#> 2: 0.2939585
#> 3: 0.3509449

```
```

--------------------------------

### SMS-EGO Acquisition Function Example

Source: https://mlr3mbo.mlr-org.com/reference/mlr_acqfunctions_smsego.html

Demonstrates the setup and usage of the SMS-EGO acquisition function. Requires mlr3learners, DiceKriging, and rgenoud packages. Defines a multi-objective function, an optimization instance, a Gaussian Process surrogate model, and then applies the SMS-EGO acquisition function to evaluate candidate points.

```R
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)))
}
#>    acq_smsego acq_epsilon
#>         <num>      <list>
#> 1:  -581.3294         0,0
#> 2:  -730.5643         0,0
#> 3: -1132.3221         0,0

```

--------------------------------

### AcqFunctionEHVIGH Example

Source: https://mlr3mbo.mlr-org.com/reference/mlr_acqfunctions_ehvigh.html

Example demonstrating the usage of AcqFunctionEHVIGH in an optimization context.

```APIDOC
## Examples
```R
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)))
}
```
```

--------------------------------

### Example Usage of AcqOptimizerLocalSearch

Source: https://mlr3mbo.mlr-org.com/reference/AcqOptimizerLocalSearch.html

Demonstrates how to instantiate and print an AcqOptimizerLocalSearch object using the `acqo()` shortcut.

```R
acqo("local_search")
#> <AcqOptimizerLocalSearch>: (OptimizerLocalSearch)
#> * Parameters: catch_errors=TRUE
```

--------------------------------

### AcqFunctionMulti Example

Source: https://mlr3mbo.mlr-org.com/reference/mlr_acqfunctions_multi.html

Example demonstrating the creation and usage of AcqFunctionMulti.

```APIDOC
## 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)))
}
#>      acq_ei    acq_pi   acq_cb
#>       <num>     <num>    <num>
#> 1: 4.401181 0.2666813 28.30175
#> 2: 4.864589 0.2939562 29.30322
#> 3: 5.297093 0.3509427 27.23331

```
```

--------------------------------

### Example: Using AcqFunctionMulti with EI, PI, and CB

Source: https://mlr3mbo.mlr-org.com/reference/mlr_acqfunctions_multi.html

This example demonstrates how to create and use an AcqFunctionMulti with 'ei', 'pi', and 'cb' acquisition functions. It requires setting up an objective, an optimization instance, a surrogate model, and then updating and evaluating the multi-objective acquisition function.

```R
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)))
}
#>      acq_ei    acq_pi   acq_cb
#>       <num>     <num>    <num>
#> 1: 4.401181 0.2666813 28.30175
#> 2: 4.864589 0.2939562 29.30322
#> 3: 5.297093 0.3509427 27.23331

```

--------------------------------

### Example Usage of SD Acquisition Function

Source: https://mlr3mbo.mlr-org.com/reference/mlr_acqfunctions_sd.html

Provides a complete example of setting up an objective, an optimization instance, a surrogate model, and then evaluating the SD acquisition function. Requires several mlr3 ecosystem packages.

```R
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)))
}
```

--------------------------------

### AcqFunctionMean Example

Source: https://mlr3mbo.mlr-org.com/reference/mlr_acqfunctions_mean.html

Provides an example of how to use the AcqFunctionMean.

```APIDOC
## 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)))
}
#>    acq_mean
#>       <num>
#> 1: 25.87231
#> 2: 23.23444
#> 3: 17.57632

```
```

--------------------------------

### Stochastic EI Acquisition Function Example

Source: https://mlr3mbo.mlr-org.com/reference/mlr_acqfunctions_stochastic_ei.html

Demonstrates the setup and usage of the stochastic EI acquisition function. Requires mlr3learners, DiceKriging, and rgenoud packages. Initializes an objective function, an optimization instance, a Gaussian Process surrogate model, and then the stochastic EI acquisition function itself. Finally, it updates the surrogate and acquisition function and evaluates the acquisition function over a grid.

```R
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)))
}
#>      acq_ei acq_epsilon acq_epsilon_0
#>       <num>       <num>         <num>
#> 1: 4.374618         0.1           0.1
#> 2: 4.835304         0.1           0.1
#> 3: 5.262113         0.1           0.1

```

--------------------------------

### Example: Setting up and running OptimizerADBO

Source: https://mlr3mbo.mlr-org.com/reference/mlr_optimizers_adbo.html

Demonstrates setting up an objective function, an asynchronous single-criterion optimization instance, configuring parallel workers using rush and mirai, and then running the OptimizerADBO. Requires Redis server availability.

```R
# \donttest{
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))

    mirai::daemons(2)
    rush::rush_plan(n_workers=2, worker_type = "mirai")

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

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

--------------------------------

### Async MBO Optimizer Setup and Execution

Source: https://mlr3mbo.mlr-org.com/reference/OptimizerAsyncMbo.html

Sets up and runs the asynchronous MBO optimizer. Requires 'rush' and 'mlr3learners' packages. Ensure Redis is available for asynchronous operation.

```R
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))

    mirai::daemons(2)
    rush::rush_plan(n_workers=2, worker_type = "mirai")

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

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

--------------------------------

### AcqFunctionEILog Example

Source: https://mlr3mbo.mlr-org.com/reference/mlr_acqfunctions_ei_log.html

An example demonstrating the usage of `AcqFunctionEILog` with a surrogate model and objective function.

```APIDOC
## 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()

  output_trafo = ot("log", invert_posterior = FALSE)

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

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

  acq_function$surrogate$update()
  acq_function$update()
  acq_function$eval_dt(data.table(x = c(-1, 0, 1)))
}
#>     acq_ei_log
#>          <num>
#> 1: 0.004804737
#> 2: 0.008287288
#> 3: 0.012162093

```
```

--------------------------------

### Basic Bayesian Optimization Example

Source: https://mlr3mbo.mlr-org.com/reference/mlr_loop_functions_ego.html

Demonstrates setting up and running a basic Bayesian Optimization loop using the bayesopt_ego function with an Expected Improvement acquisition function. Requires mlr3learners, DiceKriging, and rgenoud packages.

```R
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)
}
#>
#>            x  x_domain          y
#>        <num>    <list>      <num>
#> 1: 0.1607787 <list[1]> 0.02584979
# }

```

--------------------------------

### Single-Objective EGO Optimization Example

Source: https://mlr3mbo.mlr-org.com/reference/mlr_optimizers_mbo.html

Demonstrates setting up and running a single-objective Expected Gradient Optimization (EGO) using OptimizerMbo. Requires mlr3learners, DiceKriging, and rgenoud packages.

```R
# \donttest{
if (requireNamespace("mlr3learners") &
    requireNamespace("DiceKriging") &
    requireNamespace("rgenoud")) {

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

  # single-objective EGO
  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)

  # multi-objective ParEGO
  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))

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

  optimizer$optimize(instance)
}
#> WARN  [16:27:22.572] [bbotk] Could not update the surrogate a final time after the optimization process has terminated.
#>            x  x_domain        y1       y2
#>        <num>    <list>     <num>    <num>
#> 1: 0.5190372 <list[1]> 0.2693997 2.193251
#> 2: 0.7298441 <list[1]> 0.5326723 1.613296
# }
```

--------------------------------

### Usage Examples

Source: https://mlr3mbo.mlr-org.com/reference/mlr_optimizers_mbo.html

Demonstrates how to use OptimizerMbo for both single-objective and multi-objective optimization using different loop functions like bayesopt_ego and bayesopt_parego.

```APIDOC
## Examples
__```
# \donttest{
if (requireNamespace("mlr3learners") &
    requireNamespace("DiceKriging") &
    requireNamespace("rgenoud")) {

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

  # single-objective EGO
  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)

  # multi-objective ParEGO
  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))

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

  optimizer$optimize(instance)

}
#>
#> WARN  [16:27:22.572] [bbotk] Could not update the surrogate a final time after the optimization process has terminated.
#>            x  x_domain        y1       y2
#>        <num>    <list>     <num>    <num>
#> 1: 0.5190372 <list[1]> 0.2693997 2.193251
#> 2: 0.7298441 <list[1]> 0.5326723 1.613296
# }

```
```

--------------------------------

### Stochastic CB Acquisition Function Example

Source: https://mlr3mbo.mlr-org.com/reference/mlr_acqfunctions_stochastic_cb.html

Demonstrates the creation and evaluation of the stochastic_cb acquisition function. Requires mlr3learners, DiceKriging, and rgenoud packages. The example defines an objective function, an optimization instance, a Gaussian process surrogate learner, and then initializes and updates the stochastic_cb acquisition function before evaluating it.

```R
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)))
}
#>       acq_cb acq_lambda acq_lambda_0
#>        <num>      <num>        <num>
#> 1: -191.7298   8.033506     8.033506
#> 2: -187.7947   8.033506     8.033506
#> 3: -162.4114   8.033506     8.033506

```

--------------------------------

### Async MBO Tuning Example

Source: https://mlr3mbo.mlr-org.com/reference/mlr_tuners_async_mbo.html

Sets up and runs an asynchronous MBO tuning process for a classification task. Requires 'rush' and 'mlr3learners' packages, and a running Redis server.

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

  if (redis_available()) {

    library(mlr3)
    library(mlr3tuning)

    # single-objective
    task = tsk("wine")
    learner = lrn("classif.rpart", cp = to_tune(lower = 1e-4, upper = 1, logscale = TRUE))
    resampling = rsmp("cv", folds = 3)
    measure = msr("classif.acc")

    instance = TuningInstanceAsyncSingleCrit$new(
      task = task,
      learner = learner,
      resampling = resampling,
      measure = measure,
      terminator = trm("evals", n_evals = 10))

    mirai::daemons(2)
    rush::rush_plan(n_workers=2, worker_type = "mirai")

    tnr("async_mbo", design_size = 4, n_workers = 2)$optimize(instance)
    mirai::daemons(0)
  } else {
    message("Redis server is not available.\nPlease set up Redis prior to running the example.")
  }
}
```

--------------------------------

### Example: Setting up and running MBO for Multi-Objective Optimization

Source: https://mlr3mbo.mlr-org.com/reference/mlr_loop_functions_emo.html

Demonstrates how to set up and run multi-objective Bayesian Optimization using `bayesopt_emo`. It includes defining the objective function, instance, surrogate, acquisition function, and acquisition optimizer.

```R
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)
}
#>            x  x_domain        y1        y2
#>        <num>    <list>     <num>     <num>
#> 1:  3.174763 <list[1]> 10.079118  1.380067
#> 2: -1.825238 <list[1]>  3.331493 14.632445
# }
```

--------------------------------

### Expected Improvement Acquisition Function Example

Source: https://mlr3mbo.mlr-org.com/reference/mlr_acqfunctions_ei.html

This example shows how to set up an objective function, an optimization instance, a surrogate model, and then use the EI acquisition function to evaluate points. It requires several mlr3 ecosystem packages and DiceKriging for the Gaussian Process surrogate.

```R
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)))
}
#>      acq_ei
#>       <num>
#> 1: 4.092188
#> 2: 4.549039
#> 3: 5.037109
```

--------------------------------

### Instantiate SD Acquisition Function

Source: https://mlr3mbo.mlr-org.com/reference/mlr_acqfunctions_sd.html

Demonstrates how to get the 'sd' acquisition function from the dictionary or using the sugar function.

```R
mlr_acqfunctions$get("sd")
acqf("sd")
```
Tokens:
Raw