cashinr/MBOexample.R at master · hildafab/cashinr · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
#------------------------------------------------------------------------------------------
#------------------------------------------------------------------------------------------

library("mlr")
library("OpenML")
library("mlrMBO")

#------------------------------------------------------------------------------------------
#------------------------------------------------------------------------------------------

tuningTask = function(oml.task.id, learner, par.set, budget) {

  # specify the task
  oml.task = getOMLTask(oml.task.id)

  # make a check is imputation is needed
  if (any(is.na(oml.task$input$data$data))) {
    catf(" - Data imputation required ...")
    temp = impute(data = oml.task$input$data.set$data, classes = list(numeric = imputeMean(), factor = imputeMode()))
    oml.task$input$data.set$data = temp$data
  }

  obj = convertOMLTaskToMlr(oml.task)
  obj$mlr.rin = makeResampleDesc("CV", iters = 10L)

  # Random Search
  ctrl.random = makeTuneControlRandom(maxit=budget)
  # List of tuning controls
  ctrls = list(ctrl.random )# ctrl.grid #, ctrl.irace, ctrl.gensa, ctrl.cmaes)
# predict.type = "se"

  inner = makeResampleDesc("CV", iters=5)
  outer = makeResampleInstance("CV", iters=10, task=obj$mlr.task)

  # Calling tuning techniques (for each tuning control ... )
  aux = lapply(ctrls, function(ct) {

    tuned.learner = makeTuneWrapper(learner=learner, resampling=inner, par.set=par.set,
      control=ct, show.info=FALSE)

    res = resample(learner=tuned.learner, task=obj$mlr.task, resampling=outer,
      extract=getTuneResult, models=TRUE, show.info = FALSE,
      measures=list(mse, rmse, timetrain, timepredict, timeboth))

    return(res)
  })

  return(aux)
}

#------------------------------------------------------------------------------------------
#------------------------------------------------------------------------------------------

MBOTuning = function(oml.task.id, learner, par.set, budget = NULL) {

  mbo.control = makeMBOControl(iters = 10L, init.design.points = 30L)
  mbo.control = setMBOControlInfill(mbo.control, crit = "ei")

  oml.task = getOMLTask(oml.task.id)

  # make a check is imputation is needed
  if (any(is.na(oml.task$input$data$data))) {
    catf("   - Data imputation required ...")
    temp = impute(data = oml.task$input$data.set$data, classes = list(numeric = imputeMean(), factor = imputeMode()))
    oml.task$input$data.set$data = temp$data
  }

  # define the objective function (intern function)
  myObjectiveFunction = function(x){

    obj = convertOMLTaskToMlr(oml.task)
    rdesc = makeResampleInstance("CV", iters=5, task=obj$mlr.task)

    # modifying the learner
    new.learner = setHyperPars(learner, par.vals = list(cost = x[[1]],
      gamma = x[[2]]))

    res = resample(learner=new.learner, task=obj$mlr.task, resampling=rdesc,
     models=TRUE, show.info = FALSE, measures=list(mse, rmse, timetrain, timepredict, timeboth))

    value = res$aggr[1]
    return(value)

  }

  mbo.result = mbo(myObjectiveFunction, par.set = par.set, learner = learner,
    control = mbo.control, show.info = TRUE)

  return(mbo.result)

}

#------------------------------------------------------------------------------------------
#------------------------------------------------------------------------------------------

main = function() {

  task.id = 5141
  budget = 20

  # SVM regrersors
  lrn = makeLearner("regr.svm")

  # SVM hyper-parameter search space
  ps = makeParamSet(
    makeNumericParam("cost", lower=-15, upper=15, trafo=function(x) 2^x),
    makeNumericParam("gamma", lower=-15, upper=15, trafo=function(x) 2^x)
  )

  # output = tuningTask(oml.task.id = task.id, learner = lrn, par.set = ps, budget = 20)
  # print(output)

  # List of mlr Regressors (see those with 'se option in the predicted type)
  #  https://mlr-org.github.io/mlr-tutorial/devel/html/integrated_learners/index.html

#  random forest regressor
  # lrn2 = makeLearner("regr.randomForest", predict.type = "se")
#   lrn2 = makeLearner("regr.randomForest") #, predict.type="prob")
#   # random forest hyper-parameter search space
#   ps2 = makeParamSet(
#     makeIntegerParam("ntree", lower=1L, upper=500L),
#     makeIntegerParam("nodesize", lower = 1L, upper = 100L )
#   )

  catf(" * MBO optimization")
  bag.lrn = makeBaggingWrapper(lrn)
  lrn2 = setPredictType(bag.lrn, predict.type = "se")

  mbo.output = MBOTuning(oml.task.id = task.id, learner = lrn2, par.set = ps)
  print(mbo.output)

}


#------------------------------------------------------------------------------------------
#------------------------------------------------------------------------------------------

main()

#------------------------------------------------------------------------------------------
#------------------------------------------------------------------------------------------