algorithm_05_mlrMBO.R

print("libPaths:")
print(.libPaths())

library(mlrMBO)
require(reticulate)

files.sources = dir("helperScriptsFunctions/")
files.sources <- paste0("helperScriptsFunctions/",files.sources[endsWith(files.sources, ".R")])
invisible(sapply(files.sources, source))

args = commandArgs(trailingOnly=TRUE)

print("Args:")
print(args)

retries = 10
while(tryCatch({
    use_python("/usr/bin/python2", required = T)
    py_config()
    return(0)
}, error = function(e) {
    return(1)
})){
    retries <- retries - 1
    if(retries <= 0){
        break
    }
}

### RUN Parameters #########################################

### Recieve Setup
### 
seed <- as.numeric(args[1])
set.seed(seed)
funID <- as.numeric(args[2])
algoID <- as.numeric(args[3])

nDim <- as.numeric(args[4])
budget <- as.numeric(args[5])
batchSize <- as.numeric(args[6])
experimentPath <- args[7]
args <- args[-7]

maxIters <- budget
maxEvals <- maxIters * batchSize

############################
############################


solver <- function(fun,lower,upper,solverParameterList){
    configureMlr(show.learner.output = FALSE)
    
    obj.fun <- makeSingleObjectiveFunction(
        fn = fun,
        par.set = makeNumericParamSet(lower = lower, upper = upper, len = length(lower))
    )
    
    ctrl <- makeMBOControl(propose.points = batchSize)
    if(batchSize > 1){
        ctrl <- setMBOControlMultiPoint(ctrl, method = "moimbo",
                                        moimbo.objective = "mean.se.dist",
                                        moimbo.dist = "nearest.neighbor",
                                        moimbo.selection = "first",
                                        moimbo.maxit = as.integer(log(length(lower)) * 1000))
    }else{
        ctrl <- setMBOControlInfill(ctrl, crit = makeMBOInfillCritMeanResponse())
    }
    
    designSize <- length(lower) * 2 * batchSize
    design <- generateDesign(designSize, getParamSet(obj.fun), fun = lhs::maximinLHS)
    
    remainingIters <- maxIters-2*length(lower)
    ctrl <- setMBOControlTermination(ctrl, iters = remainingIters)
    
    lrn <- makeMBOLearner(ctrl, obj.fun)
    
    res <- mbo(obj.fun, design = design, learner = lrn,
               control = ctrl, show.info = TRUE)
    
    return(res)
}


print("Creating obj fun")
wrapped <- getBBOBWrappedFun(functionID = funID, 
                             algoName = paste("05MOI",paste(args,collapse="_"),sep="_"), 
                             experimentPath = experimentPath,
                             nDim = nDim,
                             iid = seed)

start_time<-Sys.time()
print("Running solver")
solver(wrapped$fun, wrapped$lower, wrapped$upper)
end_time<-Sys.time()
print("Time taken: \n")
print(end_time-start_time)