optimizertuneRace: Tuning of optimization algorithms
In matthiasgruber/EBO: Easy Benchmarks of Optimization Algorithms

optimizertuneRace

R Documentation

Tuning of optimization algorithms

Description

This functions enables users to tune the hyperparameters of different optimization algorithms.

Usage

optimizertuneRace(
  optimizer,
  psTune,
  funcEvals = 50,
  itersTune = 1000,
  trainInstanceList,
  minimize = TRUE,
  configurationsFile = NA,
  plotAblation = FALSE,
  ablationFile = NA,
  firstTest = 6,
  test = "F-test",
  seed = 1
)

Arguments

`optimizer`	[`character`] optimization algorithm which user want to tune possible optimization algorithms are: "optimizeMBO", "optimizeES", "optimizeDE", "optimizeGenoud", "optimizeCmaesr" Default is 'NA'.
`psTune`	[`ParamHelpers::ParamSet()`] Collection of hyperparameters and their constraints for the tuning, e.g. tuning of optimizer In the following, the hyperparamter of the optimizer, which one can tune are summarized. "optimizeMBO": - design[string]: "maximinLHS", "randomLHS", "random", "optimumLHS", "augmentLHS", "geneticLHS", "improvedLHS", "optAugmentLHS" - surrogate[string]: "regr.randomForest", "regr.km" - amountDesign[integer]: defines number of initial design points. default is number of features + 1. - covtype[string]: "matern5_2","matern3_2", "powexp", "gauss" - nodesize[integer]: default is ... - mtry[integer]: default is ... - crit[string]: "makeMBOInfillCritAEI","makeMBOInfillCritCB", "makeMBOInfillCritAdaCB","makeMBOInfillCritEI", "makeMBOInfillCritEQI", "makeMBOInfillCritMeanResponse", "makeMBOInfillCritStandardError" - cb.lambda[numeric]: defines cb.lambda from makeMBOInfillCritCB; default is 1 for fully numeric parameter set and 2 otherwise - cb.lambda.start[numeric]: defines cb.lambda.start from makeMBOInfillCritAdaCB - cb.lambda.end[numeric]: defines cb.lambda.end from makeMBOInfillCritAdaCB - eqi.beta[numeric]: Beta parameter for expected quantile improvement criterion. Default is 0.75. "optimizeES": - nu[integer]: selection pressure. That means, number of offspring (lambda) is mue multiplied with nu. Default is 10 - mue[integer]: number of parents, default is 10 - sigmaInit[numeric]: initial sigma value (step size), default is 1.0 - nSigma[integer]: number of different sigmas, default is 1 - mutation[integer]: string of mutation type, default is 1 - tau[numeric]: number, learning parameter for self adaption, i.e. the local multiplier for step sizes (for each dimension).default is 1.0 - stratReco[integer]: Recombination operator for strategy variables. 1: none. 2: dominant/discrete (default). 3: intermediate. 4: variation of intermediate recombination. - objReco[integer]: Recombination operator for object variables. 1: none. 2: dominant/discrete (default). 3: intermediate. 4: variation of intermediate recombination. "optimizeGenoud": - populationSize[integer]: Number of individuals in the population. Default is 10dimension. "optimizeDE": - populationSize[integer]: Number of particles in the population. Default is 10dimension. "optimizeCmaesr": - sigma[numeric]: Initial step-size. Default is 0.5. - lambda[integer]: Number of offspring generated in each generation.
`funcEvals`	[`integer(1)`] Define the number of function evaluations. Default is 50.
`itersTune`	[`integer(1)`] Define the tuning budget used for tuning with `irace` Default is 1000.
`trainInstanceList`	[`list()`] Define list with instances / problems, which were defined with EBO::generateProblemList().
`minimize`	[`logical(1)`] Should the target be minimized? Default is 'TRUE'.
`configurationsFile`	[`character`] Use a .txt file to define the source for ablation analysis We recommend using the default algorithm setting. Default is 'NA'.
`plotAblation`	[`logical(1)`] Should an ablation analysis be run with the tuning Result? Default is 'FALSE'.
`ablationFile`	[`character`] Saving path for the ablation analysis. Default is 'NA'.
`firstTest`	[`integer(1)`] defines how many instances are evaluated, before the first test `irace` Default is 6.
`test`	[`character`] Defines the test used for the iRace tuning procedure Default is 'F-test'.
`seed`	[`numeric(1)`] Define the seed used for the computation. Will be set by `irace`. Default is one.

Value

Elite configurations for defined tasks and an ablation analysis if plotAblation = TRUE.

References

[mlrMBO::mbo()]

Manuel López-Ibànez, Leslie Pérez Cáceres, Jérémie Dubois-Lacoste, Thomas Stützle and Mauro Birattari, The irace Package: User Guide. Preprint: https://cran.r-project.org/web/packages/irace/vignettes/irace-package.pdf (2019).

Examples

## Not run: 

set.seed(1)

library(mlrMBO)
library(ParamHelpers)
library(mlr)

set.seed(1)

# define problem 1
data1 <- data.frame(a = runif(50,10,5555), b = runif(50,-30000,-500),
                   c = runif(50,0,1000))
data1$ratio <- rowSums(data1[,1:3]^2)
data1$ratio <- data1$ratio/max(data1$ratio)
colnames(data1) <- c("power", "time", "pressure","ratio")

psOpt = makeParamSet(

 makeIntegerParam("power", lower = 10, upper = 5555),

 makeIntegerParam("time", lower = -30000, upper = -500),

 makeIntegerParam("pressure", lower = 0, upper = 1000)
)

task1 = task(
 simulation = "regr.randomForest",
 data = data1,
 target = "ratio",
 psOpt = psOpt,
 minimize = FALSE
)


# define problem 2
data2 <- data.frame(a = runif(80,0,0.25), b = runif(80, 0,0.1),
                   c = runif(80,0,1), d = runif(80,0,1))
data2$interface <- rowSums((data2[,1:4]*8)^2)
data2$interface <- data2$interface/max(data2$interface)
colnames(data2) <- c("f", "k", "du","dv")


psOpt = ParamHelpers::makeParamSet(
 ParamHelpers::makeNumericParam("f", lower = 0, upper = 0.25),
 ParamHelpers::makeNumericParam("k", lower = 0, upper = 0.1),
 ParamHelpers::makeNumericParam("du", lower = 0, upper = 1),
 ParamHelpers::makeNumericParam("dv", lower = 0, upper = 1)
)

task2 = task(
 simulation = "regr.randomForest",
 data = data2,
 target = "interface",
 psOpt = psOpt,
 minimize = FALSE
)


################## Define problemList #############

problemList = generateProblemList(task1, task2)


### tune SMBO algorithm

psTune = ParamHelpers::makeParamSet(

 ParamHelpers::makeDiscreteParam("design", values = c("maximinLHS",
                                                      "optimumLHS")),

 ParamHelpers::makeDiscreteParam("surrogate", values = c("regr.randomForest", "regr.km")),

 ParamHelpers::makeDiscreteParam("covtype", values = c("matern5_2","matern3_2", "powexp", "gauss")),

 ParamHelpers::makeDiscreteParam("crit", values = c("makeMBOInfillCritAEI","makeMBOInfillCritCB", "makeMBOInfillCritAdaCB","makeMBOInfillCritEI")),

 ParamHelpers::makeNumericParam("cb.lambda", lower = 1, upper = 5,
                                requires = quote(crit == "makeMBOInfillCritCB")),

 ParamHelpers::makeIntegerParam("cb.lambda.start", lower = 3, upper = 10,
                                requires = quote(crit == "makeMBOInfillCritAdaCB")),

 ParamHelpers::makeNumericParam("cb.lambda.end", lower = 0, upper = 3,
                                requires = quote(crit == "makeMBOInfillCritAdaCB"))
)



tuneResultsMBO = optimizertuneRace("optimizeMBO", psTune,
                               funcEvals = 55, itersTune = 1000, trainInstanceList = problemList,
                               minimize = FALSE,
                               plotAblation = TRUE, ablationFile = "ablationMBOPlot.pdf", seed = 1)


## tune ES algorithm

psTune = ParamHelpers::makeParamSet(

ParamHelpers::makeIntegerParam("nu", lower = 5, upper = 15),

ParamHelpers::makeIntegerParam("mue", lower = 5, upper = 15),

ParamHelpers::makeNumericParam("sigmaInit", lower = 0.7, upper = 1.3),

ParamHelpers::makeNumericParam("tau", lower = 0.7, upper = 1.3),

ParamHelpers::makeIntegerParam("stratReco", lower = 1, upper = 4),

ParamHelpers::makeIntegerParam("objReco", lower = 1, upper = 4)
)

tuneResultsES = optimizertuneRace("optimizeES", psTune,
                               funcEvals = 65, itersTune = 1000, trainInstanceList = problemList,
                               minimize = FALSE,
                               plotAblation = TRUE, ablationFile = "ablationESPlot.pdf", seed = 1)


## End(Not run)

matthiasgruber/EBO documentation built on May 17, 2022, 3:19 p.m.