introduce adaptive infill (#388)

* introduce adaptive infill (WIP)

* improve adative infill

* better progress handling

* fix progress and tests

* progress not always necessary

* better fixation of adaptive infill

* documentation [ci skip]

* fix

* add random cb

* infill update

* remove rcb

* remove rcb (2)

* design was too complicated

Author: jakob-r

NAMESPACE

@@ -1,5 +1,6 @@
 # Generated by roxygen2: do not edit by hand
 
+S3method(initCrit,InfillCritAdaCB)
 S3method(initCrit,InfillCritCB)
 S3method(initCrit,default)
 S3method(plot,MBOMultiObjResult)
@@ -39,6 +40,7 @@ export(initSMBO)
 export(makeMBOControl)
 export(makeMBOInfillCrit)
 export(makeMBOInfillCritAEI)
+export(makeMBOInfillCritAdaCB)
 export(makeMBOInfillCritCB)
 export(makeMBOInfillCritDIB)
 export(makeMBOInfillCritEI)

R/OptState.R

@@ -39,6 +39,8 @@ NULL
 #  @param time.used \code{integer(1)} \cr
 #    The time in seconds we are already used for optimization since the very start.
 #    This counts all iterations together and is necessary for continuation with a given time budget.
+#  @param progress \code{numeric(1)} \cr
+#    The progress in percent determined by the termination criterion.
 
 # IMPORTANT NOTE:
 # See this as a constructor and it's variables as member variables.
@@ -48,7 +50,7 @@ NULL
 
 makeOptState = function(opt.problem, loop = 0L, tasks = NULL, models = NULL,
   time.model = NULL, opt.result = NULL, state = "init", opt.path = NULL,
-  time.last.saved = Sys.time(), loop.starttime = Sys.time(), time.used = 0L, time.created = Sys.time()) {
+  time.last.saved = Sys.time(), loop.starttime = Sys.time(), time.used = 0L, progress = 0, time.created = Sys.time()) {
 
   opt.state = new.env()
 
@@ -65,6 +67,7 @@ makeOptState = function(opt.problem, loop = 0L, tasks = NULL, models = NULL,
   opt.state$time.last.saved = time.last.saved
   opt.state$loop.starttime = loop.starttime
   opt.state$time.used = time.used
+  opt.state$progress = progress
 
   opt.state$random.seed = getRandomSeed()
   opt.state$time.created = time.created

R/OptState_getter.R

@@ -119,17 +119,23 @@ getOptStateState = function(opt.state) {
 
 getOptStateTermination = function(opt.state) {
   terminate = shouldTerminate.OptState(opt.state)
+  setOptStateProgress(opt.state, terminate$progress)
   # update only if termination condition is met
   if (terminate$term) {
     setOptStateState(opt.state, terminate$code)
   }
   terminate
 }
 
+getOptStateProgress = function(opt.state) {
+  opt.state$progress
+}
+
 getOptStateValidStates = function() {
   c("init", "iter", getOptStateValidTerminationStates())
 }
 
 getOptStateValidTerminationStates = function() {
   c("term.iter", "term.time", "term.exectime", "term.yval", "term.feval", "term.custom")
 }
+

R/OptState_setter.R

@@ -58,3 +58,9 @@ setOptStateState = function(opt.state, state) {
   opt.state$state = state
   invisible()
 }
+
+setOptStateProgress = function(opt.state, progress) {
+  assertNumber(progress, null.ok = TRUE)
+  opt.state$progress = progress
+  invisible()
+}

R/infillOptFocus.R

@@ -6,7 +6,7 @@
 #FIXME should we shrink if a local value is NA (dependent param)
 #
 # See infillOptCMAES.R for interface explanation.
-infillOptFocus = function(infill.crit, models, control, par.set, opt.path, design, iter, ...) {
+infillOptFocus = function(infill.crit, models, control, par.set, opt.path, ...) {
   global.y = Inf
 
   # restart the whole crap some times
@@ -22,7 +22,7 @@ infillOptFocus = function(infill.crit, models, control, par.set, opt.path, desig
       # convert to param encoding our model was trained on and can use
       newdesign = convertDataFrameCols(newdesign, ints.as.num = TRUE, logicals.as.factor = TRUE)
 
-      y = infill.crit(newdesign, models, control, ps.local, design, iter, ...)
+      y = infill.crit(newdesign, models, control, ps.local, ...)
 
 
       # get current best value

R/infill_crits.R

@@ -24,6 +24,13 @@
 #   Calculates the range of the mean and standard error and multiplies the standard error
 #   with the quotient of theses ranges.
 #   Default is \code{FALSE}.
+#' @param cb.lambda.start [\code{numeric(1)} | \code{NULL}]\cr
+#'  The value of \code{cb.lambda} at the beginning of the optimization.
+#'  The \code{makeMBOInfillCritAdaCB} crit takes the progress of the optimization determined by the termination criterion to linearly move from \code{cb.lambda.start} to \code{cb.lambda.end}.
+#'  The initial desgin does not account for the progress of the optimization.
+#'  Eexcept for \code{makeMBOTerminationMaxExecBudget}) if you dont pass a precalculated initial design.
+#' @param cb.lambda.end [\code{numeric(1)} | \code{NULL}]\cr
+#'  The value of \code{cb.lambda} at the end of the optimization.
 #' @param aei.use.nugget [\code{logical(1)}]\cr
 #'   Should the nugget effect be used for the pure variance estimation for augmented
 #'   expected improvement?
@@ -47,7 +54,7 @@ NULL
 #' @rdname infillcrits
 makeMBOInfillCritMeanResponse = function() {
   makeMBOInfillCrit(
-    fun = function(points, models, control, par.set, design, iter, attributes = FALSE) {
+    fun = function(points, models, control, par.set, design, iter, progress, attributes = FALSE) {
       ifelse(control$minimize, 1, -1) * predict(models[[1L]], newdata = points)$data$response
     },
     name = "Mean response",
@@ -60,7 +67,7 @@ makeMBOInfillCritMeanResponse = function() {
 #' @rdname infillcrits
 makeMBOInfillCritStandardError = function() {
   makeMBOInfillCrit(
-    fun = function(points, models, control, par.set, design, iter, attributes = FALSE) {
+    fun = function(points, models, control, par.set, design, iter, progress, attributes = FALSE) {
        -predict(models[[1L]], newdata = points)$data$se
     },
     name = "Standard error",
@@ -76,7 +83,7 @@ makeMBOInfillCritEI = function(se.threshold = 1e-6) {
   assertNumber(se.threshold, lower = 1e-20)
   force(se.threshold)
   makeMBOInfillCrit(
-    fun = function(points, models, control, par.set, design, iter, attributes = FALSE) {
+    fun = function(points, models, control, par.set, design, iter, progress, attributes = FALSE) {
       model = models[[1L]]
       maximize.mult = ifelse(control$minimize, 1, -1)
       y = maximize.mult * design[, control$y.name]
@@ -110,7 +117,7 @@ makeMBOInfillCritCB = function(cb.lambda = NULL) {
   assertNumber(cb.lambda, lower = 0, null.ok = TRUE)
   force(cb.lambda)
   makeMBOInfillCrit(
-    fun = function(points, models, control, par.set, design, iter, attributes = FALSE) {
+    fun = function(points, models, control, par.set, design, iter, progress, attributes = FALSE) {
       model = models[[1L]]
       maximize.mult = ifelse(control$minimize, 1, -1)
       p = predict(model, newdata = points)$data
@@ -152,7 +159,7 @@ makeMBOInfillCritAEI = function(aei.use.nugget = FALSE, se.threshold = 1e-6) {
   force(se.threshold)
 
   makeMBOInfillCrit(
-    fun = function(points, models, control, par.set, design, iter, attributes = FALSE) {
+    fun = function(points, models, control, par.set, design, iter, progress, attributes = FALSE) {
       model = models[[1L]]
       maximize.mult = ifelse(control$minimize, 1, -1)
       p = predict(model, newdata = points)$data
@@ -198,7 +205,7 @@ makeMBOInfillCritEQI = function(eqi.beta = 0.75, se.threshold = 1e-6) {
   force(se.threshold)
 
   makeMBOInfillCrit(
-    fun = function(points, models, control, par.set, design, iter, attributes = FALSE) {
+    fun = function(points, models, control, par.set, design, iter, progress, attributes = FALSE) {
       model = models[[1L]]
       maximize.mult = ifelse(control$minimize, 1, -1)
       # compute q.min
@@ -251,7 +258,7 @@ makeMBOInfillCritDIB = function(cb.lambda = 1, sms.eps = NULL) {
   if (!is.null(sms.eps))
     assertNumber(sms.eps, lower = 0, finite = TRUE)
   makeMBOInfillCrit(
-    fun = function(points, models, control, par.set, design, iter, attributes = FALSE) {
+    fun = function(points, models, control, par.set, design, iter, progress, attributes = FALSE) {
       # get ys and cb-value-matrix for new points, minimize version
       maximize.mult = ifelse(control$minimize, 1, -1)
       ys = as.matrix(design[, control$y.name]) %*% diag(maximize.mult)
@@ -292,3 +299,28 @@ makeMBOInfillCritDIB = function(cb.lambda = 1, sms.eps = NULL) {
     requires.se = TRUE
   )
 }
+
+# ============================
+# Experimental Infill Criteria
+# ============================
+
+#' @export
+#' @rdname infillcrits
+makeMBOInfillCritAdaCB = function(cb.lambda.start = NULL, cb.lambda.end = NULL) {
+  assertNumber(cb.lambda.start, lower = 0, null.ok = TRUE)
+  assertNumber(cb.lambda.end, lower = 0, null.ok = TRUE)
+  force(cb.lambda.start)
+  force(cb.lambda.end)
+  crit = makeMBOInfillCritCB()
+  orig.fun = crit$fun
+  crit$fun = function(points, models, control, par.set, design, iter, progress, attributes = FALSE) {
+    assertNumber(progress)
+    cb.lambda = (1-progress) * cb.lambda.start + progress * cb.lambda.end
+    assign("cb.lambda", cb.lambda, envir = environment(orig.fun))
+    orig.fun(points, models, control, par.set, design, iter, progress, attributes)
+  }
+  crit$name = "Adaptive Confidence bound"
+  crit$id = "adacb"
+  crit$params = list(cb.lambda.start = cb.lambda.start, cb.lambda.end = cb.lambda.end)
+  return(addClasses(crit, "InfillCritAdaCB"))
+}

R/initCrit.R

@@ -40,6 +40,15 @@ initCrit.InfillCritCB = function(crit, fun, design, learner, control) {
   initCritOptDirection(crit, fun)
 }
 
+#' @export
+initCrit.InfillCritAdaCB = function(crit, fun, design, learner, control) {
+  cb.lambda = crit$params$cb.lambda
+  if (is.null(cb.lambda))
+    cb.lambda = ifelse(isSimpleNumeric(getParamSet(fun)), 1, 2)
+  crit = makeMBOInfillCritAdaCB(2 * cb.lambda, 0.5 * cb.lambda)
+  initCritOptDirection(crit, fun)
+}
+
 # sets the opt.direction to minimize or maximize depending on the object function.
 initCritOptDirection = function(crit, fun) {
   if (crit$opt.direction == "objective") {

R/makeMBOInfillCrit.R

@@ -15,6 +15,7 @@
 #'     \item{par.set [\code{ParamSet}]}{Parameter set.}
 #'     \item{design [\code{data.frame}]}{Design of already visited points.}
 #'     \item{iter [\code{integer(1)}]}{Current iteration.}
+#'     \item{progress [\code{numeric{1}}]}{A value between 0 and 1 indicating the progress of the optimization.}
 #'     \item{attributes [\code{logical{1}}]}{Are there attributes appended to the return
 #'      value that should be added to the \code{OptPath}?}
 #'   }
@@ -51,8 +52,7 @@ makeMBOInfillCrit = function(fun, name, id,
   requires.se = FALSE) {
   assertFunction(
     fun,
-    args = c("points", "models", "control",
-      "par.set", "design", "iter", "attributes"),
+    args = c("points", "models", "control", "par.set", "design", "iter", "progress", "attributes"),
     ordered = TRUE)
 
   assertString(name)

R/proposePointsByInfillOptimization.R

@@ -20,7 +20,7 @@ proposePointsByInfillOptimization = function(opt.state, par.set = NULL, control
   opt.path = coalesce(opt.path, getOptStateOptPath(opt.state))
   iter = getOptStateLoop(opt.state)
   infill.crit.id = getMBOInfillCritId(control$infill.crit)
-
+  progress = getOptStateProgress(opt.state)
   #FIXME: maybe better do this in setMBOControlMultifid?
   if (control$multifid) {
     infill.crit.id = "multifid"
@@ -40,12 +40,12 @@ proposePointsByInfillOptimization = function(opt.state, par.set = NULL, control
   secs = measureTime({
     prop.points = infill.opt.fun(infill.crit.fun, models = models,
       control = control, par.set = par.set, opt.path = opt.path,
-      design = design, iter = iter, ...)
+      design = design, iter = iter, progress = progress, ...)
   })
   prop.points.converted = convertDataFrameCols(prop.points, ints.as.num = TRUE,
     logicals.as.factor = TRUE)
   crit.vals = infill.crit.fun(prop.points.converted, models, control, par.set,
-    design, iter, attributes = TRUE, ...)
+    design, iter, progress = progress, attributes = TRUE, ...)
   crit.components = attr(crit.vals, "crit.components")
   crit.vals = matrix(crit.vals, ncol = 1L)
 

R/setMBOControlTermination.R

@@ -31,6 +31,11 @@
 #'     termination condition is met.}
 #'     \item{message [\code{character(1)}]}{Termination message. At the moment we just allow \code{term.custom}.}
 #'   }
+#' @param use.for.adaptive.infill [\code{character(1)}|NULL]\cr
+#'   Which termination criterion should determine the progress that is used for adaptive infill criteria like [\code{\link{makeMBOInfillCritAdaCB}}].
+#'   The default is \code{NULL} which means, that the first supplied argument is taken, following the order of the function signature.
+#'   Other values can be \code{"iters"}, \code{"time.budget"}, etc.\cr
+#'   If you want to to use it together with a criterion you supplied in \code{more.termination.conds}, \code{more.termination.conds} has to be a named list and the function further has to return a list element \code{progress} with values between 0 and 1.
 #' @return [\code{\link{MBOControl}}].
 #' @family MBOControl
 #' @export
@@ -56,9 +61,10 @@
 #' res = mbo(fn, control = ctrl)
 #' print(res)
 setMBOControlTermination = function(control,
-  iters = NULL, time.budget = NULL, exec.time.budget = NULL, target.fun.value = NULL, max.evals = NULL, more.termination.conds = list()) {
+  iters = NULL, time.budget = NULL, exec.time.budget = NULL, target.fun.value = NULL, max.evals = NULL, more.termination.conds = list(), use.for.adaptive.infill = NULL) {
 
   assertList(more.termination.conds)
+  assertCharacter(use.for.adaptive.infill, null.ok = TRUE)
 
   stop.conds = more.termination.conds
 
@@ -68,39 +74,48 @@ setMBOControlTermination = function(control,
   }
 
   if (!is.null(iters)) {
-    stop.conds = c(stop.conds, makeMBOTerminationMaxIter(iters))
+    stop.conds = c(stop.conds, iters = makeMBOTerminationMaxIter(iters))
   }
 
   if (!is.null(time.budget)) {
-    stop.conds = c(stop.conds, makeMBOTerminationMaxBudget(time.budget))
+    stop.conds = c(stop.conds, time.budget = makeMBOTerminationMaxBudget(time.budget))
   }
 
   if (!is.null(exec.time.budget)) {
-    stop.conds = c(stop.conds, makeMBOTerminationMaxExecBudget(exec.time.budget))
-  }
-
-  if (!is.null(max.evals)) {
-    stop.conds = c(stop.conds, makeMBOTerminationMaxEvals(max.evals))
+    stop.conds = c(stop.conds, exec.time.budget = makeMBOTerminationMaxExecBudget(exec.time.budget))
   }
 
   if (!is.null(target.fun.value)) {
     if (control$n.objectives > 1L)
       stop("Specifying target.fun.value is only useful in single-objective optimization.")
-    stop.conds = c(stop.conds, makeMBOTerminationTargetFunValue(target.fun.value))
+    stop.conds = c(stop.conds, target.fun.value = makeMBOTerminationTargetFunValue(target.fun.value))
   }
 
+  if (!is.null(max.evals)) {
+    stop.conds = c(stop.conds, max.evals = makeMBOTerminationMaxEvals(max.evals))
+  }
+
+
   # sanity check termination conditions
   lapply(stop.conds, function(stop.on) {
     assertFunction(stop.on, args = "opt.state")
   })
 
+  # sanity check, whether use.for.adaptive.infill was set to an active criterion
+  if (is.null(use.for.adaptive.infill)) {
+    use.for.adaptive.infill = names(stop.conds)[1]
+  } else {
+    assertSubset(use.for.adaptive.infill, names(stop.conds))
+  }
+
   control$stop.conds = stop.conds
 
   # store stuff in control object since it is needed internally
   control$iters = coalesce(iters, control$iters, Inf)
   control$time.budget = coalesce(time.budget, control$time.budget, Inf)
   control$exec.time.budget = coalesce(exec.time.budget, control$exec.time.budget, Inf)
   control$max.evals = coalesce(max.evals, Inf)
+  control$use.for.adaptive.infill = use.for.adaptive.infill
 
   return(control)
 }