Creates a control object for MBO optimization.

makeMBOControl(
n.objectives = 1L,
propose.points = 1L,
final.method = "best.true.y",
final.evals = 0L,
y.name = "y",
impute.y.fun = NULL,
trafo.y.fun = NULL,
suppress.eval.errors = TRUE,
save.on.disk.at = integer(0L),
save.on.disk.at.time = Inf,
save.file.path = file.path(getwd(), "mlrMBO_run.RData"),
store.model.at = NULL,
resample.at = integer(0),
resample.desc = makeResampleDesc("CV", iter = 10),
resample.measures = list(mse),
output.num.format = "%.3g",
on.surrogate.error = "stop"
)

## Arguments

n.objectives |
[`integer(1)` ]
How many objectives are to be optimized? `n.objectives = 1` implies normal single
criteria optimization, `n.objectives > 1` implies multi-objective optimization.
Default is 1. |

propose.points |
[`integer(1)` ]
Number of proposed / really evaluated points each iteration.
Default is 1. |

final.method |
[`character(1)` ]
How should the final point be proposed. Possible values are:
“best.true.y”: Return best point ever visited according to true value of target function.
Can be bad if target function is noisy.
“last.proposed”: Return the last point proposed by the model.
“best.predicted”: Use the final model to predict all points ever visited and use the best one.
This might average-out noisy function values.
Default is: “best.true.y”. |

final.evals |
[`integer(1)` ]
How many target function evals should be done at final point to reduce noise?
Default is 0. |

y.name |
[`character` ]
Vector for names of y-columns for target values in optimization path.
Default is “y_i”, i = 1, ..., n.objectives. |

impute.y.fun |
[`function(x, y, opt.path, ...)` *]
Functions that gets triggered if your objective evaluation produced
a) an exception b) a return object of invalid type c) a numeric vector that
contains `NA` , `NaN` , `Inf` .
You now have a chance to handle this. You are expected to return a numeric vector
of the correct length with concrete values.
The optimization path will show some information whether y-values where imputed
and what the original, faulty object was.
`x` is the current x-value, `y` the current (invalid) y-object (or an error object)
and `opt.path` the current optimization path.
Default is `NULL` which means to stop if the objective function did not produce the desired
result. |

trafo.y.fun |
[`MBOTrafoFunction` ]
Sometimes it is favorable to transform the target function values before modeling. Provide a
MBO transformation function to do so. |

suppress.eval.errors |
[`logical(1)` ]
Should reporting of error messages during target function evaluations be suppressed?
Only used if `impute.errors` is `TRUE` .
Default is `TRUE` . |

save.on.disk.at |
[`integer` ]
Sequential optimization iteration when the actual state should be saved
on disk. Iteration 0 denotes the initial design. If the optimization
stops with an crucial error, it can be restarted with this file via the
function `mboContinue` .
Default is `integer(0L)` , i. e., not to save. |

save.on.disk.at.time |
[`integer` ]
Same as above. But here you define the time which have to be passed until the last save in seconds. Any finite value will lead to save at end.
Default is `Inf` , i. e., not to save ever. |

save.file.path |
[`character(1)` ]
If `save.on.disk.at` is used, this is the name of the file where the data
will be saved.
Default “mbo_run.RData” in your current working directory. |

store.model.at |
[`integer` ]
Sequential optimization iterations when the model should be saved.
Iteration 1 is the model fit for the initial design, iters + 1 is a final
save containing the final results of the optimization. .
Default is `iters + 1` . |

resample.at |
[`integer` ]
At which iterations should the model be resampled and assessed?
Iteration 0 does some resampling on the initial design.
Default is none. |

resample.desc |
[`ResampleDesc` ]
How should the model be resampled?
Default is 10-fold CV. |

resample.measures |
[list of `Measure` ]
Performance measures to assess model with during resampling.
Default is `mse` . |

output.num.format |
[`logical(1)` ]
Format string for the precision of the numeric output of mbo. |

on.surrogate.error |
[`character(1)` ]
What should happen when the surrogate learner can not train the model.
Possible values are:
“stop”: R exception is generated.
“warn”: The error will be converted to a waring and a random point will be proposed.
“quiet”: Same as “warn” but without the warning.
This will overwrite the mlr setting `on.learner.error` for the surrogate learner.
Default is: “stop”. |

## Value

[`MBOControl`

].

## See also