Running ‘run-base.R’ [188s/278s]
Running the tests in ‘tests/run-base.R’ failed.
Complete output:
  > library(testthat)
  > test_check("mlr", filter = "base_")
  Loading required package: mlr
  Loading required package: ParamHelpers
  
  Attaching package: 'rex'
  
  The following object is masked from 'package:testthat':
  
      matches
  
  
  Attaching package: 'BBmisc'
  
  The following object is masked from 'package:base':
  
      isFALSE
  
  ── 1. Error: BaggingWrapper (@test_base_BaggingWrapper.R#7)  ───────────────────
  argument "def" is missing, with no default
  1: train(lrn2, multiclass.task) at testthat/test_base_BaggingWrapper.R:7
  2: measureTime(fun1({
         learner.model = fun2(fun3(do.call(trainLearner, pars)))
     }))
  3: force(expr)
  4: fun1({
         learner.model = fun2(fun3(do.call(trainLearner, pars)))
     })
  5: evalVis(expr)
  6: withVisible(eval(expr, pf))
  7: eval(expr, pf)
  8: eval(expr, pf)
  9: fun2(fun3(do.call(trainLearner, pars)))
  10: fun3(do.call(trainLearner, pars))
  11: do.call(trainLearner, pars)
  12: (function (.learner, .task, .subset, .weights = NULL, ...) 
     {
         UseMethod("trainLearner")
     })(.learner = structure(list(id = "classif.rpart.bagged", type = "classif", package = "rpart", 
         properties = NULL, par.set = structure(list(pars = list(bw.iters = structure(list(
             id = "bw.iters", type = "integer", len = 1L, lower = 1L, upper = Inf, values = NULL, 
             cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 10L, trafo = NULL, 
             requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), bw.replace = structure(list(id = "bw.replace", type = "logical", len = 1L, 
             lower = NULL, upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), 
             cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = TRUE, trafo = NULL, 
             requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), bw.size = structure(list(id = "bw.size", type = "numeric", len = 1L, 
             lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
             default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
             when = "train"), class = c("LearnerParam", "Param")), bw.feats = structure(list(
             id = "bw.feats", type = "numeric", len = 1L, lower = 0, upper = 1, values = NULL, 
             cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 0.666666666666667, 
             trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param"))), forbidden = NULL), class = c("LearnerParamSet", "ParamSet")), par.vals = list(
             bw.iters = 3L), predict.type = "response", fix.factors.prediction = FALSE, 
         next.learner = structure(list(id = "classif.rpart", type = "classif", package = "rpart", 
             properties = c("twoclass", "multiclass", "missings", "numerics", "factors", 
             "ordered", "prob", "weights", "featimp"), par.set = structure(list(pars = list(
                 minsplit = structure(list(id = "minsplit", type = "integer", len = 1L, 
                     lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 20L, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), minbucket = structure(list(id = "minbucket", type = "integer", 
                     len = 1L, lower = 1L, upper = Inf, values = NULL, cnames = NULL, 
                     allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), cp = structure(list(id = "cp", type = "numeric", len = 1L, 
                     lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 0.01, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), maxcompete = structure(list(id = "maxcompete", type = "integer", 
                     len = 1L, lower = 0L, upper = Inf, values = NULL, cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = 4L, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), maxsurrogate = structure(list(id = "maxsurrogate", type = "integer", 
                     len = 1L, lower = 0L, upper = Inf, values = NULL, cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = 5L, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), usesurrogate = structure(list(id = "usesurrogate", type = "discrete", 
                     len = 1L, lower = NULL, upper = NULL, values = list(`0` = 0L, `1` = 1L, 
                       `2` = 2L), cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = 2L, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), surrogatestyle = structure(list(
                     id = "surrogatestyle", type = "discrete", len = 1L, lower = NULL, 
                     upper = NULL, values = list(`0` = 0L, `1` = 1L), cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 0L, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), maxdepth = structure(list(id = "maxdepth", type = "integer", 
                     len = 1L, lower = 1L, upper = 30L, values = NULL, cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = 30L, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), xval = structure(list(id = "xval", type = "integer", len = 1L, 
                     lower = 0L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 10L, trafo = NULL, requires = NULL, 
                     tunable = FALSE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), parms = structure(list(id = "parms", type = "untyped", len = 1L, 
                     lower = NULL, upper = NULL, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param"))), forbidden = NULL), class = c("LearnerParamSet", "ParamSet"
             )), par.vals = list(xval = 0L), predict.type = "response", name = "Decision Tree", 
             short.name = "rpart", note = "`xval` has been set to `0` by default for speed.", 
             callees = c("rpart", "rpart.control"), help.list = list(minsplit = "Argument of: rpart::rpart.control\n\nthe minimum number of observations that must exist in a node in order for a split to be attempted.", 
                 minbucket = "Argument of: rpart::rpart.control\n\nthe minimum number of observations in any terminal <leaf> node. If only one of minbucket or minsplit is specified, the code either sets minsplit to minbucket*3 or minbucket to minsplit/3, as appropriate.", 
                 cp = "Argument of: rpart::rpart.control\n\ncomplexity parameter.  Any split that does not decrease the overall lack of fit by a factor of cp is not attempted.  For instance, with anova splitting, this means that the overall R-squared must increase by cp at each step. The main role of this parameter is to save computing time by pruning off splits that are obviously not worthwhile. Essentially,the user informs the program that any split which does not improve the fit by cp will likely be pruned off by cross-validation, and that hence the program need not pursue it.", 
                 maxcompete = "Argument of: rpart::rpart.control\n\nthe number of competitor splits retained in the output.  It is useful to know not just which split was chosen, but which variable came in second, third, etc.", 
                 maxsurrogate = "Argument of: rpart::rpart.control\n\nthe number of surrogate splits retained in the output.  If this is set to zero the compute time will be reduced, since approximately half of the computational time (other than setup) is used in the search for surrogate splits.", 
                 usesurrogate = "Argument of: rpart::rpart.control\n\nhow to use surrogates in the splitting process.  0 means display only; an observation with a missing value for the primary split rule is not sent further down the tree.  1 means use surrogates, in order, to split subjects missing the primary variable; if all surrogates are missing the observation is not split.  For value 2 ,if all surrogates are missing, then send the observation in the majority direction.  A value of 0 corresponds to the action of tree, and 2 to the recommendations of Breiman et.al (1984).", 
                 xval = "Argument of: rpart::rpart.control\n\nnumber of cross-validations.", 
                 surrogatestyle = "Argument of: rpart::rpart.control\n\ncontrols the selection of a best surrogate. If set to 0 (default) the program uses the total number of correct classification for a potential surrogate variable, if set to 1 it uses the percent correct, calculated over the non-missing values of the surrogate. The first option more severely penalizes covariates with a large number of missing values.", 
                 maxdepth = "Argument of: rpart::rpart.control\n\nSet the maximum depth of any node of the final tree, with the root node counted as depth 0.  Values greater than  30 rpart will give nonsense results on 32-bit machines.", 
                 parms = "Argument of: rpart::rpart\n\noptional parameters for the splitting function. Anova splitting has no parameters. Poisson splitting has a single parameter, the coefficient of variation of the prior distribution on the rates.  The default value is 1. Exponential splitting has the same parameter as Poisson. For classification splitting, the list can contain any of: the vector of prior probabilities (component prior), the loss matrix (component loss) or the splitting index (component split).  The priors must be positive and sum to 1.  The loss matrix must have zeros on the diagonal and positive off-diagonal elements.  The splitting index can be gini or information.  The default priors are proportional to the data counts, the losses default to 1, and the split defaults to gini."), 
             config = list(), fix.factors.prediction = FALSE), class = c("classif.rpart", 
         "RLearnerClassif", "RLearner", "Learner")), model.subclass = c("BaggingModel", 
         "HomogeneousEnsembleModel")), class = c("BaggingWrapper", "HomogeneousEnsemble", 
     "BaseWrapper", "Learner")), .task = structure(list(type = "classif", env = <environment>, 
         weights = NULL, blocking = NULL, coordinates = NULL, task.desc = structure(list(
             id = "multiclass", type = "classif", target = "Species", size = 150L, n.feat = c(numerics = 4L, 
             factors = 0L, ordered = 0L, functionals = 0L), has.missings = FALSE, has.weights = FALSE, 
             has.blocking = FALSE, has.coordinates = FALSE, class.levels = c("setosa", 
             "versicolor", "virginica"), positive = NA_character_, negative = NA_character_, 
             class.distribution = structure(c(setosa = 50L, versicolor = 50L, virginica = 50L
             ), .Dim = 3L, .Dimnames = list(c("setosa", "versicolor", "virginica")), class = "table")), class = c("ClassifTaskDesc", 
         "SupervisedTaskDesc", "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", 
     "Task")), .subset = NULL, xval = 0L, bw.iters = 3L)
  13: trainLearner.BaggingWrapper(.learner = structure(list(id = "classif.rpart.bagged", 
         type = "classif", package = "rpart", properties = NULL, par.set = structure(list(
             pars = list(bw.iters = structure(list(id = "bw.iters", type = "integer", 
                 len = 1L, lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 10L, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), bw.replace = structure(list(id = "bw.replace", type = "logical", len = 1L, 
                 lower = NULL, upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = TRUE, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), bw.size = structure(list(
                 id = "bw.size", type = "numeric", len = 1L, lower = 0, upper = 1, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), bw.feats = structure(list(
                 id = "bw.feats", type = "numeric", len = 1L, lower = 0, upper = 1, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 0.666666666666667, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param"))), forbidden = NULL), class = c("LearnerParamSet", 
         "ParamSet")), par.vals = list(bw.iters = 3L), predict.type = "response", fix.factors.prediction = FALSE, 
         next.learner = structure(list(id = "classif.rpart", type = "classif", package = "rpart", 
             properties = c("twoclass", "multiclass", "missings", "numerics", "factors", 
             "ordered", "prob", "weights", "featimp"), par.set = structure(list(pars = list(
                 minsplit = structure(list(id = "minsplit", type = "integer", len = 1L, 
                     lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 20L, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), minbucket = structure(list(id = "minbucket", type = "integer", 
                     len = 1L, lower = 1L, upper = Inf, values = NULL, cnames = NULL, 
                     allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), cp = structure(list(id = "cp", type = "numeric", len = 1L, 
                     lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 0.01, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), maxcompete = structure(list(id = "maxcompete", type = "integer", 
                     len = 1L, lower = 0L, upper = Inf, values = NULL, cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = 4L, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), maxsurrogate = structure(list(id = "maxsurrogate", type = "integer", 
                     len = 1L, lower = 0L, upper = Inf, values = NULL, cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = 5L, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), usesurrogate = structure(list(id = "usesurrogate", type = "discrete", 
                     len = 1L, lower = NULL, upper = NULL, values = list(`0` = 0L, `1` = 1L, 
                       `2` = 2L), cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = 2L, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), surrogatestyle = structure(list(
                     id = "surrogatestyle", type = "discrete", len = 1L, lower = NULL, 
                     upper = NULL, values = list(`0` = 0L, `1` = 1L), cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 0L, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), maxdepth = structure(list(id = "maxdepth", type = "integer", 
                     len = 1L, lower = 1L, upper = 30L, values = NULL, cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = 30L, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), xval = structure(list(id = "xval", type = "integer", len = 1L, 
                     lower = 0L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 10L, trafo = NULL, requires = NULL, 
                     tunable = FALSE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), parms = structure(list(id = "parms", type = "untyped", len = 1L, 
                     lower = NULL, upper = NULL, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param"))), forbidden = NULL), class = c("LearnerParamSet", "ParamSet"
             )), par.vals = list(xval = 0L), predict.type = "response", name = "Decision Tree", 
             short.name = "rpart", note = "`xval` has been set to `0` by default for speed.", 
             callees = c("rpart", "rpart.control"), help.list = list(minsplit = "Argument of: rpart::rpart.control\n\nthe minimum number of observations that must exist in a node in order for a split to be attempted.", 
                 minbucket = "Argument of: rpart::rpart.control\n\nthe minimum number of observations in any terminal <leaf> node. If only one of minbucket or minsplit is specified, the code either sets minsplit to minbucket*3 or minbucket to minsplit/3, as appropriate.", 
                 cp = "Argument of: rpart::rpart.control\n\ncomplexity parameter.  Any split that does not decrease the overall lack of fit by a factor of cp is not attempted.  For instance, with anova splitting, this means that the overall R-squared must increase by cp at each step. The main role of this parameter is to save computing time by pruning off splits that are obviously not worthwhile. Essentially,the user informs the program that any split which does not improve the fit by cp will likely be pruned off by cross-validation, and that hence the program need not pursue it.", 
                 maxcompete = "Argument of: rpart::rpart.control\n\nthe number of competitor splits retained in the output.  It is useful to know not just which split was chosen, but which variable came in second, third, etc.", 
                 maxsurrogate = "Argument of: rpart::rpart.control\n\nthe number of surrogate splits retained in the output.  If this is set to zero the compute time will be reduced, since approximately half of the computational time (other than setup) is used in the search for surrogate splits.", 
                 usesurrogate = "Argument of: rpart::rpart.control\n\nhow to use surrogates in the splitting process.  0 means display only; an observation with a missing value for the primary split rule is not sent further down the tree.  1 means use surrogates, in order, to split subjects missing the primary variable; if all surrogates are missing the observation is not split.  For value 2 ,if all surrogates are missing, then send the observation in the majority direction.  A value of 0 corresponds to the action of tree, and 2 to the recommendations of Breiman et.al (1984).", 
                 xval = "Argument of: rpart::rpart.control\n\nnumber of cross-validations.", 
                 surrogatestyle = "Argument of: rpart::rpart.control\n\ncontrols the selection of a best surrogate. If set to 0 (default) the program uses the total number of correct classification for a potential surrogate variable, if set to 1 it uses the percent correct, calculated over the non-missing values of the surrogate. The first option more severely penalizes covariates with a large number of missing values.", 
                 maxdepth = "Argument of: rpart::rpart.control\n\nSet the maximum depth of any node of the final tree, with the root node counted as depth 0.  Values greater than  30 rpart will give nonsense results on 32-bit machines.", 
                 parms = "Argument of: rpart::rpart\n\noptional parameters for the splitting function. Anova splitting has no parameters. Poisson splitting has a single parameter, the coefficient of variation of the prior distribution on the rates.  The default value is 1. Exponential splitting has the same parameter as Poisson. For classification splitting, the list can contain any of: the vector of prior probabilities (component prior), the loss matrix (component loss) or the splitting index (component split).  The priors must be positive and sum to 1.  The loss matrix must have zeros on the diagonal and positive off-diagonal elements.  The splitting index can be gini or information.  The default priors are proportional to the data counts, the losses default to 1, and the split defaults to gini."), 
             config = list(), fix.factors.prediction = FALSE), class = c("classif.rpart", 
         "RLearnerClassif", "RLearner", "Learner")), model.subclass = c("BaggingModel", 
         "HomogeneousEnsembleModel")), class = c("BaggingWrapper", "HomogeneousEnsemble", 
     "BaseWrapper", "Learner")), .task = structure(list(type = "classif", env = <environment>, 
         weights = NULL, blocking = NULL, coordinates = NULL, task.desc = structure(list(
             id = "multiclass", type = "classif", target = "Species", size = 150L, n.feat = c(numerics = 4L, 
             factors = 0L, ordered = 0L, functionals = 0L), has.missings = FALSE, has.weights = FALSE, 
             has.blocking = FALSE, has.coordinates = FALSE, class.levels = c("setosa", 
             "versicolor", "virginica"), positive = NA_character_, negative = NA_character_, 
             class.distribution = structure(c(setosa = 50L, versicolor = 50L, virginica = 50L
             ), .Dim = 3L, .Dimnames = list(c("setosa", "versicolor", "virginica")), class = "table")), class = c("ClassifTaskDesc", 
         "SupervisedTaskDesc", "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", 
     "Task")), .subset = NULL, xval = 0L, bw.iters = 3L)
  14: parallelMap(doBaggingTrainIteration, i = seq_len(bw.iters), more.args = args, level = "mlr.ensemble")
  15: options(parallelMap.nextmap = (getPMOptNextMap() + 1L))
  16: getPMOptNextMap()
  17: getPMOption("nextmap")
  18: getOption(sprintf("parallelMap.%s", opt), def)
  
  ── 2. Error: BaggingWrapper works with feature subsampling (@test_base_BaggingWr
  argument "def" is missing, with no default
  1: train(lrn, multiclass.task) at testthat/test_base_BaggingWrapper.R:53
  2: measureTime(fun1({
         learner.model = fun2(fun3(do.call(trainLearner, pars)))
     }))
  3: force(expr)
  4: fun1({
         learner.model = fun2(fun3(do.call(trainLearner, pars)))
     })
  5: evalVis(expr)
  6: withVisible(eval(expr, pf))
  7: eval(expr, pf)
  8: eval(expr, pf)
  9: fun2(fun3(do.call(trainLearner, pars)))
  10: fun3(do.call(trainLearner, pars))
  11: do.call(trainLearner, pars)
  12: (function (.learner, .task, .subset, .weights = NULL, ...) 
     {
         UseMethod("trainLearner")
     })(.learner = structure(list(id = "classif.fnn.bagged", type = "classif", package = "FNN", 
         properties = NULL, par.set = structure(list(pars = list(bw.iters = structure(list(
             id = "bw.iters", type = "integer", len = 1L, lower = 1L, upper = Inf, values = NULL, 
             cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 10L, trafo = NULL, 
             requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), bw.replace = structure(list(id = "bw.replace", type = "logical", len = 1L, 
             lower = NULL, upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), 
             cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = TRUE, trafo = NULL, 
             requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), bw.size = structure(list(id = "bw.size", type = "numeric", len = 1L, 
             lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
             default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
             when = "train"), class = c("LearnerParam", "Param")), bw.feats = structure(list(
             id = "bw.feats", type = "numeric", len = 1L, lower = 0, upper = 1, values = NULL, 
             cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 0.666666666666667, 
             trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param"))), forbidden = NULL), class = c("LearnerParamSet", "ParamSet")), par.vals = list(
             bw.iters = 2L, bw.feats = 0.5), predict.type = "response", fix.factors.prediction = FALSE, 
         next.learner = structure(list(id = "classif.fnn", type = "classif", package = "FNN", 
             properties = c("twoclass", "multiclass", "numerics"), par.set = structure(list(
                 pars = list(k = structure(list(id = "k", type = "integer", len = 1L, 
                     lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 1L, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), prob = structure(list(id = "prob", type = "logical", len = 1L, 
                     lower = NULL, upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), 
                     cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = FALSE, 
                     trafo = NULL, requires = NULL, tunable = FALSE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), algorithm = structure(list(
                     id = "algorithm", type = "discrete", len = 1L, lower = NULL, upper = NULL, 
                     values = list(cover_tree = "cover_tree", kd_tree = "kd_tree", brute = "brute"), 
                     cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = "cover_tree", 
                     trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param"))), forbidden = NULL), class = c("LearnerParamSet", 
             "ParamSet")), par.vals = list(), predict.type = "response", name = "Fast k-Nearest Neighbour", 
             short.name = "fnn", note = "", callees = "knn", help.list = list(k = "Argument of: FNN::knn\n\nnumber of neighbours considered.", 
                 prob = "Argument of: FNN::knn\n\nif this is true, the proportion of the votes for the winning class are returned as attribute prob.", 
                 algorithm = "Argument of: FNN::knn\n\nnearest neighbor search algorithm."), 
             config = list(), fix.factors.prediction = FALSE), class = c("classif.fnn", 
         "RLearnerClassif", "RLearner", "Learner")), model.subclass = c("BaggingModel", 
         "HomogeneousEnsembleModel")), class = c("BaggingWrapper", "HomogeneousEnsemble", 
     "BaseWrapper", "Learner")), .task = structure(list(type = "classif", env = <environment>, 
         weights = NULL, blocking = NULL, coordinates = NULL, task.desc = structure(list(
             id = "multiclass", type = "classif", target = "Species", size = 150L, n.feat = c(numerics = 4L, 
             factors = 0L, ordered = 0L, functionals = 0L), has.missings = FALSE, has.weights = FALSE, 
             has.blocking = FALSE, has.coordinates = FALSE, class.levels = c("setosa", 
             "versicolor", "virginica"), positive = NA_character_, negative = NA_character_, 
             class.distribution = structure(c(setosa = 50L, versicolor = 50L, virginica = 50L
             ), .Dim = 3L, .Dimnames = list(c("setosa", "versicolor", "virginica")), class = "table")), class = c("ClassifTaskDesc", 
         "SupervisedTaskDesc", "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", 
     "Task")), .subset = NULL, bw.iters = 2L, bw.feats = 0.5)
  13: trainLearner.BaggingWrapper(.learner = structure(list(id = "classif.fnn.bagged", 
         type = "classif", package = "FNN", properties = NULL, par.set = structure(list(
             pars = list(bw.iters = structure(list(id = "bw.iters", type = "integer", 
                 len = 1L, lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 10L, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), bw.replace = structure(list(id = "bw.replace", type = "logical", len = 1L, 
                 lower = NULL, upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = TRUE, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), bw.size = structure(list(
                 id = "bw.size", type = "numeric", len = 1L, lower = 0, upper = 1, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), bw.feats = structure(list(
                 id = "bw.feats", type = "numeric", len = 1L, lower = 0, upper = 1, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 0.666666666666667, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param"))), forbidden = NULL), class = c("LearnerParamSet", 
         "ParamSet")), par.vals = list(bw.iters = 2L, bw.feats = 0.5), predict.type = "response", 
         fix.factors.prediction = FALSE, next.learner = structure(list(id = "classif.fnn", 
             type = "classif", package = "FNN", properties = c("twoclass", "multiclass", 
             "numerics"), par.set = structure(list(pars = list(k = structure(list(id = "k", 
                 type = "integer", len = 1L, lower = 1L, upper = Inf, values = NULL, cnames = NULL, 
                 allow.inf = FALSE, has.default = TRUE, default = 1L, trafo = NULL, requires = NULL, 
                 tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), prob = structure(list(id = "prob", type = "logical", len = 1L, 
                 lower = NULL, upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = FALSE, 
                 trafo = NULL, requires = NULL, tunable = FALSE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), algorithm = structure(list(
                 id = "algorithm", type = "discrete", len = 1L, lower = NULL, upper = NULL, 
                 values = list(cover_tree = "cover_tree", kd_tree = "kd_tree", brute = "brute"), 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = "cover_tree", 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param"))), forbidden = NULL), class = c("LearnerParamSet", 
             "ParamSet")), par.vals = list(), predict.type = "response", name = "Fast k-Nearest Neighbour", 
             short.name = "fnn", note = "", callees = "knn", help.list = list(k = "Argument of: FNN::knn\n\nnumber of neighbours considered.", 
                 prob = "Argument of: FNN::knn\n\nif this is true, the proportion of the votes for the winning class are returned as attribute prob.", 
                 algorithm = "Argument of: FNN::knn\n\nnearest neighbor search algorithm."), 
             config = list(), fix.factors.prediction = FALSE), class = c("classif.fnn", 
         "RLearnerClassif", "RLearner", "Learner")), model.subclass = c("BaggingModel", 
         "HomogeneousEnsembleModel")), class = c("BaggingWrapper", "HomogeneousEnsemble", 
     "BaseWrapper", "Learner")), .task = structure(list(type = "classif", env = <environment>, 
         weights = NULL, blocking = NULL, coordinates = NULL, task.desc = structure(list(
             id = "multiclass", type = "classif", target = "Species", size = 150L, n.feat = c(numerics = 4L, 
             factors = 0L, ordered = 0L, functionals = 0L), has.missings = FALSE, has.weights = FALSE, 
             has.blocking = FALSE, has.coordinates = FALSE, class.levels = c("setosa", 
             "versicolor", "virginica"), positive = NA_character_, negative = NA_character_, 
             class.distribution = structure(c(setosa = 50L, versicolor = 50L, virginica = 50L
             ), .Dim = 3L, .Dimnames = list(c("setosa", "versicolor", "virginica")), class = "table")), class = c("ClassifTaskDesc", 
         "SupervisedTaskDesc", "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", 
     "Task")), .subset = NULL, bw.iters = 2L, bw.feats = 0.5)
  14: parallelMap(doBaggingTrainIteration, i = seq_len(bw.iters), more.args = args, level = "mlr.ensemble")
  15: options(parallelMap.nextmap = (getPMOptNextMap() + 1L))
  16: getPMOptNextMap()
  17: getPMOption("nextmap")
  18: getOption(sprintf("parallelMap.%s", opt), def)
  
  ── 3. Error: BaggingWrapper works with 1 obs in newdata (@test_base_BaggingWrapp
  argument "def" is missing, with no default
  1: train(lrn, regr.task) at testthat/test_base_BaggingWrapper.R:61
  2: measureTime(fun1({
         learner.model = fun2(fun3(do.call(trainLearner, pars)))
     }))
  3: force(expr)
  4: fun1({
         learner.model = fun2(fun3(do.call(trainLearner, pars)))
     })
  5: evalVis(expr)
  6: withVisible(eval(expr, pf))
  7: eval(expr, pf)
  8: eval(expr, pf)
  9: fun2(fun3(do.call(trainLearner, pars)))
  10: fun3(do.call(trainLearner, pars))
  11: do.call(trainLearner, pars)
  12: (function (.learner, .task, .subset, .weights = NULL, ...) 
     {
         UseMethod("trainLearner")
     })(.learner = structure(list(id = "regr.lm.bagged", type = "regr", package = "stats", 
         properties = NULL, par.set = structure(list(pars = list(bw.iters = structure(list(
             id = "bw.iters", type = "integer", len = 1L, lower = 1L, upper = Inf, values = NULL, 
             cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 10L, trafo = NULL, 
             requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), bw.replace = structure(list(id = "bw.replace", type = "logical", len = 1L, 
             lower = NULL, upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), 
             cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = TRUE, trafo = NULL, 
             requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), bw.size = structure(list(id = "bw.size", type = "numeric", len = 1L, 
             lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
             default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
             when = "train"), class = c("LearnerParam", "Param")), bw.feats = structure(list(
             id = "bw.feats", type = "numeric", len = 1L, lower = 0, upper = 1, values = NULL, 
             cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 0.666666666666667, 
             trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param"))), forbidden = NULL), class = c("LearnerParamSet", "ParamSet")), par.vals = list(
             bw.iters = 2L), predict.type = "response", fix.factors.prediction = FALSE, 
         next.learner = structure(list(id = "regr.lm", type = "regr", package = "stats", 
             properties = c("numerics", "factors", "se", "weights"), par.set = structure(list(
                 pars = list(tol = structure(list(id = "tol", type = "numeric", len = 1L, 
                     lower = 0, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 1e-07, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), singular.ok = structure(list(id = "singular.ok", type = "logical", 
                     len = 1L, lower = NULL, upper = NULL, values = list(`TRUE` = TRUE, 
                       `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = TRUE, trafo = NULL, requires = NULL, tunable = FALSE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param"))), forbidden = NULL), class = c("LearnerParamSet", 
             "ParamSet")), par.vals = list(), predict.type = "response", name = "Simple Linear Regression", 
             short.name = "lm", note = "", callees = c("lm", "lm.fit", "lm.wfit"), help.list = list(
                 tol = "Argument of: stats::lm.fit\n\ntolerance for the qr decomposition.  Default is 1e-7.", 
                 singular.ok = "Argument of: stats::lm\n\nlogical. If FALSE (the default in S but not in R) a singular fit is an error."), 
             config = list(), fix.factors.prediction = FALSE), class = c("regr.lm", "RLearnerRegr", 
         "RLearner", "Learner")), model.subclass = c("BaggingModel", "HomogeneousEnsembleModel"
         )), class = c("BaggingWrapper", "HomogeneousEnsemble", "BaseWrapper", "Learner"
     )), .task = structure(list(type = "regr", env = <environment>, weights = NULL, blocking = NULL, 
         coordinates = NULL, task.desc = structure(list(id = "regrtask", type = "regr", 
             target = "medv", size = 506L, n.feat = c(numerics = 12L, factors = 1L, ordered = 0L, 
             functionals = 0L), has.missings = FALSE, has.weights = FALSE, has.blocking = FALSE, 
             has.coordinates = FALSE), class = c("RegrTaskDesc", "SupervisedTaskDesc", 
         "TaskDesc"))), class = c("RegrTask", "SupervisedTask", "Task")), .subset = NULL, 
         bw.iters = 2L)
  13: trainLearner.BaggingWrapper(.learner = structure(list(id = "regr.lm.bagged", type = "regr", 
         package = "stats", properties = NULL, par.set = structure(list(pars = list(bw.iters = structure(list(
             id = "bw.iters", type = "integer", len = 1L, lower = 1L, upper = Inf, values = NULL, 
             cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 10L, trafo = NULL, 
             requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), bw.replace = structure(list(id = "bw.replace", type = "logical", len = 1L, 
             lower = NULL, upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), 
             cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = TRUE, trafo = NULL, 
             requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), bw.size = structure(list(id = "bw.size", type = "numeric", len = 1L, 
             lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
             default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
             when = "train"), class = c("LearnerParam", "Param")), bw.feats = structure(list(
             id = "bw.feats", type = "numeric", len = 1L, lower = 0, upper = 1, values = NULL, 
             cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 0.666666666666667, 
             trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param"))), forbidden = NULL), class = c("LearnerParamSet", "ParamSet")), par.vals = list(
             bw.iters = 2L), predict.type = "response", fix.factors.prediction = FALSE, 
         next.learner = structure(list(id = "regr.lm", type = "regr", package = "stats", 
             properties = c("numerics", "factors", "se", "weights"), par.set = structure(list(
                 pars = list(tol = structure(list(id = "tol", type = "numeric", len = 1L, 
                     lower = 0, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 1e-07, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), singular.ok = structure(list(id = "singular.ok", type = "logical", 
                     len = 1L, lower = NULL, upper = NULL, values = list(`TRUE` = TRUE, 
                       `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = TRUE, trafo = NULL, requires = NULL, tunable = FALSE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param"))), forbidden = NULL), class = c("LearnerParamSet", 
             "ParamSet")), par.vals = list(), predict.type = "response", name = "Simple Linear Regression", 
             short.name = "lm", note = "", callees = c("lm", "lm.fit", "lm.wfit"), help.list = list(
                 tol = "Argument of: stats::lm.fit\n\ntolerance for the qr decomposition.  Default is 1e-7.", 
                 singular.ok = "Argument of: stats::lm\n\nlogical. If FALSE (the default in S but not in R) a singular fit is an error."), 
             config = list(), fix.factors.prediction = FALSE), class = c("regr.lm", "RLearnerRegr", 
         "RLearner", "Learner")), model.subclass = c("BaggingModel", "HomogeneousEnsembleModel"
         )), class = c("BaggingWrapper", "HomogeneousEnsemble", "BaseWrapper", "Learner"
     )), .task = structure(list(type = "regr", env = <environment>, weights = NULL, blocking = NULL, 
         coordinates = NULL, task.desc = structure(list(id = "regrtask", type = "regr", 
             target = "medv", size = 506L, n.feat = c(numerics = 12L, factors = 1L, ordered = 0L, 
             functionals = 0L), has.missings = FALSE, has.weights = FALSE, has.blocking = FALSE, 
             has.coordinates = FALSE), class = c("RegrTaskDesc", "SupervisedTaskDesc", 
         "TaskDesc"))), class = c("RegrTask", "SupervisedTask", "Task")), .subset = NULL, 
         bw.iters = 2L)
  14: parallelMap(doBaggingTrainIteration, i = seq_len(bw.iters), more.args = args, level = "mlr.ensemble")
  15: options(parallelMap.nextmap = (getPMOptNextMap() + 1L))
  16: getPMOptNextMap()
  17: getPMOption("nextmap")
  18: getOption(sprintf("parallelMap.%s", opt), def)
  
  ── 4. Error: BaggingWrapper with glmnet (#958) (@test_base_BaggingWrapper.R#70) 
  argument "def" is missing, with no default
  1: train(lrn2, multiclass.task) at testthat/test_base_BaggingWrapper.R:70
  2: measureTime(fun1({
         learner.model = fun2(fun3(do.call(trainLearner, pars)))
     }))
  3: force(expr)
  4: fun1({
         learner.model = fun2(fun3(do.call(trainLearner, pars)))
     })
  5: evalVis(expr)
  6: withVisible(eval(expr, pf))
  7: eval(expr, pf)
  8: eval(expr, pf)
  9: fun2(fun3(do.call(trainLearner, pars)))
  10: fun3(do.call(trainLearner, pars))
  11: do.call(trainLearner, pars)
  12: (function (.learner, .task, .subset, .weights = NULL, ...) 
     {
         UseMethod("trainLearner")
     })(.learner = structure(list(id = "classif.glmnet.bagged", type = "classif", package = "glmnet", 
         properties = NULL, par.set = structure(list(pars = list(bw.iters = structure(list(
             id = "bw.iters", type = "integer", len = 1L, lower = 1L, upper = Inf, values = NULL, 
             cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 10L, trafo = NULL, 
             requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), bw.replace = structure(list(id = "bw.replace", type = "logical", len = 1L, 
             lower = NULL, upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), 
             cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = TRUE, trafo = NULL, 
             requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), bw.size = structure(list(id = "bw.size", type = "numeric", len = 1L, 
             lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
             default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
             when = "train"), class = c("LearnerParam", "Param")), bw.feats = structure(list(
             id = "bw.feats", type = "numeric", len = 1L, lower = 0, upper = 1, values = NULL, 
             cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 0.666666666666667, 
             trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param"))), forbidden = NULL), class = c("LearnerParamSet", "ParamSet")), par.vals = list(), 
         predict.type = "response", fix.factors.prediction = FALSE, next.learner = structure(list(
             id = "classif.glmnet", type = "classif", package = "glmnet", properties = c("numerics", 
             "factors", "prob", "twoclass", "multiclass", "weights"), par.set = structure(list(
                 pars = list(alpha = structure(list(id = "alpha", type = "numeric", len = 1L, 
                     lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 1, trafo = NULL, requires = NULL, tunable = TRUE, 
                     special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), s = structure(list(id = "s", type = "numeric", len = 1L, lower = 0, 
                     upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                     default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "predict"), class = c("LearnerParam", "Param")), exact = structure(list(
                     id = "exact", type = "logical", len = 1L, lower = NULL, upper = NULL, 
                     values = list(`TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = FALSE, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "predict"), class = c("LearnerParam", 
                 "Param")), nlambda = structure(list(id = "nlambda", type = "integer", 
                     len = 1L, lower = 1L, upper = Inf, values = NULL, cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = 100L, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), lambda.min.ratio = structure(list(id = "lambda.min.ratio", 
                     type = "numeric", len = 1L, lower = 0, upper = 1, values = NULL, 
                     cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, 
                     trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), lambda = structure(list(
                     id = "lambda", type = "numericvector", len = NA_integer_, lower = 0, 
                     upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                     default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), standardize = structure(list(
                     id = "standardize", type = "logical", len = 1L, lower = NULL, upper = NULL, 
                     values = list(`TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = TRUE, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), intercept = structure(list(id = "intercept", type = "logical", 
                     len = 1L, lower = NULL, upper = NULL, values = list(`TRUE` = TRUE, 
                       `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = TRUE, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), thresh = structure(list(
                     id = "thresh", type = "numeric", len = 1L, lower = 0, upper = Inf, 
                     values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = 1e-07, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), dfmax = structure(list(
                     id = "dfmax", type = "integer", len = 1L, lower = 0L, upper = Inf, 
                     values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                     default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), pmax = structure(list(
                     id = "pmax", type = "integer", len = 1L, lower = 0L, upper = Inf, 
                     values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                     default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), exclude = structure(list(
                     id = "exclude", type = "integervector", len = NA_integer_, lower = 1L, 
                     upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                     default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), penalty.factor = structure(list(
                     id = "penalty.factor", type = "numericvector", len = NA_integer_, 
                     lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), lower.limits = structure(list(id = "lower.limits", type = "numericvector", 
                     len = NA_integer_, lower = -Inf, upper = 0, values = NULL, cnames = NULL, 
                     allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), upper.limits = structure(list(id = "upper.limits", type = "numericvector", 
                     len = NA_integer_, lower = 0, upper = Inf, values = NULL, cnames = NULL, 
                     allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), maxit = structure(list(id = "maxit", type = "integer", len = 1L, 
                     lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 100000L, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), type.logistic = structure(list(id = "type.logistic", type = "discrete", 
                     len = 1L, lower = NULL, upper = NULL, values = list(Newton = "Newton", 
                       modified.Newton = "modified.Newton"), cnames = NULL, allow.inf = FALSE, 
                     has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), type.multinomial = structure(list(id = "type.multinomial", 
                     type = "discrete", len = 1L, lower = NULL, upper = NULL, values = list(
                       ungrouped = "ungrouped", grouped = "grouped"), cnames = NULL, allow.inf = FALSE, 
                     has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), fdev = structure(list(id = "fdev", type = "numeric", len = 1L, 
                     lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 1e-05, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), devmax = structure(list(id = "devmax", type = "numeric", len = 1L, 
                     lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 0.999, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), eps = structure(list(id = "eps", type = "numeric", len = 1L, 
                     lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 1e-06, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), big = structure(list(id = "big", type = "numeric", len = 1L, 
                     lower = -Inf, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 9.9e+35, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), mnlam = structure(list(id = "mnlam", type = "integer", len = 1L, 
                     lower = 1, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 5, trafo = NULL, requires = NULL, tunable = TRUE, 
                     special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), pmin = structure(list(id = "pmin", type = "numeric", len = 1L, 
                     lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 1e-09, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), exmx = structure(list(id = "exmx", type = "numeric", len = 1L, 
                     lower = -Inf, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 250, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), prec = structure(list(id = "prec", type = "numeric", len = 1L, 
                     lower = -Inf, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 1e-10, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), mxit = structure(list(id = "mxit", type = "integer", len = 1L, 
                     lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 100L, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param"))), forbidden = NULL), class = c("LearnerParamSet", "ParamSet"
             )), par.vals = list(s = 0.01), predict.type = "response", name = "GLM with Lasso or Elasticnet Regularization", 
             short.name = "glmnet", note = "The family parameter is set to `binomial` for two-class problems and to `multinomial` otherwise.\n      Factors automatically get converted to dummy columns, ordered factors to integer.\n      Parameter `s` (value of the regularization parameter used for predictions) is set to `0.1` by default,\n      but needs to be tuned by the user.\n      glmnet uses a global control object for its parameters. mlr resets all control parameters to their defaults\n      before setting the specified parameters and after training.\n      If you are setting glmnet.control parameters through glmnet.control,\n      you need to save and re-set them after running the glmnet learner.", 
             callees = c("glmnet", "glmnet.control", "predict.glmnet"), help.list = list(
                 s = "Argument of: glmnet::predict.glmnet\n\nValue(s) of the penalty parameter lambda at which predictions are required. Default is the entire sequence used to create the model.", 
                 exact = "Argument of: glmnet::predict.glmnet\n\nThis argument is relevant only when predictions are made at values of s (lambda) different from those used in the fitting of the original model. If exact=FALSE (default), then the predict function uses linear interpolation to make predictions for values of s (lambda) that do not coincide with those used in the fitting algorithm. While this is often a good approximation, it can sometimes be a bit coarse. With exact=TRUE, these different values of s are merged (and sorted) with object$lambda, and the model is refit before predictions are made. In this case, it is required to supply the original data x= and y= as additional named  arguments to predict() or coef(). The workhorse predict.glmnet() needs to  update the model, and so needs the data used to create it. The same is true of weights, offset, penalty.factor, lower.limits, upper.limits if these were used in the original call. Failure to do so will result in an error.", 
                 fdev = "Argument of: glmnet::glmnet.control\n\nminimum fractional change in deviance for stopping path; factory default = 1.0e-5", 
                 devmax = "Argument of: glmnet::glmnet.control\n\nmaximum fraction of explained deviance for stopping path; factory default = 0.999", 
                 eps = "Argument of: glmnet::glmnet.control\n\nminimum value of lambda.min.ratio (see glmnet); factory default= 1.0e-6", 
                 big = "Argument of: glmnet::glmnet.control\n\nlarge floating point number; factory default = 9.9e35. Inf in definition of upper.limit is set to big", 
                 mnlam = "Argument of: glmnet::glmnet.control\n\nminimum number of path points (lambda values) allowed; factory default = 5", 
                 pmin = "Argument of: glmnet::glmnet.control\n\nminimum probability for any class. factory default = 1.0e-9. Note that this implies a pmax of 1-pmin.", 
                 exmx = "Argument of: glmnet::glmnet.control\n\nmaximum allowed exponent. factory default = 250.0", 
                 prec = "Argument of: glmnet::glmnet.control\n\nconvergence threshold for multi response bounds adjustment solution. factory default = 1.0e-10", 
                 mxit = "Argument of: glmnet::glmnet.control\n\nmaximum iterations for multiresponse bounds adjustment solution.  factory default = 100", 
                 alpha = "Argument of: glmnet::glmnet\n\nThe elasticnet mixing parameter, with 0≤α≤ 1. The penalty is defined as (1-α)/2||β||_2^2+α||β||_1. alpha=1 is the lasso penalty, and alpha=0 the ridge penalty.", 
                 nlambda = "Argument of: glmnet::glmnet\n\nThe number of lambda values - default is 100.", 
                 lambda.min.ratio = "Argument of: glmnet::glmnet\n\nSmallest value for lambda, as a fraction of lambda.max, the (data derived) entry value (i.e. the smallest value for which all coefficients are zero). The default depends on the sample size nobs relative to the number of variables nvars. If nobs > nvars, the default is 0.0001, close to zero.  If nobs < nvars, the default is 0.01. A very small value of lambda.min.ratio will lead to a saturated fit in the nobs < nvars case. This is undefined for \"binomial\" and \"multinomial\" models, and glmnet will exit gracefully when the percentage deviance explained is almost 1.", 
                 lambda = "Argument of: glmnet::glmnet\n\nA user supplied lambda sequence. Typical usage is to have the program compute its own lambda sequence based on nlambda and lambda.min.ratio. Supplying a value of lambda overrides this. WARNING: use with care. Avoid supplying a single value for lambda (for predictions after CV use predict() instead).  Supply instead a decreasing sequence of lambda values. glmnet relies on its warms starts for speed, and its often faster to fit a whole path than compute a single fit.", 
                 standardize = "Argument of: glmnet::glmnet\n\nLogical flag for x variable standardization, prior to fitting the model sequence. The coefficients are always returned on the original scale. Default is standardize=TRUE. If variables are in the same units already, you might not wish to standardize. See details below for y standardization with family=\"gaussian\".", 
                 intercept = "Argument of: glmnet::glmnet\n\nShould intercept(s) be fitted (default=TRUE) or set to zero (FALSE)", 
                 thresh = "Argument of: glmnet::glmnet\n\nConvergence threshold for coordinate descent. Each inner coordinate-descent loop continues until the maximum change in the objective after any coefficient update is less than thresh times the null deviance. Defaults value is 1E-7.", 
                 dfmax = "Argument of: glmnet::glmnet\n\nLimit the maximum number of variables in the model. Useful for very large nvars, if a partial path is desired.", 
                 pmax = "Argument of: glmnet::glmnet\n\nLimit the maximum number of variables ever to be nonzero", 
                 exclude = "Argument of: glmnet::glmnet\n\nIndices of variables to be excluded from the model. Default is none. Equivalent to an infinite penalty factor (next item).", 
                 penalty.factor = "Argument of: glmnet::glmnet\n\nSeparate penalty factors can be applied to each coefficient. This is a number that multiplies lambda to allow differential shrinkage. Can be 0 for some variables, which implies no shrinkage, and that variable is always included in the model. Default is 1 for all variables (and implicitly infinity for variables listed in exclude). Note: the penalty factors are internally rescaled to sum to nvars, and the lambda sequence will reflect this change.", 
                 lower.limits = "Argument of: glmnet::glmnet\n\nVector of lower limits for each coefficient; default -Inf. Each of these must be non-positive. Can be presented as a single value (which will then be replicated), else a vector of length nvars", 
                 upper.limits = "Argument of: glmnet::glmnet\n\nVector of upper limits for each coefficient; default Inf. See lower.limits", 
                 maxit = "Argument of: glmnet::glmnet\n\nMaximum number of passes over the data for all lambda values; default is 10^5.", 
                 type.logistic = "Argument of: glmnet::glmnet\n\nIf \"Newton\" then the exact hessian is used (default), while \"modified.Newton\" uses an upper-bound on the hessian, and can be faster.", 
                 type.multinomial = "Argument of: glmnet::glmnet\n\nIf \"grouped\" then a grouped lasso penalty is used on the multinomial coefficients for a variable. This ensures they are all in our out together. The default is \"ungrouped\""), 
             config = list(), fix.factors.prediction = FALSE), class = c("classif.glmnet", 
         "RLearnerClassif", "RLearner", "Learner")), model.subclass = c("BaggingModel", 
         "HomogeneousEnsembleModel")), class = c("BaggingWrapper", "HomogeneousEnsemble", 
     "BaseWrapper", "Learner")), .task = structure(list(type = "classif", env = <environment>, 
         weights = NULL, blocking = NULL, coordinates = NULL, task.desc = structure(list(
             id = "multiclass", type = "classif", target = "Species", size = 150L, n.feat = c(numerics = 4L, 
             factors = 0L, ordered = 0L, functionals = 0L), has.missings = FALSE, has.weights = FALSE, 
             has.blocking = FALSE, has.coordinates = FALSE, class.levels = c("setosa", 
             "versicolor", "virginica"), positive = NA_character_, negative = NA_character_, 
             class.distribution = structure(c(setosa = 50L, versicolor = 50L, virginica = 50L
             ), .Dim = 3L, .Dimnames = list(c("setosa", "versicolor", "virginica")), class = "table")), class = c("ClassifTaskDesc", 
         "SupervisedTaskDesc", "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", 
     "Task")), .subset = NULL)
  13: trainLearner.BaggingWrapper(.learner = structure(list(id = "classif.glmnet.bagged", 
         type = "classif", package = "glmnet", properties = NULL, par.set = structure(list(
             pars = list(bw.iters = structure(list(id = "bw.iters", type = "integer", 
                 len = 1L, lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 10L, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), bw.replace = structure(list(id = "bw.replace", type = "logical", len = 1L, 
                 lower = NULL, upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = TRUE, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), bw.size = structure(list(
                 id = "bw.size", type = "numeric", len = 1L, lower = 0, upper = 1, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), bw.feats = structure(list(
                 id = "bw.feats", type = "numeric", len = 1L, lower = 0, upper = 1, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 0.666666666666667, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param"))), forbidden = NULL), class = c("LearnerParamSet", 
         "ParamSet")), par.vals = list(), predict.type = "response", fix.factors.prediction = FALSE, 
         next.learner = structure(list(id = "classif.glmnet", type = "classif", package = "glmnet", 
             properties = c("numerics", "factors", "prob", "twoclass", "multiclass", "weights"
             ), par.set = structure(list(pars = list(alpha = structure(list(id = "alpha", 
                 type = "numeric", len = 1L, lower = 0, upper = 1, values = NULL, cnames = NULL, 
                 allow.inf = FALSE, has.default = TRUE, default = 1, trafo = NULL, requires = NULL, 
                 tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), s = structure(list(id = "s", type = "numeric", len = 1L, lower = 0, 
                 upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                 default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "predict"), class = c("LearnerParam", "Param")), exact = structure(list(
                 id = "exact", type = "logical", len = 1L, lower = NULL, upper = NULL, 
                 values = list(`TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = FALSE, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "predict"), class = c("LearnerParam", "Param"
             )), nlambda = structure(list(id = "nlambda", type = "integer", len = 1L, 
                 lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 100L, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), lambda.min.ratio = structure(list(id = "lambda.min.ratio", type = "numeric", 
                 len = 1L, lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), lambda = structure(list(id = "lambda", type = "numericvector", len = NA_integer_, 
                 lower = 0, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), standardize = structure(list(id = "standardize", type = "logical", len = 1L, 
                 lower = NULL, upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = TRUE, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), intercept = structure(list(
                 id = "intercept", type = "logical", len = 1L, lower = NULL, upper = NULL, 
                 values = list(`TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = TRUE, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), thresh = structure(list(id = "thresh", type = "numeric", len = 1L, lower = 0, 
                 upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 1e-07, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), dfmax = structure(list(
                 id = "dfmax", type = "integer", len = 1L, lower = 0L, upper = Inf, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), pmax = structure(list(
                 id = "pmax", type = "integer", len = 1L, lower = 0L, upper = Inf, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), exclude = structure(list(
                 id = "exclude", type = "integervector", len = NA_integer_, lower = 1L, 
                 upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                 default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), penalty.factor = structure(list(
                 id = "penalty.factor", type = "numericvector", len = NA_integer_, lower = 0, 
                 upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                 default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), lower.limits = structure(list(
                 id = "lower.limits", type = "numericvector", len = NA_integer_, lower = -Inf, 
                 upper = 0, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                 default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), upper.limits = structure(list(
                 id = "upper.limits", type = "numericvector", len = NA_integer_, lower = 0, 
                 upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                 default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), maxit = structure(list(
                 id = "maxit", type = "integer", len = 1L, lower = 1L, upper = Inf, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 100000L, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), type.logistic = structure(list(
                 id = "type.logistic", type = "discrete", len = 1L, lower = NULL, upper = NULL, 
                 values = list(Newton = "Newton", modified.Newton = "modified.Newton"), 
                 cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), type.multinomial = structure(list(
                 id = "type.multinomial", type = "discrete", len = 1L, lower = NULL, upper = NULL, 
                 values = list(ungrouped = "ungrouped", grouped = "grouped"), cnames = NULL, 
                 allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, 
                 requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), fdev = structure(list(id = "fdev", type = "numeric", len = 1L, 
                 lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 1e-05, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), devmax = structure(list(id = "devmax", type = "numeric", len = 1L, lower = 0, 
                 upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 0.999, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), eps = structure(list(
                 id = "eps", type = "numeric", len = 1L, lower = 0, upper = 1, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 1e-06, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), big = structure(list(
                 id = "big", type = "numeric", len = 1L, lower = -Inf, upper = Inf, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 9.9e+35, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), mnlam = structure(list(
                 id = "mnlam", type = "integer", len = 1L, lower = 1, upper = Inf, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 5, trafo = NULL, 
                 requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), pmin = structure(list(id = "pmin", type = "numeric", len = 1L, 
                 lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 1e-09, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), exmx = structure(list(id = "exmx", type = "numeric", len = 1L, lower = -Inf, 
                 upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 250, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), prec = structure(list(
                 id = "prec", type = "numeric", len = 1L, lower = -Inf, upper = Inf, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 1e-10, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), mxit = structure(list(
                 id = "mxit", type = "integer", len = 1L, lower = 1L, upper = Inf, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 100L, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param"))), forbidden = NULL), class = c("LearnerParamSet", 
             "ParamSet")), par.vals = list(s = 0.01), predict.type = "response", name = "GLM with Lasso or Elasticnet Regularization", 
             short.name = "glmnet", note = "The family parameter is set to `binomial` for two-class problems and to `multinomial` otherwise.\n      Factors automatically get converted to dummy columns, ordered factors to integer.\n      Parameter `s` (value of the regularization parameter used for predictions) is set to `0.1` by default,\n      but needs to be tuned by the user.\n      glmnet uses a global control object for its parameters. mlr resets all control parameters to their defaults\n      before setting the specified parameters and after training.\n      If you are setting glmnet.control parameters through glmnet.control,\n      you need to save and re-set them after running the glmnet learner.", 
             callees = c("glmnet", "glmnet.control", "predict.glmnet"), help.list = list(
                 s = "Argument of: glmnet::predict.glmnet\n\nValue(s) of the penalty parameter lambda at which predictions are required. Default is the entire sequence used to create the model.", 
                 exact = "Argument of: glmnet::predict.glmnet\n\nThis argument is relevant only when predictions are made at values of s (lambda) different from those used in the fitting of the original model. If exact=FALSE (default), then the predict function uses linear interpolation to make predictions for values of s (lambda) that do not coincide with those used in the fitting algorithm. While this is often a good approximation, it can sometimes be a bit coarse. With exact=TRUE, these different values of s are merged (and sorted) with object$lambda, and the model is refit before predictions are made. In this case, it is required to supply the original data x= and y= as additional named  arguments to predict() or coef(). The workhorse predict.glmnet() needs to  update the model, and so needs the data used to create it. The same is true of weights, offset, penalty.factor, lower.limits, upper.limits if these were used in the original call. Failure to do so will result in an error.", 
                 fdev = "Argument of: glmnet::glmnet.control\n\nminimum fractional change in deviance for stopping path; factory default = 1.0e-5", 
                 devmax = "Argument of: glmnet::glmnet.control\n\nmaximum fraction of explained deviance for stopping path; factory default = 0.999", 
                 eps = "Argument of: glmnet::glmnet.control\n\nminimum value of lambda.min.ratio (see glmnet); factory default= 1.0e-6", 
                 big = "Argument of: glmnet::glmnet.control\n\nlarge floating point number; factory default = 9.9e35. Inf in definition of upper.limit is set to big", 
                 mnlam = "Argument of: glmnet::glmnet.control\n\nminimum number of path points (lambda values) allowed; factory default = 5", 
                 pmin = "Argument of: glmnet::glmnet.control\n\nminimum probability for any class. factory default = 1.0e-9. Note that this implies a pmax of 1-pmin.", 
                 exmx = "Argument of: glmnet::glmnet.control\n\nmaximum allowed exponent. factory default = 250.0", 
                 prec = "Argument of: glmnet::glmnet.control\n\nconvergence threshold for multi response bounds adjustment solution. factory default = 1.0e-10", 
                 mxit = "Argument of: glmnet::glmnet.control\n\nmaximum iterations for multiresponse bounds adjustment solution.  factory default = 100", 
                 alpha = "Argument of: glmnet::glmnet\n\nThe elasticnet mixing parameter, with 0≤α≤ 1. The penalty is defined as (1-α)/2||β||_2^2+α||β||_1. alpha=1 is the lasso penalty, and alpha=0 the ridge penalty.", 
                 nlambda = "Argument of: glmnet::glmnet\n\nThe number of lambda values - default is 100.", 
                 lambda.min.ratio = "Argument of: glmnet::glmnet\n\nSmallest value for lambda, as a fraction of lambda.max, the (data derived) entry value (i.e. the smallest value for which all coefficients are zero). The default depends on the sample size nobs relative to the number of variables nvars. If nobs > nvars, the default is 0.0001, close to zero.  If nobs < nvars, the default is 0.01. A very small value of lambda.min.ratio will lead to a saturated fit in the nobs < nvars case. This is undefined for \"binomial\" and \"multinomial\" models, and glmnet will exit gracefully when the percentage deviance explained is almost 1.", 
                 lambda = "Argument of: glmnet::glmnet\n\nA user supplied lambda sequence. Typical usage is to have the program compute its own lambda sequence based on nlambda and lambda.min.ratio. Supplying a value of lambda overrides this. WARNING: use with care. Avoid supplying a single value for lambda (for predictions after CV use predict() instead).  Supply instead a decreasing sequence of lambda values. glmnet relies on its warms starts for speed, and its often faster to fit a whole path than compute a single fit.", 
                 standardize = "Argument of: glmnet::glmnet\n\nLogical flag for x variable standardization, prior to fitting the model sequence. The coefficients are always returned on the original scale. Default is standardize=TRUE. If variables are in the same units already, you might not wish to standardize. See details below for y standardization with family=\"gaussian\".", 
                 intercept = "Argument of: glmnet::glmnet\n\nShould intercept(s) be fitted (default=TRUE) or set to zero (FALSE)", 
                 thresh = "Argument of: glmnet::glmnet\n\nConvergence threshold for coordinate descent. Each inner coordinate-descent loop continues until the maximum change in the objective after any coefficient update is less than thresh times the null deviance. Defaults value is 1E-7.", 
                 dfmax = "Argument of: glmnet::glmnet\n\nLimit the maximum number of variables in the model. Useful for very large nvars, if a partial path is desired.", 
                 pmax = "Argument of: glmnet::glmnet\n\nLimit the maximum number of variables ever to be nonzero", 
                 exclude = "Argument of: glmnet::glmnet\n\nIndices of variables to be excluded from the model. Default is none. Equivalent to an infinite penalty factor (next item).", 
                 penalty.factor = "Argument of: glmnet::glmnet\n\nSeparate penalty factors can be applied to each coefficient. This is a number that multiplies lambda to allow differential shrinkage. Can be 0 for some variables, which implies no shrinkage, and that variable is always included in the model. Default is 1 for all variables (and implicitly infinity for variables listed in exclude). Note: the penalty factors are internally rescaled to sum to nvars, and the lambda sequence will reflect this change.", 
                 lower.limits = "Argument of: glmnet::glmnet\n\nVector of lower limits for each coefficient; default -Inf. Each of these must be non-positive. Can be presented as a single value (which will then be replicated), else a vector of length nvars", 
                 upper.limits = "Argument of: glmnet::glmnet\n\nVector of upper limits for each coefficient; default Inf. See lower.limits", 
                 maxit = "Argument of: glmnet::glmnet\n\nMaximum number of passes over the data for all lambda values; default is 10^5.", 
                 type.logistic = "Argument of: glmnet::glmnet\n\nIf \"Newton\" then the exact hessian is used (default), while \"modified.Newton\" uses an upper-bound on the hessian, and can be faster.", 
                 type.multinomial = "Argument of: glmnet::glmnet\n\nIf \"grouped\" then a grouped lasso penalty is used on the multinomial coefficients for a variable. This ensures they are all in our out together. The default is \"ungrouped\""), 
             config = list(), fix.factors.prediction = FALSE), class = c("classif.glmnet", 
         "RLearnerClassif", "RLearner", "Learner")), model.subclass = c("BaggingModel", 
         "HomogeneousEnsembleModel")), class = c("BaggingWrapper", "HomogeneousEnsemble", 
     "BaseWrapper", "Learner")), .task = structure(list(type = "classif", env = <environment>, 
         weights = NULL, blocking = NULL, coordinates = NULL, task.desc = structure(list(
             id = "multiclass", type = "classif", target = "Species", size = 150L, n.feat = c(numerics = 4L, 
             factors = 0L, ordered = 0L, functionals = 0L), has.missings = FALSE, has.weights = FALSE, 
             has.blocking = FALSE, has.coordinates = FALSE, class.levels = c("setosa", 
             "versicolor", "virginica"), positive = NA_character_, negative = NA_character_, 
             class.distribution = structure(c(setosa = 50L, versicolor = 50L, virginica = 50L
             ), .Dim = 3L, .Dimnames = list(c("setosa", "versicolor", "virginica")), class = "table")), class = c("ClassifTaskDesc", 
         "SupervisedTaskDesc", "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", 
     "Task")), .subset = NULL)
  14: parallelMap(doBaggingTrainIteration, i = seq_len(bw.iters), more.args = args, level = "mlr.ensemble")
  15: options(parallelMap.nextmap = (getPMOptNextMap() + 1L))
  16: getPMOptNextMap()
  17: getPMOption("nextmap")
  18: getOption(sprintf("parallelMap.%s", opt), def)
  
  ── 5. Error: Joint model performance estimation, tuning, and model performance (
  argument "def" is missing, with no default
  1: benchmark(lrn3, pid.task, makeResampleDesc(method = "Holdout")) at testthat/test_base_BaseWrapper.R:44
  2: parallelMap(benchmarkParallel, task = grid$task, learner = grid$learner, more.args = list(learners = learners, 
         tasks = tasks, resamplings = resamplings, measures = measures, keep.pred = keep.pred, 
         models = models, show.info = show.info), level = plevel)
  3: mapply(fun2, ..., MoreArgs = more.args, SIMPLIFY = FALSE, USE.NAMES = FALSE)
  4: (function (task, learner, learners, tasks, resamplings, measures, keep.pred = TRUE, 
         models = TRUE, show.info) 
     {
         setSlaveOptions()
         if (show.info) 
             messagef("Task: %s, Learner: %s", task, learner)
         lrn = learners[[learner]]
         extract.this = getExtractor(lrn)
         r = resample(lrn, tasks[[task]], resamplings[[task]], measures = measures, models = models, 
             extract = extract.this, keep.pred = keep.pred, show.info = show.info)
         r$learner = lrn
         return(r)
     })(task = dots[[1L]][[1L]], learner = dots[[2L]][[1L]], learners = list(classif.ksvm.tuned.featsel = structure(list(
         id = "classif.ksvm.tuned.featsel", type = "classif", package = "kernlab", properties = NULL, 
         par.set = structure(list(pars = list(), forbidden = NULL), class = "ParamSet"), 
         par.vals = list(), predict.type = "prob", fix.factors.prediction = FALSE, next.learner = structure(list(
             id = "classif.ksvm.tuned", type = "classif", package = "kernlab", properties = NULL, 
             par.set = structure(list(pars = list(), forbidden = NULL), class = "ParamSet"), 
             par.vals = list(), predict.type = "prob", fix.factors.prediction = FALSE, 
             next.learner = structure(list(id = "classif.ksvm", type = "classif", package = "kernlab", 
                 properties = c("twoclass", "multiclass", "numerics", "factors", "prob", 
                 "class.weights"), par.set = structure(list(pars = list(scaled = structure(list(
                     id = "scaled", type = "logical", len = 1L, lower = NULL, upper = NULL, 
                     values = list(`TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = TRUE, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), type = structure(list(id = "type", type = "discrete", len = 1L, 
                     lower = NULL, upper = NULL, values = list(`C-svc` = "C-svc", `nu-svc` = "nu-svc", 
                       `C-bsvc` = "C-bsvc", `spoc-svc` = "spoc-svc", `kbb-svc` = "kbb-svc"), 
                     cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = "C-svc", 
                     trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), kernel = structure(list(
                     id = "kernel", type = "discrete", len = 1L, lower = NULL, upper = NULL, 
                     values = list(vanilladot = "vanilladot", polydot = "polydot", rbfdot = "rbfdot", 
                       tanhdot = "tanhdot", laplacedot = "laplacedot", besseldot = "besseldot", 
                       anovadot = "anovadot", splinedot = "splinedot"), cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = "rbfdot", trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), C = structure(list(id = "C", type = "numeric", len = 1L, lower = 0, 
                     upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = 1, trafo = NULL, requires = type %in% c("C-svc", "C-bsvc", 
                       "spoc-svc", "kbb-svc"), tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), nu = structure(list(
                     id = "nu", type = "numeric", len = 1L, lower = 0, upper = Inf, values = NULL, 
                     cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 0.2, 
                     trafo = NULL, requires = type == "nu-svc", tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), epsilon = structure(list(
                     id = "epsilon", type = "numeric", len = 1L, lower = -Inf, upper = Inf, 
                     values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = 0.1, trafo = NULL, requires = type %in% c("eps-svr", "nu-svr", 
                       "eps-bsvm"), tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), sigma = structure(list(id = "sigma", type = "numeric", len = 1L, 
                     lower = 0, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = FALSE, default = NULL, trafo = NULL, requires = kernel %in% 
                       c("rbfdot", "anovadot", "besseldot", "laplacedot"), tunable = TRUE, 
                     special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), degree = structure(list(id = "degree", type = "integer", len = 1L, 
                     lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 3L, trafo = NULL, requires = kernel %in% 
                       c("polydot", "anovadot", "besseldot"), tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), scale = structure(list(
                     id = "scale", type = "numeric", len = 1L, lower = 0, upper = Inf, 
                     values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = 1, trafo = NULL, requires = kernel %in% c("polydot", "tanhdot"), 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), offset = structure(list(id = "offset", type = "numeric", len = 1L, 
                     lower = -Inf, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 1, trafo = NULL, requires = kernel %in% 
                       c("polydot", "tanhdot"), tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), order = structure(list(
                     id = "order", type = "integer", len = 1L, lower = -Inf, upper = Inf, 
                     values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = 1L, trafo = NULL, requires = kernel == "besseldot", tunable = TRUE, 
                     special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), tol = structure(list(id = "tol", type = "numeric", len = 1L, 
                     lower = 0, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 0.001, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), shrinking = structure(list(id = "shrinking", type = "logical", 
                     len = 1L, lower = NULL, upper = NULL, values = list(`TRUE` = TRUE, 
                       `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = TRUE, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), class.weights = structure(list(
                     id = "class.weights", type = "numericvector", len = NA_integer_, 
                     lower = 0, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), fit = structure(list(id = "fit", type = "logical", len = 1L, 
                     lower = NULL, upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), 
                     cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = TRUE, 
                     trafo = NULL, requires = NULL, tunable = FALSE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), cache = structure(list(
                     id = "cache", type = "integer", len = 1L, lower = 1L, upper = Inf, 
                     values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = 40L, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param"))), forbidden = NULL), class = c("LearnerParamSet", 
                 "ParamSet")), par.vals = list(fit = FALSE), predict.type = "prob", name = "Support Vector Machines", 
                 short.name = "ksvm", note = "Kernel parameters have to be passed directly and not by using the `kpar` list in `ksvm`. Note that `fit` has been set to `FALSE` by default for speed.", 
                 callees = "ksvm", help.list = list(sigma = "Argument of: kernlab::ksvm\n\nfor the ANOVA kernel \"anovadot\".", 
                     degree = "Argument of: kernlab::ksvm\n\nfor the ANOVA kernel \"anovadot\".", 
                     scale = "Argument of: kernlab::ksvm\n\nfor the Hyperbolic tangent kernel function \"tanhdot\"", 
                     offset = "Argument of: kernlab::ksvm\n\nfor the Hyperbolic tangent kernel function \"tanhdot\"", 
                     order = "Argument of: kernlab::ksvm\n\nfor the Bessel kernel \"besseldot\".", 
                     scaled = "Argument of: kernlab::ksvm\n\nA logical vector indicating the variables to be scaled. If scaled is of length 1, the value is recycled as many times as needed and all non-binary variables are scaled. Per default, data are scaled internally (both x and y variables) to zero mean and unit variance. The center and scale values are returned and used for later predictions.", 
                     type = "Argument of: kernlab::ksvm\n\nksvm can be used for classification , for regression, or for novelty detection. Depending on whether y is a factor or not, the default setting for type is C-svc or eps-svr, respectively, but can be overwritten by setting an explicit value. Valid options are:\n\nC-svc   C classification\n\nnu-svc  nu classification\n\nC-bsvc  bound-constraint svm classification\n\nspoc-svc  Crammer, Singer native multi-class\n\nkbb-svc  Weston, Watkins native multi-class\n\none-svc  novelty detection\n\neps-svr  epsilon regression\n\nnu-svr   nu regression\n\neps-bsvr  bound-constraint svm regression", 
                     kernel = "Argument of: kernlab::ksvm\n\nthe kernel function used in training and predicting. This parameter can be set to any function, of class kernel, which computes the inner product in feature space between two vector arguments (see kernels). kernlab provides the most popular kernel functions which can be used by setting the kernel parameter to the following strings:\n\nrbfdot Radial Basis kernel \"Gaussian\"\n\npolydot Polynomial kernel\n\nvanilladot Linear kernel\n\ntanhdot Hyperbolic tangent kernel\n\nlaplacedot Laplacian kernel\n\nbesseldot Bessel kernel\n\nanovadot ANOVA RBF kernel\n\nsplinedot Spline kernel\n\nstringdot String kernel\n\nSetting the kernel parameter to \"matrix\" treats x as a kernel matrix calling the kernelMatrix interface. The kernel parameter can also be set to a user defined function of class kernel by passing the function name as an argument.", 
                     C = "Argument of: kernlab::ksvm\n\ncost of constraints violation (default: 1) this is the ‘C’-constant of the regularization term in the Lagrange formulation.", 
                     nu = "Argument of: kernlab::ksvm\n\nparameter needed for nu-svc, one-svc, and nu-svr. The nu parameter sets the upper bound on the training error and the lower bound on the fraction of data points to become Support Vectors (default: 0.2).", 
                     epsilon = "Argument of: kernlab::ksvm\n\nepsilon in the insensitive-loss function used for eps-svr, nu-svr and eps-bsvm (default: 0.1)", 
                     class.weights = "Argument of: kernlab::ksvm\n\na named vector of weights for the different classes, used for asymmetric class sizes. Not all factor levels have to be supplied (default weight: 1). All components have to be named.", 
                     cache = "Argument of: kernlab::ksvm\n\ncache memory in MB (default 40)", 
                     tol = "Argument of: kernlab::ksvm\n\ntolerance of termination criterion (default: 0.001)", 
                     shrinking = "Argument of: kernlab::ksvm\n\noption whether to use the shrinking-heuristics (default: TRUE)", 
                     fit = "Argument of: kernlab::ksvm\n\nindicates whether the fitted values should be computed and included in the model or not (default: TRUE)"), 
                 class.weights.param = "class.weights", config = list(), fix.factors.prediction = FALSE), class = c("classif.ksvm", 
             "RLearnerClassif", "RLearner", "Learner")), model.subclass = "TuneModel", 
             resampling = structure(list(split = 0.666666666666667, id = "holdout", iters = 1L, 
                 predict = "test", stratify = FALSE), class = c("HoldoutDesc", "ResampleDesc"
             )), measures = list(structure(list(id = "auc", minimize = FALSE, properties = c("classif", 
             "req.pred", "req.truth", "req.prob"), fun = function (task, model, pred, 
                 feats, extra.args) 
             {
                 if (anyMissing(pred$data$response) || length(unique(pred$data$truth)) == 
                     1L) 
                     return(NA_real_)
                 measureAUC(getPredictionProbabilities(pred), pred$data$truth, pred$task.desc$negative, 
                     pred$task.desc$positive)
             }, extra.args = list(), best = 1, worst = 0, name = "Area under the curve", 
                 note = "Integral over the graph that results from computing fpr and tpr for many different thresholds.", 
                 aggr = structure(list(id = "test.mean", name = "Test mean", fun = function (task, 
                     perf.test, perf.train, measure, group, pred) 
                 mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure"), 
                 structure(list(id = "acc", minimize = FALSE, properties = c("classif", 
                 "classif.multi", "req.pred", "req.truth"), fun = function (task, model, 
                     pred, feats, extra.args) 
                 {
                     measureACC(pred$data$truth, pred$data$response)
                 }, extra.args = list(), best = 1, worst = 0, name = "Accuracy", note = "Defined as: mean(response == truth)", 
                     aggr = structure(list(id = "test.mean", name = "Test mean", fun = function (task, 
                       perf.test, perf.train, measure, group, pred) 
                     mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure")), 
             opt.pars = structure(list(pars = list(C = structure(list(id = "C", type = "discrete", 
                 len = 1L, lower = NULL, upper = NULL, values = list(`0.25` = 0.25, `0.5` = 0.5, 
                     `1` = 1, `2` = 2, `4` = 4), cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                 default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list()), class = "Param"), 
                 sigma = structure(list(id = "sigma", type = "discrete", len = 1L, lower = NULL, 
                     upper = NULL, values = list(`0.25` = 0.25, `0.5` = 0.5, `1` = 1, 
                       `2` = 2, `4` = 4), cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                     default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list()), class = "Param")), 
                 forbidden = NULL), class = "ParamSet"), bit.names = character(0), bits.to.features = function () 
             {
             }, control = structure(list(same.resampling.instance = TRUE, impute.val = NULL, 
                 tune.threshold = FALSE, tune.threshold.args = list(), log.fun = function (learner, 
                     task, resampling, measures, par.set, control, opt.path, dob, x, y, 
                     remove.nas, stage, prev.stage) 
                 {
                     x.string = paramValueToString(par.set, x, show.missing.values = !remove.nas)
                     if (inherits(learner, "ModelMultiplexer")) 
                       x.string = stri_replace_all(x.string, "", regex = stri_paste(x$selected.learner, 
                         "\\."))
                     logFunDefault(learner, task, resampling, measures, par.set, control, 
                       opt.path, dob, x.string, y, remove.nas, stage, prev.stage, prefixes = c("Tune-x", 
                         "Tune-y"))
                 }, final.dw.perc = NULL, extra.args = list(maxit = 3L), budget = 3L), class = c("TuneControlRandom", 
             "TuneControl", "OptControl")), show.info = FALSE), class = c("TuneWrapper", 
         "OptWrapper", "BaseWrapper", "Learner")), model.subclass = "FeatSelModel", resampling = structure(list(
             split = 0.666666666666667, id = "holdout", iters = 1L, predict = "test", 
             stratify = FALSE), class = c("HoldoutDesc", "ResampleDesc")), measures = list(
             structure(list(id = "auc", minimize = FALSE, properties = c("classif", "req.pred", 
             "req.truth", "req.prob"), fun = function (task, model, pred, feats, extra.args) 
             {
                 if (anyMissing(pred$data$response) || length(unique(pred$data$truth)) == 
                     1L) 
                     return(NA_real_)
                 measureAUC(getPredictionProbabilities(pred), pred$data$truth, pred$task.desc$negative, 
                     pred$task.desc$positive)
             }, extra.args = list(), best = 1, worst = 0, name = "Area under the curve", 
                 note = "Integral over the graph that results from computing fpr and tpr for many different thresholds.", 
                 aggr = structure(list(id = "test.mean", name = "Test mean", fun = function (task, 
                     perf.test, perf.train, measure, group, pred) 
                 mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure"), 
             structure(list(id = "acc", minimize = FALSE, properties = c("classif", "classif.multi", 
             "req.pred", "req.truth"), fun = function (task, model, pred, feats, extra.args) 
             {
                 measureACC(pred$data$truth, pred$data$response)
             }, extra.args = list(), best = 1, worst = 0, name = "Accuracy", note = "Defined as: mean(response == truth)", 
                 aggr = structure(list(id = "test.mean", name = "Test mean", fun = function (task, 
                     perf.test, perf.train, measure, group, pred) 
                 mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure")), 
         opt.pars = structure(list(pars = list(), forbidden = NULL), class = "ParamSet"), 
         bit.names = character(0), control = structure(list(same.resampling.instance = TRUE, 
             impute.val = NULL, tune.threshold = FALSE, tune.threshold.args = list(), 
             log.fun = function (learner, task, resampling, measures, par.set, control, 
                 opt.path, dob, x, y, remove.nas, stage, prev.stage) 
             {
                 x.string = sprintf("%s (%i bits)", clipString(collapse(x, ""), 80L), 
                     sum(x))
                 logFunDefault(learner, task, resampling, measures, par.set, control, 
                     opt.path, dob, x.string, y, remove.nas, stage, prev.stage, prefixes = c("FeatSel-x", 
                       "FeatSel-y"))
             }, final.dw.perc = NULL, extra.args = list(prob = 0.5), maxit = 3L, max.features = NA_integer_), class = c("FeatSelControlRandom", 
         "FeatSelControl", "OptControl")), show.info = FALSE), class = c("FeatSelWrapper", 
     "OptWrapper", "BaseWrapper", "Learner"))), tasks = list(`PimaIndiansDiabetes-example` = structure(list(
         type = "classif", env = <environment>, weights = NULL, blocking = NULL, coordinates = NULL, 
         task.desc = structure(list(id = "PimaIndiansDiabetes-example", type = "classif", 
             target = "diabetes", size = 768L, n.feat = c(numerics = 8L, factors = 0L, 
             ordered = 0L, functionals = 0L), has.missings = FALSE, has.weights = FALSE, 
             has.blocking = FALSE, has.coordinates = FALSE, class.levels = c("neg", "pos"
             ), positive = "pos", negative = "neg", class.distribution = structure(c(neg = 500L, 
             pos = 268L), .Dim = 2L, .Dimnames = list(c("neg", "pos")), class = "table")), class = c("ClassifTaskDesc", 
         "SupervisedTaskDesc", "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", 
     "Task"))), resamplings = list(`PimaIndiansDiabetes-example` = structure(list(desc = structure(list(
         split = 0.666666666666667, id = "holdout", iters = 1L, predict = "test", stratify = FALSE), class = c("HoldoutDesc", 
     "ResampleDesc")), size = 768L, train.inds = list(c(221L, 605L, 314L, 676L, 719L, 
     35L, 403L, 680L, 420L, 347L, 726L, 344L, 513L, 433L, 78L, 678L, 186L, 32L, 246L, 
     715L, 666L, 518L, 478L, 741L, 488L, 527L, 404L, 441L, 214L, 109L, 711L, 665L, 509L, 
     585L, 19L, 351L, 556L, 159L, 233L, 169L, 104L, 302L, 301L, 268L, 111L, 101L, 729L, 
     336L, 192L, 617L, 33L, 318L, 573L, 88L, 401L, 148L, 91L, 536L, 636L, 266L, 471L, 
     68L, 272L, 194L, 574L, 316L, 569L, 570L, 557L, 308L, 743L, 439L, 495L, 1L, 330L, 
     153L, 263L, 424L, 243L, 77L, 168L, 459L, 287L, 540L, 71L, 298L, 672L, 609L, 603L, 
     119L, 89L, 443L, 730L, 444L, 216L, 127L, 526L, 63L, 313L, 343L, 714L, 222L, 326L, 
     635L, 321L, 591L, 606L, 762L, 706L, 97L, 616L, 198L, 40L, 621L, 472L, 93L, 359L, 
     622L, 381L, 692L, 760L, 207L, 199L, 142L, 238L, 633L, 99L, 59L, 712L, 745L, 396L, 
     568L, 429L, 469L, 331L, 418L, 520L, 497L, 618L, 277L, 196L, 257L, 7L, 115L, 682L, 
     145L, 149L, 48L, 693L, 454L, 524L, 307L, 239L, 152L, 69L, 240L, 733L, 133L, 660L, 
     611L, 306L, 215L, 394L, 227L, 607L, 322L, 446L, 681L, 248L, 160L, 377L, 110L, 515L, 
     445L, 397L, 367L, 768L, 766L, 517L, 669L, 494L, 184L, 416L, 156L, 348L, 281L, 155L, 
     329L, 530L, 523L, 731L, 752L, 637L, 357L, 539L, 725L, 765L, 598L, 87L, 748L, 136L, 
     546L, 341L, 291L, 228L, 496L, 205L, 162L, 96L, 659L, 269L, 141L, 121L, 375L, 27L, 
     388L, 195L, 226L, 452L, 505L, 582L, 624L, 398L, 555L, 29L, 604L, 259L, 304L, 378L, 
     588L, 333L, 231L, 565L, 751L, 140L, 212L, 106L, 442L, 82L, 426L, 289L, 350L, 640L, 
     538L, 164L, 379L, 209L, 506L, 504L, 685L, 134L, 625L, 764L, 138L, 273L, 661L, 701L, 
     647L, 241L, 531L, 708L, 448L, 342L, 480L, 261L, 290L, 722L, 175L, 11L, 251L, 434L, 
     4L, 36L, 580L, 650L, 363L, 479L, 230L, 37L, 717L, 371L, 67L, 193L, 597L, 544L, 720L, 
     535L, 739L, 554L, 761L, 143L, 49L, 763L, 419L, 358L, 387L, 464L, 477L, 47L, 545L, 
     368L, 5L, 364L, 340L, 293L, 223L, 73L, 631L, 522L, 551L, 179L, 213L, 702L, 26L, 561L, 
     466L, 519L, 108L, 599L, 385L, 383L, 601L, 66L, 663L, 470L, 15L, 736L, 16L, 651L, 
     402L, 271L, 126L, 492L, 493L, 137L, 740L, 727L, 629L, 431L, 648L, 178L, 51L, 225L, 
     560L, 511L, 157L, 415L, 630L, 559L, 262L, 58L, 742L, 543L, 707L, 258L, 408L, 276L, 
     173L, 447L, 521L, 641L, 79L, 365L, 125L, 147L, 703L, 754L, 8L, 163L, 486L, 688L, 
     498L, 757L, 180L, 211L, 579L, 541L, 696L, 732L, 550L, 767L, 295L, 144L, 297L, 691L, 
     612L, 684L, 451L, 490L, 80L, 370L, 112L, 514L, 473L, 656L, 90L, 723L, 38L, 44L, 366L, 
     435L, 427L, 332L, 662L, 386L, 421L, 256L, 30L, 123L, 245L, 114L, 449L, 689L, 177L, 
     98L, 422L, 335L, 113L, 567L, 10L, 191L, 224L, 384L, 571L, 516L, 586L, 728L, 410L, 
     55L, 654L, 323L, 190L, 724L, 334L, 407L, 562L, 563L, 619L, 718L, 54L, 653L, 584L, 
     658L, 581L, 583L, 229L, 652L, 655L, 590L, 589L, 167L, 721L, 356L, 734L, 75L, 279L, 
     254L, 572L, 508L, 39L, 758L, 747L, 645L, 593L, 428L, 83L, 70L, 460L, 85L, 690L, 28L, 
     436L, 673L, 463L, 552L, 131L, 587L, 695L, 64L, 204L, 62L, 234L, 753L, 197L, 265L, 
     694L, 380L, 327L, 390L, 311L, 438L, 20L, 296L, 399L, 24L, 610L, 614L, 14L, 577L, 
     533L, 95L, 354L, 756L, 22L, 710L, 675L, 700L, 132L, 750L, 286L, 120L, 284L)), test.inds = list(
         c(564L, 237L, 393L, 744L, 705L, 260L, 615L, 709L, 60L, 627L, 282L, 150L, 646L, 
         482L, 369L, 12L, 553L, 468L, 283L, 643L, 300L, 671L, 500L, 13L, 677L, 42L, 667L, 
         61L, 467L, 154L, 118L, 252L, 65L, 389L, 501L, 649L, 746L, 698L, 549L, 738L, 484L, 
         475L, 299L, 462L, 218L, 525L, 440L, 575L, 107L, 53L, 172L, 255L, 122L, 759L, 
         270L, 328L, 102L, 151L, 374L, 687L, 613L, 57L, 250L, 491L, 360L, 414L, 3L, 686L, 
         235L, 338L, 339L, 481L, 355L, 425L, 294L, 465L, 628L, 642L, 638L, 737L, 319L, 
         406L, 130L, 409L, 450L, 458L, 542L, 176L, 23L, 461L, 232L, 315L, 171L, 413L, 
         362L, 547L, 317L, 278L, 453L, 503L, 25L, 2L, 208L, 292L, 128L, 43L, 324L, 608L, 
         103L, 312L, 534L, 735L, 596L, 18L, 620L, 210L, 594L, 512L, 626L, 6L, 280L, 600L, 
         373L, 166L, 664L, 755L, 146L, 305L, 352L, 206L, 337L, 713L, 382L, 502L, 576L, 
         139L, 116L, 372L, 249L, 124L, 417L, 566L, 72L, 181L, 9L, 346L, 529L, 430L, 670L, 
         345L, 483L, 185L, 52L, 668L, 412L, 45L, 548L, 253L, 275L, 187L, 41L, 56L, 165L, 
         183L, 201L, 31L, 285L, 81L, 92L, 50L, 639L, 392L, 264L, 361L, 507L, 267L, 135L, 
         325L, 200L, 202L, 632L, 476L, 161L, 405L, 17L, 592L, 129L, 528L, 349L, 455L, 
         489L, 309L, 457L, 395L, 437L, 244L, 105L, 320L, 683L, 558L, 217L, 749L, 499L, 
         400L, 247L, 274L, 188L, 86L, 634L, 174L, 84L, 76L, 117L, 644L, 46L, 699L, 578L, 
         602L, 674L, 236L, 288L, 21L, 411L, 474L, 170L, 74L, 485L, 303L, 242L, 697L, 657L, 
         94L, 716L, 310L, 182L, 423L, 203L, 100L, 532L, 391L, 432L, 704L, 353L, 220L, 
         189L, 679L, 510L, 456L, 487L, 158L, 537L, 376L, 219L, 623L, 34L, 595L)), group = structure(integer(0), .Label = character(0), class = "factor")), class = "ResampleInstance")), 
         measures = list(structure(list(id = "mmce", minimize = TRUE, properties = c("classif", 
         "classif.multi", "req.pred", "req.truth"), fun = function (task, model, pred, 
             feats, extra.args) 
         {
             measureMMCE(pred$data$truth, pred$data$response)
         }, extra.args = list(), best = 0, worst = 1, name = "Mean misclassification error", 
             note = "Defined as: mean(response != truth)", aggr = structure(list(id = "test.mean", 
                 name = "Test mean", fun = function (task, perf.test, perf.train, measure, 
                     group, pred) 
                 mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure")), 
         keep.pred = TRUE, models = TRUE, show.info = FALSE)
  5: resample(lrn, tasks[[task]], resamplings[[task]], measures = measures, models = models, 
         extract = extract.this, keep.pred = keep.pred, show.info = show.info)
  6: parallelMap(doResampleIteration, seq_len(rin$desc$iters), level = "mlr.resample", 
         more.args = more.args)
  7: mapply(fun2, ..., MoreArgs = more.args, SIMPLIFY = FALSE, USE.NAMES = FALSE)
  8: (function (learner, task, rin, i, measures, weights, model, extract, show.info) 
     {
         setSlaveOptions()
         train.i = rin$train.inds[[i]]
         test.i = rin$test.inds[[i]]
         calculateResampleIterationResult(learner = learner, task = task, i = i, train.i = train.i, 
             test.i = test.i, measures = measures, weights = weights, rdesc = rin$desc, 
             model = model, extract = extract, show.info = show.info)
     })(dots[[1L]][[1L]], learner = structure(list(id = "classif.ksvm.tuned.featsel", 
         type = "classif", package = "kernlab", properties = NULL, par.set = structure(list(
             pars = list(), forbidden = NULL), class = "ParamSet"), par.vals = list(), 
         predict.type = "prob", fix.factors.prediction = FALSE, next.learner = structure(list(
             id = "classif.ksvm.tuned", type = "classif", package = "kernlab", properties = NULL, 
             par.set = structure(list(pars = list(), forbidden = NULL), class = "ParamSet"), 
             par.vals = list(), predict.type = "prob", fix.factors.prediction = FALSE, 
             next.learner = structure(list(id = "classif.ksvm", type = "classif", package = "kernlab", 
                 properties = c("twoclass", "multiclass", "numerics", "factors", "prob", 
                 "class.weights"), par.set = structure(list(pars = list(scaled = structure(list(
                     id = "scaled", type = "logical", len = 1L, lower = NULL, upper = NULL, 
                     values = list(`TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = TRUE, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), type = structure(list(id = "type", type = "discrete", len = 1L, 
                     lower = NULL, upper = NULL, values = list(`C-svc` = "C-svc", `nu-svc` = "nu-svc", 
                       `C-bsvc` = "C-bsvc", `spoc-svc` = "spoc-svc", `kbb-svc` = "kbb-svc"), 
                     cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = "C-svc", 
                     trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), kernel = structure(list(
                     id = "kernel", type = "discrete", len = 1L, lower = NULL, upper = NULL, 
                     values = list(vanilladot = "vanilladot", polydot = "polydot", rbfdot = "rbfdot", 
                       tanhdot = "tanhdot", laplacedot = "laplacedot", besseldot = "besseldot", 
                       anovadot = "anovadot", splinedot = "splinedot"), cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = "rbfdot", trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), C = structure(list(id = "C", type = "numeric", len = 1L, lower = 0, 
                     upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = 1, trafo = NULL, requires = type %in% c("C-svc", "C-bsvc", 
                       "spoc-svc", "kbb-svc"), tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), nu = structure(list(
                     id = "nu", type = "numeric", len = 1L, lower = 0, upper = Inf, values = NULL, 
                     cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 0.2, 
                     trafo = NULL, requires = type == "nu-svc", tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), epsilon = structure(list(
                     id = "epsilon", type = "numeric", len = 1L, lower = -Inf, upper = Inf, 
                     values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = 0.1, trafo = NULL, requires = type %in% c("eps-svr", "nu-svr", 
                       "eps-bsvm"), tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), sigma = structure(list(id = "sigma", type = "numeric", len = 1L, 
                     lower = 0, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = FALSE, default = NULL, trafo = NULL, requires = kernel %in% 
                       c("rbfdot", "anovadot", "besseldot", "laplacedot"), tunable = TRUE, 
                     special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), degree = structure(list(id = "degree", type = "integer", len = 1L, 
                     lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 3L, trafo = NULL, requires = kernel %in% 
                       c("polydot", "anovadot", "besseldot"), tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), scale = structure(list(
                     id = "scale", type = "numeric", len = 1L, lower = 0, upper = Inf, 
                     values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = 1, trafo = NULL, requires = kernel %in% c("polydot", "tanhdot"), 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), offset = structure(list(id = "offset", type = "numeric", len = 1L, 
                     lower = -Inf, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 1, trafo = NULL, requires = kernel %in% 
                       c("polydot", "tanhdot"), tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), order = structure(list(
                     id = "order", type = "integer", len = 1L, lower = -Inf, upper = Inf, 
                     values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = 1L, trafo = NULL, requires = kernel == "besseldot", tunable = TRUE, 
                     special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), tol = structure(list(id = "tol", type = "numeric", len = 1L, 
                     lower = 0, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 0.001, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), shrinking = structure(list(id = "shrinking", type = "logical", 
                     len = 1L, lower = NULL, upper = NULL, values = list(`TRUE` = TRUE, 
                       `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = TRUE, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), class.weights = structure(list(
                     id = "class.weights", type = "numericvector", len = NA_integer_, 
                     lower = 0, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), fit = structure(list(id = "fit", type = "logical", len = 1L, 
                     lower = NULL, upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), 
                     cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = TRUE, 
                     trafo = NULL, requires = NULL, tunable = FALSE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), cache = structure(list(
                     id = "cache", type = "integer", len = 1L, lower = 1L, upper = Inf, 
                     values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = 40L, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param"))), forbidden = NULL), class = c("LearnerParamSet", 
                 "ParamSet")), par.vals = list(fit = FALSE), predict.type = "prob", name = "Support Vector Machines", 
                 short.name = "ksvm", note = "Kernel parameters have to be passed directly and not by using the `kpar` list in `ksvm`. Note that `fit` has been set to `FALSE` by default for speed.", 
                 callees = "ksvm", help.list = list(sigma = "Argument of: kernlab::ksvm\n\nfor the ANOVA kernel \"anovadot\".", 
                     degree = "Argument of: kernlab::ksvm\n\nfor the ANOVA kernel \"anovadot\".", 
                     scale = "Argument of: kernlab::ksvm\n\nfor the Hyperbolic tangent kernel function \"tanhdot\"", 
                     offset = "Argument of: kernlab::ksvm\n\nfor the Hyperbolic tangent kernel function \"tanhdot\"", 
                     order = "Argument of: kernlab::ksvm\n\nfor the Bessel kernel \"besseldot\".", 
                     scaled = "Argument of: kernlab::ksvm\n\nA logical vector indicating the variables to be scaled. If scaled is of length 1, the value is recycled as many times as needed and all non-binary variables are scaled. Per default, data are scaled internally (both x and y variables) to zero mean and unit variance. The center and scale values are returned and used for later predictions.", 
                     type = "Argument of: kernlab::ksvm\n\nksvm can be used for classification , for regression, or for novelty detection. Depending on whether y is a factor or not, the default setting for type is C-svc or eps-svr, respectively, but can be overwritten by setting an explicit value. Valid options are:\n\nC-svc   C classification\n\nnu-svc  nu classification\n\nC-bsvc  bound-constraint svm classification\n\nspoc-svc  Crammer, Singer native multi-class\n\nkbb-svc  Weston, Watkins native multi-class\n\none-svc  novelty detection\n\neps-svr  epsilon regression\n\nnu-svr   nu regression\n\neps-bsvr  bound-constraint svm regression", 
                     kernel = "Argument of: kernlab::ksvm\n\nthe kernel function used in training and predicting. This parameter can be set to any function, of class kernel, which computes the inner product in feature space between two vector arguments (see kernels). kernlab provides the most popular kernel functions which can be used by setting the kernel parameter to the following strings:\n\nrbfdot Radial Basis kernel \"Gaussian\"\n\npolydot Polynomial kernel\n\nvanilladot Linear kernel\n\ntanhdot Hyperbolic tangent kernel\n\nlaplacedot Laplacian kernel\n\nbesseldot Bessel kernel\n\nanovadot ANOVA RBF kernel\n\nsplinedot Spline kernel\n\nstringdot String kernel\n\nSetting the kernel parameter to \"matrix\" treats x as a kernel matrix calling the kernelMatrix interface. The kernel parameter can also be set to a user defined function of class kernel by passing the function name as an argument.", 
                     C = "Argument of: kernlab::ksvm\n\ncost of constraints violation (default: 1) this is the ‘C’-constant of the regularization term in the Lagrange formulation.", 
                     nu = "Argument of: kernlab::ksvm\n\nparameter needed for nu-svc, one-svc, and nu-svr. The nu parameter sets the upper bound on the training error and the lower bound on the fraction of data points to become Support Vectors (default: 0.2).", 
                     epsilon = "Argument of: kernlab::ksvm\n\nepsilon in the insensitive-loss function used for eps-svr, nu-svr and eps-bsvm (default: 0.1)", 
                     class.weights = "Argument of: kernlab::ksvm\n\na named vector of weights for the different classes, used for asymmetric class sizes. Not all factor levels have to be supplied (default weight: 1). All components have to be named.", 
                     cache = "Argument of: kernlab::ksvm\n\ncache memory in MB (default 40)", 
                     tol = "Argument of: kernlab::ksvm\n\ntolerance of termination criterion (default: 0.001)", 
                     shrinking = "Argument of: kernlab::ksvm\n\noption whether to use the shrinking-heuristics (default: TRUE)", 
                     fit = "Argument of: kernlab::ksvm\n\nindicates whether the fitted values should be computed and included in the model or not (default: TRUE)"), 
                 class.weights.param = "class.weights", config = list(), fix.factors.prediction = FALSE), class = c("classif.ksvm", 
             "RLearnerClassif", "RLearner", "Learner")), model.subclass = "TuneModel", 
             resampling = structure(list(split = 0.666666666666667, id = "holdout", iters = 1L, 
                 predict = "test", stratify = FALSE), class = c("HoldoutDesc", "ResampleDesc"
             )), measures = list(structure(list(id = "auc", minimize = FALSE, properties = c("classif", 
             "req.pred", "req.truth", "req.prob"), fun = function (task, model, pred, 
                 feats, extra.args) 
             {
                 if (anyMissing(pred$data$response) || length(unique(pred$data$truth)) == 
                     1L) 
                     return(NA_real_)
                 measureAUC(getPredictionProbabilities(pred), pred$data$truth, pred$task.desc$negative, 
                     pred$task.desc$positive)
             }, extra.args = list(), best = 1, worst = 0, name = "Area under the curve", 
                 note = "Integral over the graph that results from computing fpr and tpr for many different thresholds.", 
                 aggr = structure(list(id = "test.mean", name = "Test mean", fun = function (task, 
                     perf.test, perf.train, measure, group, pred) 
                 mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure"), 
                 structure(list(id = "acc", minimize = FALSE, properties = c("classif", 
                 "classif.multi", "req.pred", "req.truth"), fun = function (task, model, 
                     pred, feats, extra.args) 
                 {
                     measureACC(pred$data$truth, pred$data$response)
                 }, extra.args = list(), best = 1, worst = 0, name = "Accuracy", note = "Defined as: mean(response == truth)", 
                     aggr = structure(list(id = "test.mean", name = "Test mean", fun = function (task, 
                       perf.test, perf.train, measure, group, pred) 
                     mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure")), 
             opt.pars = structure(list(pars = list(C = structure(list(id = "C", type = "discrete", 
                 len = 1L, lower = NULL, upper = NULL, values = list(`0.25` = 0.25, `0.5` = 0.5, 
                     `1` = 1, `2` = 2, `4` = 4), cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                 default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list()), class = "Param"), 
                 sigma = structure(list(id = "sigma", type = "discrete", len = 1L, lower = NULL, 
                     upper = NULL, values = list(`0.25` = 0.25, `0.5` = 0.5, `1` = 1, 
                       `2` = 2, `4` = 4), cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                     default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list()), class = "Param")), 
                 forbidden = NULL), class = "ParamSet"), bit.names = character(0), bits.to.features = function () 
             {
             }, control = structure(list(same.resampling.instance = TRUE, impute.val = NULL, 
                 tune.threshold = FALSE, tune.threshold.args = list(), log.fun = function (learner, 
                     task, resampling, measures, par.set, control, opt.path, dob, x, y, 
                     remove.nas, stage, prev.stage) 
                 {
                     x.string = paramValueToString(par.set, x, show.missing.values = !remove.nas)
                     if (inherits(learner, "ModelMultiplexer")) 
                       x.string = stri_replace_all(x.string, "", regex = stri_paste(x$selected.learner, 
                         "\\."))
                     logFunDefault(learner, task, resampling, measures, par.set, control, 
                       opt.path, dob, x.string, y, remove.nas, stage, prev.stage, prefixes = c("Tune-x", 
                         "Tune-y"))
                 }, final.dw.perc = NULL, extra.args = list(maxit = 3L), budget = 3L), class = c("TuneControlRandom", 
             "TuneControl", "OptControl")), show.info = FALSE), class = c("TuneWrapper", 
         "OptWrapper", "BaseWrapper", "Learner")), model.subclass = "FeatSelModel", resampling = structure(list(
             split = 0.666666666666667, id = "holdout", iters = 1L, predict = "test", 
             stratify = FALSE), class = c("HoldoutDesc", "ResampleDesc")), measures = list(
             structure(list(id = "auc", minimize = FALSE, properties = c("classif", "req.pred", 
             "req.truth", "req.prob"), fun = function (task, model, pred, feats, extra.args) 
             {
                 if (anyMissing(pred$data$response) || length(unique(pred$data$truth)) == 
                     1L) 
                     return(NA_real_)
                 measureAUC(getPredictionProbabilities(pred), pred$data$truth, pred$task.desc$negative, 
                     pred$task.desc$positive)
             }, extra.args = list(), best = 1, worst = 0, name = "Area under the curve", 
                 note = "Integral over the graph that results from computing fpr and tpr for many different thresholds.", 
                 aggr = structure(list(id = "test.mean", name = "Test mean", fun = function (task, 
                     perf.test, perf.train, measure, group, pred) 
                 mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure"), 
             structure(list(id = "acc", minimize = FALSE, properties = c("classif", "classif.multi", 
             "req.pred", "req.truth"), fun = function (task, model, pred, feats, extra.args) 
             {
                 measureACC(pred$data$truth, pred$data$response)
             }, extra.args = list(), best = 1, worst = 0, name = "Accuracy", note = "Defined as: mean(response == truth)", 
                 aggr = structure(list(id = "test.mean", name = "Test mean", fun = function (task, 
                     perf.test, perf.train, measure, group, pred) 
                 mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure")), 
         opt.pars = structure(list(pars = list(), forbidden = NULL), class = "ParamSet"), 
         bit.names = character(0), control = structure(list(same.resampling.instance = TRUE, 
             impute.val = NULL, tune.threshold = FALSE, tune.threshold.args = list(), 
             log.fun = function (learner, task, resampling, measures, par.set, control, 
                 opt.path, dob, x, y, remove.nas, stage, prev.stage) 
             {
                 x.string = sprintf("%s (%i bits)", clipString(collapse(x, ""), 80L), 
                     sum(x))
                 logFunDefault(learner, task, resampling, measures, par.set, control, 
                     opt.path, dob, x.string, y, remove.nas, stage, prev.stage, prefixes = c("FeatSel-x", 
                       "FeatSel-y"))
             }, final.dw.perc = NULL, extra.args = list(prob = 0.5), maxit = 3L, max.features = NA_integer_), class = c("FeatSelControlRandom", 
         "FeatSelControl", "OptControl")), show.info = FALSE), class = c("FeatSelWrapper", 
     "OptWrapper", "BaseWrapper", "Learner")), task = structure(list(type = "classif", 
         env = <environment>, weights = NULL, blocking = NULL, coordinates = NULL, task.desc = structure(list(
             id = "PimaIndiansDiabetes-example", type = "classif", target = "diabetes", 
             size = 768L, n.feat = c(numerics = 8L, factors = 0L, ordered = 0L, functionals = 0L
             ), has.missings = FALSE, has.weights = FALSE, has.blocking = FALSE, has.coordinates = FALSE, 
             class.levels = c("neg", "pos"), positive = "pos", negative = "neg", class.distribution = structure(c(neg = 500L, 
             pos = 268L), .Dim = 2L, .Dimnames = list(c("neg", "pos")), class = "table")), class = c("ClassifTaskDesc", 
         "SupervisedTaskDesc", "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", 
     "Task")), rin = structure(list(desc = structure(list(split = 0.666666666666667, id = "holdout", 
         iters = 1L, predict = "test", stratify = FALSE), class = c("HoldoutDesc", "ResampleDesc"
     )), size = 768L, train.inds = list(c(221L, 605L, 314L, 676L, 719L, 35L, 403L, 680L, 
     420L, 347L, 726L, 344L, 513L, 433L, 78L, 678L, 186L, 32L, 246L, 715L, 666L, 518L, 
     478L, 741L, 488L, 527L, 404L, 441L, 214L, 109L, 711L, 665L, 509L, 585L, 19L, 351L, 
     556L, 159L, 233L, 169L, 104L, 302L, 301L, 268L, 111L, 101L, 729L, 336L, 192L, 617L, 
     33L, 318L, 573L, 88L, 401L, 148L, 91L, 536L, 636L, 266L, 471L, 68L, 272L, 194L, 574L, 
     316L, 569L, 570L, 557L, 308L, 743L, 439L, 495L, 1L, 330L, 153L, 263L, 424L, 243L, 
     77L, 168L, 459L, 287L, 540L, 71L, 298L, 672L, 609L, 603L, 119L, 89L, 443L, 730L, 
     444L, 216L, 127L, 526L, 63L, 313L, 343L, 714L, 222L, 326L, 635L, 321L, 591L, 606L, 
     762L, 706L, 97L, 616L, 198L, 40L, 621L, 472L, 93L, 359L, 622L, 381L, 692L, 760L, 
     207L, 199L, 142L, 238L, 633L, 99L, 59L, 712L, 745L, 396L, 568L, 429L, 469L, 331L, 
     418L, 520L, 497L, 618L, 277L, 196L, 257L, 7L, 115L, 682L, 145L, 149L, 48L, 693L, 
     454L, 524L, 307L, 239L, 152L, 69L, 240L, 733L, 133L, 660L, 611L, 306L, 215L, 394L, 
     227L, 607L, 322L, 446L, 681L, 248L, 160L, 377L, 110L, 515L, 445L, 397L, 367L, 768L, 
     766L, 517L, 669L, 494L, 184L, 416L, 156L, 348L, 281L, 155L, 329L, 530L, 523L, 731L, 
     752L, 637L, 357L, 539L, 725L, 765L, 598L, 87L, 748L, 136L, 546L, 341L, 291L, 228L, 
     496L, 205L, 162L, 96L, 659L, 269L, 141L, 121L, 375L, 27L, 388L, 195L, 226L, 452L, 
     505L, 582L, 624L, 398L, 555L, 29L, 604L, 259L, 304L, 378L, 588L, 333L, 231L, 565L, 
     751L, 140L, 212L, 106L, 442L, 82L, 426L, 289L, 350L, 640L, 538L, 164L, 379L, 209L, 
     506L, 504L, 685L, 134L, 625L, 764L, 138L, 273L, 661L, 701L, 647L, 241L, 531L, 708L, 
     448L, 342L, 480L, 261L, 290L, 722L, 175L, 11L, 251L, 434L, 4L, 36L, 580L, 650L, 363L, 
     479L, 230L, 37L, 717L, 371L, 67L, 193L, 597L, 544L, 720L, 535L, 739L, 554L, 761L, 
     143L, 49L, 763L, 419L, 358L, 387L, 464L, 477L, 47L, 545L, 368L, 5L, 364L, 340L, 293L, 
     223L, 73L, 631L, 522L, 551L, 179L, 213L, 702L, 26L, 561L, 466L, 519L, 108L, 599L, 
     385L, 383L, 601L, 66L, 663L, 470L, 15L, 736L, 16L, 651L, 402L, 271L, 126L, 492L, 
     493L, 137L, 740L, 727L, 629L, 431L, 648L, 178L, 51L, 225L, 560L, 511L, 157L, 415L, 
     630L, 559L, 262L, 58L, 742L, 543L, 707L, 258L, 408L, 276L, 173L, 447L, 521L, 641L, 
     79L, 365L, 125L, 147L, 703L, 754L, 8L, 163L, 486L, 688L, 498L, 757L, 180L, 211L, 
     579L, 541L, 696L, 732L, 550L, 767L, 295L, 144L, 297L, 691L, 612L, 684L, 451L, 490L, 
     80L, 370L, 112L, 514L, 473L, 656L, 90L, 723L, 38L, 44L, 366L, 435L, 427L, 332L, 662L, 
     386L, 421L, 256L, 30L, 123L, 245L, 114L, 449L, 689L, 177L, 98L, 422L, 335L, 113L, 
     567L, 10L, 191L, 224L, 384L, 571L, 516L, 586L, 728L, 410L, 55L, 654L, 323L, 190L, 
     724L, 334L, 407L, 562L, 563L, 619L, 718L, 54L, 653L, 584L, 658L, 581L, 583L, 229L, 
     652L, 655L, 590L, 589L, 167L, 721L, 356L, 734L, 75L, 279L, 254L, 572L, 508L, 39L, 
     758L, 747L, 645L, 593L, 428L, 83L, 70L, 460L, 85L, 690L, 28L, 436L, 673L, 463L, 552L, 
     131L, 587L, 695L, 64L, 204L, 62L, 234L, 753L, 197L, 265L, 694L, 380L, 327L, 390L, 
     311L, 438L, 20L, 296L, 399L, 24L, 610L, 614L, 14L, 577L, 533L, 95L, 354L, 756L, 22L, 
     710L, 675L, 700L, 132L, 750L, 286L, 120L, 284L)), test.inds = list(c(564L, 237L, 
     393L, 744L, 705L, 260L, 615L, 709L, 60L, 627L, 282L, 150L, 646L, 482L, 369L, 12L, 
     553L, 468L, 283L, 643L, 300L, 671L, 500L, 13L, 677L, 42L, 667L, 61L, 467L, 154L, 
     118L, 252L, 65L, 389L, 501L, 649L, 746L, 698L, 549L, 738L, 484L, 475L, 299L, 462L, 
     218L, 525L, 440L, 575L, 107L, 53L, 172L, 255L, 122L, 759L, 270L, 328L, 102L, 151L, 
     374L, 687L, 613L, 57L, 250L, 491L, 360L, 414L, 3L, 686L, 235L, 338L, 339L, 481L, 
     355L, 425L, 294L, 465L, 628L, 642L, 638L, 737L, 319L, 406L, 130L, 409L, 450L, 458L, 
     542L, 176L, 23L, 461L, 232L, 315L, 171L, 413L, 362L, 547L, 317L, 278L, 453L, 503L, 
     25L, 2L, 208L, 292L, 128L, 43L, 324L, 608L, 103L, 312L, 534L, 735L, 596L, 18L, 620L, 
     210L, 594L, 512L, 626L, 6L, 280L, 600L, 373L, 166L, 664L, 755L, 146L, 305L, 352L, 
     206L, 337L, 713L, 382L, 502L, 576L, 139L, 116L, 372L, 249L, 124L, 417L, 566L, 72L, 
     181L, 9L, 346L, 529L, 430L, 670L, 345L, 483L, 185L, 52L, 668L, 412L, 45L, 548L, 253L, 
     275L, 187L, 41L, 56L, 165L, 183L, 201L, 31L, 285L, 81L, 92L, 50L, 639L, 392L, 264L, 
     361L, 507L, 267L, 135L, 325L, 200L, 202L, 632L, 476L, 161L, 405L, 17L, 592L, 129L, 
     528L, 349L, 455L, 489L, 309L, 457L, 395L, 437L, 244L, 105L, 320L, 683L, 558L, 217L, 
     749L, 499L, 400L, 247L, 274L, 188L, 86L, 634L, 174L, 84L, 76L, 117L, 644L, 46L, 699L, 
     578L, 602L, 674L, 236L, 288L, 21L, 411L, 474L, 170L, 74L, 485L, 303L, 242L, 697L, 
     657L, 94L, 716L, 310L, 182L, 423L, 203L, 100L, 532L, 391L, 432L, 704L, 353L, 220L, 
     189L, 679L, 510L, 456L, 487L, 158L, 537L, 376L, 219L, 623L, 34L, 595L)), group = structure(integer(0), .Label = character(0), class = "factor")), class = "ResampleInstance"), 
         weights = NULL, measures = list(structure(list(id = "mmce", minimize = TRUE, 
             properties = c("classif", "classif.multi", "req.pred", "req.truth"), fun = function (task, 
                 model, pred, feats, extra.args) 
             {
                 measureMMCE(pred$data$truth, pred$data$response)
             }, extra.args = list(), best = 0, worst = 1, name = "Mean misclassification error", 
             note = "Defined as: mean(response != truth)", aggr = structure(list(id = "test.mean", 
                 name = "Test mean", fun = function (task, perf.test, perf.train, measure, 
                     group, pred) 
                 mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure")), 
         model = TRUE, extract = function (object) 
         {
             assertClass(object, "FeatSelModel")
             object$learner.model$opt.result
         }, show.info = FALSE)
  9: calculateResampleIterationResult(learner = learner, task = task, i = i, train.i = train.i, 
         test.i = test.i, measures = measures, weights = weights, rdesc = rin$desc, model = model, 
         extract = extract, show.info = show.info)
  10: train(learner, task, subset = train.i, weights = weights[train.i])
  ...
  47: mapply(fun2, ..., MoreArgs = more.args, SIMPLIFY = FALSE, USE.NAMES = FALSE)
  48: (function (learner, task, resampling, measures, par.set, bits.to.features, control, 
         opt.path, show.info, dob, state, remove.nas, resample.fun) 
     {
         setSlaveOptions()
         y = setNames(rep(NA_real_, length(measures)), vcapply(measures, measureAggrName))
         errmsg = NA_character_
         exec.time = NA_real_
         set.pars.ok = TRUE
         learner2 = learner
         threshold = NULL
         log.fun = control$log.fun
         err.dumps = list()
         if (inherits(control, "TuneControl") || inherits(control, "TuneMultiCritControl")) {
             state = setValueCNames(par.set, state)
             state = trafoValue(par.set, state)
             state2 = if (remove.nas) 
                 removeMissingValues(state)
             else state
             learner2 = try(setHyperPars(learner, par.vals = state2), silent = TRUE)
             if (is.error(learner2)) {
                 set.pars.ok = FALSE
                 errmsg = as.character(learner2)
                 if (show.info) 
                     messagef("[Tune-x] Setting hyperpars failed: %s", errmsg)
             }
         }
         else if (inherits(control, "FeatSelControl")) {
             task = subsetTask(task, features = bits.to.features(state, task))
         }
         if (show.info) 
             prev.stage = log.fun(learner, task, resampling, measures, par.set, control, 
                 opt.path, dob, state, NA_real_, remove.nas, stage = 1L)
         if (set.pars.ok) {
             exec.time = measureTime({
                 r = resample.fun(learner2, task, resampling, measures = measures, show.info = FALSE)
             })
             if (control$tune.threshold) {
                 th.args = control$tune.threshold.args
                 th.args$pred = r$pred
                 th.args$measure = measures[[1L]]
                 tune.th.res = do.call(tuneThreshold, th.args)
                 threshold = tune.th.res$th
                 y = performance(setThreshold(r$pred, threshold = threshold), measures = measures)
                 names(y) = names(r$aggr)
             }
             else {
                 y = r$aggr
             }
             errmsgs = as.character(t(r$err.msgs[, -1L]))
             notna = !is.na(errmsgs)
             if (any(notna)) 
                 errmsg = errmsgs[notna][1L]
             err.dumps = r$err.dumps
         }
         else {
             if (control$tune.threshold) 
                 threshold = NA_real_
         }
         if (show.info) 
             log.fun(learner, task, resampling, measures, par.set, control, opt.path, 
                 dob, state, y, remove.nas, stage = 2L, prev.stage = prev.stage)
         list(y = y, exec.time = exec.time, errmsg = errmsg, threshold = threshold, err.dumps = err.dumps)
     })(dots[[1L]][[1L]], dots[[2L]][[1L]], learner = structure(list(id = "classif.ksvm", 
         type = "classif", package = "kernlab", properties = c("twoclass", "multiclass", 
         "numerics", "factors", "prob", "class.weights"), par.set = structure(list(pars = list(
             scaled = structure(list(id = "scaled", type = "logical", len = 1L, lower = NULL, 
                 upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, 
                 allow.inf = FALSE, has.default = TRUE, default = TRUE, trafo = NULL, 
                 requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), type = structure(list(id = "type", type = "discrete", len = 1L, 
                 lower = NULL, upper = NULL, values = list(`C-svc` = "C-svc", `nu-svc` = "nu-svc", 
                     `C-bsvc` = "C-bsvc", `spoc-svc` = "spoc-svc", `kbb-svc` = "kbb-svc"), 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = "C-svc", 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), kernel = structure(list(
                 id = "kernel", type = "discrete", len = 1L, lower = NULL, upper = NULL, 
                 values = list(vanilladot = "vanilladot", polydot = "polydot", rbfdot = "rbfdot", 
                     tanhdot = "tanhdot", laplacedot = "laplacedot", besseldot = "besseldot", 
                     anovadot = "anovadot", splinedot = "splinedot"), cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = "rbfdot", trafo = NULL, requires = NULL, 
                 tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), C = structure(list(id = "C", type = "numeric", len = 1L, lower = 0, 
                 upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 1, trafo = NULL, requires = type %in% c("C-svc", "C-bsvc", 
                     "spoc-svc", "kbb-svc"), tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), nu = structure(list(id = "nu", type = "numeric", len = 1L, lower = 0, 
                 upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 0.2, trafo = NULL, requires = type == "nu-svc", tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), epsilon = structure(list(id = "epsilon", type = "numeric", len = 1L, 
                 lower = -Inf, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 0.1, trafo = NULL, requires = type %in% 
                     c("eps-svr", "nu-svr", "eps-bsvm"), tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), sigma = structure(list(
                 id = "sigma", type = "numeric", len = 1L, lower = 0, upper = Inf, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, 
                 trafo = NULL, requires = kernel %in% c("rbfdot", "anovadot", "besseldot", 
                     "laplacedot"), tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), degree = structure(list(id = "degree", type = "integer", len = 1L, 
                 lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 3L, trafo = NULL, requires = kernel %in% 
                     c("polydot", "anovadot", "besseldot"), tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), scale = structure(list(
                 id = "scale", type = "numeric", len = 1L, lower = 0, upper = Inf, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 1, trafo = NULL, 
                 requires = kernel %in% c("polydot", "tanhdot"), tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), offset = structure(list(
                 id = "offset", type = "numeric", len = 1L, lower = -Inf, upper = Inf, 
                 values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 1, trafo = NULL, requires = kernel %in% c("polydot", "tanhdot"), 
                 tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), order = structure(list(id = "order", type = "integer", len = 1L, 
                 lower = -Inf, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 1L, trafo = NULL, requires = kernel == 
                     "besseldot", tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), tol = structure(list(id = "tol", type = "numeric", len = 1L, lower = 0, 
                 upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 0.001, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), shrinking = structure(list(
                 id = "shrinking", type = "logical", len = 1L, lower = NULL, upper = NULL, 
                 values = list(`TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = TRUE, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), class.weights = structure(list(id = "class.weights", type = "numericvector", 
                 len = NA_integer_, lower = 0, upper = Inf, values = NULL, cnames = NULL, 
                 allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, 
                 requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), fit = structure(list(id = "fit", type = "logical", len = 1L, lower = NULL, 
                 upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, 
                 allow.inf = FALSE, has.default = TRUE, default = TRUE, trafo = NULL, 
                 requires = NULL, tunable = FALSE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), cache = structure(list(id = "cache", type = "integer", len = 1L, 
                 lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 40L, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             ))), forbidden = NULL), class = c("LearnerParamSet", "ParamSet")), par.vals = list(
             fit = FALSE), predict.type = "prob", name = "Support Vector Machines", short.name = "ksvm", 
         note = "Kernel parameters have to be passed directly and not by using the `kpar` list in `ksvm`. Note that `fit` has been set to `FALSE` by default for speed.", 
         callees = "ksvm", help.list = list(sigma = "Argument of: kernlab::ksvm\n\nfor the ANOVA kernel \"anovadot\".", 
             degree = "Argument of: kernlab::ksvm\n\nfor the ANOVA kernel \"anovadot\".", 
             scale = "Argument of: kernlab::ksvm\n\nfor the Hyperbolic tangent kernel function \"tanhdot\"", 
             offset = "Argument of: kernlab::ksvm\n\nfor the Hyperbolic tangent kernel function \"tanhdot\"", 
             order = "Argument of: kernlab::ksvm\n\nfor the Bessel kernel \"besseldot\".", 
             scaled = "Argument of: kernlab::ksvm\n\nA logical vector indicating the variables to be scaled. If scaled is of length 1, the value is recycled as many times as needed and all non-binary variables are scaled. Per default, data are scaled internally (both x and y variables) to zero mean and unit variance. The center and scale values are returned and used for later predictions.", 
             type = "Argument of: kernlab::ksvm\n\nksvm can be used for classification , for regression, or for novelty detection. Depending on whether y is a factor or not, the default setting for type is C-svc or eps-svr, respectively, but can be overwritten by setting an explicit value. Valid options are:\n\nC-svc   C classification\n\nnu-svc  nu classification\n\nC-bsvc  bound-constraint svm classification\n\nspoc-svc  Crammer, Singer native multi-class\n\nkbb-svc  Weston, Watkins native multi-class\n\none-svc  novelty detection\n\neps-svr  epsilon regression\n\nnu-svr   nu regression\n\neps-bsvr  bound-constraint svm regression", 
             kernel = "Argument of: kernlab::ksvm\n\nthe kernel function used in training and predicting. This parameter can be set to any function, of class kernel, which computes the inner product in feature space between two vector arguments (see kernels). kernlab provides the most popular kernel functions which can be used by setting the kernel parameter to the following strings:\n\nrbfdot Radial Basis kernel \"Gaussian\"\n\npolydot Polynomial kernel\n\nvanilladot Linear kernel\n\ntanhdot Hyperbolic tangent kernel\n\nlaplacedot Laplacian kernel\n\nbesseldot Bessel kernel\n\nanovadot ANOVA RBF kernel\n\nsplinedot Spline kernel\n\nstringdot String kernel\n\nSetting the kernel parameter to \"matrix\" treats x as a kernel matrix calling the kernelMatrix interface. The kernel parameter can also be set to a user defined function of class kernel by passing the function name as an argument.", 
             C = "Argument of: kernlab::ksvm\n\ncost of constraints violation (default: 1) this is the ‘C’-constant of the regularization term in the Lagrange formulation.", 
             nu = "Argument of: kernlab::ksvm\n\nparameter needed for nu-svc, one-svc, and nu-svr. The nu parameter sets the upper bound on the training error and the lower bound on the fraction of data points to become Support Vectors (default: 0.2).", 
             epsilon = "Argument of: kernlab::ksvm\n\nepsilon in the insensitive-loss function used for eps-svr, nu-svr and eps-bsvm (default: 0.1)", 
             class.weights = "Argument of: kernlab::ksvm\n\na named vector of weights for the different classes, used for asymmetric class sizes. Not all factor levels have to be supplied (default weight: 1). All components have to be named.", 
             cache = "Argument of: kernlab::ksvm\n\ncache memory in MB (default 40)", 
             tol = "Argument of: kernlab::ksvm\n\ntolerance of termination criterion (default: 0.001)", 
             shrinking = "Argument of: kernlab::ksvm\n\noption whether to use the shrinking-heuristics (default: TRUE)", 
             fit = "Argument of: kernlab::ksvm\n\nindicates whether the fitted values should be computed and included in the model or not (default: TRUE)"), 
         class.weights.param = "class.weights", config = list(), fix.factors.prediction = FALSE), class = c("classif.ksvm", 
     "RLearnerClassif", "RLearner", "Learner")), task = structure(list(type = "classif", 
         env = <environment>, weights = NULL, blocking = NULL, coordinates = NULL, task.desc = structure(list(
             id = "PimaIndiansDiabetes-example", type = "classif", target = "diabetes", 
             size = 341L, n.feat = c(numerics = 4L, factors = 0L, ordered = 0L, functionals = 0L
             ), has.missings = FALSE, has.weights = FALSE, has.blocking = FALSE, has.coordinates = FALSE, 
             class.levels = c("neg", "pos"), positive = "pos", negative = "neg", class.distribution = structure(c(neg = 216L, 
             pos = 125L), .Dim = 2L, .Dimnames = list(c("neg", "pos")), class = "table")), class = c("ClassifTaskDesc", 
         "SupervisedTaskDesc", "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", 
     "Task")), resampling = structure(list(desc = structure(list(split = 0.666666666666667, 
         id = "holdout", iters = 1L, predict = "test", stratify = FALSE), class = c("HoldoutDesc", 
     "ResampleDesc")), size = 341L, train.inds = list(c(99L, 269L, 139L, 299L, 317L, 16L, 
     177L, 338L, 184L, 152L, 337L, 150L, 223L, 188L, 34L, 294L, 80L, 14L, 106L, 308L, 
     286L, 222L, 205L, 331L, 208L, 224L, 172L, 187L, 91L, 46L, 300L, 280L, 214L, 246L, 
     8L, 147L, 232L, 66L, 97L, 70L, 43L, 125L, 124L, 110L, 312L, 42L, 69L, 137L, 78L, 
     251L, 324L, 129L, 231L, 36L, 161L, 60L, 37L, 309L, 254L, 323L, 314L, 27L, 108L, 77L, 
     226L, 334L, 329L, 275L, 217L, 120L, 319L, 170L, 192L, 1L, 127L, 59L, 101L, 162L, 
     93L, 30L, 64L, 174L, 109L, 204L, 310L, 112L, 252L, 227L, 225L, 45L, 33L, 164L, 86L, 
     163L, 325L, 47L, 340L, 23L, 114L, 276L, 145L, 247L, 117L, 228L, 115L, 211L, 215L, 
     143L, 96L, 35L, 273L, 302L, 291L, 289L, 250L, 292L, 242L, 284L, 131L, 90L, 144L, 
     71L, 68L, 48L, 81L, 213L, 327L, 20L, 31L, 306L, 274L, 328L, 141L, 154L, 279L, 136L, 
     169L, 287L, 199L, 89L, 63L, 82L, 3L, 285L, 167L, 297L, 322L, 15L, 218L, 209L, 264L, 
     95L, 74L, 195L, 21L, 73L, 282L, 40L, 200L, 333L, 313L, 261L, 239L, 67L, 201L, 94L, 
     130L, 39L, 72L, 196L, 207L, 32L, 146L, 126L, 256L, 103L, 62L, 87L, 234L, 190L, 206L, 
     50L, 113L, 296L, 176L, 76L, 158L, 283L, 140L, 138L, 155L, 49L, 212L, 92L, 332L, 295L, 
     266L, 191L, 22L, 183L, 235L, 135L, 84L, 173L, 56L, 272L, 160L, 260L, 244L, 133L, 
     180L, 277L, 28L, 318L, 7L, 202L, 44L, 51L, 265L, 159L, 305L, 116L, 128L, 238L, 267L, 
     315L, 55L)), test.inds = list(c(311L, 210L, 88L, 102L, 85L, 53L, 271L, 290L, 157L, 
     175L, 105L, 151L, 2L, 216L, 316L, 219L, 65L, 17L, 19L, 83L, 335L, 243L, 268L, 29L, 
     194L, 118L, 336L, 26L, 9L, 288L, 320L, 303L, 197L, 149L, 119L, 330L, 278L, 134L, 
     142L, 237L, 236L, 185L, 281L, 75L, 4L, 240L, 104L, 230L, 193L, 168L, 52L, 18L, 38L, 
     321L, 259L, 262L, 166L, 233L, 229L, 220L, 182L, 5L, 203L, 257L, 132L, 148L, 255L, 
     13L, 253L, 339L, 171L, 41L, 270L, 258L, 121L, 61L, 24L, 186L, 307L, 10L, 245L, 165L, 
     58L, 178L, 79L, 98L, 11L, 6L, 123L, 189L, 25L, 12L, 156L, 57L, 221L, 341L, 111L, 
     304L, 54L, 301L, 153L, 179L, 326L, 100L, 122L, 248L, 198L, 298L, 107L, 263L, 181L, 
     293L, 241L, 249L)), group = structure(integer(0), .Label = character(0), class = "factor")), class = "ResampleInstance"), 
         measures = list(structure(list(id = "auc", minimize = FALSE, properties = c("classif", 
         "req.pred", "req.truth", "req.prob"), fun = function (task, model, pred, feats, 
             extra.args) 
         {
             if (anyMissing(pred$data$response) || length(unique(pred$data$truth)) == 
                 1L) 
                 return(NA_real_)
             measureAUC(getPredictionProbabilities(pred), pred$data$truth, pred$task.desc$negative, 
                 pred$task.desc$positive)
         }, extra.args = list(), best = 1, worst = 0, name = "Area under the curve", note = "Integral over the graph that results from computing fpr and tpr for many different thresholds.", 
             aggr = structure(list(id = "test.mean", name = "Test mean", fun = function (task, 
                 perf.test, perf.train, measure, group, pred) 
             mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure"), 
             structure(list(id = "acc", minimize = FALSE, properties = c("classif", "classif.multi", 
             "req.pred", "req.truth"), fun = function (task, model, pred, feats, extra.args) 
             {
                 measureACC(pred$data$truth, pred$data$response)
             }, extra.args = list(), best = 1, worst = 0, name = "Accuracy", note = "Defined as: mean(response == truth)", 
                 aggr = structure(list(id = "test.mean", name = "Test mean", fun = function (task, 
                     perf.test, perf.train, measure, group, pred) 
                 mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure")), 
         par.set = structure(list(pars = list(C = structure(list(id = "C", type = "discrete", 
             len = 1L, lower = NULL, upper = NULL, values = list(`0.25` = 0.25, `0.5` = 0.5, 
                 `1` = 1, `2` = 2, `4` = 4), cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
             default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list()), class = "Param"), 
             sigma = structure(list(id = "sigma", type = "discrete", len = 1L, lower = NULL, 
                 upper = NULL, values = list(`0.25` = 0.25, `0.5` = 0.5, `1` = 1, `2` = 2, 
                     `4` = 4), cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                 default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list()), class = "Param")), 
             forbidden = NULL), class = "ParamSet"), bits.to.features = NULL, control = structure(list(
             same.resampling.instance = TRUE, impute.val = c(0, 0), tune.threshold = FALSE, 
             tune.threshold.args = list(), log.fun = function (learner, task, resampling, 
                 measures, par.set, control, opt.path, dob, x, y, remove.nas, stage, prev.stage) 
             {
                 x.string = paramValueToString(par.set, x, show.missing.values = !remove.nas)
                 if (inherits(learner, "ModelMultiplexer")) 
                     x.string = stri_replace_all(x.string, "", regex = stri_paste(x$selected.learner, 
                       "\\."))
                 logFunDefault(learner, task, resampling, measures, par.set, control, 
                     opt.path, dob, x.string, y, remove.nas, stage, prev.stage, prefixes = c("Tune-x", 
                       "Tune-y"))
             }, final.dw.perc = NULL, extra.args = list(maxit = 3L), budget = 3L), class = c("TuneControlRandom", 
         "TuneControl", "OptControl")), opt.path = structure(list(par.set = structure(list(
             pars = list(C = structure(list(id = "C", type = "discrete", len = 1L, lower = NULL, 
                 upper = NULL, values = list(`0.25` = 0.25, `0.5` = 0.5, `1` = 1, `2` = 2, 
                     `4` = 4), cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                 default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list()), class = "Param"), 
                 sigma = structure(list(id = "sigma", type = "discrete", len = 1L, lower = NULL, 
                     upper = NULL, values = list(`0.25` = 0.25, `0.5` = 0.5, `1` = 1, 
                       `2` = 2, `4` = 4), cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                     default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list()), class = "Param")), 
             forbidden = NULL), class = "ParamSet"), y.names = c("auc.test.mean", "acc.test.mean"
         ), minimize = c(auc.test.mean = FALSE, acc.test.mean = FALSE), add.transformed.x = FALSE, 
             env = <environment>), class = c("OptPathDF", "OptPath")), show.info = FALSE, 
         remove.nas = TRUE, resample.fun = function (learner, task, resampling, measures, 
             weights = NULL, models = FALSE, extract, keep.pred = TRUE, ..., show.info = getMlrOption("show.info")) 
         {
             learner = checkLearner(learner)
             learner = setHyperPars(learner, ...)
             assertClass(task, classes = "Task")
             n = getTaskSize(task)
             if (inherits(resampling, "ResampleDesc")) 
                 resampling = makeResampleInstance(resampling, task = task)
             assertClass(resampling, classes = "ResampleInstance")
             measures = checkMeasures(measures, task)
             if (!is.null(weights)) {
                 assertNumeric(weights, len = n, any.missing = FALSE, lower = 0)
             }
             assertFlag(models)
             if (missing(extract)) 
                 extract = function(model) {
                 }
             else assertFunction(extract)
             assertFlag(show.info)
             r = resampling$size
             if (n != r) 
                 stop(stri_paste("Size of data set:", n, "and resampling instance:", r, 
                     "differ!", sep = " "))
             checkLearnerBeforeTrain(task, learner, weights)
             checkAggrsBeforeResample(measures, resampling$desc)
             rin = resampling
             more.args = list(learner = learner, task = task, rin = rin, weights = NULL, 
                 measures = measures, model = models, extract = extract, show.info = show.info)
             if (!is.null(weights)) {
                 more.args$weights = weights
             }
             else if (!is.null(getTaskWeights(task))) {
                 more.args$weights = getTaskWeights(task)
             }
             parallelLibrary("mlr", master = FALSE, level = "mlr.resample", show.info = FALSE)
             exportMlrOptions(level = "mlr.resample")
             if (show.info) {
                 messagef("Resampling: %s", rin$desc$id)
                 measure.lognames = extractSubList(measures, "id")
                 if (rin$desc$predict == "both") {
                     id.train = which(vlapply(measures, function(x) "req.train" %in% x$aggr$properties))
                     id.test = which(vlapply(measures, function(x) "req.test" %in% x$aggr$properties))
                     measure.lognames = c(stri_paste(measure.lognames[id.train], "train", 
                       sep = "."), stri_paste(measure.lognames[id.test], "test", sep = "."))
                 }
                 printResampleFormatLine("Measures:", measure.lognames)
             }
             time1 = Sys.time()
             iter.results = parallelMap(doResampleIteration, seq_len(rin$desc$iters), 
                 level = "mlr.resample", more.args = more.args)
             time2 = Sys.time()
             runtime = as.numeric(difftime(time2, time1, units = "secs"))
             addClasses(mergeResampleResult(learner$id, task, iter.results, measures, 
                 rin, models, extract, keep.pred, show.info, runtime), "ResampleResult")
         })
  49: measureTime({
         r = resample.fun(learner2, task, resampling, measures = measures, show.info = FALSE)
     })
  50: force(expr)
  51: resample.fun(learner2, task, resampling, measures = measures, show.info = FALSE)
  52: parallelMap(doResampleIteration, seq_len(rin$desc$iters), level = "mlr.resample", 
         more.args = more.args)
  53: options(parallelMap.nextmap = (getPMOptNextMap() + 1L))
  54: getPMOptNextMap()
  55: getPMOption("nextmap")
  56: getOption(sprintf("parallelMap.%s", opt), def)
  
  ── 6. Error: MulticlassWrapper (@test_base_MulticlassWrapper.R#28)  ────────────
  argument "def" is missing, with no default
  1: train(lrn1.w, multiclass.task) at testthat/test_base_MulticlassWrapper.R:28
  2: measureTime(fun1({
         learner.model = fun2(fun3(do.call(trainLearner, pars)))
     }))
  3: force(expr)
  4: fun1({
         learner.model = fun2(fun3(do.call(trainLearner, pars)))
     })
  5: evalVis(expr)
  6: withVisible(eval(expr, pf))
  7: eval(expr, pf)
  8: eval(expr, pf)
  9: fun2(fun3(do.call(trainLearner, pars)))
  10: fun3(do.call(trainLearner, pars))
  11: do.call(trainLearner, pars)
  12: (function (.learner, .task, .subset, .weights = NULL, ...) 
     {
         UseMethod("trainLearner")
     })(.learner = structure(list(id = "classif.rpart.multiclass", type = "classif", package = "rpart", 
         properties = NULL, par.set = structure(list(pars = list(mcw.method = structure(list(
             id = "mcw.method", type = "untyped", len = 1L, lower = NULL, upper = NULL, 
             values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = "onevsrest", 
             trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param"))), forbidden = NULL), class = c("LearnerParamSet", "ParamSet")), par.vals = list(
             mcw.method = "onevsrest"), predict.type = "response", fix.factors.prediction = FALSE, 
         next.learner = structure(list(id = "classif.rpart", type = "classif", package = "rpart", 
             properties = c("twoclass", "multiclass", "missings", "numerics", "factors", 
             "ordered", "prob", "weights", "featimp"), par.set = structure(list(pars = list(
                 minsplit = structure(list(id = "minsplit", type = "integer", len = 1L, 
                     lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 20L, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), minbucket = structure(list(id = "minbucket", type = "integer", 
                     len = 1L, lower = 1L, upper = Inf, values = NULL, cnames = NULL, 
                     allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), cp = structure(list(id = "cp", type = "numeric", len = 1L, 
                     lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 0.01, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), maxcompete = structure(list(id = "maxcompete", type = "integer", 
                     len = 1L, lower = 0L, upper = Inf, values = NULL, cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = 4L, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), maxsurrogate = structure(list(id = "maxsurrogate", type = "integer", 
                     len = 1L, lower = 0L, upper = Inf, values = NULL, cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = 5L, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), usesurrogate = structure(list(id = "usesurrogate", type = "discrete", 
                     len = 1L, lower = NULL, upper = NULL, values = list(`0` = 0L, `1` = 1L, 
                       `2` = 2L), cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = 2L, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), surrogatestyle = structure(list(
                     id = "surrogatestyle", type = "discrete", len = 1L, lower = NULL, 
                     upper = NULL, values = list(`0` = 0L, `1` = 1L), cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 0L, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), maxdepth = structure(list(id = "maxdepth", type = "integer", 
                     len = 1L, lower = 1L, upper = 30L, values = NULL, cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = 30L, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), xval = structure(list(id = "xval", type = "integer", len = 1L, 
                     lower = 0L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 10L, trafo = NULL, requires = NULL, 
                     tunable = FALSE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), parms = structure(list(id = "parms", type = "untyped", len = 1L, 
                     lower = NULL, upper = NULL, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param"))), forbidden = NULL), class = c("LearnerParamSet", "ParamSet"
             )), par.vals = list(xval = 0L), predict.type = "response", name = "Decision Tree", 
             short.name = "rpart", note = "`xval` has been set to `0` by default for speed.", 
             callees = c("rpart", "rpart.control"), help.list = list(minsplit = "Argument of: rpart::rpart.control\n\nthe minimum number of observations that must exist in a node in order for a split to be attempted.", 
                 minbucket = "Argument of: rpart::rpart.control\n\nthe minimum number of observations in any terminal <leaf> node. If only one of minbucket or minsplit is specified, the code either sets minsplit to minbucket*3 or minbucket to minsplit/3, as appropriate.", 
                 cp = "Argument of: rpart::rpart.control\n\ncomplexity parameter.  Any split that does not decrease the overall lack of fit by a factor of cp is not attempted.  For instance, with anova splitting, this means that the overall R-squared must increase by cp at each step. The main role of this parameter is to save computing time by pruning off splits that are obviously not worthwhile. Essentially,the user informs the program that any split which does not improve the fit by cp will likely be pruned off by cross-validation, and that hence the program need not pursue it.", 
                 maxcompete = "Argument of: rpart::rpart.control\n\nthe number of competitor splits retained in the output.  It is useful to know not just which split was chosen, but which variable came in second, third, etc.", 
                 maxsurrogate = "Argument of: rpart::rpart.control\n\nthe number of surrogate splits retained in the output.  If this is set to zero the compute time will be reduced, since approximately half of the computational time (other than setup) is used in the search for surrogate splits.", 
                 usesurrogate = "Argument of: rpart::rpart.control\n\nhow to use surrogates in the splitting process.  0 means display only; an observation with a missing value for the primary split rule is not sent further down the tree.  1 means use surrogates, in order, to split subjects missing the primary variable; if all surrogates are missing the observation is not split.  For value 2 ,if all surrogates are missing, then send the observation in the majority direction.  A value of 0 corresponds to the action of tree, and 2 to the recommendations of Breiman et.al (1984).", 
                 xval = "Argument of: rpart::rpart.control\n\nnumber of cross-validations.", 
                 surrogatestyle = "Argument of: rpart::rpart.control\n\ncontrols the selection of a best surrogate. If set to 0 (default) the program uses the total number of correct classification for a potential surrogate variable, if set to 1 it uses the percent correct, calculated over the non-missing values of the surrogate. The first option more severely penalizes covariates with a large number of missing values.", 
                 maxdepth = "Argument of: rpart::rpart.control\n\nSet the maximum depth of any node of the final tree, with the root node counted as depth 0.  Values greater than  30 rpart will give nonsense results on 32-bit machines.", 
                 parms = "Argument of: rpart::rpart\n\noptional parameters for the splitting function. Anova splitting has no parameters. Poisson splitting has a single parameter, the coefficient of variation of the prior distribution on the rates.  The default value is 1. Exponential splitting has the same parameter as Poisson. For classification splitting, the list can contain any of: the vector of prior probabilities (component prior), the loss matrix (component loss) or the splitting index (component split).  The priors must be positive and sum to 1.  The loss matrix must have zeros on the diagonal and positive off-diagonal elements.  The splitting index can be gini or information.  The default priors are proportional to the data counts, the losses default to 1, and the split defaults to gini."), 
             config = list(), fix.factors.prediction = FALSE), class = c("classif.rpart", 
         "RLearnerClassif", "RLearner", "Learner")), model.subclass = c("MulticlassModel", 
         "HomogeneousEnsembleModel")), class = c("MulticlassWrapper", "HomogeneousEnsemble", 
     "BaseWrapper", "Learner")), .task = structure(list(type = "classif", env = <environment>, 
         weights = NULL, blocking = NULL, coordinates = NULL, task.desc = structure(list(
             id = "multiclass", type = "classif", target = "Species", size = 150L, n.feat = c(numerics = 4L, 
             factors = 0L, ordered = 0L, functionals = 0L), has.missings = FALSE, has.weights = FALSE, 
             has.blocking = FALSE, has.coordinates = FALSE, class.levels = c("setosa", 
             "versicolor", "virginica"), positive = NA_character_, negative = NA_character_, 
             class.distribution = structure(c(setosa = 50L, versicolor = 50L, virginica = 50L
             ), .Dim = 3L, .Dimnames = list(c("setosa", "versicolor", "virginica")), class = "table")), class = c("ClassifTaskDesc", 
         "SupervisedTaskDesc", "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", 
     "Task")), .subset = NULL, xval = 0L, mcw.method = "onevsrest")
  13: trainLearner.MulticlassWrapper(.learner = structure(list(id = "classif.rpart.multiclass", 
         type = "classif", package = "rpart", properties = NULL, par.set = structure(list(
             pars = list(mcw.method = structure(list(id = "mcw.method", type = "untyped", 
                 len = 1L, lower = NULL, upper = NULL, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = "onevsrest", trafo = NULL, requires = NULL, 
                 tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param"))), forbidden = NULL), class = c("LearnerParamSet", "ParamSet")), 
         par.vals = list(mcw.method = "onevsrest"), predict.type = "response", fix.factors.prediction = FALSE, 
         next.learner = structure(list(id = "classif.rpart", type = "classif", package = "rpart", 
             properties = c("twoclass", "multiclass", "missings", "numerics", "factors", 
             "ordered", "prob", "weights", "featimp"), par.set = structure(list(pars = list(
                 minsplit = structure(list(id = "minsplit", type = "integer", len = 1L, 
                     lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 20L, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), minbucket = structure(list(id = "minbucket", type = "integer", 
                     len = 1L, lower = 1L, upper = Inf, values = NULL, cnames = NULL, 
                     allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), cp = structure(list(id = "cp", type = "numeric", len = 1L, 
                     lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 0.01, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), maxcompete = structure(list(id = "maxcompete", type = "integer", 
                     len = 1L, lower = 0L, upper = Inf, values = NULL, cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = 4L, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), maxsurrogate = structure(list(id = "maxsurrogate", type = "integer", 
                     len = 1L, lower = 0L, upper = Inf, values = NULL, cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = 5L, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), usesurrogate = structure(list(id = "usesurrogate", type = "discrete", 
                     len = 1L, lower = NULL, upper = NULL, values = list(`0` = 0L, `1` = 1L, 
                       `2` = 2L), cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = 2L, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), surrogatestyle = structure(list(
                     id = "surrogatestyle", type = "discrete", len = 1L, lower = NULL, 
                     upper = NULL, values = list(`0` = 0L, `1` = 1L), cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 0L, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), maxdepth = structure(list(id = "maxdepth", type = "integer", 
                     len = 1L, lower = 1L, upper = 30L, values = NULL, cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = 30L, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), xval = structure(list(id = "xval", type = "integer", len = 1L, 
                     lower = 0L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 10L, trafo = NULL, requires = NULL, 
                     tunable = FALSE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), parms = structure(list(id = "parms", type = "untyped", len = 1L, 
                     lower = NULL, upper = NULL, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param"))), forbidden = NULL), class = c("LearnerParamSet", "ParamSet"
             )), par.vals = list(xval = 0L), predict.type = "response", name = "Decision Tree", 
             short.name = "rpart", note = "`xval` has been set to `0` by default for speed.", 
             callees = c("rpart", "rpart.control"), help.list = list(minsplit = "Argument of: rpart::rpart.control\n\nthe minimum number of observations that must exist in a node in order for a split to be attempted.", 
                 minbucket = "Argument of: rpart::rpart.control\n\nthe minimum number of observations in any terminal <leaf> node. If only one of minbucket or minsplit is specified, the code either sets minsplit to minbucket*3 or minbucket to minsplit/3, as appropriate.", 
                 cp = "Argument of: rpart::rpart.control\n\ncomplexity parameter.  Any split that does not decrease the overall lack of fit by a factor of cp is not attempted.  For instance, with anova splitting, this means that the overall R-squared must increase by cp at each step. The main role of this parameter is to save computing time by pruning off splits that are obviously not worthwhile. Essentially,the user informs the program that any split which does not improve the fit by cp will likely be pruned off by cross-validation, and that hence the program need not pursue it.", 
                 maxcompete = "Argument of: rpart::rpart.control\n\nthe number of competitor splits retained in the output.  It is useful to know not just which split was chosen, but which variable came in second, third, etc.", 
                 maxsurrogate = "Argument of: rpart::rpart.control\n\nthe number of surrogate splits retained in the output.  If this is set to zero the compute time will be reduced, since approximately half of the computational time (other than setup) is used in the search for surrogate splits.", 
                 usesurrogate = "Argument of: rpart::rpart.control\n\nhow to use surrogates in the splitting process.  0 means display only; an observation with a missing value for the primary split rule is not sent further down the tree.  1 means use surrogates, in order, to split subjects missing the primary variable; if all surrogates are missing the observation is not split.  For value 2 ,if all surrogates are missing, then send the observation in the majority direction.  A value of 0 corresponds to the action of tree, and 2 to the recommendations of Breiman et.al (1984).", 
                 xval = "Argument of: rpart::rpart.control\n\nnumber of cross-validations.", 
                 surrogatestyle = "Argument of: rpart::rpart.control\n\ncontrols the selection of a best surrogate. If set to 0 (default) the program uses the total number of correct classification for a potential surrogate variable, if set to 1 it uses the percent correct, calculated over the non-missing values of the surrogate. The first option more severely penalizes covariates with a large number of missing values.", 
                 maxdepth = "Argument of: rpart::rpart.control\n\nSet the maximum depth of any node of the final tree, with the root node counted as depth 0.  Values greater than  30 rpart will give nonsense results on 32-bit machines.", 
                 parms = "Argument of: rpart::rpart\n\noptional parameters for the splitting function. Anova splitting has no parameters. Poisson splitting has a single parameter, the coefficient of variation of the prior distribution on the rates.  The default value is 1. Exponential splitting has the same parameter as Poisson. For classification splitting, the list can contain any of: the vector of prior probabilities (component prior), the loss matrix (component loss) or the splitting index (component split).  The priors must be positive and sum to 1.  The loss matrix must have zeros on the diagonal and positive off-diagonal elements.  The splitting index can be gini or information.  The default priors are proportional to the data counts, the losses default to 1, and the split defaults to gini."), 
             config = list(), fix.factors.prediction = FALSE), class = c("classif.rpart", 
         "RLearnerClassif", "RLearner", "Learner")), model.subclass = c("MulticlassModel", 
         "HomogeneousEnsembleModel")), class = c("MulticlassWrapper", "HomogeneousEnsemble", 
     "BaseWrapper", "Learner")), .task = structure(list(type = "classif", env = <environment>, 
         weights = NULL, blocking = NULL, coordinates = NULL, task.desc = structure(list(
             id = "multiclass", type = "classif", target = "Species", size = 150L, n.feat = c(numerics = 4L, 
             factors = 0L, ordered = 0L, functionals = 0L), has.missings = FALSE, has.weights = FALSE, 
             has.blocking = FALSE, has.coordinates = FALSE, class.levels = c("setosa", 
             "versicolor", "virginica"), positive = NA_character_, negative = NA_character_, 
             class.distribution = structure(c(setosa = 50L, versicolor = 50L, virginica = 50L
             ), .Dim = 3L, .Dimnames = list(c("setosa", "versicolor", "virginica")), class = "table")), class = c("ClassifTaskDesc", 
         "SupervisedTaskDesc", "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", 
     "Task")), .subset = NULL, xval = 0L, mcw.method = "onevsrest")
  14: parallelMap(i = seq_along(x$row.inds), doMulticlassTrainIteration, more.args = args, 
         level = "mlr.ensemble")
  15: options(parallelMap.nextmap = (getPMOptNextMap() + 1L))
  16: getPMOptNextMap()
  17: getPMOption("nextmap")
  18: getOption(sprintf("parallelMap.%s", opt), def)
  
  ── 7. Error: MulticlassWrapper works with multiple factor levels (#620) (@test_b
  argument "def" is missing, with no default
  1: benchmark(w, classif.task, rdesc) at testthat/test_base_MulticlassWrapper.R:50
  2: parallelMap(benchmarkParallel, task = grid$task, learner = grid$learner, more.args = list(learners = learners, 
         tasks = tasks, resamplings = resamplings, measures = measures, keep.pred = keep.pred, 
         models = models, show.info = show.info), level = plevel)
  3: mapply(fun2, ..., MoreArgs = more.args, SIMPLIFY = FALSE, USE.NAMES = FALSE)
  4: (function (task, learner, learners, tasks, resamplings, measures, keep.pred = TRUE, 
         models = TRUE, show.info) 
     {
         setSlaveOptions()
         if (show.info) 
             messagef("Task: %s, Learner: %s", task, learner)
         lrn = learners[[learner]]
         extract.this = getExtractor(lrn)
         r = resample(lrn, tasks[[task]], resamplings[[task]], measures = measures, models = models, 
             extract = extract.this, keep.pred = keep.pred, show.info = show.info)
         r$learner = lrn
         return(r)
     })(task = dots[[1L]][[1L]], learner = dots[[2L]][[1L]], learners = list(classif.rpart.multiclass = structure(list(
         id = "classif.rpart.multiclass", type = "classif", package = "rpart", properties = NULL, 
         par.set = structure(list(pars = list(mcw.method = structure(list(id = "mcw.method", 
             type = "untyped", len = 1L, lower = NULL, upper = NULL, values = NULL, cnames = NULL, 
             allow.inf = FALSE, has.default = TRUE, default = "onevsrest", trafo = NULL, 
             requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param"))), forbidden = NULL), class = c("LearnerParamSet", "ParamSet")), par.vals = list(
             mcw.method = "onevsrest"), predict.type = "response", fix.factors.prediction = FALSE, 
         next.learner = structure(list(id = "classif.rpart", type = "classif", package = "rpart", 
             properties = c("twoclass", "multiclass", "missings", "numerics", "factors", 
             "ordered", "prob", "weights", "featimp"), par.set = structure(list(pars = list(
                 minsplit = structure(list(id = "minsplit", type = "integer", len = 1L, 
                     lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 20L, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), minbucket = structure(list(id = "minbucket", type = "integer", 
                     len = 1L, lower = 1L, upper = Inf, values = NULL, cnames = NULL, 
                     allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), cp = structure(list(id = "cp", type = "numeric", len = 1L, 
                     lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 0.01, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), maxcompete = structure(list(id = "maxcompete", type = "integer", 
                     len = 1L, lower = 0L, upper = Inf, values = NULL, cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = 4L, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), maxsurrogate = structure(list(id = "maxsurrogate", type = "integer", 
                     len = 1L, lower = 0L, upper = Inf, values = NULL, cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = 5L, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), usesurrogate = structure(list(id = "usesurrogate", type = "discrete", 
                     len = 1L, lower = NULL, upper = NULL, values = list(`0` = 0L, `1` = 1L, 
                       `2` = 2L), cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = 2L, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), surrogatestyle = structure(list(
                     id = "surrogatestyle", type = "discrete", len = 1L, lower = NULL, 
                     upper = NULL, values = list(`0` = 0L, `1` = 1L), cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 0L, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), maxdepth = structure(list(id = "maxdepth", type = "integer", 
                     len = 1L, lower = 1L, upper = 30L, values = NULL, cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = 30L, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), xval = structure(list(id = "xval", type = "integer", len = 1L, 
                     lower = 0L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 10L, trafo = NULL, requires = NULL, 
                     tunable = FALSE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), parms = structure(list(id = "parms", type = "untyped", len = 1L, 
                     lower = NULL, upper = NULL, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param"))), forbidden = NULL), class = c("LearnerParamSet", "ParamSet"
             )), par.vals = list(xval = 0L), predict.type = "response", name = "Decision Tree", 
             short.name = "rpart", note = "`xval` has been set to `0` by default for speed.", 
             callees = c("rpart", "rpart.control"), help.list = list(minsplit = "Argument of: rpart::rpart.control\n\nthe minimum number of observations that must exist in a node in order for a split to be attempted.", 
                 minbucket = "Argument of: rpart::rpart.control\n\nthe minimum number of observations in any terminal <leaf> node. If only one of minbucket or minsplit is specified, the code either sets minsplit to minbucket*3 or minbucket to minsplit/3, as appropriate.", 
                 cp = "Argument of: rpart::rpart.control\n\ncomplexity parameter.  Any split that does not decrease the overall lack of fit by a factor of cp is not attempted.  For instance, with anova splitting, this means that the overall R-squared must increase by cp at each step. The main role of this parameter is to save computing time by pruning off splits that are obviously not worthwhile. Essentially,the user informs the program that any split which does not improve the fit by cp will likely be pruned off by cross-validation, and that hence the program need not pursue it.", 
                 maxcompete = "Argument of: rpart::rpart.control\n\nthe number of competitor splits retained in the output.  It is useful to know not just which split was chosen, but which variable came in second, third, etc.", 
                 maxsurrogate = "Argument of: rpart::rpart.control\n\nthe number of surrogate splits retained in the output.  If this is set to zero the compute time will be reduced, since approximately half of the computational time (other than setup) is used in the search for surrogate splits.", 
                 usesurrogate = "Argument of: rpart::rpart.control\n\nhow to use surrogates in the splitting process.  0 means display only; an observation with a missing value for the primary split rule is not sent further down the tree.  1 means use surrogates, in order, to split subjects missing the primary variable; if all surrogates are missing the observation is not split.  For value 2 ,if all surrogates are missing, then send the observation in the majority direction.  A value of 0 corresponds to the action of tree, and 2 to the recommendations of Breiman et.al (1984).", 
                 xval = "Argument of: rpart::rpart.control\n\nnumber of cross-validations.", 
                 surrogatestyle = "Argument of: rpart::rpart.control\n\ncontrols the selection of a best surrogate. If set to 0 (default) the program uses the total number of correct classification for a potential surrogate variable, if set to 1 it uses the percent correct, calculated over the non-missing values of the surrogate. The first option more severely penalizes covariates with a large number of missing values.", 
                 maxdepth = "Argument of: rpart::rpart.control\n\nSet the maximum depth of any node of the final tree, with the root node counted as depth 0.  Values greater than  30 rpart will give nonsense results on 32-bit machines.", 
                 parms = "Argument of: rpart::rpart\n\noptional parameters for the splitting function. Anova splitting has no parameters. Poisson splitting has a single parameter, the coefficient of variation of the prior distribution on the rates.  The default value is 1. Exponential splitting has the same parameter as Poisson. For classification splitting, the list can contain any of: the vector of prior probabilities (component prior), the loss matrix (component loss) or the splitting index (component split).  The priors must be positive and sum to 1.  The loss matrix must have zeros on the diagonal and positive off-diagonal elements.  The splitting index can be gini or information.  The default priors are proportional to the data counts, the losses default to 1, and the split defaults to gini."), 
             config = list(), fix.factors.prediction = FALSE), class = c("classif.rpart", 
         "RLearnerClassif", "RLearner", "Learner")), model.subclass = c("MulticlassModel", 
         "HomogeneousEnsembleModel")), class = c("MulticlassWrapper", "HomogeneousEnsemble", 
     "BaseWrapper", "Learner"))), tasks = list(test = structure(list(type = "classif", 
         env = <environment>, weights = NULL, blocking = NULL, coordinates = NULL, task.desc = structure(list(
             id = "test", type = "classif", target = "Species", size = 150L, n.feat = c(numerics = 3L, 
             factors = 1L, ordered = 0L, functionals = 0L), has.missings = FALSE, has.weights = FALSE, 
             has.blocking = FALSE, has.coordinates = FALSE, class.levels = c("setosa", 
             "versicolor", "virginica"), positive = NA_character_, negative = NA_character_, 
             class.distribution = structure(c(setosa = 50L, versicolor = 50L, virginica = 50L
             ), .Dim = 3L, .Dimnames = list(c("setosa", "versicolor", "virginica")), class = "table")), class = c("ClassifTaskDesc", 
         "SupervisedTaskDesc", "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", 
     "Task"))), resamplings = list(test = structure(list(desc = structure(list(id = "cross-validation", 
         iters = 2L, predict = "test", stratify = FALSE), class = c("CVDesc", "ResampleDesc"
     )), size = 150L, train.inds = list(c(32L, 64L, 71L, 50L, 52L, 49L, 73L, 30L, 55L, 
     95L, 107L, 101L, 143L, 69L, 56L, 141L, 122L, 134L, 136L, 68L, 16L, 148L, 96L, 139L, 
     118L, 27L, 44L, 23L, 20L, 98L, 5L, 133L, 34L, 76L, 145L, 86L, 127L, 109L, 41L, 138L, 
     4L, 18L, 13L, 40L, 121L, 22L, 72L, 119L, 113L, 11L, 29L, 61L, 8L, 115L, 63L, 94L, 
     135L, 19L, 21L, 12L, 144L, 1L, 91L, 99L, 2L, 14L, 28L, 70L, 48L, 42L, 126L, 15L, 
     80L, 150L, 54L), c(128L, 75L, 58L, 37L, 17L, 57L, 83L, 31L, 90L, 100L, 35L, 82L, 
     24L, 111L, 85L, 78L, 47L, 66L, 140L, 38L, 84L, 142L, 103L, 120L, 114L, 36L, 67L, 
     43L, 129L, 59L, 39L, 131L, 102L, 92L, 60L, 112L, 149L, 89L, 53L, 51L, 123L, 81L, 
     147L, 26L, 77L, 10L, 97L, 33L, 62L, 130L, 87L, 137L, 25L, 74L, 88L, 45L, 65L, 93L, 
     117L, 3L, 79L, 125L, 106L, 105L, 110L, 108L, 6L, 46L, 132L, 104L, 124L, 9L, 7L, 116L, 
     146L)), test.inds = list(c(3L, 6L, 7L, 9L, 10L, 17L, 24L, 25L, 26L, 31L, 33L, 35L, 
     36L, 37L, 38L, 39L, 43L, 45L, 46L, 47L, 51L, 53L, 57L, 58L, 59L, 60L, 62L, 65L, 66L, 
     67L, 74L, 75L, 77L, 78L, 79L, 81L, 82L, 83L, 84L, 85L, 87L, 88L, 89L, 90L, 92L, 93L, 
     97L, 100L, 102L, 103L, 104L, 105L, 106L, 108L, 110L, 111L, 112L, 114L, 116L, 117L, 
     120L, 123L, 124L, 125L, 128L, 129L, 130L, 131L, 132L, 137L, 140L, 142L, 146L, 147L, 
     149L), c(1L, 2L, 4L, 5L, 8L, 11L, 12L, 13L, 14L, 15L, 16L, 18L, 19L, 20L, 21L, 22L, 
     23L, 27L, 28L, 29L, 30L, 32L, 34L, 40L, 41L, 42L, 44L, 48L, 49L, 50L, 52L, 54L, 55L, 
     56L, 61L, 63L, 64L, 68L, 69L, 70L, 71L, 72L, 73L, 76L, 80L, 86L, 91L, 94L, 95L, 96L, 
     98L, 99L, 101L, 107L, 109L, 113L, 115L, 118L, 119L, 121L, 122L, 126L, 127L, 133L, 
     134L, 135L, 136L, 138L, 139L, 141L, 143L, 144L, 145L, 148L, 150L)), group = structure(integer(0), .Label = character(0), class = "factor")), class = "ResampleInstance")), 
         measures = list(structure(list(id = "mmce", minimize = TRUE, properties = c("classif", 
         "classif.multi", "req.pred", "req.truth"), fun = function (task, model, pred, 
             feats, extra.args) 
         {
             measureMMCE(pred$data$truth, pred$data$response)
         }, extra.args = list(), best = 0, worst = 1, name = "Mean misclassification error", 
             note = "Defined as: mean(response != truth)", aggr = structure(list(id = "test.mean", 
                 name = "Test mean", fun = function (task, perf.test, perf.train, measure, 
                     group, pred) 
                 mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure")), 
         keep.pred = TRUE, models = TRUE, show.info = FALSE)
  5: resample(lrn, tasks[[task]], resamplings[[task]], measures = measures, models = models, 
         extract = extract.this, keep.pred = keep.pred, show.info = show.info)
  6: parallelMap(doResampleIteration, seq_len(rin$desc$iters), level = "mlr.resample", 
         more.args = more.args)
  7: mapply(fun2, ..., MoreArgs = more.args, SIMPLIFY = FALSE, USE.NAMES = FALSE)
  8: (function (learner, task, rin, i, measures, weights, model, extract, show.info) 
     {
         setSlaveOptions()
         train.i = rin$train.inds[[i]]
         test.i = rin$test.inds[[i]]
         calculateResampleIterationResult(learner = learner, task = task, i = i, train.i = train.i, 
             test.i = test.i, measures = measures, weights = weights, rdesc = rin$desc, 
             model = model, extract = extract, show.info = show.info)
     })(dots[[1L]][[1L]], learner = structure(list(id = "classif.rpart.multiclass", type = "classif", 
         package = "rpart", properties = NULL, par.set = structure(list(pars = list(mcw.method = structure(list(
             id = "mcw.method", type = "untyped", len = 1L, lower = NULL, upper = NULL, 
             values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = "onevsrest", 
             trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param"))), forbidden = NULL), class = c("LearnerParamSet", "ParamSet")), par.vals = list(
             mcw.method = "onevsrest"), predict.type = "response", fix.factors.prediction = FALSE, 
         next.learner = structure(list(id = "classif.rpart", type = "classif", package = "rpart", 
             properties = c("twoclass", "multiclass", "missings", "numerics", "factors", 
             "ordered", "prob", "weights", "featimp"), par.set = structure(list(pars = list(
                 minsplit = structure(list(id = "minsplit", type = "integer", len = 1L, 
                     lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 20L, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), minbucket = structure(list(id = "minbucket", type = "integer", 
                     len = 1L, lower = 1L, upper = Inf, values = NULL, cnames = NULL, 
                     allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), cp = structure(list(id = "cp", type = "numeric", len = 1L, 
                     lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 0.01, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), maxcompete = structure(list(id = "maxcompete", type = "integer", 
                     len = 1L, lower = 0L, upper = Inf, values = NULL, cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = 4L, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), maxsurrogate = structure(list(id = "maxsurrogate", type = "integer", 
                     len = 1L, lower = 0L, upper = Inf, values = NULL, cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = 5L, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), usesurrogate = structure(list(id = "usesurrogate", type = "discrete", 
                     len = 1L, lower = NULL, upper = NULL, values = list(`0` = 0L, `1` = 1L, 
                       `2` = 2L), cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = 2L, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), surrogatestyle = structure(list(
                     id = "surrogatestyle", type = "discrete", len = 1L, lower = NULL, 
                     upper = NULL, values = list(`0` = 0L, `1` = 1L), cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 0L, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), maxdepth = structure(list(id = "maxdepth", type = "integer", 
                     len = 1L, lower = 1L, upper = 30L, values = NULL, cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = 30L, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), xval = structure(list(id = "xval", type = "integer", len = 1L, 
                     lower = 0L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 10L, trafo = NULL, requires = NULL, 
                     tunable = FALSE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), parms = structure(list(id = "parms", type = "untyped", len = 1L, 
                     lower = NULL, upper = NULL, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param"))), forbidden = NULL), class = c("LearnerParamSet", "ParamSet"
             )), par.vals = list(xval = 0L), predict.type = "response", name = "Decision Tree", 
             short.name = "rpart", note = "`xval` has been set to `0` by default for speed.", 
             callees = c("rpart", "rpart.control"), help.list = list(minsplit = "Argument of: rpart::rpart.control\n\nthe minimum number of observations that must exist in a node in order for a split to be attempted.", 
                 minbucket = "Argument of: rpart::rpart.control\n\nthe minimum number of observations in any terminal <leaf> node. If only one of minbucket or minsplit is specified, the code either sets minsplit to minbucket*3 or minbucket to minsplit/3, as appropriate.", 
                 cp = "Argument of: rpart::rpart.control\n\ncomplexity parameter.  Any split that does not decrease the overall lack of fit by a factor of cp is not attempted.  For instance, with anova splitting, this means that the overall R-squared must increase by cp at each step. The main role of this parameter is to save computing time by pruning off splits that are obviously not worthwhile. Essentially,the user informs the program that any split which does not improve the fit by cp will likely be pruned off by cross-validation, and that hence the program need not pursue it.", 
                 maxcompete = "Argument of: rpart::rpart.control\n\nthe number of competitor splits retained in the output.  It is useful to know not just which split was chosen, but which variable came in second, third, etc.", 
                 maxsurrogate = "Argument of: rpart::rpart.control\n\nthe number of surrogate splits retained in the output.  If this is set to zero the compute time will be reduced, since approximately half of the computational time (other than setup) is used in the search for surrogate splits.", 
                 usesurrogate = "Argument of: rpart::rpart.control\n\nhow to use surrogates in the splitting process.  0 means display only; an observation with a missing value for the primary split rule is not sent further down the tree.  1 means use surrogates, in order, to split subjects missing the primary variable; if all surrogates are missing the observation is not split.  For value 2 ,if all surrogates are missing, then send the observation in the majority direction.  A value of 0 corresponds to the action of tree, and 2 to the recommendations of Breiman et.al (1984).", 
                 xval = "Argument of: rpart::rpart.control\n\nnumber of cross-validations.", 
                 surrogatestyle = "Argument of: rpart::rpart.control\n\ncontrols the selection of a best surrogate. If set to 0 (default) the program uses the total number of correct classification for a potential surrogate variable, if set to 1 it uses the percent correct, calculated over the non-missing values of the surrogate. The first option more severely penalizes covariates with a large number of missing values.", 
                 maxdepth = "Argument of: rpart::rpart.control\n\nSet the maximum depth of any node of the final tree, with the root node counted as depth 0.  Values greater than  30 rpart will give nonsense results on 32-bit machines.", 
                 parms = "Argument of: rpart::rpart\n\noptional parameters for the splitting function. Anova splitting has no parameters. Poisson splitting has a single parameter, the coefficient of variation of the prior distribution on the rates.  The default value is 1. Exponential splitting has the same parameter as Poisson. For classification splitting, the list can contain any of: the vector of prior probabilities (component prior), the loss matrix (component loss) or the splitting index (component split).  The priors must be positive and sum to 1.  The loss matrix must have zeros on the diagonal and positive off-diagonal elements.  The splitting index can be gini or information.  The default priors are proportional to the data counts, the losses default to 1, and the split defaults to gini."), 
             config = list(), fix.factors.prediction = FALSE), class = c("classif.rpart", 
         "RLearnerClassif", "RLearner", "Learner")), model.subclass = c("MulticlassModel", 
         "HomogeneousEnsembleModel")), class = c("MulticlassWrapper", "HomogeneousEnsemble", 
     "BaseWrapper", "Learner")), task = structure(list(type = "classif", env = <environment>, 
         weights = NULL, blocking = NULL, coordinates = NULL, task.desc = structure(list(
             id = "test", type = "classif", target = "Species", size = 150L, n.feat = c(numerics = 3L, 
             factors = 1L, ordered = 0L, functionals = 0L), has.missings = FALSE, has.weights = FALSE, 
             has.blocking = FALSE, has.coordinates = FALSE, class.levels = c("setosa", 
             "versicolor", "virginica"), positive = NA_character_, negative = NA_character_, 
             class.distribution = structure(c(setosa = 50L, versicolor = 50L, virginica = 50L
             ), .Dim = 3L, .Dimnames = list(c("setosa", "versicolor", "virginica")), class = "table")), class = c("ClassifTaskDesc", 
         "SupervisedTaskDesc", "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", 
     "Task")), rin = structure(list(desc = structure(list(id = "cross-validation", iters = 2L, 
         predict = "test", stratify = FALSE), class = c("CVDesc", "ResampleDesc")), size = 150L, 
         train.inds = list(c(32L, 64L, 71L, 50L, 52L, 49L, 73L, 30L, 55L, 95L, 107L, 101L, 
         143L, 69L, 56L, 141L, 122L, 134L, 136L, 68L, 16L, 148L, 96L, 139L, 118L, 27L, 
         44L, 23L, 20L, 98L, 5L, 133L, 34L, 76L, 145L, 86L, 127L, 109L, 41L, 138L, 4L, 
         18L, 13L, 40L, 121L, 22L, 72L, 119L, 113L, 11L, 29L, 61L, 8L, 115L, 63L, 94L, 
         135L, 19L, 21L, 12L, 144L, 1L, 91L, 99L, 2L, 14L, 28L, 70L, 48L, 42L, 126L, 15L, 
         80L, 150L, 54L), c(128L, 75L, 58L, 37L, 17L, 57L, 83L, 31L, 90L, 100L, 35L, 82L, 
         24L, 111L, 85L, 78L, 47L, 66L, 140L, 38L, 84L, 142L, 103L, 120L, 114L, 36L, 67L, 
         43L, 129L, 59L, 39L, 131L, 102L, 92L, 60L, 112L, 149L, 89L, 53L, 51L, 123L, 81L, 
         147L, 26L, 77L, 10L, 97L, 33L, 62L, 130L, 87L, 137L, 25L, 74L, 88L, 45L, 65L, 
         93L, 117L, 3L, 79L, 125L, 106L, 105L, 110L, 108L, 6L, 46L, 132L, 104L, 124L, 
         9L, 7L, 116L, 146L)), test.inds = list(c(3L, 6L, 7L, 9L, 10L, 17L, 24L, 25L, 
         26L, 31L, 33L, 35L, 36L, 37L, 38L, 39L, 43L, 45L, 46L, 47L, 51L, 53L, 57L, 58L, 
         59L, 60L, 62L, 65L, 66L, 67L, 74L, 75L, 77L, 78L, 79L, 81L, 82L, 83L, 84L, 85L, 
         87L, 88L, 89L, 90L, 92L, 93L, 97L, 100L, 102L, 103L, 104L, 105L, 106L, 108L, 
         110L, 111L, 112L, 114L, 116L, 117L, 120L, 123L, 124L, 125L, 128L, 129L, 130L, 
         131L, 132L, 137L, 140L, 142L, 146L, 147L, 149L), c(1L, 2L, 4L, 5L, 8L, 11L, 12L, 
         13L, 14L, 15L, 16L, 18L, 19L, 20L, 21L, 22L, 23L, 27L, 28L, 29L, 30L, 32L, 34L, 
         40L, 41L, 42L, 44L, 48L, 49L, 50L, 52L, 54L, 55L, 56L, 61L, 63L, 64L, 68L, 69L, 
         70L, 71L, 72L, 73L, 76L, 80L, 86L, 91L, 94L, 95L, 96L, 98L, 99L, 101L, 107L, 
         109L, 113L, 115L, 118L, 119L, 121L, 122L, 126L, 127L, 133L, 134L, 135L, 136L, 
         138L, 139L, 141L, 143L, 144L, 145L, 148L, 150L)), group = structure(integer(0), .Label = character(0), class = "factor")), class = "ResampleInstance"), 
         weights = NULL, measures = list(structure(list(id = "mmce", minimize = TRUE, 
             properties = c("classif", "classif.multi", "req.pred", "req.truth"), fun = function (task, 
                 model, pred, feats, extra.args) 
             {
                 measureMMCE(pred$data$truth, pred$data$response)
             }, extra.args = list(), best = 0, worst = 1, name = "Mean misclassification error", 
             note = "Defined as: mean(response != truth)", aggr = structure(list(id = "test.mean", 
                 name = "Test mean", fun = function (task, perf.test, perf.train, measure, 
                     group, pred) 
                 mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure")), 
         model = TRUE, extract = function (model) 
         {
             NULL
         }, show.info = FALSE)
  9: calculateResampleIterationResult(learner = learner, task = task, i = i, train.i = train.i, 
         test.i = test.i, measures = measures, weights = weights, rdesc = rin$desc, model = model, 
         extract = extract, show.info = show.info)
  10: train(learner, task, subset = train.i, weights = weights[train.i])
  ...
  18: fun2(fun3(do.call(trainLearner, pars)))
  19: fun3(do.call(trainLearner, pars))
  20: do.call(trainLearner, pars)
  21: (function (.learner, .task, .subset, .weights = NULL, ...) 
     {
         UseMethod("trainLearner")
     })(.learner = structure(list(id = "classif.rpart.multiclass", type = "classif", package = "rpart", 
         properties = NULL, par.set = structure(list(pars = list(mcw.method = structure(list(
             id = "mcw.method", type = "untyped", len = 1L, lower = NULL, upper = NULL, 
             values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = "onevsrest", 
             trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param"))), forbidden = NULL), class = c("LearnerParamSet", "ParamSet")), par.vals = list(
             mcw.method = "onevsrest"), predict.type = "response", fix.factors.prediction = FALSE, 
         next.learner = structure(list(id = "classif.rpart", type = "classif", package = "rpart", 
             properties = c("twoclass", "multiclass", "missings", "numerics", "factors", 
             "ordered", "prob", "weights", "featimp"), par.set = structure(list(pars = list(
                 minsplit = structure(list(id = "minsplit", type = "integer", len = 1L, 
                     lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 20L, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), minbucket = structure(list(id = "minbucket", type = "integer", 
                     len = 1L, lower = 1L, upper = Inf, values = NULL, cnames = NULL, 
                     allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), cp = structure(list(id = "cp", type = "numeric", len = 1L, 
                     lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 0.01, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), maxcompete = structure(list(id = "maxcompete", type = "integer", 
                     len = 1L, lower = 0L, upper = Inf, values = NULL, cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = 4L, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), maxsurrogate = structure(list(id = "maxsurrogate", type = "integer", 
                     len = 1L, lower = 0L, upper = Inf, values = NULL, cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = 5L, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), usesurrogate = structure(list(id = "usesurrogate", type = "discrete", 
                     len = 1L, lower = NULL, upper = NULL, values = list(`0` = 0L, `1` = 1L, 
                       `2` = 2L), cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = 2L, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), surrogatestyle = structure(list(
                     id = "surrogatestyle", type = "discrete", len = 1L, lower = NULL, 
                     upper = NULL, values = list(`0` = 0L, `1` = 1L), cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 0L, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), maxdepth = structure(list(id = "maxdepth", type = "integer", 
                     len = 1L, lower = 1L, upper = 30L, values = NULL, cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = 30L, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), xval = structure(list(id = "xval", type = "integer", len = 1L, 
                     lower = 0L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 10L, trafo = NULL, requires = NULL, 
                     tunable = FALSE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), parms = structure(list(id = "parms", type = "untyped", len = 1L, 
                     lower = NULL, upper = NULL, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param"))), forbidden = NULL), class = c("LearnerParamSet", "ParamSet"
             )), par.vals = list(xval = 0L), predict.type = "response", name = "Decision Tree", 
             short.name = "rpart", note = "`xval` has been set to `0` by default for speed.", 
             callees = c("rpart", "rpart.control"), help.list = list(minsplit = "Argument of: rpart::rpart.control\n\nthe minimum number of observations that must exist in a node in order for a split to be attempted.", 
                 minbucket = "Argument of: rpart::rpart.control\n\nthe minimum number of observations in any terminal <leaf> node. If only one of minbucket or minsplit is specified, the code either sets minsplit to minbucket*3 or minbucket to minsplit/3, as appropriate.", 
                 cp = "Argument of: rpart::rpart.control\n\ncomplexity parameter.  Any split that does not decrease the overall lack of fit by a factor of cp is not attempted.  For instance, with anova splitting, this means that the overall R-squared must increase by cp at each step. The main role of this parameter is to save computing time by pruning off splits that are obviously not worthwhile. Essentially,the user informs the program that any split which does not improve the fit by cp will likely be pruned off by cross-validation, and that hence the program need not pursue it.", 
                 maxcompete = "Argument of: rpart::rpart.control\n\nthe number of competitor splits retained in the output.  It is useful to know not just which split was chosen, but which variable came in second, third, etc.", 
                 maxsurrogate = "Argument of: rpart::rpart.control\n\nthe number of surrogate splits retained in the output.  If this is set to zero the compute time will be reduced, since approximately half of the computational time (other than setup) is used in the search for surrogate splits.", 
                 usesurrogate = "Argument of: rpart::rpart.control\n\nhow to use surrogates in the splitting process.  0 means display only; an observation with a missing value for the primary split rule is not sent further down the tree.  1 means use surrogates, in order, to split subjects missing the primary variable; if all surrogates are missing the observation is not split.  For value 2 ,if all surrogates are missing, then send the observation in the majority direction.  A value of 0 corresponds to the action of tree, and 2 to the recommendations of Breiman et.al (1984).", 
                 xval = "Argument of: rpart::rpart.control\n\nnumber of cross-validations.", 
                 surrogatestyle = "Argument of: rpart::rpart.control\n\ncontrols the selection of a best surrogate. If set to 0 (default) the program uses the total number of correct classification for a potential surrogate variable, if set to 1 it uses the percent correct, calculated over the non-missing values of the surrogate. The first option more severely penalizes covariates with a large number of missing values.", 
                 maxdepth = "Argument of: rpart::rpart.control\n\nSet the maximum depth of any node of the final tree, with the root node counted as depth 0.  Values greater than  30 rpart will give nonsense results on 32-bit machines.", 
                 parms = "Argument of: rpart::rpart\n\noptional parameters for the splitting function. Anova splitting has no parameters. Poisson splitting has a single parameter, the coefficient of variation of the prior distribution on the rates.  The default value is 1. Exponential splitting has the same parameter as Poisson. For classification splitting, the list can contain any of: the vector of prior probabilities (component prior), the loss matrix (component loss) or the splitting index (component split).  The priors must be positive and sum to 1.  The loss matrix must have zeros on the diagonal and positive off-diagonal elements.  The splitting index can be gini or information.  The default priors are proportional to the data counts, the losses default to 1, and the split defaults to gini."), 
             config = list(), fix.factors.prediction = FALSE), class = c("classif.rpart", 
         "RLearnerClassif", "RLearner", "Learner")), model.subclass = c("MulticlassModel", 
         "HomogeneousEnsembleModel")), class = c("MulticlassWrapper", "HomogeneousEnsemble", 
     "BaseWrapper", "Learner")), .task = structure(list(type = "classif", env = <environment>, 
         weights = NULL, blocking = NULL, coordinates = NULL, task.desc = structure(list(
             id = "test", type = "classif", target = "Species", size = 75L, n.feat = c(numerics = 3L, 
             factors = 1L, ordered = 0L, functionals = 0L), has.missings = FALSE, has.weights = FALSE, 
             has.blocking = FALSE, has.coordinates = FALSE, class.levels = c("setosa", 
             "versicolor", "virginica"), positive = NA_character_, negative = NA_character_, 
             class.distribution = structure(c(setosa = 30L, versicolor = 22L, virginica = 23L
             ), .Dim = 3L, .Dimnames = list(c("setosa", "versicolor", "virginica")), class = "table")), class = c("ClassifTaskDesc", 
         "SupervisedTaskDesc", "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", 
     "Task")), .subset = NULL, xval = 0L, mcw.method = "onevsrest")
  22: trainLearner.MulticlassWrapper(.learner = structure(list(id = "classif.rpart.multiclass", 
         type = "classif", package = "rpart", properties = NULL, par.set = structure(list(
             pars = list(mcw.method = structure(list(id = "mcw.method", type = "untyped", 
                 len = 1L, lower = NULL, upper = NULL, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = "onevsrest", trafo = NULL, requires = NULL, 
                 tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param"))), forbidden = NULL), class = c("LearnerParamSet", "ParamSet")), 
         par.vals = list(mcw.method = "onevsrest"), predict.type = "response", fix.factors.prediction = FALSE, 
         next.learner = structure(list(id = "classif.rpart", type = "classif", package = "rpart", 
             properties = c("twoclass", "multiclass", "missings", "numerics", "factors", 
             "ordered", "prob", "weights", "featimp"), par.set = structure(list(pars = list(
                 minsplit = structure(list(id = "minsplit", type = "integer", len = 1L, 
                     lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 20L, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), minbucket = structure(list(id = "minbucket", type = "integer", 
                     len = 1L, lower = 1L, upper = Inf, values = NULL, cnames = NULL, 
                     allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), cp = structure(list(id = "cp", type = "numeric", len = 1L, 
                     lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 0.01, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), maxcompete = structure(list(id = "maxcompete", type = "integer", 
                     len = 1L, lower = 0L, upper = Inf, values = NULL, cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = 4L, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), maxsurrogate = structure(list(id = "maxsurrogate", type = "integer", 
                     len = 1L, lower = 0L, upper = Inf, values = NULL, cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = 5L, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), usesurrogate = structure(list(id = "usesurrogate", type = "discrete", 
                     len = 1L, lower = NULL, upper = NULL, values = list(`0` = 0L, `1` = 1L, 
                       `2` = 2L), cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = 2L, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), surrogatestyle = structure(list(
                     id = "surrogatestyle", type = "discrete", len = 1L, lower = NULL, 
                     upper = NULL, values = list(`0` = 0L, `1` = 1L), cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 0L, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), maxdepth = structure(list(id = "maxdepth", type = "integer", 
                     len = 1L, lower = 1L, upper = 30L, values = NULL, cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = 30L, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), xval = structure(list(id = "xval", type = "integer", len = 1L, 
                     lower = 0L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 10L, trafo = NULL, requires = NULL, 
                     tunable = FALSE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), parms = structure(list(id = "parms", type = "untyped", len = 1L, 
                     lower = NULL, upper = NULL, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param"))), forbidden = NULL), class = c("LearnerParamSet", "ParamSet"
             )), par.vals = list(xval = 0L), predict.type = "response", name = "Decision Tree", 
             short.name = "rpart", note = "`xval` has been set to `0` by default for speed.", 
             callees = c("rpart", "rpart.control"), help.list = list(minsplit = "Argument of: rpart::rpart.control\n\nthe minimum number of observations that must exist in a node in order for a split to be attempted.", 
                 minbucket = "Argument of: rpart::rpart.control\n\nthe minimum number of observations in any terminal <leaf> node. If only one of minbucket or minsplit is specified, the code either sets minsplit to minbucket*3 or minbucket to minsplit/3, as appropriate.", 
                 cp = "Argument of: rpart::rpart.control\n\ncomplexity parameter.  Any split that does not decrease the overall lack of fit by a factor of cp is not attempted.  For instance, with anova splitting, this means that the overall R-squared must increase by cp at each step. The main role of this parameter is to save computing time by pruning off splits that are obviously not worthwhile. Essentially,the user informs the program that any split which does not improve the fit by cp will likely be pruned off by cross-validation, and that hence the program need not pursue it.", 
                 maxcompete = "Argument of: rpart::rpart.control\n\nthe number of competitor splits retained in the output.  It is useful to know not just which split was chosen, but which variable came in second, third, etc.", 
                 maxsurrogate = "Argument of: rpart::rpart.control\n\nthe number of surrogate splits retained in the output.  If this is set to zero the compute time will be reduced, since approximately half of the computational time (other than setup) is used in the search for surrogate splits.", 
                 usesurrogate = "Argument of: rpart::rpart.control\n\nhow to use surrogates in the splitting process.  0 means display only; an observation with a missing value for the primary split rule is not sent further down the tree.  1 means use surrogates, in order, to split subjects missing the primary variable; if all surrogates are missing the observation is not split.  For value 2 ,if all surrogates are missing, then send the observation in the majority direction.  A value of 0 corresponds to the action of tree, and 2 to the recommendations of Breiman et.al (1984).", 
                 xval = "Argument of: rpart::rpart.control\n\nnumber of cross-validations.", 
                 surrogatestyle = "Argument of: rpart::rpart.control\n\ncontrols the selection of a best surrogate. If set to 0 (default) the program uses the total number of correct classification for a potential surrogate variable, if set to 1 it uses the percent correct, calculated over the non-missing values of the surrogate. The first option more severely penalizes covariates with a large number of missing values.", 
                 maxdepth = "Argument of: rpart::rpart.control\n\nSet the maximum depth of any node of the final tree, with the root node counted as depth 0.  Values greater than  30 rpart will give nonsense results on 32-bit machines.", 
                 parms = "Argument of: rpart::rpart\n\noptional parameters for the splitting function. Anova splitting has no parameters. Poisson splitting has a single parameter, the coefficient of variation of the prior distribution on the rates.  The default value is 1. Exponential splitting has the same parameter as Poisson. For classification splitting, the list can contain any of: the vector of prior probabilities (component prior), the loss matrix (component loss) or the splitting index (component split).  The priors must be positive and sum to 1.  The loss matrix must have zeros on the diagonal and positive off-diagonal elements.  The splitting index can be gini or information.  The default priors are proportional to the data counts, the losses default to 1, and the split defaults to gini."), 
             config = list(), fix.factors.prediction = FALSE), class = c("classif.rpart", 
         "RLearnerClassif", "RLearner", "Learner")), model.subclass = c("MulticlassModel", 
         "HomogeneousEnsembleModel")), class = c("MulticlassWrapper", "HomogeneousEnsemble", 
     "BaseWrapper", "Learner")), .task = structure(list(type = "classif", env = <environment>, 
         weights = NULL, blocking = NULL, coordinates = NULL, task.desc = structure(list(
             id = "test", type = "classif", target = "Species", size = 75L, n.feat = c(numerics = 3L, 
             factors = 1L, ordered = 0L, functionals = 0L), has.missings = FALSE, has.weights = FALSE, 
             has.blocking = FALSE, has.coordinates = FALSE, class.levels = c("setosa", 
             "versicolor", "virginica"), positive = NA_character_, negative = NA_character_, 
             class.distribution = structure(c(setosa = 30L, versicolor = 22L, virginica = 23L
             ), .Dim = 3L, .Dimnames = list(c("setosa", "versicolor", "virginica")), class = "table")), class = c("ClassifTaskDesc", 
         "SupervisedTaskDesc", "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", 
     "Task")), .subset = NULL, xval = 0L, mcw.method = "onevsrest")
  23: parallelMap(i = seq_along(x$row.inds), doMulticlassTrainIteration, more.args = args, 
         level = "mlr.ensemble")
  24: options(parallelMap.nextmap = (getPMOptNextMap() + 1L))
  25: getPMOptNextMap()
  26: getPMOption("nextmap")
  27: getOption(sprintf("parallelMap.%s", opt), def)
  
  ── 8. Error: NoFeaturesModel (@test_base_NoFeaturesModel.R#14)  ────────────────
  argument "def" is missing, with no default
  1: resample(lrn, task, res) at testthat/test_base_NoFeaturesModel.R:14
  2: parallelMap(doResampleIteration, seq_len(rin$desc$iters), level = "mlr.resample", 
         more.args = more.args)
  3: options(parallelMap.nextmap = (getPMOptNextMap() + 1L))
  4: getPMOptNextMap()
  5: getPMOption("nextmap")
  6: getOption(sprintf("parallelMap.%s", opt), def)
  
  ── 9. Error: TuneWrapper (@test_base_TuneWrapper.R#12)  ────────────────────────
  argument "def" is missing, with no default
  1: train(lrn2, task = multiclass.task) at testthat/test_base_TuneWrapper.R:12
  2: measureTime(fun1({
         learner.model = fun2(fun3(do.call(trainLearner, pars)))
     }))
  3: force(expr)
  4: fun1({
         learner.model = fun2(fun3(do.call(trainLearner, pars)))
     })
  5: fun2(fun3(do.call(trainLearner, pars)))
  6: fun3(do.call(trainLearner, pars))
  7: do.call(trainLearner, pars)
  8: (function (.learner, .task, .subset, .weights = NULL, ...) 
     {
         UseMethod("trainLearner")
     })(.learner = structure(list(id = "classif.ksvm.tuned", type = "classif", package = "kernlab", 
         properties = NULL, par.set = structure(list(pars = list(), forbidden = NULL), class = "ParamSet"), 
         par.vals = list(), predict.type = "response", fix.factors.prediction = FALSE, 
         next.learner = structure(list(id = "classif.ksvm", type = "classif", package = "kernlab", 
             properties = c("twoclass", "multiclass", "numerics", "factors", "prob", "class.weights"
             ), par.set = structure(list(pars = list(scaled = structure(list(id = "scaled", 
                 type = "logical", len = 1L, lower = NULL, upper = NULL, values = list(
                     `TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = TRUE, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), type = structure(list(id = "type", type = "discrete", len = 1L, lower = NULL, 
                 upper = NULL, values = list(`C-svc` = "C-svc", `nu-svc` = "nu-svc", `C-bsvc` = "C-bsvc", 
                     `spoc-svc` = "spoc-svc", `kbb-svc` = "kbb-svc"), cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = "C-svc", trafo = NULL, requires = NULL, 
                 tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), kernel = structure(list(id = "kernel", type = "discrete", len = 1L, 
                 lower = NULL, upper = NULL, values = list(vanilladot = "vanilladot", 
                     polydot = "polydot", rbfdot = "rbfdot", tanhdot = "tanhdot", laplacedot = "laplacedot", 
                     besseldot = "besseldot", anovadot = "anovadot", splinedot = "splinedot"), 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = "rbfdot", 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), C = structure(list(
                 id = "C", type = "numeric", len = 1L, lower = 0, upper = Inf, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 1, trafo = NULL, 
                 requires = type %in% c("C-svc", "C-bsvc", "spoc-svc", "kbb-svc"), tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), nu = structure(list(id = "nu", type = "numeric", len = 1L, lower = 0, 
                 upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 0.2, trafo = NULL, requires = type == "nu-svc", tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), epsilon = structure(list(id = "epsilon", type = "numeric", len = 1L, 
                 lower = -Inf, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 0.1, trafo = NULL, requires = type %in% 
                     c("eps-svr", "nu-svr", "eps-bsvm"), tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), sigma = structure(list(
                 id = "sigma", type = "numeric", len = 1L, lower = 0, upper = Inf, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, 
                 trafo = NULL, requires = kernel %in% c("rbfdot", "anovadot", "besseldot", 
                     "laplacedot"), tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), degree = structure(list(id = "degree", type = "integer", len = 1L, 
                 lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 3L, trafo = NULL, requires = kernel %in% 
                     c("polydot", "anovadot", "besseldot"), tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), scale = structure(list(
                 id = "scale", type = "numeric", len = 1L, lower = 0, upper = Inf, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 1, trafo = NULL, 
                 requires = kernel %in% c("polydot", "tanhdot"), tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), offset = structure(list(
                 id = "offset", type = "numeric", len = 1L, lower = -Inf, upper = Inf, 
                 values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 1, trafo = NULL, requires = kernel %in% c("polydot", "tanhdot"), 
                 tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), order = structure(list(id = "order", type = "integer", len = 1L, 
                 lower = -Inf, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 1L, trafo = NULL, requires = kernel == 
                     "besseldot", tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), tol = structure(list(id = "tol", type = "numeric", len = 1L, lower = 0, 
                 upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 0.001, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), shrinking = structure(list(
                 id = "shrinking", type = "logical", len = 1L, lower = NULL, upper = NULL, 
                 values = list(`TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = TRUE, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), class.weights = structure(list(id = "class.weights", type = "numericvector", 
                 len = NA_integer_, lower = 0, upper = Inf, values = NULL, cnames = NULL, 
                 allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, 
                 requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), fit = structure(list(id = "fit", type = "logical", len = 1L, lower = NULL, 
                 upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, 
                 allow.inf = FALSE, has.default = TRUE, default = TRUE, trafo = NULL, 
                 requires = NULL, tunable = FALSE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), cache = structure(list(id = "cache", type = "integer", len = 1L, 
                 lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 40L, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             ))), forbidden = NULL), class = c("LearnerParamSet", "ParamSet")), par.vals = list(
                 fit = FALSE), predict.type = "response", name = "Support Vector Machines", 
             short.name = "ksvm", note = "Kernel parameters have to be passed directly and not by using the `kpar` list in `ksvm`. Note that `fit` has been set to `FALSE` by default for speed.", 
             callees = "ksvm", help.list = list(sigma = "Argument of: kernlab::ksvm\n\nfor the ANOVA kernel \"anovadot\".", 
                 degree = "Argument of: kernlab::ksvm\n\nfor the ANOVA kernel \"anovadot\".", 
                 scale = "Argument of: kernlab::ksvm\n\nfor the Hyperbolic tangent kernel function \"tanhdot\"", 
                 offset = "Argument of: kernlab::ksvm\n\nfor the Hyperbolic tangent kernel function \"tanhdot\"", 
                 order = "Argument of: kernlab::ksvm\n\nfor the Bessel kernel \"besseldot\".", 
                 scaled = "Argument of: kernlab::ksvm\n\nA logical vector indicating the variables to be scaled. If scaled is of length 1, the value is recycled as many times as needed and all non-binary variables are scaled. Per default, data are scaled internally (both x and y variables) to zero mean and unit variance. The center and scale values are returned and used for later predictions.", 
                 type = "Argument of: kernlab::ksvm\n\nksvm can be used for classification , for regression, or for novelty detection. Depending on whether y is a factor or not, the default setting for type is C-svc or eps-svr, respectively, but can be overwritten by setting an explicit value. Valid options are:\n\nC-svc   C classification\n\nnu-svc  nu classification\n\nC-bsvc  bound-constraint svm classification\n\nspoc-svc  Crammer, Singer native multi-class\n\nkbb-svc  Weston, Watkins native multi-class\n\none-svc  novelty detection\n\neps-svr  epsilon regression\n\nnu-svr   nu regression\n\neps-bsvr  bound-constraint svm regression", 
                 kernel = "Argument of: kernlab::ksvm\n\nthe kernel function used in training and predicting. This parameter can be set to any function, of class kernel, which computes the inner product in feature space between two vector arguments (see kernels). kernlab provides the most popular kernel functions which can be used by setting the kernel parameter to the following strings:\n\nrbfdot Radial Basis kernel \"Gaussian\"\n\npolydot Polynomial kernel\n\nvanilladot Linear kernel\n\ntanhdot Hyperbolic tangent kernel\n\nlaplacedot Laplacian kernel\n\nbesseldot Bessel kernel\n\nanovadot ANOVA RBF kernel\n\nsplinedot Spline kernel\n\nstringdot String kernel\n\nSetting the kernel parameter to \"matrix\" treats x as a kernel matrix calling the kernelMatrix interface. The kernel parameter can also be set to a user defined function of class kernel by passing the function name as an argument.", 
                 C = "Argument of: kernlab::ksvm\n\ncost of constraints violation (default: 1) this is the ‘C’-constant of the regularization term in the Lagrange formulation.", 
                 nu = "Argument of: kernlab::ksvm\n\nparameter needed for nu-svc, one-svc, and nu-svr. The nu parameter sets the upper bound on the training error and the lower bound on the fraction of data points to become Support Vectors (default: 0.2).", 
                 epsilon = "Argument of: kernlab::ksvm\n\nepsilon in the insensitive-loss function used for eps-svr, nu-svr and eps-bsvm (default: 0.1)", 
                 class.weights = "Argument of: kernlab::ksvm\n\na named vector of weights for the different classes, used for asymmetric class sizes. Not all factor levels have to be supplied (default weight: 1). All components have to be named.", 
                 cache = "Argument of: kernlab::ksvm\n\ncache memory in MB (default 40)", 
                 tol = "Argument of: kernlab::ksvm\n\ntolerance of termination criterion (default: 0.001)", 
                 shrinking = "Argument of: kernlab::ksvm\n\noption whether to use the shrinking-heuristics (default: TRUE)", 
                 fit = "Argument of: kernlab::ksvm\n\nindicates whether the fitted values should be computed and included in the model or not (default: TRUE)"), 
             class.weights.param = "class.weights", config = list(), fix.factors.prediction = FALSE), class = c("classif.ksvm", 
         "RLearnerClassif", "RLearner", "Learner")), model.subclass = "TuneModel", resampling = structure(list(
             id = "cross-validation", iters = 2L, predict = "test", stratify = FALSE), class = c("CVDesc", 
         "ResampleDesc")), measures = list(structure(list(id = "mmce", minimize = TRUE, 
             properties = c("classif", "classif.multi", "req.pred", "req.truth"), fun = function (task, 
                 model, pred, feats, extra.args) 
             {
                 measureMMCE(pred$data$truth, pred$data$response)
             }, extra.args = list(), best = 0, worst = 1, name = "Mean misclassification error", 
             note = "Defined as: mean(response != truth)", aggr = structure(list(id = "test.mean", 
                 name = "Test mean", fun = function (task, perf.test, perf.train, measure, 
                     group, pred) 
                 mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure")), 
         opt.pars = structure(list(pars = list(C = structure(list(id = "C", type = "discrete", 
             len = 1L, lower = NULL, upper = NULL, values = list(`1` = 1, `1e-06` = 1e-06), 
             cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, 
             requires = NULL, tunable = TRUE, special.vals = list()), class = "Param")), 
             forbidden = NULL), class = "ParamSet"), bit.names = character(0), bits.to.features = function () 
         {
         }, control = structure(list(same.resampling.instance = TRUE, impute.val = NULL, 
             tune.threshold = FALSE, tune.threshold.args = list(), log.fun = function (learner, 
                 task, resampling, measures, par.set, control, opt.path, dob, x, y, remove.nas, 
                 stage, prev.stage) 
             {
                 x.string = paramValueToString(par.set, x, show.missing.values = !remove.nas)
                 if (inherits(learner, "ModelMultiplexer")) 
                     x.string = stri_replace_all(x.string, "", regex = stri_paste(x$selected.learner, 
                       "\\."))
                 logFunDefault(learner, task, resampling, measures, par.set, control, 
                     opt.path, dob, x.string, y, remove.nas, stage, prev.stage, prefixes = c("Tune-x", 
                       "Tune-y"))
             }, final.dw.perc = NULL, extra.args = list(resolution = 10L)), class = c("TuneControlGrid", 
         "TuneControl", "OptControl")), show.info = FALSE), class = c("TuneWrapper", "OptWrapper", 
     "BaseWrapper", "Learner")), .task = structure(list(type = "classif", env = <environment>, 
         weights = NULL, blocking = NULL, coordinates = NULL, task.desc = structure(list(
             id = "multiclass", type = "classif", target = "Species", size = 150L, n.feat = c(numerics = 4L, 
             factors = 0L, ordered = 0L, functionals = 0L), has.missings = FALSE, has.weights = FALSE, 
             has.blocking = FALSE, has.coordinates = FALSE, class.levels = c("setosa", 
             "versicolor", "virginica"), positive = NA_character_, negative = NA_character_, 
             class.distribution = structure(c(setosa = 50L, versicolor = 50L, virginica = 50L
             ), .Dim = 3L, .Dimnames = list(c("setosa", "versicolor", "virginica")), class = "table")), class = c("ClassifTaskDesc", 
         "SupervisedTaskDesc", "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", 
     "Task")), .subset = NULL, fit = FALSE)
  9: trainLearner.TuneWrapper(.learner = structure(list(id = "classif.ksvm.tuned", type = "classif", 
         package = "kernlab", properties = NULL, par.set = structure(list(pars = list(), 
             forbidden = NULL), class = "ParamSet"), par.vals = list(), predict.type = "response", 
         fix.factors.prediction = FALSE, next.learner = structure(list(id = "classif.ksvm", 
             type = "classif", package = "kernlab", properties = c("twoclass", "multiclass", 
             "numerics", "factors", "prob", "class.weights"), par.set = structure(list(
                 pars = list(scaled = structure(list(id = "scaled", type = "logical", 
                     len = 1L, lower = NULL, upper = NULL, values = list(`TRUE` = TRUE, 
                       `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = TRUE, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), type = structure(list(
                     id = "type", type = "discrete", len = 1L, lower = NULL, upper = NULL, 
                     values = list(`C-svc` = "C-svc", `nu-svc` = "nu-svc", `C-bsvc` = "C-bsvc", 
                       `spoc-svc` = "spoc-svc", `kbb-svc` = "kbb-svc"), cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = "C-svc", trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), kernel = structure(list(id = "kernel", type = "discrete", 
                     len = 1L, lower = NULL, upper = NULL, values = list(vanilladot = "vanilladot", 
                       polydot = "polydot", rbfdot = "rbfdot", tanhdot = "tanhdot", laplacedot = "laplacedot", 
                       besseldot = "besseldot", anovadot = "anovadot", splinedot = "splinedot"), 
                     cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = "rbfdot", 
                     trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), C = structure(list(
                     id = "C", type = "numeric", len = 1L, lower = 0, upper = Inf, values = NULL, 
                     cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 1, 
                     trafo = NULL, requires = type %in% c("C-svc", "C-bsvc", "spoc-svc", 
                       "kbb-svc"), tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), nu = structure(list(id = "nu", type = "numeric", len = 1L, 
                     lower = 0, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 0.2, trafo = NULL, requires = type == 
                       "nu-svc", tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), epsilon = structure(list(id = "epsilon", type = "numeric", 
                     len = 1L, lower = -Inf, upper = Inf, values = NULL, cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = 0.1, trafo = NULL, 
                     requires = type %in% c("eps-svr", "nu-svr", "eps-bsvm"), tunable = TRUE, 
                     special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), sigma = structure(list(id = "sigma", type = "numeric", len = 1L, 
                     lower = 0, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = FALSE, default = NULL, trafo = NULL, requires = kernel %in% 
                       c("rbfdot", "anovadot", "besseldot", "laplacedot"), tunable = TRUE, 
                     special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), degree = structure(list(id = "degree", type = "integer", len = 1L, 
                     lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 3L, trafo = NULL, requires = kernel %in% 
                       c("polydot", "anovadot", "besseldot"), tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), scale = structure(list(
                     id = "scale", type = "numeric", len = 1L, lower = 0, upper = Inf, 
                     values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = 1, trafo = NULL, requires = kernel %in% c("polydot", "tanhdot"), 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), offset = structure(list(id = "offset", type = "numeric", len = 1L, 
                     lower = -Inf, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 1, trafo = NULL, requires = kernel %in% 
                       c("polydot", "tanhdot"), tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), order = structure(list(
                     id = "order", type = "integer", len = 1L, lower = -Inf, upper = Inf, 
                     values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = 1L, trafo = NULL, requires = kernel == "besseldot", tunable = TRUE, 
                     special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), tol = structure(list(id = "tol", type = "numeric", len = 1L, 
                     lower = 0, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 0.001, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), shrinking = structure(list(id = "shrinking", type = "logical", 
                     len = 1L, lower = NULL, upper = NULL, values = list(`TRUE` = TRUE, 
                       `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = TRUE, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), class.weights = structure(list(
                     id = "class.weights", type = "numericvector", len = NA_integer_, 
                     lower = 0, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), fit = structure(list(id = "fit", type = "logical", len = 1L, 
                     lower = NULL, upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), 
                     cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = TRUE, 
                     trafo = NULL, requires = NULL, tunable = FALSE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), cache = structure(list(
                     id = "cache", type = "integer", len = 1L, lower = 1L, upper = Inf, 
                     values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = 40L, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param"))), forbidden = NULL), class = c("LearnerParamSet", 
             "ParamSet")), par.vals = list(fit = FALSE), predict.type = "response", name = "Support Vector Machines", 
             short.name = "ksvm", note = "Kernel parameters have to be passed directly and not by using the `kpar` list in `ksvm`. Note that `fit` has been set to `FALSE` by default for speed.", 
             callees = "ksvm", help.list = list(sigma = "Argument of: kernlab::ksvm\n\nfor the ANOVA kernel \"anovadot\".", 
                 degree = "Argument of: kernlab::ksvm\n\nfor the ANOVA kernel \"anovadot\".", 
                 scale = "Argument of: kernlab::ksvm\n\nfor the Hyperbolic tangent kernel function \"tanhdot\"", 
                 offset = "Argument of: kernlab::ksvm\n\nfor the Hyperbolic tangent kernel function \"tanhdot\"", 
                 order = "Argument of: kernlab::ksvm\n\nfor the Bessel kernel \"besseldot\".", 
                 scaled = "Argument of: kernlab::ksvm\n\nA logical vector indicating the variables to be scaled. If scaled is of length 1, the value is recycled as many times as needed and all non-binary variables are scaled. Per default, data are scaled internally (both x and y variables) to zero mean and unit variance. The center and scale values are returned and used for later predictions.", 
                 type = "Argument of: kernlab::ksvm\n\nksvm can be used for classification , for regression, or for novelty detection. Depending on whether y is a factor or not, the default setting for type is C-svc or eps-svr, respectively, but can be overwritten by setting an explicit value. Valid options are:\n\nC-svc   C classification\n\nnu-svc  nu classification\n\nC-bsvc  bound-constraint svm classification\n\nspoc-svc  Crammer, Singer native multi-class\n\nkbb-svc  Weston, Watkins native multi-class\n\none-svc  novelty detection\n\neps-svr  epsilon regression\n\nnu-svr   nu regression\n\neps-bsvr  bound-constraint svm regression", 
                 kernel = "Argument of: kernlab::ksvm\n\nthe kernel function used in training and predicting. This parameter can be set to any function, of class kernel, which computes the inner product in feature space between two vector arguments (see kernels). kernlab provides the most popular kernel functions which can be used by setting the kernel parameter to the following strings:\n\nrbfdot Radial Basis kernel \"Gaussian\"\n\npolydot Polynomial kernel\n\nvanilladot Linear kernel\n\ntanhdot Hyperbolic tangent kernel\n\nlaplacedot Laplacian kernel\n\nbesseldot Bessel kernel\n\nanovadot ANOVA RBF kernel\n\nsplinedot Spline kernel\n\nstringdot String kernel\n\nSetting the kernel parameter to \"matrix\" treats x as a kernel matrix calling the kernelMatrix interface. The kernel parameter can also be set to a user defined function of class kernel by passing the function name as an argument.", 
                 C = "Argument of: kernlab::ksvm\n\ncost of constraints violation (default: 1) this is the ‘C’-constant of the regularization term in the Lagrange formulation.", 
                 nu = "Argument of: kernlab::ksvm\n\nparameter needed for nu-svc, one-svc, and nu-svr. The nu parameter sets the upper bound on the training error and the lower bound on the fraction of data points to become Support Vectors (default: 0.2).", 
                 epsilon = "Argument of: kernlab::ksvm\n\nepsilon in the insensitive-loss function used for eps-svr, nu-svr and eps-bsvm (default: 0.1)", 
                 class.weights = "Argument of: kernlab::ksvm\n\na named vector of weights for the different classes, used for asymmetric class sizes. Not all factor levels have to be supplied (default weight: 1). All components have to be named.", 
                 cache = "Argument of: kernlab::ksvm\n\ncache memory in MB (default 40)", 
                 tol = "Argument of: kernlab::ksvm\n\ntolerance of termination criterion (default: 0.001)", 
                 shrinking = "Argument of: kernlab::ksvm\n\noption whether to use the shrinking-heuristics (default: TRUE)", 
                 fit = "Argument of: kernlab::ksvm\n\nindicates whether the fitted values should be computed and included in the model or not (default: TRUE)"), 
             class.weights.param = "class.weights", config = list(), fix.factors.prediction = FALSE), class = c("classif.ksvm", 
         "RLearnerClassif", "RLearner", "Learner")), model.subclass = "TuneModel", resampling = structure(list(
             id = "cross-validation", iters = 2L, predict = "test", stratify = FALSE), class = c("CVDesc", 
         "ResampleDesc")), measures = list(structure(list(id = "mmce", minimize = TRUE, 
             properties = c("classif", "classif.multi", "req.pred", "req.truth"), fun = function (task, 
                 model, pred, feats, extra.args) 
             {
                 measureMMCE(pred$data$truth, pred$data$response)
             }, extra.args = list(), best = 0, worst = 1, name = "Mean misclassification error", 
             note = "Defined as: mean(response != truth)", aggr = structure(list(id = "test.mean", 
                 name = "Test mean", fun = function (task, perf.test, perf.train, measure, 
                     group, pred) 
                 mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure")), 
         opt.pars = structure(list(pars = list(C = structure(list(id = "C", type = "discrete", 
             len = 1L, lower = NULL, upper = NULL, values = list(`1` = 1, `1e-06` = 1e-06), 
             cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, 
             requires = NULL, tunable = TRUE, special.vals = list()), class = "Param")), 
             forbidden = NULL), class = "ParamSet"), bit.names = character(0), bits.to.features = function () 
         {
         }, control = structure(list(same.resampling.instance = TRUE, impute.val = NULL, 
             tune.threshold = FALSE, tune.threshold.args = list(), log.fun = function (learner, 
                 task, resampling, measures, par.set, control, opt.path, dob, x, y, remove.nas, 
                 stage, prev.stage) 
             {
                 x.string = paramValueToString(par.set, x, show.missing.values = !remove.nas)
                 if (inherits(learner, "ModelMultiplexer")) 
                     x.string = stri_replace_all(x.string, "", regex = stri_paste(x$selected.learner, 
                       "\\."))
                 logFunDefault(learner, task, resampling, measures, par.set, control, 
                     opt.path, dob, x.string, y, remove.nas, stage, prev.stage, prefixes = c("Tune-x", 
                       "Tune-y"))
             }, final.dw.perc = NULL, extra.args = list(resolution = 10L)), class = c("TuneControlGrid", 
         "TuneControl", "OptControl")), show.info = FALSE), class = c("TuneWrapper", "OptWrapper", 
     "BaseWrapper", "Learner")), .task = structure(list(type = "classif", env = <environment>, 
         weights = NULL, blocking = NULL, coordinates = NULL, task.desc = structure(list(
             id = "multiclass", type = "classif", target = "Species", size = 150L, n.feat = c(numerics = 4L, 
             factors = 0L, ordered = 0L, functionals = 0L), has.missings = FALSE, has.weights = FALSE, 
             has.blocking = FALSE, has.coordinates = FALSE, class.levels = c("setosa", 
             "versicolor", "virginica"), positive = NA_character_, negative = NA_character_, 
             class.distribution = structure(c(setosa = 50L, versicolor = 50L, virginica = 50L
             ), .Dim = 3L, .Dimnames = list(c("setosa", "versicolor", "virginica")), class = "table")), class = c("ClassifTaskDesc", 
         "SupervisedTaskDesc", "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", 
     "Task")), .subset = NULL, fit = FALSE)
  10: tuneParams(.learner$next.learner, .task, .learner$resampling, .learner$measures, 
         .learner$opt.pars, .learner$control, .learner$show.info)
  ...
  15: mapply(fun2, ..., MoreArgs = more.args, SIMPLIFY = FALSE, USE.NAMES = FALSE)
  16: (function (learner, task, resampling, measures, par.set, bits.to.features, control, 
         opt.path, show.info, dob, state, remove.nas, resample.fun) 
     {
         setSlaveOptions()
         y = setNames(rep(NA_real_, length(measures)), vcapply(measures, measureAggrName))
         errmsg = NA_character_
         exec.time = NA_real_
         set.pars.ok = TRUE
         learner2 = learner
         threshold = NULL
         log.fun = control$log.fun
         err.dumps = list()
         if (inherits(control, "TuneControl") || inherits(control, "TuneMultiCritControl")) {
             state = setValueCNames(par.set, state)
             state = trafoValue(par.set, state)
             state2 = if (remove.nas) 
                 removeMissingValues(state)
             else state
             learner2 = try(setHyperPars(learner, par.vals = state2), silent = TRUE)
             if (is.error(learner2)) {
                 set.pars.ok = FALSE
                 errmsg = as.character(learner2)
                 if (show.info) 
                     messagef("[Tune-x] Setting hyperpars failed: %s", errmsg)
             }
         }
         else if (inherits(control, "FeatSelControl")) {
             task = subsetTask(task, features = bits.to.features(state, task))
         }
         if (show.info) 
             prev.stage = log.fun(learner, task, resampling, measures, par.set, control, 
                 opt.path, dob, state, NA_real_, remove.nas, stage = 1L)
         if (set.pars.ok) {
             exec.time = measureTime({
                 r = resample.fun(learner2, task, resampling, measures = measures, show.info = FALSE)
             })
             if (control$tune.threshold) {
                 th.args = control$tune.threshold.args
                 th.args$pred = r$pred
                 th.args$measure = measures[[1L]]
                 tune.th.res = do.call(tuneThreshold, th.args)
                 threshold = tune.th.res$th
                 y = performance(setThreshold(r$pred, threshold = threshold), measures = measures)
                 names(y) = names(r$aggr)
             }
             else {
                 y = r$aggr
             }
             errmsgs = as.character(t(r$err.msgs[, -1L]))
             notna = !is.na(errmsgs)
             if (any(notna)) 
                 errmsg = errmsgs[notna][1L]
             err.dumps = r$err.dumps
         }
         else {
             if (control$tune.threshold) 
                 threshold = NA_real_
         }
         if (show.info) 
             log.fun(learner, task, resampling, measures, par.set, control, opt.path, 
                 dob, state, y, remove.nas, stage = 2L, prev.stage = prev.stage)
         list(y = y, exec.time = exec.time, errmsg = errmsg, threshold = threshold, err.dumps = err.dumps)
     })(dots[[1L]][[1L]], dots[[2L]][[1L]], learner = structure(list(id = "classif.ksvm", 
         type = "classif", package = "kernlab", properties = c("twoclass", "multiclass", 
         "numerics", "factors", "prob", "class.weights"), par.set = structure(list(pars = list(
             scaled = structure(list(id = "scaled", type = "logical", len = 1L, lower = NULL, 
                 upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, 
                 allow.inf = FALSE, has.default = TRUE, default = TRUE, trafo = NULL, 
                 requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), type = structure(list(id = "type", type = "discrete", len = 1L, 
                 lower = NULL, upper = NULL, values = list(`C-svc` = "C-svc", `nu-svc` = "nu-svc", 
                     `C-bsvc` = "C-bsvc", `spoc-svc` = "spoc-svc", `kbb-svc` = "kbb-svc"), 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = "C-svc", 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), kernel = structure(list(
                 id = "kernel", type = "discrete", len = 1L, lower = NULL, upper = NULL, 
                 values = list(vanilladot = "vanilladot", polydot = "polydot", rbfdot = "rbfdot", 
                     tanhdot = "tanhdot", laplacedot = "laplacedot", besseldot = "besseldot", 
                     anovadot = "anovadot", splinedot = "splinedot"), cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = "rbfdot", trafo = NULL, requires = NULL, 
                 tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), C = structure(list(id = "C", type = "numeric", len = 1L, lower = 0, 
                 upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 1, trafo = NULL, requires = type %in% c("C-svc", "C-bsvc", 
                     "spoc-svc", "kbb-svc"), tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), nu = structure(list(id = "nu", type = "numeric", len = 1L, lower = 0, 
                 upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 0.2, trafo = NULL, requires = type == "nu-svc", tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), epsilon = structure(list(id = "epsilon", type = "numeric", len = 1L, 
                 lower = -Inf, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 0.1, trafo = NULL, requires = type %in% 
                     c("eps-svr", "nu-svr", "eps-bsvm"), tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), sigma = structure(list(
                 id = "sigma", type = "numeric", len = 1L, lower = 0, upper = Inf, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, 
                 trafo = NULL, requires = kernel %in% c("rbfdot", "anovadot", "besseldot", 
                     "laplacedot"), tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), degree = structure(list(id = "degree", type = "integer", len = 1L, 
                 lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 3L, trafo = NULL, requires = kernel %in% 
                     c("polydot", "anovadot", "besseldot"), tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), scale = structure(list(
                 id = "scale", type = "numeric", len = 1L, lower = 0, upper = Inf, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 1, trafo = NULL, 
                 requires = kernel %in% c("polydot", "tanhdot"), tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), offset = structure(list(
                 id = "offset", type = "numeric", len = 1L, lower = -Inf, upper = Inf, 
                 values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 1, trafo = NULL, requires = kernel %in% c("polydot", "tanhdot"), 
                 tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), order = structure(list(id = "order", type = "integer", len = 1L, 
                 lower = -Inf, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 1L, trafo = NULL, requires = kernel == 
                     "besseldot", tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), tol = structure(list(id = "tol", type = "numeric", len = 1L, lower = 0, 
                 upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 0.001, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), shrinking = structure(list(
                 id = "shrinking", type = "logical", len = 1L, lower = NULL, upper = NULL, 
                 values = list(`TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = TRUE, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), class.weights = structure(list(id = "class.weights", type = "numericvector", 
                 len = NA_integer_, lower = 0, upper = Inf, values = NULL, cnames = NULL, 
                 allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, 
                 requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), fit = structure(list(id = "fit", type = "logical", len = 1L, lower = NULL, 
                 upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, 
                 allow.inf = FALSE, has.default = TRUE, default = TRUE, trafo = NULL, 
                 requires = NULL, tunable = FALSE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), cache = structure(list(id = "cache", type = "integer", len = 1L, 
                 lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 40L, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             ))), forbidden = NULL), class = c("LearnerParamSet", "ParamSet")), par.vals = list(
             fit = FALSE), predict.type = "response", name = "Support Vector Machines", 
         short.name = "ksvm", note = "Kernel parameters have to be passed directly and not by using the `kpar` list in `ksvm`. Note that `fit` has been set to `FALSE` by default for speed.", 
         callees = "ksvm", help.list = list(sigma = "Argument of: kernlab::ksvm\n\nfor the ANOVA kernel \"anovadot\".", 
             degree = "Argument of: kernlab::ksvm\n\nfor the ANOVA kernel \"anovadot\".", 
             scale = "Argument of: kernlab::ksvm\n\nfor the Hyperbolic tangent kernel function \"tanhdot\"", 
             offset = "Argument of: kernlab::ksvm\n\nfor the Hyperbolic tangent kernel function \"tanhdot\"", 
             order = "Argument of: kernlab::ksvm\n\nfor the Bessel kernel \"besseldot\".", 
             scaled = "Argument of: kernlab::ksvm\n\nA logical vector indicating the variables to be scaled. If scaled is of length 1, the value is recycled as many times as needed and all non-binary variables are scaled. Per default, data are scaled internally (both x and y variables) to zero mean and unit variance. The center and scale values are returned and used for later predictions.", 
             type = "Argument of: kernlab::ksvm\n\nksvm can be used for classification , for regression, or for novelty detection. Depending on whether y is a factor or not, the default setting for type is C-svc or eps-svr, respectively, but can be overwritten by setting an explicit value. Valid options are:\n\nC-svc   C classification\n\nnu-svc  nu classification\n\nC-bsvc  bound-constraint svm classification\n\nspoc-svc  Crammer, Singer native multi-class\n\nkbb-svc  Weston, Watkins native multi-class\n\none-svc  novelty detection\n\neps-svr  epsilon regression\n\nnu-svr   nu regression\n\neps-bsvr  bound-constraint svm regression", 
             kernel = "Argument of: kernlab::ksvm\n\nthe kernel function used in training and predicting. This parameter can be set to any function, of class kernel, which computes the inner product in feature space between two vector arguments (see kernels). kernlab provides the most popular kernel functions which can be used by setting the kernel parameter to the following strings:\n\nrbfdot Radial Basis kernel \"Gaussian\"\n\npolydot Polynomial kernel\n\nvanilladot Linear kernel\n\ntanhdot Hyperbolic tangent kernel\n\nlaplacedot Laplacian kernel\n\nbesseldot Bessel kernel\n\nanovadot ANOVA RBF kernel\n\nsplinedot Spline kernel\n\nstringdot String kernel\n\nSetting the kernel parameter to \"matrix\" treats x as a kernel matrix calling the kernelMatrix interface. The kernel parameter can also be set to a user defined function of class kernel by passing the function name as an argument.", 
             C = "Argument of: kernlab::ksvm\n\ncost of constraints violation (default: 1) this is the ‘C’-constant of the regularization term in the Lagrange formulation.", 
             nu = "Argument of: kernlab::ksvm\n\nparameter needed for nu-svc, one-svc, and nu-svr. The nu parameter sets the upper bound on the training error and the lower bound on the fraction of data points to become Support Vectors (default: 0.2).", 
             epsilon = "Argument of: kernlab::ksvm\n\nepsilon in the insensitive-loss function used for eps-svr, nu-svr and eps-bsvm (default: 0.1)", 
             class.weights = "Argument of: kernlab::ksvm\n\na named vector of weights for the different classes, used for asymmetric class sizes. Not all factor levels have to be supplied (default weight: 1). All components have to be named.", 
             cache = "Argument of: kernlab::ksvm\n\ncache memory in MB (default 40)", 
             tol = "Argument of: kernlab::ksvm\n\ntolerance of termination criterion (default: 0.001)", 
             shrinking = "Argument of: kernlab::ksvm\n\noption whether to use the shrinking-heuristics (default: TRUE)", 
             fit = "Argument of: kernlab::ksvm\n\nindicates whether the fitted values should be computed and included in the model or not (default: TRUE)"), 
         class.weights.param = "class.weights", config = list(), fix.factors.prediction = FALSE), class = c("classif.ksvm", 
     "RLearnerClassif", "RLearner", "Learner")), task = structure(list(type = "classif", 
         env = <environment>, weights = NULL, blocking = NULL, coordinates = NULL, task.desc = structure(list(
             id = "multiclass", type = "classif", target = "Species", size = 150L, n.feat = c(numerics = 4L, 
             factors = 0L, ordered = 0L, functionals = 0L), has.missings = FALSE, has.weights = FALSE, 
             has.blocking = FALSE, has.coordinates = FALSE, class.levels = c("setosa", 
             "versicolor", "virginica"), positive = NA_character_, negative = NA_character_, 
             class.distribution = structure(c(setosa = 50L, versicolor = 50L, virginica = 50L
             ), .Dim = 3L, .Dimnames = list(c("setosa", "versicolor", "virginica")), class = "table")), class = c("ClassifTaskDesc", 
         "SupervisedTaskDesc", "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", 
     "Task")), resampling = structure(list(desc = structure(list(id = "cross-validation", 
         iters = 2L, predict = "test", stratify = FALSE), class = c("CVDesc", "ResampleDesc"
     )), size = 150L, train.inds = list(c(32L, 64L, 71L, 50L, 52L, 49L, 73L, 30L, 55L, 
     95L, 107L, 101L, 143L, 69L, 56L, 141L, 122L, 134L, 136L, 68L, 16L, 148L, 96L, 139L, 
     118L, 27L, 44L, 23L, 20L, 98L, 5L, 133L, 34L, 76L, 145L, 86L, 127L, 109L, 41L, 138L, 
     4L, 18L, 13L, 40L, 121L, 22L, 72L, 119L, 113L, 11L, 29L, 61L, 8L, 115L, 63L, 94L, 
     135L, 19L, 21L, 12L, 144L, 1L, 91L, 99L, 2L, 14L, 28L, 70L, 48L, 42L, 126L, 15L, 
     80L, 150L, 54L), c(128L, 75L, 58L, 37L, 17L, 57L, 83L, 31L, 90L, 100L, 35L, 82L, 
     24L, 111L, 85L, 78L, 47L, 66L, 140L, 38L, 84L, 142L, 103L, 120L, 114L, 36L, 67L, 
     43L, 129L, 59L, 39L, 131L, 102L, 92L, 60L, 112L, 149L, 89L, 53L, 51L, 123L, 81L, 
     147L, 26L, 77L, 10L, 97L, 33L, 62L, 130L, 87L, 137L, 25L, 74L, 88L, 45L, 65L, 93L, 
     117L, 3L, 79L, 125L, 106L, 105L, 110L, 108L, 6L, 46L, 132L, 104L, 124L, 9L, 7L, 116L, 
     146L)), test.inds = list(c(3L, 6L, 7L, 9L, 10L, 17L, 24L, 25L, 26L, 31L, 33L, 35L, 
     36L, 37L, 38L, 39L, 43L, 45L, 46L, 47L, 51L, 53L, 57L, 58L, 59L, 60L, 62L, 65L, 66L, 
     67L, 74L, 75L, 77L, 78L, 79L, 81L, 82L, 83L, 84L, 85L, 87L, 88L, 89L, 90L, 92L, 93L, 
     97L, 100L, 102L, 103L, 104L, 105L, 106L, 108L, 110L, 111L, 112L, 114L, 116L, 117L, 
     120L, 123L, 124L, 125L, 128L, 129L, 130L, 131L, 132L, 137L, 140L, 142L, 146L, 147L, 
     149L), c(1L, 2L, 4L, 5L, 8L, 11L, 12L, 13L, 14L, 15L, 16L, 18L, 19L, 20L, 21L, 22L, 
     23L, 27L, 28L, 29L, 30L, 32L, 34L, 40L, 41L, 42L, 44L, 48L, 49L, 50L, 52L, 54L, 55L, 
     56L, 61L, 63L, 64L, 68L, 69L, 70L, 71L, 72L, 73L, 76L, 80L, 86L, 91L, 94L, 95L, 96L, 
     98L, 99L, 101L, 107L, 109L, 113L, 115L, 118L, 119L, 121L, 122L, 126L, 127L, 133L, 
     134L, 135L, 136L, 138L, 139L, 141L, 143L, 144L, 145L, 148L, 150L)), group = structure(integer(0), .Label = character(0), class = "factor")), class = "ResampleInstance"), 
         measures = list(structure(list(id = "mmce", minimize = TRUE, properties = c("classif", 
         "classif.multi", "req.pred", "req.truth"), fun = function (task, model, pred, 
             feats, extra.args) 
         {
             measureMMCE(pred$data$truth, pred$data$response)
         }, extra.args = list(), best = 0, worst = 1, name = "Mean misclassification error", 
             note = "Defined as: mean(response != truth)", aggr = structure(list(id = "test.mean", 
                 name = "Test mean", fun = function (task, perf.test, perf.train, measure, 
                     group, pred) 
                 mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure")), 
         par.set = structure(list(pars = list(C = structure(list(id = "C", type = "discrete", 
             len = 1L, lower = NULL, upper = NULL, values = list(`1` = 1, `1e-06` = 1e-06), 
             cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, 
             requires = NULL, tunable = TRUE, special.vals = list()), class = "Param")), 
             forbidden = NULL), class = "ParamSet"), bits.to.features = NULL, control = structure(list(
             same.resampling.instance = TRUE, impute.val = 1, tune.threshold = FALSE, 
             tune.threshold.args = list(), log.fun = function (learner, task, resampling, 
                 measures, par.set, control, opt.path, dob, x, y, remove.nas, stage, prev.stage) 
             {
                 x.string = paramValueToString(par.set, x, show.missing.values = !remove.nas)
                 if (inherits(learner, "ModelMultiplexer")) 
                     x.string = stri_replace_all(x.string, "", regex = stri_paste(x$selected.learner, 
                       "\\."))
                 logFunDefault(learner, task, resampling, measures, par.set, control, 
                     opt.path, dob, x.string, y, remove.nas, stage, prev.stage, prefixes = c("Tune-x", 
                       "Tune-y"))
             }, final.dw.perc = NULL, extra.args = list(resolution = 10L)), class = c("TuneControlGrid", 
         "TuneControl", "OptControl")), opt.path = structure(list(par.set = structure(list(
             pars = list(C = structure(list(id = "C", type = "discrete", len = 1L, lower = NULL, 
                 upper = NULL, values = list(`1` = 1, `1e-06` = 1e-06), cnames = NULL, 
                 allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, 
                 requires = NULL, tunable = TRUE, special.vals = list()), class = "Param")), 
             forbidden = NULL), class = "ParamSet"), y.names = "mmce.test.mean", minimize = c(mmce.test.mean = TRUE), 
             add.transformed.x = FALSE, env = <environment>), class = c("OptPathDF", "OptPath"
         )), show.info = FALSE, remove.nas = TRUE, resample.fun = function (learner, task, 
             resampling, measures, weights = NULL, models = FALSE, extract, keep.pred = TRUE, 
             ..., show.info = getMlrOption("show.info")) 
         {
             learner = checkLearner(learner)
             learner = setHyperPars(learner, ...)
             assertClass(task, classes = "Task")
             n = getTaskSize(task)
             if (inherits(resampling, "ResampleDesc")) 
                 resampling = makeResampleInstance(resampling, task = task)
             assertClass(resampling, classes = "ResampleInstance")
             measures = checkMeasures(measures, task)
             if (!is.null(weights)) {
                 assertNumeric(weights, len = n, any.missing = FALSE, lower = 0)
             }
             assertFlag(models)
             if (missing(extract)) 
                 extract = function(model) {
                 }
             else assertFunction(extract)
             assertFlag(show.info)
             r = resampling$size
             if (n != r) 
                 stop(stri_paste("Size of data set:", n, "and resampling instance:", r, 
                     "differ!", sep = " "))
             checkLearnerBeforeTrain(task, learner, weights)
             checkAggrsBeforeResample(measures, resampling$desc)
             rin = resampling
             more.args = list(learner = learner, task = task, rin = rin, weights = NULL, 
                 measures = measures, model = models, extract = extract, show.info = show.info)
             if (!is.null(weights)) {
                 more.args$weights = weights
             }
             else if (!is.null(getTaskWeights(task))) {
                 more.args$weights = getTaskWeights(task)
             }
             parallelLibrary("mlr", master = FALSE, level = "mlr.resample", show.info = FALSE)
             exportMlrOptions(level = "mlr.resample")
             if (show.info) {
                 messagef("Resampling: %s", rin$desc$id)
                 measure.lognames = extractSubList(measures, "id")
                 if (rin$desc$predict == "both") {
                     id.train = which(vlapply(measures, function(x) "req.train" %in% x$aggr$properties))
                     id.test = which(vlapply(measures, function(x) "req.test" %in% x$aggr$properties))
                     measure.lognames = c(stri_paste(measure.lognames[id.train], "train", 
                       sep = "."), stri_paste(measure.lognames[id.test], "test", sep = "."))
                 }
                 printResampleFormatLine("Measures:", measure.lognames)
             }
             time1 = Sys.time()
             iter.results = parallelMap(doResampleIteration, seq_len(rin$desc$iters), 
                 level = "mlr.resample", more.args = more.args)
             time2 = Sys.time()
             runtime = as.numeric(difftime(time2, time1, units = "secs"))
             addClasses(mergeResampleResult(learner$id, task, iter.results, measures, 
                 rin, models, extract, keep.pred, show.info, runtime), "ResampleResult")
         })
  17: measureTime({
         r = resample.fun(learner2, task, resampling, measures = measures, show.info = FALSE)
     })
  18: force(expr)
  19: resample.fun(learner2, task, resampling, measures = measures, show.info = FALSE)
  20: parallelMap(doResampleIteration, seq_len(rin$desc$iters), level = "mlr.resample", 
         more.args = more.args)
  21: options(parallelMap.nextmap = (getPMOptNextMap() + 1L))
  22: getPMOptNextMap()
  23: getPMOption("nextmap")
  24: getOption(sprintf("parallelMap.%s", opt), def)
  
  ── 10. Error: TuneWrapper passed predict hyper pars correctly to base learner (@
  argument "def" is missing, with no default
  1: resample(tw, binaryclass.task, rdesc) at testthat/test_base_TuneWrapper.R:51
  2: parallelMap(doResampleIteration, seq_len(rin$desc$iters), level = "mlr.resample", 
         more.args = more.args)
  3: mapply(fun2, ..., MoreArgs = more.args, SIMPLIFY = FALSE, USE.NAMES = FALSE)
  4: (function (learner, task, rin, i, measures, weights, model, extract, show.info) 
     {
         setSlaveOptions()
         train.i = rin$train.inds[[i]]
         test.i = rin$test.inds[[i]]
         calculateResampleIterationResult(learner = learner, task = task, i = i, train.i = train.i, 
             test.i = test.i, measures = measures, weights = weights, rdesc = rin$desc, 
             model = model, extract = extract, show.info = show.info)
     })(dots[[1L]][[1L]], learner = structure(list(id = "classif.glmnet.tuned", type = "classif", 
         package = "glmnet", properties = NULL, par.set = structure(list(pars = list(), 
             forbidden = NULL), class = "ParamSet"), par.vals = list(), predict.type = "prob", 
         fix.factors.prediction = FALSE, next.learner = structure(list(id = "classif.glmnet", 
             type = "classif", package = "glmnet", properties = c("numerics", "factors", 
             "prob", "twoclass", "multiclass", "weights"), par.set = structure(list(pars = list(
                 alpha = structure(list(id = "alpha", type = "numeric", len = 1L, lower = 0, 
                     upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = 1, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), s = structure(list(
                     id = "s", type = "numeric", len = 1L, lower = 0, upper = Inf, values = NULL, 
                     cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, 
                     trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "predict"), class = c("LearnerParam", "Param")), exact = structure(list(
                     id = "exact", type = "logical", len = 1L, lower = NULL, upper = NULL, 
                     values = list(`TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = FALSE, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "predict"), class = c("LearnerParam", 
                 "Param")), nlambda = structure(list(id = "nlambda", type = "integer", 
                     len = 1L, lower = 1L, upper = Inf, values = NULL, cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = 100L, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), lambda.min.ratio = structure(list(id = "lambda.min.ratio", 
                     type = "numeric", len = 1L, lower = 0, upper = 1, values = NULL, 
                     cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, 
                     trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), lambda = structure(list(
                     id = "lambda", type = "numericvector", len = NA_integer_, lower = 0, 
                     upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                     default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), standardize = structure(list(
                     id = "standardize", type = "logical", len = 1L, lower = NULL, upper = NULL, 
                     values = list(`TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = TRUE, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), intercept = structure(list(id = "intercept", type = "logical", 
                     len = 1L, lower = NULL, upper = NULL, values = list(`TRUE` = TRUE, 
                       `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = TRUE, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), thresh = structure(list(
                     id = "thresh", type = "numeric", len = 1L, lower = 0, upper = Inf, 
                     values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = 1e-07, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), dfmax = structure(list(
                     id = "dfmax", type = "integer", len = 1L, lower = 0L, upper = Inf, 
                     values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                     default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), pmax = structure(list(
                     id = "pmax", type = "integer", len = 1L, lower = 0L, upper = Inf, 
                     values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                     default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), exclude = structure(list(
                     id = "exclude", type = "integervector", len = NA_integer_, lower = 1L, 
                     upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                     default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), penalty.factor = structure(list(
                     id = "penalty.factor", type = "numericvector", len = NA_integer_, 
                     lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), lower.limits = structure(list(id = "lower.limits", type = "numericvector", 
                     len = NA_integer_, lower = -Inf, upper = 0, values = NULL, cnames = NULL, 
                     allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), upper.limits = structure(list(id = "upper.limits", type = "numericvector", 
                     len = NA_integer_, lower = 0, upper = Inf, values = NULL, cnames = NULL, 
                     allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), maxit = structure(list(id = "maxit", type = "integer", len = 1L, 
                     lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 100000L, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), type.logistic = structure(list(id = "type.logistic", type = "discrete", 
                     len = 1L, lower = NULL, upper = NULL, values = list(Newton = "Newton", 
                       modified.Newton = "modified.Newton"), cnames = NULL, allow.inf = FALSE, 
                     has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), type.multinomial = structure(list(id = "type.multinomial", 
                     type = "discrete", len = 1L, lower = NULL, upper = NULL, values = list(
                       ungrouped = "ungrouped", grouped = "grouped"), cnames = NULL, allow.inf = FALSE, 
                     has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), fdev = structure(list(id = "fdev", type = "numeric", len = 1L, 
                     lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 1e-05, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), devmax = structure(list(id = "devmax", type = "numeric", len = 1L, 
                     lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 0.999, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), eps = structure(list(id = "eps", type = "numeric", len = 1L, 
                     lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 1e-06, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), big = structure(list(id = "big", type = "numeric", len = 1L, 
                     lower = -Inf, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 9.9e+35, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), mnlam = structure(list(id = "mnlam", type = "integer", len = 1L, 
                     lower = 1, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 5, trafo = NULL, requires = NULL, tunable = TRUE, 
                     special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), pmin = structure(list(id = "pmin", type = "numeric", len = 1L, 
                     lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 1e-09, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), exmx = structure(list(id = "exmx", type = "numeric", len = 1L, 
                     lower = -Inf, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 250, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), prec = structure(list(id = "prec", type = "numeric", len = 1L, 
                     lower = -Inf, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 1e-10, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), mxit = structure(list(id = "mxit", type = "integer", len = 1L, 
                     lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 100L, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param"))), forbidden = NULL), class = c("LearnerParamSet", "ParamSet"
             )), par.vals = list(s = 0.01), predict.type = "prob", name = "GLM with Lasso or Elasticnet Regularization", 
             short.name = "glmnet", note = "The family parameter is set to `binomial` for two-class problems and to `multinomial` otherwise.\n      Factors automatically get converted to dummy columns, ordered factors to integer.\n      Parameter `s` (value of the regularization parameter used for predictions) is set to `0.1` by default,\n      but needs to be tuned by the user.\n      glmnet uses a global control object for its parameters. mlr resets all control parameters to their defaults\n      before setting the specified parameters and after training.\n      If you are setting glmnet.control parameters through glmnet.control,\n      you need to save and re-set them after running the glmnet learner.", 
             callees = c("glmnet", "glmnet.control", "predict.glmnet"), help.list = list(
                 s = "Argument of: glmnet::predict.glmnet\n\nValue(s) of the penalty parameter lambda at which predictions are required. Default is the entire sequence used to create the model.", 
                 exact = "Argument of: glmnet::predict.glmnet\n\nThis argument is relevant only when predictions are made at values of s (lambda) different from those used in the fitting of the original model. If exact=FALSE (default), then the predict function uses linear interpolation to make predictions for values of s (lambda) that do not coincide with those used in the fitting algorithm. While this is often a good approximation, it can sometimes be a bit coarse. With exact=TRUE, these different values of s are merged (and sorted) with object$lambda, and the model is refit before predictions are made. In this case, it is required to supply the original data x= and y= as additional named  arguments to predict() or coef(). The workhorse predict.glmnet() needs to  update the model, and so needs the data used to create it. The same is true of weights, offset, penalty.factor, lower.limits, upper.limits if these were used in the original call. Failure to do so will result in an error.", 
                 fdev = "Argument of: glmnet::glmnet.control\n\nminimum fractional change in deviance for stopping path; factory default = 1.0e-5", 
                 devmax = "Argument of: glmnet::glmnet.control\n\nmaximum fraction of explained deviance for stopping path; factory default = 0.999", 
                 eps = "Argument of: glmnet::glmnet.control\n\nminimum value of lambda.min.ratio (see glmnet); factory default= 1.0e-6", 
                 big = "Argument of: glmnet::glmnet.control\n\nlarge floating point number; factory default = 9.9e35. Inf in definition of upper.limit is set to big", 
                 mnlam = "Argument of: glmnet::glmnet.control\n\nminimum number of path points (lambda values) allowed; factory default = 5", 
                 pmin = "Argument of: glmnet::glmnet.control\n\nminimum probability for any class. factory default = 1.0e-9. Note that this implies a pmax of 1-pmin.", 
                 exmx = "Argument of: glmnet::glmnet.control\n\nmaximum allowed exponent. factory default = 250.0", 
                 prec = "Argument of: glmnet::glmnet.control\n\nconvergence threshold for multi response bounds adjustment solution. factory default = 1.0e-10", 
                 mxit = "Argument of: glmnet::glmnet.control\n\nmaximum iterations for multiresponse bounds adjustment solution.  factory default = 100", 
                 alpha = "Argument of: glmnet::glmnet\n\nThe elasticnet mixing parameter, with 0≤α≤ 1. The penalty is defined as (1-α)/2||β||_2^2+α||β||_1. alpha=1 is the lasso penalty, and alpha=0 the ridge penalty.", 
                 nlambda = "Argument of: glmnet::glmnet\n\nThe number of lambda values - default is 100.", 
                 lambda.min.ratio = "Argument of: glmnet::glmnet\n\nSmallest value for lambda, as a fraction of lambda.max, the (data derived) entry value (i.e. the smallest value for which all coefficients are zero). The default depends on the sample size nobs relative to the number of variables nvars. If nobs > nvars, the default is 0.0001, close to zero.  If nobs < nvars, the default is 0.01. A very small value of lambda.min.ratio will lead to a saturated fit in the nobs < nvars case. This is undefined for \"binomial\" and \"multinomial\" models, and glmnet will exit gracefully when the percentage deviance explained is almost 1.", 
                 lambda = "Argument of: glmnet::glmnet\n\nA user supplied lambda sequence. Typical usage is to have the program compute its own lambda sequence based on nlambda and lambda.min.ratio. Supplying a value of lambda overrides this. WARNING: use with care. Avoid supplying a single value for lambda (for predictions after CV use predict() instead).  Supply instead a decreasing sequence of lambda values. glmnet relies on its warms starts for speed, and its often faster to fit a whole path than compute a single fit.", 
                 standardize = "Argument of: glmnet::glmnet\n\nLogical flag for x variable standardization, prior to fitting the model sequence. The coefficients are always returned on the original scale. Default is standardize=TRUE. If variables are in the same units already, you might not wish to standardize. See details below for y standardization with family=\"gaussian\".", 
                 intercept = "Argument of: glmnet::glmnet\n\nShould intercept(s) be fitted (default=TRUE) or set to zero (FALSE)", 
                 thresh = "Argument of: glmnet::glmnet\n\nConvergence threshold for coordinate descent. Each inner coordinate-descent loop continues until the maximum change in the objective after any coefficient update is less than thresh times the null deviance. Defaults value is 1E-7.", 
                 dfmax = "Argument of: glmnet::glmnet\n\nLimit the maximum number of variables in the model. Useful for very large nvars, if a partial path is desired.", 
                 pmax = "Argument of: glmnet::glmnet\n\nLimit the maximum number of variables ever to be nonzero", 
                 exclude = "Argument of: glmnet::glmnet\n\nIndices of variables to be excluded from the model. Default is none. Equivalent to an infinite penalty factor (next item).", 
                 penalty.factor = "Argument of: glmnet::glmnet\n\nSeparate penalty factors can be applied to each coefficient. This is a number that multiplies lambda to allow differential shrinkage. Can be 0 for some variables, which implies no shrinkage, and that variable is always included in the model. Default is 1 for all variables (and implicitly infinity for variables listed in exclude). Note: the penalty factors are internally rescaled to sum to nvars, and the lambda sequence will reflect this change.", 
                 lower.limits = "Argument of: glmnet::glmnet\n\nVector of lower limits for each coefficient; default -Inf. Each of these must be non-positive. Can be presented as a single value (which will then be replicated), else a vector of length nvars", 
                 upper.limits = "Argument of: glmnet::glmnet\n\nVector of upper limits for each coefficient; default Inf. See lower.limits", 
                 maxit = "Argument of: glmnet::glmnet\n\nMaximum number of passes over the data for all lambda values; default is 10^5.", 
                 type.logistic = "Argument of: glmnet::glmnet\n\nIf \"Newton\" then the exact hessian is used (default), while \"modified.Newton\" uses an upper-bound on the hessian, and can be faster.", 
                 type.multinomial = "Argument of: glmnet::glmnet\n\nIf \"grouped\" then a grouped lasso penalty is used on the multinomial coefficients for a variable. This ensures they are all in our out together. The default is \"ungrouped\""), 
             config = list(), fix.factors.prediction = FALSE), class = c("classif.glmnet", 
         "RLearnerClassif", "RLearner", "Learner")), model.subclass = "TuneModel", resampling = structure(list(
             split = 0.3, id = "holdout", iters = 1L, predict = "test", stratify = FALSE), class = c("HoldoutDesc", 
         "ResampleDesc")), measures = list(structure(list(id = "mmce", minimize = TRUE, 
             properties = c("classif", "classif.multi", "req.pred", "req.truth"), fun = function (task, 
                 model, pred, feats, extra.args) 
             {
                 measureMMCE(pred$data$truth, pred$data$response)
             }, extra.args = list(), best = 0, worst = 1, name = "Mean misclassification error", 
             note = "Defined as: mean(response != truth)", aggr = structure(list(id = "test.mean", 
                 name = "Test mean", fun = function (task, perf.test, perf.train, measure, 
                     group, pred) 
                 mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure")), 
         opt.pars = structure(list(pars = list(s = structure(list(id = "s", type = "numeric", 
             len = 1L, lower = 0.001, upper = 0.1, values = NULL, cnames = NULL, allow.inf = FALSE, 
             has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, 
             special.vals = list()), class = "Param")), forbidden = NULL), class = "ParamSet"), 
         bit.names = character(0), bits.to.features = function () 
         {
         }, control = structure(list(same.resampling.instance = TRUE, impute.val = NULL, 
             tune.threshold = FALSE, tune.threshold.args = list(), log.fun = function (learner, 
                 task, resampling, measures, par.set, control, opt.path, dob, x, y, remove.nas, 
                 stage, prev.stage) 
             {
                 x.string = paramValueToString(par.set, x, show.missing.values = !remove.nas)
                 if (inherits(learner, "ModelMultiplexer")) 
                     x.string = stri_replace_all(x.string, "", regex = stri_paste(x$selected.learner, 
                       "\\."))
                 logFunDefault(learner, task, resampling, measures, par.set, control, 
                     opt.path, dob, x.string, y, remove.nas, stage, prev.stage, prefixes = c("Tune-x", 
                       "Tune-y"))
             }, final.dw.perc = NULL, extra.args = list(maxit = 1L), budget = 1L), class = c("TuneControlRandom", 
         "TuneControl", "OptControl")), show.info = FALSE), class = c("TuneWrapper", "OptWrapper", 
     "BaseWrapper", "Learner")), task = structure(list(type = "classif", env = <environment>, 
         weights = NULL, blocking = NULL, coordinates = NULL, task.desc = structure(list(
             id = "binary", type = "classif", target = "Class", size = 208L, n.feat = c(numerics = 60L, 
             factors = 0L, ordered = 0L, functionals = 0L), has.missings = FALSE, has.weights = FALSE, 
             has.blocking = FALSE, has.coordinates = FALSE, class.levels = c("M", "R"), 
             positive = "M", negative = "R", class.distribution = structure(c(M = 111L, 
             R = 97L), .Dim = 2L, .Dimnames = list(c("M", "R")), class = "table")), class = c("ClassifTaskDesc", 
         "SupervisedTaskDesc", "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", 
     "Task")), rin = structure(list(desc = structure(list(split = 0.3, id = "holdout", 
         iters = 1L, predict = "test", stratify = FALSE), class = c("HoldoutDesc", "ResampleDesc"
     )), size = 208L, train.inds = list(c(60L, 164L, 85L, 182L, 192L, 10L, 107L, 180L, 
     111L, 91L, 190L, 90L, 133L, 112L, 20L, 174L, 48L, 9L, 63L, 181L, 168L, 130L, 120L, 
     184L, 121L, 187L, 100L, 108L, 53L, 27L, 172L, 160L, 122L, 140L, 5L, 83L, 131L, 38L, 
     55L, 40L, 24L, 70L, 69L, 61L, 26L, 23L, 171L, 76L, 43L, 137L, 8L, 167L, 125L, 19L, 
     87L, 32L, 194L, 114L, 135L, 56L, 99L, 14L)), test.inds = list(c(80L, 57L, 92L, 166L, 
     165L, 161L, 89L, 151L, 126L, 141L, 1L, 94L, 74L, 119L, 68L, 22L, 47L, 127L, 79L, 
     148L, 81L, 162L, 117L, 62L, 179L, 207L, 33L, 17L, 185L, 88L, 102L, 176L, 147L, 150L, 
     67L, 183L, 149L, 113L, 146L, 201L, 178L, 98L, 159L, 46L, 175L, 54L, 143L, 155L, 21L, 
     124L, 93L, 101L, 71L, 105L, 58L, 41L, 2L, 202L, 29L, 30L, 158L, 139L, 152L, 170L, 
     13L, 45L, 66L, 25L, 50L, 156L, 39L, 136L, 132L, 169L, 77L, 144L, 195L, 154L, 73L, 
     65L, 59L, 35L, 204L, 129L, 28L, 163L, 189L, 52L, 199L, 103L, 75L, 191L, 104L, 157L, 
     72L, 196L, 31L, 49L, 11L, 198L, 173L, 82L, 200L, 177L, 15L, 116L, 109L, 3L, 186L, 
     208L, 206L, 95L, 78L, 203L, 110L, 18L, 134L, 106L, 86L, 142L, 118L, 123L, 145L, 7L, 
     153L, 115L, 36L, 84L, 44L, 16L, 6L, 51L, 205L, 188L, 12L, 37L, 193L, 96L, 64L, 138L, 
     34L, 4L, 97L, 128L, 197L, 42L)), group = structure(integer(0), .Label = character(0), class = "factor")), class = "ResampleInstance"), 
         weights = NULL, measures = list(structure(list(id = "mmce", minimize = TRUE, 
             properties = c("classif", "classif.multi", "req.pred", "req.truth"), fun = function (task, 
                 model, pred, feats, extra.args) 
             {
                 measureMMCE(pred$data$truth, pred$data$response)
             }, extra.args = list(), best = 0, worst = 1, name = "Mean misclassification error", 
             note = "Defined as: mean(response != truth)", aggr = structure(list(id = "test.mean", 
                 name = "Test mean", fun = function (task, perf.test, perf.train, measure, 
                     group, pred) 
                 mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure")), 
         model = FALSE, extract = function (model) 
         {
         }, show.info = FALSE)
  5: calculateResampleIterationResult(learner = learner, task = task, i = i, train.i = train.i, 
         test.i = test.i, measures = measures, weights = weights, rdesc = rin$desc, model = model, 
         extract = extract, show.info = show.info)
  6: train(learner, task, subset = train.i, weights = weights[train.i])
  7: measureTime(fun1({
         learner.model = fun2(fun3(do.call(trainLearner, pars)))
     }))
  8: force(expr)
  9: fun1({
         learner.model = fun2(fun3(do.call(trainLearner, pars)))
     })
  10: fun2(fun3(do.call(trainLearner, pars)))
  ...
  20: mapply(fun2, ..., MoreArgs = more.args, SIMPLIFY = FALSE, USE.NAMES = FALSE)
  21: (function (learner, task, resampling, measures, par.set, bits.to.features, control, 
         opt.path, show.info, dob, state, remove.nas, resample.fun) 
     {
         setSlaveOptions()
         y = setNames(rep(NA_real_, length(measures)), vcapply(measures, measureAggrName))
         errmsg = NA_character_
         exec.time = NA_real_
         set.pars.ok = TRUE
         learner2 = learner
         threshold = NULL
         log.fun = control$log.fun
         err.dumps = list()
         if (inherits(control, "TuneControl") || inherits(control, "TuneMultiCritControl")) {
             state = setValueCNames(par.set, state)
             state = trafoValue(par.set, state)
             state2 = if (remove.nas) 
                 removeMissingValues(state)
             else state
             learner2 = try(setHyperPars(learner, par.vals = state2), silent = TRUE)
             if (is.error(learner2)) {
                 set.pars.ok = FALSE
                 errmsg = as.character(learner2)
                 if (show.info) 
                     messagef("[Tune-x] Setting hyperpars failed: %s", errmsg)
             }
         }
         else if (inherits(control, "FeatSelControl")) {
             task = subsetTask(task, features = bits.to.features(state, task))
         }
         if (show.info) 
             prev.stage = log.fun(learner, task, resampling, measures, par.set, control, 
                 opt.path, dob, state, NA_real_, remove.nas, stage = 1L)
         if (set.pars.ok) {
             exec.time = measureTime({
                 r = resample.fun(learner2, task, resampling, measures = measures, show.info = FALSE)
             })
             if (control$tune.threshold) {
                 th.args = control$tune.threshold.args
                 th.args$pred = r$pred
                 th.args$measure = measures[[1L]]
                 tune.th.res = do.call(tuneThreshold, th.args)
                 threshold = tune.th.res$th
                 y = performance(setThreshold(r$pred, threshold = threshold), measures = measures)
                 names(y) = names(r$aggr)
             }
             else {
                 y = r$aggr
             }
             errmsgs = as.character(t(r$err.msgs[, -1L]))
             notna = !is.na(errmsgs)
             if (any(notna)) 
                 errmsg = errmsgs[notna][1L]
             err.dumps = r$err.dumps
         }
         else {
             if (control$tune.threshold) 
                 threshold = NA_real_
         }
         if (show.info) 
             log.fun(learner, task, resampling, measures, par.set, control, opt.path, 
                 dob, state, y, remove.nas, stage = 2L, prev.stage = prev.stage)
         list(y = y, exec.time = exec.time, errmsg = errmsg, threshold = threshold, err.dumps = err.dumps)
     })(dots[[1L]][[1L]], dots[[2L]][[1L]], learner = structure(list(id = "classif.glmnet", 
         type = "classif", package = "glmnet", properties = c("numerics", "factors", "prob", 
         "twoclass", "multiclass", "weights"), par.set = structure(list(pars = list(alpha = structure(list(
             id = "alpha", type = "numeric", len = 1L, lower = 0, upper = 1, values = NULL, 
             cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 1, trafo = NULL, 
             requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), s = structure(list(id = "s", type = "numeric", len = 1L, lower = 0, 
             upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
             default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
             when = "predict"), class = c("LearnerParam", "Param")), exact = structure(list(
             id = "exact", type = "logical", len = 1L, lower = NULL, upper = NULL, values = list(
                 `TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
             default = FALSE, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
             when = "predict"), class = c("LearnerParam", "Param")), nlambda = structure(list(
             id = "nlambda", type = "integer", len = 1L, lower = 1L, upper = Inf, values = NULL, 
             cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 100L, trafo = NULL, 
             requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), lambda.min.ratio = structure(list(id = "lambda.min.ratio", type = "numeric", 
             len = 1L, lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, 
             has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, 
             special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
         )), lambda = structure(list(id = "lambda", type = "numericvector", len = NA_integer_, 
             lower = 0, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
             has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, 
             special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
         )), standardize = structure(list(id = "standardize", type = "logical", len = 1L, 
             lower = NULL, upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), 
             cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = TRUE, trafo = NULL, 
             requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), intercept = structure(list(id = "intercept", type = "logical", len = 1L, 
             lower = NULL, upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), 
             cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = TRUE, trafo = NULL, 
             requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), thresh = structure(list(id = "thresh", type = "numeric", len = 1L, 
             lower = 0, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
             has.default = TRUE, default = 1e-07, trafo = NULL, requires = NULL, tunable = TRUE, 
             special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
         )), dfmax = structure(list(id = "dfmax", type = "integer", len = 1L, lower = 0L, 
             upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
             default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
             when = "train"), class = c("LearnerParam", "Param")), pmax = structure(list(
             id = "pmax", type = "integer", len = 1L, lower = 0L, upper = Inf, values = NULL, 
             cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, 
             requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), exclude = structure(list(id = "exclude", type = "integervector", len = NA_integer_, 
             lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
             has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, 
             special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
         )), penalty.factor = structure(list(id = "penalty.factor", type = "numericvector", 
             len = NA_integer_, lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, 
             has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, 
             special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
         )), lower.limits = structure(list(id = "lower.limits", type = "numericvector", 
             len = NA_integer_, lower = -Inf, upper = 0, values = NULL, cnames = NULL, 
             allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, 
             tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), upper.limits = structure(list(id = "upper.limits", type = "numericvector", 
             len = NA_integer_, lower = 0, upper = Inf, values = NULL, cnames = NULL, 
             allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, 
             tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), maxit = structure(list(id = "maxit", type = "integer", len = 1L, lower = 1L, 
             upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
             default = 100000L, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
             when = "train"), class = c("LearnerParam", "Param")), type.logistic = structure(list(
             id = "type.logistic", type = "discrete", len = 1L, lower = NULL, upper = NULL, 
             values = list(Newton = "Newton", modified.Newton = "modified.Newton"), cnames = NULL, 
             allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, 
             tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), type.multinomial = structure(list(id = "type.multinomial", type = "discrete", 
             len = 1L, lower = NULL, upper = NULL, values = list(ungrouped = "ungrouped", 
                 grouped = "grouped"), cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
             default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
             when = "train"), class = c("LearnerParam", "Param")), fdev = structure(list(
             id = "fdev", type = "numeric", len = 1L, lower = 0, upper = 1, values = NULL, 
             cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 1e-05, trafo = NULL, 
             requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), devmax = structure(list(id = "devmax", type = "numeric", len = 1L, 
             lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
             default = 0.999, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
             when = "train"), class = c("LearnerParam", "Param")), eps = structure(list(
             id = "eps", type = "numeric", len = 1L, lower = 0, upper = 1, values = NULL, 
             cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 1e-06, trafo = NULL, 
             requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), big = structure(list(id = "big", type = "numeric", len = 1L, lower = -Inf, 
             upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
             default = 9.9e+35, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
             when = "train"), class = c("LearnerParam", "Param")), mnlam = structure(list(
             id = "mnlam", type = "integer", len = 1L, lower = 1, upper = Inf, values = NULL, 
             cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 5, trafo = NULL, 
             requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), pmin = structure(list(id = "pmin", type = "numeric", len = 1L, lower = 0, 
             upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
             default = 1e-09, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
             when = "train"), class = c("LearnerParam", "Param")), exmx = structure(list(
             id = "exmx", type = "numeric", len = 1L, lower = -Inf, upper = Inf, values = NULL, 
             cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 250, trafo = NULL, 
             requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), prec = structure(list(id = "prec", type = "numeric", len = 1L, lower = -Inf, 
             upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
             default = 1e-10, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
             when = "train"), class = c("LearnerParam", "Param")), mxit = structure(list(
             id = "mxit", type = "integer", len = 1L, lower = 1L, upper = Inf, values = NULL, 
             cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 100L, trafo = NULL, 
             requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param"))), forbidden = NULL), class = c("LearnerParamSet", "ParamSet")), par.vals = list(
             s = 0.01), predict.type = "prob", name = "GLM with Lasso or Elasticnet Regularization", 
         short.name = "glmnet", note = "The family parameter is set to `binomial` for two-class problems and to `multinomial` otherwise.\n      Factors automatically get converted to dummy columns, ordered factors to integer.\n      Parameter `s` (value of the regularization parameter used for predictions) is set to `0.1` by default,\n      but needs to be tuned by the user.\n      glmnet uses a global control object for its parameters. mlr resets all control parameters to their defaults\n      before setting the specified parameters and after training.\n      If you are setting glmnet.control parameters through glmnet.control,\n      you need to save and re-set them after running the glmnet learner.", 
         callees = c("glmnet", "glmnet.control", "predict.glmnet"), help.list = list(s = "Argument of: glmnet::predict.glmnet\n\nValue(s) of the penalty parameter lambda at which predictions are required. Default is the entire sequence used to create the model.", 
             exact = "Argument of: glmnet::predict.glmnet\n\nThis argument is relevant only when predictions are made at values of s (lambda) different from those used in the fitting of the original model. If exact=FALSE (default), then the predict function uses linear interpolation to make predictions for values of s (lambda) that do not coincide with those used in the fitting algorithm. While this is often a good approximation, it can sometimes be a bit coarse. With exact=TRUE, these different values of s are merged (and sorted) with object$lambda, and the model is refit before predictions are made. In this case, it is required to supply the original data x= and y= as additional named  arguments to predict() or coef(). The workhorse predict.glmnet() needs to  update the model, and so needs the data used to create it. The same is true of weights, offset, penalty.factor, lower.limits, upper.limits if these were used in the original call. Failure to do so will result in an error.", 
             fdev = "Argument of: glmnet::glmnet.control\n\nminimum fractional change in deviance for stopping path; factory default = 1.0e-5", 
             devmax = "Argument of: glmnet::glmnet.control\n\nmaximum fraction of explained deviance for stopping path; factory default = 0.999", 
             eps = "Argument of: glmnet::glmnet.control\n\nminimum value of lambda.min.ratio (see glmnet); factory default= 1.0e-6", 
             big = "Argument of: glmnet::glmnet.control\n\nlarge floating point number; factory default = 9.9e35. Inf in definition of upper.limit is set to big", 
             mnlam = "Argument of: glmnet::glmnet.control\n\nminimum number of path points (lambda values) allowed; factory default = 5", 
             pmin = "Argument of: glmnet::glmnet.control\n\nminimum probability for any class. factory default = 1.0e-9. Note that this implies a pmax of 1-pmin.", 
             exmx = "Argument of: glmnet::glmnet.control\n\nmaximum allowed exponent. factory default = 250.0", 
             prec = "Argument of: glmnet::glmnet.control\n\nconvergence threshold for multi response bounds adjustment solution. factory default = 1.0e-10", 
             mxit = "Argument of: glmnet::glmnet.control\n\nmaximum iterations for multiresponse bounds adjustment solution.  factory default = 100", 
             alpha = "Argument of: glmnet::glmnet\n\nThe elasticnet mixing parameter, with 0≤α≤ 1. The penalty is defined as (1-α)/2||β||_2^2+α||β||_1. alpha=1 is the lasso penalty, and alpha=0 the ridge penalty.", 
             nlambda = "Argument of: glmnet::glmnet\n\nThe number of lambda values - default is 100.", 
             lambda.min.ratio = "Argument of: glmnet::glmnet\n\nSmallest value for lambda, as a fraction of lambda.max, the (data derived) entry value (i.e. the smallest value for which all coefficients are zero). The default depends on the sample size nobs relative to the number of variables nvars. If nobs > nvars, the default is 0.0001, close to zero.  If nobs < nvars, the default is 0.01. A very small value of lambda.min.ratio will lead to a saturated fit in the nobs < nvars case. This is undefined for \"binomial\" and \"multinomial\" models, and glmnet will exit gracefully when the percentage deviance explained is almost 1.", 
             lambda = "Argument of: glmnet::glmnet\n\nA user supplied lambda sequence. Typical usage is to have the program compute its own lambda sequence based on nlambda and lambda.min.ratio. Supplying a value of lambda overrides this. WARNING: use with care. Avoid supplying a single value for lambda (for predictions after CV use predict() instead).  Supply instead a decreasing sequence of lambda values. glmnet relies on its warms starts for speed, and its often faster to fit a whole path than compute a single fit.", 
             standardize = "Argument of: glmnet::glmnet\n\nLogical flag for x variable standardization, prior to fitting the model sequence. The coefficients are always returned on the original scale. Default is standardize=TRUE. If variables are in the same units already, you might not wish to standardize. See details below for y standardization with family=\"gaussian\".", 
             intercept = "Argument of: glmnet::glmnet\n\nShould intercept(s) be fitted (default=TRUE) or set to zero (FALSE)", 
             thresh = "Argument of: glmnet::glmnet\n\nConvergence threshold for coordinate descent. Each inner coordinate-descent loop continues until the maximum change in the objective after any coefficient update is less than thresh times the null deviance. Defaults value is 1E-7.", 
             dfmax = "Argument of: glmnet::glmnet\n\nLimit the maximum number of variables in the model. Useful for very large nvars, if a partial path is desired.", 
             pmax = "Argument of: glmnet::glmnet\n\nLimit the maximum number of variables ever to be nonzero", 
             exclude = "Argument of: glmnet::glmnet\n\nIndices of variables to be excluded from the model. Default is none. Equivalent to an infinite penalty factor (next item).", 
             penalty.factor = "Argument of: glmnet::glmnet\n\nSeparate penalty factors can be applied to each coefficient. This is a number that multiplies lambda to allow differential shrinkage. Can be 0 for some variables, which implies no shrinkage, and that variable is always included in the model. Default is 1 for all variables (and implicitly infinity for variables listed in exclude). Note: the penalty factors are internally rescaled to sum to nvars, and the lambda sequence will reflect this change.", 
             lower.limits = "Argument of: glmnet::glmnet\n\nVector of lower limits for each coefficient; default -Inf. Each of these must be non-positive. Can be presented as a single value (which will then be replicated), else a vector of length nvars", 
             upper.limits = "Argument of: glmnet::glmnet\n\nVector of upper limits for each coefficient; default Inf. See lower.limits", 
             maxit = "Argument of: glmnet::glmnet\n\nMaximum number of passes over the data for all lambda values; default is 10^5.", 
             type.logistic = "Argument of: glmnet::glmnet\n\nIf \"Newton\" then the exact hessian is used (default), while \"modified.Newton\" uses an upper-bound on the hessian, and can be faster.", 
             type.multinomial = "Argument of: glmnet::glmnet\n\nIf \"grouped\" then a grouped lasso penalty is used on the multinomial coefficients for a variable. This ensures they are all in our out together. The default is \"ungrouped\""), 
         config = list(), fix.factors.prediction = FALSE), class = c("classif.glmnet", 
     "RLearnerClassif", "RLearner", "Learner")), task = structure(list(type = "classif", 
         env = <environment>, weights = NULL, blocking = NULL, coordinates = NULL, task.desc = structure(list(
             id = "binary", type = "classif", target = "Class", size = 62L, n.feat = c(numerics = 60L, 
             factors = 0L, ordered = 0L, functionals = 0L), has.missings = FALSE, has.weights = FALSE, 
             has.blocking = FALSE, has.coordinates = FALSE, class.levels = c("M", "R"), 
             positive = "M", negative = "R", class.distribution = structure(c(M = 32L, 
             R = 30L), .Dim = 2L, .Dimnames = list(c("M", "R")), class = "table")), class = c("ClassifTaskDesc", 
         "SupervisedTaskDesc", "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", 
     "Task")), resampling = structure(list(desc = structure(list(split = 0.3, id = "holdout", 
         iters = 1L, predict = "test", stratify = FALSE), class = c("HoldoutDesc", "ResampleDesc"
     )), size = 62L, train.inds = list(c(18L, 49L, 25L, 53L, 55L, 3L, 30L, 50L, 56L, 60L, 
     58L, 24L, 34L, 29L, 5L, 43L, 12L, 2L)), test.inds = list(c(21L, 59L, 54L, 41L, 38L, 
     57L, 37L, 39L, 32L, 16L, 8L, 45L, 22L, 48L, 10L, 14L, 6L, 17L, 52L, 42L, 40L, 51L, 
     47L, 9L, 27L, 46L, 13L, 23L, 4L, 15L, 36L, 31L, 20L, 44L, 7L, 35L, 28L, 11L, 61L, 
     62L, 1L, 19L, 26L, 33L)), group = structure(integer(0), .Label = character(0), class = "factor")), class = "ResampleInstance"), 
         measures = list(structure(list(id = "mmce", minimize = TRUE, properties = c("classif", 
         "classif.multi", "req.pred", "req.truth"), fun = function (task, model, pred, 
             feats, extra.args) 
         {
             measureMMCE(pred$data$truth, pred$data$response)
         }, extra.args = list(), best = 0, worst = 1, name = "Mean misclassification error", 
             note = "Defined as: mean(response != truth)", aggr = structure(list(id = "test.mean", 
                 name = "Test mean", fun = function (task, perf.test, perf.train, measure, 
                     group, pred) 
                 mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure")), 
         par.set = structure(list(pars = list(s = structure(list(id = "s", type = "numeric", 
             len = 1L, lower = 0.001, upper = 0.1, values = NULL, cnames = NULL, allow.inf = FALSE, 
             has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, 
             special.vals = list()), class = "Param")), forbidden = NULL), class = "ParamSet"), 
         bits.to.features = NULL, control = structure(list(same.resampling.instance = TRUE, 
             impute.val = 1, tune.threshold = FALSE, tune.threshold.args = list(), log.fun = function (learner, 
                 task, resampling, measures, par.set, control, opt.path, dob, x, y, remove.nas, 
                 stage, prev.stage) 
             {
                 x.string = paramValueToString(par.set, x, show.missing.values = !remove.nas)
                 if (inherits(learner, "ModelMultiplexer")) 
                     x.string = stri_replace_all(x.string, "", regex = stri_paste(x$selected.learner, 
                       "\\."))
                 logFunDefault(learner, task, resampling, measures, par.set, control, 
                     opt.path, dob, x.string, y, remove.nas, stage, prev.stage, prefixes = c("Tune-x", 
                       "Tune-y"))
             }, final.dw.perc = NULL, extra.args = list(maxit = 1L), budget = 1L), class = c("TuneControlRandom", 
         "TuneControl", "OptControl")), opt.path = structure(list(par.set = structure(list(
             pars = list(s = structure(list(id = "s", type = "numeric", len = 1L, lower = 0.001, 
                 upper = 0.1, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                 default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list()), class = "Param")), 
             forbidden = NULL), class = "ParamSet"), y.names = "mmce.test.mean", minimize = c(mmce.test.mean = TRUE), 
             add.transformed.x = FALSE, env = <environment>), class = c("OptPathDF", "OptPath"
         )), show.info = FALSE, remove.nas = TRUE, resample.fun = function (learner, task, 
             resampling, measures, weights = NULL, models = FALSE, extract, keep.pred = TRUE, 
             ..., show.info = getMlrOption("show.info")) 
         {
             learner = checkLearner(learner)
             learner = setHyperPars(learner, ...)
             assertClass(task, classes = "Task")
             n = getTaskSize(task)
             if (inherits(resampling, "ResampleDesc")) 
                 resampling = makeResampleInstance(resampling, task = task)
             assertClass(resampling, classes = "ResampleInstance")
             measures = checkMeasures(measures, task)
             if (!is.null(weights)) {
                 assertNumeric(weights, len = n, any.missing = FALSE, lower = 0)
             }
             assertFlag(models)
             if (missing(extract)) 
                 extract = function(model) {
                 }
             else assertFunction(extract)
             assertFlag(show.info)
             r = resampling$size
             if (n != r) 
                 stop(stri_paste("Size of data set:", n, "and resampling instance:", r, 
                     "differ!", sep = " "))
             checkLearnerBeforeTrain(task, learner, weights)
             checkAggrsBeforeResample(measures, resampling$desc)
             rin = resampling
             more.args = list(learner = learner, task = task, rin = rin, weights = NULL, 
                 measures = measures, model = models, extract = extract, show.info = show.info)
             if (!is.null(weights)) {
                 more.args$weights = weights
             }
             else if (!is.null(getTaskWeights(task))) {
                 more.args$weights = getTaskWeights(task)
             }
             parallelLibrary("mlr", master = FALSE, level = "mlr.resample", show.info = FALSE)
             exportMlrOptions(level = "mlr.resample")
             if (show.info) {
                 messagef("Resampling: %s", rin$desc$id)
                 measure.lognames = extractSubList(measures, "id")
                 if (rin$desc$predict == "both") {
                     id.train = which(vlapply(measures, function(x) "req.train" %in% x$aggr$properties))
                     id.test = which(vlapply(measures, function(x) "req.test" %in% x$aggr$properties))
                     measure.lognames = c(stri_paste(measure.lognames[id.train], "train", 
                       sep = "."), stri_paste(measure.lognames[id.test], "test", sep = "."))
                 }
                 printResampleFormatLine("Measures:", measure.lognames)
             }
             time1 = Sys.time()
             iter.results = parallelMap(doResampleIteration, seq_len(rin$desc$iters), 
                 level = "mlr.resample", more.args = more.args)
             time2 = Sys.time()
             runtime = as.numeric(difftime(time2, time1, units = "secs"))
             addClasses(mergeResampleResult(learner$id, task, iter.results, measures, 
                 rin, models, extract, keep.pred, show.info, runtime), "ResampleResult")
         })
  22: measureTime({
         r = resample.fun(learner2, task, resampling, measures = measures, show.info = FALSE)
     })
  23: force(expr)
  24: resample.fun(learner2, task, resampling, measures = measures, show.info = FALSE)
  25: parallelMap(doResampleIteration, seq_len(rin$desc$iters), level = "mlr.resample", 
         more.args = more.args)
  26: options(parallelMap.nextmap = (getPMOptNextMap() + 1L))
  27: getPMOptNextMap()
  28: getPMOption("nextmap")
  29: getOption(sprintf("parallelMap.%s", opt), def)
  
  ── 11. Error: TuneWrapper uses tune.threshold (@test_base_TuneWrapper.R#64)  ───
  argument "def" is missing, with no default
  1: train(lrn, binaryclass.task) at testthat/test_base_TuneWrapper.R:64
  2: measureTime(fun1({
         learner.model = fun2(fun3(do.call(trainLearner, pars)))
     }))
  3: force(expr)
  4: fun1({
         learner.model = fun2(fun3(do.call(trainLearner, pars)))
     })
  5: fun2(fun3(do.call(trainLearner, pars)))
  6: fun3(do.call(trainLearner, pars))
  7: do.call(trainLearner, pars)
  8: (function (.learner, .task, .subset, .weights = NULL, ...) 
     {
         UseMethod("trainLearner")
     })(.learner = structure(list(id = "classif.lda.tuned", type = "classif", package = "MASS", 
         properties = NULL, par.set = structure(list(pars = list(), forbidden = NULL), class = "ParamSet"), 
         par.vals = list(), predict.type = "prob", fix.factors.prediction = FALSE, next.learner = structure(list(
             id = "classif.lda", type = "classif", package = "MASS", properties = c("twoclass", 
             "multiclass", "numerics", "factors", "prob"), par.set = structure(list(pars = list(
                 method = structure(list(id = "method", type = "discrete", len = 1L, lower = NULL, 
                     upper = NULL, values = list(moment = "moment", mle = "mle", mve = "mve", 
                       t = "t"), cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = "moment", trafo = NULL, requires = NULL, tunable = TRUE, 
                     special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), nu = structure(list(id = "nu", type = "numeric", len = 1L, 
                     lower = 2, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = FALSE, default = NULL, trafo = NULL, requires = method == 
                       "t", tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), tol = structure(list(id = "tol", type = "numeric", len = 1L, 
                     lower = 0, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 1e-04, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), predict.method = structure(list(id = "predict.method", type = "discrete", 
                     len = 1L, lower = NULL, upper = NULL, values = list(`plug-in` = "plug-in", 
                       predictive = "predictive", debiased = "debiased"), cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = "plug-in", trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "predict"), class = c("LearnerParam", 
                 "Param")), CV = structure(list(id = "CV", type = "logical", len = 1L, 
                     lower = NULL, upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), 
                     cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = FALSE, 
                     trafo = NULL, requires = NULL, tunable = FALSE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), prior = structure(list(
                     id = "prior", type = "numericvector", len = NA_integer_, lower = 0, 
                     upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                     default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param"))), forbidden = NULL), class = c("LearnerParamSet", 
             "ParamSet")), par.vals = list(), predict.type = "prob", name = "Linear Discriminant Analysis", 
             short.name = "lda", note = "Learner parameter `predict.method` maps to `method` in `predict.lda`.", 
             callees = c("lda", "predict.lda"), help.list = list(prior = "Argument of: MASS::lda\n\nthe prior probabilities of class membership.  If unspecified, the class proportions for the training set are used.  If present, the probabilities should be specified in the order of the factor levels.", 
                 method = "Argument of: MASS::lda\n\n\"moment\" for standard estimators of the mean and variance, \"mle\" for MLEs, \"mve\" to use cov.mve, or \"t\" for robust estimates based on a t distribution.", 
                 tol = "Argument of: MASS::lda\n\nA tolerance to decide if a matrix is singular; it will reject variables and linear combinations of unit-variance variables whose variance is less than tol^2.", 
                 CV = "Argument of: MASS::lda\n\nIf true, returns results (classes and posterior probabilities) for leave-one-out cross-validation. Note that if the prior is estimated, the proportions in the whole dataset are used.", 
                 nu = "Argument of: MASS::lda\n\ndegrees of freedom for method = \"t\"."), 
             config = list(), fix.factors.prediction = FALSE), class = c("classif.lda", 
         "RLearnerClassif", "RLearner", "Learner")), model.subclass = "TuneModel", resampling = structure(list(
             split = 0.666666666666667, id = "holdout", iters = 1L, predict = "test", 
             stratify = FALSE), class = c("HoldoutDesc", "ResampleDesc")), measures = list(
             structure(list(id = "costs", minimize = TRUE, properties = c("classif", "classif.multi", 
             "req.pred", "req.truth", "predtype.response", "predtype.prob"), fun = function (task, 
                 model, pred, feats, extra.args) 
             {
                 td = pred$task.desc
                 levs = td$class.levels
                 if (any(dim(costs))) {
                     if (any(dim(costs) != length(levs))) 
                       stop("Dimensions of costs have to be the same as number of class levels!")
                     rns = rownames(costs)
                     cns = colnames(costs)
                     if (!setequal(rns, levs) || !setequal(cns, levs)) 
                       stop("Row and column names of cost matrix have to equal class levels!")
                 }
                 costs = extra.args[[1L]]
                 r = pred$data$response
                 if (anyMissing(r)) 
                     return(NA_real_)
                 cc = function(truth, pred) {
                     costs[truth, pred]
                 }
                 y = mapply(cc, as.character(pred$data$truth), as.character(r))
                 combine(y)
             }, extra.args = list(costs = structure(c(0, 5, 1, 0), .Dim = c(2L, 2L), .Dimnames = list(
                 c("M", "R"), c("M", "R"))), combine = function (x, ...) 
             UseMethod("mean")), best = 0, worst = 5, name = "costs", note = "", aggr = structure(list(
                 id = "test.mean", name = "Test mean", fun = function (task, perf.test, 
                     perf.train, measure, group, pred) 
                 mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure")), 
         opt.pars = structure(list(pars = list(method = structure(list(id = "method", 
             type = "discrete", len = 1L, lower = NULL, upper = NULL, values = list(moment = "moment"), 
             cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, 
             requires = NULL, tunable = TRUE, special.vals = list()), class = "Param")), 
             forbidden = NULL), class = "ParamSet"), bit.names = character(0), bits.to.features = function () 
         {
         }, control = structure(list(same.resampling.instance = TRUE, impute.val = NULL, 
             tune.threshold = TRUE, tune.threshold.args = list(), log.fun = function (learner, 
                 task, resampling, measures, par.set, control, opt.path, dob, x, y, remove.nas, 
                 stage, prev.stage) 
             {
                 x.string = paramValueToString(par.set, x, show.missing.values = !remove.nas)
                 if (inherits(learner, "ModelMultiplexer")) 
                     x.string = stri_replace_all(x.string, "", regex = stri_paste(x$selected.learner, 
                       "\\."))
                 logFunDefault(learner, task, resampling, measures, par.set, control, 
                     opt.path, dob, x.string, y, remove.nas, stage, prev.stage, prefixes = c("Tune-x", 
                       "Tune-y"))
             }, final.dw.perc = NULL, extra.args = list(resolution = 10L)), class = c("TuneControlGrid", 
         "TuneControl", "OptControl")), show.info = FALSE), class = c("TuneWrapper", "OptWrapper", 
     "BaseWrapper", "Learner")), .task = structure(list(type = "classif", env = <environment>, 
         weights = NULL, blocking = NULL, coordinates = NULL, task.desc = structure(list(
             id = "binary", type = "classif", target = "Class", size = 208L, n.feat = c(numerics = 60L, 
             factors = 0L, ordered = 0L, functionals = 0L), has.missings = FALSE, has.weights = FALSE, 
             has.blocking = FALSE, has.coordinates = FALSE, class.levels = c("M", "R"), 
             positive = "M", negative = "R", class.distribution = structure(c(M = 111L, 
             R = 97L), .Dim = 2L, .Dimnames = list(c("M", "R")), class = "table")), class = c("ClassifTaskDesc", 
         "SupervisedTaskDesc", "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", 
     "Task")), .subset = NULL)
  9: trainLearner.TuneWrapper(.learner = structure(list(id = "classif.lda.tuned", type = "classif", 
         package = "MASS", properties = NULL, par.set = structure(list(pars = list(), 
             forbidden = NULL), class = "ParamSet"), par.vals = list(), predict.type = "prob", 
         fix.factors.prediction = FALSE, next.learner = structure(list(id = "classif.lda", 
             type = "classif", package = "MASS", properties = c("twoclass", "multiclass", 
             "numerics", "factors", "prob"), par.set = structure(list(pars = list(method = structure(list(
                 id = "method", type = "discrete", len = 1L, lower = NULL, upper = NULL, 
                 values = list(moment = "moment", mle = "mle", mve = "mve", t = "t"), 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = "moment", 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), nu = structure(list(
                 id = "nu", type = "numeric", len = 1L, lower = 2, upper = Inf, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, 
                 trafo = NULL, requires = method == "t", tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), tol = structure(list(
                 id = "tol", type = "numeric", len = 1L, lower = 0, upper = Inf, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 1e-04, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), predict.method = structure(list(
                 id = "predict.method", type = "discrete", len = 1L, lower = NULL, upper = NULL, 
                 values = list(`plug-in` = "plug-in", predictive = "predictive", debiased = "debiased"), 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = "plug-in", 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "predict"), class = c("LearnerParam", "Param")), CV = structure(list(
                 id = "CV", type = "logical", len = 1L, lower = NULL, upper = NULL, values = list(
                     `TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = FALSE, trafo = NULL, requires = NULL, tunable = FALSE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), prior = structure(list(id = "prior", type = "numericvector", len = NA_integer_, 
                 lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             ))), forbidden = NULL), class = c("LearnerParamSet", "ParamSet")), par.vals = list(), 
             predict.type = "prob", name = "Linear Discriminant Analysis", short.name = "lda", 
             note = "Learner parameter `predict.method` maps to `method` in `predict.lda`.", 
             callees = c("lda", "predict.lda"), help.list = list(prior = "Argument of: MASS::lda\n\nthe prior probabilities of class membership.  If unspecified, the class proportions for the training set are used.  If present, the probabilities should be specified in the order of the factor levels.", 
                 method = "Argument of: MASS::lda\n\n\"moment\" for standard estimators of the mean and variance, \"mle\" for MLEs, \"mve\" to use cov.mve, or \"t\" for robust estimates based on a t distribution.", 
                 tol = "Argument of: MASS::lda\n\nA tolerance to decide if a matrix is singular; it will reject variables and linear combinations of unit-variance variables whose variance is less than tol^2.", 
                 CV = "Argument of: MASS::lda\n\nIf true, returns results (classes and posterior probabilities) for leave-one-out cross-validation. Note that if the prior is estimated, the proportions in the whole dataset are used.", 
                 nu = "Argument of: MASS::lda\n\ndegrees of freedom for method = \"t\"."), 
             config = list(), fix.factors.prediction = FALSE), class = c("classif.lda", 
         "RLearnerClassif", "RLearner", "Learner")), model.subclass = "TuneModel", resampling = structure(list(
             split = 0.666666666666667, id = "holdout", iters = 1L, predict = "test", 
             stratify = FALSE), class = c("HoldoutDesc", "ResampleDesc")), measures = list(
             structure(list(id = "costs", minimize = TRUE, properties = c("classif", "classif.multi", 
             "req.pred", "req.truth", "predtype.response", "predtype.prob"), fun = function (task, 
                 model, pred, feats, extra.args) 
             {
                 td = pred$task.desc
                 levs = td$class.levels
                 if (any(dim(costs))) {
                     if (any(dim(costs) != length(levs))) 
                       stop("Dimensions of costs have to be the same as number of class levels!")
                     rns = rownames(costs)
                     cns = colnames(costs)
                     if (!setequal(rns, levs) || !setequal(cns, levs)) 
                       stop("Row and column names of cost matrix have to equal class levels!")
                 }
                 costs = extra.args[[1L]]
                 r = pred$data$response
                 if (anyMissing(r)) 
                     return(NA_real_)
                 cc = function(truth, pred) {
                     costs[truth, pred]
                 }
                 y = mapply(cc, as.character(pred$data$truth), as.character(r))
                 combine(y)
             }, extra.args = list(costs = structure(c(0, 5, 1, 0), .Dim = c(2L, 2L), .Dimnames = list(
                 c("M", "R"), c("M", "R"))), combine = function (x, ...) 
             UseMethod("mean")), best = 0, worst = 5, name = "costs", note = "", aggr = structure(list(
                 id = "test.mean", name = "Test mean", fun = function (task, perf.test, 
                     perf.train, measure, group, pred) 
                 mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure")), 
         opt.pars = structure(list(pars = list(method = structure(list(id = "method", 
             type = "discrete", len = 1L, lower = NULL, upper = NULL, values = list(moment = "moment"), 
             cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, 
             requires = NULL, tunable = TRUE, special.vals = list()), class = "Param")), 
             forbidden = NULL), class = "ParamSet"), bit.names = character(0), bits.to.features = function () 
         {
         }, control = structure(list(same.resampling.instance = TRUE, impute.val = NULL, 
             tune.threshold = TRUE, tune.threshold.args = list(), log.fun = function (learner, 
                 task, resampling, measures, par.set, control, opt.path, dob, x, y, remove.nas, 
                 stage, prev.stage) 
             {
                 x.string = paramValueToString(par.set, x, show.missing.values = !remove.nas)
                 if (inherits(learner, "ModelMultiplexer")) 
                     x.string = stri_replace_all(x.string, "", regex = stri_paste(x$selected.learner, 
                       "\\."))
                 logFunDefault(learner, task, resampling, measures, par.set, control, 
                     opt.path, dob, x.string, y, remove.nas, stage, prev.stage, prefixes = c("Tune-x", 
                       "Tune-y"))
             }, final.dw.perc = NULL, extra.args = list(resolution = 10L)), class = c("TuneControlGrid", 
         "TuneControl", "OptControl")), show.info = FALSE), class = c("TuneWrapper", "OptWrapper", 
     "BaseWrapper", "Learner")), .task = structure(list(type = "classif", env = <environment>, 
         weights = NULL, blocking = NULL, coordinates = NULL, task.desc = structure(list(
             id = "binary", type = "classif", target = "Class", size = 208L, n.feat = c(numerics = 60L, 
             factors = 0L, ordered = 0L, functionals = 0L), has.missings = FALSE, has.weights = FALSE, 
             has.blocking = FALSE, has.coordinates = FALSE, class.levels = c("M", "R"), 
             positive = "M", negative = "R", class.distribution = structure(c(M = 111L, 
             R = 97L), .Dim = 2L, .Dimnames = list(c("M", "R")), class = "table")), class = c("ClassifTaskDesc", 
         "SupervisedTaskDesc", "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", 
     "Task")), .subset = NULL)
  10: tuneParams(.learner$next.learner, .task, .learner$resampling, .learner$measures, 
         .learner$opt.pars, .learner$control, .learner$show.info)
  ...
  15: mapply(fun2, ..., MoreArgs = more.args, SIMPLIFY = FALSE, USE.NAMES = FALSE)
  16: (function (learner, task, resampling, measures, par.set, bits.to.features, control, 
         opt.path, show.info, dob, state, remove.nas, resample.fun) 
     {
         setSlaveOptions()
         y = setNames(rep(NA_real_, length(measures)), vcapply(measures, measureAggrName))
         errmsg = NA_character_
         exec.time = NA_real_
         set.pars.ok = TRUE
         learner2 = learner
         threshold = NULL
         log.fun = control$log.fun
         err.dumps = list()
         if (inherits(control, "TuneControl") || inherits(control, "TuneMultiCritControl")) {
             state = setValueCNames(par.set, state)
             state = trafoValue(par.set, state)
             state2 = if (remove.nas) 
                 removeMissingValues(state)
             else state
             learner2 = try(setHyperPars(learner, par.vals = state2), silent = TRUE)
             if (is.error(learner2)) {
                 set.pars.ok = FALSE
                 errmsg = as.character(learner2)
                 if (show.info) 
                     messagef("[Tune-x] Setting hyperpars failed: %s", errmsg)
             }
         }
         else if (inherits(control, "FeatSelControl")) {
             task = subsetTask(task, features = bits.to.features(state, task))
         }
         if (show.info) 
             prev.stage = log.fun(learner, task, resampling, measures, par.set, control, 
                 opt.path, dob, state, NA_real_, remove.nas, stage = 1L)
         if (set.pars.ok) {
             exec.time = measureTime({
                 r = resample.fun(learner2, task, resampling, measures = measures, show.info = FALSE)
             })
             if (control$tune.threshold) {
                 th.args = control$tune.threshold.args
                 th.args$pred = r$pred
                 th.args$measure = measures[[1L]]
                 tune.th.res = do.call(tuneThreshold, th.args)
                 threshold = tune.th.res$th
                 y = performance(setThreshold(r$pred, threshold = threshold), measures = measures)
                 names(y) = names(r$aggr)
             }
             else {
                 y = r$aggr
             }
             errmsgs = as.character(t(r$err.msgs[, -1L]))
             notna = !is.na(errmsgs)
             if (any(notna)) 
                 errmsg = errmsgs[notna][1L]
             err.dumps = r$err.dumps
         }
         else {
             if (control$tune.threshold) 
                 threshold = NA_real_
         }
         if (show.info) 
             log.fun(learner, task, resampling, measures, par.set, control, opt.path, 
                 dob, state, y, remove.nas, stage = 2L, prev.stage = prev.stage)
         list(y = y, exec.time = exec.time, errmsg = errmsg, threshold = threshold, err.dumps = err.dumps)
     })(dots[[1L]][[1L]], dots[[2L]][[1L]], learner = structure(list(id = "classif.lda", 
         type = "classif", package = "MASS", properties = c("twoclass", "multiclass", 
         "numerics", "factors", "prob"), par.set = structure(list(pars = list(method = structure(list(
             id = "method", type = "discrete", len = 1L, lower = NULL, upper = NULL, values = list(
                 moment = "moment", mle = "mle", mve = "mve", t = "t"), cnames = NULL, 
             allow.inf = FALSE, has.default = TRUE, default = "moment", trafo = NULL, 
             requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), nu = structure(list(id = "nu", type = "numeric", len = 1L, lower = 2, 
             upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
             default = NULL, trafo = NULL, requires = method == "t", tunable = TRUE, special.vals = list(), 
             when = "train"), class = c("LearnerParam", "Param")), tol = structure(list(
             id = "tol", type = "numeric", len = 1L, lower = 0, upper = Inf, values = NULL, 
             cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 1e-04, trafo = NULL, 
             requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), predict.method = structure(list(id = "predict.method", type = "discrete", 
             len = 1L, lower = NULL, upper = NULL, values = list(`plug-in` = "plug-in", 
                 predictive = "predictive", debiased = "debiased"), cnames = NULL, allow.inf = FALSE, 
             has.default = TRUE, default = "plug-in", trafo = NULL, requires = NULL, tunable = TRUE, 
             special.vals = list(), when = "predict"), class = c("LearnerParam", "Param"
         )), CV = structure(list(id = "CV", type = "logical", len = 1L, lower = NULL, 
             upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, 
             allow.inf = FALSE, has.default = TRUE, default = FALSE, trafo = NULL, requires = NULL, 
             tunable = FALSE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), prior = structure(list(id = "prior", type = "numericvector", len = NA_integer_, 
             lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
             default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
             when = "train"), class = c("LearnerParam", "Param"))), forbidden = NULL), class = c("LearnerParamSet", 
         "ParamSet")), par.vals = list(), predict.type = "prob", name = "Linear Discriminant Analysis", 
         short.name = "lda", note = "Learner parameter `predict.method` maps to `method` in `predict.lda`.", 
         callees = c("lda", "predict.lda"), help.list = list(prior = "Argument of: MASS::lda\n\nthe prior probabilities of class membership.  If unspecified, the class proportions for the training set are used.  If present, the probabilities should be specified in the order of the factor levels.", 
             method = "Argument of: MASS::lda\n\n\"moment\" for standard estimators of the mean and variance, \"mle\" for MLEs, \"mve\" to use cov.mve, or \"t\" for robust estimates based on a t distribution.", 
             tol = "Argument of: MASS::lda\n\nA tolerance to decide if a matrix is singular; it will reject variables and linear combinations of unit-variance variables whose variance is less than tol^2.", 
             CV = "Argument of: MASS::lda\n\nIf true, returns results (classes and posterior probabilities) for leave-one-out cross-validation. Note that if the prior is estimated, the proportions in the whole dataset are used.", 
             nu = "Argument of: MASS::lda\n\ndegrees of freedom for method = \"t\"."), 
         config = list(), fix.factors.prediction = FALSE), class = c("classif.lda", "RLearnerClassif", 
     "RLearner", "Learner")), task = structure(list(type = "classif", env = <environment>, 
         weights = NULL, blocking = NULL, coordinates = NULL, task.desc = structure(list(
             id = "binary", type = "classif", target = "Class", size = 208L, n.feat = c(numerics = 60L, 
             factors = 0L, ordered = 0L, functionals = 0L), has.missings = FALSE, has.weights = FALSE, 
             has.blocking = FALSE, has.coordinates = FALSE, class.levels = c("M", "R"), 
             positive = "M", negative = "R", class.distribution = structure(c(M = 111L, 
             R = 97L), .Dim = 2L, .Dimnames = list(c("M", "R")), class = "table")), class = c("ClassifTaskDesc", 
         "SupervisedTaskDesc", "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", 
     "Task")), resampling = structure(list(desc = structure(list(split = 0.666666666666667, 
         id = "holdout", iters = 1L, predict = "test", stratify = FALSE), class = c("HoldoutDesc", 
     "ResampleDesc")), size = 208L, train.inds = list(c(60L, 164L, 85L, 182L, 192L, 10L, 
     107L, 180L, 111L, 91L, 190L, 90L, 133L, 112L, 20L, 174L, 48L, 9L, 63L, 181L, 168L, 
     130L, 120L, 184L, 121L, 187L, 100L, 108L, 53L, 27L, 172L, 160L, 122L, 140L, 5L, 83L, 
     131L, 38L, 55L, 40L, 24L, 70L, 69L, 61L, 26L, 23L, 171L, 76L, 43L, 137L, 8L, 167L, 
     125L, 19L, 87L, 32L, 194L, 114L, 135L, 56L, 99L, 14L, 57L, 169L, 118L, 65L, 116L, 
     115L, 195L, 62L, 105L, 154L, 97L, 1L, 64L, 30L, 51L, 81L, 46L, 15L, 153L, 206L, 201L, 
     148L, 13L, 54L, 185L, 109L, 202L, 21L, 16L, 77L, 145L, 161L, 37L, 22L, 88L, 11L, 
     52L, 149L, 143L, 36L, 110L, 101L, 132L, 92L, 94L, 139L, 42L, 129L, 103L, 196L, 6L, 
     199L, 68L, 147L, 104L, 159L, 126L, 151L, 58L, 28L, 179L, 155L, 128L, 82L, 124L, 158L, 
     12L, 170L, 49L, 166L, 106L, 176L, 39L, 78L, 208L, 75L)), test.inds = list(c(204L, 
     84L, 3L, 47L, 98L, 200L, 41L, 205L, 189L, 66L, 134L, 74L, 193L, 33L, 117L, 44L, 197L, 
     142L, 50L, 152L, 95L, 71L, 35L, 178L, 138L, 146L, 29L, 7L, 207L, 177L, 157L, 67L, 
     72L, 150L, 45L, 17L, 86L, 18L, 136L, 96L, 25L, 198L, 80L, 191L, 79L, 156L, 2L, 119L, 
     186L, 183L, 175L, 163L, 4L, 93L, 127L, 203L, 123L, 102L, 113L, 73L, 34L, 165L, 144L, 
     188L, 141L, 59L, 162L, 173L, 31L, 89L)), group = structure(integer(0), .Label = character(0), class = "factor")), class = "ResampleInstance"), 
         measures = list(structure(list(id = "costs", minimize = TRUE, properties = c("classif", 
         "classif.multi", "req.pred", "req.truth", "predtype.response", "predtype.prob"
         ), fun = function (task, model, pred, feats, extra.args) 
         {
             td = pred$task.desc
             levs = td$class.levels
             if (any(dim(costs))) {
                 if (any(dim(costs) != length(levs))) 
                     stop("Dimensions of costs have to be the same as number of class levels!")
                 rns = rownames(costs)
                 cns = colnames(costs)
                 if (!setequal(rns, levs) || !setequal(cns, levs)) 
                     stop("Row and column names of cost matrix have to equal class levels!")
             }
             costs = extra.args[[1L]]
             r = pred$data$response
             if (anyMissing(r)) 
                 return(NA_real_)
             cc = function(truth, pred) {
                 costs[truth, pred]
             }
             y = mapply(cc, as.character(pred$data$truth), as.character(r))
             combine(y)
         }, extra.args = list(costs = structure(c(0, 5, 1, 0), .Dim = c(2L, 2L), .Dimnames = list(
             c("M", "R"), c("M", "R"))), combine = function (x, ...) 
         UseMethod("mean")), best = 0, worst = 5, name = "costs", note = "", aggr = structure(list(
             id = "test.mean", name = "Test mean", fun = function (task, perf.test, perf.train, 
                 measure, group, pred) 
             mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure")), 
         par.set = structure(list(pars = list(method = structure(list(id = "method", type = "discrete", 
             len = 1L, lower = NULL, upper = NULL, values = list(moment = "moment"), cnames = NULL, 
             allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, 
             tunable = TRUE, special.vals = list()), class = "Param")), forbidden = NULL), class = "ParamSet"), 
         bits.to.features = NULL, control = structure(list(same.resampling.instance = TRUE, 
             impute.val = 5, tune.threshold = TRUE, tune.threshold.args = list(), log.fun = function (learner, 
                 task, resampling, measures, par.set, control, opt.path, dob, x, y, remove.nas, 
                 stage, prev.stage) 
             {
                 x.string = paramValueToString(par.set, x, show.missing.values = !remove.nas)
                 if (inherits(learner, "ModelMultiplexer")) 
                     x.string = stri_replace_all(x.string, "", regex = stri_paste(x$selected.learner, 
                       "\\."))
                 logFunDefault(learner, task, resampling, measures, par.set, control, 
                     opt.path, dob, x.string, y, remove.nas, stage, prev.stage, prefixes = c("Tune-x", 
                       "Tune-y"))
             }, final.dw.perc = NULL, extra.args = list(resolution = 10L)), class = c("TuneControlGrid", 
         "TuneControl", "OptControl")), opt.path = structure(list(par.set = structure(list(
             pars = list(method = structure(list(id = "method", type = "discrete", len = 1L, 
                 lower = NULL, upper = NULL, values = list(moment = "moment"), cnames = NULL, 
                 allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, 
                 requires = NULL, tunable = TRUE, special.vals = list()), class = "Param")), 
             forbidden = NULL), class = "ParamSet"), y.names = "costs.test.mean", minimize = c(costs.test.mean = TRUE), 
             add.transformed.x = FALSE, env = <environment>), class = c("OptPathDF", "OptPath"
         )), show.info = FALSE, remove.nas = TRUE, resample.fun = function (learner, task, 
             resampling, measures, weights = NULL, models = FALSE, extract, keep.pred = TRUE, 
             ..., show.info = getMlrOption("show.info")) 
         {
             learner = checkLearner(learner)
             learner = setHyperPars(learner, ...)
             assertClass(task, classes = "Task")
             n = getTaskSize(task)
             if (inherits(resampling, "ResampleDesc")) 
                 resampling = makeResampleInstance(resampling, task = task)
             assertClass(resampling, classes = "ResampleInstance")
             measures = checkMeasures(measures, task)
             if (!is.null(weights)) {
                 assertNumeric(weights, len = n, any.missing = FALSE, lower = 0)
             }
             assertFlag(models)
             if (missing(extract)) 
                 extract = function(model) {
                 }
             else assertFunction(extract)
             assertFlag(show.info)
             r = resampling$size
             if (n != r) 
                 stop(stri_paste("Size of data set:", n, "and resampling instance:", r, 
                     "differ!", sep = " "))
             checkLearnerBeforeTrain(task, learner, weights)
             checkAggrsBeforeResample(measures, resampling$desc)
             rin = resampling
             more.args = list(learner = learner, task = task, rin = rin, weights = NULL, 
                 measures = measures, model = models, extract = extract, show.info = show.info)
             if (!is.null(weights)) {
                 more.args$weights = weights
             }
             else if (!is.null(getTaskWeights(task))) {
                 more.args$weights = getTaskWeights(task)
             }
             parallelLibrary("mlr", master = FALSE, level = "mlr.resample", show.info = FALSE)
             exportMlrOptions(level = "mlr.resample")
             if (show.info) {
                 messagef("Resampling: %s", rin$desc$id)
                 measure.lognames = extractSubList(measures, "id")
                 if (rin$desc$predict == "both") {
                     id.train = which(vlapply(measures, function(x) "req.train" %in% x$aggr$properties))
                     id.test = which(vlapply(measures, function(x) "req.test" %in% x$aggr$properties))
                     measure.lognames = c(stri_paste(measure.lognames[id.train], "train", 
                       sep = "."), stri_paste(measure.lognames[id.test], "test", sep = "."))
                 }
                 printResampleFormatLine("Measures:", measure.lognames)
             }
             time1 = Sys.time()
             iter.results = parallelMap(doResampleIteration, seq_len(rin$desc$iters), 
                 level = "mlr.resample", more.args = more.args)
             time2 = Sys.time()
             runtime = as.numeric(difftime(time2, time1, units = "secs"))
             addClasses(mergeResampleResult(learner$id, task, iter.results, measures, 
                 rin, models, extract, keep.pred, show.info, runtime), "ResampleResult")
         })
  17: measureTime({
         r = resample.fun(learner2, task, resampling, measures = measures, show.info = FALSE)
     })
  18: force(expr)
  19: resample.fun(learner2, task, resampling, measures = measures, show.info = FALSE)
  20: parallelMap(doResampleIteration, seq_len(rin$desc$iters), level = "mlr.resample", 
         more.args = more.args)
  21: options(parallelMap.nextmap = (getPMOptNextMap() + 1L))
  22: getPMOptNextMap()
  23: getPMOption("nextmap")
  24: getOption(sprintf("parallelMap.%s", opt), def)
  
  ── 12. Error: TuneWrapper works with getTuneResult and getNestedTuneResults (@te
  argument "def" is missing, with no default
  1: resample(lrn2, binaryclass.task, outer, measures = mlr::mmce, extract = getTuneResult) at testthat/test_base_TuneWrapper.R:78
  2: parallelMap(doResampleIteration, seq_len(rin$desc$iters), level = "mlr.resample", 
         more.args = more.args)
  3: mapply(fun2, ..., MoreArgs = more.args, SIMPLIFY = FALSE, USE.NAMES = FALSE)
  4: (function (learner, task, rin, i, measures, weights, model, extract, show.info) 
     {
         setSlaveOptions()
         train.i = rin$train.inds[[i]]
         test.i = rin$test.inds[[i]]
         calculateResampleIterationResult(learner = learner, task = task, i = i, train.i = train.i, 
             test.i = test.i, measures = measures, weights = weights, rdesc = rin$desc, 
             model = model, extract = extract, show.info = show.info)
     })(dots[[1L]][[1L]], learner = structure(list(id = "classif.ksvm.tuned", type = "classif", 
         package = "kernlab", properties = NULL, par.set = structure(list(pars = list(), 
             forbidden = NULL), class = "ParamSet"), par.vals = list(), predict.type = "response", 
         fix.factors.prediction = FALSE, next.learner = structure(list(id = "classif.ksvm", 
             type = "classif", package = "kernlab", properties = c("twoclass", "multiclass", 
             "numerics", "factors", "prob", "class.weights"), par.set = structure(list(
                 pars = list(scaled = structure(list(id = "scaled", type = "logical", 
                     len = 1L, lower = NULL, upper = NULL, values = list(`TRUE` = TRUE, 
                       `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = TRUE, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), type = structure(list(
                     id = "type", type = "discrete", len = 1L, lower = NULL, upper = NULL, 
                     values = list(`C-svc` = "C-svc", `nu-svc` = "nu-svc", `C-bsvc` = "C-bsvc", 
                       `spoc-svc` = "spoc-svc", `kbb-svc` = "kbb-svc"), cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = "C-svc", trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), kernel = structure(list(id = "kernel", type = "discrete", 
                     len = 1L, lower = NULL, upper = NULL, values = list(vanilladot = "vanilladot", 
                       polydot = "polydot", rbfdot = "rbfdot", tanhdot = "tanhdot", laplacedot = "laplacedot", 
                       besseldot = "besseldot", anovadot = "anovadot", splinedot = "splinedot"), 
                     cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = "rbfdot", 
                     trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), C = structure(list(
                     id = "C", type = "numeric", len = 1L, lower = 0, upper = Inf, values = NULL, 
                     cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 1, 
                     trafo = NULL, requires = type %in% c("C-svc", "C-bsvc", "spoc-svc", 
                       "kbb-svc"), tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), nu = structure(list(id = "nu", type = "numeric", len = 1L, 
                     lower = 0, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 0.2, trafo = NULL, requires = type == 
                       "nu-svc", tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), epsilon = structure(list(id = "epsilon", type = "numeric", 
                     len = 1L, lower = -Inf, upper = Inf, values = NULL, cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = 0.1, trafo = NULL, 
                     requires = type %in% c("eps-svr", "nu-svr", "eps-bsvm"), tunable = TRUE, 
                     special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), sigma = structure(list(id = "sigma", type = "numeric", len = 1L, 
                     lower = 0, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = FALSE, default = NULL, trafo = NULL, requires = kernel %in% 
                       c("rbfdot", "anovadot", "besseldot", "laplacedot"), tunable = TRUE, 
                     special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), degree = structure(list(id = "degree", type = "integer", len = 1L, 
                     lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 3L, trafo = NULL, requires = kernel %in% 
                       c("polydot", "anovadot", "besseldot"), tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), scale = structure(list(
                     id = "scale", type = "numeric", len = 1L, lower = 0, upper = Inf, 
                     values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = 1, trafo = NULL, requires = kernel %in% c("polydot", "tanhdot"), 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), offset = structure(list(id = "offset", type = "numeric", len = 1L, 
                     lower = -Inf, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 1, trafo = NULL, requires = kernel %in% 
                       c("polydot", "tanhdot"), tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), order = structure(list(
                     id = "order", type = "integer", len = 1L, lower = -Inf, upper = Inf, 
                     values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = 1L, trafo = NULL, requires = kernel == "besseldot", tunable = TRUE, 
                     special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), tol = structure(list(id = "tol", type = "numeric", len = 1L, 
                     lower = 0, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 0.001, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), shrinking = structure(list(id = "shrinking", type = "logical", 
                     len = 1L, lower = NULL, upper = NULL, values = list(`TRUE` = TRUE, 
                       `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = TRUE, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), class.weights = structure(list(
                     id = "class.weights", type = "numericvector", len = NA_integer_, 
                     lower = 0, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), fit = structure(list(id = "fit", type = "logical", len = 1L, 
                     lower = NULL, upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), 
                     cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = TRUE, 
                     trafo = NULL, requires = NULL, tunable = FALSE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), cache = structure(list(
                     id = "cache", type = "integer", len = 1L, lower = 1L, upper = Inf, 
                     values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = 40L, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param"))), forbidden = NULL), class = c("LearnerParamSet", 
             "ParamSet")), par.vals = list(fit = FALSE), predict.type = "response", name = "Support Vector Machines", 
             short.name = "ksvm", note = "Kernel parameters have to be passed directly and not by using the `kpar` list in `ksvm`. Note that `fit` has been set to `FALSE` by default for speed.", 
             callees = "ksvm", help.list = list(sigma = "Argument of: kernlab::ksvm\n\nfor the ANOVA kernel \"anovadot\".", 
                 degree = "Argument of: kernlab::ksvm\n\nfor the ANOVA kernel \"anovadot\".", 
                 scale = "Argument of: kernlab::ksvm\n\nfor the Hyperbolic tangent kernel function \"tanhdot\"", 
                 offset = "Argument of: kernlab::ksvm\n\nfor the Hyperbolic tangent kernel function \"tanhdot\"", 
                 order = "Argument of: kernlab::ksvm\n\nfor the Bessel kernel \"besseldot\".", 
                 scaled = "Argument of: kernlab::ksvm\n\nA logical vector indicating the variables to be scaled. If scaled is of length 1, the value is recycled as many times as needed and all non-binary variables are scaled. Per default, data are scaled internally (both x and y variables) to zero mean and unit variance. The center and scale values are returned and used for later predictions.", 
                 type = "Argument of: kernlab::ksvm\n\nksvm can be used for classification , for regression, or for novelty detection. Depending on whether y is a factor or not, the default setting for type is C-svc or eps-svr, respectively, but can be overwritten by setting an explicit value. Valid options are:\n\nC-svc   C classification\n\nnu-svc  nu classification\n\nC-bsvc  bound-constraint svm classification\n\nspoc-svc  Crammer, Singer native multi-class\n\nkbb-svc  Weston, Watkins native multi-class\n\none-svc  novelty detection\n\neps-svr  epsilon regression\n\nnu-svr   nu regression\n\neps-bsvr  bound-constraint svm regression", 
                 kernel = "Argument of: kernlab::ksvm\n\nthe kernel function used in training and predicting. This parameter can be set to any function, of class kernel, which computes the inner product in feature space between two vector arguments (see kernels). kernlab provides the most popular kernel functions which can be used by setting the kernel parameter to the following strings:\n\nrbfdot Radial Basis kernel \"Gaussian\"\n\npolydot Polynomial kernel\n\nvanilladot Linear kernel\n\ntanhdot Hyperbolic tangent kernel\n\nlaplacedot Laplacian kernel\n\nbesseldot Bessel kernel\n\nanovadot ANOVA RBF kernel\n\nsplinedot Spline kernel\n\nstringdot String kernel\n\nSetting the kernel parameter to \"matrix\" treats x as a kernel matrix calling the kernelMatrix interface. The kernel parameter can also be set to a user defined function of class kernel by passing the function name as an argument.", 
                 C = "Argument of: kernlab::ksvm\n\ncost of constraints violation (default: 1) this is the ‘C’-constant of the regularization term in the Lagrange formulation.", 
                 nu = "Argument of: kernlab::ksvm\n\nparameter needed for nu-svc, one-svc, and nu-svr. The nu parameter sets the upper bound on the training error and the lower bound on the fraction of data points to become Support Vectors (default: 0.2).", 
                 epsilon = "Argument of: kernlab::ksvm\n\nepsilon in the insensitive-loss function used for eps-svr, nu-svr and eps-bsvm (default: 0.1)", 
                 class.weights = "Argument of: kernlab::ksvm\n\na named vector of weights for the different classes, used for asymmetric class sizes. Not all factor levels have to be supplied (default weight: 1). All components have to be named.", 
                 cache = "Argument of: kernlab::ksvm\n\ncache memory in MB (default 40)", 
                 tol = "Argument of: kernlab::ksvm\n\ntolerance of termination criterion (default: 0.001)", 
                 shrinking = "Argument of: kernlab::ksvm\n\noption whether to use the shrinking-heuristics (default: TRUE)", 
                 fit = "Argument of: kernlab::ksvm\n\nindicates whether the fitted values should be computed and included in the model or not (default: TRUE)"), 
             class.weights.param = "class.weights", config = list(), fix.factors.prediction = FALSE), class = c("classif.ksvm", 
         "RLearnerClassif", "RLearner", "Learner")), model.subclass = "TuneModel", resampling = structure(list(
             split = 0.666666666666667, id = "holdout", iters = 1L, predict = "test", 
             stratify = FALSE), class = c("HoldoutDesc", "ResampleDesc")), measures = list(
             structure(list(id = "mmce", minimize = TRUE, properties = c("classif", "classif.multi", 
             "req.pred", "req.truth"), fun = function (task, model, pred, feats, extra.args) 
             {
                 measureMMCE(pred$data$truth, pred$data$response)
             }, extra.args = list(), best = 0, worst = 1, name = "Mean misclassification error", 
                 note = "Defined as: mean(response != truth)", aggr = structure(list(id = "test.mean", 
                     name = "Test mean", fun = function (task, perf.test, perf.train, 
                       measure, group, pred) 
                     mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure")), 
         opt.pars = structure(list(pars = list(C = structure(list(id = "C", type = "discrete", 
             len = 1L, lower = NULL, upper = NULL, values = list(`1` = 1, `1e-06` = 1e-06), 
             cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, 
             requires = NULL, tunable = TRUE, special.vals = list()), class = "Param")), 
             forbidden = NULL), class = "ParamSet"), bit.names = character(0), bits.to.features = function () 
         {
         }, control = structure(list(same.resampling.instance = TRUE, impute.val = NULL, 
             tune.threshold = FALSE, tune.threshold.args = list(), log.fun = function (learner, 
                 task, resampling, measures, par.set, control, opt.path, dob, x, y, remove.nas, 
                 stage, prev.stage) 
             {
                 x.string = paramValueToString(par.set, x, show.missing.values = !remove.nas)
                 if (inherits(learner, "ModelMultiplexer")) 
                     x.string = stri_replace_all(x.string, "", regex = stri_paste(x$selected.learner, 
                       "\\."))
                 logFunDefault(learner, task, resampling, measures, par.set, control, 
                     opt.path, dob, x.string, y, remove.nas, stage, prev.stage, prefixes = c("Tune-x", 
                       "Tune-y"))
             }, final.dw.perc = NULL, extra.args = list(resolution = 10L)), class = c("TuneControlGrid", 
         "TuneControl", "OptControl")), show.info = FALSE), class = c("TuneWrapper", "OptWrapper", 
     "BaseWrapper", "Learner")), task = structure(list(type = "classif", env = <environment>, 
         weights = NULL, blocking = NULL, coordinates = NULL, task.desc = structure(list(
             id = "binary", type = "classif", target = "Class", size = 208L, n.feat = c(numerics = 60L, 
             factors = 0L, ordered = 0L, functionals = 0L), has.missings = FALSE, has.weights = FALSE, 
             has.blocking = FALSE, has.coordinates = FALSE, class.levels = c("M", "R"), 
             positive = "M", negative = "R", class.distribution = structure(c(M = 111L, 
             R = 97L), .Dim = 2L, .Dimnames = list(c("M", "R")), class = "table")), class = c("ClassifTaskDesc", 
         "SupervisedTaskDesc", "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", 
     "Task")), rin = structure(list(desc = structure(list(id = "cross-validation", iters = 2L, 
         predict = "test", stratify = FALSE), class = c("CVDesc", "ResampleDesc")), size = 208L, 
         train.inds = list(c(45L, 137L, 82L, 56L, 188L, 133L, 11L, 76L, 91L, 106L, 132L, 
         48L, 72L, 207L, 149L, 28L, 143L, 97L, 186L, 198L, 122L, 127L, 27L, 65L, 75L, 
         203L, 157L, 146L, 79L, 51L, 205L, 128L, 1L, 24L, 155L, 144L, 89L, 187L, 174L, 
         8L, 86L, 38L, 130L, 109L, 99L, 125L, 12L, 2L, 200L, 134L, 42L, 6L, 165L, 199L, 
         84L, 177L, 14L, 4L, 190L, 129L, 185L, 62L, 70L, 40L, 196L, 150L, 32L, 171L, 17L, 
         160L, 112L, 16L, 33L, 147L, 41L, 197L, 136L, 105L, 58L, 167L, 23L, 57L, 31L, 
         181L, 22L, 113L, 119L, 96L, 103L, 151L, 178L, 21L, 115L, 102L, 107L, 121L, 34L, 
         5L, 126L, 117L, 15L, 67L, 153L, 60L), c(36L, 208L, 100L, 52L, 10L, 141L, 71L, 
         163L, 182L, 142L, 172L, 116L, 80L, 206L, 192L, 30L, 110L, 54L, 124L, 68L, 164L, 
         43L, 37L, 98L, 44L, 87L, 145L, 104L, 88L, 3L, 74L, 183L, 173L, 154L, 159L, 201L, 
         19L, 179L, 9L, 193L, 7L, 13L, 93L, 118L, 94L, 92L, 140L, 83L, 18L, 156L, 49L, 
         53L, 108L, 158L, 35L, 184L, 101L, 29L, 66L, 202L, 90L, 111L, 25L, 26L, 152L, 
         191L, 39L, 180L, 69L, 189L, 175L, 63L, 138L, 61L, 85L, 135L, 139L, 73L, 81L, 
         123L, 20L, 170L, 176L, 46L, 47L, 78L, 162L, 120L, 194L, 95L, 168L, 148L, 64L, 
         195L, 77L, 131L, 169L, 204L, 59L, 161L, 55L, 166L, 114L, 50L)), test.inds = list(
             c(3L, 7L, 9L, 10L, 13L, 18L, 19L, 20L, 25L, 26L, 29L, 30L, 35L, 36L, 37L, 
             39L, 43L, 44L, 46L, 47L, 49L, 50L, 52L, 53L, 54L, 55L, 59L, 61L, 63L, 64L, 
             66L, 68L, 69L, 71L, 73L, 74L, 77L, 78L, 80L, 81L, 83L, 85L, 87L, 88L, 90L, 
             92L, 93L, 94L, 95L, 98L, 100L, 101L, 104L, 108L, 110L, 111L, 114L, 116L, 
             118L, 120L, 123L, 124L, 131L, 135L, 138L, 139L, 140L, 141L, 142L, 145L, 148L, 
             152L, 154L, 156L, 158L, 159L, 161L, 162L, 163L, 164L, 166L, 168L, 169L, 170L, 
             172L, 173L, 175L, 176L, 179L, 180L, 182L, 183L, 184L, 189L, 191L, 192L, 193L, 
             194L, 195L, 201L, 202L, 204L, 206L, 208L), c(1L, 2L, 4L, 5L, 6L, 8L, 11L, 
             12L, 14L, 15L, 16L, 17L, 21L, 22L, 23L, 24L, 27L, 28L, 31L, 32L, 33L, 34L, 
             38L, 40L, 41L, 42L, 45L, 48L, 51L, 56L, 57L, 58L, 60L, 62L, 65L, 67L, 70L, 
             72L, 75L, 76L, 79L, 82L, 84L, 86L, 89L, 91L, 96L, 97L, 99L, 102L, 103L, 105L, 
             106L, 107L, 109L, 112L, 113L, 115L, 117L, 119L, 121L, 122L, 125L, 126L, 127L, 
             128L, 129L, 130L, 132L, 133L, 134L, 136L, 137L, 143L, 144L, 146L, 147L, 149L, 
             150L, 151L, 153L, 155L, 157L, 160L, 165L, 167L, 171L, 174L, 177L, 178L, 181L, 
             185L, 186L, 187L, 188L, 190L, 196L, 197L, 198L, 199L, 200L, 203L, 205L, 207L
             )), group = structure(integer(0), .Label = character(0), class = "factor")), class = "ResampleInstance"), 
         weights = NULL, measures = list(structure(list(id = "mmce", minimize = TRUE, 
             properties = c("classif", "classif.multi", "req.pred", "req.truth"), fun = function (task, 
                 model, pred, feats, extra.args) 
             {
                 measureMMCE(pred$data$truth, pred$data$response)
             }, extra.args = list(), best = 0, worst = 1, name = "Mean misclassification error", 
             note = "Defined as: mean(response != truth)", aggr = structure(list(id = "test.mean", 
                 name = "Test mean", fun = function (task, perf.test, perf.train, measure, 
                     group, pred) 
                 mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure")), 
         model = FALSE, extract = function (object) 
         {
             assertClass(object, "TuneModel")
             object$learner.model$opt.result
         }, show.info = FALSE)
  5: calculateResampleIterationResult(learner = learner, task = task, i = i, train.i = train.i, 
         test.i = test.i, measures = measures, weights = weights, rdesc = rin$desc, model = model, 
         extract = extract, show.info = show.info)
  6: train(learner, task, subset = train.i, weights = weights[train.i])
  7: measureTime(fun1({
         learner.model = fun2(fun3(do.call(trainLearner, pars)))
     }))
  8: force(expr)
  9: fun1({
         learner.model = fun2(fun3(do.call(trainLearner, pars)))
     })
  10: fun2(fun3(do.call(trainLearner, pars)))
  ...
  20: mapply(fun2, ..., MoreArgs = more.args, SIMPLIFY = FALSE, USE.NAMES = FALSE)
  21: (function (learner, task, resampling, measures, par.set, bits.to.features, control, 
         opt.path, show.info, dob, state, remove.nas, resample.fun) 
     {
         setSlaveOptions()
         y = setNames(rep(NA_real_, length(measures)), vcapply(measures, measureAggrName))
         errmsg = NA_character_
         exec.time = NA_real_
         set.pars.ok = TRUE
         learner2 = learner
         threshold = NULL
         log.fun = control$log.fun
         err.dumps = list()
         if (inherits(control, "TuneControl") || inherits(control, "TuneMultiCritControl")) {
             state = setValueCNames(par.set, state)
             state = trafoValue(par.set, state)
             state2 = if (remove.nas) 
                 removeMissingValues(state)
             else state
             learner2 = try(setHyperPars(learner, par.vals = state2), silent = TRUE)
             if (is.error(learner2)) {
                 set.pars.ok = FALSE
                 errmsg = as.character(learner2)
                 if (show.info) 
                     messagef("[Tune-x] Setting hyperpars failed: %s", errmsg)
             }
         }
         else if (inherits(control, "FeatSelControl")) {
             task = subsetTask(task, features = bits.to.features(state, task))
         }
         if (show.info) 
             prev.stage = log.fun(learner, task, resampling, measures, par.set, control, 
                 opt.path, dob, state, NA_real_, remove.nas, stage = 1L)
         if (set.pars.ok) {
             exec.time = measureTime({
                 r = resample.fun(learner2, task, resampling, measures = measures, show.info = FALSE)
             })
             if (control$tune.threshold) {
                 th.args = control$tune.threshold.args
                 th.args$pred = r$pred
                 th.args$measure = measures[[1L]]
                 tune.th.res = do.call(tuneThreshold, th.args)
                 threshold = tune.th.res$th
                 y = performance(setThreshold(r$pred, threshold = threshold), measures = measures)
                 names(y) = names(r$aggr)
             }
             else {
                 y = r$aggr
             }
             errmsgs = as.character(t(r$err.msgs[, -1L]))
             notna = !is.na(errmsgs)
             if (any(notna)) 
                 errmsg = errmsgs[notna][1L]
             err.dumps = r$err.dumps
         }
         else {
             if (control$tune.threshold) 
                 threshold = NA_real_
         }
         if (show.info) 
             log.fun(learner, task, resampling, measures, par.set, control, opt.path, 
                 dob, state, y, remove.nas, stage = 2L, prev.stage = prev.stage)
         list(y = y, exec.time = exec.time, errmsg = errmsg, threshold = threshold, err.dumps = err.dumps)
     })(dots[[1L]][[1L]], dots[[2L]][[1L]], learner = structure(list(id = "classif.ksvm", 
         type = "classif", package = "kernlab", properties = c("twoclass", "multiclass", 
         "numerics", "factors", "prob", "class.weights"), par.set = structure(list(pars = list(
             scaled = structure(list(id = "scaled", type = "logical", len = 1L, lower = NULL, 
                 upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, 
                 allow.inf = FALSE, has.default = TRUE, default = TRUE, trafo = NULL, 
                 requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), type = structure(list(id = "type", type = "discrete", len = 1L, 
                 lower = NULL, upper = NULL, values = list(`C-svc` = "C-svc", `nu-svc` = "nu-svc", 
                     `C-bsvc` = "C-bsvc", `spoc-svc` = "spoc-svc", `kbb-svc` = "kbb-svc"), 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = "C-svc", 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), kernel = structure(list(
                 id = "kernel", type = "discrete", len = 1L, lower = NULL, upper = NULL, 
                 values = list(vanilladot = "vanilladot", polydot = "polydot", rbfdot = "rbfdot", 
                     tanhdot = "tanhdot", laplacedot = "laplacedot", besseldot = "besseldot", 
                     anovadot = "anovadot", splinedot = "splinedot"), cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = "rbfdot", trafo = NULL, requires = NULL, 
                 tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), C = structure(list(id = "C", type = "numeric", len = 1L, lower = 0, 
                 upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 1, trafo = NULL, requires = type %in% c("C-svc", "C-bsvc", 
                     "spoc-svc", "kbb-svc"), tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), nu = structure(list(id = "nu", type = "numeric", len = 1L, lower = 0, 
                 upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 0.2, trafo = NULL, requires = type == "nu-svc", tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), epsilon = structure(list(id = "epsilon", type = "numeric", len = 1L, 
                 lower = -Inf, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 0.1, trafo = NULL, requires = type %in% 
                     c("eps-svr", "nu-svr", "eps-bsvm"), tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), sigma = structure(list(
                 id = "sigma", type = "numeric", len = 1L, lower = 0, upper = Inf, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, 
                 trafo = NULL, requires = kernel %in% c("rbfdot", "anovadot", "besseldot", 
                     "laplacedot"), tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), degree = structure(list(id = "degree", type = "integer", len = 1L, 
                 lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 3L, trafo = NULL, requires = kernel %in% 
                     c("polydot", "anovadot", "besseldot"), tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), scale = structure(list(
                 id = "scale", type = "numeric", len = 1L, lower = 0, upper = Inf, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 1, trafo = NULL, 
                 requires = kernel %in% c("polydot", "tanhdot"), tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), offset = structure(list(
                 id = "offset", type = "numeric", len = 1L, lower = -Inf, upper = Inf, 
                 values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 1, trafo = NULL, requires = kernel %in% c("polydot", "tanhdot"), 
                 tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), order = structure(list(id = "order", type = "integer", len = 1L, 
                 lower = -Inf, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 1L, trafo = NULL, requires = kernel == 
                     "besseldot", tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), tol = structure(list(id = "tol", type = "numeric", len = 1L, lower = 0, 
                 upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 0.001, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), shrinking = structure(list(
                 id = "shrinking", type = "logical", len = 1L, lower = NULL, upper = NULL, 
                 values = list(`TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = TRUE, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), class.weights = structure(list(id = "class.weights", type = "numericvector", 
                 len = NA_integer_, lower = 0, upper = Inf, values = NULL, cnames = NULL, 
                 allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, 
                 requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), fit = structure(list(id = "fit", type = "logical", len = 1L, lower = NULL, 
                 upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, 
                 allow.inf = FALSE, has.default = TRUE, default = TRUE, trafo = NULL, 
                 requires = NULL, tunable = FALSE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), cache = structure(list(id = "cache", type = "integer", len = 1L, 
                 lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 40L, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             ))), forbidden = NULL), class = c("LearnerParamSet", "ParamSet")), par.vals = list(
             fit = FALSE), predict.type = "response", name = "Support Vector Machines", 
         short.name = "ksvm", note = "Kernel parameters have to be passed directly and not by using the `kpar` list in `ksvm`. Note that `fit` has been set to `FALSE` by default for speed.", 
         callees = "ksvm", help.list = list(sigma = "Argument of: kernlab::ksvm\n\nfor the ANOVA kernel \"anovadot\".", 
             degree = "Argument of: kernlab::ksvm\n\nfor the ANOVA kernel \"anovadot\".", 
             scale = "Argument of: kernlab::ksvm\n\nfor the Hyperbolic tangent kernel function \"tanhdot\"", 
             offset = "Argument of: kernlab::ksvm\n\nfor the Hyperbolic tangent kernel function \"tanhdot\"", 
             order = "Argument of: kernlab::ksvm\n\nfor the Bessel kernel \"besseldot\".", 
             scaled = "Argument of: kernlab::ksvm\n\nA logical vector indicating the variables to be scaled. If scaled is of length 1, the value is recycled as many times as needed and all non-binary variables are scaled. Per default, data are scaled internally (both x and y variables) to zero mean and unit variance. The center and scale values are returned and used for later predictions.", 
             type = "Argument of: kernlab::ksvm\n\nksvm can be used for classification , for regression, or for novelty detection. Depending on whether y is a factor or not, the default setting for type is C-svc or eps-svr, respectively, but can be overwritten by setting an explicit value. Valid options are:\n\nC-svc   C classification\n\nnu-svc  nu classification\n\nC-bsvc  bound-constraint svm classification\n\nspoc-svc  Crammer, Singer native multi-class\n\nkbb-svc  Weston, Watkins native multi-class\n\none-svc  novelty detection\n\neps-svr  epsilon regression\n\nnu-svr   nu regression\n\neps-bsvr  bound-constraint svm regression", 
             kernel = "Argument of: kernlab::ksvm\n\nthe kernel function used in training and predicting. This parameter can be set to any function, of class kernel, which computes the inner product in feature space between two vector arguments (see kernels). kernlab provides the most popular kernel functions which can be used by setting the kernel parameter to the following strings:\n\nrbfdot Radial Basis kernel \"Gaussian\"\n\npolydot Polynomial kernel\n\nvanilladot Linear kernel\n\ntanhdot Hyperbolic tangent kernel\n\nlaplacedot Laplacian kernel\n\nbesseldot Bessel kernel\n\nanovadot ANOVA RBF kernel\n\nsplinedot Spline kernel\n\nstringdot String kernel\n\nSetting the kernel parameter to \"matrix\" treats x as a kernel matrix calling the kernelMatrix interface. The kernel parameter can also be set to a user defined function of class kernel by passing the function name as an argument.", 
             C = "Argument of: kernlab::ksvm\n\ncost of constraints violation (default: 1) this is the ‘C’-constant of the regularization term in the Lagrange formulation.", 
             nu = "Argument of: kernlab::ksvm\n\nparameter needed for nu-svc, one-svc, and nu-svr. The nu parameter sets the upper bound on the training error and the lower bound on the fraction of data points to become Support Vectors (default: 0.2).", 
             epsilon = "Argument of: kernlab::ksvm\n\nepsilon in the insensitive-loss function used for eps-svr, nu-svr and eps-bsvm (default: 0.1)", 
             class.weights = "Argument of: kernlab::ksvm\n\na named vector of weights for the different classes, used for asymmetric class sizes. Not all factor levels have to be supplied (default weight: 1). All components have to be named.", 
             cache = "Argument of: kernlab::ksvm\n\ncache memory in MB (default 40)", 
             tol = "Argument of: kernlab::ksvm\n\ntolerance of termination criterion (default: 0.001)", 
             shrinking = "Argument of: kernlab::ksvm\n\noption whether to use the shrinking-heuristics (default: TRUE)", 
             fit = "Argument of: kernlab::ksvm\n\nindicates whether the fitted values should be computed and included in the model or not (default: TRUE)"), 
         class.weights.param = "class.weights", config = list(), fix.factors.prediction = FALSE), class = c("classif.ksvm", 
     "RLearnerClassif", "RLearner", "Learner")), task = structure(list(type = "classif", 
         env = <environment>, weights = NULL, blocking = NULL, coordinates = NULL, task.desc = structure(list(
             id = "binary", type = "classif", target = "Class", size = 104L, n.feat = c(numerics = 60L, 
             factors = 0L, ordered = 0L, functionals = 0L), has.missings = FALSE, has.weights = FALSE, 
             has.blocking = FALSE, has.coordinates = FALSE, class.levels = c("M", "R"), 
             positive = "M", negative = "R", class.distribution = structure(c(M = 56L, 
             R = 48L), .Dim = 2L, .Dimnames = list(c("M", "R")), class = "table")), class = c("ClassifTaskDesc", 
         "SupervisedTaskDesc", "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", 
     "Task")), resampling = structure(list(desc = structure(list(split = 0.666666666666667, 
         id = "holdout", iters = 1L, predict = "test", stratify = FALSE), class = c("HoldoutDesc", 
     "ResampleDesc")), size = 104L, train.inds = list(c(30L, 82L, 42L, 90L, 95L, 5L, 52L, 
     87L, 53L, 44L, 101L, 43L, 63L, 96L, 10L, 81L, 22L, 4L, 29L, 103L, 75L, 58L, 91L, 
     89L, 85L, 56L, 93L, 46L, 88L, 12L, 72L, 66L, 50L, 57L, 2L, 33L, 98L, 15L, 21L, 16L, 
     94L, 27L, 26L, 23L, 64L, 9L, 14L, 92L, 67L, 48L, 3L, 24L, 102L, 7L, 86L, 11L, 51L, 
     36L, 68L, 17L, 104L, 99L, 45L, 84L, 69L, 18L, 31L, 38L, 74L)), test.inds = list(c(78L, 
     65L, 1L, 37L, 59L, 34L, 62L, 39L, 71L, 77L, 76L, 54L, 28L, 61L, 8L, 35L, 41L, 19L, 
     32L, 83L, 70L, 79L, 73L, 80L, 100L, 6L, 25L, 20L, 55L, 47L, 60L, 40L, 49L, 13L, 97L
     )), group = structure(integer(0), .Label = character(0), class = "factor")), class = "ResampleInstance"), 
         measures = list(structure(list(id = "mmce", minimize = TRUE, properties = c("classif", 
         "classif.multi", "req.pred", "req.truth"), fun = function (task, model, pred, 
             feats, extra.args) 
         {
             measureMMCE(pred$data$truth, pred$data$response)
         }, extra.args = list(), best = 0, worst = 1, name = "Mean misclassification error", 
             note = "Defined as: mean(response != truth)", aggr = structure(list(id = "test.mean", 
                 name = "Test mean", fun = function (task, perf.test, perf.train, measure, 
                     group, pred) 
                 mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure")), 
         par.set = structure(list(pars = list(C = structure(list(id = "C", type = "discrete", 
             len = 1L, lower = NULL, upper = NULL, values = list(`1` = 1, `1e-06` = 1e-06), 
             cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, 
             requires = NULL, tunable = TRUE, special.vals = list()), class = "Param")), 
             forbidden = NULL), class = "ParamSet"), bits.to.features = NULL, control = structure(list(
             same.resampling.instance = TRUE, impute.val = 1, tune.threshold = FALSE, 
             tune.threshold.args = list(), log.fun = function (learner, task, resampling, 
                 measures, par.set, control, opt.path, dob, x, y, remove.nas, stage, prev.stage) 
             {
                 x.string = paramValueToString(par.set, x, show.missing.values = !remove.nas)
                 if (inherits(learner, "ModelMultiplexer")) 
                     x.string = stri_replace_all(x.string, "", regex = stri_paste(x$selected.learner, 
                       "\\."))
                 logFunDefault(learner, task, resampling, measures, par.set, control, 
                     opt.path, dob, x.string, y, remove.nas, stage, prev.stage, prefixes = c("Tune-x", 
                       "Tune-y"))
             }, final.dw.perc = NULL, extra.args = list(resolution = 10L)), class = c("TuneControlGrid", 
         "TuneControl", "OptControl")), opt.path = structure(list(par.set = structure(list(
             pars = list(C = structure(list(id = "C", type = "discrete", len = 1L, lower = NULL, 
                 upper = NULL, values = list(`1` = 1, `1e-06` = 1e-06), cnames = NULL, 
                 allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, 
                 requires = NULL, tunable = TRUE, special.vals = list()), class = "Param")), 
             forbidden = NULL), class = "ParamSet"), y.names = "mmce.test.mean", minimize = c(mmce.test.mean = TRUE), 
             add.transformed.x = FALSE, env = <environment>), class = c("OptPathDF", "OptPath"
         )), show.info = FALSE, remove.nas = TRUE, resample.fun = function (learner, task, 
             resampling, measures, weights = NULL, models = FALSE, extract, keep.pred = TRUE, 
             ..., show.info = getMlrOption("show.info")) 
         {
             learner = checkLearner(learner)
             learner = setHyperPars(learner, ...)
             assertClass(task, classes = "Task")
             n = getTaskSize(task)
             if (inherits(resampling, "ResampleDesc")) 
                 resampling = makeResampleInstance(resampling, task = task)
             assertClass(resampling, classes = "ResampleInstance")
             measures = checkMeasures(measures, task)
             if (!is.null(weights)) {
                 assertNumeric(weights, len = n, any.missing = FALSE, lower = 0)
             }
             assertFlag(models)
             if (missing(extract)) 
                 extract = function(model) {
                 }
             else assertFunction(extract)
             assertFlag(show.info)
             r = resampling$size
             if (n != r) 
                 stop(stri_paste("Size of data set:", n, "and resampling instance:", r, 
                     "differ!", sep = " "))
             checkLearnerBeforeTrain(task, learner, weights)
             checkAggrsBeforeResample(measures, resampling$desc)
             rin = resampling
             more.args = list(learner = learner, task = task, rin = rin, weights = NULL, 
                 measures = measures, model = models, extract = extract, show.info = show.info)
             if (!is.null(weights)) {
                 more.args$weights = weights
             }
             else if (!is.null(getTaskWeights(task))) {
                 more.args$weights = getTaskWeights(task)
             }
             parallelLibrary("mlr", master = FALSE, level = "mlr.resample", show.info = FALSE)
             exportMlrOptions(level = "mlr.resample")
             if (show.info) {
                 messagef("Resampling: %s", rin$desc$id)
                 measure.lognames = extractSubList(measures, "id")
                 if (rin$desc$predict == "both") {
                     id.train = which(vlapply(measures, function(x) "req.train" %in% x$aggr$properties))
                     id.test = which(vlapply(measures, function(x) "req.test" %in% x$aggr$properties))
                     measure.lognames = c(stri_paste(measure.lognames[id.train], "train", 
                       sep = "."), stri_paste(measure.lognames[id.test], "test", sep = "."))
                 }
                 printResampleFormatLine("Measures:", measure.lognames)
             }
             time1 = Sys.time()
             iter.results = parallelMap(doResampleIteration, seq_len(rin$desc$iters), 
                 level = "mlr.resample", more.args = more.args)
             time2 = Sys.time()
             runtime = as.numeric(difftime(time2, time1, units = "secs"))
             addClasses(mergeResampleResult(learner$id, task, iter.results, measures, 
                 rin, models, extract, keep.pred, show.info, runtime), "ResampleResult")
         })
  22: measureTime({
         r = resample.fun(learner2, task, resampling, measures = measures, show.info = FALSE)
     })
  23: force(expr)
  24: resample.fun(learner2, task, resampling, measures = measures, show.info = FALSE)
  25: parallelMap(doResampleIteration, seq_len(rin$desc$iters), level = "mlr.resample", 
         more.args = more.args)
  26: options(parallelMap.nextmap = (getPMOptNextMap() + 1L))
  27: getPMOptNextMap()
  28: getPMOption("nextmap")
  29: getOption(sprintf("parallelMap.%s", opt), def)
  
  ── 13. Error: TuneWrapper works with nested sampling and threshold tuning, cf. i
  argument "def" is missing, with no default
  1: resample(lrn2, iris.task, rdesc, measures = mmce) at testthat/test_base_TuneWrapper.R:109
  2: parallelMap(doResampleIteration, seq_len(rin$desc$iters), level = "mlr.resample", 
         more.args = more.args)
  3: mapply(fun2, ..., MoreArgs = more.args, SIMPLIFY = FALSE, USE.NAMES = FALSE)
  4: (function (learner, task, rin, i, measures, weights, model, extract, show.info) 
     {
         setSlaveOptions()
         train.i = rin$train.inds[[i]]
         test.i = rin$test.inds[[i]]
         calculateResampleIterationResult(learner = learner, task = task, i = i, train.i = train.i, 
             test.i = test.i, measures = measures, weights = weights, rdesc = rin$desc, 
             model = model, extract = extract, show.info = show.info)
     })(dots[[1L]][[1L]], learner = structure(list(id = "classif.ksvm.tuned", type = "classif", 
         package = "kernlab", properties = NULL, par.set = structure(list(pars = list(), 
             forbidden = NULL), class = "ParamSet"), par.vals = list(), predict.type = "prob", 
         fix.factors.prediction = FALSE, next.learner = structure(list(id = "classif.ksvm", 
             type = "classif", package = "kernlab", properties = c("twoclass", "multiclass", 
             "numerics", "factors", "prob", "class.weights"), par.set = structure(list(
                 pars = list(scaled = structure(list(id = "scaled", type = "logical", 
                     len = 1L, lower = NULL, upper = NULL, values = list(`TRUE` = TRUE, 
                       `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = TRUE, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), type = structure(list(
                     id = "type", type = "discrete", len = 1L, lower = NULL, upper = NULL, 
                     values = list(`C-svc` = "C-svc", `nu-svc` = "nu-svc", `C-bsvc` = "C-bsvc", 
                       `spoc-svc` = "spoc-svc", `kbb-svc` = "kbb-svc"), cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = "C-svc", trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), kernel = structure(list(id = "kernel", type = "discrete", 
                     len = 1L, lower = NULL, upper = NULL, values = list(vanilladot = "vanilladot", 
                       polydot = "polydot", rbfdot = "rbfdot", tanhdot = "tanhdot", laplacedot = "laplacedot", 
                       besseldot = "besseldot", anovadot = "anovadot", splinedot = "splinedot"), 
                     cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = "rbfdot", 
                     trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), C = structure(list(
                     id = "C", type = "numeric", len = 1L, lower = 0, upper = Inf, values = NULL, 
                     cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 1, 
                     trafo = NULL, requires = type %in% c("C-svc", "C-bsvc", "spoc-svc", 
                       "kbb-svc"), tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), nu = structure(list(id = "nu", type = "numeric", len = 1L, 
                     lower = 0, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 0.2, trafo = NULL, requires = type == 
                       "nu-svc", tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), epsilon = structure(list(id = "epsilon", type = "numeric", 
                     len = 1L, lower = -Inf, upper = Inf, values = NULL, cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = 0.1, trafo = NULL, 
                     requires = type %in% c("eps-svr", "nu-svr", "eps-bsvm"), tunable = TRUE, 
                     special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), sigma = structure(list(id = "sigma", type = "numeric", len = 1L, 
                     lower = 0, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = FALSE, default = NULL, trafo = NULL, requires = kernel %in% 
                       c("rbfdot", "anovadot", "besseldot", "laplacedot"), tunable = TRUE, 
                     special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), degree = structure(list(id = "degree", type = "integer", len = 1L, 
                     lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 3L, trafo = NULL, requires = kernel %in% 
                       c("polydot", "anovadot", "besseldot"), tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), scale = structure(list(
                     id = "scale", type = "numeric", len = 1L, lower = 0, upper = Inf, 
                     values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = 1, trafo = NULL, requires = kernel %in% c("polydot", "tanhdot"), 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), offset = structure(list(id = "offset", type = "numeric", len = 1L, 
                     lower = -Inf, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 1, trafo = NULL, requires = kernel %in% 
                       c("polydot", "tanhdot"), tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), order = structure(list(
                     id = "order", type = "integer", len = 1L, lower = -Inf, upper = Inf, 
                     values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = 1L, trafo = NULL, requires = kernel == "besseldot", tunable = TRUE, 
                     special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), tol = structure(list(id = "tol", type = "numeric", len = 1L, 
                     lower = 0, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 0.001, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), shrinking = structure(list(id = "shrinking", type = "logical", 
                     len = 1L, lower = NULL, upper = NULL, values = list(`TRUE` = TRUE, 
                       `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = TRUE, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), class.weights = structure(list(
                     id = "class.weights", type = "numericvector", len = NA_integer_, 
                     lower = 0, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), fit = structure(list(id = "fit", type = "logical", len = 1L, 
                     lower = NULL, upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), 
                     cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = TRUE, 
                     trafo = NULL, requires = NULL, tunable = FALSE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), cache = structure(list(
                     id = "cache", type = "integer", len = 1L, lower = 1L, upper = Inf, 
                     values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = 40L, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param"))), forbidden = NULL), class = c("LearnerParamSet", 
             "ParamSet")), par.vals = list(fit = FALSE), predict.type = "prob", name = "Support Vector Machines", 
             short.name = "ksvm", note = "Kernel parameters have to be passed directly and not by using the `kpar` list in `ksvm`. Note that `fit` has been set to `FALSE` by default for speed.", 
             callees = "ksvm", help.list = list(sigma = "Argument of: kernlab::ksvm\n\nfor the ANOVA kernel \"anovadot\".", 
                 degree = "Argument of: kernlab::ksvm\n\nfor the ANOVA kernel \"anovadot\".", 
                 scale = "Argument of: kernlab::ksvm\n\nfor the Hyperbolic tangent kernel function \"tanhdot\"", 
                 offset = "Argument of: kernlab::ksvm\n\nfor the Hyperbolic tangent kernel function \"tanhdot\"", 
                 order = "Argument of: kernlab::ksvm\n\nfor the Bessel kernel \"besseldot\".", 
                 scaled = "Argument of: kernlab::ksvm\n\nA logical vector indicating the variables to be scaled. If scaled is of length 1, the value is recycled as many times as needed and all non-binary variables are scaled. Per default, data are scaled internally (both x and y variables) to zero mean and unit variance. The center and scale values are returned and used for later predictions.", 
                 type = "Argument of: kernlab::ksvm\n\nksvm can be used for classification , for regression, or for novelty detection. Depending on whether y is a factor or not, the default setting for type is C-svc or eps-svr, respectively, but can be overwritten by setting an explicit value. Valid options are:\n\nC-svc   C classification\n\nnu-svc  nu classification\n\nC-bsvc  bound-constraint svm classification\n\nspoc-svc  Crammer, Singer native multi-class\n\nkbb-svc  Weston, Watkins native multi-class\n\none-svc  novelty detection\n\neps-svr  epsilon regression\n\nnu-svr   nu regression\n\neps-bsvr  bound-constraint svm regression", 
                 kernel = "Argument of: kernlab::ksvm\n\nthe kernel function used in training and predicting. This parameter can be set to any function, of class kernel, which computes the inner product in feature space between two vector arguments (see kernels). kernlab provides the most popular kernel functions which can be used by setting the kernel parameter to the following strings:\n\nrbfdot Radial Basis kernel \"Gaussian\"\n\npolydot Polynomial kernel\n\nvanilladot Linear kernel\n\ntanhdot Hyperbolic tangent kernel\n\nlaplacedot Laplacian kernel\n\nbesseldot Bessel kernel\n\nanovadot ANOVA RBF kernel\n\nsplinedot Spline kernel\n\nstringdot String kernel\n\nSetting the kernel parameter to \"matrix\" treats x as a kernel matrix calling the kernelMatrix interface. The kernel parameter can also be set to a user defined function of class kernel by passing the function name as an argument.", 
                 C = "Argument of: kernlab::ksvm\n\ncost of constraints violation (default: 1) this is the ‘C’-constant of the regularization term in the Lagrange formulation.", 
                 nu = "Argument of: kernlab::ksvm\n\nparameter needed for nu-svc, one-svc, and nu-svr. The nu parameter sets the upper bound on the training error and the lower bound on the fraction of data points to become Support Vectors (default: 0.2).", 
                 epsilon = "Argument of: kernlab::ksvm\n\nepsilon in the insensitive-loss function used for eps-svr, nu-svr and eps-bsvm (default: 0.1)", 
                 class.weights = "Argument of: kernlab::ksvm\n\na named vector of weights for the different classes, used for asymmetric class sizes. Not all factor levels have to be supplied (default weight: 1). All components have to be named.", 
                 cache = "Argument of: kernlab::ksvm\n\ncache memory in MB (default 40)", 
                 tol = "Argument of: kernlab::ksvm\n\ntolerance of termination criterion (default: 0.001)", 
                 shrinking = "Argument of: kernlab::ksvm\n\noption whether to use the shrinking-heuristics (default: TRUE)", 
                 fit = "Argument of: kernlab::ksvm\n\nindicates whether the fitted values should be computed and included in the model or not (default: TRUE)"), 
             class.weights.param = "class.weights", config = list(), fix.factors.prediction = FALSE), class = c("classif.ksvm", 
         "RLearnerClassif", "RLearner", "Learner")), model.subclass = "TuneModel", resampling = structure(list(
             split = 0.666666666666667, id = "holdout", iters = 1L, predict = "test", 
             stratify = FALSE), class = c("HoldoutDesc", "ResampleDesc")), measures = list(
             structure(list(id = "ber", minimize = TRUE, properties = c("classif", "classif.multi", 
             "req.pred", "req.truth"), fun = function (task, model, pred, feats, extra.args) 
             {
                 measureBER(pred$data$truth, pred$data$response)
             }, extra.args = list(), best = 0, worst = 1, name = "Balanced error rate", 
                 note = "Mean of misclassification error rates on all individual classes.", 
                 aggr = structure(list(id = "test.mean", name = "Test mean", fun = function (task, 
                     perf.test, perf.train, measure, group, pred) 
                 mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure"), 
             structure(list(id = "mmce", minimize = TRUE, properties = c("classif", "classif.multi", 
             "req.pred", "req.truth"), fun = function (task, model, pred, feats, extra.args) 
             {
                 measureMMCE(pred$data$truth, pred$data$response)
             }, extra.args = list(), best = 0, worst = 1, name = "Mean misclassification error", 
                 note = "Defined as: mean(response != truth)", aggr = structure(list(id = "test.mean", 
                     name = "Test mean", fun = function (task, perf.test, perf.train, 
                       measure, group, pred) 
                     mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure")), 
         opt.pars = structure(list(pars = list(C = structure(list(id = "C", type = "discrete", 
             len = 1L, lower = NULL, upper = NULL, values = list(`0.5` = 0.5), cnames = NULL, 
             allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, 
             tunable = TRUE, special.vals = list()), class = "Param")), forbidden = NULL), class = "ParamSet"), 
         bit.names = character(0), bits.to.features = function () 
         {
         }, control = structure(list(same.resampling.instance = TRUE, impute.val = NULL, 
             tune.threshold = TRUE, tune.threshold.args = list(nsub = 2L), log.fun = function (learner, 
                 task, resampling, measures, par.set, control, opt.path, dob, x, y, remove.nas, 
                 stage, prev.stage) 
             {
                 x.string = paramValueToString(par.set, x, show.missing.values = !remove.nas)
                 if (inherits(learner, "ModelMultiplexer")) 
                     x.string = stri_replace_all(x.string, "", regex = stri_paste(x$selected.learner, 
                       "\\."))
                 logFunDefault(learner, task, resampling, measures, par.set, control, 
                     opt.path, dob, x.string, y, remove.nas, stage, prev.stage, prefixes = c("Tune-x", 
                       "Tune-y"))
             }, final.dw.perc = NULL, extra.args = list(resolution = 10L)), class = c("TuneControlGrid", 
         "TuneControl", "OptControl")), show.info = FALSE), class = c("TuneWrapper", "OptWrapper", 
     "BaseWrapper", "Learner")), task = structure(list(type = "classif", env = <environment>, 
         weights = NULL, blocking = NULL, coordinates = NULL, task.desc = structure(list(
             id = "iris-example", type = "classif", target = "Species", size = 150L, n.feat = c(numerics = 4L, 
             factors = 0L, ordered = 0L, functionals = 0L), has.missings = FALSE, has.weights = FALSE, 
             has.blocking = FALSE, has.coordinates = FALSE, class.levels = c("setosa", 
             "versicolor", "virginica"), positive = NA_character_, negative = NA_character_, 
             class.distribution = structure(c(setosa = 50L, versicolor = 50L, virginica = 50L
             ), .Dim = 3L, .Dimnames = list(c("setosa", "versicolor", "virginica")), class = "table")), class = c("ClassifTaskDesc", 
         "SupervisedTaskDesc", "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", 
     "Task")), rin = structure(list(desc = structure(list(split = 0.666666666666667, id = "holdout", 
         iters = 1L, predict = "test", stratify = FALSE), class = c("HoldoutDesc", "ResampleDesc"
     )), size = 150L, train.inds = list(c(44L, 118L, 61L, 130L, 138L, 7L, 77L, 128L, 79L, 
     65L, 134L, 64L, 94L, 142L, 14L, 122L, 33L, 6L, 150L, 126L, 116L, 90L, 82L, 127L, 
     83L, 89L, 68L, 74L, 36L, 18L, 147L, 108L, 143L, 146L, 3L, 55L, 87L, 25L, 135L, 26L, 
     16L, 46L, 45L, 40L, 17L, 15L, 113L, 48L, 28L, 114L, 5L, 132L, 137L, 12L, 54L, 20L, 
     97L, 71L, 131L, 35L, 60L, 9L, 34L, 24L, 93L, 39L, 69L, 124L, 66L, 112L, 148L, 50L, 
     56L, 1L, 37L, 106L, 29L, 119L, 111L, 8L, 121L, 47L, 123L, 53L, 145L, 92L, 139L, 57L, 
     115L, 11L, 86L, 85L, 95L, 38L, 70L, 80L, 43L, 100L, 104L, 27L)), test.inds = list(
         c(73L, 141L, 88L, 59L, 21L, 42L, 99L, 78L, 84L, 75L, 107L, 76L, 110L, 49L, 2L, 
         125L, 105L, 149L, 41L, 32L, 58L, 31L, 63L, 19L, 22L, 51L, 133L, 98L, 129L, 81L, 
         72L, 140L, 102L, 103L, 30L, 13L, 52L, 91L, 10L, 120L, 136L, 144L, 101L, 62L, 
         109L, 23L, 96L, 67L, 4L, 117L)), group = structure(integer(0), .Label = character(0), class = "factor")), class = "ResampleInstance"), 
         weights = NULL, measures = list(structure(list(id = "mmce", minimize = TRUE, 
             properties = c("classif", "classif.multi", "req.pred", "req.truth"), fun = function (task, 
                 model, pred, feats, extra.args) 
             {
                 measureMMCE(pred$data$truth, pred$data$response)
             }, extra.args = list(), best = 0, worst = 1, name = "Mean misclassification error", 
             note = "Defined as: mean(response != truth)", aggr = structure(list(id = "test.mean", 
                 name = "Test mean", fun = function (task, perf.test, perf.train, measure, 
                     group, pred) 
                 mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure")), 
         model = FALSE, extract = function (model) 
         {
         }, show.info = FALSE)
  5: calculateResampleIterationResult(learner = learner, task = task, i = i, train.i = train.i, 
         test.i = test.i, measures = measures, weights = weights, rdesc = rin$desc, model = model, 
         extract = extract, show.info = show.info)
  6: train(learner, task, subset = train.i, weights = weights[train.i])
  7: measureTime(fun1({
         learner.model = fun2(fun3(do.call(trainLearner, pars)))
     }))
  8: force(expr)
  9: fun1({
         learner.model = fun2(fun3(do.call(trainLearner, pars)))
     })
  10: fun2(fun3(do.call(trainLearner, pars)))
  ...
  20: mapply(fun2, ..., MoreArgs = more.args, SIMPLIFY = FALSE, USE.NAMES = FALSE)
  21: (function (learner, task, resampling, measures, par.set, bits.to.features, control, 
         opt.path, show.info, dob, state, remove.nas, resample.fun) 
     {
         setSlaveOptions()
         y = setNames(rep(NA_real_, length(measures)), vcapply(measures, measureAggrName))
         errmsg = NA_character_
         exec.time = NA_real_
         set.pars.ok = TRUE
         learner2 = learner
         threshold = NULL
         log.fun = control$log.fun
         err.dumps = list()
         if (inherits(control, "TuneControl") || inherits(control, "TuneMultiCritControl")) {
             state = setValueCNames(par.set, state)
             state = trafoValue(par.set, state)
             state2 = if (remove.nas) 
                 removeMissingValues(state)
             else state
             learner2 = try(setHyperPars(learner, par.vals = state2), silent = TRUE)
             if (is.error(learner2)) {
                 set.pars.ok = FALSE
                 errmsg = as.character(learner2)
                 if (show.info) 
                     messagef("[Tune-x] Setting hyperpars failed: %s", errmsg)
             }
         }
         else if (inherits(control, "FeatSelControl")) {
             task = subsetTask(task, features = bits.to.features(state, task))
         }
         if (show.info) 
             prev.stage = log.fun(learner, task, resampling, measures, par.set, control, 
                 opt.path, dob, state, NA_real_, remove.nas, stage = 1L)
         if (set.pars.ok) {
             exec.time = measureTime({
                 r = resample.fun(learner2, task, resampling, measures = measures, show.info = FALSE)
             })
             if (control$tune.threshold) {
                 th.args = control$tune.threshold.args
                 th.args$pred = r$pred
                 th.args$measure = measures[[1L]]
                 tune.th.res = do.call(tuneThreshold, th.args)
                 threshold = tune.th.res$th
                 y = performance(setThreshold(r$pred, threshold = threshold), measures = measures)
                 names(y) = names(r$aggr)
             }
             else {
                 y = r$aggr
             }
             errmsgs = as.character(t(r$err.msgs[, -1L]))
             notna = !is.na(errmsgs)
             if (any(notna)) 
                 errmsg = errmsgs[notna][1L]
             err.dumps = r$err.dumps
         }
         else {
             if (control$tune.threshold) 
                 threshold = NA_real_
         }
         if (show.info) 
             log.fun(learner, task, resampling, measures, par.set, control, opt.path, 
                 dob, state, y, remove.nas, stage = 2L, prev.stage = prev.stage)
         list(y = y, exec.time = exec.time, errmsg = errmsg, threshold = threshold, err.dumps = err.dumps)
     })(dots[[1L]][[1L]], dots[[2L]][[1L]], learner = structure(list(id = "classif.ksvm", 
         type = "classif", package = "kernlab", properties = c("twoclass", "multiclass", 
         "numerics", "factors", "prob", "class.weights"), par.set = structure(list(pars = list(
             scaled = structure(list(id = "scaled", type = "logical", len = 1L, lower = NULL, 
                 upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, 
                 allow.inf = FALSE, has.default = TRUE, default = TRUE, trafo = NULL, 
                 requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), type = structure(list(id = "type", type = "discrete", len = 1L, 
                 lower = NULL, upper = NULL, values = list(`C-svc` = "C-svc", `nu-svc` = "nu-svc", 
                     `C-bsvc` = "C-bsvc", `spoc-svc` = "spoc-svc", `kbb-svc` = "kbb-svc"), 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = "C-svc", 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), kernel = structure(list(
                 id = "kernel", type = "discrete", len = 1L, lower = NULL, upper = NULL, 
                 values = list(vanilladot = "vanilladot", polydot = "polydot", rbfdot = "rbfdot", 
                     tanhdot = "tanhdot", laplacedot = "laplacedot", besseldot = "besseldot", 
                     anovadot = "anovadot", splinedot = "splinedot"), cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = "rbfdot", trafo = NULL, requires = NULL, 
                 tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), C = structure(list(id = "C", type = "numeric", len = 1L, lower = 0, 
                 upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 1, trafo = NULL, requires = type %in% c("C-svc", "C-bsvc", 
                     "spoc-svc", "kbb-svc"), tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), nu = structure(list(id = "nu", type = "numeric", len = 1L, lower = 0, 
                 upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 0.2, trafo = NULL, requires = type == "nu-svc", tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), epsilon = structure(list(id = "epsilon", type = "numeric", len = 1L, 
                 lower = -Inf, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 0.1, trafo = NULL, requires = type %in% 
                     c("eps-svr", "nu-svr", "eps-bsvm"), tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), sigma = structure(list(
                 id = "sigma", type = "numeric", len = 1L, lower = 0, upper = Inf, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, 
                 trafo = NULL, requires = kernel %in% c("rbfdot", "anovadot", "besseldot", 
                     "laplacedot"), tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), degree = structure(list(id = "degree", type = "integer", len = 1L, 
                 lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 3L, trafo = NULL, requires = kernel %in% 
                     c("polydot", "anovadot", "besseldot"), tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), scale = structure(list(
                 id = "scale", type = "numeric", len = 1L, lower = 0, upper = Inf, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 1, trafo = NULL, 
                 requires = kernel %in% c("polydot", "tanhdot"), tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), offset = structure(list(
                 id = "offset", type = "numeric", len = 1L, lower = -Inf, upper = Inf, 
                 values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 1, trafo = NULL, requires = kernel %in% c("polydot", "tanhdot"), 
                 tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), order = structure(list(id = "order", type = "integer", len = 1L, 
                 lower = -Inf, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 1L, trafo = NULL, requires = kernel == 
                     "besseldot", tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), tol = structure(list(id = "tol", type = "numeric", len = 1L, lower = 0, 
                 upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 0.001, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), shrinking = structure(list(
                 id = "shrinking", type = "logical", len = 1L, lower = NULL, upper = NULL, 
                 values = list(`TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = TRUE, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), class.weights = structure(list(id = "class.weights", type = "numericvector", 
                 len = NA_integer_, lower = 0, upper = Inf, values = NULL, cnames = NULL, 
                 allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, 
                 requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), fit = structure(list(id = "fit", type = "logical", len = 1L, lower = NULL, 
                 upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, 
                 allow.inf = FALSE, has.default = TRUE, default = TRUE, trafo = NULL, 
                 requires = NULL, tunable = FALSE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), cache = structure(list(id = "cache", type = "integer", len = 1L, 
                 lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 40L, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             ))), forbidden = NULL), class = c("LearnerParamSet", "ParamSet")), par.vals = list(
             fit = FALSE), predict.type = "prob", name = "Support Vector Machines", short.name = "ksvm", 
         note = "Kernel parameters have to be passed directly and not by using the `kpar` list in `ksvm`. Note that `fit` has been set to `FALSE` by default for speed.", 
         callees = "ksvm", help.list = list(sigma = "Argument of: kernlab::ksvm\n\nfor the ANOVA kernel \"anovadot\".", 
             degree = "Argument of: kernlab::ksvm\n\nfor the ANOVA kernel \"anovadot\".", 
             scale = "Argument of: kernlab::ksvm\n\nfor the Hyperbolic tangent kernel function \"tanhdot\"", 
             offset = "Argument of: kernlab::ksvm\n\nfor the Hyperbolic tangent kernel function \"tanhdot\"", 
             order = "Argument of: kernlab::ksvm\n\nfor the Bessel kernel \"besseldot\".", 
             scaled = "Argument of: kernlab::ksvm\n\nA logical vector indicating the variables to be scaled. If scaled is of length 1, the value is recycled as many times as needed and all non-binary variables are scaled. Per default, data are scaled internally (both x and y variables) to zero mean and unit variance. The center and scale values are returned and used for later predictions.", 
             type = "Argument of: kernlab::ksvm\n\nksvm can be used for classification , for regression, or for novelty detection. Depending on whether y is a factor or not, the default setting for type is C-svc or eps-svr, respectively, but can be overwritten by setting an explicit value. Valid options are:\n\nC-svc   C classification\n\nnu-svc  nu classification\n\nC-bsvc  bound-constraint svm classification\n\nspoc-svc  Crammer, Singer native multi-class\n\nkbb-svc  Weston, Watkins native multi-class\n\none-svc  novelty detection\n\neps-svr  epsilon regression\n\nnu-svr   nu regression\n\neps-bsvr  bound-constraint svm regression", 
             kernel = "Argument of: kernlab::ksvm\n\nthe kernel function used in training and predicting. This parameter can be set to any function, of class kernel, which computes the inner product in feature space between two vector arguments (see kernels). kernlab provides the most popular kernel functions which can be used by setting the kernel parameter to the following strings:\n\nrbfdot Radial Basis kernel \"Gaussian\"\n\npolydot Polynomial kernel\n\nvanilladot Linear kernel\n\ntanhdot Hyperbolic tangent kernel\n\nlaplacedot Laplacian kernel\n\nbesseldot Bessel kernel\n\nanovadot ANOVA RBF kernel\n\nsplinedot Spline kernel\n\nstringdot String kernel\n\nSetting the kernel parameter to \"matrix\" treats x as a kernel matrix calling the kernelMatrix interface. The kernel parameter can also be set to a user defined function of class kernel by passing the function name as an argument.", 
             C = "Argument of: kernlab::ksvm\n\ncost of constraints violation (default: 1) this is the ‘C’-constant of the regularization term in the Lagrange formulation.", 
             nu = "Argument of: kernlab::ksvm\n\nparameter needed for nu-svc, one-svc, and nu-svr. The nu parameter sets the upper bound on the training error and the lower bound on the fraction of data points to become Support Vectors (default: 0.2).", 
             epsilon = "Argument of: kernlab::ksvm\n\nepsilon in the insensitive-loss function used for eps-svr, nu-svr and eps-bsvm (default: 0.1)", 
             class.weights = "Argument of: kernlab::ksvm\n\na named vector of weights for the different classes, used for asymmetric class sizes. Not all factor levels have to be supplied (default weight: 1). All components have to be named.", 
             cache = "Argument of: kernlab::ksvm\n\ncache memory in MB (default 40)", 
             tol = "Argument of: kernlab::ksvm\n\ntolerance of termination criterion (default: 0.001)", 
             shrinking = "Argument of: kernlab::ksvm\n\noption whether to use the shrinking-heuristics (default: TRUE)", 
             fit = "Argument of: kernlab::ksvm\n\nindicates whether the fitted values should be computed and included in the model or not (default: TRUE)"), 
         class.weights.param = "class.weights", config = list(), fix.factors.prediction = FALSE), class = c("classif.ksvm", 
     "RLearnerClassif", "RLearner", "Learner")), task = structure(list(type = "classif", 
         env = <environment>, weights = NULL, blocking = NULL, coordinates = NULL, task.desc = structure(list(
             id = "iris-example", type = "classif", target = "Species", size = 100L, n.feat = c(numerics = 4L, 
             factors = 0L, ordered = 0L, functionals = 0L), has.missings = FALSE, has.weights = FALSE, 
             has.blocking = FALSE, has.coordinates = FALSE, class.levels = c("setosa", 
             "versicolor", "virginica"), positive = NA_character_, negative = NA_character_, 
             class.distribution = structure(c(setosa = 36L, versicolor = 31L, virginica = 33L
             ), .Dim = 3L, .Dimnames = list(c("setosa", "versicolor", "virginica")), class = "table")), class = c("ClassifTaskDesc", 
         "SupervisedTaskDesc", "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", 
     "Task")), resampling = structure(list(desc = structure(list(split = 0.666666666666667, 
         id = "holdout", iters = 1L, predict = "test", stratify = FALSE), class = c("HoldoutDesc", 
     "ResampleDesc")), size = 100L, train.inds = list(c(29L, 79L, 41L, 86L, 91L, 5L, 50L, 
     83L, 51L, 42L, 87L, 98L, 60L, 94L, 9L, 77L, 21L, 4L, 27L, 78L, 72L, 55L, 90L, 85L, 
     81L, 54L, 89L, 44L, 84L, 11L, 68L, 63L, 47L, 75L, 2L, 32L, 49L, 14L, 20L, 15L, 97L, 
     25L, 24L, 22L, 88L, 8L, 13L, 59L, 69L, 73L, 3L, 57L, 39L, 6L, 26L, 10L, 70L, 33L, 
     38L, 16L, 82L, 93L, 61L, 71L, 30L, 74L)), test.inds = list(c(43L, 67L, 1L, 35L, 31L, 
     36L, 66L, 48L, 7L, 40L, 99L, 100L, 53L, 17L, 28L, 62L, 80L, 76L, 23L, 64L, 95L, 34L, 
     12L, 19L, 96L, 92L, 56L, 52L, 65L, 18L, 37L, 45L, 46L, 58L)), group = structure(integer(0), .Label = character(0), class = "factor")), class = "ResampleInstance"), 
         measures = list(structure(list(id = "ber", minimize = TRUE, properties = c("classif", 
         "classif.multi", "req.pred", "req.truth"), fun = function (task, model, pred, 
             feats, extra.args) 
         {
             measureBER(pred$data$truth, pred$data$response)
         }, extra.args = list(), best = 0, worst = 1, name = "Balanced error rate", note = "Mean of misclassification error rates on all individual classes.", 
             aggr = structure(list(id = "test.mean", name = "Test mean", fun = function (task, 
                 perf.test, perf.train, measure, group, pred) 
             mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure"), 
             structure(list(id = "mmce", minimize = TRUE, properties = c("classif", "classif.multi", 
             "req.pred", "req.truth"), fun = function (task, model, pred, feats, extra.args) 
             {
                 measureMMCE(pred$data$truth, pred$data$response)
             }, extra.args = list(), best = 0, worst = 1, name = "Mean misclassification error", 
                 note = "Defined as: mean(response != truth)", aggr = structure(list(id = "test.mean", 
                     name = "Test mean", fun = function (task, perf.test, perf.train, 
                       measure, group, pred) 
                     mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure")), 
         par.set = structure(list(pars = list(C = structure(list(id = "C", type = "discrete", 
             len = 1L, lower = NULL, upper = NULL, values = list(`0.5` = 0.5), cnames = NULL, 
             allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, 
             tunable = TRUE, special.vals = list()), class = "Param")), forbidden = NULL), class = "ParamSet"), 
         bits.to.features = NULL, control = structure(list(same.resampling.instance = TRUE, 
             impute.val = c(1, 1), tune.threshold = TRUE, tune.threshold.args = list(nsub = 2L), 
             log.fun = function (learner, task, resampling, measures, par.set, control, 
                 opt.path, dob, x, y, remove.nas, stage, prev.stage) 
             {
                 x.string = paramValueToString(par.set, x, show.missing.values = !remove.nas)
                 if (inherits(learner, "ModelMultiplexer")) 
                     x.string = stri_replace_all(x.string, "", regex = stri_paste(x$selected.learner, 
                       "\\."))
                 logFunDefault(learner, task, resampling, measures, par.set, control, 
                     opt.path, dob, x.string, y, remove.nas, stage, prev.stage, prefixes = c("Tune-x", 
                       "Tune-y"))
             }, final.dw.perc = NULL, extra.args = list(resolution = 10L)), class = c("TuneControlGrid", 
         "TuneControl", "OptControl")), opt.path = structure(list(par.set = structure(list(
             pars = list(C = structure(list(id = "C", type = "discrete", len = 1L, lower = NULL, 
                 upper = NULL, values = list(`0.5` = 0.5), cnames = NULL, allow.inf = FALSE, 
                 has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list()), class = "Param")), forbidden = NULL), class = "ParamSet"), 
             y.names = c("ber.test.mean", "mmce.test.mean"), minimize = c(ber.test.mean = TRUE, 
             mmce.test.mean = TRUE), add.transformed.x = FALSE, env = <environment>), class = c("OptPathDF", 
         "OptPath")), show.info = FALSE, remove.nas = TRUE, resample.fun = function (learner, 
             task, resampling, measures, weights = NULL, models = FALSE, extract, keep.pred = TRUE, 
             ..., show.info = getMlrOption("show.info")) 
         {
             learner = checkLearner(learner)
             learner = setHyperPars(learner, ...)
             assertClass(task, classes = "Task")
             n = getTaskSize(task)
             if (inherits(resampling, "ResampleDesc")) 
                 resampling = makeResampleInstance(resampling, task = task)
             assertClass(resampling, classes = "ResampleInstance")
             measures = checkMeasures(measures, task)
             if (!is.null(weights)) {
                 assertNumeric(weights, len = n, any.missing = FALSE, lower = 0)
             }
             assertFlag(models)
             if (missing(extract)) 
                 extract = function(model) {
                 }
             else assertFunction(extract)
             assertFlag(show.info)
             r = resampling$size
             if (n != r) 
                 stop(stri_paste("Size of data set:", n, "and resampling instance:", r, 
                     "differ!", sep = " "))
             checkLearnerBeforeTrain(task, learner, weights)
             checkAggrsBeforeResample(measures, resampling$desc)
             rin = resampling
             more.args = list(learner = learner, task = task, rin = rin, weights = NULL, 
                 measures = measures, model = models, extract = extract, show.info = show.info)
             if (!is.null(weights)) {
                 more.args$weights = weights
             }
             else if (!is.null(getTaskWeights(task))) {
                 more.args$weights = getTaskWeights(task)
             }
             parallelLibrary("mlr", master = FALSE, level = "mlr.resample", show.info = FALSE)
             exportMlrOptions(level = "mlr.resample")
             if (show.info) {
                 messagef("Resampling: %s", rin$desc$id)
                 measure.lognames = extractSubList(measures, "id")
                 if (rin$desc$predict == "both") {
                     id.train = which(vlapply(measures, function(x) "req.train" %in% x$aggr$properties))
                     id.test = which(vlapply(measures, function(x) "req.test" %in% x$aggr$properties))
                     measure.lognames = c(stri_paste(measure.lognames[id.train], "train", 
                       sep = "."), stri_paste(measure.lognames[id.test], "test", sep = "."))
                 }
                 printResampleFormatLine("Measures:", measure.lognames)
             }
             time1 = Sys.time()
             iter.results = parallelMap(doResampleIteration, seq_len(rin$desc$iters), 
                 level = "mlr.resample", more.args = more.args)
             time2 = Sys.time()
             runtime = as.numeric(difftime(time2, time1, units = "secs"))
             addClasses(mergeResampleResult(learner$id, task, iter.results, measures, 
                 rin, models, extract, keep.pred, show.info, runtime), "ResampleResult")
         })
  22: measureTime({
         r = resample.fun(learner2, task, resampling, measures = measures, show.info = FALSE)
     })
  23: force(expr)
  24: resample.fun(learner2, task, resampling, measures = measures, show.info = FALSE)
  25: parallelMap(doResampleIteration, seq_len(rin$desc$iters), level = "mlr.resample", 
         more.args = more.args)
  26: options(parallelMap.nextmap = (getPMOptNextMap() + 1L))
  27: getPMOptNextMap()
  28: getPMOption("nextmap")
  29: getOption(sprintf("parallelMap.%s", opt), def)
  
  ── 14. Error: TuneWrapper with glmnet (#958) (@test_base_TuneWrapper.R#118)  ───
  argument "def" is missing, with no default
  1: train(lrn2, multiclass.task) at testthat/test_base_TuneWrapper.R:118
  2: measureTime(fun1({
         learner.model = fun2(fun3(do.call(trainLearner, pars)))
     }))
  3: force(expr)
  4: fun1({
         learner.model = fun2(fun3(do.call(trainLearner, pars)))
     })
  5: fun2(fun3(do.call(trainLearner, pars)))
  6: fun3(do.call(trainLearner, pars))
  7: do.call(trainLearner, pars)
  8: (function (.learner, .task, .subset, .weights = NULL, ...) 
     {
         UseMethod("trainLearner")
     })(.learner = structure(list(id = "classif.glmnet.tuned", type = "classif", package = "glmnet", 
         properties = NULL, par.set = structure(list(pars = list(), forbidden = NULL), class = "ParamSet"), 
         par.vals = list(), predict.type = "response", fix.factors.prediction = FALSE, 
         next.learner = structure(list(id = "classif.glmnet", type = "classif", package = "glmnet", 
             properties = c("numerics", "factors", "prob", "twoclass", "multiclass", "weights"
             ), par.set = structure(list(pars = list(alpha = structure(list(id = "alpha", 
                 type = "numeric", len = 1L, lower = 0, upper = 1, values = NULL, cnames = NULL, 
                 allow.inf = FALSE, has.default = TRUE, default = 1, trafo = NULL, requires = NULL, 
                 tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), s = structure(list(id = "s", type = "numeric", len = 1L, lower = 0, 
                 upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                 default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "predict"), class = c("LearnerParam", "Param")), exact = structure(list(
                 id = "exact", type = "logical", len = 1L, lower = NULL, upper = NULL, 
                 values = list(`TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = FALSE, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "predict"), class = c("LearnerParam", "Param"
             )), nlambda = structure(list(id = "nlambda", type = "integer", len = 1L, 
                 lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 100L, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), lambda.min.ratio = structure(list(id = "lambda.min.ratio", type = "numeric", 
                 len = 1L, lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), lambda = structure(list(id = "lambda", type = "numericvector", len = NA_integer_, 
                 lower = 0, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), standardize = structure(list(id = "standardize", type = "logical", len = 1L, 
                 lower = NULL, upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = TRUE, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), intercept = structure(list(
                 id = "intercept", type = "logical", len = 1L, lower = NULL, upper = NULL, 
                 values = list(`TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = TRUE, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), thresh = structure(list(id = "thresh", type = "numeric", len = 1L, lower = 0, 
                 upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 1e-07, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), dfmax = structure(list(
                 id = "dfmax", type = "integer", len = 1L, lower = 0L, upper = Inf, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), pmax = structure(list(
                 id = "pmax", type = "integer", len = 1L, lower = 0L, upper = Inf, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), exclude = structure(list(
                 id = "exclude", type = "integervector", len = NA_integer_, lower = 1L, 
                 upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                 default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), penalty.factor = structure(list(
                 id = "penalty.factor", type = "numericvector", len = NA_integer_, lower = 0, 
                 upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                 default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), lower.limits = structure(list(
                 id = "lower.limits", type = "numericvector", len = NA_integer_, lower = -Inf, 
                 upper = 0, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                 default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), upper.limits = structure(list(
                 id = "upper.limits", type = "numericvector", len = NA_integer_, lower = 0, 
                 upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                 default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), maxit = structure(list(
                 id = "maxit", type = "integer", len = 1L, lower = 1L, upper = Inf, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 100000L, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), type.logistic = structure(list(
                 id = "type.logistic", type = "discrete", len = 1L, lower = NULL, upper = NULL, 
                 values = list(Newton = "Newton", modified.Newton = "modified.Newton"), 
                 cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), type.multinomial = structure(list(
                 id = "type.multinomial", type = "discrete", len = 1L, lower = NULL, upper = NULL, 
                 values = list(ungrouped = "ungrouped", grouped = "grouped"), cnames = NULL, 
                 allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, 
                 requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), fdev = structure(list(id = "fdev", type = "numeric", len = 1L, 
                 lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 1e-05, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), devmax = structure(list(id = "devmax", type = "numeric", len = 1L, lower = 0, 
                 upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 0.999, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), eps = structure(list(
                 id = "eps", type = "numeric", len = 1L, lower = 0, upper = 1, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 1e-06, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), big = structure(list(
                 id = "big", type = "numeric", len = 1L, lower = -Inf, upper = Inf, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 9.9e+35, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), mnlam = structure(list(
                 id = "mnlam", type = "integer", len = 1L, lower = 1, upper = Inf, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 5, trafo = NULL, 
                 requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), pmin = structure(list(id = "pmin", type = "numeric", len = 1L, 
                 lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 1e-09, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), exmx = structure(list(id = "exmx", type = "numeric", len = 1L, lower = -Inf, 
                 upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 250, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), prec = structure(list(
                 id = "prec", type = "numeric", len = 1L, lower = -Inf, upper = Inf, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 1e-10, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), mxit = structure(list(
                 id = "mxit", type = "integer", len = 1L, lower = 1L, upper = Inf, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 100L, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param"))), forbidden = NULL), class = c("LearnerParamSet", 
             "ParamSet")), par.vals = list(s = 0.01), predict.type = "response", name = "GLM with Lasso or Elasticnet Regularization", 
             short.name = "glmnet", note = "The family parameter is set to `binomial` for two-class problems and to `multinomial` otherwise.\n      Factors automatically get converted to dummy columns, ordered factors to integer.\n      Parameter `s` (value of the regularization parameter used for predictions) is set to `0.1` by default,\n      but needs to be tuned by the user.\n      glmnet uses a global control object for its parameters. mlr resets all control parameters to their defaults\n      before setting the specified parameters and after training.\n      If you are setting glmnet.control parameters through glmnet.control,\n      you need to save and re-set them after running the glmnet learner.", 
             callees = c("glmnet", "glmnet.control", "predict.glmnet"), help.list = list(
                 s = "Argument of: glmnet::predict.glmnet\n\nValue(s) of the penalty parameter lambda at which predictions are required. Default is the entire sequence used to create the model.", 
                 exact = "Argument of: glmnet::predict.glmnet\n\nThis argument is relevant only when predictions are made at values of s (lambda) different from those used in the fitting of the original model. If exact=FALSE (default), then the predict function uses linear interpolation to make predictions for values of s (lambda) that do not coincide with those used in the fitting algorithm. While this is often a good approximation, it can sometimes be a bit coarse. With exact=TRUE, these different values of s are merged (and sorted) with object$lambda, and the model is refit before predictions are made. In this case, it is required to supply the original data x= and y= as additional named  arguments to predict() or coef(). The workhorse predict.glmnet() needs to  update the model, and so needs the data used to create it. The same is true of weights, offset, penalty.factor, lower.limits, upper.limits if these were used in the original call. Failure to do so will result in an error.", 
                 fdev = "Argument of: glmnet::glmnet.control\n\nminimum fractional change in deviance for stopping path; factory default = 1.0e-5", 
                 devmax = "Argument of: glmnet::glmnet.control\n\nmaximum fraction of explained deviance for stopping path; factory default = 0.999", 
                 eps = "Argument of: glmnet::glmnet.control\n\nminimum value of lambda.min.ratio (see glmnet); factory default= 1.0e-6", 
                 big = "Argument of: glmnet::glmnet.control\n\nlarge floating point number; factory default = 9.9e35. Inf in definition of upper.limit is set to big", 
                 mnlam = "Argument of: glmnet::glmnet.control\n\nminimum number of path points (lambda values) allowed; factory default = 5", 
                 pmin = "Argument of: glmnet::glmnet.control\n\nminimum probability for any class. factory default = 1.0e-9. Note that this implies a pmax of 1-pmin.", 
                 exmx = "Argument of: glmnet::glmnet.control\n\nmaximum allowed exponent. factory default = 250.0", 
                 prec = "Argument of: glmnet::glmnet.control\n\nconvergence threshold for multi response bounds adjustment solution. factory default = 1.0e-10", 
                 mxit = "Argument of: glmnet::glmnet.control\n\nmaximum iterations for multiresponse bounds adjustment solution.  factory default = 100", 
                 alpha = "Argument of: glmnet::glmnet\n\nThe elasticnet mixing parameter, with 0≤α≤ 1. The penalty is defined as (1-α)/2||β||_2^2+α||β||_1. alpha=1 is the lasso penalty, and alpha=0 the ridge penalty.", 
                 nlambda = "Argument of: glmnet::glmnet\n\nThe number of lambda values - default is 100.", 
                 lambda.min.ratio = "Argument of: glmnet::glmnet\n\nSmallest value for lambda, as a fraction of lambda.max, the (data derived) entry value (i.e. the smallest value for which all coefficients are zero). The default depends on the sample size nobs relative to the number of variables nvars. If nobs > nvars, the default is 0.0001, close to zero.  If nobs < nvars, the default is 0.01. A very small value of lambda.min.ratio will lead to a saturated fit in the nobs < nvars case. This is undefined for \"binomial\" and \"multinomial\" models, and glmnet will exit gracefully when the percentage deviance explained is almost 1.", 
                 lambda = "Argument of: glmnet::glmnet\n\nA user supplied lambda sequence. Typical usage is to have the program compute its own lambda sequence based on nlambda and lambda.min.ratio. Supplying a value of lambda overrides this. WARNING: use with care. Avoid supplying a single value for lambda (for predictions after CV use predict() instead).  Supply instead a decreasing sequence of lambda values. glmnet relies on its warms starts for speed, and its often faster to fit a whole path than compute a single fit.", 
                 standardize = "Argument of: glmnet::glmnet\n\nLogical flag for x variable standardization, prior to fitting the model sequence. The coefficients are always returned on the original scale. Default is standardize=TRUE. If variables are in the same units already, you might not wish to standardize. See details below for y standardization with family=\"gaussian\".", 
                 intercept = "Argument of: glmnet::glmnet\n\nShould intercept(s) be fitted (default=TRUE) or set to zero (FALSE)", 
                 thresh = "Argument of: glmnet::glmnet\n\nConvergence threshold for coordinate descent. Each inner coordinate-descent loop continues until the maximum change in the objective after any coefficient update is less than thresh times the null deviance. Defaults value is 1E-7.", 
                 dfmax = "Argument of: glmnet::glmnet\n\nLimit the maximum number of variables in the model. Useful for very large nvars, if a partial path is desired.", 
                 pmax = "Argument of: glmnet::glmnet\n\nLimit the maximum number of variables ever to be nonzero", 
                 exclude = "Argument of: glmnet::glmnet\n\nIndices of variables to be excluded from the model. Default is none. Equivalent to an infinite penalty factor (next item).", 
                 penalty.factor = "Argument of: glmnet::glmnet\n\nSeparate penalty factors can be applied to each coefficient. This is a number that multiplies lambda to allow differential shrinkage. Can be 0 for some variables, which implies no shrinkage, and that variable is always included in the model. Default is 1 for all variables (and implicitly infinity for variables listed in exclude). Note: the penalty factors are internally rescaled to sum to nvars, and the lambda sequence will reflect this change.", 
                 lower.limits = "Argument of: glmnet::glmnet\n\nVector of lower limits for each coefficient; default -Inf. Each of these must be non-positive. Can be presented as a single value (which will then be replicated), else a vector of length nvars", 
                 upper.limits = "Argument of: glmnet::glmnet\n\nVector of upper limits for each coefficient; default Inf. See lower.limits", 
                 maxit = "Argument of: glmnet::glmnet\n\nMaximum number of passes over the data for all lambda values; default is 10^5.", 
                 type.logistic = "Argument of: glmnet::glmnet\n\nIf \"Newton\" then the exact hessian is used (default), while \"modified.Newton\" uses an upper-bound on the hessian, and can be faster.", 
                 type.multinomial = "Argument of: glmnet::glmnet\n\nIf \"grouped\" then a grouped lasso penalty is used on the multinomial coefficients for a variable. This ensures they are all in our out together. The default is \"ungrouped\""), 
             config = list(), fix.factors.prediction = FALSE), class = c("classif.glmnet", 
         "RLearnerClassif", "RLearner", "Learner")), model.subclass = "TuneModel", resampling = structure(list(
             split = 0.666666666666667, id = "holdout", iters = 1L, predict = "test", 
             stratify = FALSE), class = c("HoldoutDesc", "ResampleDesc")), measures = list(
             structure(list(id = "mmce", minimize = TRUE, properties = c("classif", "classif.multi", 
             "req.pred", "req.truth"), fun = function (task, model, pred, feats, extra.args) 
             {
                 measureMMCE(pred$data$truth, pred$data$response)
             }, extra.args = list(), best = 0, worst = 1, name = "Mean misclassification error", 
                 note = "Defined as: mean(response != truth)", aggr = structure(list(id = "test.mean", 
                     name = "Test mean", fun = function (task, perf.test, perf.train, 
                       measure, group, pred) 
                     mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure")), 
         opt.pars = structure(list(pars = list(alpha = structure(list(id = "alpha", type = "numeric", 
             len = 1L, lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, 
             has.default = TRUE, default = 1, trafo = NULL, requires = NULL, tunable = TRUE, 
             special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
         ))), forbidden = NULL), class = c("LearnerParamSet", "ParamSet")), bit.names = character(0), 
         bits.to.features = function () 
         {
         }, control = structure(list(same.resampling.instance = TRUE, impute.val = NULL, 
             tune.threshold = FALSE, tune.threshold.args = list(), log.fun = function (learner, 
                 task, resampling, measures, par.set, control, opt.path, dob, x, y, remove.nas, 
                 stage, prev.stage) 
             {
                 x.string = paramValueToString(par.set, x, show.missing.values = !remove.nas)
                 if (inherits(learner, "ModelMultiplexer")) 
                     x.string = stri_replace_all(x.string, "", regex = stri_paste(x$selected.learner, 
                       "\\."))
                 logFunDefault(learner, task, resampling, measures, par.set, control, 
                     opt.path, dob, x.string, y, remove.nas, stage, prev.stage, prefixes = c("Tune-x", 
                       "Tune-y"))
             }, final.dw.perc = NULL, extra.args = list(maxit = 100L), budget = 100L), class = c("TuneControlRandom", 
         "TuneControl", "OptControl")), show.info = FALSE), class = c("TuneWrapper", "OptWrapper", 
     "BaseWrapper", "Learner")), .task = structure(list(type = "classif", env = <environment>, 
         weights = NULL, blocking = NULL, coordinates = NULL, task.desc = structure(list(
             id = "multiclass", type = "classif", target = "Species", size = 150L, n.feat = c(numerics = 4L, 
             factors = 0L, ordered = 0L, functionals = 0L), has.missings = FALSE, has.weights = FALSE, 
             has.blocking = FALSE, has.coordinates = FALSE, class.levels = c("setosa", 
             "versicolor", "virginica"), positive = NA_character_, negative = NA_character_, 
             class.distribution = structure(c(setosa = 50L, versicolor = 50L, virginica = 50L
             ), .Dim = 3L, .Dimnames = list(c("setosa", "versicolor", "virginica")), class = "table")), class = c("ClassifTaskDesc", 
         "SupervisedTaskDesc", "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", 
     "Task")), .subset = NULL)
  9: trainLearner.TuneWrapper(.learner = structure(list(id = "classif.glmnet.tuned", type = "classif", 
         package = "glmnet", properties = NULL, par.set = structure(list(pars = list(), 
             forbidden = NULL), class = "ParamSet"), par.vals = list(), predict.type = "response", 
         fix.factors.prediction = FALSE, next.learner = structure(list(id = "classif.glmnet", 
             type = "classif", package = "glmnet", properties = c("numerics", "factors", 
             "prob", "twoclass", "multiclass", "weights"), par.set = structure(list(pars = list(
                 alpha = structure(list(id = "alpha", type = "numeric", len = 1L, lower = 0, 
                     upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = 1, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), s = structure(list(
                     id = "s", type = "numeric", len = 1L, lower = 0, upper = Inf, values = NULL, 
                     cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, 
                     trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "predict"), class = c("LearnerParam", "Param")), exact = structure(list(
                     id = "exact", type = "logical", len = 1L, lower = NULL, upper = NULL, 
                     values = list(`TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = FALSE, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "predict"), class = c("LearnerParam", 
                 "Param")), nlambda = structure(list(id = "nlambda", type = "integer", 
                     len = 1L, lower = 1L, upper = Inf, values = NULL, cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = 100L, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), lambda.min.ratio = structure(list(id = "lambda.min.ratio", 
                     type = "numeric", len = 1L, lower = 0, upper = 1, values = NULL, 
                     cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, 
                     trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), lambda = structure(list(
                     id = "lambda", type = "numericvector", len = NA_integer_, lower = 0, 
                     upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                     default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), standardize = structure(list(
                     id = "standardize", type = "logical", len = 1L, lower = NULL, upper = NULL, 
                     values = list(`TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = TRUE, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), intercept = structure(list(id = "intercept", type = "logical", 
                     len = 1L, lower = NULL, upper = NULL, values = list(`TRUE` = TRUE, 
                       `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = TRUE, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), thresh = structure(list(
                     id = "thresh", type = "numeric", len = 1L, lower = 0, upper = Inf, 
                     values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = 1e-07, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), dfmax = structure(list(
                     id = "dfmax", type = "integer", len = 1L, lower = 0L, upper = Inf, 
                     values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                     default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), pmax = structure(list(
                     id = "pmax", type = "integer", len = 1L, lower = 0L, upper = Inf, 
                     values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                     default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), exclude = structure(list(
                     id = "exclude", type = "integervector", len = NA_integer_, lower = 1L, 
                     upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                     default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), penalty.factor = structure(list(
                     id = "penalty.factor", type = "numericvector", len = NA_integer_, 
                     lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), lower.limits = structure(list(id = "lower.limits", type = "numericvector", 
                     len = NA_integer_, lower = -Inf, upper = 0, values = NULL, cnames = NULL, 
                     allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), upper.limits = structure(list(id = "upper.limits", type = "numericvector", 
                     len = NA_integer_, lower = 0, upper = Inf, values = NULL, cnames = NULL, 
                     allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), maxit = structure(list(id = "maxit", type = "integer", len = 1L, 
                     lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 100000L, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), type.logistic = structure(list(id = "type.logistic", type = "discrete", 
                     len = 1L, lower = NULL, upper = NULL, values = list(Newton = "Newton", 
                       modified.Newton = "modified.Newton"), cnames = NULL, allow.inf = FALSE, 
                     has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), type.multinomial = structure(list(id = "type.multinomial", 
                     type = "discrete", len = 1L, lower = NULL, upper = NULL, values = list(
                       ungrouped = "ungrouped", grouped = "grouped"), cnames = NULL, allow.inf = FALSE, 
                     has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), fdev = structure(list(id = "fdev", type = "numeric", len = 1L, 
                     lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 1e-05, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), devmax = structure(list(id = "devmax", type = "numeric", len = 1L, 
                     lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 0.999, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), eps = structure(list(id = "eps", type = "numeric", len = 1L, 
                     lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 1e-06, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), big = structure(list(id = "big", type = "numeric", len = 1L, 
                     lower = -Inf, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 9.9e+35, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), mnlam = structure(list(id = "mnlam", type = "integer", len = 1L, 
                     lower = 1, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 5, trafo = NULL, requires = NULL, tunable = TRUE, 
                     special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), pmin = structure(list(id = "pmin", type = "numeric", len = 1L, 
                     lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 1e-09, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), exmx = structure(list(id = "exmx", type = "numeric", len = 1L, 
                     lower = -Inf, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 250, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), prec = structure(list(id = "prec", type = "numeric", len = 1L, 
                     lower = -Inf, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 1e-10, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), mxit = structure(list(id = "mxit", type = "integer", len = 1L, 
                     lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 100L, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param"))), forbidden = NULL), class = c("LearnerParamSet", "ParamSet"
             )), par.vals = list(s = 0.01), predict.type = "response", name = "GLM with Lasso or Elasticnet Regularization", 
             short.name = "glmnet", note = "The family parameter is set to `binomial` for two-class problems and to `multinomial` otherwise.\n      Factors automatically get converted to dummy columns, ordered factors to integer.\n      Parameter `s` (value of the regularization parameter used for predictions) is set to `0.1` by default,\n      but needs to be tuned by the user.\n      glmnet uses a global control object for its parameters. mlr resets all control parameters to their defaults\n      before setting the specified parameters and after training.\n      If you are setting glmnet.control parameters through glmnet.control,\n      you need to save and re-set them after running the glmnet learner.", 
             callees = c("glmnet", "glmnet.control", "predict.glmnet"), help.list = list(
                 s = "Argument of: glmnet::predict.glmnet\n\nValue(s) of the penalty parameter lambda at which predictions are required. Default is the entire sequence used to create the model.", 
                 exact = "Argument of: glmnet::predict.glmnet\n\nThis argument is relevant only when predictions are made at values of s (lambda) different from those used in the fitting of the original model. If exact=FALSE (default), then the predict function uses linear interpolation to make predictions for values of s (lambda) that do not coincide with those used in the fitting algorithm. While this is often a good approximation, it can sometimes be a bit coarse. With exact=TRUE, these different values of s are merged (and sorted) with object$lambda, and the model is refit before predictions are made. In this case, it is required to supply the original data x= and y= as additional named  arguments to predict() or coef(). The workhorse predict.glmnet() needs to  update the model, and so needs the data used to create it. The same is true of weights, offset, penalty.factor, lower.limits, upper.limits if these were used in the original call. Failure to do so will result in an error.", 
                 fdev = "Argument of: glmnet::glmnet.control\n\nminimum fractional change in deviance for stopping path; factory default = 1.0e-5", 
                 devmax = "Argument of: glmnet::glmnet.control\n\nmaximum fraction of explained deviance for stopping path; factory default = 0.999", 
                 eps = "Argument of: glmnet::glmnet.control\n\nminimum value of lambda.min.ratio (see glmnet); factory default= 1.0e-6", 
                 big = "Argument of: glmnet::glmnet.control\n\nlarge floating point number; factory default = 9.9e35. Inf in definition of upper.limit is set to big", 
                 mnlam = "Argument of: glmnet::glmnet.control\n\nminimum number of path points (lambda values) allowed; factory default = 5", 
                 pmin = "Argument of: glmnet::glmnet.control\n\nminimum probability for any class. factory default = 1.0e-9. Note that this implies a pmax of 1-pmin.", 
                 exmx = "Argument of: glmnet::glmnet.control\n\nmaximum allowed exponent. factory default = 250.0", 
                 prec = "Argument of: glmnet::glmnet.control\n\nconvergence threshold for multi response bounds adjustment solution. factory default = 1.0e-10", 
                 mxit = "Argument of: glmnet::glmnet.control\n\nmaximum iterations for multiresponse bounds adjustment solution.  factory default = 100", 
                 alpha = "Argument of: glmnet::glmnet\n\nThe elasticnet mixing parameter, with 0≤α≤ 1. The penalty is defined as (1-α)/2||β||_2^2+α||β||_1. alpha=1 is the lasso penalty, and alpha=0 the ridge penalty.", 
                 nlambda = "Argument of: glmnet::glmnet\n\nThe number of lambda values - default is 100.", 
                 lambda.min.ratio = "Argument of: glmnet::glmnet\n\nSmallest value for lambda, as a fraction of lambda.max, the (data derived) entry value (i.e. the smallest value for which all coefficients are zero). The default depends on the sample size nobs relative to the number of variables nvars. If nobs > nvars, the default is 0.0001, close to zero.  If nobs < nvars, the default is 0.01. A very small value of lambda.min.ratio will lead to a saturated fit in the nobs < nvars case. This is undefined for \"binomial\" and \"multinomial\" models, and glmnet will exit gracefully when the percentage deviance explained is almost 1.", 
                 lambda = "Argument of: glmnet::glmnet\n\nA user supplied lambda sequence. Typical usage is to have the program compute its own lambda sequence based on nlambda and lambda.min.ratio. Supplying a value of lambda overrides this. WARNING: use with care. Avoid supplying a single value for lambda (for predictions after CV use predict() instead).  Supply instead a decreasing sequence of lambda values. glmnet relies on its warms starts for speed, and its often faster to fit a whole path than compute a single fit.", 
                 standardize = "Argument of: glmnet::glmnet\n\nLogical flag for x variable standardization, prior to fitting the model sequence. The coefficients are always returned on the original scale. Default is standardize=TRUE. If variables are in the same units already, you might not wish to standardize. See details below for y standardization with family=\"gaussian\".", 
                 intercept = "Argument of: glmnet::glmnet\n\nShould intercept(s) be fitted (default=TRUE) or set to zero (FALSE)", 
                 thresh = "Argument of: glmnet::glmnet\n\nConvergence threshold for coordinate descent. Each inner coordinate-descent loop continues until the maximum change in the objective after any coefficient update is less than thresh times the null deviance. Defaults value is 1E-7.", 
                 dfmax = "Argument of: glmnet::glmnet\n\nLimit the maximum number of variables in the model. Useful for very large nvars, if a partial path is desired.", 
                 pmax = "Argument of: glmnet::glmnet\n\nLimit the maximum number of variables ever to be nonzero", 
                 exclude = "Argument of: glmnet::glmnet\n\nIndices of variables to be excluded from the model. Default is none. Equivalent to an infinite penalty factor (next item).", 
                 penalty.factor = "Argument of: glmnet::glmnet\n\nSeparate penalty factors can be applied to each coefficient. This is a number that multiplies lambda to allow differential shrinkage. Can be 0 for some variables, which implies no shrinkage, and that variable is always included in the model. Default is 1 for all variables (and implicitly infinity for variables listed in exclude). Note: the penalty factors are internally rescaled to sum to nvars, and the lambda sequence will reflect this change.", 
                 lower.limits = "Argument of: glmnet::glmnet\n\nVector of lower limits for each coefficient; default -Inf. Each of these must be non-positive. Can be presented as a single value (which will then be replicated), else a vector of length nvars", 
                 upper.limits = "Argument of: glmnet::glmnet\n\nVector of upper limits for each coefficient; default Inf. See lower.limits", 
                 maxit = "Argument of: glmnet::glmnet\n\nMaximum number of passes over the data for all lambda values; default is 10^5.", 
                 type.logistic = "Argument of: glmnet::glmnet\n\nIf \"Newton\" then the exact hessian is used (default), while \"modified.Newton\" uses an upper-bound on the hessian, and can be faster.", 
                 type.multinomial = "Argument of: glmnet::glmnet\n\nIf \"grouped\" then a grouped lasso penalty is used on the multinomial coefficients for a variable. This ensures they are all in our out together. The default is \"ungrouped\""), 
             config = list(), fix.factors.prediction = FALSE), class = c("classif.glmnet", 
         "RLearnerClassif", "RLearner", "Learner")), model.subclass = "TuneModel", resampling = structure(list(
             split = 0.666666666666667, id = "holdout", iters = 1L, predict = "test", 
             stratify = FALSE), class = c("HoldoutDesc", "ResampleDesc")), measures = list(
             structure(list(id = "mmce", minimize = TRUE, properties = c("classif", "classif.multi", 
             "req.pred", "req.truth"), fun = function (task, model, pred, feats, extra.args) 
             {
                 measureMMCE(pred$data$truth, pred$data$response)
             }, extra.args = list(), best = 0, worst = 1, name = "Mean misclassification error", 
                 note = "Defined as: mean(response != truth)", aggr = structure(list(id = "test.mean", 
                     name = "Test mean", fun = function (task, perf.test, perf.train, 
                       measure, group, pred) 
                     mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure")), 
         opt.pars = structure(list(pars = list(alpha = structure(list(id = "alpha", type = "numeric", 
             len = 1L, lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, 
             has.default = TRUE, default = 1, trafo = NULL, requires = NULL, tunable = TRUE, 
             special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
         ))), forbidden = NULL), class = c("LearnerParamSet", "ParamSet")), bit.names = character(0), 
         bits.to.features = function () 
         {
         }, control = structure(list(same.resampling.instance = TRUE, impute.val = NULL, 
             tune.threshold = FALSE, tune.threshold.args = list(), log.fun = function (learner, 
                 task, resampling, measures, par.set, control, opt.path, dob, x, y, remove.nas, 
                 stage, prev.stage) 
             {
                 x.string = paramValueToString(par.set, x, show.missing.values = !remove.nas)
                 if (inherits(learner, "ModelMultiplexer")) 
                     x.string = stri_replace_all(x.string, "", regex = stri_paste(x$selected.learner, 
                       "\\."))
                 logFunDefault(learner, task, resampling, measures, par.set, control, 
                     opt.path, dob, x.string, y, remove.nas, stage, prev.stage, prefixes = c("Tune-x", 
                       "Tune-y"))
             }, final.dw.perc = NULL, extra.args = list(maxit = 100L), budget = 100L), class = c("TuneControlRandom", 
         "TuneControl", "OptControl")), show.info = FALSE), class = c("TuneWrapper", "OptWrapper", 
     "BaseWrapper", "Learner")), .task = structure(list(type = "classif", env = <environment>, 
         weights = NULL, blocking = NULL, coordinates = NULL, task.desc = structure(list(
             id = "multiclass", type = "classif", target = "Species", size = 150L, n.feat = c(numerics = 4L, 
             factors = 0L, ordered = 0L, functionals = 0L), has.missings = FALSE, has.weights = FALSE, 
             has.blocking = FALSE, has.coordinates = FALSE, class.levels = c("setosa", 
             "versicolor", "virginica"), positive = NA_character_, negative = NA_character_, 
             class.distribution = structure(c(setosa = 50L, versicolor = 50L, virginica = 50L
             ), .Dim = 3L, .Dimnames = list(c("setosa", "versicolor", "virginica")), class = "table")), class = c("ClassifTaskDesc", 
         "SupervisedTaskDesc", "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", 
     "Task")), .subset = NULL)
  10: tuneParams(.learner$next.learner, .task, .learner$resampling, .learner$measures, 
         .learner$opt.pars, .learner$control, .learner$show.info)
  ...
  15: mapply(fun2, ..., MoreArgs = more.args, SIMPLIFY = FALSE, USE.NAMES = FALSE)
  16: (function (learner, task, resampling, measures, par.set, bits.to.features, control, 
         opt.path, show.info, dob, state, remove.nas, resample.fun) 
     {
         setSlaveOptions()
         y = setNames(rep(NA_real_, length(measures)), vcapply(measures, measureAggrName))
         errmsg = NA_character_
         exec.time = NA_real_
         set.pars.ok = TRUE
         learner2 = learner
         threshold = NULL
         log.fun = control$log.fun
         err.dumps = list()
         if (inherits(control, "TuneControl") || inherits(control, "TuneMultiCritControl")) {
             state = setValueCNames(par.set, state)
             state = trafoValue(par.set, state)
             state2 = if (remove.nas) 
                 removeMissingValues(state)
             else state
             learner2 = try(setHyperPars(learner, par.vals = state2), silent = TRUE)
             if (is.error(learner2)) {
                 set.pars.ok = FALSE
                 errmsg = as.character(learner2)
                 if (show.info) 
                     messagef("[Tune-x] Setting hyperpars failed: %s", errmsg)
             }
         }
         else if (inherits(control, "FeatSelControl")) {
             task = subsetTask(task, features = bits.to.features(state, task))
         }
         if (show.info) 
             prev.stage = log.fun(learner, task, resampling, measures, par.set, control, 
                 opt.path, dob, state, NA_real_, remove.nas, stage = 1L)
         if (set.pars.ok) {
             exec.time = measureTime({
                 r = resample.fun(learner2, task, resampling, measures = measures, show.info = FALSE)
             })
             if (control$tune.threshold) {
                 th.args = control$tune.threshold.args
                 th.args$pred = r$pred
                 th.args$measure = measures[[1L]]
                 tune.th.res = do.call(tuneThreshold, th.args)
                 threshold = tune.th.res$th
                 y = performance(setThreshold(r$pred, threshold = threshold), measures = measures)
                 names(y) = names(r$aggr)
             }
             else {
                 y = r$aggr
             }
             errmsgs = as.character(t(r$err.msgs[, -1L]))
             notna = !is.na(errmsgs)
             if (any(notna)) 
                 errmsg = errmsgs[notna][1L]
             err.dumps = r$err.dumps
         }
         else {
             if (control$tune.threshold) 
                 threshold = NA_real_
         }
         if (show.info) 
             log.fun(learner, task, resampling, measures, par.set, control, opt.path, 
                 dob, state, y, remove.nas, stage = 2L, prev.stage = prev.stage)
         list(y = y, exec.time = exec.time, errmsg = errmsg, threshold = threshold, err.dumps = err.dumps)
     })(dots[[1L]][[1L]], dots[[2L]][[1L]], learner = structure(list(id = "classif.glmnet", 
         type = "classif", package = "glmnet", properties = c("numerics", "factors", "prob", 
         "twoclass", "multiclass", "weights"), par.set = structure(list(pars = list(alpha = structure(list(
             id = "alpha", type = "numeric", len = 1L, lower = 0, upper = 1, values = NULL, 
             cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 1, trafo = NULL, 
             requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), s = structure(list(id = "s", type = "numeric", len = 1L, lower = 0, 
             upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
             default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
             when = "predict"), class = c("LearnerParam", "Param")), exact = structure(list(
             id = "exact", type = "logical", len = 1L, lower = NULL, upper = NULL, values = list(
                 `TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
             default = FALSE, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
             when = "predict"), class = c("LearnerParam", "Param")), nlambda = structure(list(
             id = "nlambda", type = "integer", len = 1L, lower = 1L, upper = Inf, values = NULL, 
             cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 100L, trafo = NULL, 
             requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), lambda.min.ratio = structure(list(id = "lambda.min.ratio", type = "numeric", 
             len = 1L, lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, 
             has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, 
             special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
         )), lambda = structure(list(id = "lambda", type = "numericvector", len = NA_integer_, 
             lower = 0, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
             has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, 
             special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
         )), standardize = structure(list(id = "standardize", type = "logical", len = 1L, 
             lower = NULL, upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), 
             cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = TRUE, trafo = NULL, 
             requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), intercept = structure(list(id = "intercept", type = "logical", len = 1L, 
             lower = NULL, upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), 
             cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = TRUE, trafo = NULL, 
             requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), thresh = structure(list(id = "thresh", type = "numeric", len = 1L, 
             lower = 0, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
             has.default = TRUE, default = 1e-07, trafo = NULL, requires = NULL, tunable = TRUE, 
             special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
         )), dfmax = structure(list(id = "dfmax", type = "integer", len = 1L, lower = 0L, 
             upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
             default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
             when = "train"), class = c("LearnerParam", "Param")), pmax = structure(list(
             id = "pmax", type = "integer", len = 1L, lower = 0L, upper = Inf, values = NULL, 
             cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, 
             requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), exclude = structure(list(id = "exclude", type = "integervector", len = NA_integer_, 
             lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
             has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, 
             special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
         )), penalty.factor = structure(list(id = "penalty.factor", type = "numericvector", 
             len = NA_integer_, lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, 
             has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, 
             special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
         )), lower.limits = structure(list(id = "lower.limits", type = "numericvector", 
             len = NA_integer_, lower = -Inf, upper = 0, values = NULL, cnames = NULL, 
             allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, 
             tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), upper.limits = structure(list(id = "upper.limits", type = "numericvector", 
             len = NA_integer_, lower = 0, upper = Inf, values = NULL, cnames = NULL, 
             allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, 
             tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), maxit = structure(list(id = "maxit", type = "integer", len = 1L, lower = 1L, 
             upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
             default = 100000L, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
             when = "train"), class = c("LearnerParam", "Param")), type.logistic = structure(list(
             id = "type.logistic", type = "discrete", len = 1L, lower = NULL, upper = NULL, 
             values = list(Newton = "Newton", modified.Newton = "modified.Newton"), cnames = NULL, 
             allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, 
             tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), type.multinomial = structure(list(id = "type.multinomial", type = "discrete", 
             len = 1L, lower = NULL, upper = NULL, values = list(ungrouped = "ungrouped", 
                 grouped = "grouped"), cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
             default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
             when = "train"), class = c("LearnerParam", "Param")), fdev = structure(list(
             id = "fdev", type = "numeric", len = 1L, lower = 0, upper = 1, values = NULL, 
             cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 1e-05, trafo = NULL, 
             requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), devmax = structure(list(id = "devmax", type = "numeric", len = 1L, 
             lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
             default = 0.999, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
             when = "train"), class = c("LearnerParam", "Param")), eps = structure(list(
             id = "eps", type = "numeric", len = 1L, lower = 0, upper = 1, values = NULL, 
             cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 1e-06, trafo = NULL, 
             requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), big = structure(list(id = "big", type = "numeric", len = 1L, lower = -Inf, 
             upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
             default = 9.9e+35, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
             when = "train"), class = c("LearnerParam", "Param")), mnlam = structure(list(
             id = "mnlam", type = "integer", len = 1L, lower = 1, upper = Inf, values = NULL, 
             cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 5, trafo = NULL, 
             requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), pmin = structure(list(id = "pmin", type = "numeric", len = 1L, lower = 0, 
             upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
             default = 1e-09, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
             when = "train"), class = c("LearnerParam", "Param")), exmx = structure(list(
             id = "exmx", type = "numeric", len = 1L, lower = -Inf, upper = Inf, values = NULL, 
             cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 250, trafo = NULL, 
             requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), prec = structure(list(id = "prec", type = "numeric", len = 1L, lower = -Inf, 
             upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
             default = 1e-10, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
             when = "train"), class = c("LearnerParam", "Param")), mxit = structure(list(
             id = "mxit", type = "integer", len = 1L, lower = 1L, upper = Inf, values = NULL, 
             cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 100L, trafo = NULL, 
             requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param"))), forbidden = NULL), class = c("LearnerParamSet", "ParamSet")), par.vals = list(
             s = 0.01), predict.type = "response", name = "GLM with Lasso or Elasticnet Regularization", 
         short.name = "glmnet", note = "The family parameter is set to `binomial` for two-class problems and to `multinomial` otherwise.\n      Factors automatically get converted to dummy columns, ordered factors to integer.\n      Parameter `s` (value of the regularization parameter used for predictions) is set to `0.1` by default,\n      but needs to be tuned by the user.\n      glmnet uses a global control object for its parameters. mlr resets all control parameters to their defaults\n      before setting the specified parameters and after training.\n      If you are setting glmnet.control parameters through glmnet.control,\n      you need to save and re-set them after running the glmnet learner.", 
         callees = c("glmnet", "glmnet.control", "predict.glmnet"), help.list = list(s = "Argument of: glmnet::predict.glmnet\n\nValue(s) of the penalty parameter lambda at which predictions are required. Default is the entire sequence used to create the model.", 
             exact = "Argument of: glmnet::predict.glmnet\n\nThis argument is relevant only when predictions are made at values of s (lambda) different from those used in the fitting of the original model. If exact=FALSE (default), then the predict function uses linear interpolation to make predictions for values of s (lambda) that do not coincide with those used in the fitting algorithm. While this is often a good approximation, it can sometimes be a bit coarse. With exact=TRUE, these different values of s are merged (and sorted) with object$lambda, and the model is refit before predictions are made. In this case, it is required to supply the original data x= and y= as additional named  arguments to predict() or coef(). The workhorse predict.glmnet() needs to  update the model, and so needs the data used to create it. The same is true of weights, offset, penalty.factor, lower.limits, upper.limits if these were used in the original call. Failure to do so will result in an error.", 
             fdev = "Argument of: glmnet::glmnet.control\n\nminimum fractional change in deviance for stopping path; factory default = 1.0e-5", 
             devmax = "Argument of: glmnet::glmnet.control\n\nmaximum fraction of explained deviance for stopping path; factory default = 0.999", 
             eps = "Argument of: glmnet::glmnet.control\n\nminimum value of lambda.min.ratio (see glmnet); factory default= 1.0e-6", 
             big = "Argument of: glmnet::glmnet.control\n\nlarge floating point number; factory default = 9.9e35. Inf in definition of upper.limit is set to big", 
             mnlam = "Argument of: glmnet::glmnet.control\n\nminimum number of path points (lambda values) allowed; factory default = 5", 
             pmin = "Argument of: glmnet::glmnet.control\n\nminimum probability for any class. factory default = 1.0e-9. Note that this implies a pmax of 1-pmin.", 
             exmx = "Argument of: glmnet::glmnet.control\n\nmaximum allowed exponent. factory default = 250.0", 
             prec = "Argument of: glmnet::glmnet.control\n\nconvergence threshold for multi response bounds adjustment solution. factory default = 1.0e-10", 
             mxit = "Argument of: glmnet::glmnet.control\n\nmaximum iterations for multiresponse bounds adjustment solution.  factory default = 100", 
             alpha = "Argument of: glmnet::glmnet\n\nThe elasticnet mixing parameter, with 0≤α≤ 1. The penalty is defined as (1-α)/2||β||_2^2+α||β||_1. alpha=1 is the lasso penalty, and alpha=0 the ridge penalty.", 
             nlambda = "Argument of: glmnet::glmnet\n\nThe number of lambda values - default is 100.", 
             lambda.min.ratio = "Argument of: glmnet::glmnet\n\nSmallest value for lambda, as a fraction of lambda.max, the (data derived) entry value (i.e. the smallest value for which all coefficients are zero). The default depends on the sample size nobs relative to the number of variables nvars. If nobs > nvars, the default is 0.0001, close to zero.  If nobs < nvars, the default is 0.01. A very small value of lambda.min.ratio will lead to a saturated fit in the nobs < nvars case. This is undefined for \"binomial\" and \"multinomial\" models, and glmnet will exit gracefully when the percentage deviance explained is almost 1.", 
             lambda = "Argument of: glmnet::glmnet\n\nA user supplied lambda sequence. Typical usage is to have the program compute its own lambda sequence based on nlambda and lambda.min.ratio. Supplying a value of lambda overrides this. WARNING: use with care. Avoid supplying a single value for lambda (for predictions after CV use predict() instead).  Supply instead a decreasing sequence of lambda values. glmnet relies on its warms starts for speed, and its often faster to fit a whole path than compute a single fit.", 
             standardize = "Argument of: glmnet::glmnet\n\nLogical flag for x variable standardization, prior to fitting the model sequence. The coefficients are always returned on the original scale. Default is standardize=TRUE. If variables are in the same units already, you might not wish to standardize. See details below for y standardization with family=\"gaussian\".", 
             intercept = "Argument of: glmnet::glmnet\n\nShould intercept(s) be fitted (default=TRUE) or set to zero (FALSE)", 
             thresh = "Argument of: glmnet::glmnet\n\nConvergence threshold for coordinate descent. Each inner coordinate-descent loop continues until the maximum change in the objective after any coefficient update is less than thresh times the null deviance. Defaults value is 1E-7.", 
             dfmax = "Argument of: glmnet::glmnet\n\nLimit the maximum number of variables in the model. Useful for very large nvars, if a partial path is desired.", 
             pmax = "Argument of: glmnet::glmnet\n\nLimit the maximum number of variables ever to be nonzero", 
             exclude = "Argument of: glmnet::glmnet\n\nIndices of variables to be excluded from the model. Default is none. Equivalent to an infinite penalty factor (next item).", 
             penalty.factor = "Argument of: glmnet::glmnet\n\nSeparate penalty factors can be applied to each coefficient. This is a number that multiplies lambda to allow differential shrinkage. Can be 0 for some variables, which implies no shrinkage, and that variable is always included in the model. Default is 1 for all variables (and implicitly infinity for variables listed in exclude). Note: the penalty factors are internally rescaled to sum to nvars, and the lambda sequence will reflect this change.", 
             lower.limits = "Argument of: glmnet::glmnet\n\nVector of lower limits for each coefficient; default -Inf. Each of these must be non-positive. Can be presented as a single value (which will then be replicated), else a vector of length nvars", 
             upper.limits = "Argument of: glmnet::glmnet\n\nVector of upper limits for each coefficient; default Inf. See lower.limits", 
             maxit = "Argument of: glmnet::glmnet\n\nMaximum number of passes over the data for all lambda values; default is 10^5.", 
             type.logistic = "Argument of: glmnet::glmnet\n\nIf \"Newton\" then the exact hessian is used (default), while \"modified.Newton\" uses an upper-bound on the hessian, and can be faster.", 
             type.multinomial = "Argument of: glmnet::glmnet\n\nIf \"grouped\" then a grouped lasso penalty is used on the multinomial coefficients for a variable. This ensures they are all in our out together. The default is \"ungrouped\""), 
         config = list(), fix.factors.prediction = FALSE), class = c("classif.glmnet", 
     "RLearnerClassif", "RLearner", "Learner")), task = structure(list(type = "classif", 
         env = <environment>, weights = NULL, blocking = NULL, coordinates = NULL, task.desc = structure(list(
             id = "multiclass", type = "classif", target = "Species", size = 150L, n.feat = c(numerics = 4L, 
             factors = 0L, ordered = 0L, functionals = 0L), has.missings = FALSE, has.weights = FALSE, 
             has.blocking = FALSE, has.coordinates = FALSE, class.levels = c("setosa", 
             "versicolor", "virginica"), positive = NA_character_, negative = NA_character_, 
             class.distribution = structure(c(setosa = 50L, versicolor = 50L, virginica = 50L
             ), .Dim = 3L, .Dimnames = list(c("setosa", "versicolor", "virginica")), class = "table")), class = c("ClassifTaskDesc", 
         "SupervisedTaskDesc", "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", 
     "Task")), resampling = structure(list(desc = structure(list(split = 0.666666666666667, 
         id = "holdout", iters = 1L, predict = "test", stratify = FALSE), class = c("HoldoutDesc", 
     "ResampleDesc")), size = 150L, train.inds = list(c(44L, 118L, 61L, 130L, 138L, 7L, 
     77L, 128L, 79L, 65L, 134L, 64L, 94L, 142L, 14L, 122L, 33L, 6L, 150L, 126L, 116L, 
     90L, 82L, 127L, 83L, 89L, 68L, 74L, 36L, 18L, 147L, 108L, 143L, 146L, 3L, 55L, 87L, 
     25L, 135L, 26L, 16L, 46L, 45L, 40L, 17L, 15L, 113L, 48L, 28L, 114L, 5L, 132L, 137L, 
     12L, 54L, 20L, 97L, 71L, 131L, 35L, 60L, 9L, 34L, 24L, 93L, 39L, 69L, 124L, 66L, 
     112L, 148L, 50L, 56L, 1L, 37L, 106L, 29L, 119L, 111L, 8L, 121L, 47L, 123L, 53L, 145L, 
     92L, 139L, 57L, 115L, 11L, 86L, 85L, 95L, 38L, 70L, 80L, 43L, 100L, 104L, 27L)), 
         test.inds = list(c(73L, 141L, 88L, 59L, 21L, 42L, 99L, 78L, 84L, 75L, 107L, 76L, 
         110L, 49L, 2L, 125L, 105L, 149L, 41L, 32L, 58L, 31L, 63L, 19L, 22L, 51L, 133L, 
         98L, 129L, 81L, 72L, 140L, 102L, 103L, 30L, 13L, 52L, 91L, 10L, 120L, 136L, 144L, 
         101L, 62L, 109L, 23L, 96L, 67L, 4L, 117L)), group = structure(integer(0), .Label = character(0), class = "factor")), class = "ResampleInstance"), 
         measures = list(structure(list(id = "mmce", minimize = TRUE, properties = c("classif", 
         "classif.multi", "req.pred", "req.truth"), fun = function (task, model, pred, 
             feats, extra.args) 
         {
             measureMMCE(pred$data$truth, pred$data$response)
         }, extra.args = list(), best = 0, worst = 1, name = "Mean misclassification error", 
             note = "Defined as: mean(response != truth)", aggr = structure(list(id = "test.mean", 
                 name = "Test mean", fun = function (task, perf.test, perf.train, measure, 
                     group, pred) 
                 mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure")), 
         par.set = structure(list(pars = list(alpha = structure(list(id = "alpha", type = "numeric", 
             len = 1L, lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, 
             has.default = TRUE, default = 1, trafo = NULL, requires = NULL, tunable = TRUE, 
             special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
         ))), forbidden = NULL), class = c("LearnerParamSet", "ParamSet")), bits.to.features = NULL, 
         control = structure(list(same.resampling.instance = TRUE, impute.val = 1, tune.threshold = FALSE, 
             tune.threshold.args = list(), log.fun = function (learner, task, resampling, 
                 measures, par.set, control, opt.path, dob, x, y, remove.nas, stage, prev.stage) 
             {
                 x.string = paramValueToString(par.set, x, show.missing.values = !remove.nas)
                 if (inherits(learner, "ModelMultiplexer")) 
                     x.string = stri_replace_all(x.string, "", regex = stri_paste(x$selected.learner, 
                       "\\."))
                 logFunDefault(learner, task, resampling, measures, par.set, control, 
                     opt.path, dob, x.string, y, remove.nas, stage, prev.stage, prefixes = c("Tune-x", 
                       "Tune-y"))
             }, final.dw.perc = NULL, extra.args = list(maxit = 100L), budget = 100L), class = c("TuneControlRandom", 
         "TuneControl", "OptControl")), opt.path = structure(list(par.set = structure(list(
             pars = list(alpha = structure(list(id = "alpha", type = "numeric", len = 1L, 
                 lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 1, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             ))), forbidden = NULL), class = c("LearnerParamSet", "ParamSet")), y.names = "mmce.test.mean", 
             minimize = c(mmce.test.mean = TRUE), add.transformed.x = FALSE, env = <environment>), class = c("OptPathDF", 
         "OptPath")), show.info = FALSE, remove.nas = TRUE, resample.fun = function (learner, 
             task, resampling, measures, weights = NULL, models = FALSE, extract, keep.pred = TRUE, 
             ..., show.info = getMlrOption("show.info")) 
         {
             learner = checkLearner(learner)
             learner = setHyperPars(learner, ...)
             assertClass(task, classes = "Task")
             n = getTaskSize(task)
             if (inherits(resampling, "ResampleDesc")) 
                 resampling = makeResampleInstance(resampling, task = task)
             assertClass(resampling, classes = "ResampleInstance")
             measures = checkMeasures(measures, task)
             if (!is.null(weights)) {
                 assertNumeric(weights, len = n, any.missing = FALSE, lower = 0)
             }
             assertFlag(models)
             if (missing(extract)) 
                 extract = function(model) {
                 }
             else assertFunction(extract)
             assertFlag(show.info)
             r = resampling$size
             if (n != r) 
                 stop(stri_paste("Size of data set:", n, "and resampling instance:", r, 
                     "differ!", sep = " "))
             checkLearnerBeforeTrain(task, learner, weights)
             checkAggrsBeforeResample(measures, resampling$desc)
             rin = resampling
             more.args = list(learner = learner, task = task, rin = rin, weights = NULL, 
                 measures = measures, model = models, extract = extract, show.info = show.info)
             if (!is.null(weights)) {
                 more.args$weights = weights
             }
             else if (!is.null(getTaskWeights(task))) {
                 more.args$weights = getTaskWeights(task)
             }
             parallelLibrary("mlr", master = FALSE, level = "mlr.resample", show.info = FALSE)
             exportMlrOptions(level = "mlr.resample")
             if (show.info) {
                 messagef("Resampling: %s", rin$desc$id)
                 measure.lognames = extractSubList(measures, "id")
                 if (rin$desc$predict == "both") {
                     id.train = which(vlapply(measures, function(x) "req.train" %in% x$aggr$properties))
                     id.test = which(vlapply(measures, function(x) "req.test" %in% x$aggr$properties))
                     measure.lognames = c(stri_paste(measure.lognames[id.train], "train", 
                       sep = "."), stri_paste(measure.lognames[id.test], "test", sep = "."))
                 }
                 printResampleFormatLine("Measures:", measure.lognames)
             }
             time1 = Sys.time()
             iter.results = parallelMap(doResampleIteration, seq_len(rin$desc$iters), 
                 level = "mlr.resample", more.args = more.args)
             time2 = Sys.time()
             runtime = as.numeric(difftime(time2, time1, units = "secs"))
             addClasses(mergeResampleResult(learner$id, task, iter.results, measures, 
                 rin, models, extract, keep.pred, show.info, runtime), "ResampleResult")
         })
  17: measureTime({
         r = resample.fun(learner2, task, resampling, measures = measures, show.info = FALSE)
     })
  18: force(expr)
  19: resample.fun(learner2, task, resampling, measures = measures, show.info = FALSE)
  20: parallelMap(doResampleIteration, seq_len(rin$desc$iters), level = "mlr.resample", 
         more.args = more.args)
  21: options(parallelMap.nextmap = (getPMOptNextMap() + 1L))
  22: getPMOptNextMap()
  23: getPMOption("nextmap")
  24: getOption(sprintf("parallelMap.%s", opt), def)
  
  ── 15. Error: aggregations (@test_base_aggregations.R#7)  ──────────────────────
  argument "def" is missing, with no default
  1: resample(lrn, task = binaryclass.task, resampling = rdesc, measures = ms) at testthat/test_base_aggregations.R:7
  2: parallelMap(doResampleIteration, seq_len(rin$desc$iters), level = "mlr.resample", 
         more.args = more.args)
  3: options(parallelMap.nextmap = (getPMOptNextMap() + 1L))
  4: getPMOptNextMap()
  5: getPMOption("nextmap")
  6: getOption(sprintf("parallelMap.%s", opt), def)
  
  ── 16. Error: benchmark (@test_base_benchmark.R#10)  ───────────────────────────
  argument "def" is missing, with no default
  1: benchmark(learners = makeLearner("classif.lda", predict.type = "prob"), task = binaryclass.task, 
         resampling = rin) at testthat/test_base_benchmark.R:10
  2: parallelMap(benchmarkParallel, task = grid$task, learner = grid$learner, more.args = list(learners = learners, 
         tasks = tasks, resamplings = resamplings, measures = measures, keep.pred = keep.pred, 
         models = models, show.info = show.info), level = plevel)
  3: mapply(fun2, ..., MoreArgs = more.args, SIMPLIFY = FALSE, USE.NAMES = FALSE)
  4: (function (task, learner, learners, tasks, resamplings, measures, keep.pred = TRUE, 
         models = TRUE, show.info) 
     {
         setSlaveOptions()
         if (show.info) 
             messagef("Task: %s, Learner: %s", task, learner)
         lrn = learners[[learner]]
         extract.this = getExtractor(lrn)
         r = resample(lrn, tasks[[task]], resamplings[[task]], measures = measures, models = models, 
             extract = extract.this, keep.pred = keep.pred, show.info = show.info)
         r$learner = lrn
         return(r)
     })(task = dots[[1L]][[1L]], learner = dots[[2L]][[1L]], learners = list(classif.lda = structure(list(
         id = "classif.lda", type = "classif", package = "MASS", properties = c("twoclass", 
         "multiclass", "numerics", "factors", "prob"), par.set = structure(list(pars = list(
             method = structure(list(id = "method", type = "discrete", len = 1L, lower = NULL, 
                 upper = NULL, values = list(moment = "moment", mle = "mle", mve = "mve", 
                     t = "t"), cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = "moment", 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), nu = structure(list(
                 id = "nu", type = "numeric", len = 1L, lower = 2, upper = Inf, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, 
                 trafo = NULL, requires = method == "t", tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), tol = structure(list(
                 id = "tol", type = "numeric", len = 1L, lower = 0, upper = Inf, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 1e-04, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), predict.method = structure(list(
                 id = "predict.method", type = "discrete", len = 1L, lower = NULL, upper = NULL, 
                 values = list(`plug-in` = "plug-in", predictive = "predictive", debiased = "debiased"), 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = "plug-in", 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "predict"), class = c("LearnerParam", "Param")), CV = structure(list(
                 id = "CV", type = "logical", len = 1L, lower = NULL, upper = NULL, values = list(
                     `TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = FALSE, trafo = NULL, requires = NULL, tunable = FALSE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), prior = structure(list(id = "prior", type = "numericvector", len = NA_integer_, 
                 lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             ))), forbidden = NULL), class = c("LearnerParamSet", "ParamSet")), par.vals = list(), 
         predict.type = "prob", name = "Linear Discriminant Analysis", short.name = "lda", 
         note = "Learner parameter `predict.method` maps to `method` in `predict.lda`.", 
         callees = c("lda", "predict.lda"), help.list = list(prior = "Argument of: MASS::lda\n\nthe prior probabilities of class membership.  If unspecified, the class proportions for the training set are used.  If present, the probabilities should be specified in the order of the factor levels.", 
             method = "Argument of: MASS::lda\n\n\"moment\" for standard estimators of the mean and variance, \"mle\" for MLEs, \"mve\" to use cov.mve, or \"t\" for robust estimates based on a t distribution.", 
             tol = "Argument of: MASS::lda\n\nA tolerance to decide if a matrix is singular; it will reject variables and linear combinations of unit-variance variables whose variance is less than tol^2.", 
             CV = "Argument of: MASS::lda\n\nIf true, returns results (classes and posterior probabilities) for leave-one-out cross-validation. Note that if the prior is estimated, the proportions in the whole dataset are used.", 
             nu = "Argument of: MASS::lda\n\ndegrees of freedom for method = \"t\"."), 
         config = list(), fix.factors.prediction = FALSE), class = c("classif.lda", "RLearnerClassif", 
     "RLearner", "Learner"))), tasks = list(binary = structure(list(type = "classif", 
         env = <environment>, weights = NULL, blocking = NULL, coordinates = NULL, task.desc = structure(list(
             id = "binary", type = "classif", target = "Class", size = 208L, n.feat = c(numerics = 60L, 
             factors = 0L, ordered = 0L, functionals = 0L), has.missings = FALSE, has.weights = FALSE, 
             has.blocking = FALSE, has.coordinates = FALSE, class.levels = c("M", "R"), 
             positive = "M", negative = "R", class.distribution = structure(c(M = 111L, 
             R = 97L), .Dim = 2L, .Dimnames = list(c("M", "R")), class = "table")), class = c("ClassifTaskDesc", 
         "SupervisedTaskDesc", "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", 
     "Task"))), resamplings = list(binary = structure(list(desc = structure(list(id = "cross-validation", 
         iters = 2L, predict = "test", stratify = FALSE), class = c("CVDesc", "ResampleDesc"
     )), size = 208L, train.inds = list(c(45L, 137L, 82L, 56L, 188L, 133L, 11L, 76L, 91L, 
     106L, 132L, 48L, 72L, 207L, 149L, 28L, 143L, 97L, 186L, 198L, 122L, 127L, 27L, 65L, 
     75L, 203L, 157L, 146L, 79L, 51L, 205L, 128L, 1L, 24L, 155L, 144L, 89L, 187L, 174L, 
     8L, 86L, 38L, 130L, 109L, 99L, 125L, 12L, 2L, 200L, 134L, 42L, 6L, 165L, 199L, 84L, 
     177L, 14L, 4L, 190L, 129L, 185L, 62L, 70L, 40L, 196L, 150L, 32L, 171L, 17L, 160L, 
     112L, 16L, 33L, 147L, 41L, 197L, 136L, 105L, 58L, 167L, 23L, 57L, 31L, 181L, 22L, 
     113L, 119L, 96L, 103L, 151L, 178L, 21L, 115L, 102L, 107L, 121L, 34L, 5L, 126L, 117L, 
     15L, 67L, 153L, 60L), c(36L, 208L, 100L, 52L, 10L, 141L, 71L, 163L, 182L, 142L, 172L, 
     116L, 80L, 206L, 192L, 30L, 110L, 54L, 124L, 68L, 164L, 43L, 37L, 98L, 44L, 87L, 
     145L, 104L, 88L, 3L, 74L, 183L, 173L, 154L, 159L, 201L, 19L, 179L, 9L, 193L, 7L, 
     13L, 93L, 118L, 94L, 92L, 140L, 83L, 18L, 156L, 49L, 53L, 108L, 158L, 35L, 184L, 
     101L, 29L, 66L, 202L, 90L, 111L, 25L, 26L, 152L, 191L, 39L, 180L, 69L, 189L, 175L, 
     63L, 138L, 61L, 85L, 135L, 139L, 73L, 81L, 123L, 20L, 170L, 176L, 46L, 47L, 78L, 
     162L, 120L, 194L, 95L, 168L, 148L, 64L, 195L, 77L, 131L, 169L, 204L, 59L, 161L, 55L, 
     166L, 114L, 50L)), test.inds = list(c(3L, 7L, 9L, 10L, 13L, 18L, 19L, 20L, 25L, 26L, 
     29L, 30L, 35L, 36L, 37L, 39L, 43L, 44L, 46L, 47L, 49L, 50L, 52L, 53L, 54L, 55L, 59L, 
     61L, 63L, 64L, 66L, 68L, 69L, 71L, 73L, 74L, 77L, 78L, 80L, 81L, 83L, 85L, 87L, 88L, 
     90L, 92L, 93L, 94L, 95L, 98L, 100L, 101L, 104L, 108L, 110L, 111L, 114L, 116L, 118L, 
     120L, 123L, 124L, 131L, 135L, 138L, 139L, 140L, 141L, 142L, 145L, 148L, 152L, 154L, 
     156L, 158L, 159L, 161L, 162L, 163L, 164L, 166L, 168L, 169L, 170L, 172L, 173L, 175L, 
     176L, 179L, 180L, 182L, 183L, 184L, 189L, 191L, 192L, 193L, 194L, 195L, 201L, 202L, 
     204L, 206L, 208L), c(1L, 2L, 4L, 5L, 6L, 8L, 11L, 12L, 14L, 15L, 16L, 17L, 21L, 22L, 
     23L, 24L, 27L, 28L, 31L, 32L, 33L, 34L, 38L, 40L, 41L, 42L, 45L, 48L, 51L, 56L, 57L, 
     58L, 60L, 62L, 65L, 67L, 70L, 72L, 75L, 76L, 79L, 82L, 84L, 86L, 89L, 91L, 96L, 97L, 
     99L, 102L, 103L, 105L, 106L, 107L, 109L, 112L, 113L, 115L, 117L, 119L, 121L, 122L, 
     125L, 126L, 127L, 128L, 129L, 130L, 132L, 133L, 134L, 136L, 137L, 143L, 144L, 146L, 
     147L, 149L, 150L, 151L, 153L, 155L, 157L, 160L, 165L, 167L, 171L, 174L, 177L, 178L, 
     181L, 185L, 186L, 187L, 188L, 190L, 196L, 197L, 198L, 199L, 200L, 203L, 205L, 207L
     )), group = structure(integer(0), .Label = character(0), class = "factor")), class = "ResampleInstance")), 
         measures = list(structure(list(id = "mmce", minimize = TRUE, properties = c("classif", 
         "classif.multi", "req.pred", "req.truth"), fun = function (task, model, pred, 
             feats, extra.args) 
         {
             measureMMCE(pred$data$truth, pred$data$response)
         }, extra.args = list(), best = 0, worst = 1, name = "Mean misclassification error", 
             note = "Defined as: mean(response != truth)", aggr = structure(list(id = "test.mean", 
                 name = "Test mean", fun = function (task, perf.test, perf.train, measure, 
                     group, pred) 
                 mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure")), 
         keep.pred = TRUE, models = TRUE, show.info = FALSE)
  5: resample(lrn, tasks[[task]], resamplings[[task]], measures = measures, models = models, 
         extract = extract.this, keep.pred = keep.pred, show.info = show.info)
  6: parallelMap(doResampleIteration, seq_len(rin$desc$iters), level = "mlr.resample", 
         more.args = more.args)
  7: options(parallelMap.nextmap = (getPMOptNextMap() + 1L))
  8: getPMOptNextMap()
  9: getPMOption("nextmap")
  10: getOption(sprintf("parallelMap.%s", opt), def)
  
  ── 17. Error: keep.preds and models are passed down to resample() (@test_base_be
  argument "def" is missing, with no default
  1: benchmark(learners = makeLearner("classif.lda", predict.type = "prob"), task = binaryclass.task, 
         resampling = rin, keep.pred = TRUE, models = TRUE) at testthat/test_base_benchmark.R:190
  2: parallelMap(benchmarkParallel, task = grid$task, learner = grid$learner, more.args = list(learners = learners, 
         tasks = tasks, resamplings = resamplings, measures = measures, keep.pred = keep.pred, 
         models = models, show.info = show.info), level = plevel)
  3: mapply(fun2, ..., MoreArgs = more.args, SIMPLIFY = FALSE, USE.NAMES = FALSE)
  4: (function (task, learner, learners, tasks, resamplings, measures, keep.pred = TRUE, 
         models = TRUE, show.info) 
     {
         setSlaveOptions()
         if (show.info) 
             messagef("Task: %s, Learner: %s", task, learner)
         lrn = learners[[learner]]
         extract.this = getExtractor(lrn)
         r = resample(lrn, tasks[[task]], resamplings[[task]], measures = measures, models = models, 
             extract = extract.this, keep.pred = keep.pred, show.info = show.info)
         r$learner = lrn
         return(r)
     })(task = dots[[1L]][[1L]], learner = dots[[2L]][[1L]], learners = list(classif.lda = structure(list(
         id = "classif.lda", type = "classif", package = "MASS", properties = c("twoclass", 
         "multiclass", "numerics", "factors", "prob"), par.set = structure(list(pars = list(
             method = structure(list(id = "method", type = "discrete", len = 1L, lower = NULL, 
                 upper = NULL, values = list(moment = "moment", mle = "mle", mve = "mve", 
                     t = "t"), cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = "moment", 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), nu = structure(list(
                 id = "nu", type = "numeric", len = 1L, lower = 2, upper = Inf, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, 
                 trafo = NULL, requires = method == "t", tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), tol = structure(list(
                 id = "tol", type = "numeric", len = 1L, lower = 0, upper = Inf, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 1e-04, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), predict.method = structure(list(
                 id = "predict.method", type = "discrete", len = 1L, lower = NULL, upper = NULL, 
                 values = list(`plug-in` = "plug-in", predictive = "predictive", debiased = "debiased"), 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = "plug-in", 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "predict"), class = c("LearnerParam", "Param")), CV = structure(list(
                 id = "CV", type = "logical", len = 1L, lower = NULL, upper = NULL, values = list(
                     `TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = FALSE, trafo = NULL, requires = NULL, tunable = FALSE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), prior = structure(list(id = "prior", type = "numericvector", len = NA_integer_, 
                 lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             ))), forbidden = NULL), class = c("LearnerParamSet", "ParamSet")), par.vals = list(), 
         predict.type = "prob", name = "Linear Discriminant Analysis", short.name = "lda", 
         note = "Learner parameter `predict.method` maps to `method` in `predict.lda`.", 
         callees = c("lda", "predict.lda"), help.list = list(prior = "Argument of: MASS::lda\n\nthe prior probabilities of class membership.  If unspecified, the class proportions for the training set are used.  If present, the probabilities should be specified in the order of the factor levels.", 
             method = "Argument of: MASS::lda\n\n\"moment\" for standard estimators of the mean and variance, \"mle\" for MLEs, \"mve\" to use cov.mve, or \"t\" for robust estimates based on a t distribution.", 
             tol = "Argument of: MASS::lda\n\nA tolerance to decide if a matrix is singular; it will reject variables and linear combinations of unit-variance variables whose variance is less than tol^2.", 
             CV = "Argument of: MASS::lda\n\nIf true, returns results (classes and posterior probabilities) for leave-one-out cross-validation. Note that if the prior is estimated, the proportions in the whole dataset are used.", 
             nu = "Argument of: MASS::lda\n\ndegrees of freedom for method = \"t\"."), 
         config = list(), fix.factors.prediction = FALSE), class = c("classif.lda", "RLearnerClassif", 
     "RLearner", "Learner"))), tasks = list(binary = structure(list(type = "classif", 
         env = <environment>, weights = NULL, blocking = NULL, coordinates = NULL, task.desc = structure(list(
             id = "binary", type = "classif", target = "Class", size = 208L, n.feat = c(numerics = 60L, 
             factors = 0L, ordered = 0L, functionals = 0L), has.missings = FALSE, has.weights = FALSE, 
             has.blocking = FALSE, has.coordinates = FALSE, class.levels = c("M", "R"), 
             positive = "M", negative = "R", class.distribution = structure(c(M = 111L, 
             R = 97L), .Dim = 2L, .Dimnames = list(c("M", "R")), class = "table")), class = c("ClassifTaskDesc", 
         "SupervisedTaskDesc", "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", 
     "Task"))), resamplings = list(binary = structure(list(desc = structure(list(id = "cross-validation", 
         iters = 2L, predict = "test", stratify = FALSE), class = c("CVDesc", "ResampleDesc"
     )), size = 208L, train.inds = list(c(45L, 137L, 82L, 56L, 188L, 133L, 11L, 76L, 91L, 
     106L, 132L, 48L, 72L, 207L, 149L, 28L, 143L, 97L, 186L, 198L, 122L, 127L, 27L, 65L, 
     75L, 203L, 157L, 146L, 79L, 51L, 205L, 128L, 1L, 24L, 155L, 144L, 89L, 187L, 174L, 
     8L, 86L, 38L, 130L, 109L, 99L, 125L, 12L, 2L, 200L, 134L, 42L, 6L, 165L, 199L, 84L, 
     177L, 14L, 4L, 190L, 129L, 185L, 62L, 70L, 40L, 196L, 150L, 32L, 171L, 17L, 160L, 
     112L, 16L, 33L, 147L, 41L, 197L, 136L, 105L, 58L, 167L, 23L, 57L, 31L, 181L, 22L, 
     113L, 119L, 96L, 103L, 151L, 178L, 21L, 115L, 102L, 107L, 121L, 34L, 5L, 126L, 117L, 
     15L, 67L, 153L, 60L), c(36L, 208L, 100L, 52L, 10L, 141L, 71L, 163L, 182L, 142L, 172L, 
     116L, 80L, 206L, 192L, 30L, 110L, 54L, 124L, 68L, 164L, 43L, 37L, 98L, 44L, 87L, 
     145L, 104L, 88L, 3L, 74L, 183L, 173L, 154L, 159L, 201L, 19L, 179L, 9L, 193L, 7L, 
     13L, 93L, 118L, 94L, 92L, 140L, 83L, 18L, 156L, 49L, 53L, 108L, 158L, 35L, 184L, 
     101L, 29L, 66L, 202L, 90L, 111L, 25L, 26L, 152L, 191L, 39L, 180L, 69L, 189L, 175L, 
     63L, 138L, 61L, 85L, 135L, 139L, 73L, 81L, 123L, 20L, 170L, 176L, 46L, 47L, 78L, 
     162L, 120L, 194L, 95L, 168L, 148L, 64L, 195L, 77L, 131L, 169L, 204L, 59L, 161L, 55L, 
     166L, 114L, 50L)), test.inds = list(c(3L, 7L, 9L, 10L, 13L, 18L, 19L, 20L, 25L, 26L, 
     29L, 30L, 35L, 36L, 37L, 39L, 43L, 44L, 46L, 47L, 49L, 50L, 52L, 53L, 54L, 55L, 59L, 
     61L, 63L, 64L, 66L, 68L, 69L, 71L, 73L, 74L, 77L, 78L, 80L, 81L, 83L, 85L, 87L, 88L, 
     90L, 92L, 93L, 94L, 95L, 98L, 100L, 101L, 104L, 108L, 110L, 111L, 114L, 116L, 118L, 
     120L, 123L, 124L, 131L, 135L, 138L, 139L, 140L, 141L, 142L, 145L, 148L, 152L, 154L, 
     156L, 158L, 159L, 161L, 162L, 163L, 164L, 166L, 168L, 169L, 170L, 172L, 173L, 175L, 
     176L, 179L, 180L, 182L, 183L, 184L, 189L, 191L, 192L, 193L, 194L, 195L, 201L, 202L, 
     204L, 206L, 208L), c(1L, 2L, 4L, 5L, 6L, 8L, 11L, 12L, 14L, 15L, 16L, 17L, 21L, 22L, 
     23L, 24L, 27L, 28L, 31L, 32L, 33L, 34L, 38L, 40L, 41L, 42L, 45L, 48L, 51L, 56L, 57L, 
     58L, 60L, 62L, 65L, 67L, 70L, 72L, 75L, 76L, 79L, 82L, 84L, 86L, 89L, 91L, 96L, 97L, 
     99L, 102L, 103L, 105L, 106L, 107L, 109L, 112L, 113L, 115L, 117L, 119L, 121L, 122L, 
     125L, 126L, 127L, 128L, 129L, 130L, 132L, 133L, 134L, 136L, 137L, 143L, 144L, 146L, 
     147L, 149L, 150L, 151L, 153L, 155L, 157L, 160L, 165L, 167L, 171L, 174L, 177L, 178L, 
     181L, 185L, 186L, 187L, 188L, 190L, 196L, 197L, 198L, 199L, 200L, 203L, 205L, 207L
     )), group = structure(integer(0), .Label = character(0), class = "factor")), class = "ResampleInstance")), 
         measures = list(structure(list(id = "mmce", minimize = TRUE, properties = c("classif", 
         "classif.multi", "req.pred", "req.truth"), fun = function (task, model, pred, 
             feats, extra.args) 
         {
             measureMMCE(pred$data$truth, pred$data$response)
         }, extra.args = list(), best = 0, worst = 1, name = "Mean misclassification error", 
             note = "Defined as: mean(response != truth)", aggr = structure(list(id = "test.mean", 
                 name = "Test mean", fun = function (task, perf.test, perf.train, measure, 
                     group, pred) 
                 mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure")), 
         keep.pred = TRUE, models = TRUE, show.info = FALSE)
  5: resample(lrn, tasks[[task]], resamplings[[task]], measures = measures, models = models, 
         extract = extract.this, keep.pred = keep.pred, show.info = show.info)
  6: parallelMap(doResampleIteration, seq_len(rin$desc$iters), level = "mlr.resample", 
         more.args = more.args)
  7: options(parallelMap.nextmap = (getPMOptNextMap() + 1L))
  8: getPMOptNextMap()
  9: getPMOption("nextmap")
  10: getOption(sprintf("parallelMap.%s", opt), def)
  
  ── 18. Error: benchmark work with learner string (@test_base_benchmark.R#219)  ─
  argument "def" is missing, with no default
  1: benchmark("classif.rpart", iris.task, hout) at testthat/test_base_benchmark.R:219
  2: parallelMap(benchmarkParallel, task = grid$task, learner = grid$learner, more.args = list(learners = learners, 
         tasks = tasks, resamplings = resamplings, measures = measures, keep.pred = keep.pred, 
         models = models, show.info = show.info), level = plevel)
  3: mapply(fun2, ..., MoreArgs = more.args, SIMPLIFY = FALSE, USE.NAMES = FALSE)
  4: (function (task, learner, learners, tasks, resamplings, measures, keep.pred = TRUE, 
         models = TRUE, show.info) 
     {
         setSlaveOptions()
         if (show.info) 
             messagef("Task: %s, Learner: %s", task, learner)
         lrn = learners[[learner]]
         extract.this = getExtractor(lrn)
         r = resample(lrn, tasks[[task]], resamplings[[task]], measures = measures, models = models, 
             extract = extract.this, keep.pred = keep.pred, show.info = show.info)
         r$learner = lrn
         return(r)
     })(task = dots[[1L]][[1L]], learner = dots[[2L]][[1L]], learners = list(classif.rpart = structure(list(
         id = "classif.rpart", type = "classif", package = "rpart", properties = c("twoclass", 
         "multiclass", "missings", "numerics", "factors", "ordered", "prob", "weights", 
         "featimp"), par.set = structure(list(pars = list(minsplit = structure(list(id = "minsplit", 
             type = "integer", len = 1L, lower = 1L, upper = Inf, values = NULL, cnames = NULL, 
             allow.inf = FALSE, has.default = TRUE, default = 20L, trafo = NULL, requires = NULL, 
             tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), minbucket = structure(list(id = "minbucket", type = "integer", len = 1L, 
             lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
             has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, 
             special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
         )), cp = structure(list(id = "cp", type = "numeric", len = 1L, lower = 0, upper = 1, 
             values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 0.01, 
             trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), maxcompete = structure(list(id = "maxcompete", type = "integer", len = 1L, 
             lower = 0L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
             has.default = TRUE, default = 4L, trafo = NULL, requires = NULL, tunable = TRUE, 
             special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
         )), maxsurrogate = structure(list(id = "maxsurrogate", type = "integer", len = 1L, 
             lower = 0L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
             has.default = TRUE, default = 5L, trafo = NULL, requires = NULL, tunable = TRUE, 
             special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
         )), usesurrogate = structure(list(id = "usesurrogate", type = "discrete", len = 1L, 
             lower = NULL, upper = NULL, values = list(`0` = 0L, `1` = 1L, `2` = 2L), 
             cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 2L, trafo = NULL, 
             requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), surrogatestyle = structure(list(id = "surrogatestyle", type = "discrete", 
             len = 1L, lower = NULL, upper = NULL, values = list(`0` = 0L, `1` = 1L), 
             cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 0L, trafo = NULL, 
             requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), maxdepth = structure(list(id = "maxdepth", type = "integer", len = 1L, 
             lower = 1L, upper = 30L, values = NULL, cnames = NULL, allow.inf = FALSE, 
             has.default = TRUE, default = 30L, trafo = NULL, requires = NULL, tunable = TRUE, 
             special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
         )), xval = structure(list(id = "xval", type = "integer", len = 1L, lower = 0L, 
             upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
             default = 10L, trafo = NULL, requires = NULL, tunable = FALSE, special.vals = list(), 
             when = "train"), class = c("LearnerParam", "Param")), parms = structure(list(
             id = "parms", type = "untyped", len = 1L, lower = NULL, upper = NULL, values = NULL, 
             cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, 
             requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param"))), forbidden = NULL), class = c("LearnerParamSet", "ParamSet")), par.vals = list(
             xval = 0L), predict.type = "response", name = "Decision Tree", short.name = "rpart", 
         note = "`xval` has been set to `0` by default for speed.", callees = c("rpart", 
         "rpart.control"), help.list = list(minsplit = "Argument of: rpart::rpart.control\n\nthe minimum number of observations that must exist in a node in order for a split to be attempted.", 
             minbucket = "Argument of: rpart::rpart.control\n\nthe minimum number of observations in any terminal <leaf> node. If only one of minbucket or minsplit is specified, the code either sets minsplit to minbucket*3 or minbucket to minsplit/3, as appropriate.", 
             cp = "Argument of: rpart::rpart.control\n\ncomplexity parameter.  Any split that does not decrease the overall lack of fit by a factor of cp is not attempted.  For instance, with anova splitting, this means that the overall R-squared must increase by cp at each step. The main role of this parameter is to save computing time by pruning off splits that are obviously not worthwhile. Essentially,the user informs the program that any split which does not improve the fit by cp will likely be pruned off by cross-validation, and that hence the program need not pursue it.", 
             maxcompete = "Argument of: rpart::rpart.control\n\nthe number of competitor splits retained in the output.  It is useful to know not just which split was chosen, but which variable came in second, third, etc.", 
             maxsurrogate = "Argument of: rpart::rpart.control\n\nthe number of surrogate splits retained in the output.  If this is set to zero the compute time will be reduced, since approximately half of the computational time (other than setup) is used in the search for surrogate splits.", 
             usesurrogate = "Argument of: rpart::rpart.control\n\nhow to use surrogates in the splitting process.  0 means display only; an observation with a missing value for the primary split rule is not sent further down the tree.  1 means use surrogates, in order, to split subjects missing the primary variable; if all surrogates are missing the observation is not split.  For value 2 ,if all surrogates are missing, then send the observation in the majority direction.  A value of 0 corresponds to the action of tree, and 2 to the recommendations of Breiman et.al (1984).", 
             xval = "Argument of: rpart::rpart.control\n\nnumber of cross-validations.", 
             surrogatestyle = "Argument of: rpart::rpart.control\n\ncontrols the selection of a best surrogate. If set to 0 (default) the program uses the total number of correct classification for a potential surrogate variable, if set to 1 it uses the percent correct, calculated over the non-missing values of the surrogate. The first option more severely penalizes covariates with a large number of missing values.", 
             maxdepth = "Argument of: rpart::rpart.control\n\nSet the maximum depth of any node of the final tree, with the root node counted as depth 0.  Values greater than  30 rpart will give nonsense results on 32-bit machines.", 
             parms = "Argument of: rpart::rpart\n\noptional parameters for the splitting function. Anova splitting has no parameters. Poisson splitting has a single parameter, the coefficient of variation of the prior distribution on the rates.  The default value is 1. Exponential splitting has the same parameter as Poisson. For classification splitting, the list can contain any of: the vector of prior probabilities (component prior), the loss matrix (component loss) or the splitting index (component split).  The priors must be positive and sum to 1.  The loss matrix must have zeros on the diagonal and positive off-diagonal elements.  The splitting index can be gini or information.  The default priors are proportional to the data counts, the losses default to 1, and the split defaults to gini."), 
         config = list(), fix.factors.prediction = FALSE), class = c("classif.rpart", 
     "RLearnerClassif", "RLearner", "Learner"))), tasks = list(`iris-example` = structure(list(
         type = "classif", env = <environment>, weights = NULL, blocking = NULL, coordinates = NULL, 
         task.desc = structure(list(id = "iris-example", type = "classif", target = "Species", 
             size = 150L, n.feat = c(numerics = 4L, factors = 0L, ordered = 0L, functionals = 0L
             ), has.missings = FALSE, has.weights = FALSE, has.blocking = FALSE, has.coordinates = FALSE, 
             class.levels = c("setosa", "versicolor", "virginica"), positive = NA_character_, 
             negative = NA_character_, class.distribution = structure(c(setosa = 50L, 
             versicolor = 50L, virginica = 50L), .Dim = 3L, .Dimnames = list(c("setosa", 
             "versicolor", "virginica")), class = "table")), class = c("ClassifTaskDesc", 
         "SupervisedTaskDesc", "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", 
     "Task"))), resamplings = list(`iris-example` = structure(list(desc = structure(list(
         split = 0.666666666666667, id = "holdout", iters = 1L, predict = "test", stratify = FALSE), class = c("HoldoutDesc", 
     "ResampleDesc")), size = 150L, train.inds = list(c(44L, 118L, 61L, 130L, 138L, 7L, 
     77L, 128L, 79L, 65L, 134L, 64L, 94L, 142L, 14L, 122L, 33L, 6L, 150L, 126L, 116L, 
     90L, 82L, 127L, 83L, 89L, 68L, 74L, 36L, 18L, 147L, 108L, 143L, 146L, 3L, 55L, 87L, 
     25L, 135L, 26L, 16L, 46L, 45L, 40L, 17L, 15L, 113L, 48L, 28L, 114L, 5L, 132L, 137L, 
     12L, 54L, 20L, 97L, 71L, 131L, 35L, 60L, 9L, 34L, 24L, 93L, 39L, 69L, 124L, 66L, 
     112L, 148L, 50L, 56L, 1L, 37L, 106L, 29L, 119L, 111L, 8L, 121L, 47L, 123L, 53L, 145L, 
     92L, 139L, 57L, 115L, 11L, 86L, 85L, 95L, 38L, 70L, 80L, 43L, 100L, 104L, 27L)), 
         test.inds = list(c(73L, 141L, 88L, 59L, 21L, 42L, 99L, 78L, 84L, 75L, 107L, 76L, 
         110L, 49L, 2L, 125L, 105L, 149L, 41L, 32L, 58L, 31L, 63L, 19L, 22L, 51L, 133L, 
         98L, 129L, 81L, 72L, 140L, 102L, 103L, 30L, 13L, 52L, 91L, 10L, 120L, 136L, 144L, 
         101L, 62L, 109L, 23L, 96L, 67L, 4L, 117L)), group = structure(integer(0), .Label = character(0), class = "factor")), class = "ResampleInstance")), 
         measures = list(structure(list(id = "mmce", minimize = TRUE, properties = c("classif", 
         "classif.multi", "req.pred", "req.truth"), fun = function (task, model, pred, 
             feats, extra.args) 
         {
             measureMMCE(pred$data$truth, pred$data$response)
         }, extra.args = list(), best = 0, worst = 1, name = "Mean misclassification error", 
             note = "Defined as: mean(response != truth)", aggr = structure(list(id = "test.mean", 
                 name = "Test mean", fun = function (task, perf.test, perf.train, measure, 
                     group, pred) 
                 mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure")), 
         keep.pred = TRUE, models = TRUE, show.info = FALSE)
  5: resample(lrn, tasks[[task]], resamplings[[task]], measures = measures, models = models, 
         extract = extract.this, keep.pred = keep.pred, show.info = show.info)
  6: parallelMap(doResampleIteration, seq_len(rin$desc$iters), level = "mlr.resample", 
         more.args = more.args)
  7: options(parallelMap.nextmap = (getPMOptNextMap() + 1L))
  8: getPMOptNextMap()
  9: getPMOption("nextmap")
  10: getOption(sprintf("parallelMap.%s", opt), def)
  
  ── 19. Error: drop option works for BenchmarkResults_operators (@test_base_bench
  argument "def" is missing, with no default
  1: benchmark(learners = learners, task = tasks, resampling = hout) at testthat/test_base_benchmark.R:232
  2: parallelMap(benchmarkParallel, task = grid$task, learner = grid$learner, more.args = list(learners = learners, 
         tasks = tasks, resamplings = resamplings, measures = measures, keep.pred = keep.pred, 
         models = models, show.info = show.info), level = plevel)
  3: mapply(fun2, ..., MoreArgs = more.args, SIMPLIFY = FALSE, USE.NAMES = FALSE)
  4: (function (task, learner, learners, tasks, resamplings, measures, keep.pred = TRUE, 
         models = TRUE, show.info) 
     {
         setSlaveOptions()
         if (show.info) 
             messagef("Task: %s, Learner: %s", task, learner)
         lrn = learners[[learner]]
         extract.this = getExtractor(lrn)
         r = resample(lrn, tasks[[task]], resamplings[[task]], measures = measures, models = models, 
             extract = extract.this, keep.pred = keep.pred, show.info = show.info)
         r$learner = lrn
         return(r)
     })(task = dots[[1L]][[1L]], learner = dots[[2L]][[1L]], learners = list(classif.lda = structure(list(
         id = "classif.lda", type = "classif", package = "MASS", properties = c("twoclass", 
         "multiclass", "numerics", "factors", "prob"), par.set = structure(list(pars = list(
             method = structure(list(id = "method", type = "discrete", len = 1L, lower = NULL, 
                 upper = NULL, values = list(moment = "moment", mle = "mle", mve = "mve", 
                     t = "t"), cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = "moment", 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), nu = structure(list(
                 id = "nu", type = "numeric", len = 1L, lower = 2, upper = Inf, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, 
                 trafo = NULL, requires = method == "t", tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), tol = structure(list(
                 id = "tol", type = "numeric", len = 1L, lower = 0, upper = Inf, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 1e-04, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), predict.method = structure(list(
                 id = "predict.method", type = "discrete", len = 1L, lower = NULL, upper = NULL, 
                 values = list(`plug-in` = "plug-in", predictive = "predictive", debiased = "debiased"), 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = "plug-in", 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "predict"), class = c("LearnerParam", "Param")), CV = structure(list(
                 id = "CV", type = "logical", len = 1L, lower = NULL, upper = NULL, values = list(
                     `TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = FALSE, trafo = NULL, requires = NULL, tunable = FALSE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), prior = structure(list(id = "prior", type = "numericvector", len = NA_integer_, 
                 lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             ))), forbidden = NULL), class = c("LearnerParamSet", "ParamSet")), par.vals = list(), 
         predict.type = "response", name = "Linear Discriminant Analysis", short.name = "lda", 
         note = "Learner parameter `predict.method` maps to `method` in `predict.lda`.", 
         callees = c("lda", "predict.lda"), help.list = list(prior = "Argument of: MASS::lda\n\nthe prior probabilities of class membership.  If unspecified, the class proportions for the training set are used.  If present, the probabilities should be specified in the order of the factor levels.", 
             method = "Argument of: MASS::lda\n\n\"moment\" for standard estimators of the mean and variance, \"mle\" for MLEs, \"mve\" to use cov.mve, or \"t\" for robust estimates based on a t distribution.", 
             tol = "Argument of: MASS::lda\n\nA tolerance to decide if a matrix is singular; it will reject variables and linear combinations of unit-variance variables whose variance is less than tol^2.", 
             CV = "Argument of: MASS::lda\n\nIf true, returns results (classes and posterior probabilities) for leave-one-out cross-validation. Note that if the prior is estimated, the proportions in the whole dataset are used.", 
             nu = "Argument of: MASS::lda\n\ndegrees of freedom for method = \"t\"."), 
         config = list(), fix.factors.prediction = FALSE), class = c("classif.lda", "RLearnerClassif", 
     "RLearner", "Learner")), classif.rpart = structure(list(id = "classif.rpart", type = "classif", 
         package = "rpart", properties = c("twoclass", "multiclass", "missings", "numerics", 
         "factors", "ordered", "prob", "weights", "featimp"), par.set = structure(list(
             pars = list(minsplit = structure(list(id = "minsplit", type = "integer", 
                 len = 1L, lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 20L, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), minbucket = structure(list(id = "minbucket", type = "integer", len = 1L, 
                 lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), cp = structure(list(id = "cp", type = "numeric", len = 1L, lower = 0, 
                 upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 0.01, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), maxcompete = structure(list(
                 id = "maxcompete", type = "integer", len = 1L, lower = 0L, upper = Inf, 
                 values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 4L, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), maxsurrogate = structure(list(
                 id = "maxsurrogate", type = "integer", len = 1L, lower = 0L, upper = Inf, 
                 values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 5L, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), usesurrogate = structure(list(
                 id = "usesurrogate", type = "discrete", len = 1L, lower = NULL, upper = NULL, 
                 values = list(`0` = 0L, `1` = 1L, `2` = 2L), cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 2L, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), surrogatestyle = structure(list(id = "surrogatestyle", type = "discrete", 
                 len = 1L, lower = NULL, upper = NULL, values = list(`0` = 0L, `1` = 1L), 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 0L, trafo = NULL, 
                 requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), maxdepth = structure(list(id = "maxdepth", type = "integer", len = 1L, 
                 lower = 1L, upper = 30L, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 30L, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), xval = structure(list(id = "xval", type = "integer", len = 1L, lower = 0L, 
                 upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 10L, trafo = NULL, requires = NULL, tunable = FALSE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), parms = structure(list(
                 id = "parms", type = "untyped", len = 1L, lower = NULL, upper = NULL, 
                 values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                 default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param"))), forbidden = NULL), class = c("LearnerParamSet", 
         "ParamSet")), par.vals = list(xval = 0L), predict.type = "response", name = "Decision Tree", 
         short.name = "rpart", note = "`xval` has been set to `0` by default for speed.", 
         callees = c("rpart", "rpart.control"), help.list = list(minsplit = "Argument of: rpart::rpart.control\n\nthe minimum number of observations that must exist in a node in order for a split to be attempted.", 
             minbucket = "Argument of: rpart::rpart.control\n\nthe minimum number of observations in any terminal <leaf> node. If only one of minbucket or minsplit is specified, the code either sets minsplit to minbucket*3 or minbucket to minsplit/3, as appropriate.", 
             cp = "Argument of: rpart::rpart.control\n\ncomplexity parameter.  Any split that does not decrease the overall lack of fit by a factor of cp is not attempted.  For instance, with anova splitting, this means that the overall R-squared must increase by cp at each step. The main role of this parameter is to save computing time by pruning off splits that are obviously not worthwhile. Essentially,the user informs the program that any split which does not improve the fit by cp will likely be pruned off by cross-validation, and that hence the program need not pursue it.", 
             maxcompete = "Argument of: rpart::rpart.control\n\nthe number of competitor splits retained in the output.  It is useful to know not just which split was chosen, but which variable came in second, third, etc.", 
             maxsurrogate = "Argument of: rpart::rpart.control\n\nthe number of surrogate splits retained in the output.  If this is set to zero the compute time will be reduced, since approximately half of the computational time (other than setup) is used in the search for surrogate splits.", 
             usesurrogate = "Argument of: rpart::rpart.control\n\nhow to use surrogates in the splitting process.  0 means display only; an observation with a missing value for the primary split rule is not sent further down the tree.  1 means use surrogates, in order, to split subjects missing the primary variable; if all surrogates are missing the observation is not split.  For value 2 ,if all surrogates are missing, then send the observation in the majority direction.  A value of 0 corresponds to the action of tree, and 2 to the recommendations of Breiman et.al (1984).", 
             xval = "Argument of: rpart::rpart.control\n\nnumber of cross-validations.", 
             surrogatestyle = "Argument of: rpart::rpart.control\n\ncontrols the selection of a best surrogate. If set to 0 (default) the program uses the total number of correct classification for a potential surrogate variable, if set to 1 it uses the percent correct, calculated over the non-missing values of the surrogate. The first option more severely penalizes covariates with a large number of missing values.", 
             maxdepth = "Argument of: rpart::rpart.control\n\nSet the maximum depth of any node of the final tree, with the root node counted as depth 0.  Values greater than  30 rpart will give nonsense results on 32-bit machines.", 
             parms = "Argument of: rpart::rpart\n\noptional parameters for the splitting function. Anova splitting has no parameters. Poisson splitting has a single parameter, the coefficient of variation of the prior distribution on the rates.  The default value is 1. Exponential splitting has the same parameter as Poisson. For classification splitting, the list can contain any of: the vector of prior probabilities (component prior), the loss matrix (component loss) or the splitting index (component split).  The priors must be positive and sum to 1.  The loss matrix must have zeros on the diagonal and positive off-diagonal elements.  The splitting index can be gini or information.  The default priors are proportional to the data counts, the losses default to 1, and the split defaults to gini."), 
         config = list(), fix.factors.prediction = FALSE), class = c("classif.rpart", 
     "RLearnerClassif", "RLearner", "Learner"))), tasks = list(binary = structure(list(
         type = "classif", env = <environment>, weights = NULL, blocking = NULL, coordinates = NULL, 
         task.desc = structure(list(id = "binary", type = "classif", target = "Class", 
             size = 208L, n.feat = c(numerics = 60L, factors = 0L, ordered = 0L, functionals = 0L
             ), has.missings = FALSE, has.weights = FALSE, has.blocking = FALSE, has.coordinates = FALSE, 
             class.levels = c("M", "R"), positive = "M", negative = "R", class.distribution = structure(c(M = 111L, 
             R = 97L), .Dim = 2L, .Dimnames = list(c("M", "R")), class = "table")), class = c("ClassifTaskDesc", 
         "SupervisedTaskDesc", "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", 
     "Task")), multiclass = structure(list(type = "classif", env = <environment>, weights = NULL, 
         blocking = NULL, coordinates = NULL, task.desc = structure(list(id = "multiclass", 
             type = "classif", target = "Species", size = 150L, n.feat = c(numerics = 4L, 
             factors = 0L, ordered = 0L, functionals = 0L), has.missings = FALSE, has.weights = FALSE, 
             has.blocking = FALSE, has.coordinates = FALSE, class.levels = c("setosa", 
             "versicolor", "virginica"), positive = NA_character_, negative = NA_character_, 
             class.distribution = structure(c(setosa = 50L, versicolor = 50L, virginica = 50L
             ), .Dim = 3L, .Dimnames = list(c("setosa", "versicolor", "virginica")), class = "table")), class = c("ClassifTaskDesc", 
         "SupervisedTaskDesc", "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", 
     "Task"))), resamplings = list(binary = structure(list(desc = structure(list(split = 0.666666666666667, 
         id = "holdout", iters = 1L, predict = "test", stratify = FALSE), class = c("HoldoutDesc", 
     "ResampleDesc")), size = 208L, train.inds = list(c(60L, 164L, 85L, 182L, 192L, 10L, 
     107L, 180L, 111L, 91L, 190L, 90L, 133L, 112L, 20L, 174L, 48L, 9L, 63L, 181L, 168L, 
     130L, 120L, 184L, 121L, 187L, 100L, 108L, 53L, 27L, 172L, 160L, 122L, 140L, 5L, 83L, 
     131L, 38L, 55L, 40L, 24L, 70L, 69L, 61L, 26L, 23L, 171L, 76L, 43L, 137L, 8L, 167L, 
     125L, 19L, 87L, 32L, 194L, 114L, 135L, 56L, 99L, 14L, 57L, 169L, 118L, 65L, 116L, 
     115L, 195L, 62L, 105L, 154L, 97L, 1L, 64L, 30L, 51L, 81L, 46L, 15L, 153L, 206L, 201L, 
     148L, 13L, 54L, 185L, 109L, 202L, 21L, 16L, 77L, 145L, 161L, 37L, 22L, 88L, 11L, 
     52L, 149L, 143L, 36L, 110L, 101L, 132L, 92L, 94L, 139L, 42L, 129L, 103L, 196L, 6L, 
     199L, 68L, 147L, 104L, 159L, 126L, 151L, 58L, 28L, 179L, 155L, 128L, 82L, 124L, 158L, 
     12L, 170L, 49L, 166L, 106L, 176L, 39L, 78L, 208L, 75L)), test.inds = list(c(204L, 
     84L, 3L, 47L, 98L, 200L, 41L, 205L, 189L, 66L, 134L, 74L, 193L, 33L, 117L, 44L, 197L, 
     142L, 50L, 152L, 95L, 71L, 35L, 178L, 138L, 146L, 29L, 7L, 207L, 177L, 157L, 67L, 
     72L, 150L, 45L, 17L, 86L, 18L, 136L, 96L, 25L, 198L, 80L, 191L, 79L, 156L, 2L, 119L, 
     186L, 183L, 175L, 163L, 4L, 93L, 127L, 203L, 123L, 102L, 113L, 73L, 34L, 165L, 144L, 
     188L, 141L, 59L, 162L, 173L, 31L, 89L)), group = structure(integer(0), .Label = character(0), class = "factor")), class = "ResampleInstance"), 
         multiclass = structure(list(desc = structure(list(split = 0.666666666666667, 
             id = "holdout", iters = 1L, predict = "test", stratify = FALSE), class = c("HoldoutDesc", 
         "ResampleDesc")), size = 150L, train.inds = list(c(148L, 58L, 34L, 92L, 20L, 
         141L, 75L, 24L, 89L, 140L, 94L, 59L, 45L, 115L, 146L, 27L, 121L, 41L, 48L, 103L, 
         26L, 3L, 53L, 62L, 54L, 43L, 108L, 56L, 66L, 117L, 93L, 25L, 37L, 114L, 68L, 
         88L, 125L, 87L, 61L, 102L, 21L, 31L, 11L, 23L, 104L, 32L, 76L, 81L, 124L, 119L, 
         28L, 111L, 12L, 97L, 95L, 14L, 86L, 126L, 118L, 133L, 64L, 8L, 30L, 60L, 100L, 
         71L, 19L, 42L, 107L, 16L, 77L, 130L, 38L, 129L, 83L, 49L, 138L, 143L, 65L, 74L, 
         22L, 135L, 99L, 149L, 63L, 147L, 70L, 122L, 15L, 78L, 7L, 29L, 6L, 10L, 131L, 
         33L, 40L, 9L, 46L, 72L)), test.inds = list(c(51L, 35L, 18L, 36L, 90L, 127L, 1L, 
         132L, 105L, 13L, 47L, 73L, 101L, 5L, 142L, 144L, 112L, 96L, 17L, 84L, 123L, 106L, 
         128L, 82L, 134L, 2L, 98L, 52L, 67L, 110L, 50L, 113L, 39L, 57L, 139L, 120L, 116L, 
         150L, 69L, 109L, 79L, 44L, 80L, 136L, 145L, 137L, 85L, 4L, 55L, 91L)), group = structure(integer(0), .Label = character(0), class = "factor")), class = "ResampleInstance")), 
         measures = list(structure(list(id = "mmce", minimize = TRUE, properties = c("classif", 
         "classif.multi", "req.pred", "req.truth"), fun = function (task, model, pred, 
             feats, extra.args) 
         {
             measureMMCE(pred$data$truth, pred$data$response)
         }, extra.args = list(), best = 0, worst = 1, name = "Mean misclassification error", 
             note = "Defined as: mean(response != truth)", aggr = structure(list(id = "test.mean", 
                 name = "Test mean", fun = function (task, perf.test, perf.train, measure, 
                     group, pred) 
                 mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure")), 
         keep.pred = TRUE, models = TRUE, show.info = FALSE)
  5: resample(lrn, tasks[[task]], resamplings[[task]], measures = measures, models = models, 
         extract = extract.this, keep.pred = keep.pred, show.info = show.info)
  6: parallelMap(doResampleIteration, seq_len(rin$desc$iters), level = "mlr.resample", 
         more.args = more.args)
  7: options(parallelMap.nextmap = (getPMOptNextMap() + 1L))
  8: getPMOptNextMap()
  9: getPMOption("nextmap")
  10: getOption(sprintf("parallelMap.%s", opt), def)
  
  ── 20. Error: blocking (@test_base_blocking.R#28)  ─────────────────────────────
  argument "def" is missing, with no default
  1: resample(lrn, ct, rdesc) at testthat/test_base_blocking.R:28
  2: parallelMap(doResampleIteration, seq_len(rin$desc$iters), level = "mlr.resample", 
         more.args = more.args)
  3: options(parallelMap.nextmap = (getPMOptNextMap() + 1L))
  4: getPMOptNextMap()
  5: getPMOption("nextmap")
  6: getOption(sprintf("parallelMap.%s", opt), def)
  
  ── 21. Error: calculateConfusionMatrix (@test_base_calculateConfusionMatrix.R#40
  argument "def" is missing, with no default
  1: resample(makeLearner("classif.rpart"), iris.task, rdesc) at testthat/test_base_calculateConfusionMatrix.R:40
  2: parallelMap(doResampleIteration, seq_len(rin$desc$iters), level = "mlr.resample", 
         more.args = more.args)
  3: options(parallelMap.nextmap = (getPMOptNextMap() + 1L))
  4: getPMOptNextMap()
  5: getPMOption("nextmap")
  6: getOption(sprintf("parallelMap.%s", opt), def)
  
  ── 22. Error: calculateConfusionMatrix elements are consistent with implemented 
  argument "def" is missing, with no default
  1: holdout(makeLearner("classif.rpart"), task, split = 1/2) at testthat/test_base_calculateConfusionMatrix.R:64
  2: resample(learner, task, rdesc, measures = measures, models = models, keep.pred = keep.pred, 
         show.info = show.info)
  3: parallelMap(doResampleIteration, seq_len(rin$desc$iters), level = "mlr.resample", 
         more.args = more.args)
  4: options(parallelMap.nextmap = (getPMOptNextMap() + 1L))
  5: getPMOptNextMap()
  6: getPMOption("nextmap")
  7: getOption(sprintf("parallelMap.%s", opt), def)
  
  ── 23. Error: calculateConfusionMatrix set argument works (@test_base_calculateC
  argument "def" is missing, with no default
  1: resample("classif.rpart", iris.task, rdesc) at testthat/test_base_calculateConfusionMatrix.R:128
  2: parallelMap(doResampleIteration, seq_len(rin$desc$iters), level = "mlr.resample", 
         more.args = more.args)
  3: options(parallelMap.nextmap = (getPMOptNextMap() + 1L))
  4: getPMOptNextMap()
  5: getPMOption("nextmap")
  6: getOption(sprintf("parallelMap.%s", opt), def)
  
  ── 24. Error: calculateConfusionMatrix raises error when set argument is 'wrong'
  argument "def" is missing, with no default
  1: resample("classif.rpart", iris.task, rdesc.test) at testthat/test_base_calculateConfusionMatrix.R:147
  2: parallelMap(doResampleIteration, seq_len(rin$desc$iters), level = "mlr.resample", 
         more.args = more.args)
  3: options(parallelMap.nextmap = (getPMOptNextMap() + 1L))
  4: getPMOptNextMap()
  5: getPMOption("nextmap")
  6: getOption(sprintf("parallelMap.%s", opt), def)
  
  ── 25. Error: calculateROCMeasures (@test_base_calculateROCMeasures.R#5)  ──────
  argument "def" is missing, with no default
  1: resample(makeLearner("classif.rpart"), binaryclass.task, rdesc) at testthat/test_base_calculateROCMeasures.R:5
  2: parallelMap(doResampleIteration, seq_len(rin$desc$iters), level = "mlr.resample", 
         more.args = more.args)
  3: options(parallelMap.nextmap = (getPMOptNextMap() + 1L))
  4: getPMOptNextMap()
  5: getPMOption("nextmap")
  6: getOption(sprintf("parallelMap.%s", opt), def)
  
  ── 26. Error: chains (@test_base_chains.R#23)  ─────────────────────────────────
  argument "def" is missing, with no default
  1: train(lrn5, task = multiclass.task) at testthat/test_base_chains.R:23
  2: measureTime(fun1({
         learner.model = fun2(fun3(do.call(trainLearner, pars)))
     }))
  3: force(expr)
  4: fun1({
         learner.model = fun2(fun3(do.call(trainLearner, pars)))
     })
  5: fun2(fun3(do.call(trainLearner, pars)))
  6: fun3(do.call(trainLearner, pars))
  7: do.call(trainLearner, pars)
  8: (function (.learner, .task, .subset, .weights = NULL, ...) 
     {
         UseMethod("trainLearner")
     })(.learner = structure(list(id = "classif.rpart.filtered.tuned", type = "classif", 
         package = c("randomForestSRC", "rpart"), properties = NULL, par.set = structure(list(
             pars = list(), forbidden = NULL), class = "ParamSet"), par.vals = list(), 
         predict.type = "response", fix.factors.prediction = FALSE, next.learner = structure(list(
             id = "classif.rpart.filtered", type = "classif", package = c("randomForestSRC", 
             "rpart"), properties = NULL, par.set = structure(list(pars = list(fw.method = structure(list(
                 id = "fw.method", type = "discrete", len = 1L, lower = NULL, upper = NULL, 
                 values = list(anova.test = "anova.test", auc = "auc", carscore = "carscore", 
                     cforest.importance = "cforest.importance", chi.squared = "chi.squared", 
                     gain.ratio = "gain.ratio", information.gain = "information.gain", 
                     kruskal.test = "kruskal.test", linear.correlation = "linear.correlation", 
                     mrmr = "mrmr", oneR = "oneR", permutation.importance = "permutation.importance", 
                     randomForest.importance = "randomForest.importance", randomForestSRC.rfsrc = "randomForestSRC.rfsrc", 
                     randomForestSRC.var.select = "randomForestSRC.var.select", ranger.impurity = "ranger.impurity", 
                     ranger.permutation = "ranger.permutation", rank.correlation = "rank.correlation", 
                     relief = "relief", rf.importance = "rf.importance", rf.min.depth = "rf.min.depth", 
                     symmetrical.uncertainty = "symmetrical.uncertainty", univariate = "univariate", 
                     univariate.model.score = "univariate.model.score", variance = "variance"), 
                 cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), fw.perc = structure(list(
                 id = "fw.perc", type = "numeric", len = 1L, lower = 0, upper = 1, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), fw.abs = structure(list(
                 id = "fw.abs", type = "integer", len = 1L, lower = 0, upper = Inf, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), fw.threshold = structure(list(
                 id = "fw.threshold", type = "numeric", len = 1L, lower = -Inf, upper = Inf, 
                 values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                 default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), fw.mandatory.feat = structure(list(
                 id = "fw.mandatory.feat", type = "untyped", len = 1L, lower = NULL, upper = NULL, 
                 values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                 default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param"))), forbidden = NULL), class = c("LearnerParamSet", 
             "ParamSet")), par.vals = list(fw.method = "randomForestSRC.rfsrc", fw.perc = 0.5), 
             predict.type = "response", fix.factors.prediction = FALSE, next.learner = structure(list(
                 id = "classif.rpart", type = "classif", package = "rpart", properties = c("twoclass", 
                 "multiclass", "missings", "numerics", "factors", "ordered", "prob", "weights", 
                 "featimp"), par.set = structure(list(pars = list(minsplit = structure(list(
                     id = "minsplit", type = "integer", len = 1L, lower = 1L, upper = Inf, 
                     values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = 20L, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), minbucket = structure(list(
                     id = "minbucket", type = "integer", len = 1L, lower = 1L, upper = Inf, 
                     values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                     default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), cp = structure(list(
                     id = "cp", type = "numeric", len = 1L, lower = 0, upper = 1, values = NULL, 
                     cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 0.01, 
                     trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), maxcompete = structure(list(
                     id = "maxcompete", type = "integer", len = 1L, lower = 0L, upper = Inf, 
                     values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = 4L, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), maxsurrogate = structure(list(
                     id = "maxsurrogate", type = "integer", len = 1L, lower = 0L, upper = Inf, 
                     values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = 5L, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), usesurrogate = structure(list(
                     id = "usesurrogate", type = "discrete", len = 1L, lower = NULL, upper = NULL, 
                     values = list(`0` = 0L, `1` = 1L, `2` = 2L), cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 2L, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), surrogatestyle = structure(list(id = "surrogatestyle", type = "discrete", 
                     len = 1L, lower = NULL, upper = NULL, values = list(`0` = 0L, `1` = 1L), 
                     cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 0L, 
                     trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), maxdepth = structure(list(
                     id = "maxdepth", type = "integer", len = 1L, lower = 1L, upper = 30L, 
                     values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = 30L, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), xval = structure(list(
                     id = "xval", type = "integer", len = 1L, lower = 0L, upper = Inf, 
                     values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = 10L, trafo = NULL, requires = NULL, tunable = FALSE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), parms = structure(list(
                     id = "parms", type = "untyped", len = 1L, lower = NULL, upper = NULL, 
                     values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                     default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param"))), forbidden = NULL), class = c("LearnerParamSet", 
                 "ParamSet")), par.vals = list(xval = 0L, minsplit = 10), predict.type = "response", 
                 name = "Decision Tree", short.name = "rpart", note = "`xval` has been set to `0` by default for speed.", 
                 callees = c("rpart", "rpart.control"), help.list = list(minsplit = "Argument of: rpart::rpart.control\n\nthe minimum number of observations that must exist in a node in order for a split to be attempted.", 
                     minbucket = "Argument of: rpart::rpart.control\n\nthe minimum number of observations in any terminal <leaf> node. If only one of minbucket or minsplit is specified, the code either sets minsplit to minbucket*3 or minbucket to minsplit/3, as appropriate.", 
                     cp = "Argument of: rpart::rpart.control\n\ncomplexity parameter.  Any split that does not decrease the overall lack of fit by a factor of cp is not attempted.  For instance, with anova splitting, this means that the overall R-squared must increase by cp at each step. The main role of this parameter is to save computing time by pruning off splits that are obviously not worthwhile. Essentially,the user informs the program that any split which does not improve the fit by cp will likely be pruned off by cross-validation, and that hence the program need not pursue it.", 
                     maxcompete = "Argument of: rpart::rpart.control\n\nthe number of competitor splits retained in the output.  It is useful to know not just which split was chosen, but which variable came in second, third, etc.", 
                     maxsurrogate = "Argument of: rpart::rpart.control\n\nthe number of surrogate splits retained in the output.  If this is set to zero the compute time will be reduced, since approximately half of the computational time (other than setup) is used in the search for surrogate splits.", 
                     usesurrogate = "Argument of: rpart::rpart.control\n\nhow to use surrogates in the splitting process.  0 means display only; an observation with a missing value for the primary split rule is not sent further down the tree.  1 means use surrogates, in order, to split subjects missing the primary variable; if all surrogates are missing the observation is not split.  For value 2 ,if all surrogates are missing, then send the observation in the majority direction.  A value of 0 corresponds to the action of tree, and 2 to the recommendations of Breiman et.al (1984).", 
                     xval = "Argument of: rpart::rpart.control\n\nnumber of cross-validations.", 
                     surrogatestyle = "Argument of: rpart::rpart.control\n\ncontrols the selection of a best surrogate. If set to 0 (default) the program uses the total number of correct classification for a potential surrogate variable, if set to 1 it uses the percent correct, calculated over the non-missing values of the surrogate. The first option more severely penalizes covariates with a large number of missing values.", 
                     maxdepth = "Argument of: rpart::rpart.control\n\nSet the maximum depth of any node of the final tree, with the root node counted as depth 0.  Values greater than  30 rpart will give nonsense results on 32-bit machines.", 
                     parms = "Argument of: rpart::rpart\n\noptional parameters for the splitting function. Anova splitting has no parameters. Poisson splitting has a single parameter, the coefficient of variation of the prior distribution on the rates.  The default value is 1. Exponential splitting has the same parameter as Poisson. For classification splitting, the list can contain any of: the vector of prior probabilities (component prior), the loss matrix (component loss) or the splitting index (component split).  The priors must be positive and sum to 1.  The loss matrix must have zeros on the diagonal and positive off-diagonal elements.  The splitting index can be gini or information.  The default priors are proportional to the data counts, the losses default to 1, and the split defaults to gini."), 
                 config = list(), fix.factors.prediction = FALSE), class = c("classif.rpart", 
             "RLearnerClassif", "RLearner", "Learner")), model.subclass = "FilterModel", 
             more.args = list()), class = c("FilterWrapper", "BaseWrapper", "Learner")), 
         model.subclass = "TuneModel", resampling = structure(list(id = "cross-validation", 
             iters = 2L, predict = "test", stratify = FALSE), class = c("CVDesc", "ResampleDesc"
         )), measures = list(structure(list(id = "mmce", minimize = TRUE, properties = c("classif", 
         "classif.multi", "req.pred", "req.truth"), fun = function (task, model, pred, 
             feats, extra.args) 
         {
             measureMMCE(pred$data$truth, pred$data$response)
         }, extra.args = list(), best = 0, worst = 1, name = "Mean misclassification error", 
             note = "Defined as: mean(response != truth)", aggr = structure(list(id = "test.mean", 
                 name = "Test mean", fun = function (task, perf.test, perf.train, measure, 
                     group, pred) 
                 mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure")), 
         opt.pars = structure(list(pars = list(minsplit = structure(list(id = "minsplit", 
             type = "discrete", len = 1L, lower = NULL, upper = NULL, values = list(`5` = 5, 
                 `10` = 10), cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, 
             trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list()), class = "Param"), 
             fw.perc = structure(list(id = "fw.perc", type = "discrete", len = 1L, lower = NULL, 
                 upper = NULL, values = list(`0.8` = 0.8, `1` = 1), cnames = NULL, allow.inf = FALSE, 
                 has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list()), class = "Param")), forbidden = NULL), class = "ParamSet"), 
         bit.names = character(0), bits.to.features = function () 
         {
         }, control = structure(list(same.resampling.instance = TRUE, impute.val = NULL, 
             tune.threshold = FALSE, tune.threshold.args = list(), log.fun = function (learner, 
                 task, resampling, measures, par.set, control, opt.path, dob, x, y, remove.nas, 
                 stage, prev.stage) 
             {
                 x.string = paramValueToString(par.set, x, show.missing.values = !remove.nas)
                 if (inherits(learner, "ModelMultiplexer")) 
                     x.string = stri_replace_all(x.string, "", regex = stri_paste(x$selected.learner, 
                       "\\."))
                 logFunDefault(learner, task, resampling, measures, par.set, control, 
                     opt.path, dob, x.string, y, remove.nas, stage, prev.stage, prefixes = c("Tune-x", 
                       "Tune-y"))
             }, final.dw.perc = NULL, extra.args = list(resolution = 10L)), class = c("TuneControlGrid", 
         "TuneControl", "OptControl")), show.info = FALSE), class = c("TuneWrapper", "OptWrapper", 
     "BaseWrapper", "Learner")), .task = structure(list(type = "classif", env = <environment>, 
         weights = NULL, blocking = NULL, coordinates = NULL, task.desc = structure(list(
             id = "multiclass", type = "classif", target = "Species", size = 150L, n.feat = c(numerics = 4L, 
             factors = 0L, ordered = 0L, functionals = 0L), has.missings = FALSE, has.weights = FALSE, 
             has.blocking = FALSE, has.coordinates = FALSE, class.levels = c("setosa", 
             "versicolor", "virginica"), positive = NA_character_, negative = NA_character_, 
             class.distribution = structure(c(setosa = 50L, versicolor = 50L, virginica = 50L
             ), .Dim = 3L, .Dimnames = list(c("setosa", "versicolor", "virginica")), class = "table")), class = c("ClassifTaskDesc", 
         "SupervisedTaskDesc", "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", 
     "Task")), .subset = NULL, xval = 0L, minsplit = 10, fw.method = "randomForestSRC.rfsrc", 
         fw.perc = 0.5)
  9: trainLearner.TuneWrapper(.learner = structure(list(id = "classif.rpart.filtered.tuned", 
         type = "classif", package = c("randomForestSRC", "rpart"), properties = NULL, 
         par.set = structure(list(pars = list(), forbidden = NULL), class = "ParamSet"), 
         par.vals = list(), predict.type = "response", fix.factors.prediction = FALSE, 
         next.learner = structure(list(id = "classif.rpart.filtered", type = "classif", 
             package = c("randomForestSRC", "rpart"), properties = NULL, par.set = structure(list(
                 pars = list(fw.method = structure(list(id = "fw.method", type = "discrete", 
                     len = 1L, lower = NULL, upper = NULL, values = list(anova.test = "anova.test", 
                       auc = "auc", carscore = "carscore", cforest.importance = "cforest.importance", 
                       chi.squared = "chi.squared", gain.ratio = "gain.ratio", information.gain = "information.gain", 
                       kruskal.test = "kruskal.test", linear.correlation = "linear.correlation", 
                       mrmr = "mrmr", oneR = "oneR", permutation.importance = "permutation.importance", 
                       randomForest.importance = "randomForest.importance", randomForestSRC.rfsrc = "randomForestSRC.rfsrc", 
                       randomForestSRC.var.select = "randomForestSRC.var.select", ranger.impurity = "ranger.impurity", 
                       ranger.permutation = "ranger.permutation", rank.correlation = "rank.correlation", 
                       relief = "relief", rf.importance = "rf.importance", rf.min.depth = "rf.min.depth", 
                       symmetrical.uncertainty = "symmetrical.uncertainty", univariate = "univariate", 
                       univariate.model.score = "univariate.model.score", variance = "variance"), 
                     cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, 
                     trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), fw.perc = structure(list(
                     id = "fw.perc", type = "numeric", len = 1L, lower = 0, upper = 1, 
                     values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                     default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), fw.abs = structure(list(
                     id = "fw.abs", type = "integer", len = 1L, lower = 0, upper = Inf, 
                     values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                     default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), fw.threshold = structure(list(
                     id = "fw.threshold", type = "numeric", len = 1L, lower = -Inf, upper = Inf, 
                     values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                     default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), fw.mandatory.feat = structure(list(
                     id = "fw.mandatory.feat", type = "untyped", len = 1L, lower = NULL, 
                     upper = NULL, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                     default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param"))), forbidden = NULL), class = c("LearnerParamSet", 
             "ParamSet")), par.vals = list(fw.method = "randomForestSRC.rfsrc", fw.perc = 0.5), 
             predict.type = "response", fix.factors.prediction = FALSE, next.learner = structure(list(
                 id = "classif.rpart", type = "classif", package = "rpart", properties = c("twoclass", 
                 "multiclass", "missings", "numerics", "factors", "ordered", "prob", "weights", 
                 "featimp"), par.set = structure(list(pars = list(minsplit = structure(list(
                     id = "minsplit", type = "integer", len = 1L, lower = 1L, upper = Inf, 
                     values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = 20L, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), minbucket = structure(list(
                     id = "minbucket", type = "integer", len = 1L, lower = 1L, upper = Inf, 
                     values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                     default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), cp = structure(list(
                     id = "cp", type = "numeric", len = 1L, lower = 0, upper = 1, values = NULL, 
                     cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 0.01, 
                     trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), maxcompete = structure(list(
                     id = "maxcompete", type = "integer", len = 1L, lower = 0L, upper = Inf, 
                     values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = 4L, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), maxsurrogate = structure(list(
                     id = "maxsurrogate", type = "integer", len = 1L, lower = 0L, upper = Inf, 
                     values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = 5L, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), usesurrogate = structure(list(
                     id = "usesurrogate", type = "discrete", len = 1L, lower = NULL, upper = NULL, 
                     values = list(`0` = 0L, `1` = 1L, `2` = 2L), cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 2L, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), surrogatestyle = structure(list(id = "surrogatestyle", type = "discrete", 
                     len = 1L, lower = NULL, upper = NULL, values = list(`0` = 0L, `1` = 1L), 
                     cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 0L, 
                     trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), maxdepth = structure(list(
                     id = "maxdepth", type = "integer", len = 1L, lower = 1L, upper = 30L, 
                     values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = 30L, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), xval = structure(list(
                     id = "xval", type = "integer", len = 1L, lower = 0L, upper = Inf, 
                     values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = 10L, trafo = NULL, requires = NULL, tunable = FALSE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), parms = structure(list(
                     id = "parms", type = "untyped", len = 1L, lower = NULL, upper = NULL, 
                     values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                     default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param"))), forbidden = NULL), class = c("LearnerParamSet", 
                 "ParamSet")), par.vals = list(xval = 0L, minsplit = 10), predict.type = "response", 
                 name = "Decision Tree", short.name = "rpart", note = "`xval` has been set to `0` by default for speed.", 
                 callees = c("rpart", "rpart.control"), help.list = list(minsplit = "Argument of: rpart::rpart.control\n\nthe minimum number of observations that must exist in a node in order for a split to be attempted.", 
                     minbucket = "Argument of: rpart::rpart.control\n\nthe minimum number of observations in any terminal <leaf> node. If only one of minbucket or minsplit is specified, the code either sets minsplit to minbucket*3 or minbucket to minsplit/3, as appropriate.", 
                     cp = "Argument of: rpart::rpart.control\n\ncomplexity parameter.  Any split that does not decrease the overall lack of fit by a factor of cp is not attempted.  For instance, with anova splitting, this means that the overall R-squared must increase by cp at each step. The main role of this parameter is to save computing time by pruning off splits that are obviously not worthwhile. Essentially,the user informs the program that any split which does not improve the fit by cp will likely be pruned off by cross-validation, and that hence the program need not pursue it.", 
                     maxcompete = "Argument of: rpart::rpart.control\n\nthe number of competitor splits retained in the output.  It is useful to know not just which split was chosen, but which variable came in second, third, etc.", 
                     maxsurrogate = "Argument of: rpart::rpart.control\n\nthe number of surrogate splits retained in the output.  If this is set to zero the compute time will be reduced, since approximately half of the computational time (other than setup) is used in the search for surrogate splits.", 
                     usesurrogate = "Argument of: rpart::rpart.control\n\nhow to use surrogates in the splitting process.  0 means display only; an observation with a missing value for the primary split rule is not sent further down the tree.  1 means use surrogates, in order, to split subjects missing the primary variable; if all surrogates are missing the observation is not split.  For value 2 ,if all surrogates are missing, then send the observation in the majority direction.  A value of 0 corresponds to the action of tree, and 2 to the recommendations of Breiman et.al (1984).", 
                     xval = "Argument of: rpart::rpart.control\n\nnumber of cross-validations.", 
                     surrogatestyle = "Argument of: rpart::rpart.control\n\ncontrols the selection of a best surrogate. If set to 0 (default) the program uses the total number of correct classification for a potential surrogate variable, if set to 1 it uses the percent correct, calculated over the non-missing values of the surrogate. The first option more severely penalizes covariates with a large number of missing values.", 
                     maxdepth = "Argument of: rpart::rpart.control\n\nSet the maximum depth of any node of the final tree, with the root node counted as depth 0.  Values greater than  30 rpart will give nonsense results on 32-bit machines.", 
                     parms = "Argument of: rpart::rpart\n\noptional parameters for the splitting function. Anova splitting has no parameters. Poisson splitting has a single parameter, the coefficient of variation of the prior distribution on the rates.  The default value is 1. Exponential splitting has the same parameter as Poisson. For classification splitting, the list can contain any of: the vector of prior probabilities (component prior), the loss matrix (component loss) or the splitting index (component split).  The priors must be positive and sum to 1.  The loss matrix must have zeros on the diagonal and positive off-diagonal elements.  The splitting index can be gini or information.  The default priors are proportional to the data counts, the losses default to 1, and the split defaults to gini."), 
                 config = list(), fix.factors.prediction = FALSE), class = c("classif.rpart", 
             "RLearnerClassif", "RLearner", "Learner")), model.subclass = "FilterModel", 
             more.args = list()), class = c("FilterWrapper", "BaseWrapper", "Learner")), 
         model.subclass = "TuneModel", resampling = structure(list(id = "cross-validation", 
             iters = 2L, predict = "test", stratify = FALSE), class = c("CVDesc", "ResampleDesc"
         )), measures = list(structure(list(id = "mmce", minimize = TRUE, properties = c("classif", 
         "classif.multi", "req.pred", "req.truth"), fun = function (task, model, pred, 
             feats, extra.args) 
         {
             measureMMCE(pred$data$truth, pred$data$response)
         }, extra.args = list(), best = 0, worst = 1, name = "Mean misclassification error", 
             note = "Defined as: mean(response != truth)", aggr = structure(list(id = "test.mean", 
                 name = "Test mean", fun = function (task, perf.test, perf.train, measure, 
                     group, pred) 
                 mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure")), 
         opt.pars = structure(list(pars = list(minsplit = structure(list(id = "minsplit", 
             type = "discrete", len = 1L, lower = NULL, upper = NULL, values = list(`5` = 5, 
                 `10` = 10), cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, 
             trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list()), class = "Param"), 
             fw.perc = structure(list(id = "fw.perc", type = "discrete", len = 1L, lower = NULL, 
                 upper = NULL, values = list(`0.8` = 0.8, `1` = 1), cnames = NULL, allow.inf = FALSE, 
                 has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list()), class = "Param")), forbidden = NULL), class = "ParamSet"), 
         bit.names = character(0), bits.to.features = function () 
         {
         }, control = structure(list(same.resampling.instance = TRUE, impute.val = NULL, 
             tune.threshold = FALSE, tune.threshold.args = list(), log.fun = function (learner, 
                 task, resampling, measures, par.set, control, opt.path, dob, x, y, remove.nas, 
                 stage, prev.stage) 
             {
                 x.string = paramValueToString(par.set, x, show.missing.values = !remove.nas)
                 if (inherits(learner, "ModelMultiplexer")) 
                     x.string = stri_replace_all(x.string, "", regex = stri_paste(x$selected.learner, 
                       "\\."))
                 logFunDefault(learner, task, resampling, measures, par.set, control, 
                     opt.path, dob, x.string, y, remove.nas, stage, prev.stage, prefixes = c("Tune-x", 
                       "Tune-y"))
             }, final.dw.perc = NULL, extra.args = list(resolution = 10L)), class = c("TuneControlGrid", 
         "TuneControl", "OptControl")), show.info = FALSE), class = c("TuneWrapper", "OptWrapper", 
     "BaseWrapper", "Learner")), .task = structure(list(type = "classif", env = <environment>, 
         weights = NULL, blocking = NULL, coordinates = NULL, task.desc = structure(list(
             id = "multiclass", type = "classif", target = "Species", size = 150L, n.feat = c(numerics = 4L, 
             factors = 0L, ordered = 0L, functionals = 0L), has.missings = FALSE, has.weights = FALSE, 
             has.blocking = FALSE, has.coordinates = FALSE, class.levels = c("setosa", 
             "versicolor", "virginica"), positive = NA_character_, negative = NA_character_, 
             class.distribution = structure(c(setosa = 50L, versicolor = 50L, virginica = 50L
             ), .Dim = 3L, .Dimnames = list(c("setosa", "versicolor", "virginica")), class = "table")), class = c("ClassifTaskDesc", 
         "SupervisedTaskDesc", "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", 
     "Task")), .subset = NULL, xval = 0L, minsplit = 10, fw.method = "randomForestSRC.rfsrc", 
         fw.perc = 0.5)
  10: tuneParams(.learner$next.learner, .task, .learner$resampling, .learner$measures, 
         .learner$opt.pars, .learner$control, .learner$show.info)
  ...
  15: mapply(fun2, ..., MoreArgs = more.args, SIMPLIFY = FALSE, USE.NAMES = FALSE)
  16: (function (learner, task, resampling, measures, par.set, bits.to.features, control, 
         opt.path, show.info, dob, state, remove.nas, resample.fun) 
     {
         setSlaveOptions()
         y = setNames(rep(NA_real_, length(measures)), vcapply(measures, measureAggrName))
         errmsg = NA_character_
         exec.time = NA_real_
         set.pars.ok = TRUE
         learner2 = learner
         threshold = NULL
         log.fun = control$log.fun
         err.dumps = list()
         if (inherits(control, "TuneControl") || inherits(control, "TuneMultiCritControl")) {
             state = setValueCNames(par.set, state)
             state = trafoValue(par.set, state)
             state2 = if (remove.nas) 
                 removeMissingValues(state)
             else state
             learner2 = try(setHyperPars(learner, par.vals = state2), silent = TRUE)
             if (is.error(learner2)) {
                 set.pars.ok = FALSE
                 errmsg = as.character(learner2)
                 if (show.info) 
                     messagef("[Tune-x] Setting hyperpars failed: %s", errmsg)
             }
         }
         else if (inherits(control, "FeatSelControl")) {
             task = subsetTask(task, features = bits.to.features(state, task))
         }
         if (show.info) 
             prev.stage = log.fun(learner, task, resampling, measures, par.set, control, 
                 opt.path, dob, state, NA_real_, remove.nas, stage = 1L)
         if (set.pars.ok) {
             exec.time = measureTime({
                 r = resample.fun(learner2, task, resampling, measures = measures, show.info = FALSE)
             })
             if (control$tune.threshold) {
                 th.args = control$tune.threshold.args
                 th.args$pred = r$pred
                 th.args$measure = measures[[1L]]
                 tune.th.res = do.call(tuneThreshold, th.args)
                 threshold = tune.th.res$th
                 y = performance(setThreshold(r$pred, threshold = threshold), measures = measures)
                 names(y) = names(r$aggr)
             }
             else {
                 y = r$aggr
             }
             errmsgs = as.character(t(r$err.msgs[, -1L]))
             notna = !is.na(errmsgs)
             if (any(notna)) 
                 errmsg = errmsgs[notna][1L]
             err.dumps = r$err.dumps
         }
         else {
             if (control$tune.threshold) 
                 threshold = NA_real_
         }
         if (show.info) 
             log.fun(learner, task, resampling, measures, par.set, control, opt.path, 
                 dob, state, y, remove.nas, stage = 2L, prev.stage = prev.stage)
         list(y = y, exec.time = exec.time, errmsg = errmsg, threshold = threshold, err.dumps = err.dumps)
     })(dots[[1L]][[1L]], dots[[2L]][[1L]], learner = structure(list(id = "classif.rpart.filtered", 
         type = "classif", package = c("randomForestSRC", "rpart"), properties = NULL, 
         par.set = structure(list(pars = list(fw.method = structure(list(id = "fw.method", 
             type = "discrete", len = 1L, lower = NULL, upper = NULL, values = list(anova.test = "anova.test", 
                 auc = "auc", carscore = "carscore", cforest.importance = "cforest.importance", 
                 chi.squared = "chi.squared", gain.ratio = "gain.ratio", information.gain = "information.gain", 
                 kruskal.test = "kruskal.test", linear.correlation = "linear.correlation", 
                 mrmr = "mrmr", oneR = "oneR", permutation.importance = "permutation.importance", 
                 randomForest.importance = "randomForest.importance", randomForestSRC.rfsrc = "randomForestSRC.rfsrc", 
                 randomForestSRC.var.select = "randomForestSRC.var.select", ranger.impurity = "ranger.impurity", 
                 ranger.permutation = "ranger.permutation", rank.correlation = "rank.correlation", 
                 relief = "relief", rf.importance = "rf.importance", rf.min.depth = "rf.min.depth", 
                 symmetrical.uncertainty = "symmetrical.uncertainty", univariate = "univariate", 
                 univariate.model.score = "univariate.model.score", variance = "variance"), 
             cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, 
             requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), fw.perc = structure(list(id = "fw.perc", type = "numeric", len = 1L, 
             lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
             default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
             when = "train"), class = c("LearnerParam", "Param")), fw.abs = structure(list(
             id = "fw.abs", type = "integer", len = 1L, lower = 0, upper = Inf, values = NULL, 
             cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, 
             requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), fw.threshold = structure(list(id = "fw.threshold", type = "numeric", 
             len = 1L, lower = -Inf, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
             has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, 
             special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
         )), fw.mandatory.feat = structure(list(id = "fw.mandatory.feat", type = "untyped", 
             len = 1L, lower = NULL, upper = NULL, values = NULL, cnames = NULL, allow.inf = FALSE, 
             has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, 
             special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
         ))), forbidden = NULL), class = c("LearnerParamSet", "ParamSet")), par.vals = list(
             fw.method = "randomForestSRC.rfsrc", fw.perc = 0.5), predict.type = "response", 
         fix.factors.prediction = FALSE, next.learner = structure(list(id = "classif.rpart", 
             type = "classif", package = "rpart", properties = c("twoclass", "multiclass", 
             "missings", "numerics", "factors", "ordered", "prob", "weights", "featimp"
             ), par.set = structure(list(pars = list(minsplit = structure(list(id = "minsplit", 
                 type = "integer", len = 1L, lower = 1L, upper = Inf, values = NULL, cnames = NULL, 
                 allow.inf = FALSE, has.default = TRUE, default = 20L, trafo = NULL, requires = NULL, 
                 tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), minbucket = structure(list(id = "minbucket", type = "integer", 
                 len = 1L, lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), cp = structure(list(id = "cp", type = "numeric", len = 1L, lower = 0, 
                 upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 0.01, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), maxcompete = structure(list(
                 id = "maxcompete", type = "integer", len = 1L, lower = 0L, upper = Inf, 
                 values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 4L, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), maxsurrogate = structure(list(
                 id = "maxsurrogate", type = "integer", len = 1L, lower = 0L, upper = Inf, 
                 values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 5L, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), usesurrogate = structure(list(
                 id = "usesurrogate", type = "discrete", len = 1L, lower = NULL, upper = NULL, 
                 values = list(`0` = 0L, `1` = 1L, `2` = 2L), cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 2L, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), surrogatestyle = structure(list(id = "surrogatestyle", type = "discrete", 
                 len = 1L, lower = NULL, upper = NULL, values = list(`0` = 0L, `1` = 1L), 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 0L, trafo = NULL, 
                 requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), maxdepth = structure(list(id = "maxdepth", type = "integer", len = 1L, 
                 lower = 1L, upper = 30L, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 30L, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), xval = structure(list(id = "xval", type = "integer", len = 1L, lower = 0L, 
                 upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 10L, trafo = NULL, requires = NULL, tunable = FALSE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), parms = structure(list(
                 id = "parms", type = "untyped", len = 1L, lower = NULL, upper = NULL, 
                 values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                 default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param"))), forbidden = NULL), class = c("LearnerParamSet", 
             "ParamSet")), par.vals = list(xval = 0L, minsplit = 10), predict.type = "response", 
             name = "Decision Tree", short.name = "rpart", note = "`xval` has been set to `0` by default for speed.", 
             callees = c("rpart", "rpart.control"), help.list = list(minsplit = "Argument of: rpart::rpart.control\n\nthe minimum number of observations that must exist in a node in order for a split to be attempted.", 
                 minbucket = "Argument of: rpart::rpart.control\n\nthe minimum number of observations in any terminal <leaf> node. If only one of minbucket or minsplit is specified, the code either sets minsplit to minbucket*3 or minbucket to minsplit/3, as appropriate.", 
                 cp = "Argument of: rpart::rpart.control\n\ncomplexity parameter.  Any split that does not decrease the overall lack of fit by a factor of cp is not attempted.  For instance, with anova splitting, this means that the overall R-squared must increase by cp at each step. The main role of this parameter is to save computing time by pruning off splits that are obviously not worthwhile. Essentially,the user informs the program that any split which does not improve the fit by cp will likely be pruned off by cross-validation, and that hence the program need not pursue it.", 
                 maxcompete = "Argument of: rpart::rpart.control\n\nthe number of competitor splits retained in the output.  It is useful to know not just which split was chosen, but which variable came in second, third, etc.", 
                 maxsurrogate = "Argument of: rpart::rpart.control\n\nthe number of surrogate splits retained in the output.  If this is set to zero the compute time will be reduced, since approximately half of the computational time (other than setup) is used in the search for surrogate splits.", 
                 usesurrogate = "Argument of: rpart::rpart.control\n\nhow to use surrogates in the splitting process.  0 means display only; an observation with a missing value for the primary split rule is not sent further down the tree.  1 means use surrogates, in order, to split subjects missing the primary variable; if all surrogates are missing the observation is not split.  For value 2 ,if all surrogates are missing, then send the observation in the majority direction.  A value of 0 corresponds to the action of tree, and 2 to the recommendations of Breiman et.al (1984).", 
                 xval = "Argument of: rpart::rpart.control\n\nnumber of cross-validations.", 
                 surrogatestyle = "Argument of: rpart::rpart.control\n\ncontrols the selection of a best surrogate. If set to 0 (default) the program uses the total number of correct classification for a potential surrogate variable, if set to 1 it uses the percent correct, calculated over the non-missing values of the surrogate. The first option more severely penalizes covariates with a large number of missing values.", 
                 maxdepth = "Argument of: rpart::rpart.control\n\nSet the maximum depth of any node of the final tree, with the root node counted as depth 0.  Values greater than  30 rpart will give nonsense results on 32-bit machines.", 
                 parms = "Argument of: rpart::rpart\n\noptional parameters for the splitting function. Anova splitting has no parameters. Poisson splitting has a single parameter, the coefficient of variation of the prior distribution on the rates.  The default value is 1. Exponential splitting has the same parameter as Poisson. For classification splitting, the list can contain any of: the vector of prior probabilities (component prior), the loss matrix (component loss) or the splitting index (component split).  The priors must be positive and sum to 1.  The loss matrix must have zeros on the diagonal and positive off-diagonal elements.  The splitting index can be gini or information.  The default priors are proportional to the data counts, the losses default to 1, and the split defaults to gini."), 
             config = list(), fix.factors.prediction = FALSE), class = c("classif.rpart", 
         "RLearnerClassif", "RLearner", "Learner")), model.subclass = "FilterModel", more.args = list()), class = c("FilterWrapper", 
     "BaseWrapper", "Learner")), task = structure(list(type = "classif", env = <environment>, 
         weights = NULL, blocking = NULL, coordinates = NULL, task.desc = structure(list(
             id = "multiclass", type = "classif", target = "Species", size = 150L, n.feat = c(numerics = 4L, 
             factors = 0L, ordered = 0L, functionals = 0L), has.missings = FALSE, has.weights = FALSE, 
             has.blocking = FALSE, has.coordinates = FALSE, class.levels = c("setosa", 
             "versicolor", "virginica"), positive = NA_character_, negative = NA_character_, 
             class.distribution = structure(c(setosa = 50L, versicolor = 50L, virginica = 50L
             ), .Dim = 3L, .Dimnames = list(c("setosa", "versicolor", "virginica")), class = "table")), class = c("ClassifTaskDesc", 
         "SupervisedTaskDesc", "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", 
     "Task")), resampling = structure(list(desc = structure(list(id = "cross-validation", 
         iters = 2L, predict = "test", stratify = FALSE), class = c("CVDesc", "ResampleDesc"
     )), size = 150L, train.inds = list(c(32L, 64L, 71L, 50L, 52L, 49L, 73L, 30L, 55L, 
     95L, 107L, 101L, 143L, 69L, 56L, 141L, 122L, 134L, 136L, 68L, 16L, 148L, 96L, 139L, 
     118L, 27L, 44L, 23L, 20L, 98L, 5L, 133L, 34L, 76L, 145L, 86L, 127L, 109L, 41L, 138L, 
     4L, 18L, 13L, 40L, 121L, 22L, 72L, 119L, 113L, 11L, 29L, 61L, 8L, 115L, 63L, 94L, 
     135L, 19L, 21L, 12L, 144L, 1L, 91L, 99L, 2L, 14L, 28L, 70L, 48L, 42L, 126L, 15L, 
     80L, 150L, 54L), c(128L, 75L, 58L, 37L, 17L, 57L, 83L, 31L, 90L, 100L, 35L, 82L, 
     24L, 111L, 85L, 78L, 47L, 66L, 140L, 38L, 84L, 142L, 103L, 120L, 114L, 36L, 67L, 
     43L, 129L, 59L, 39L, 131L, 102L, 92L, 60L, 112L, 149L, 89L, 53L, 51L, 123L, 81L, 
     147L, 26L, 77L, 10L, 97L, 33L, 62L, 130L, 87L, 137L, 25L, 74L, 88L, 45L, 65L, 93L, 
     117L, 3L, 79L, 125L, 106L, 105L, 110L, 108L, 6L, 46L, 132L, 104L, 124L, 9L, 7L, 116L, 
     146L)), test.inds = list(c(3L, 6L, 7L, 9L, 10L, 17L, 24L, 25L, 26L, 31L, 33L, 35L, 
     36L, 37L, 38L, 39L, 43L, 45L, 46L, 47L, 51L, 53L, 57L, 58L, 59L, 60L, 62L, 65L, 66L, 
     67L, 74L, 75L, 77L, 78L, 79L, 81L, 82L, 83L, 84L, 85L, 87L, 88L, 89L, 90L, 92L, 93L, 
     97L, 100L, 102L, 103L, 104L, 105L, 106L, 108L, 110L, 111L, 112L, 114L, 116L, 117L, 
     120L, 123L, 124L, 125L, 128L, 129L, 130L, 131L, 132L, 137L, 140L, 142L, 146L, 147L, 
     149L), c(1L, 2L, 4L, 5L, 8L, 11L, 12L, 13L, 14L, 15L, 16L, 18L, 19L, 20L, 21L, 22L, 
     23L, 27L, 28L, 29L, 30L, 32L, 34L, 40L, 41L, 42L, 44L, 48L, 49L, 50L, 52L, 54L, 55L, 
     56L, 61L, 63L, 64L, 68L, 69L, 70L, 71L, 72L, 73L, 76L, 80L, 86L, 91L, 94L, 95L, 96L, 
     98L, 99L, 101L, 107L, 109L, 113L, 115L, 118L, 119L, 121L, 122L, 126L, 127L, 133L, 
     134L, 135L, 136L, 138L, 139L, 141L, 143L, 144L, 145L, 148L, 150L)), group = structure(integer(0), .Label = character(0), class = "factor")), class = "ResampleInstance"), 
         measures = list(structure(list(id = "mmce", minimize = TRUE, properties = c("classif", 
         "classif.multi", "req.pred", "req.truth"), fun = function (task, model, pred, 
             feats, extra.args) 
         {
             measureMMCE(pred$data$truth, pred$data$response)
         }, extra.args = list(), best = 0, worst = 1, name = "Mean misclassification error", 
             note = "Defined as: mean(response != truth)", aggr = structure(list(id = "test.mean", 
                 name = "Test mean", fun = function (task, perf.test, perf.train, measure, 
                     group, pred) 
                 mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure")), 
         par.set = structure(list(pars = list(minsplit = structure(list(id = "minsplit", 
             type = "discrete", len = 1L, lower = NULL, upper = NULL, values = list(`5` = 5, 
                 `10` = 10), cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, 
             trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list()), class = "Param"), 
             fw.perc = structure(list(id = "fw.perc", type = "discrete", len = 1L, lower = NULL, 
                 upper = NULL, values = list(`0.8` = 0.8, `1` = 1), cnames = NULL, allow.inf = FALSE, 
                 has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list()), class = "Param")), forbidden = NULL), class = "ParamSet"), 
         bits.to.features = NULL, control = structure(list(same.resampling.instance = TRUE, 
             impute.val = 1, tune.threshold = FALSE, tune.threshold.args = list(), log.fun = function (learner, 
                 task, resampling, measures, par.set, control, opt.path, dob, x, y, remove.nas, 
                 stage, prev.stage) 
             {
                 x.string = paramValueToString(par.set, x, show.missing.values = !remove.nas)
                 if (inherits(learner, "ModelMultiplexer")) 
                     x.string = stri_replace_all(x.string, "", regex = stri_paste(x$selected.learner, 
                       "\\."))
                 logFunDefault(learner, task, resampling, measures, par.set, control, 
                     opt.path, dob, x.string, y, remove.nas, stage, prev.stage, prefixes = c("Tune-x", 
                       "Tune-y"))
             }, final.dw.perc = NULL, extra.args = list(resolution = 10L)), class = c("TuneControlGrid", 
         "TuneControl", "OptControl")), opt.path = structure(list(par.set = structure(list(
             pars = list(minsplit = structure(list(id = "minsplit", type = "discrete", 
                 len = 1L, lower = NULL, upper = NULL, values = list(`5` = 5, `10` = 10), 
                 cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list()), class = "Param"), 
                 fw.perc = structure(list(id = "fw.perc", type = "discrete", len = 1L, 
                     lower = NULL, upper = NULL, values = list(`0.8` = 0.8, `1` = 1), 
                     cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, 
                     trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list()), class = "Param")), 
             forbidden = NULL), class = "ParamSet"), y.names = "mmce.test.mean", minimize = c(mmce.test.mean = TRUE), 
             add.transformed.x = FALSE, env = <environment>), class = c("OptPathDF", "OptPath"
         )), show.info = FALSE, remove.nas = TRUE, resample.fun = function (learner, task, 
             resampling, measures, weights = NULL, models = FALSE, extract, keep.pred = TRUE, 
             ..., show.info = getMlrOption("show.info")) 
         {
             learner = checkLearner(learner)
             learner = setHyperPars(learner, ...)
             assertClass(task, classes = "Task")
             n = getTaskSize(task)
             if (inherits(resampling, "ResampleDesc")) 
                 resampling = makeResampleInstance(resampling, task = task)
             assertClass(resampling, classes = "ResampleInstance")
             measures = checkMeasures(measures, task)
             if (!is.null(weights)) {
                 assertNumeric(weights, len = n, any.missing = FALSE, lower = 0)
             }
             assertFlag(models)
             if (missing(extract)) 
                 extract = function(model) {
                 }
             else assertFunction(extract)
             assertFlag(show.info)
             r = resampling$size
             if (n != r) 
                 stop(stri_paste("Size of data set:", n, "and resampling instance:", r, 
                     "differ!", sep = " "))
             checkLearnerBeforeTrain(task, learner, weights)
             checkAggrsBeforeResample(measures, resampling$desc)
             rin = resampling
             more.args = list(learner = learner, task = task, rin = rin, weights = NULL, 
                 measures = measures, model = models, extract = extract, show.info = show.info)
             if (!is.null(weights)) {
                 more.args$weights = weights
             }
             else if (!is.null(getTaskWeights(task))) {
                 more.args$weights = getTaskWeights(task)
             }
             parallelLibrary("mlr", master = FALSE, level = "mlr.resample", show.info = FALSE)
             exportMlrOptions(level = "mlr.resample")
             if (show.info) {
                 messagef("Resampling: %s", rin$desc$id)
                 measure.lognames = extractSubList(measures, "id")
                 if (rin$desc$predict == "both") {
                     id.train = which(vlapply(measures, function(x) "req.train" %in% x$aggr$properties))
                     id.test = which(vlapply(measures, function(x) "req.test" %in% x$aggr$properties))
                     measure.lognames = c(stri_paste(measure.lognames[id.train], "train", 
                       sep = "."), stri_paste(measure.lognames[id.test], "test", sep = "."))
                 }
                 printResampleFormatLine("Measures:", measure.lognames)
             }
             time1 = Sys.time()
             iter.results = parallelMap(doResampleIteration, seq_len(rin$desc$iters), 
                 level = "mlr.resample", more.args = more.args)
             time2 = Sys.time()
             runtime = as.numeric(difftime(time2, time1, units = "secs"))
             addClasses(mergeResampleResult(learner$id, task, iter.results, measures, 
                 rin, models, extract, keep.pred, show.info, runtime), "ResampleResult")
         })
  17: measureTime({
         r = resample.fun(learner2, task, resampling, measures = measures, show.info = FALSE)
     })
  18: force(expr)
  19: resample.fun(learner2, task, resampling, measures = measures, show.info = FALSE)
  20: parallelMap(doResampleIteration, seq_len(rin$desc$iters), level = "mlr.resample", 
         more.args = more.args)
  21: options(parallelMap.nextmap = (getPMOptNextMap() + 1L))
  22: getPMOptNextMap()
  23: getPMOption("nextmap")
  24: getOption(sprintf("parallelMap.%s", opt), def)
  
  ── 27. Error: clustering resample (@test_base_clustering.R#42)  ────────────────
  argument "def" is missing, with no default
  1: resample(lrn, noclass.task, rdesc) at testthat/test_base_clustering.R:42
  2: parallelMap(doResampleIteration, seq_len(rin$desc$iters), level = "mlr.resample", 
         more.args = more.args)
  3: options(parallelMap.nextmap = (getPMOptNextMap() + 1L))
  4: getPMOptNextMap()
  5: getPMOption("nextmap")
  6: getOption(sprintf("parallelMap.%s", opt), def)
  
  ── 28. Error: clustering benchmark (@test_base_clustering.R#55)  ───────────────
  argument "def" is missing, with no default
  1: benchmark(learners = learners, task = tasks, resamplings = makeResampleDesc("CV", 
         iters = 2L)) at testthat/test_base_clustering.R:55
  2: parallelMap(benchmarkParallel, task = grid$task, learner = grid$learner, more.args = list(learners = learners, 
         tasks = tasks, resamplings = resamplings, measures = measures, keep.pred = keep.pred, 
         models = models, show.info = show.info), level = plevel)
  3: mapply(fun2, ..., MoreArgs = more.args, SIMPLIFY = FALSE, USE.NAMES = FALSE)
  4: (function (task, learner, learners, tasks, resamplings, measures, keep.pred = TRUE, 
         models = TRUE, show.info) 
     {
         setSlaveOptions()
         if (show.info) 
             messagef("Task: %s, Learner: %s", task, learner)
         lrn = learners[[learner]]
         extract.this = getExtractor(lrn)
         r = resample(lrn, tasks[[task]], resamplings[[task]], measures = measures, models = models, 
             extract = extract.this, keep.pred = keep.pred, show.info = show.info)
         r$learner = lrn
         return(r)
     })(task = dots[[1L]][[1L]], learner = dots[[2L]][[1L]], learners = list(cluster.SimpleKMeans = structure(list(
         id = "cluster.SimpleKMeans", type = "cluster", package = "RWeka", properties = "numerics", 
         par.set = structure(list(pars = list(A = structure(list(id = "A", type = "untyped", 
             len = 1L, lower = NULL, upper = NULL, values = NULL, cnames = NULL, allow.inf = FALSE, 
             has.default = TRUE, default = "weka.core.EuclideanDistance", trafo = NULL, 
             requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), C = structure(list(id = "C", type = "logical", len = 1L, lower = NULL, 
             upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, 
             allow.inf = FALSE, has.default = TRUE, default = FALSE, trafo = NULL, requires = NULL, 
             tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), fast = structure(list(id = "fast", type = "logical", len = 1L, lower = NULL, 
             upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, 
             allow.inf = FALSE, has.default = TRUE, default = FALSE, trafo = NULL, requires = NULL, 
             tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), I = structure(list(id = "I", type = "integer", len = 1L, lower = 1L, 
             upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
             default = 100L, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
             when = "train"), class = c("LearnerParam", "Param")), init = structure(list(
             id = "init", type = "integer", len = 1L, lower = 0L, upper = 3L, values = NULL, 
             cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 0L, trafo = NULL, 
             requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), M = structure(list(id = "M", type = "logical", len = 1L, lower = NULL, 
             upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, 
             allow.inf = FALSE, has.default = TRUE, default = FALSE, trafo = NULL, requires = NULL, 
             tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), `max-candidates` = structure(list(id = "max-candidates", type = "integer", 
             len = 1L, lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
             has.default = TRUE, default = 100L, trafo = NULL, requires = NULL, tunable = TRUE, 
             special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
         )), `min-density` = structure(list(id = "min-density", type = "integer", len = 1L, 
             lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
             has.default = TRUE, default = 2L, trafo = NULL, requires = NULL, tunable = TRUE, 
             special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
         )), N = structure(list(id = "N", type = "integer", len = 1L, lower = 1L, upper = Inf, 
             values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 2L, 
             trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), `num-slots` = structure(list(id = "num-slots", type = "integer", len = 1L, 
             lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
             has.default = TRUE, default = 1L, trafo = NULL, requires = NULL, tunable = TRUE, 
             special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
         )), O = structure(list(id = "O", type = "logical", len = 1L, lower = NULL, upper = NULL, 
             values = list(`TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, 
             has.default = TRUE, default = FALSE, trafo = NULL, requires = NULL, tunable = TRUE, 
             special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
         )), `periodic-pruning` = structure(list(id = "periodic-pruning", type = "integer", 
             len = 1L, lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
             has.default = TRUE, default = 10000L, trafo = NULL, requires = NULL, tunable = TRUE, 
             special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
         )), S = structure(list(id = "S", type = "integer", len = 1L, lower = 0L, upper = Inf, 
             values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 10L, 
             trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), t2 = structure(list(id = "t2", type = "numeric", len = 1L, lower = -Inf, 
             upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
             default = -1, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
             when = "train"), class = c("LearnerParam", "Param")), t1 = structure(list(
             id = "t1", type = "numeric", len = 1L, lower = -Inf, upper = Inf, values = NULL, 
             cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = -1.5, trafo = NULL, 
             requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), V = structure(list(id = "V", type = "logical", len = 1L, lower = NULL, 
             upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, 
             allow.inf = FALSE, has.default = TRUE, default = FALSE, trafo = NULL, requires = NULL, 
             tunable = FALSE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), `output-debug-info` = structure(list(id = "output-debug-info", type = "logical", 
             len = 1L, lower = NULL, upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), 
             cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = FALSE, trafo = NULL, 
             requires = NULL, tunable = FALSE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param"))), forbidden = NULL), class = c("LearnerParamSet", "ParamSet")), par.vals = list(), 
         predict.type = "response", name = "K-Means Clustering", short.name = "simplekmeans", 
         note = "", callees = c("SimpleKMeans", "Weka_control"), help.list = list(), config = list(), 
         fix.factors.prediction = FALSE), class = c("cluster.SimpleKMeans", "RLearnerCluster", 
     "RLearner", "Learner"))), tasks = list(noclass = structure(list(type = "cluster", 
         env = <environment>, weights = NULL, blocking = NULL, coordinates = NULL, task.desc = structure(list(
             id = "noclass", type = "cluster", target = character(0), size = 150L, n.feat = c(numerics = 4L, 
             factors = 0L, ordered = 0L, functionals = 0L), has.missings = FALSE, has.weights = FALSE, 
             has.blocking = FALSE, has.coordinates = FALSE), class = c("ClusterTaskDesc", 
         "UnsupervisedTaskDesc", "TaskDesc"))), class = c("ClusterTask", "UnsupervisedTask", 
     "Task"))), resamplings = list(noclass = structure(list(desc = structure(list(id = "cross-validation", 
         iters = 2L, predict = "test", stratify = FALSE), class = c("CVDesc", "ResampleDesc"
     )), size = 150L, train.inds = list(c(32L, 64L, 71L, 50L, 52L, 49L, 73L, 30L, 55L, 
     95L, 107L, 101L, 143L, 69L, 56L, 141L, 122L, 134L, 136L, 68L, 16L, 148L, 96L, 139L, 
     118L, 27L, 44L, 23L, 20L, 98L, 5L, 133L, 34L, 76L, 145L, 86L, 127L, 109L, 41L, 138L, 
     4L, 18L, 13L, 40L, 121L, 22L, 72L, 119L, 113L, 11L, 29L, 61L, 8L, 115L, 63L, 94L, 
     135L, 19L, 21L, 12L, 144L, 1L, 91L, 99L, 2L, 14L, 28L, 70L, 48L, 42L, 126L, 15L, 
     80L, 150L, 54L), c(128L, 75L, 58L, 37L, 17L, 57L, 83L, 31L, 90L, 100L, 35L, 82L, 
     24L, 111L, 85L, 78L, 47L, 66L, 140L, 38L, 84L, 142L, 103L, 120L, 114L, 36L, 67L, 
     43L, 129L, 59L, 39L, 131L, 102L, 92L, 60L, 112L, 149L, 89L, 53L, 51L, 123L, 81L, 
     147L, 26L, 77L, 10L, 97L, 33L, 62L, 130L, 87L, 137L, 25L, 74L, 88L, 45L, 65L, 93L, 
     117L, 3L, 79L, 125L, 106L, 105L, 110L, 108L, 6L, 46L, 132L, 104L, 124L, 9L, 7L, 116L, 
     146L)), test.inds = list(c(3L, 6L, 7L, 9L, 10L, 17L, 24L, 25L, 26L, 31L, 33L, 35L, 
     36L, 37L, 38L, 39L, 43L, 45L, 46L, 47L, 51L, 53L, 57L, 58L, 59L, 60L, 62L, 65L, 66L, 
     67L, 74L, 75L, 77L, 78L, 79L, 81L, 82L, 83L, 84L, 85L, 87L, 88L, 89L, 90L, 92L, 93L, 
     97L, 100L, 102L, 103L, 104L, 105L, 106L, 108L, 110L, 111L, 112L, 114L, 116L, 117L, 
     120L, 123L, 124L, 125L, 128L, 129L, 130L, 131L, 132L, 137L, 140L, 142L, 146L, 147L, 
     149L), c(1L, 2L, 4L, 5L, 8L, 11L, 12L, 13L, 14L, 15L, 16L, 18L, 19L, 20L, 21L, 22L, 
     23L, 27L, 28L, 29L, 30L, 32L, 34L, 40L, 41L, 42L, 44L, 48L, 49L, 50L, 52L, 54L, 55L, 
     56L, 61L, 63L, 64L, 68L, 69L, 70L, 71L, 72L, 73L, 76L, 80L, 86L, 91L, 94L, 95L, 96L, 
     98L, 99L, 101L, 107L, 109L, 113L, 115L, 118L, 119L, 121L, 122L, 126L, 127L, 133L, 
     134L, 135L, 136L, 138L, 139L, 141L, 143L, 144L, 145L, 148L, 150L)), group = structure(integer(0), .Label = character(0), class = "factor")), class = "ResampleInstance")), 
         measures = list(structure(list(id = "db", minimize = TRUE, properties = c("cluster", 
         "req.pred", "req.feats"), fun = function (task, model, pred, feats, extra.args) 
         {
             if (length(unique(pred$data$response)) > 1L) {
                 requirePackages("clusterSim", default.method = "load")
                 r = as.integer(as.factor(pred$data$response))
                 clusterSim::index.DB(feats, r)$DB
             }
             else {
                 NA
             }
         }, extra.args = list(), best = 0, worst = Inf, name = "Davies-Bouldin cluster separation measure", 
             note = "Ratio of the within cluster scatter, to the between cluster separation, averaged over the clusters. See `?clusterSim::index.DB`.", 
             aggr = structure(list(id = "test.mean", name = "Test mean", fun = function (task, 
                 perf.test, perf.train, measure, group, pred) 
             mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure")), 
         keep.pred = TRUE, models = TRUE, show.info = FALSE)
  5: resample(lrn, tasks[[task]], resamplings[[task]], measures = measures, models = models, 
         extract = extract.this, keep.pred = keep.pred, show.info = show.info)
  6: parallelMap(doResampleIteration, seq_len(rin$desc$iters), level = "mlr.resample", 
         more.args = more.args)
  7: options(parallelMap.nextmap = (getPMOptNextMap() + 1L))
  8: getPMOptNextMap()
  9: getPMOption("nextmap")
  10: getOption(sprintf("parallelMap.%s", opt), def)
  
  ── 29. Error: clustering tune (@test_base_clustering.R#72)  ────────────────────
  argument "def" is missing, with no default
  1: tuneParams(lrn, noclass.task, rdesc, par.set = ps, control = ctrl) at testthat/test_base_clustering.R:72
  2: sel.func(learner, task, resampling, measures, par.set, control, opt.path, show.info, 
         resample.fun)
  3: evalOptimizationStatesTune(learner, task, resampling, measures, par.set, control, 
         opt.path, show.info, vals, dobs = seq_along(vals), eols = NA_integer_, remove.nas = TRUE, 
         resample.fun)
  4: evalOptimizationStates(learner, task, resampling, measures, par.set, NULL, control, 
         opt.path, show.info, states, dobs, eols, remove.nas, resample.fun, "mlr.tuneParams")
  5: parallelMap(evalOptimizationState, dobs, states, level = level, more.args = list(learner = learner, 
         task = task, resampling = resampling, measures = measures, par.set = par.set, 
         bits.to.features = bits.to.features, control = control, opt.path = opt.path, 
         show.info = show.info, remove.nas = remove.nas, resample.fun = resample.fun))
  6: mapply(fun2, ..., MoreArgs = more.args, SIMPLIFY = FALSE, USE.NAMES = FALSE)
  7: (function (learner, task, resampling, measures, par.set, bits.to.features, control, 
         opt.path, show.info, dob, state, remove.nas, resample.fun) 
     {
         setSlaveOptions()
         y = setNames(rep(NA_real_, length(measures)), vcapply(measures, measureAggrName))
         errmsg = NA_character_
         exec.time = NA_real_
         set.pars.ok = TRUE
         learner2 = learner
         threshold = NULL
         log.fun = control$log.fun
         err.dumps = list()
         if (inherits(control, "TuneControl") || inherits(control, "TuneMultiCritControl")) {
             state = setValueCNames(par.set, state)
             state = trafoValue(par.set, state)
             state2 = if (remove.nas) 
                 removeMissingValues(state)
             else state
             learner2 = try(setHyperPars(learner, par.vals = state2), silent = TRUE)
             if (is.error(learner2)) {
                 set.pars.ok = FALSE
                 errmsg = as.character(learner2)
                 if (show.info) 
                     messagef("[Tune-x] Setting hyperpars failed: %s", errmsg)
             }
         }
         else if (inherits(control, "FeatSelControl")) {
             task = subsetTask(task, features = bits.to.features(state, task))
         }
         if (show.info) 
             prev.stage = log.fun(learner, task, resampling, measures, par.set, control, 
                 opt.path, dob, state, NA_real_, remove.nas, stage = 1L)
         if (set.pars.ok) {
             exec.time = measureTime({
                 r = resample.fun(learner2, task, resampling, measures = measures, show.info = FALSE)
             })
             if (control$tune.threshold) {
                 th.args = control$tune.threshold.args
                 th.args$pred = r$pred
                 th.args$measure = measures[[1L]]
                 tune.th.res = do.call(tuneThreshold, th.args)
                 threshold = tune.th.res$th
                 y = performance(setThreshold(r$pred, threshold = threshold), measures = measures)
                 names(y) = names(r$aggr)
             }
             else {
                 y = r$aggr
             }
             errmsgs = as.character(t(r$err.msgs[, -1L]))
             notna = !is.na(errmsgs)
             if (any(notna)) 
                 errmsg = errmsgs[notna][1L]
             err.dumps = r$err.dumps
         }
         else {
             if (control$tune.threshold) 
                 threshold = NA_real_
         }
         if (show.info) 
             log.fun(learner, task, resampling, measures, par.set, control, opt.path, 
                 dob, state, y, remove.nas, stage = 2L, prev.stage = prev.stage)
         list(y = y, exec.time = exec.time, errmsg = errmsg, threshold = threshold, err.dumps = err.dumps)
     })(dots[[1L]][[1L]], dots[[2L]][[1L]], learner = structure(list(id = "cluster.SimpleKMeans", 
         type = "cluster", package = "RWeka", properties = "numerics", par.set = structure(list(
             pars = list(A = structure(list(id = "A", type = "untyped", len = 1L, lower = NULL, 
                 upper = NULL, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = "weka.core.EuclideanDistance", trafo = NULL, requires = NULL, 
                 tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), C = structure(list(id = "C", type = "logical", len = 1L, lower = NULL, 
                 upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, 
                 allow.inf = FALSE, has.default = TRUE, default = FALSE, trafo = NULL, 
                 requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), fast = structure(list(id = "fast", type = "logical", len = 1L, 
                 lower = NULL, upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = FALSE, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), I = structure(list(
                 id = "I", type = "integer", len = 1L, lower = 1L, upper = Inf, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 100L, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), init = structure(list(
                 id = "init", type = "integer", len = 1L, lower = 0L, upper = 3L, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 0L, trafo = NULL, 
                 requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), M = structure(list(id = "M", type = "logical", len = 1L, lower = NULL, 
                 upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, 
                 allow.inf = FALSE, has.default = TRUE, default = FALSE, trafo = NULL, 
                 requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), `max-candidates` = structure(list(id = "max-candidates", type = "integer", 
                 len = 1L, lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 100L, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), `min-density` = structure(list(id = "min-density", type = "integer", 
                 len = 1L, lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 2L, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), N = structure(list(id = "N", type = "integer", len = 1L, lower = 1L, 
                 upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 2L, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), `num-slots` = structure(list(
                 id = "num-slots", type = "integer", len = 1L, lower = 1L, upper = Inf, 
                 values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 1L, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), O = structure(list(
                 id = "O", type = "logical", len = 1L, lower = NULL, upper = NULL, values = list(
                     `TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = FALSE, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), `periodic-pruning` = structure(list(id = "periodic-pruning", type = "integer", 
                 len = 1L, lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 10000L, trafo = NULL, requires = NULL, 
                 tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), S = structure(list(id = "S", type = "integer", len = 1L, lower = 0L, 
                 upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 10L, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), t2 = structure(list(
                 id = "t2", type = "numeric", len = 1L, lower = -Inf, upper = Inf, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = -1, trafo = NULL, 
                 requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), t1 = structure(list(id = "t1", type = "numeric", len = 1L, lower = -Inf, 
                 upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = -1.5, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), V = structure(list(
                 id = "V", type = "logical", len = 1L, lower = NULL, upper = NULL, values = list(
                     `TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = FALSE, trafo = NULL, requires = NULL, tunable = FALSE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), `output-debug-info` = structure(list(id = "output-debug-info", type = "logical", 
                 len = 1L, lower = NULL, upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = FALSE, 
                 trafo = NULL, requires = NULL, tunable = FALSE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param"))), forbidden = NULL), class = c("LearnerParamSet", 
         "ParamSet")), par.vals = list(), predict.type = "response", name = "K-Means Clustering", 
         short.name = "simplekmeans", note = "", callees = c("SimpleKMeans", "Weka_control"
         ), help.list = list(), config = list(), fix.factors.prediction = FALSE), class = c("cluster.SimpleKMeans", 
     "RLearnerCluster", "RLearner", "Learner")), task = structure(list(type = "cluster", 
         env = <environment>, weights = NULL, blocking = NULL, coordinates = NULL, task.desc = structure(list(
             id = "noclass", type = "cluster", target = character(0), size = 150L, n.feat = c(numerics = 4L, 
             factors = 0L, ordered = 0L, functionals = 0L), has.missings = FALSE, has.weights = FALSE, 
             has.blocking = FALSE, has.coordinates = FALSE), class = c("ClusterTaskDesc", 
         "UnsupervisedTaskDesc", "TaskDesc"))), class = c("ClusterTask", "UnsupervisedTask", 
     "Task")), resampling = structure(list(desc = structure(list(split = 0.666666666666667, 
         id = "holdout", iters = 1L, predict = "test", stratify = FALSE), class = c("HoldoutDesc", 
     "ResampleDesc")), size = 150L, train.inds = list(c(36L, 144L, 90L, 76L, 59L, 128L, 
     53L, 42L, 25L, 142L, 68L, 150L, 30L, 93L, 7L, 95L, 48L, 55L, 109L, 121L, 37L, 124L, 
     94L, 88L, 136L, 50L, 60L, 69L, 86L, 111L, 75L, 51L, 64L, 126L, 31L, 46L, 23L, 135L, 
     18L, 148L, 61L, 73L, 19L, 140L, 34L, 77L, 143L, 100L, 99L, 74L, 26L, 22L, 146L, 103L, 
     119L, 120L, 16L, 38L, 44L, 79L, 84L, 91L, 129L, 83L, 45L, 125L, 29L, 131L, 2L, 41L, 
     70L, 1L, 6L, 13L, 98L, 56L, 72L, 35L, 78L, 47L, 54L, 10L, 27L, 145L, 4L, 97L, 5L, 
     15L, 66L, 81L, 112L, 101L, 118L, 96L, 43L, 122L, 80L, 147L, 149L, 110L)), test.inds = list(
         c(116L, 108L, 92L, 65L, 8L, 49L, 32L, 113L, 39L, 14L, 130L, 57L, 115L, 52L, 40L, 
         24L, 63L, 105L, 133L, 67L, 17L, 104L, 82L, 28L, 134L, 58L, 106L, 138L, 12L, 89L, 
         127L, 62L, 117L, 85L, 21L, 132L, 33L, 9L, 11L, 102L, 137L, 87L, 20L, 114L, 71L, 
         141L, 3L, 139L, 107L, 123L)), group = structure(integer(0), .Label = character(0), class = "factor")), class = "ResampleInstance"), 
         measures = list(structure(list(id = "db", minimize = TRUE, properties = c("cluster", 
         "req.pred", "req.feats"), fun = function (task, model, pred, feats, extra.args) 
         {
             if (length(unique(pred$data$response)) > 1L) {
                 requirePackages("clusterSim", default.method = "load")
                 r = as.integer(as.factor(pred$data$response))
                 clusterSim::index.DB(feats, r)$DB
             }
             else {
                 NA
             }
         }, extra.args = list(), best = 0, worst = Inf, name = "Davies-Bouldin cluster separation measure", 
             note = "Ratio of the within cluster scatter, to the between cluster separation, averaged over the clusters. See `?clusterSim::index.DB`.", 
             aggr = structure(list(id = "test.mean", name = "Test mean", fun = function (task, 
                 perf.test, perf.train, measure, group, pred) 
             mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure")), 
         par.set = structure(list(pars = list(N = structure(list(id = "N", type = "integer", 
             len = 1L, lower = 2, upper = 10, values = NULL, cnames = NULL, allow.inf = FALSE, 
             has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, 
             special.vals = list()), class = "Param")), forbidden = NULL), class = "ParamSet"), 
         bits.to.features = NULL, control = structure(list(same.resampling.instance = TRUE, 
             impute.val = Inf, tune.threshold = FALSE, tune.threshold.args = list(), log.fun = function (learner, 
                 task, resampling, measures, par.set, control, opt.path, dob, x, y, remove.nas, 
                 stage, prev.stage) 
             {
                 x.string = paramValueToString(par.set, x, show.missing.values = !remove.nas)
                 if (inherits(learner, "ModelMultiplexer")) 
                     x.string = stri_replace_all(x.string, "", regex = stri_paste(x$selected.learner, 
                       "\\."))
                 logFunDefault(learner, task, resampling, measures, par.set, control, 
                     opt.path, dob, x.string, y, remove.nas, stage, prev.stage, prefixes = c("Tune-x", 
                       "Tune-y"))
             }, final.dw.perc = NULL, extra.args = list(maxit = 2L), budget = 2L), class = c("TuneControlRandom", 
         "TuneControl", "OptControl")), opt.path = structure(list(par.set = structure(list(
             pars = list(N = structure(list(id = "N", type = "integer", len = 1L, lower = 2, 
                 upper = 10, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                 default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list()), class = "Param")), 
             forbidden = NULL), class = "ParamSet"), y.names = "db.test.mean", minimize = c(db.test.mean = TRUE), 
             add.transformed.x = FALSE, env = <environment>), class = c("OptPathDF", "OptPath"
         )), show.info = FALSE, remove.nas = TRUE, resample.fun = function (learner, task, 
             resampling, measures, weights = NULL, models = FALSE, extract, keep.pred = TRUE, 
             ..., show.info = getMlrOption("show.info")) 
         {
             learner = checkLearner(learner)
             learner = setHyperPars(learner, ...)
             assertClass(task, classes = "Task")
             n = getTaskSize(task)
             if (inherits(resampling, "ResampleDesc")) 
                 resampling = makeResampleInstance(resampling, task = task)
             assertClass(resampling, classes = "ResampleInstance")
             measures = checkMeasures(measures, task)
             if (!is.null(weights)) {
                 assertNumeric(weights, len = n, any.missing = FALSE, lower = 0)
             }
             assertFlag(models)
             if (missing(extract)) 
                 extract = function(model) {
                 }
             else assertFunction(extract)
             assertFlag(show.info)
             r = resampling$size
             if (n != r) 
                 stop(stri_paste("Size of data set:", n, "and resampling instance:", r, 
                     "differ!", sep = " "))
             checkLearnerBeforeTrain(task, learner, weights)
             checkAggrsBeforeResample(measures, resampling$desc)
             rin = resampling
             more.args = list(learner = learner, task = task, rin = rin, weights = NULL, 
                 measures = measures, model = models, extract = extract, show.info = show.info)
             if (!is.null(weights)) {
                 more.args$weights = weights
             }
             else if (!is.null(getTaskWeights(task))) {
                 more.args$weights = getTaskWeights(task)
             }
             parallelLibrary("mlr", master = FALSE, level = "mlr.resample", show.info = FALSE)
             exportMlrOptions(level = "mlr.resample")
             if (show.info) {
                 messagef("Resampling: %s", rin$desc$id)
                 measure.lognames = extractSubList(measures, "id")
                 if (rin$desc$predict == "both") {
                     id.train = which(vlapply(measures, function(x) "req.train" %in% x$aggr$properties))
                     id.test = which(vlapply(measures, function(x) "req.test" %in% x$aggr$properties))
                     measure.lognames = c(stri_paste(measure.lognames[id.train], "train", 
                       sep = "."), stri_paste(measure.lognames[id.test], "test", sep = "."))
                 }
                 printResampleFormatLine("Measures:", measure.lognames)
             }
             time1 = Sys.time()
             iter.results = parallelMap(doResampleIteration, seq_len(rin$desc$iters), 
                 level = "mlr.resample", more.args = more.args)
             time2 = Sys.time()
             runtime = as.numeric(difftime(time2, time1, units = "secs"))
             addClasses(mergeResampleResult(learner$id, task, iter.results, measures, 
                 rin, models, extract, keep.pred, show.info, runtime), "ResampleResult")
         })
  8: measureTime({
         r = resample.fun(learner2, task, resampling, measures = measures, show.info = FALSE)
     })
  9: force(expr)
  10: resample.fun(learner2, task, resampling, measures = measures, show.info = FALSE)
  11: parallelMap(doResampleIteration, seq_len(rin$desc$iters), level = "mlr.resample", 
         more.args = more.args)
  12: options(parallelMap.nextmap = (getPMOptNextMap() + 1L))
  13: getPMOptNextMap()
  14: getPMOption("nextmap")
  15: getOption(sprintf("parallelMap.%s", opt), def)
  
  ── 30. Error: convertBMRToRankMatrix (@test_base_convertBMRToRankMatrix.R#9)  ──
  argument "def" is missing, with no default
  1: benchmark(lrns, tasks, rdesc, meas) at testthat/test_base_convertBMRToRankMatrix.R:9
  2: parallelMap(benchmarkParallel, task = grid$task, learner = grid$learner, more.args = list(learners = learners, 
         tasks = tasks, resamplings = resamplings, measures = measures, keep.pred = keep.pred, 
         models = models, show.info = show.info), level = plevel)
  3: mapply(fun2, ..., MoreArgs = more.args, SIMPLIFY = FALSE, USE.NAMES = FALSE)
  4: (function (task, learner, learners, tasks, resamplings, measures, keep.pred = TRUE, 
         models = TRUE, show.info) 
     {
         setSlaveOptions()
         if (show.info) 
             messagef("Task: %s, Learner: %s", task, learner)
         lrn = learners[[learner]]
         extract.this = getExtractor(lrn)
         r = resample(lrn, tasks[[task]], resamplings[[task]], measures = measures, models = models, 
             extract = extract.this, keep.pred = keep.pred, show.info = show.info)
         r$learner = lrn
         return(r)
     })(task = dots[[1L]][[1L]], learner = dots[[2L]][[1L]], learners = list(classif.nnet = structure(list(
         id = "classif.nnet", type = "classif", package = "nnet", properties = c("twoclass", 
         "multiclass", "numerics", "factors", "prob", "weights"), par.set = structure(list(
             pars = list(size = structure(list(id = "size", type = "integer", len = 1L, 
                 lower = 0L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 3L, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), maxit = structure(list(id = "maxit", type = "integer", len = 1L, lower = 1L, 
                 upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 100L, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), skip = structure(list(
                 id = "skip", type = "logical", len = 1L, lower = NULL, upper = NULL, 
                 values = list(`TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = FALSE, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), rang = structure(list(id = "rang", type = "numeric", len = 1L, lower = -Inf, 
                 upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 0.7, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), decay = structure(list(
                 id = "decay", type = "numeric", len = 1L, lower = -Inf, upper = Inf, 
                 values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 0, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), Hess = structure(list(
                 id = "Hess", type = "logical", len = 1L, lower = NULL, upper = NULL, 
                 values = list(`TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = FALSE, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), trace = structure(list(id = "trace", type = "logical", len = 1L, lower = NULL, 
                 upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, 
                 allow.inf = FALSE, has.default = TRUE, default = TRUE, trafo = NULL, 
                 requires = NULL, tunable = FALSE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), MaxNWts = structure(list(id = "MaxNWts", type = "integer", len = 1L, 
                 lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 1000L, trafo = NULL, requires = NULL, tunable = FALSE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), abstol = structure(list(id = "abstol", type = "numeric", len = 1L, lower = -Inf, 
                 upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 1e-04, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), reltol = structure(list(
                 id = "reltol", type = "numeric", len = 1L, lower = -Inf, upper = Inf, 
                 values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 1e-08, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param"))), forbidden = NULL), class = c("LearnerParamSet", 
         "ParamSet")), par.vals = list(size = 3L), predict.type = "response", name = "Neural Network", 
         short.name = "nnet", note = "`size` has been set to `3` by default.", callees = "nnet", 
         help.list = list(size = "Argument of: nnet::nnet\n\nnumber of units in the hidden layer. Can be zero if there are skip-layer units.", 
             skip = "Argument of: nnet::nnet\n\nswitch to add skip-layer connections from input to output.", 
             rang = "Argument of: nnet::nnet\n\nInitial random weights on [-rang, rang].  Value about 0.5 unless the inputs are large, in which case it should be chosen so that rang * max(|x|) is about 1.", 
             decay = "Argument of: nnet::nnet\n\nparameter for weight decay.  Default 0.", 
             maxit = "Argument of: nnet::nnet\n\nmaximum number of iterations. Default 100.", 
             Hess = "Argument of: nnet::nnet\n\nIf true, the Hessian of the measure of fit at the best set of weights found is returned as component Hessian.", 
             trace = "Argument of: nnet::nnet\n\nswitch for tracing optimization. Default TRUE.", 
             MaxNWts = "Argument of: nnet::nnet\n\nThe maximum allowable number of weights.  There is no intrinsic limit in the code, but increasing MaxNWts will probably allow fits that are very slow and time-consuming.", 
             abstol = "Argument of: nnet::nnet\n\nStop if the fit criterion falls below abstol, indicating an essentially perfect fit.", 
             reltol = "Argument of: nnet::nnet\n\nStop if the optimizer is unable to reduce the fit criterion by a factor of at least 1 - reltol."), 
         config = list(), fix.factors.prediction = FALSE), class = c("classif.nnet", "RLearnerClassif", 
     "RLearner", "Learner")), classif.rpart = structure(list(id = "classif.rpart", type = "classif", 
         package = "rpart", properties = c("twoclass", "multiclass", "missings", "numerics", 
         "factors", "ordered", "prob", "weights", "featimp"), par.set = structure(list(
             pars = list(minsplit = structure(list(id = "minsplit", type = "integer", 
                 len = 1L, lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 20L, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), minbucket = structure(list(id = "minbucket", type = "integer", len = 1L, 
                 lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), cp = structure(list(id = "cp", type = "numeric", len = 1L, lower = 0, 
                 upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 0.01, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), maxcompete = structure(list(
                 id = "maxcompete", type = "integer", len = 1L, lower = 0L, upper = Inf, 
                 values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 4L, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), maxsurrogate = structure(list(
                 id = "maxsurrogate", type = "integer", len = 1L, lower = 0L, upper = Inf, 
                 values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 5L, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), usesurrogate = structure(list(
                 id = "usesurrogate", type = "discrete", len = 1L, lower = NULL, upper = NULL, 
                 values = list(`0` = 0L, `1` = 1L, `2` = 2L), cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 2L, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), surrogatestyle = structure(list(id = "surrogatestyle", type = "discrete", 
                 len = 1L, lower = NULL, upper = NULL, values = list(`0` = 0L, `1` = 1L), 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 0L, trafo = NULL, 
                 requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), maxdepth = structure(list(id = "maxdepth", type = "integer", len = 1L, 
                 lower = 1L, upper = 30L, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 30L, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), xval = structure(list(id = "xval", type = "integer", len = 1L, lower = 0L, 
                 upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 10L, trafo = NULL, requires = NULL, tunable = FALSE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), parms = structure(list(
                 id = "parms", type = "untyped", len = 1L, lower = NULL, upper = NULL, 
                 values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                 default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param"))), forbidden = NULL), class = c("LearnerParamSet", 
         "ParamSet")), par.vals = list(xval = 0L), predict.type = "response", name = "Decision Tree", 
         short.name = "rpart", note = "`xval` has been set to `0` by default for speed.", 
         callees = c("rpart", "rpart.control"), help.list = list(minsplit = "Argument of: rpart::rpart.control\n\nthe minimum number of observations that must exist in a node in order for a split to be attempted.", 
             minbucket = "Argument of: rpart::rpart.control\n\nthe minimum number of observations in any terminal <leaf> node. If only one of minbucket or minsplit is specified, the code either sets minsplit to minbucket*3 or minbucket to minsplit/3, as appropriate.", 
             cp = "Argument of: rpart::rpart.control\n\ncomplexity parameter.  Any split that does not decrease the overall lack of fit by a factor of cp is not attempted.  For instance, with anova splitting, this means that the overall R-squared must increase by cp at each step. The main role of this parameter is to save computing time by pruning off splits that are obviously not worthwhile. Essentially,the user informs the program that any split which does not improve the fit by cp will likely be pruned off by cross-validation, and that hence the program need not pursue it.", 
             maxcompete = "Argument of: rpart::rpart.control\n\nthe number of competitor splits retained in the output.  It is useful to know not just which split was chosen, but which variable came in second, third, etc.", 
             maxsurrogate = "Argument of: rpart::rpart.control\n\nthe number of surrogate splits retained in the output.  If this is set to zero the compute time will be reduced, since approximately half of the computational time (other than setup) is used in the search for surrogate splits.", 
             usesurrogate = "Argument of: rpart::rpart.control\n\nhow to use surrogates in the splitting process.  0 means display only; an observation with a missing value for the primary split rule is not sent further down the tree.  1 means use surrogates, in order, to split subjects missing the primary variable; if all surrogates are missing the observation is not split.  For value 2 ,if all surrogates are missing, then send the observation in the majority direction.  A value of 0 corresponds to the action of tree, and 2 to the recommendations of Breiman et.al (1984).", 
             xval = "Argument of: rpart::rpart.control\n\nnumber of cross-validations.", 
             surrogatestyle = "Argument of: rpart::rpart.control\n\ncontrols the selection of a best surrogate. If set to 0 (default) the program uses the total number of correct classification for a potential surrogate variable, if set to 1 it uses the percent correct, calculated over the non-missing values of the surrogate. The first option more severely penalizes covariates with a large number of missing values.", 
             maxdepth = "Argument of: rpart::rpart.control\n\nSet the maximum depth of any node of the final tree, with the root node counted as depth 0.  Values greater than  30 rpart will give nonsense results on 32-bit machines.", 
             parms = "Argument of: rpart::rpart\n\noptional parameters for the splitting function. Anova splitting has no parameters. Poisson splitting has a single parameter, the coefficient of variation of the prior distribution on the rates.  The default value is 1. Exponential splitting has the same parameter as Poisson. For classification splitting, the list can contain any of: the vector of prior probabilities (component prior), the loss matrix (component loss) or the splitting index (component split).  The priors must be positive and sum to 1.  The loss matrix must have zeros on the diagonal and positive off-diagonal elements.  The splitting index can be gini or information.  The default priors are proportional to the data counts, the losses default to 1, and the split defaults to gini."), 
         config = list(), fix.factors.prediction = FALSE), class = c("classif.rpart", 
     "RLearnerClassif", "RLearner", "Learner"))), tasks = list(multiclass = structure(list(
         type = "classif", env = <environment>, weights = NULL, blocking = NULL, coordinates = NULL, 
         task.desc = structure(list(id = "multiclass", type = "classif", target = "Species", 
             size = 150L, n.feat = c(numerics = 4L, factors = 0L, ordered = 0L, functionals = 0L
             ), has.missings = FALSE, has.weights = FALSE, has.blocking = FALSE, has.coordinates = FALSE, 
             class.levels = c("setosa", "versicolor", "virginica"), positive = NA_character_, 
             negative = NA_character_, class.distribution = structure(c(setosa = 50L, 
             versicolor = 50L, virginica = 50L), .Dim = 3L, .Dimnames = list(c("setosa", 
             "versicolor", "virginica")), class = "table")), class = c("ClassifTaskDesc", 
         "SupervisedTaskDesc", "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", 
     "Task")), binary = structure(list(type = "classif", env = <environment>, weights = NULL, 
         blocking = NULL, coordinates = NULL, task.desc = structure(list(id = "binary", 
             type = "classif", target = "Class", size = 208L, n.feat = c(numerics = 60L, 
             factors = 0L, ordered = 0L, functionals = 0L), has.missings = FALSE, has.weights = FALSE, 
             has.blocking = FALSE, has.coordinates = FALSE, class.levels = c("M", "R"), 
             positive = "M", negative = "R", class.distribution = structure(c(M = 111L, 
             R = 97L), .Dim = 2L, .Dimnames = list(c("M", "R")), class = "table")), class = c("ClassifTaskDesc", 
         "SupervisedTaskDesc", "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", 
     "Task"))), resamplings = list(multiclass = structure(list(desc = structure(list(id = "cross-validation", 
         iters = 2L, predict = "test", stratify = FALSE), class = c("CVDesc", "ResampleDesc"
     )), size = 150L, train.inds = list(c(32L, 64L, 71L, 50L, 52L, 49L, 73L, 30L, 55L, 
     95L, 107L, 101L, 143L, 69L, 56L, 141L, 122L, 134L, 136L, 68L, 16L, 148L, 96L, 139L, 
     118L, 27L, 44L, 23L, 20L, 98L, 5L, 133L, 34L, 76L, 145L, 86L, 127L, 109L, 41L, 138L, 
     4L, 18L, 13L, 40L, 121L, 22L, 72L, 119L, 113L, 11L, 29L, 61L, 8L, 115L, 63L, 94L, 
     135L, 19L, 21L, 12L, 144L, 1L, 91L, 99L, 2L, 14L, 28L, 70L, 48L, 42L, 126L, 15L, 
     80L, 150L, 54L), c(128L, 75L, 58L, 37L, 17L, 57L, 83L, 31L, 90L, 100L, 35L, 82L, 
     24L, 111L, 85L, 78L, 47L, 66L, 140L, 38L, 84L, 142L, 103L, 120L, 114L, 36L, 67L, 
     43L, 129L, 59L, 39L, 131L, 102L, 92L, 60L, 112L, 149L, 89L, 53L, 51L, 123L, 81L, 
     147L, 26L, 77L, 10L, 97L, 33L, 62L, 130L, 87L, 137L, 25L, 74L, 88L, 45L, 65L, 93L, 
     117L, 3L, 79L, 125L, 106L, 105L, 110L, 108L, 6L, 46L, 132L, 104L, 124L, 9L, 7L, 116L, 
     146L)), test.inds = list(c(3L, 6L, 7L, 9L, 10L, 17L, 24L, 25L, 26L, 31L, 33L, 35L, 
     36L, 37L, 38L, 39L, 43L, 45L, 46L, 47L, 51L, 53L, 57L, 58L, 59L, 60L, 62L, 65L, 66L, 
     67L, 74L, 75L, 77L, 78L, 79L, 81L, 82L, 83L, 84L, 85L, 87L, 88L, 89L, 90L, 92L, 93L, 
     97L, 100L, 102L, 103L, 104L, 105L, 106L, 108L, 110L, 111L, 112L, 114L, 116L, 117L, 
     120L, 123L, 124L, 125L, 128L, 129L, 130L, 131L, 132L, 137L, 140L, 142L, 146L, 147L, 
     149L), c(1L, 2L, 4L, 5L, 8L, 11L, 12L, 13L, 14L, 15L, 16L, 18L, 19L, 20L, 21L, 22L, 
     23L, 27L, 28L, 29L, 30L, 32L, 34L, 40L, 41L, 42L, 44L, 48L, 49L, 50L, 52L, 54L, 55L, 
     56L, 61L, 63L, 64L, 68L, 69L, 70L, 71L, 72L, 73L, 76L, 80L, 86L, 91L, 94L, 95L, 96L, 
     98L, 99L, 101L, 107L, 109L, 113L, 115L, 118L, 119L, 121L, 122L, 126L, 127L, 133L, 
     134L, 135L, 136L, 138L, 139L, 141L, 143L, 144L, 145L, 148L, 150L)), group = structure(integer(0), .Label = character(0), class = "factor")), class = "ResampleInstance"), 
         binary = structure(list(desc = structure(list(id = "cross-validation", iters = 2L, 
             predict = "test", stratify = FALSE), class = c("CVDesc", "ResampleDesc")), 
             size = 208L, train.inds = list(c(17L, 176L, 149L, 91L, 154L, 13L, 161L, 61L, 
             130L, 172L, 57L, 175L, 150L, 193L, 134L, 205L, 191L, 165L, 55L, 34L, 94L, 
             163L, 119L, 31L, 99L, 196L, 122L, 131L, 132L, 159L, 58L, 177L, 116L, 20L, 
             37L, 75L, 67L, 11L, 160L, 41L, 4L, 36L, 89L, 199L, 179L, 103L, 109L, 129L, 
             184L, 73L, 171L, 25L, 76L, 27L, 18L, 33L, 46L, 162L, 7L, 45L, 6L, 21L, 42L, 
             50L, 151L, 153L, 111L, 70L, 30L, 112L, 173L, 207L, 38L, 47L, 125L, 1L, 51L, 
             52L, 204L, 80L, 133L, 118L, 142L, 98L, 114L, 164L, 78L, 208L, 54L, 2L, 40L, 
             43L, 44L, 167L, 23L, 22L, 187L, 12L, 190L, 123L, 19L, 74L, 105L, 137L), c(197L, 
             71L, 96L, 81L, 35L, 60L, 72L, 8L, 100L, 5L, 186L, 128L, 83L, 63L, 202L, 206L, 
             49L, 141L, 145L, 48L, 14L, 174L, 135L, 65L, 169L, 86L, 95L, 107L, 85L, 203L, 
             3L, 182L, 152L, 158L, 148L, 194L, 168L, 192L, 157L, 79L, 68L, 120L, 110L, 
             115L, 87L, 126L, 156L, 121L, 15L, 62L, 106L, 28L, 138L, 26L, 147L, 188L, 
             90L, 113L, 185L, 139L, 183L, 181L, 127L, 178L, 189L, 108L, 117L, 32L, 66L, 
             195L, 39L, 143L, 9L, 77L, 102L, 64L, 101L, 29L, 53L, 93L, 166L, 92L, 144L, 
             198L, 59L, 88L, 82L, 24L, 146L, 140L, 16L, 97L, 170L, 180L, 201L, 84L, 155L, 
             136L, 200L, 69L, 104L, 10L, 124L, 56L)), test.inds = list(c(3L, 5L, 8L, 9L, 
             10L, 14L, 15L, 16L, 24L, 26L, 28L, 29L, 32L, 35L, 39L, 48L, 49L, 53L, 56L, 
             59L, 60L, 62L, 63L, 64L, 65L, 66L, 68L, 69L, 71L, 72L, 77L, 79L, 81L, 82L, 
             83L, 84L, 85L, 86L, 87L, 88L, 90L, 92L, 93L, 95L, 96L, 97L, 100L, 101L, 102L, 
             104L, 106L, 107L, 108L, 110L, 113L, 115L, 117L, 120L, 121L, 124L, 126L, 127L, 
             128L, 135L, 136L, 138L, 139L, 140L, 141L, 143L, 144L, 145L, 146L, 147L, 148L, 
             152L, 155L, 156L, 157L, 158L, 166L, 168L, 169L, 170L, 174L, 178L, 180L, 181L, 
             182L, 183L, 185L, 186L, 188L, 189L, 192L, 194L, 195L, 197L, 198L, 200L, 201L, 
             202L, 203L, 206L), c(1L, 2L, 4L, 6L, 7L, 11L, 12L, 13L, 17L, 18L, 19L, 20L, 
             21L, 22L, 23L, 25L, 27L, 30L, 31L, 33L, 34L, 36L, 37L, 38L, 40L, 41L, 42L, 
             43L, 44L, 45L, 46L, 47L, 50L, 51L, 52L, 54L, 55L, 57L, 58L, 61L, 67L, 70L, 
             73L, 74L, 75L, 76L, 78L, 80L, 89L, 91L, 94L, 98L, 99L, 103L, 105L, 109L, 
             111L, 112L, 114L, 116L, 118L, 119L, 122L, 123L, 125L, 129L, 130L, 131L, 132L, 
             133L, 134L, 137L, 142L, 149L, 150L, 151L, 153L, 154L, 159L, 160L, 161L, 162L, 
             163L, 164L, 165L, 167L, 171L, 172L, 173L, 175L, 176L, 177L, 179L, 184L, 187L, 
             190L, 191L, 193L, 196L, 199L, 204L, 205L, 207L, 208L)), group = structure(integer(0), .Label = character(0), class = "factor")), class = "ResampleInstance")), 
         measures = list(structure(list(id = "acc", minimize = FALSE, properties = c("classif", 
         "classif.multi", "req.pred", "req.truth"), fun = function (task, model, pred, 
             feats, extra.args) 
         {
             measureACC(pred$data$truth, pred$data$response)
         }, extra.args = list(), best = 1, worst = 0, name = "Accuracy", note = "Defined as: mean(response == truth)", 
             aggr = structure(list(id = "test.mean", name = "Test mean", fun = function (task, 
                 perf.test, perf.train, measure, group, pred) 
             mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure"), 
             structure(list(id = "mmce", minimize = TRUE, properties = c("classif", "classif.multi", 
             "req.pred", "req.truth"), fun = function (task, model, pred, feats, extra.args) 
             {
                 measureMMCE(pred$data$truth, pred$data$response)
             }, extra.args = list(), best = 0, worst = 1, name = "Mean misclassification error", 
                 note = "Defined as: mean(response != truth)", aggr = structure(list(id = "test.mean", 
                     name = "Test mean", fun = function (task, perf.test, perf.train, 
                       measure, group, pred) 
                     mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure"), 
             structure(list(id = "ber", minimize = TRUE, properties = c("classif", "classif.multi", 
             "req.pred", "req.truth"), fun = function (task, model, pred, feats, extra.args) 
             {
                 measureBER(pred$data$truth, pred$data$response)
             }, extra.args = list(), best = 0, worst = 1, name = "Balanced error rate", 
                 note = "Mean of misclassification error rates on all individual classes.", 
                 aggr = structure(list(id = "test.mean", name = "Test mean", fun = function (task, 
                     perf.test, perf.train, measure, group, pred) 
                 mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure"), 
             structure(list(id = "featperc", minimize = TRUE, properties = c("classif", 
             "classif.multi", "multilabel", "regr", "surv", "costsens", "cluster", "req.model", 
             "req.pred"), fun = function (task, model, pred, feats, extra.args) 
             {
                 length(model$features)/sum(pred$task.desc$n.feat)
             }, extra.args = list(), best = 0, worst = 1, name = "Percentage of original features used for model", 
                 note = "Useful for feature selection.", aggr = structure(list(id = "test.mean", 
                     name = "Test mean", fun = function (task, perf.test, perf.train, 
                       measure, group, pred) 
                     mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure")), 
         keep.pred = TRUE, models = TRUE, show.info = FALSE)
  5: resample(lrn, tasks[[task]], resamplings[[task]], measures = measures, models = models, 
         extract = extract.this, keep.pred = keep.pred, show.info = show.info)
  6: parallelMap(doResampleIteration, seq_len(rin$desc$iters), level = "mlr.resample", 
         more.args = more.args)
  7: options(parallelMap.nextmap = (getPMOptNextMap() + 1L))
  8: getPMOptNextMap()
  9: getPMOption("nextmap")
  10: getOption(sprintf("parallelMap.%s", opt), def)
  
  ── 31. Error: costs (@test_base_costs.R#12)  ───────────────────────────────────
  argument "def" is missing, with no default
  1: resample(lrn, rdesc, task = task, measures = list(mmce, ms)) at testthat/test_base_costs.R:12
  2: parallelMap(doResampleIteration, seq_len(rin$desc$iters), level = "mlr.resample", 
         more.args = more.args)
  3: options(parallelMap.nextmap = (getPMOptNextMap() + 1L))
  4: getPMOptNextMap()
  5: getPMOption("nextmap")
  6: getOption(sprintf("parallelMap.%s", opt), def)
  
  ── 32. Error: costsens (@test_base_costsens.R#7)  ──────────────────────────────
  argument "def" is missing, with no default
  1: resample(lrn, costsens.task, rdesc) at testthat/test_base_costsens.R:7
  2: parallelMap(doResampleIteration, seq_len(rin$desc$iters), level = "mlr.resample", 
         more.args = more.args)
  3: options(parallelMap.nextmap = (getPMOptNextMap() + 1L))
  4: getPMOptNextMap()
  5: getPMOption("nextmap")
  6: getOption(sprintf("parallelMap.%s", opt), def)
  
  ── 33. Error: error dump is created in resample (@test_base_debugdump.R#24)  ───
  argument "def" is missing, with no default
  1: holdout(lrn, multiclass.task) at testthat/test_base_debugdump.R:24
  2: resample(learner, task, rdesc, measures = measures, models = models, keep.pred = keep.pred, 
         show.info = show.info)
  3: parallelMap(doResampleIteration, seq_len(rin$desc$iters), level = "mlr.resample", 
         more.args = more.args)
  4: options(parallelMap.nextmap = (getPMOptNextMap() + 1L))
  5: getPMOptNextMap()
  6: getPMOption("nextmap")
  7: getOption(sprintf("parallelMap.%s", opt), def)
  
  ── 34. Error: error dump is created during tune (@test_base_debugdump.R#48)  ───
  argument "def" is missing, with no default
  1: tuneParams(lrn, multiclass.task, hout, par.set = ps, control = ctrl) at testthat/test_base_debugdump.R:48
  2: sel.func(learner, task, resampling, measures, par.set, control, opt.path, show.info, 
         resample.fun)
  3: evalOptimizationStatesTune(learner, task, resampling, measures, par.set, control, 
         opt.path, show.info, xs, dobs = seq_along(xs), eols = NA_integer_, remove.nas = TRUE, 
         resample.fun = resample.fun)
  4: evalOptimizationStates(learner, task, resampling, measures, par.set, NULL, control, 
         opt.path, show.info, states, dobs, eols, remove.nas, resample.fun, "mlr.tuneParams")
  5: parallelMap(evalOptimizationState, dobs, states, level = level, more.args = list(learner = learner, 
         task = task, resampling = resampling, measures = measures, par.set = par.set, 
         bits.to.features = bits.to.features, control = control, opt.path = opt.path, 
         show.info = show.info, remove.nas = remove.nas, resample.fun = resample.fun))
  6: mapply(fun2, ..., MoreArgs = more.args, SIMPLIFY = FALSE, USE.NAMES = FALSE)
  7: (function (learner, task, resampling, measures, par.set, bits.to.features, control, 
         opt.path, show.info, dob, state, remove.nas, resample.fun) 
     {
         setSlaveOptions()
         y = setNames(rep(NA_real_, length(measures)), vcapply(measures, measureAggrName))
         errmsg = NA_character_
         exec.time = NA_real_
         set.pars.ok = TRUE
         learner2 = learner
         threshold = NULL
         log.fun = control$log.fun
         err.dumps = list()
         if (inherits(control, "TuneControl") || inherits(control, "TuneMultiCritControl")) {
             state = setValueCNames(par.set, state)
             state = trafoValue(par.set, state)
             state2 = if (remove.nas) 
                 removeMissingValues(state)
             else state
             learner2 = try(setHyperPars(learner, par.vals = state2), silent = TRUE)
             if (is.error(learner2)) {
                 set.pars.ok = FALSE
                 errmsg = as.character(learner2)
                 if (show.info) 
                     messagef("[Tune-x] Setting hyperpars failed: %s", errmsg)
             }
         }
         else if (inherits(control, "FeatSelControl")) {
             task = subsetTask(task, features = bits.to.features(state, task))
         }
         if (show.info) 
             prev.stage = log.fun(learner, task, resampling, measures, par.set, control, 
                 opt.path, dob, state, NA_real_, remove.nas, stage = 1L)
         if (set.pars.ok) {
             exec.time = measureTime({
                 r = resample.fun(learner2, task, resampling, measures = measures, show.info = FALSE)
             })
             if (control$tune.threshold) {
                 th.args = control$tune.threshold.args
                 th.args$pred = r$pred
                 th.args$measure = measures[[1L]]
                 tune.th.res = do.call(tuneThreshold, th.args)
                 threshold = tune.th.res$th
                 y = performance(setThreshold(r$pred, threshold = threshold), measures = measures)
                 names(y) = names(r$aggr)
             }
             else {
                 y = r$aggr
             }
             errmsgs = as.character(t(r$err.msgs[, -1L]))
             notna = !is.na(errmsgs)
             if (any(notna)) 
                 errmsg = errmsgs[notna][1L]
             err.dumps = r$err.dumps
         }
         else {
             if (control$tune.threshold) 
                 threshold = NA_real_
         }
         if (show.info) 
             log.fun(learner, task, resampling, measures, par.set, control, opt.path, 
                 dob, state, y, remove.nas, stage = 2L, prev.stage = prev.stage)
         list(y = y, exec.time = exec.time, errmsg = errmsg, threshold = threshold, err.dumps = err.dumps)
     })(dots[[1L]][[1L]], dots[[2L]][[1L]], learner = structure(list(id = "classif.__mlrmocklearners__2", 
         type = "classif", package = character(0), properties = c("twoclass", "multiclass", 
         "missings", "numerics", "factors", "prob"), par.set = structure(list(pars = list(
             alpha = structure(list(id = "alpha", type = "numeric", len = 1L, lower = 0, 
                 upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                 default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param"))), forbidden = NULL), class = c("LearnerParamSet", 
         "ParamSet")), par.vals = list(), predict.type = "response", name = "classif.__mlrmocklearners__2", 
         short.name = "classif.__mlrmocklearners__2", note = "", callees = character(0), 
         help.list = list(), config = list(), fix.factors.prediction = FALSE), class = c("classif.__mlrmocklearners__2", 
     "RLearnerClassif", "RLearner", "Learner")), task = structure(list(type = "classif", 
         env = <environment>, weights = NULL, blocking = NULL, coordinates = NULL, task.desc = structure(list(
             id = "multiclass", type = "classif", target = "Species", size = 150L, n.feat = c(numerics = 4L, 
             factors = 0L, ordered = 0L, functionals = 0L), has.missings = FALSE, has.weights = FALSE, 
             has.blocking = FALSE, has.coordinates = FALSE, class.levels = c("setosa", 
             "versicolor", "virginica"), positive = NA_character_, negative = NA_character_, 
             class.distribution = structure(c(setosa = 50L, versicolor = 50L, virginica = 50L
             ), .Dim = 3L, .Dimnames = list(c("setosa", "versicolor", "virginica")), class = "table")), class = c("ClassifTaskDesc", 
         "SupervisedTaskDesc", "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", 
     "Task")), resampling = structure(list(desc = structure(list(split = 0.666666666666667, 
         id = "holdout", iters = 1L, predict = "test", stratify = FALSE), class = c("HoldoutDesc", 
     "ResampleDesc")), size = 150L, train.inds = list(c(44L, 118L, 61L, 130L, 138L, 7L, 
     77L, 128L, 79L, 65L, 134L, 64L, 94L, 142L, 14L, 122L, 33L, 6L, 150L, 126L, 116L, 
     90L, 82L, 127L, 83L, 89L, 68L, 74L, 36L, 18L, 147L, 108L, 143L, 146L, 3L, 55L, 87L, 
     25L, 135L, 26L, 16L, 46L, 45L, 40L, 17L, 15L, 113L, 48L, 28L, 114L, 5L, 132L, 137L, 
     12L, 54L, 20L, 97L, 71L, 131L, 35L, 60L, 9L, 34L, 24L, 93L, 39L, 69L, 124L, 66L, 
     112L, 148L, 50L, 56L, 1L, 37L, 106L, 29L, 119L, 111L, 8L, 121L, 47L, 123L, 53L, 145L, 
     92L, 139L, 57L, 115L, 11L, 86L, 85L, 95L, 38L, 70L, 80L, 43L, 100L, 104L, 27L)), 
         test.inds = list(c(73L, 141L, 88L, 59L, 21L, 42L, 99L, 78L, 84L, 75L, 107L, 76L, 
         110L, 49L, 2L, 125L, 105L, 149L, 41L, 32L, 58L, 31L, 63L, 19L, 22L, 51L, 133L, 
         98L, 129L, 81L, 72L, 140L, 102L, 103L, 30L, 13L, 52L, 91L, 10L, 120L, 136L, 144L, 
         101L, 62L, 109L, 23L, 96L, 67L, 4L, 117L)), group = structure(integer(0), .Label = character(0), class = "factor")), class = "ResampleInstance"), 
         measures = list(structure(list(id = "mmce", minimize = TRUE, properties = c("classif", 
         "classif.multi", "req.pred", "req.truth"), fun = function (task, model, pred, 
             feats, extra.args) 
         {
             measureMMCE(pred$data$truth, pred$data$response)
         }, extra.args = list(), best = 0, worst = 1, name = "Mean misclassification error", 
             note = "Defined as: mean(response != truth)", aggr = structure(list(id = "test.mean", 
                 name = "Test mean", fun = function (task, perf.test, perf.train, measure, 
                     group, pred) 
                 mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure")), 
         par.set = structure(list(pars = list(alpha = structure(list(id = "alpha", type = "discrete", 
             len = 1L, lower = NULL, upper = NULL, values = list(`1` = 1, `0` = 0), cnames = NULL, 
             allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, 
             tunable = TRUE, special.vals = list()), class = "Param")), forbidden = NULL), class = "ParamSet"), 
         bits.to.features = NULL, control = structure(list(same.resampling.instance = TRUE, 
             impute.val = 1, tune.threshold = FALSE, tune.threshold.args = list(), log.fun = function (learner, 
                 task, resampling, measures, par.set, control, opt.path, dob, x, y, remove.nas, 
                 stage, prev.stage) 
             {
                 x.string = paramValueToString(par.set, x, show.missing.values = !remove.nas)
                 if (inherits(learner, "ModelMultiplexer")) 
                     x.string = stri_replace_all(x.string, "", regex = stri_paste(x$selected.learner, 
                       "\\."))
                 logFunDefault(learner, task, resampling, measures, par.set, control, 
                     opt.path, dob, x.string, y, remove.nas, stage, prev.stage, prefixes = c("Tune-x", 
                       "Tune-y"))
             }, final.dw.perc = NULL, extra.args = list(resolution = 10L)), class = c("TuneControlGrid", 
         "TuneControl", "OptControl")), opt.path = structure(list(par.set = structure(list(
             pars = list(alpha = structure(list(id = "alpha", type = "discrete", len = 1L, 
                 lower = NULL, upper = NULL, values = list(`1` = 1, `0` = 0), cnames = NULL, 
                 allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, 
                 requires = NULL, tunable = TRUE, special.vals = list()), class = "Param")), 
             forbidden = NULL), class = "ParamSet"), y.names = "mmce.test.mean", minimize = c(mmce.test.mean = TRUE), 
             add.transformed.x = FALSE, env = <environment>), class = c("OptPathDF", "OptPath"
         )), show.info = FALSE, remove.nas = TRUE, resample.fun = function (learner, task, 
             resampling, measures, weights = NULL, models = FALSE, extract, keep.pred = TRUE, 
             ..., show.info = getMlrOption("show.info")) 
         {
             learner = checkLearner(learner)
             learner = setHyperPars(learner, ...)
             assertClass(task, classes = "Task")
             n = getTaskSize(task)
             if (inherits(resampling, "ResampleDesc")) 
                 resampling = makeResampleInstance(resampling, task = task)
             assertClass(resampling, classes = "ResampleInstance")
             measures = checkMeasures(measures, task)
             if (!is.null(weights)) {
                 assertNumeric(weights, len = n, any.missing = FALSE, lower = 0)
             }
             assertFlag(models)
             if (missing(extract)) 
                 extract = function(model) {
                 }
             else assertFunction(extract)
             assertFlag(show.info)
             r = resampling$size
             if (n != r) 
                 stop(stri_paste("Size of data set:", n, "and resampling instance:", r, 
                     "differ!", sep = " "))
             checkLearnerBeforeTrain(task, learner, weights)
             checkAggrsBeforeResample(measures, resampling$desc)
             rin = resampling
             more.args = list(learner = learner, task = task, rin = rin, weights = NULL, 
                 measures = measures, model = models, extract = extract, show.info = show.info)
             if (!is.null(weights)) {
                 more.args$weights = weights
             }
             else if (!is.null(getTaskWeights(task))) {
                 more.args$weights = getTaskWeights(task)
             }
             parallelLibrary("mlr", master = FALSE, level = "mlr.resample", show.info = FALSE)
             exportMlrOptions(level = "mlr.resample")
             if (show.info) {
                 messagef("Resampling: %s", rin$desc$id)
                 measure.lognames = extractSubList(measures, "id")
                 if (rin$desc$predict == "both") {
                     id.train = which(vlapply(measures, function(x) "req.train" %in% x$aggr$properties))
                     id.test = which(vlapply(measures, function(x) "req.test" %in% x$aggr$properties))
                     measure.lognames = c(stri_paste(measure.lognames[id.train], "train", 
                       sep = "."), stri_paste(measure.lognames[id.test], "test", sep = "."))
                 }
                 printResampleFormatLine("Measures:", measure.lognames)
             }
             time1 = Sys.time()
             iter.results = parallelMap(doResampleIteration, seq_len(rin$desc$iters), 
                 level = "mlr.resample", more.args = more.args)
             time2 = Sys.time()
             runtime = as.numeric(difftime(time2, time1, units = "secs"))
             addClasses(mergeResampleResult(learner$id, task, iter.results, measures, 
                 rin, models, extract, keep.pred, show.info, runtime), "ResampleResult")
         })
  8: measureTime({
         r = resample.fun(learner2, task, resampling, measures = measures, show.info = FALSE)
     })
  9: force(expr)
  10: resample.fun(learner2, task, resampling, measures = measures, show.info = FALSE)
  11: parallelMap(doResampleIteration, seq_len(rin$desc$iters), level = "mlr.resample", 
         more.args = more.args)
  12: options(parallelMap.nextmap = (getPMOptNextMap() + 1L))
  13: getPMOptNextMap()
  14: getPMOption("nextmap")
  15: getOption(sprintf("parallelMap.%s", opt), def)
  
  ── 35. Error: downsample wrapper (@test_base_downsample.R#23)  ─────────────────
  argument "def" is missing, with no default
  1: resample(lrn, binaryclass.task, rdesc) at testthat/test_base_downsample.R:23
  2: parallelMap(doResampleIteration, seq_len(rin$desc$iters), level = "mlr.resample", 
         more.args = more.args)
  3: options(parallelMap.nextmap = (getPMOptNextMap() + 1L))
  4: getPMOptNextMap()
  5: getPMOption("nextmap")
  6: getOption(sprintf("parallelMap.%s", opt), def)
  
  ── 36. Error: downsample wrapper works with xgboost, we had issue #492 (@test_ba
  argument "def" is missing, with no default
  1: resample(lrn, binaryclass.task, rdesc) at testthat/test_base_downsample.R:38
  2: parallelMap(doResampleIteration, seq_len(rin$desc$iters), level = "mlr.resample", 
         more.args = more.args)
  3: options(parallelMap.nextmap = (getPMOptNextMap() + 1L))
  4: getPMOptNextMap()
  5: getPMOption("nextmap")
  6: getOption(sprintf("parallelMap.%s", opt), def)
  
  ── 37. Error: training performance works as expected (#1357) (@test_base_downsam
  argument "def" is missing, with no default
  1: resample(lrn, multiclass.task, rdesc, measures = list(setAggregation(num, train.mean))) at testthat/test_base_downsample.R:78
  2: parallelMap(doResampleIteration, seq_len(rin$desc$iters), level = "mlr.resample", 
         more.args = more.args)
  3: options(parallelMap.nextmap = (getPMOptNextMap() + 1L))
  4: getPMOptNextMap()
  5: getPMOption("nextmap")
  6: getOption(sprintf("parallelMap.%s", opt), def)
  
  ── 38. Error: benchmarking on fda tasks works (@test_base_fda.R#355)  ──────────
  argument "def" is missing, with no default
  1: expect_message({
         bmr = benchmark(lrns, fda.binary.gp.task.small, cv2)
     }, "Functional features have been") at testthat/test_base_fda.R:355
  2: quasi_capture(enquo(object), capture_messages, label = label)
  3: capture(act$val <- eval_bare(get_expr(quo), get_env(quo)))
  4: withCallingHandlers(code, message = function(condition) {
         out$push(condition)
         invokeRestart("muffleMessage")
     })
  5: eval_bare(get_expr(quo), get_env(quo))
  6: benchmark(lrns, fda.binary.gp.task.small, cv2) at testthat/test_base_fda.R:355
  7: parallelMap(benchmarkParallel, task = grid$task, learner = grid$learner, more.args = list(learners = learners, 
         tasks = tasks, resamplings = resamplings, measures = measures, keep.pred = keep.pred, 
         models = models, show.info = show.info), level = plevel)
  8: mapply(fun2, ..., MoreArgs = more.args, SIMPLIFY = FALSE, USE.NAMES = FALSE)
  9: (function (task, learner, learners, tasks, resamplings, measures, keep.pred = TRUE, 
         models = TRUE, show.info) 
     {
         setSlaveOptions()
         if (show.info) 
             messagef("Task: %s, Learner: %s", task, learner)
         lrn = learners[[learner]]
         extract.this = getExtractor(lrn)
         r = resample(lrn, tasks[[task]], resamplings[[task]], measures = measures, models = models, 
             extract = extract.this, keep.pred = keep.pred, show.info = show.info)
         r$learner = lrn
         return(r)
     })(task = dots[[1L]][[1L]], learner = dots[[2L]][[1L]], learners = list(classif.fdausc.knn = structure(list(
         id = "classif.fdausc.knn", type = "classif", package = "fda.usc", properties = c("twoclass", 
         "multiclass", "weights", "prob", "single.functional"), par.set = structure(list(
             pars = list(knn = structure(list(id = "knn", type = "integer", len = 1L, 
                 lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(NULL), when = "train"), class = c("LearnerParam", 
             "Param")), metric = structure(list(id = "metric", type = "discrete", len = 1L, 
                 lower = NULL, upper = NULL, values = list(metric.lp = "metric.lp", metric.kl = "metric.kl", 
                     metric.hausdorff = "metric.hausdorff", metric.dist = "metric.dist"), 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = "metric.lp", 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), type.CV = structure(list(
                 id = "type.CV", type = "discrete", len = 1L, lower = NULL, upper = NULL, 
                 values = list(GCV.S = "GCV.S", CV.S = "CV.S", GCCV.S = "GCCV.S"), cnames = NULL, 
                 allow.inf = FALSE, has.default = TRUE, default = "GCV.S", trafo = NULL, 
                 requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), trim = structure(list(id = "trim", type = "numeric", len = 1L, 
                 lower = 0L, upper = 1L, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 0L, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), draw = structure(list(id = "draw", type = "logical", len = 1L, lower = NULL, 
                 upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, 
                 allow.inf = FALSE, has.default = TRUE, default = TRUE, trafo = NULL, 
                 requires = NULL, tunable = FALSE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param"))), forbidden = NULL), class = c("LearnerParamSet", "ParamSet")), 
         par.vals = list(draw = FALSE), predict.type = "response", name = "fdausc.knn", 
         short.name = "fdausc.knn", note = "Argument draw=FALSE is used as default.", 
         callees = character(0), help.list = list(), config = list(), fix.factors.prediction = FALSE), class = c("classif.fdausc.knn", 
     "RLearnerClassif", "RLearner", "Learner")), classif.rpart = structure(list(id = "classif.rpart", 
         type = "classif", package = "rpart", properties = c("twoclass", "multiclass", 
         "missings", "numerics", "factors", "ordered", "prob", "weights", "featimp"), 
         par.set = structure(list(pars = list(minsplit = structure(list(id = "minsplit", 
             type = "integer", len = 1L, lower = 1L, upper = Inf, values = NULL, cnames = NULL, 
             allow.inf = FALSE, has.default = TRUE, default = 20L, trafo = NULL, requires = NULL, 
             tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), minbucket = structure(list(id = "minbucket", type = "integer", len = 1L, 
             lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
             has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, 
             special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
         )), cp = structure(list(id = "cp", type = "numeric", len = 1L, lower = 0, upper = 1, 
             values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 0.01, 
             trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), maxcompete = structure(list(id = "maxcompete", type = "integer", len = 1L, 
             lower = 0L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
             has.default = TRUE, default = 4L, trafo = NULL, requires = NULL, tunable = TRUE, 
             special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
         )), maxsurrogate = structure(list(id = "maxsurrogate", type = "integer", len = 1L, 
             lower = 0L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
             has.default = TRUE, default = 5L, trafo = NULL, requires = NULL, tunable = TRUE, 
             special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
         )), usesurrogate = structure(list(id = "usesurrogate", type = "discrete", len = 1L, 
             lower = NULL, upper = NULL, values = list(`0` = 0L, `1` = 1L, `2` = 2L), 
             cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 2L, trafo = NULL, 
             requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), surrogatestyle = structure(list(id = "surrogatestyle", type = "discrete", 
             len = 1L, lower = NULL, upper = NULL, values = list(`0` = 0L, `1` = 1L), 
             cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 0L, trafo = NULL, 
             requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), maxdepth = structure(list(id = "maxdepth", type = "integer", len = 1L, 
             lower = 1L, upper = 30L, values = NULL, cnames = NULL, allow.inf = FALSE, 
             has.default = TRUE, default = 30L, trafo = NULL, requires = NULL, tunable = TRUE, 
             special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
         )), xval = structure(list(id = "xval", type = "integer", len = 1L, lower = 0L, 
             upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
             default = 10L, trafo = NULL, requires = NULL, tunable = FALSE, special.vals = list(), 
             when = "train"), class = c("LearnerParam", "Param")), parms = structure(list(
             id = "parms", type = "untyped", len = 1L, lower = NULL, upper = NULL, values = NULL, 
             cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, 
             requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param"))), forbidden = NULL), class = c("LearnerParamSet", "ParamSet")), par.vals = list(
             xval = 0L), predict.type = "response", name = "Decision Tree", short.name = "rpart", 
         note = "`xval` has been set to `0` by default for speed.", callees = c("rpart", 
         "rpart.control"), help.list = list(minsplit = "Argument of: rpart::rpart.control\n\nthe minimum number of observations that must exist in a node in order for a split to be attempted.", 
             minbucket = "Argument of: rpart::rpart.control\n\nthe minimum number of observations in any terminal <leaf> node. If only one of minbucket or minsplit is specified, the code either sets minsplit to minbucket*3 or minbucket to minsplit/3, as appropriate.", 
             cp = "Argument of: rpart::rpart.control\n\ncomplexity parameter.  Any split that does not decrease the overall lack of fit by a factor of cp is not attempted.  For instance, with anova splitting, this means that the overall R-squared must increase by cp at each step. The main role of this parameter is to save computing time by pruning off splits that are obviously not worthwhile. Essentially,the user informs the program that any split which does not improve the fit by cp will likely be pruned off by cross-validation, and that hence the program need not pursue it.", 
             maxcompete = "Argument of: rpart::rpart.control\n\nthe number of competitor splits retained in the output.  It is useful to know not just which split was chosen, but which variable came in second, third, etc.", 
             maxsurrogate = "Argument of: rpart::rpart.control\n\nthe number of surrogate splits retained in the output.  If this is set to zero the compute time will be reduced, since approximately half of the computational time (other than setup) is used in the search for surrogate splits.", 
             usesurrogate = "Argument of: rpart::rpart.control\n\nhow to use surrogates in the splitting process.  0 means display only; an observation with a missing value for the primary split rule is not sent further down the tree.  1 means use surrogates, in order, to split subjects missing the primary variable; if all surrogates are missing the observation is not split.  For value 2 ,if all surrogates are missing, then send the observation in the majority direction.  A value of 0 corresponds to the action of tree, and 2 to the recommendations of Breiman et.al (1984).", 
             xval = "Argument of: rpart::rpart.control\n\nnumber of cross-validations.", 
             surrogatestyle = "Argument of: rpart::rpart.control\n\ncontrols the selection of a best surrogate. If set to 0 (default) the program uses the total number of correct classification for a potential surrogate variable, if set to 1 it uses the percent correct, calculated over the non-missing values of the surrogate. The first option more severely penalizes covariates with a large number of missing values.", 
             maxdepth = "Argument of: rpart::rpart.control\n\nSet the maximum depth of any node of the final tree, with the root node counted as depth 0.  Values greater than  30 rpart will give nonsense results on 32-bit machines.", 
             parms = "Argument of: rpart::rpart\n\noptional parameters for the splitting function. Anova splitting has no parameters. Poisson splitting has a single parameter, the coefficient of variation of the prior distribution on the rates.  The default value is 1. Exponential splitting has the same parameter as Poisson. For classification splitting, the list can contain any of: the vector of prior probabilities (component prior), the loss matrix (component loss) or the splitting index (component split).  The priors must be positive and sum to 1.  The loss matrix must have zeros on the diagonal and positive off-diagonal elements.  The splitting index can be gini or information.  The default priors are proportional to the data counts, the losses default to 1, and the split defaults to gini."), 
         config = list(), fix.factors.prediction = FALSE), class = c("classif.rpart", 
     "RLearnerClassif", "RLearner", "Learner")), classif.featureless = structure(list(
         id = "classif.featureless", type = "classif", package = "mlr", properties = c("twoclass", 
         "multiclass", "numerics", "factors", "ordered", "missings", "prob", "functionals"
         ), par.set = structure(list(pars = list(method = structure(list(id = "method", 
             type = "discrete", len = 1L, lower = NULL, upper = NULL, values = list(majority = "majority", 
                 `sample-prior` = "sample-prior"), cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
             default = "majority", trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
             when = "train"), class = c("LearnerParam", "Param"))), forbidden = NULL), class = c("LearnerParamSet", 
         "ParamSet")), par.vals = list(), predict.type = "response", name = "Featureless classifier", 
         short.name = "featureless", note = "", callees = character(0), help.list = list(), 
         config = list(), fix.factors.prediction = FALSE), class = c("classif.featureless", 
     "RLearnerClassif", "RLearner", "Learner"))), tasks = list(gp.fdf = structure(list(
         type = "classif", env = <environment>, weights = NULL, blocking = NULL, coordinates = NULL, 
         task.desc = structure(list(id = "gp.fdf", type = "classif", target = "X1", size = 100L, 
             n.feat = c(numerics = 0L, factors = 0L, ordered = 0L, functionals = 1L), 
             has.missings = FALSE, has.weights = FALSE, has.blocking = FALSE, has.coordinates = FALSE, 
             class.levels = c("1", "2"), positive = "1", negative = "2", class.distribution = structure(c(`1` = 54L, 
             `2` = 46L), .Dim = 2L, .Dimnames = list(c("1", "2")), class = "table")), class = c("ClassifTaskDesc", 
         "SupervisedTaskDesc", "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", 
     "Task"))), resamplings = list(gp.fdf = structure(list(desc = structure(list(id = "cross-validation", 
         iters = 2L, predict = "test", stratify = FALSE), class = c("CVDesc", "ResampleDesc"
     )), size = 100L, train.inds = list(c(82L, 69L, 72L, 49L, 24L, 37L, 83L, 19L, 35L, 
     53L, 84L, 93L, 74L, 59L, 41L, 28L, 5L, 89L, 99L, 32L, 80L, 45L, 87L, 22L, 33L, 1L, 
     51L, 76L, 18L, 61L, 29L, 64L, 42L, 81L, 26L, 14L, 47L, 2L, 79L, 68L, 9L, 96L, 46L, 
     92L, 3L, 23L, 54L, 94L, 66L, 62L), c(55L, 56L, 70L, 36L, 27L, 75L, 7L, 12L, 48L, 
     71L, 63L, 15L, 77L, 17L, 8L, 86L, 10L, 60L, 25L, 91L, 38L, 13L, 31L, 39L, 65L, 11L, 
     95L, 88L, 34L, 30L, 52L, 57L, 44L, 50L, 4L, 100L, 43L, 20L, 97L, 58L, 73L, 40L, 78L, 
     6L, 98L, 85L, 90L, 16L, 67L, 21L)), test.inds = list(c(4L, 6L, 7L, 8L, 10L, 11L, 
     12L, 13L, 15L, 16L, 17L, 20L, 21L, 25L, 27L, 30L, 31L, 34L, 36L, 38L, 39L, 40L, 43L, 
     44L, 48L, 50L, 52L, 55L, 56L, 57L, 58L, 60L, 63L, 65L, 67L, 70L, 71L, 73L, 75L, 77L, 
     78L, 85L, 86L, 88L, 90L, 91L, 95L, 97L, 98L, 100L), c(1L, 2L, 3L, 5L, 9L, 14L, 18L, 
     19L, 22L, 23L, 24L, 26L, 28L, 29L, 32L, 33L, 35L, 37L, 41L, 42L, 45L, 46L, 47L, 49L, 
     51L, 53L, 54L, 59L, 61L, 62L, 64L, 66L, 68L, 69L, 72L, 74L, 76L, 79L, 80L, 81L, 82L, 
     83L, 84L, 87L, 89L, 92L, 93L, 94L, 96L, 99L)), group = structure(integer(0), .Label = character(0), class = "factor")), class = "ResampleInstance")), 
         measures = list(structure(list(id = "mmce", minimize = TRUE, properties = c("classif", 
         "classif.multi", "req.pred", "req.truth"), fun = function (task, model, pred, 
             feats, extra.args) 
         {
             measureMMCE(pred$data$truth, pred$data$response)
         }, extra.args = list(), best = 0, worst = 1, name = "Mean misclassification error", 
             note = "Defined as: mean(response != truth)", aggr = structure(list(id = "test.mean", 
                 name = "Test mean", fun = function (task, perf.test, perf.train, measure, 
                     group, pred) 
                 mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure")), 
         keep.pred = TRUE, models = TRUE, show.info = FALSE)
  10: resample(lrn, tasks[[task]], resamplings[[task]], measures = measures, models = models, 
         extract = extract.this, keep.pred = keep.pred, show.info = show.info)
  11: parallelMap(doResampleIteration, seq_len(rin$desc$iters), level = "mlr.resample", 
         more.args = more.args)
  12: options(parallelMap.nextmap = (getPMOptNextMap() + 1L))
  13: getPMOptNextMap()
  14: getPMOption("nextmap")
  15: getOption(sprintf("parallelMap.%s", opt), def)
  
  ── 39. Error: extractFDAFeaturesWrapper (@test_base_fda_extractFDAFeaturesWrappe
  argument "def" is missing, with no default
  1: resample(lrn, fuelsubset.task, cv2) at testthat/test_base_fda_extractFDAFeaturesWrapper.R:12
  2: parallelMap(doResampleIteration, seq_len(rin$desc$iters), level = "mlr.resample", 
         more.args = more.args)
  3: options(parallelMap.nextmap = (getPMOptNextMap() + 1L))
  4: getPMOptNextMap()
  5: getPMOption("nextmap")
  6: getOption(sprintf("parallelMap.%s", opt), def)
  
  ── 40. Error: generateCalibrationData (@test_base_generateCalibration.R#21)  ───
  argument "def" is missing, with no default
  1: resample(lrn, binaryclass.task, rdesc) at testthat/test_base_generateCalibration.R:21
  2: parallelMap(doResampleIteration, seq_len(rin$desc$iters), level = "mlr.resample", 
         more.args = more.args)
  3: options(parallelMap.nextmap = (getPMOptNextMap() + 1L))
  4: getPMOptNextMap()
  5: getPMOption("nextmap")
  6: getOption(sprintf("parallelMap.%s", opt), def)
  
  ── 41. Error: generateFeatureImportanceData (@test_base_generateFeatureImportanc
  argument "def" is missing, with no default
  1: generateFeatureImportanceData(regr.task, "permutation.importance", "regr.rpart", 
         c("lstat", "crim"), FALSE, mse, function(x, y) abs(x - y), median, 1L, TRUE, 
         FALSE) at testthat/test_base_generateFeatureImportanceData.R:3
  2: doPermutationImportance(task, learner, features, interaction, measure, contrast, 
         aggregation, nmc, replace, local)
  3: lapply(features, function(x) {
         parallelMap(doPermutationImportanceIteration, i = seq_len(nmc), more.args = c(args, 
             x = x))
     })
  4: FUN(X[[i]], ...)
  5: parallelMap(doPermutationImportanceIteration, i = seq_len(nmc), more.args = c(args, 
         x = x))
  6: options(parallelMap.nextmap = (getPMOptNextMap() + 1L))
  7: getPMOptNextMap()
  8: getPMOption("nextmap")
  9: getOption(sprintf("parallelMap.%s", opt), def)
  
  ── 42. Error: plotFilterValues (@test_base_generateFilterValuesData.R#68)  ─────
  argument "def" is missing, with no default
  1: generateFilterValuesData(binaryclass.task, method = filter.classif) at testthat/test_base_generateFilterValuesData.R:68
  2: lapply(filter, function(x) {
         x = do.call(x$fun, c(list(task = task, nselect = nselect), more.args[[x$name]]))
         missing.score = setdiff(fn, names(x))
         x[missing.score] = NA_real_
         x[match(fn, names(x))]
     })
  3: FUN(X[[i]], ...)
  4: do.call(x$fun, c(list(task = task, nselect = nselect), more.args[[x$name]]))
  5: (function (task, nselect, perf.learner = NULL, perf.measure = NULL, perf.resampling = NULL, 
         ...) 
     {
         typ = getTaskType(task)
         if (is.null(perf.learner)) 
             if (typ == "classif") 
                 perf.learner = "classif.rpart"
             else if (typ == "regr") 
                 perf.learner = "regr.rpart"
             else if (typ == "surv") 
                 perf.learner = "surv.rpart"
         if (is.null(perf.measure)) 
             perf.measure = getDefaultMeasure(task)
         perf.learner = checkLearner(perf.learner)
         perf.measure = checkMeasures(perf.measure, perf.learner)
         if (length(perf.measure) != 1L) 
             stop("Exactly one measure must be provided")
         if (is.null(perf.resampling)) 
             perf.resampling = makeResampleDesc("Subsample", iters = 1L, split = 0.67)
         if (getTaskType(task) != perf.learner$type) 
             stopf("Expected task of type '%s', not '%s'", getTaskType(task), perf.learner$type)
         fns = getTaskFeatureNames(task)
         res = double(length(fns))
         for (i in seq_along(fns)) {
             subtask = subsetTask(task, features = fns[i])
             res[i] = resample(learner = perf.learner, task = subtask, resampling = perf.resampling, 
                 measures = perf.measure, keep.pred = FALSE, show.info = FALSE)$aggr
         }
         if (perf.measure[[1L]]$minimize) 
             res = -1 * res
         setNames(res, fns)
     })(task = structure(list(type = "classif", env = <environment>, weights = NULL, blocking = NULL, 
         coordinates = NULL, task.desc = structure(list(id = "binary", type = "classif", 
             target = "Class", size = 208L, n.feat = c(numerics = 60L, factors = 0L, ordered = 0L, 
             functionals = 0L), has.missings = FALSE, has.weights = FALSE, has.blocking = FALSE, 
             has.coordinates = FALSE, class.levels = c("M", "R"), positive = "M", negative = "R", 
             class.distribution = structure(c(M = 111L, R = 97L), .Dim = 2L, .Dimnames = list(
                 c("M", "R")), class = "table")), class = c("ClassifTaskDesc", "SupervisedTaskDesc", 
         "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", "Task")), nselect = 60L)
  6: resample(learner = perf.learner, task = subtask, resampling = perf.resampling, measures = perf.measure, 
         keep.pred = FALSE, show.info = FALSE)
  7: parallelMap(doResampleIteration, seq_len(rin$desc$iters), level = "mlr.resample", 
         more.args = more.args)
  8: options(parallelMap.nextmap = (getPMOptNextMap() + 1L))
  9: getPMOptNextMap()
  10: getPMOption("nextmap")
  11: getOption(sprintf("parallelMap.%s", opt), def)
  
  ── 43. Error: args are passed down to filter methods (@test_base_generateFilterV
  argument "def" is missing, with no default
  1: generateFilterValuesData(regr.num.task, method = c("mrmr", "univariate.model.score"), 
         nselect = 3, more.args = list(univariate.model.score = list(perf.learner = "regr.lm"))) at testthat/test_base_generateFilterValuesData.R:97
  2: lapply(filter, function(x) {
         x = do.call(x$fun, c(list(task = task, nselect = nselect), more.args[[x$name]]))
         missing.score = setdiff(fn, names(x))
         x[missing.score] = NA_real_
         x[match(fn, names(x))]
     })
  3: FUN(X[[i]], ...)
  4: do.call(x$fun, c(list(task = task, nselect = nselect), more.args[[x$name]]))
  5: (function (task, nselect, perf.learner = NULL, perf.measure = NULL, perf.resampling = NULL, 
         ...) 
     {
         typ = getTaskType(task)
         if (is.null(perf.learner)) 
             if (typ == "classif") 
                 perf.learner = "classif.rpart"
             else if (typ == "regr") 
                 perf.learner = "regr.rpart"
             else if (typ == "surv") 
                 perf.learner = "surv.rpart"
         if (is.null(perf.measure)) 
             perf.measure = getDefaultMeasure(task)
         perf.learner = checkLearner(perf.learner)
         perf.measure = checkMeasures(perf.measure, perf.learner)
         if (length(perf.measure) != 1L) 
             stop("Exactly one measure must be provided")
         if (is.null(perf.resampling)) 
             perf.resampling = makeResampleDesc("Subsample", iters = 1L, split = 0.67)
         if (getTaskType(task) != perf.learner$type) 
             stopf("Expected task of type '%s', not '%s'", getTaskType(task), perf.learner$type)
         fns = getTaskFeatureNames(task)
         res = double(length(fns))
         for (i in seq_along(fns)) {
             subtask = subsetTask(task, features = fns[i])
             res[i] = resample(learner = perf.learner, task = subtask, resampling = perf.resampling, 
                 measures = perf.measure, keep.pred = FALSE, show.info = FALSE)$aggr
         }
         if (perf.measure[[1L]]$minimize) 
             res = -1 * res
         setNames(res, fns)
     })(task = structure(list(type = "regr", env = <environment>, weights = NULL, blocking = NULL, 
         coordinates = NULL, task.desc = structure(list(id = "regrnumtask", type = "regr", 
             target = "medv", size = 506L, n.feat = c(numerics = 12L, factors = 0L, ordered = 0L, 
             functionals = 0L), has.missings = FALSE, has.weights = FALSE, has.blocking = FALSE, 
             has.coordinates = FALSE), class = c("RegrTaskDesc", "SupervisedTaskDesc", 
         "TaskDesc"))), class = c("RegrTask", "SupervisedTask", "Task")), nselect = 3, 
         perf.learner = "regr.lm")
  6: resample(learner = perf.learner, task = subtask, resampling = perf.resampling, measures = perf.measure, 
         keep.pred = FALSE, show.info = FALSE)
  7: parallelMap(doResampleIteration, seq_len(rin$desc$iters), level = "mlr.resample", 
         more.args = more.args)
  8: options(parallelMap.nextmap = (getPMOptNextMap() + 1L))
  9: getPMOptNextMap()
  10: getPMOption("nextmap")
  11: getOption(sprintf("parallelMap.%s", opt), def)
  
  ── 44. Error: generate data (@test_base_generateHyperParsEffect.R#13)  ─────────
  $ operator is invalid for atomic vectors
  1: resample(lrn, task = pid.task, resampling = cv2, extract = getTuneResult) at testthat/test_base_generateHyperParsEffect.R:13
  2: parallelMap(doResampleIteration, seq_len(rin$desc$iters), level = "mlr.resample", 
         more.args = more.args)
  3: mapply(fun2, ..., MoreArgs = more.args, SIMPLIFY = FALSE, USE.NAMES = FALSE)
  4: (function (learner, task, rin, i, measures, weights, model, extract, show.info) 
     {
         setSlaveOptions()
         train.i = rin$train.inds[[i]]
         test.i = rin$test.inds[[i]]
         calculateResampleIterationResult(learner = learner, task = task, i = i, train.i = train.i, 
             test.i = test.i, measures = measures, weights = weights, rdesc = rin$desc, 
             model = model, extract = extract, show.info = show.info)
     })(dots[[1L]][[1L]], learner = structure(list(id = "classif.ksvm.tuned", type = "classif", 
         package = "kernlab", properties = NULL, par.set = structure(list(pars = list(), 
             forbidden = NULL), class = "ParamSet"), par.vals = list(), predict.type = "response", 
         fix.factors.prediction = FALSE, next.learner = structure(list(id = "classif.ksvm", 
             type = "classif", package = "kernlab", properties = c("twoclass", "multiclass", 
             "numerics", "factors", "prob", "class.weights"), par.set = structure(list(
                 pars = list(scaled = structure(list(id = "scaled", type = "logical", 
                     len = 1L, lower = NULL, upper = NULL, values = list(`TRUE` = TRUE, 
                       `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = TRUE, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), type = structure(list(
                     id = "type", type = "discrete", len = 1L, lower = NULL, upper = NULL, 
                     values = list(`C-svc` = "C-svc", `nu-svc` = "nu-svc", `C-bsvc` = "C-bsvc", 
                       `spoc-svc` = "spoc-svc", `kbb-svc` = "kbb-svc"), cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = "C-svc", trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), kernel = structure(list(id = "kernel", type = "discrete", 
                     len = 1L, lower = NULL, upper = NULL, values = list(vanilladot = "vanilladot", 
                       polydot = "polydot", rbfdot = "rbfdot", tanhdot = "tanhdot", laplacedot = "laplacedot", 
                       besseldot = "besseldot", anovadot = "anovadot", splinedot = "splinedot"), 
                     cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = "rbfdot", 
                     trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), C = structure(list(
                     id = "C", type = "numeric", len = 1L, lower = 0, upper = Inf, values = NULL, 
                     cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 1, 
                     trafo = NULL, requires = type %in% c("C-svc", "C-bsvc", "spoc-svc", 
                       "kbb-svc"), tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), nu = structure(list(id = "nu", type = "numeric", len = 1L, 
                     lower = 0, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 0.2, trafo = NULL, requires = type == 
                       "nu-svc", tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), epsilon = structure(list(id = "epsilon", type = "numeric", 
                     len = 1L, lower = -Inf, upper = Inf, values = NULL, cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = 0.1, trafo = NULL, 
                     requires = type %in% c("eps-svr", "nu-svr", "eps-bsvm"), tunable = TRUE, 
                     special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), sigma = structure(list(id = "sigma", type = "numeric", len = 1L, 
                     lower = 0, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = FALSE, default = NULL, trafo = NULL, requires = kernel %in% 
                       c("rbfdot", "anovadot", "besseldot", "laplacedot"), tunable = TRUE, 
                     special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), degree = structure(list(id = "degree", type = "integer", len = 1L, 
                     lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 3L, trafo = NULL, requires = kernel %in% 
                       c("polydot", "anovadot", "besseldot"), tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), scale = structure(list(
                     id = "scale", type = "numeric", len = 1L, lower = 0, upper = Inf, 
                     values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = 1, trafo = NULL, requires = kernel %in% c("polydot", "tanhdot"), 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), offset = structure(list(id = "offset", type = "numeric", len = 1L, 
                     lower = -Inf, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 1, trafo = NULL, requires = kernel %in% 
                       c("polydot", "tanhdot"), tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), order = structure(list(
                     id = "order", type = "integer", len = 1L, lower = -Inf, upper = Inf, 
                     values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = 1L, trafo = NULL, requires = kernel == "besseldot", tunable = TRUE, 
                     special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), tol = structure(list(id = "tol", type = "numeric", len = 1L, 
                     lower = 0, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 0.001, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), shrinking = structure(list(id = "shrinking", type = "logical", 
                     len = 1L, lower = NULL, upper = NULL, values = list(`TRUE` = TRUE, 
                       `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = TRUE, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), class.weights = structure(list(
                     id = "class.weights", type = "numericvector", len = NA_integer_, 
                     lower = 0, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), fit = structure(list(id = "fit", type = "logical", len = 1L, 
                     lower = NULL, upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), 
                     cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = TRUE, 
                     trafo = NULL, requires = NULL, tunable = FALSE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), cache = structure(list(
                     id = "cache", type = "integer", len = 1L, lower = 1L, upper = Inf, 
                     values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = 40L, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param"))), forbidden = NULL), class = c("LearnerParamSet", 
             "ParamSet")), par.vals = list(fit = FALSE), predict.type = "response", name = "Support Vector Machines", 
             short.name = "ksvm", note = "Kernel parameters have to be passed directly and not by using the `kpar` list in `ksvm`. Note that `fit` has been set to `FALSE` by default for speed.", 
             callees = "ksvm", help.list = list(sigma = "Argument of: kernlab::ksvm\n\nfor the ANOVA kernel \"anovadot\".", 
                 degree = "Argument of: kernlab::ksvm\n\nfor the ANOVA kernel \"anovadot\".", 
                 scale = "Argument of: kernlab::ksvm\n\nfor the Hyperbolic tangent kernel function \"tanhdot\"", 
                 offset = "Argument of: kernlab::ksvm\n\nfor the Hyperbolic tangent kernel function \"tanhdot\"", 
                 order = "Argument of: kernlab::ksvm\n\nfor the Bessel kernel \"besseldot\".", 
                 scaled = "Argument of: kernlab::ksvm\n\nA logical vector indicating the variables to be scaled. If scaled is of length 1, the value is recycled as many times as needed and all non-binary variables are scaled. Per default, data are scaled internally (both x and y variables) to zero mean and unit variance. The center and scale values are returned and used for later predictions.", 
                 type = "Argument of: kernlab::ksvm\n\nksvm can be used for classification , for regression, or for novelty detection. Depending on whether y is a factor or not, the default setting for type is C-svc or eps-svr, respectively, but can be overwritten by setting an explicit value. Valid options are:\n\nC-svc   C classification\n\nnu-svc  nu classification\n\nC-bsvc  bound-constraint svm classification\n\nspoc-svc  Crammer, Singer native multi-class\n\nkbb-svc  Weston, Watkins native multi-class\n\none-svc  novelty detection\n\neps-svr  epsilon regression\n\nnu-svr   nu regression\n\neps-bsvr  bound-constraint svm regression", 
                 kernel = "Argument of: kernlab::ksvm\n\nthe kernel function used in training and predicting. This parameter can be set to any function, of class kernel, which computes the inner product in feature space between two vector arguments (see kernels). kernlab provides the most popular kernel functions which can be used by setting the kernel parameter to the following strings:\n\nrbfdot Radial Basis kernel \"Gaussian\"\n\npolydot Polynomial kernel\n\nvanilladot Linear kernel\n\ntanhdot Hyperbolic tangent kernel\n\nlaplacedot Laplacian kernel\n\nbesseldot Bessel kernel\n\nanovadot ANOVA RBF kernel\n\nsplinedot Spline kernel\n\nstringdot String kernel\n\nSetting the kernel parameter to \"matrix\" treats x as a kernel matrix calling the kernelMatrix interface. The kernel parameter can also be set to a user defined function of class kernel by passing the function name as an argument.", 
                 C = "Argument of: kernlab::ksvm\n\ncost of constraints violation (default: 1) this is the ‘C’-constant of the regularization term in the Lagrange formulation.", 
                 nu = "Argument of: kernlab::ksvm\n\nparameter needed for nu-svc, one-svc, and nu-svr. The nu parameter sets the upper bound on the training error and the lower bound on the fraction of data points to become Support Vectors (default: 0.2).", 
                 epsilon = "Argument of: kernlab::ksvm\n\nepsilon in the insensitive-loss function used for eps-svr, nu-svr and eps-bsvm (default: 0.1)", 
                 class.weights = "Argument of: kernlab::ksvm\n\na named vector of weights for the different classes, used for asymmetric class sizes. Not all factor levels have to be supplied (default weight: 1). All components have to be named.", 
                 cache = "Argument of: kernlab::ksvm\n\ncache memory in MB (default 40)", 
                 tol = "Argument of: kernlab::ksvm\n\ntolerance of termination criterion (default: 0.001)", 
                 shrinking = "Argument of: kernlab::ksvm\n\noption whether to use the shrinking-heuristics (default: TRUE)", 
                 fit = "Argument of: kernlab::ksvm\n\nindicates whether the fitted values should be computed and included in the model or not (default: TRUE)"), 
             class.weights.param = "class.weights", config = list(), fix.factors.prediction = FALSE), class = c("classif.ksvm", 
         "RLearnerClassif", "RLearner", "Learner")), model.subclass = "TuneModel", resampling = structure(list(
             split = 0.666666666666667, id = "holdout", iters = 1L, predict = "test", 
             stratify = FALSE), class = c("HoldoutDesc", "ResampleDesc")), measures = list(
             structure(list(id = "mmce", minimize = TRUE, properties = c("classif", "classif.multi", 
             "req.pred", "req.truth"), fun = function (task, model, pred, feats, extra.args) 
             {
                 measureMMCE(pred$data$truth, pred$data$response)
             }, extra.args = list(), best = 0, worst = 1, name = "Mean misclassification error", 
                 note = "Defined as: mean(response != truth)", aggr = structure(list(id = "test.mean", 
                     name = "Test mean", fun = function (task, perf.test, perf.train, 
                       measure, group, pred) 
                     mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure")), 
         opt.pars = structure(list(pars = list(C = structure(list(id = "C", type = "numeric", 
             len = 1L, lower = -5, upper = 5, values = NULL, cnames = NULL, allow.inf = FALSE, 
             has.default = FALSE, default = NULL, trafo = function (x) 
             2^x, requires = NULL, tunable = TRUE, special.vals = list()), class = "Param")), 
             forbidden = NULL), class = "ParamSet"), bit.names = character(0), bits.to.features = function () 
         {
         }, control = structure(list(same.resampling.instance = TRUE, impute.val = NULL, 
             tune.threshold = FALSE, tune.threshold.args = list(), log.fun = function (learner, 
                 task, resampling, measures, par.set, control, opt.path, dob, x, y, remove.nas, 
                 stage, prev.stage) 
             {
                 x.string = paramValueToString(par.set, x, show.missing.values = !remove.nas)
                 if (inherits(learner, "ModelMultiplexer")) 
                     x.string = stri_replace_all(x.string, "", regex = stri_paste(x$selected.learner, 
                       "\\."))
                 logFunDefault(learner, task, resampling, measures, par.set, control, 
                     opt.path, dob, x.string, y, remove.nas, stage, prev.stage, prefixes = c("Tune-x", 
                       "Tune-y"))
             }, final.dw.perc = NULL, extra.args = list(maxit = 5L), budget = 5L), class = c("TuneControlRandom", 
         "TuneControl", "OptControl")), show.info = FALSE), class = c("TuneWrapper", "OptWrapper", 
     "BaseWrapper", "Learner")), task = structure(list(type = "classif", env = <environment>, 
         weights = NULL, blocking = NULL, coordinates = NULL, task.desc = structure(list(
             id = "PimaIndiansDiabetes-example", type = "classif", target = "diabetes", 
             size = 768L, n.feat = c(numerics = 8L, factors = 0L, ordered = 0L, functionals = 0L
             ), has.missings = FALSE, has.weights = FALSE, has.blocking = FALSE, has.coordinates = FALSE, 
             class.levels = c("neg", "pos"), positive = "pos", negative = "neg", class.distribution = structure(c(neg = 500L, 
             pos = 268L), .Dim = 2L, .Dimnames = list(c("neg", "pos")), class = "table")), class = c("ClassifTaskDesc", 
         "SupervisedTaskDesc", "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", 
     "Task")), rin = structure(list(desc = structure(list(id = "cross-validation", iters = 2L, 
         predict = "test", stratify = FALSE), class = c("CVDesc", "ResampleDesc")), size = 768L, 
         train.inds = list(c(525L, 502L, 517L, 617L, 482L, 12L, 493L, 611L, 15L, 684L, 
         405L, 595L, 303L, 208L, 267L, 192L, 709L, 357L, 546L, 486L, 504L, 264L, 101L, 
         403L, 223L, 433L, 707L, 530L, 54L, 3L, 545L, 507L, 468L, 202L, 68L, 670L, 512L, 
         426L, 84L, 182L, 620L, 163L, 498L, 489L, 297L, 646L, 602L, 29L, 316L, 416L, 340L, 
         94L, 113L, 350L, 570L, 9L, 457L, 587L, 672L, 442L, 762L, 614L, 274L, 169L, 145L, 
         683L, 432L, 352L, 487L, 244L, 509L, 588L, 370L, 423L, 323L, 481L, 706L, 634L, 
         756L, 596L, 367L, 238L, 198L, 685L, 686L, 526L, 428L, 693L, 124L, 765L, 577L, 
         642L, 749L, 582L, 248L, 56L, 601L, 240L, 245L, 755L, 559L, 722L, 237L, 81L, 313L, 
         272L, 443L, 27L, 159L, 4L, 395L, 510L, 48L, 218L, 449L, 553L, 59L, 318L, 86L, 
         254L, 411L, 733L, 653L, 266L, 11L, 404L, 333L, 243L, 301L, 657L, 681L, 137L, 
         118L, 275L, 226L, 66L, 662L, 505L, 75L, 610L, 715L, 120L, 737L, 718L, 635L, 644L, 
         261L, 37L, 336L, 64L, 263L, 368L, 555L, 408L, 371L, 125L, 732L, 511L, 344L, 459L, 
         603L, 579L, 52L, 58L, 327L, 480L, 95L, 580L, 229L, 717L, 407L, 643L, 166L, 103L, 
         178L, 393L, 111L, 628L, 573L, 566L, 49L, 230L, 332L, 285L, 461L, 750L, 115L, 
         539L, 330L, 161L, 675L, 641L, 390L, 425L, 589L, 583L, 458L, 78L, 172L, 719L, 
         565L, 495L, 151L, 533L, 136L, 242L, 467L, 660L, 491L, 328L, 289L, 496L, 22L, 
         430L, 420L, 436L, 325L, 475L, 380L, 262L, 532L, 63L, 514L, 568L, 278L, 723L, 
         154L, 70L, 659L, 695L, 766L, 550L, 93L, 712L, 434L, 184L, 129L, 557L, 632L, 655L, 
         209L, 454L, 356L, 41L, 273L, 170L, 607L, 18L, 253L, 544L, 661L, 645L, 378L, 492L, 
         764L, 415L, 721L, 738L, 309L, 508L, 392L, 201L, 576L, 185L, 200L, 399L, 422L, 
         439L, 389L, 17L, 529L, 23L, 379L, 228L, 758L, 374L, 592L, 724L, 8L, 626L, 503L, 
         528L, 206L, 60L, 348L, 355L, 513L, 183L, 219L, 112L, 427L, 25L, 612L, 87L, 314L, 
         44L, 181L, 235L, 741L, 383L, 216L, 304L, 341L, 453L, 398L, 622L, 563L, 739L, 
         97L, 447L, 571L, 754L, 286L, 625L, 677L, 648L, 387L, 205L, 554L, 65L, 621L, 150L, 
         650L, 249L, 189L, 400L, 121L, 616L, 656L, 767L, 131L, 465L, 351L, 470L, 108L, 
         391L, 479L, 139L, 109L, 584L, 107L, 729L, 664L, 102L, 372L, 221L, 600L, 148L, 
         141L, 599L, 19L, 156L, 62L, 605L, 132L, 561L, 680L, 440L, 295L, 236L, 654L, 21L, 
         572L, 497L, 746L, 671L, 16L, 271L, 471L, 551L, 472L, 649L, 177L, 386L, 651L, 
         666L, 239L, 591L, 42L, 564L, 167L, 251L, 396L, 222L), c(702L, 623L, 98L, 191L, 
         252L, 310L, 613L, 196L, 619L, 347L, 153L, 212L, 697L, 164L, 364L, 77L, 751L, 
         269L, 90L, 35L, 193L, 349L, 36L, 640L, 560L, 213L, 91L, 424L, 494L, 321L, 38L, 
         241L, 519L, 326L, 402L, 753L, 460L, 381L, 7L, 734L, 224L, 679L, 345L, 82L, 51L, 
         287L, 437L, 691L, 106L, 740L, 366L, 506L, 446L, 71L, 604L, 727L, 194L, 667L, 
         521L, 13L, 33L, 682L, 541L, 569L, 516L, 45L, 638L, 360L, 329L, 26L, 419L, 720L, 
         338L, 477L, 538L, 466L, 96L, 673L, 524L, 292L, 232L, 698L, 179L, 92L, 615L, 217L, 
         375L, 726L, 246L, 293L, 259L, 358L, 520L, 704L, 67L, 714L, 463L, 152L, 361L, 
         531L, 197L, 234L, 255L, 736L, 499L, 418L, 76L, 85L, 105L, 578L, 122L, 312L, 307L, 
         748L, 382L, 147L, 455L, 451L, 157L, 233L, 639L, 658L, 742L, 647L, 618L, 409L, 
         203L, 688L, 594L, 282L, 280L, 414L, 730L, 725L, 257L, 731L, 689L, 484L, 401L, 
         268L, 133L, 317L, 117L, 138L, 342L, 540L, 83L, 146L, 175L, 575L, 456L, 296L, 
         290L, 14L, 768L, 79L, 474L, 188L, 123L, 53L, 362L, 215L, 334L, 674L, 501L, 127L, 
         88L, 663L, 631L, 258L, 283L, 31L, 204L, 438L, 549L, 298L, 130L, 24L, 606L, 527L, 
         220L, 431L, 302L, 104L, 534L, 562L, 636L, 128L, 711L, 354L, 231L, 288L, 142L, 
         324L, 80L, 692L, 627L, 256L, 696L, 55L, 536L, 547L, 713L, 763L, 260L, 143L, 34L, 
         227L, 1L, 500L, 708L, 306L, 703L, 728L, 276L, 207L, 43L, 490L, 155L, 629L, 300L, 
         413L, 744L, 590L, 162L, 609L, 444L, 165L, 633L, 110L, 445L, 335L, 265L, 2L, 99L, 
         311L, 574L, 211L, 552L, 747L, 435L, 743L, 745L, 757L, 462L, 69L, 160L, 279L, 
         40L, 652L, 168L, 149L, 429L, 567L, 284L, 586L, 543L, 452L, 376L, 294L, 388L, 
         50L, 476L, 687L, 74L, 176L, 135L, 523L, 195L, 32L, 47L, 190L, 450L, 473L, 73L, 
         558L, 669L, 518L, 291L, 421L, 210L, 630L, 369L, 119L, 126L, 89L, 144L, 343L, 
         270L, 464L, 320L, 700L, 5L, 186L, 598L, 28L, 485L, 319L, 250L, 30L, 57L, 694L, 
         187L, 384L, 394L, 337L, 10L, 483L, 535L, 114L, 710L, 759L, 441L, 100L, 72L, 585L, 
         116L, 20L, 690L, 410L, 339L, 735L, 214L, 171L, 247L, 699L, 716L, 140L, 225L, 
         397L, 39L, 593L, 678L, 597L, 537L, 6L, 417L, 277L, 412L, 760L, 676L, 701L, 61L, 
         624L, 353L, 331L, 548L, 665L, 761L, 752L, 556L, 281L, 299L, 346L, 46L, 174L, 
         158L, 488L, 637L, 363L, 359L, 173L, 668L, 469L, 478L, 305L, 406L, 365L, 542L, 
         705L, 315L, 308L, 515L, 373L, 134L, 377L, 322L, 385L, 522L, 448L, 608L, 199L, 
         180L, 581L)), test.inds = list(c(1L, 2L, 5L, 6L, 7L, 10L, 13L, 14L, 20L, 24L, 
         26L, 28L, 30L, 31L, 32L, 33L, 34L, 35L, 36L, 38L, 39L, 40L, 43L, 45L, 46L, 47L, 
         50L, 51L, 53L, 55L, 57L, 61L, 67L, 69L, 71L, 72L, 73L, 74L, 76L, 77L, 79L, 80L, 
         82L, 83L, 85L, 88L, 89L, 90L, 91L, 92L, 96L, 98L, 99L, 100L, 104L, 105L, 106L, 
         110L, 114L, 116L, 117L, 119L, 122L, 123L, 126L, 127L, 128L, 130L, 133L, 134L, 
         135L, 138L, 140L, 142L, 143L, 144L, 146L, 147L, 149L, 152L, 153L, 155L, 157L, 
         158L, 160L, 162L, 164L, 165L, 168L, 171L, 173L, 174L, 175L, 176L, 179L, 180L, 
         186L, 187L, 188L, 190L, 191L, 193L, 194L, 195L, 196L, 197L, 199L, 203L, 204L, 
         207L, 210L, 211L, 212L, 213L, 214L, 215L, 217L, 220L, 224L, 225L, 227L, 231L, 
         232L, 233L, 234L, 241L, 246L, 247L, 250L, 252L, 255L, 256L, 257L, 258L, 259L, 
         260L, 265L, 268L, 269L, 270L, 276L, 277L, 279L, 280L, 281L, 282L, 283L, 284L, 
         287L, 288L, 290L, 291L, 292L, 293L, 294L, 296L, 298L, 299L, 300L, 302L, 305L, 
         306L, 307L, 308L, 310L, 311L, 312L, 315L, 317L, 319L, 320L, 321L, 322L, 324L, 
         326L, 329L, 331L, 334L, 335L, 337L, 338L, 339L, 342L, 343L, 345L, 346L, 347L, 
         349L, 353L, 354L, 358L, 359L, 360L, 361L, 362L, 363L, 364L, 365L, 366L, 369L, 
         373L, 375L, 376L, 377L, 381L, 382L, 384L, 385L, 388L, 394L, 397L, 401L, 402L, 
         406L, 409L, 410L, 412L, 413L, 414L, 417L, 418L, 419L, 421L, 424L, 429L, 431L, 
         435L, 437L, 438L, 441L, 444L, 445L, 446L, 448L, 450L, 451L, 452L, 455L, 456L, 
         460L, 462L, 463L, 464L, 466L, 469L, 473L, 474L, 476L, 477L, 478L, 483L, 484L, 
         485L, 488L, 490L, 494L, 499L, 500L, 501L, 506L, 515L, 516L, 518L, 519L, 520L, 
         521L, 522L, 523L, 524L, 527L, 531L, 534L, 535L, 536L, 537L, 538L, 540L, 541L, 
         542L, 543L, 547L, 548L, 549L, 552L, 556L, 558L, 560L, 562L, 567L, 569L, 574L, 
         575L, 578L, 581L, 585L, 586L, 590L, 593L, 594L, 597L, 598L, 604L, 606L, 608L, 
         609L, 613L, 615L, 618L, 619L, 623L, 624L, 627L, 629L, 630L, 631L, 633L, 636L, 
         637L, 638L, 639L, 640L, 647L, 652L, 658L, 663L, 665L, 667L, 668L, 669L, 673L, 
         674L, 676L, 678L, 679L, 682L, 687L, 688L, 689L, 690L, 691L, 692L, 694L, 696L, 
         697L, 698L, 699L, 700L, 701L, 702L, 703L, 704L, 705L, 708L, 710L, 711L, 713L, 
         714L, 716L, 720L, 725L, 726L, 727L, 728L, 730L, 731L, 734L, 735L, 736L, 740L, 
         742L, 743L, 744L, 745L, 747L, 748L, 751L, 752L, 753L, 757L, 759L, 760L, 761L, 
         763L, 768L), c(3L, 4L, 8L, 9L, 11L, 12L, 15L, 16L, 17L, 18L, 19L, 21L, 22L, 23L, 
         25L, 27L, 29L, 37L, 41L, 42L, 44L, 48L, 49L, 52L, 54L, 56L, 58L, 59L, 60L, 62L, 
         63L, 64L, 65L, 66L, 68L, 70L, 75L, 78L, 81L, 84L, 86L, 87L, 93L, 94L, 95L, 97L, 
         101L, 102L, 103L, 107L, 108L, 109L, 111L, 112L, 113L, 115L, 118L, 120L, 121L, 
         124L, 125L, 129L, 131L, 132L, 136L, 137L, 139L, 141L, 145L, 148L, 150L, 151L, 
         154L, 156L, 159L, 161L, 163L, 166L, 167L, 169L, 170L, 172L, 177L, 178L, 181L, 
         182L, 183L, 184L, 185L, 189L, 192L, 198L, 200L, 201L, 202L, 205L, 206L, 208L, 
         209L, 216L, 218L, 219L, 221L, 222L, 223L, 226L, 228L, 229L, 230L, 235L, 236L, 
         237L, 238L, 239L, 240L, 242L, 243L, 244L, 245L, 248L, 249L, 251L, 253L, 254L, 
         261L, 262L, 263L, 264L, 266L, 267L, 271L, 272L, 273L, 274L, 275L, 278L, 285L, 
         286L, 289L, 295L, 297L, 301L, 303L, 304L, 309L, 313L, 314L, 316L, 318L, 323L, 
         325L, 327L, 328L, 330L, 332L, 333L, 336L, 340L, 341L, 344L, 348L, 350L, 351L, 
         352L, 355L, 356L, 357L, 367L, 368L, 370L, 371L, 372L, 374L, 378L, 379L, 380L, 
         383L, 386L, 387L, 389L, 390L, 391L, 392L, 393L, 395L, 396L, 398L, 399L, 400L, 
         403L, 404L, 405L, 407L, 408L, 411L, 415L, 416L, 420L, 422L, 423L, 425L, 426L, 
         427L, 428L, 430L, 432L, 433L, 434L, 436L, 439L, 440L, 442L, 443L, 447L, 449L, 
         453L, 454L, 457L, 458L, 459L, 461L, 465L, 467L, 468L, 470L, 471L, 472L, 475L, 
         479L, 480L, 481L, 482L, 486L, 487L, 489L, 491L, 492L, 493L, 495L, 496L, 497L, 
         498L, 502L, 503L, 504L, 505L, 507L, 508L, 509L, 510L, 511L, 512L, 513L, 514L, 
         517L, 525L, 526L, 528L, 529L, 530L, 532L, 533L, 539L, 544L, 545L, 546L, 550L, 
         551L, 553L, 554L, 555L, 557L, 559L, 561L, 563L, 564L, 565L, 566L, 568L, 570L, 
         571L, 572L, 573L, 576L, 577L, 579L, 580L, 582L, 583L, 584L, 587L, 588L, 589L, 
         591L, 592L, 595L, 596L, 599L, 600L, 601L, 602L, 603L, 605L, 607L, 610L, 611L, 
         612L, 614L, 616L, 617L, 620L, 621L, 622L, 625L, 626L, 628L, 632L, 634L, 635L, 
         641L, 642L, 643L, 644L, 645L, 646L, 648L, 649L, 650L, 651L, 653L, 654L, 655L, 
         656L, 657L, 659L, 660L, 661L, 662L, 664L, 666L, 670L, 671L, 672L, 675L, 677L, 
         680L, 681L, 683L, 684L, 685L, 686L, 693L, 695L, 706L, 707L, 709L, 712L, 715L, 
         717L, 718L, 719L, 721L, 722L, 723L, 724L, 729L, 732L, 733L, 737L, 738L, 739L, 
         741L, 746L, 749L, 750L, 754L, 755L, 756L, 758L, 762L, 764L, 765L, 766L, 767L)), 
         group = structure(integer(0), .Label = character(0), class = "factor")), class = "ResampleInstance"), 
         weights = NULL, measures = list(structure(list(id = "mmce", minimize = TRUE, 
             properties = c("classif", "classif.multi", "req.pred", "req.truth"), fun = function (task, 
                 model, pred, feats, extra.args) 
             {
                 measureMMCE(pred$data$truth, pred$data$response)
             }, extra.args = list(), best = 0, worst = 1, name = "Mean misclassification error", 
             note = "Defined as: mean(response != truth)", aggr = structure(list(id = "test.mean", 
                 name = "Test mean", fun = function (task, perf.test, perf.train, measure, 
                     group, pred) 
                 mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure")), 
         model = FALSE, extract = function (object) 
         {
             assertClass(object, "TuneModel")
             object$learner.model$opt.result
         }, show.info = FALSE)
  5: calculateResampleIterationResult(learner = learner, task = task, i = i, train.i = train.i, 
         test.i = test.i, measures = measures, weights = weights, rdesc = rin$desc, model = model, 
         extract = extract, show.info = show.info)
  6: isFailureModel(m)
  7: isFailureModel.BaseWrapperModel(m)
  8: isFailureModel(model$learner.model$next.model)
  
  ── 45. Error: 1 numeric hyperparam (@test_base_generateHyperParsEffect.R#35)  ──
  argument "def" is missing, with no default
  1: tuneParams("classif.ksvm", task = pid.task, resampling = rdesc, par.set = ps, control = ctrl, 
         measures = acc) at testthat/test_base_generateHyperParsEffect.R:35
  2: sel.func(learner, task, resampling, measures, par.set, control, opt.path, show.info, 
         resample.fun)
  3: evalOptimizationStatesTune(learner, task, resampling, measures, par.set, control, 
         opt.path, show.info, xs, dobs = seq_along(xs), eols = NA_integer_, remove.nas = TRUE, 
         resample.fun = resample.fun)
  4: evalOptimizationStates(learner, task, resampling, measures, par.set, NULL, control, 
         opt.path, show.info, states, dobs, eols, remove.nas, resample.fun, "mlr.tuneParams")
  5: parallelMap(evalOptimizationState, dobs, states, level = level, more.args = list(learner = learner, 
         task = task, resampling = resampling, measures = measures, par.set = par.set, 
         bits.to.features = bits.to.features, control = control, opt.path = opt.path, 
         show.info = show.info, remove.nas = remove.nas, resample.fun = resample.fun))
  6: mapply(fun2, ..., MoreArgs = more.args, SIMPLIFY = FALSE, USE.NAMES = FALSE)
  7: (function (learner, task, resampling, measures, par.set, bits.to.features, control, 
         opt.path, show.info, dob, state, remove.nas, resample.fun) 
     {
         setSlaveOptions()
         y = setNames(rep(NA_real_, length(measures)), vcapply(measures, measureAggrName))
         errmsg = NA_character_
         exec.time = NA_real_
         set.pars.ok = TRUE
         learner2 = learner
         threshold = NULL
         log.fun = control$log.fun
         err.dumps = list()
         if (inherits(control, "TuneControl") || inherits(control, "TuneMultiCritControl")) {
             state = setValueCNames(par.set, state)
             state = trafoValue(par.set, state)
             state2 = if (remove.nas) 
                 removeMissingValues(state)
             else state
             learner2 = try(setHyperPars(learner, par.vals = state2), silent = TRUE)
             if (is.error(learner2)) {
                 set.pars.ok = FALSE
                 errmsg = as.character(learner2)
                 if (show.info) 
                     messagef("[Tune-x] Setting hyperpars failed: %s", errmsg)
             }
         }
         else if (inherits(control, "FeatSelControl")) {
             task = subsetTask(task, features = bits.to.features(state, task))
         }
         if (show.info) 
             prev.stage = log.fun(learner, task, resampling, measures, par.set, control, 
                 opt.path, dob, state, NA_real_, remove.nas, stage = 1L)
         if (set.pars.ok) {
             exec.time = measureTime({
                 r = resample.fun(learner2, task, resampling, measures = measures, show.info = FALSE)
             })
             if (control$tune.threshold) {
                 th.args = control$tune.threshold.args
                 th.args$pred = r$pred
                 th.args$measure = measures[[1L]]
                 tune.th.res = do.call(tuneThreshold, th.args)
                 threshold = tune.th.res$th
                 y = performance(setThreshold(r$pred, threshold = threshold), measures = measures)
                 names(y) = names(r$aggr)
             }
             else {
                 y = r$aggr
             }
             errmsgs = as.character(t(r$err.msgs[, -1L]))
             notna = !is.na(errmsgs)
             if (any(notna)) 
                 errmsg = errmsgs[notna][1L]
             err.dumps = r$err.dumps
         }
         else {
             if (control$tune.threshold) 
                 threshold = NA_real_
         }
         if (show.info) 
             log.fun(learner, task, resampling, measures, par.set, control, opt.path, 
                 dob, state, y, remove.nas, stage = 2L, prev.stage = prev.stage)
         list(y = y, exec.time = exec.time, errmsg = errmsg, threshold = threshold, err.dumps = err.dumps)
     })(dots[[1L]][[1L]], dots[[2L]][[1L]], learner = structure(list(id = "classif.ksvm", 
         type = "classif", package = "kernlab", properties = c("twoclass", "multiclass", 
         "numerics", "factors", "prob", "class.weights"), par.set = structure(list(pars = list(
             scaled = structure(list(id = "scaled", type = "logical", len = 1L, lower = NULL, 
                 upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, 
                 allow.inf = FALSE, has.default = TRUE, default = TRUE, trafo = NULL, 
                 requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), type = structure(list(id = "type", type = "discrete", len = 1L, 
                 lower = NULL, upper = NULL, values = list(`C-svc` = "C-svc", `nu-svc` = "nu-svc", 
                     `C-bsvc` = "C-bsvc", `spoc-svc` = "spoc-svc", `kbb-svc` = "kbb-svc"), 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = "C-svc", 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), kernel = structure(list(
                 id = "kernel", type = "discrete", len = 1L, lower = NULL, upper = NULL, 
                 values = list(vanilladot = "vanilladot", polydot = "polydot", rbfdot = "rbfdot", 
                     tanhdot = "tanhdot", laplacedot = "laplacedot", besseldot = "besseldot", 
                     anovadot = "anovadot", splinedot = "splinedot"), cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = "rbfdot", trafo = NULL, requires = NULL, 
                 tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), C = structure(list(id = "C", type = "numeric", len = 1L, lower = 0, 
                 upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 1, trafo = NULL, requires = type %in% c("C-svc", "C-bsvc", 
                     "spoc-svc", "kbb-svc"), tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), nu = structure(list(id = "nu", type = "numeric", len = 1L, lower = 0, 
                 upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 0.2, trafo = NULL, requires = type == "nu-svc", tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), epsilon = structure(list(id = "epsilon", type = "numeric", len = 1L, 
                 lower = -Inf, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 0.1, trafo = NULL, requires = type %in% 
                     c("eps-svr", "nu-svr", "eps-bsvm"), tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), sigma = structure(list(
                 id = "sigma", type = "numeric", len = 1L, lower = 0, upper = Inf, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, 
                 trafo = NULL, requires = kernel %in% c("rbfdot", "anovadot", "besseldot", 
                     "laplacedot"), tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), degree = structure(list(id = "degree", type = "integer", len = 1L, 
                 lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 3L, trafo = NULL, requires = kernel %in% 
                     c("polydot", "anovadot", "besseldot"), tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), scale = structure(list(
                 id = "scale", type = "numeric", len = 1L, lower = 0, upper = Inf, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 1, trafo = NULL, 
                 requires = kernel %in% c("polydot", "tanhdot"), tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), offset = structure(list(
                 id = "offset", type = "numeric", len = 1L, lower = -Inf, upper = Inf, 
                 values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 1, trafo = NULL, requires = kernel %in% c("polydot", "tanhdot"), 
                 tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), order = structure(list(id = "order", type = "integer", len = 1L, 
                 lower = -Inf, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 1L, trafo = NULL, requires = kernel == 
                     "besseldot", tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), tol = structure(list(id = "tol", type = "numeric", len = 1L, lower = 0, 
                 upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 0.001, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), shrinking = structure(list(
                 id = "shrinking", type = "logical", len = 1L, lower = NULL, upper = NULL, 
                 values = list(`TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = TRUE, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), class.weights = structure(list(id = "class.weights", type = "numericvector", 
                 len = NA_integer_, lower = 0, upper = Inf, values = NULL, cnames = NULL, 
                 allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, 
                 requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), fit = structure(list(id = "fit", type = "logical", len = 1L, lower = NULL, 
                 upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, 
                 allow.inf = FALSE, has.default = TRUE, default = TRUE, trafo = NULL, 
                 requires = NULL, tunable = FALSE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), cache = structure(list(id = "cache", type = "integer", len = 1L, 
                 lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 40L, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             ))), forbidden = NULL), class = c("LearnerParamSet", "ParamSet")), par.vals = list(
             fit = FALSE), predict.type = "response", name = "Support Vector Machines", 
         short.name = "ksvm", note = "Kernel parameters have to be passed directly and not by using the `kpar` list in `ksvm`. Note that `fit` has been set to `FALSE` by default for speed.", 
         callees = "ksvm", help.list = list(sigma = "Argument of: kernlab::ksvm\n\nfor the ANOVA kernel \"anovadot\".", 
             degree = "Argument of: kernlab::ksvm\n\nfor the ANOVA kernel \"anovadot\".", 
             scale = "Argument of: kernlab::ksvm\n\nfor the Hyperbolic tangent kernel function \"tanhdot\"", 
             offset = "Argument of: kernlab::ksvm\n\nfor the Hyperbolic tangent kernel function \"tanhdot\"", 
             order = "Argument of: kernlab::ksvm\n\nfor the Bessel kernel \"besseldot\".", 
             scaled = "Argument of: kernlab::ksvm\n\nA logical vector indicating the variables to be scaled. If scaled is of length 1, the value is recycled as many times as needed and all non-binary variables are scaled. Per default, data are scaled internally (both x and y variables) to zero mean and unit variance. The center and scale values are returned and used for later predictions.", 
             type = "Argument of: kernlab::ksvm\n\nksvm can be used for classification , for regression, or for novelty detection. Depending on whether y is a factor or not, the default setting for type is C-svc or eps-svr, respectively, but can be overwritten by setting an explicit value. Valid options are:\n\nC-svc   C classification\n\nnu-svc  nu classification\n\nC-bsvc  bound-constraint svm classification\n\nspoc-svc  Crammer, Singer native multi-class\n\nkbb-svc  Weston, Watkins native multi-class\n\none-svc  novelty detection\n\neps-svr  epsilon regression\n\nnu-svr   nu regression\n\neps-bsvr  bound-constraint svm regression", 
             kernel = "Argument of: kernlab::ksvm\n\nthe kernel function used in training and predicting. This parameter can be set to any function, of class kernel, which computes the inner product in feature space between two vector arguments (see kernels). kernlab provides the most popular kernel functions which can be used by setting the kernel parameter to the following strings:\n\nrbfdot Radial Basis kernel \"Gaussian\"\n\npolydot Polynomial kernel\n\nvanilladot Linear kernel\n\ntanhdot Hyperbolic tangent kernel\n\nlaplacedot Laplacian kernel\n\nbesseldot Bessel kernel\n\nanovadot ANOVA RBF kernel\n\nsplinedot Spline kernel\n\nstringdot String kernel\n\nSetting the kernel parameter to \"matrix\" treats x as a kernel matrix calling the kernelMatrix interface. The kernel parameter can also be set to a user defined function of class kernel by passing the function name as an argument.", 
             C = "Argument of: kernlab::ksvm\n\ncost of constraints violation (default: 1) this is the ‘C’-constant of the regularization term in the Lagrange formulation.", 
             nu = "Argument of: kernlab::ksvm\n\nparameter needed for nu-svc, one-svc, and nu-svr. The nu parameter sets the upper bound on the training error and the lower bound on the fraction of data points to become Support Vectors (default: 0.2).", 
             epsilon = "Argument of: kernlab::ksvm\n\nepsilon in the insensitive-loss function used for eps-svr, nu-svr and eps-bsvm (default: 0.1)", 
             class.weights = "Argument of: kernlab::ksvm\n\na named vector of weights for the different classes, used for asymmetric class sizes. Not all factor levels have to be supplied (default weight: 1). All components have to be named.", 
             cache = "Argument of: kernlab::ksvm\n\ncache memory in MB (default 40)", 
             tol = "Argument of: kernlab::ksvm\n\ntolerance of termination criterion (default: 0.001)", 
             shrinking = "Argument of: kernlab::ksvm\n\noption whether to use the shrinking-heuristics (default: TRUE)", 
             fit = "Argument of: kernlab::ksvm\n\nindicates whether the fitted values should be computed and included in the model or not (default: TRUE)"), 
         class.weights.param = "class.weights", config = list(), fix.factors.prediction = FALSE), class = c("classif.ksvm", 
     "RLearnerClassif", "RLearner", "Learner")), task = structure(list(type = "classif", 
         env = <environment>, weights = NULL, blocking = NULL, coordinates = NULL, task.desc = structure(list(
             id = "PimaIndiansDiabetes-example", type = "classif", target = "diabetes", 
             size = 768L, n.feat = c(numerics = 8L, factors = 0L, ordered = 0L, functionals = 0L
             ), has.missings = FALSE, has.weights = FALSE, has.blocking = FALSE, has.coordinates = FALSE, 
             class.levels = c("neg", "pos"), positive = "pos", negative = "neg", class.distribution = structure(c(neg = 500L, 
             pos = 268L), .Dim = 2L, .Dimnames = list(c("neg", "pos")), class = "table")), class = c("ClassifTaskDesc", 
         "SupervisedTaskDesc", "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", 
     "Task")), resampling = structure(list(desc = structure(list(split = 0.666666666666667, 
         id = "holdout", iters = 1L, predict = "test", stratify = FALSE), class = c("HoldoutDesc", 
     "ResampleDesc")), size = 768L, train.inds = list(c(221L, 605L, 314L, 676L, 719L, 
     35L, 403L, 680L, 420L, 347L, 726L, 344L, 513L, 433L, 78L, 678L, 186L, 32L, 246L, 
     715L, 666L, 518L, 478L, 741L, 488L, 527L, 404L, 441L, 214L, 109L, 711L, 665L, 509L, 
     585L, 19L, 351L, 556L, 159L, 233L, 169L, 104L, 302L, 301L, 268L, 111L, 101L, 729L, 
     336L, 192L, 617L, 33L, 318L, 573L, 88L, 401L, 148L, 91L, 536L, 636L, 266L, 471L, 
     68L, 272L, 194L, 574L, 316L, 569L, 570L, 557L, 308L, 743L, 439L, 495L, 1L, 330L, 
     153L, 263L, 424L, 243L, 77L, 168L, 459L, 287L, 540L, 71L, 298L, 672L, 609L, 603L, 
     119L, 89L, 443L, 730L, 444L, 216L, 127L, 526L, 63L, 313L, 343L, 714L, 222L, 326L, 
     635L, 321L, 591L, 606L, 762L, 706L, 97L, 616L, 198L, 40L, 621L, 472L, 93L, 359L, 
     622L, 381L, 692L, 760L, 207L, 199L, 142L, 238L, 633L, 99L, 59L, 712L, 745L, 396L, 
     568L, 429L, 469L, 331L, 418L, 520L, 497L, 618L, 277L, 196L, 257L, 7L, 115L, 682L, 
     145L, 149L, 48L, 693L, 454L, 524L, 307L, 239L, 152L, 69L, 240L, 733L, 133L, 660L, 
     611L, 306L, 215L, 394L, 227L, 607L, 322L, 446L, 681L, 248L, 160L, 377L, 110L, 515L, 
     445L, 397L, 367L, 768L, 766L, 517L, 669L, 494L, 184L, 416L, 156L, 348L, 281L, 155L, 
     329L, 530L, 523L, 731L, 752L, 637L, 357L, 539L, 725L, 765L, 598L, 87L, 748L, 136L, 
     546L, 341L, 291L, 228L, 496L, 205L, 162L, 96L, 659L, 269L, 141L, 121L, 375L, 27L, 
     388L, 195L, 226L, 452L, 505L, 582L, 624L, 398L, 555L, 29L, 604L, 259L, 304L, 378L, 
     588L, 333L, 231L, 565L, 751L, 140L, 212L, 106L, 442L, 82L, 426L, 289L, 350L, 640L, 
     538L, 164L, 379L, 209L, 506L, 504L, 685L, 134L, 625L, 764L, 138L, 273L, 661L, 701L, 
     647L, 241L, 531L, 708L, 448L, 342L, 480L, 261L, 290L, 722L, 175L, 11L, 251L, 434L, 
     4L, 36L, 580L, 650L, 363L, 479L, 230L, 37L, 717L, 371L, 67L, 193L, 597L, 544L, 720L, 
     535L, 739L, 554L, 761L, 143L, 49L, 763L, 419L, 358L, 387L, 464L, 477L, 47L, 545L, 
     368L, 5L, 364L, 340L, 293L, 223L, 73L, 631L, 522L, 551L, 179L, 213L, 702L, 26L, 561L, 
     466L, 519L, 108L, 599L, 385L, 383L, 601L, 66L, 663L, 470L, 15L, 736L, 16L, 651L, 
     402L, 271L, 126L, 492L, 493L, 137L, 740L, 727L, 629L, 431L, 648L, 178L, 51L, 225L, 
     560L, 511L, 157L, 415L, 630L, 559L, 262L, 58L, 742L, 543L, 707L, 258L, 408L, 276L, 
     173L, 447L, 521L, 641L, 79L, 365L, 125L, 147L, 703L, 754L, 8L, 163L, 486L, 688L, 
     498L, 757L, 180L, 211L, 579L, 541L, 696L, 732L, 550L, 767L, 295L, 144L, 297L, 691L, 
     612L, 684L, 451L, 490L, 80L, 370L, 112L, 514L, 473L, 656L, 90L, 723L, 38L, 44L, 366L, 
     435L, 427L, 332L, 662L, 386L, 421L, 256L, 30L, 123L, 245L, 114L, 449L, 689L, 177L, 
     98L, 422L, 335L, 113L, 567L, 10L, 191L, 224L, 384L, 571L, 516L, 586L, 728L, 410L, 
     55L, 654L, 323L, 190L, 724L, 334L, 407L, 562L, 563L, 619L, 718L, 54L, 653L, 584L, 
     658L, 581L, 583L, 229L, 652L, 655L, 590L, 589L, 167L, 721L, 356L, 734L, 75L, 279L, 
     254L, 572L, 508L, 39L, 758L, 747L, 645L, 593L, 428L, 83L, 70L, 460L, 85L, 690L, 28L, 
     436L, 673L, 463L, 552L, 131L, 587L, 695L, 64L, 204L, 62L, 234L, 753L, 197L, 265L, 
     694L, 380L, 327L, 390L, 311L, 438L, 20L, 296L, 399L, 24L, 610L, 614L, 14L, 577L, 
     533L, 95L, 354L, 756L, 22L, 710L, 675L, 700L, 132L, 750L, 286L, 120L, 284L)), test.inds = list(
         c(564L, 237L, 393L, 744L, 705L, 260L, 615L, 709L, 60L, 627L, 282L, 150L, 646L, 
         482L, 369L, 12L, 553L, 468L, 283L, 643L, 300L, 671L, 500L, 13L, 677L, 42L, 667L, 
         61L, 467L, 154L, 118L, 252L, 65L, 389L, 501L, 649L, 746L, 698L, 549L, 738L, 484L, 
         475L, 299L, 462L, 218L, 525L, 440L, 575L, 107L, 53L, 172L, 255L, 122L, 759L, 
         270L, 328L, 102L, 151L, 374L, 687L, 613L, 57L, 250L, 491L, 360L, 414L, 3L, 686L, 
         235L, 338L, 339L, 481L, 355L, 425L, 294L, 465L, 628L, 642L, 638L, 737L, 319L, 
         406L, 130L, 409L, 450L, 458L, 542L, 176L, 23L, 461L, 232L, 315L, 171L, 413L, 
         362L, 547L, 317L, 278L, 453L, 503L, 25L, 2L, 208L, 292L, 128L, 43L, 324L, 608L, 
         103L, 312L, 534L, 735L, 596L, 18L, 620L, 210L, 594L, 512L, 626L, 6L, 280L, 600L, 
         373L, 166L, 664L, 755L, 146L, 305L, 352L, 206L, 337L, 713L, 382L, 502L, 576L, 
         139L, 116L, 372L, 249L, 124L, 417L, 566L, 72L, 181L, 9L, 346L, 529L, 430L, 670L, 
         345L, 483L, 185L, 52L, 668L, 412L, 45L, 548L, 253L, 275L, 187L, 41L, 56L, 165L, 
         183L, 201L, 31L, 285L, 81L, 92L, 50L, 639L, 392L, 264L, 361L, 507L, 267L, 135L, 
         325L, 200L, 202L, 632L, 476L, 161L, 405L, 17L, 592L, 129L, 528L, 349L, 455L, 
         489L, 309L, 457L, 395L, 437L, 244L, 105L, 320L, 683L, 558L, 217L, 749L, 499L, 
         400L, 247L, 274L, 188L, 86L, 634L, 174L, 84L, 76L, 117L, 644L, 46L, 699L, 578L, 
         602L, 674L, 236L, 288L, 21L, 411L, 474L, 170L, 74L, 485L, 303L, 242L, 697L, 657L, 
         94L, 716L, 310L, 182L, 423L, 203L, 100L, 532L, 391L, 432L, 704L, 353L, 220L, 
         189L, 679L, 510L, 456L, 487L, 158L, 537L, 376L, 219L, 623L, 34L, 595L)), group = structure(integer(0), .Label = character(0), class = "factor")), class = "ResampleInstance"), 
         measures = list(structure(list(id = "acc", minimize = FALSE, properties = c("classif", 
         "classif.multi", "req.pred", "req.truth"), fun = function (task, model, pred, 
             feats, extra.args) 
         {
             measureACC(pred$data$truth, pred$data$response)
         }, extra.args = list(), best = 1, worst = 0, name = "Accuracy", note = "Defined as: mean(response == truth)", 
             aggr = structure(list(id = "test.mean", name = "Test mean", fun = function (task, 
                 perf.test, perf.train, measure, group, pred) 
             mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure")), 
         par.set = structure(list(pars = list(C = structure(list(id = "C", type = "discrete", 
             len = 1L, lower = NULL, upper = NULL, values = list(`0.25` = 0.25, `0.5` = 0.5, 
                 `1` = 1, `2` = 2, `4` = 4), cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
             default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list()), class = "Param")), 
             forbidden = NULL), class = "ParamSet"), bits.to.features = NULL, control = structure(list(
             same.resampling.instance = TRUE, impute.val = 0, tune.threshold = FALSE, 
             tune.threshold.args = list(), log.fun = function (learner, task, resampling, 
                 measures, par.set, control, opt.path, dob, x, y, remove.nas, stage, prev.stage) 
             {
                 x.string = paramValueToString(par.set, x, show.missing.values = !remove.nas)
                 if (inherits(learner, "ModelMultiplexer")) 
                     x.string = stri_replace_all(x.string, "", regex = stri_paste(x$selected.learner, 
                       "\\."))
                 logFunDefault(learner, task, resampling, measures, par.set, control, 
                     opt.path, dob, x.string, y, remove.nas, stage, prev.stage, prefixes = c("Tune-x", 
                       "Tune-y"))
             }, final.dw.perc = NULL, extra.args = list(resolution = 10L)), class = c("TuneControlGrid", 
         "TuneControl", "OptControl")), opt.path = structure(list(par.set = structure(list(
             pars = list(C = structure(list(id = "C", type = "discrete", len = 1L, lower = NULL, 
                 upper = NULL, values = list(`0.25` = 0.25, `0.5` = 0.5, `1` = 1, `2` = 2, 
                     `4` = 4), cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                 default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list()), class = "Param")), 
             forbidden = NULL), class = "ParamSet"), y.names = "acc.test.mean", minimize = c(acc.test.mean = FALSE), 
             add.transformed.x = FALSE, env = <environment>), class = c("OptPathDF", "OptPath"
         )), show.info = FALSE, remove.nas = TRUE, resample.fun = function (learner, task, 
             resampling, measures, weights = NULL, models = FALSE, extract, keep.pred = TRUE, 
             ..., show.info = getMlrOption("show.info")) 
         {
             learner = checkLearner(learner)
             learner = setHyperPars(learner, ...)
             assertClass(task, classes = "Task")
             n = getTaskSize(task)
             if (inherits(resampling, "ResampleDesc")) 
                 resampling = makeResampleInstance(resampling, task = task)
             assertClass(resampling, classes = "ResampleInstance")
             measures = checkMeasures(measures, task)
             if (!is.null(weights)) {
                 assertNumeric(weights, len = n, any.missing = FALSE, lower = 0)
             }
             assertFlag(models)
             if (missing(extract)) 
                 extract = function(model) {
                 }
             else assertFunction(extract)
             assertFlag(show.info)
             r = resampling$size
             if (n != r) 
                 stop(stri_paste("Size of data set:", n, "and resampling instance:", r, 
                     "differ!", sep = " "))
             checkLearnerBeforeTrain(task, learner, weights)
             checkAggrsBeforeResample(measures, resampling$desc)
             rin = resampling
             more.args = list(learner = learner, task = task, rin = rin, weights = NULL, 
                 measures = measures, model = models, extract = extract, show.info = show.info)
             if (!is.null(weights)) {
                 more.args$weights = weights
             }
             else if (!is.null(getTaskWeights(task))) {
                 more.args$weights = getTaskWeights(task)
             }
             parallelLibrary("mlr", master = FALSE, level = "mlr.resample", show.info = FALSE)
             exportMlrOptions(level = "mlr.resample")
             if (show.info) {
                 messagef("Resampling: %s", rin$desc$id)
                 measure.lognames = extractSubList(measures, "id")
                 if (rin$desc$predict == "both") {
                     id.train = which(vlapply(measures, function(x) "req.train" %in% x$aggr$properties))
                     id.test = which(vlapply(measures, function(x) "req.test" %in% x$aggr$properties))
                     measure.lognames = c(stri_paste(measure.lognames[id.train], "train", 
                       sep = "."), stri_paste(measure.lognames[id.test], "test", sep = "."))
                 }
                 printResampleFormatLine("Measures:", measure.lognames)
             }
             time1 = Sys.time()
             iter.results = parallelMap(doResampleIteration, seq_len(rin$desc$iters), 
                 level = "mlr.resample", more.args = more.args)
             time2 = Sys.time()
             runtime = as.numeric(difftime(time2, time1, units = "secs"))
             addClasses(mergeResampleResult(learner$id, task, iter.results, measures, 
                 rin, models, extract, keep.pred, show.info, runtime), "ResampleResult")
         })
  8: measureTime({
         r = resample.fun(learner2, task, resampling, measures = measures, show.info = FALSE)
     })
  9: force(expr)
  10: resample.fun(learner2, task, resampling, measures = measures, show.info = FALSE)
  11: parallelMap(doResampleIteration, seq_len(rin$desc$iters), level = "mlr.resample", 
         more.args = more.args)
  12: options(parallelMap.nextmap = (getPMOptNextMap() + 1L))
  13: getPMOptNextMap()
  14: getPMOption("nextmap")
  15: getOption(sprintf("parallelMap.%s", opt), def)
  
  ── 46. Error: 1 discrete hyperparam (@test_base_generateHyperParsEffect.R#66)  ─
  argument "def" is missing, with no default
  1: tuneParams("classif.ksvm", task = pid.task, resampling = rdesc, par.set = ps, control = ctrl, 
         measures = acc) at testthat/test_base_generateHyperParsEffect.R:66
  2: sel.func(learner, task, resampling, measures, par.set, control, opt.path, show.info, 
         resample.fun)
  3: evalOptimizationStatesTune(learner, task, resampling, measures, par.set, control, 
         opt.path, show.info, xs, dobs = seq_along(xs), eols = NA_integer_, remove.nas = TRUE, 
         resample.fun = resample.fun)
  4: evalOptimizationStates(learner, task, resampling, measures, par.set, NULL, control, 
         opt.path, show.info, states, dobs, eols, remove.nas, resample.fun, "mlr.tuneParams")
  5: parallelMap(evalOptimizationState, dobs, states, level = level, more.args = list(learner = learner, 
         task = task, resampling = resampling, measures = measures, par.set = par.set, 
         bits.to.features = bits.to.features, control = control, opt.path = opt.path, 
         show.info = show.info, remove.nas = remove.nas, resample.fun = resample.fun))
  6: mapply(fun2, ..., MoreArgs = more.args, SIMPLIFY = FALSE, USE.NAMES = FALSE)
  7: (function (learner, task, resampling, measures, par.set, bits.to.features, control, 
         opt.path, show.info, dob, state, remove.nas, resample.fun) 
     {
         setSlaveOptions()
         y = setNames(rep(NA_real_, length(measures)), vcapply(measures, measureAggrName))
         errmsg = NA_character_
         exec.time = NA_real_
         set.pars.ok = TRUE
         learner2 = learner
         threshold = NULL
         log.fun = control$log.fun
         err.dumps = list()
         if (inherits(control, "TuneControl") || inherits(control, "TuneMultiCritControl")) {
             state = setValueCNames(par.set, state)
             state = trafoValue(par.set, state)
             state2 = if (remove.nas) 
                 removeMissingValues(state)
             else state
             learner2 = try(setHyperPars(learner, par.vals = state2), silent = TRUE)
             if (is.error(learner2)) {
                 set.pars.ok = FALSE
                 errmsg = as.character(learner2)
                 if (show.info) 
                     messagef("[Tune-x] Setting hyperpars failed: %s", errmsg)
             }
         }
         else if (inherits(control, "FeatSelControl")) {
             task = subsetTask(task, features = bits.to.features(state, task))
         }
         if (show.info) 
             prev.stage = log.fun(learner, task, resampling, measures, par.set, control, 
                 opt.path, dob, state, NA_real_, remove.nas, stage = 1L)
         if (set.pars.ok) {
             exec.time = measureTime({
                 r = resample.fun(learner2, task, resampling, measures = measures, show.info = FALSE)
             })
             if (control$tune.threshold) {
                 th.args = control$tune.threshold.args
                 th.args$pred = r$pred
                 th.args$measure = measures[[1L]]
                 tune.th.res = do.call(tuneThreshold, th.args)
                 threshold = tune.th.res$th
                 y = performance(setThreshold(r$pred, threshold = threshold), measures = measures)
                 names(y) = names(r$aggr)
             }
             else {
                 y = r$aggr
             }
             errmsgs = as.character(t(r$err.msgs[, -1L]))
             notna = !is.na(errmsgs)
             if (any(notna)) 
                 errmsg = errmsgs[notna][1L]
             err.dumps = r$err.dumps
         }
         else {
             if (control$tune.threshold) 
                 threshold = NA_real_
         }
         if (show.info) 
             log.fun(learner, task, resampling, measures, par.set, control, opt.path, 
                 dob, state, y, remove.nas, stage = 2L, prev.stage = prev.stage)
         list(y = y, exec.time = exec.time, errmsg = errmsg, threshold = threshold, err.dumps = err.dumps)
     })(dots[[1L]][[1L]], dots[[2L]][[1L]], learner = structure(list(id = "classif.ksvm", 
         type = "classif", package = "kernlab", properties = c("twoclass", "multiclass", 
         "numerics", "factors", "prob", "class.weights"), par.set = structure(list(pars = list(
             scaled = structure(list(id = "scaled", type = "logical", len = 1L, lower = NULL, 
                 upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, 
                 allow.inf = FALSE, has.default = TRUE, default = TRUE, trafo = NULL, 
                 requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), type = structure(list(id = "type", type = "discrete", len = 1L, 
                 lower = NULL, upper = NULL, values = list(`C-svc` = "C-svc", `nu-svc` = "nu-svc", 
                     `C-bsvc` = "C-bsvc", `spoc-svc` = "spoc-svc", `kbb-svc` = "kbb-svc"), 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = "C-svc", 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), kernel = structure(list(
                 id = "kernel", type = "discrete", len = 1L, lower = NULL, upper = NULL, 
                 values = list(vanilladot = "vanilladot", polydot = "polydot", rbfdot = "rbfdot", 
                     tanhdot = "tanhdot", laplacedot = "laplacedot", besseldot = "besseldot", 
                     anovadot = "anovadot", splinedot = "splinedot"), cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = "rbfdot", trafo = NULL, requires = NULL, 
                 tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), C = structure(list(id = "C", type = "numeric", len = 1L, lower = 0, 
                 upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 1, trafo = NULL, requires = type %in% c("C-svc", "C-bsvc", 
                     "spoc-svc", "kbb-svc"), tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), nu = structure(list(id = "nu", type = "numeric", len = 1L, lower = 0, 
                 upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 0.2, trafo = NULL, requires = type == "nu-svc", tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), epsilon = structure(list(id = "epsilon", type = "numeric", len = 1L, 
                 lower = -Inf, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 0.1, trafo = NULL, requires = type %in% 
                     c("eps-svr", "nu-svr", "eps-bsvm"), tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), sigma = structure(list(
                 id = "sigma", type = "numeric", len = 1L, lower = 0, upper = Inf, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, 
                 trafo = NULL, requires = kernel %in% c("rbfdot", "anovadot", "besseldot", 
                     "laplacedot"), tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), degree = structure(list(id = "degree", type = "integer", len = 1L, 
                 lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 3L, trafo = NULL, requires = kernel %in% 
                     c("polydot", "anovadot", "besseldot"), tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), scale = structure(list(
                 id = "scale", type = "numeric", len = 1L, lower = 0, upper = Inf, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 1, trafo = NULL, 
                 requires = kernel %in% c("polydot", "tanhdot"), tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), offset = structure(list(
                 id = "offset", type = "numeric", len = 1L, lower = -Inf, upper = Inf, 
                 values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 1, trafo = NULL, requires = kernel %in% c("polydot", "tanhdot"), 
                 tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), order = structure(list(id = "order", type = "integer", len = 1L, 
                 lower = -Inf, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 1L, trafo = NULL, requires = kernel == 
                     "besseldot", tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), tol = structure(list(id = "tol", type = "numeric", len = 1L, lower = 0, 
                 upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 0.001, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), shrinking = structure(list(
                 id = "shrinking", type = "logical", len = 1L, lower = NULL, upper = NULL, 
                 values = list(`TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = TRUE, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), class.weights = structure(list(id = "class.weights", type = "numericvector", 
                 len = NA_integer_, lower = 0, upper = Inf, values = NULL, cnames = NULL, 
                 allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, 
                 requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), fit = structure(list(id = "fit", type = "logical", len = 1L, lower = NULL, 
                 upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, 
                 allow.inf = FALSE, has.default = TRUE, default = TRUE, trafo = NULL, 
                 requires = NULL, tunable = FALSE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), cache = structure(list(id = "cache", type = "integer", len = 1L, 
                 lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 40L, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             ))), forbidden = NULL), class = c("LearnerParamSet", "ParamSet")), par.vals = list(
             fit = FALSE), predict.type = "response", name = "Support Vector Machines", 
         short.name = "ksvm", note = "Kernel parameters have to be passed directly and not by using the `kpar` list in `ksvm`. Note that `fit` has been set to `FALSE` by default for speed.", 
         callees = "ksvm", help.list = list(sigma = "Argument of: kernlab::ksvm\n\nfor the ANOVA kernel \"anovadot\".", 
             degree = "Argument of: kernlab::ksvm\n\nfor the ANOVA kernel \"anovadot\".", 
             scale = "Argument of: kernlab::ksvm\n\nfor the Hyperbolic tangent kernel function \"tanhdot\"", 
             offset = "Argument of: kernlab::ksvm\n\nfor the Hyperbolic tangent kernel function \"tanhdot\"", 
             order = "Argument of: kernlab::ksvm\n\nfor the Bessel kernel \"besseldot\".", 
             scaled = "Argument of: kernlab::ksvm\n\nA logical vector indicating the variables to be scaled. If scaled is of length 1, the value is recycled as many times as needed and all non-binary variables are scaled. Per default, data are scaled internally (both x and y variables) to zero mean and unit variance. The center and scale values are returned and used for later predictions.", 
             type = "Argument of: kernlab::ksvm\n\nksvm can be used for classification , for regression, or for novelty detection. Depending on whether y is a factor or not, the default setting for type is C-svc or eps-svr, respectively, but can be overwritten by setting an explicit value. Valid options are:\n\nC-svc   C classification\n\nnu-svc  nu classification\n\nC-bsvc  bound-constraint svm classification\n\nspoc-svc  Crammer, Singer native multi-class\n\nkbb-svc  Weston, Watkins native multi-class\n\none-svc  novelty detection\n\neps-svr  epsilon regression\n\nnu-svr   nu regression\n\neps-bsvr  bound-constraint svm regression", 
             kernel = "Argument of: kernlab::ksvm\n\nthe kernel function used in training and predicting. This parameter can be set to any function, of class kernel, which computes the inner product in feature space between two vector arguments (see kernels). kernlab provides the most popular kernel functions which can be used by setting the kernel parameter to the following strings:\n\nrbfdot Radial Basis kernel \"Gaussian\"\n\npolydot Polynomial kernel\n\nvanilladot Linear kernel\n\ntanhdot Hyperbolic tangent kernel\n\nlaplacedot Laplacian kernel\n\nbesseldot Bessel kernel\n\nanovadot ANOVA RBF kernel\n\nsplinedot Spline kernel\n\nstringdot String kernel\n\nSetting the kernel parameter to \"matrix\" treats x as a kernel matrix calling the kernelMatrix interface. The kernel parameter can also be set to a user defined function of class kernel by passing the function name as an argument.", 
             C = "Argument of: kernlab::ksvm\n\ncost of constraints violation (default: 1) this is the ‘C’-constant of the regularization term in the Lagrange formulation.", 
             nu = "Argument of: kernlab::ksvm\n\nparameter needed for nu-svc, one-svc, and nu-svr. The nu parameter sets the upper bound on the training error and the lower bound on the fraction of data points to become Support Vectors (default: 0.2).", 
             epsilon = "Argument of: kernlab::ksvm\n\nepsilon in the insensitive-loss function used for eps-svr, nu-svr and eps-bsvm (default: 0.1)", 
             class.weights = "Argument of: kernlab::ksvm\n\na named vector of weights for the different classes, used for asymmetric class sizes. Not all factor levels have to be supplied (default weight: 1). All components have to be named.", 
             cache = "Argument of: kernlab::ksvm\n\ncache memory in MB (default 40)", 
             tol = "Argument of: kernlab::ksvm\n\ntolerance of termination criterion (default: 0.001)", 
             shrinking = "Argument of: kernlab::ksvm\n\noption whether to use the shrinking-heuristics (default: TRUE)", 
             fit = "Argument of: kernlab::ksvm\n\nindicates whether the fitted values should be computed and included in the model or not (default: TRUE)"), 
         class.weights.param = "class.weights", config = list(), fix.factors.prediction = FALSE), class = c("classif.ksvm", 
     "RLearnerClassif", "RLearner", "Learner")), task = structure(list(type = "classif", 
         env = <environment>, weights = NULL, blocking = NULL, coordinates = NULL, task.desc = structure(list(
             id = "PimaIndiansDiabetes-example", type = "classif", target = "diabetes", 
             size = 768L, n.feat = c(numerics = 8L, factors = 0L, ordered = 0L, functionals = 0L
             ), has.missings = FALSE, has.weights = FALSE, has.blocking = FALSE, has.coordinates = FALSE, 
             class.levels = c("neg", "pos"), positive = "pos", negative = "neg", class.distribution = structure(c(neg = 500L, 
             pos = 268L), .Dim = 2L, .Dimnames = list(c("neg", "pos")), class = "table")), class = c("ClassifTaskDesc", 
         "SupervisedTaskDesc", "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", 
     "Task")), resampling = structure(list(desc = structure(list(split = 0.666666666666667, 
         id = "holdout", iters = 1L, predict = "test", stratify = FALSE), class = c("HoldoutDesc", 
     "ResampleDesc")), size = 768L, train.inds = list(c(221L, 605L, 314L, 676L, 719L, 
     35L, 403L, 680L, 420L, 347L, 726L, 344L, 513L, 433L, 78L, 678L, 186L, 32L, 246L, 
     715L, 666L, 518L, 478L, 741L, 488L, 527L, 404L, 441L, 214L, 109L, 711L, 665L, 509L, 
     585L, 19L, 351L, 556L, 159L, 233L, 169L, 104L, 302L, 301L, 268L, 111L, 101L, 729L, 
     336L, 192L, 617L, 33L, 318L, 573L, 88L, 401L, 148L, 91L, 536L, 636L, 266L, 471L, 
     68L, 272L, 194L, 574L, 316L, 569L, 570L, 557L, 308L, 743L, 439L, 495L, 1L, 330L, 
     153L, 263L, 424L, 243L, 77L, 168L, 459L, 287L, 540L, 71L, 298L, 672L, 609L, 603L, 
     119L, 89L, 443L, 730L, 444L, 216L, 127L, 526L, 63L, 313L, 343L, 714L, 222L, 326L, 
     635L, 321L, 591L, 606L, 762L, 706L, 97L, 616L, 198L, 40L, 621L, 472L, 93L, 359L, 
     622L, 381L, 692L, 760L, 207L, 199L, 142L, 238L, 633L, 99L, 59L, 712L, 745L, 396L, 
     568L, 429L, 469L, 331L, 418L, 520L, 497L, 618L, 277L, 196L, 257L, 7L, 115L, 682L, 
     145L, 149L, 48L, 693L, 454L, 524L, 307L, 239L, 152L, 69L, 240L, 733L, 133L, 660L, 
     611L, 306L, 215L, 394L, 227L, 607L, 322L, 446L, 681L, 248L, 160L, 377L, 110L, 515L, 
     445L, 397L, 367L, 768L, 766L, 517L, 669L, 494L, 184L, 416L, 156L, 348L, 281L, 155L, 
     329L, 530L, 523L, 731L, 752L, 637L, 357L, 539L, 725L, 765L, 598L, 87L, 748L, 136L, 
     546L, 341L, 291L, 228L, 496L, 205L, 162L, 96L, 659L, 269L, 141L, 121L, 375L, 27L, 
     388L, 195L, 226L, 452L, 505L, 582L, 624L, 398L, 555L, 29L, 604L, 259L, 304L, 378L, 
     588L, 333L, 231L, 565L, 751L, 140L, 212L, 106L, 442L, 82L, 426L, 289L, 350L, 640L, 
     538L, 164L, 379L, 209L, 506L, 504L, 685L, 134L, 625L, 764L, 138L, 273L, 661L, 701L, 
     647L, 241L, 531L, 708L, 448L, 342L, 480L, 261L, 290L, 722L, 175L, 11L, 251L, 434L, 
     4L, 36L, 580L, 650L, 363L, 479L, 230L, 37L, 717L, 371L, 67L, 193L, 597L, 544L, 720L, 
     535L, 739L, 554L, 761L, 143L, 49L, 763L, 419L, 358L, 387L, 464L, 477L, 47L, 545L, 
     368L, 5L, 364L, 340L, 293L, 223L, 73L, 631L, 522L, 551L, 179L, 213L, 702L, 26L, 561L, 
     466L, 519L, 108L, 599L, 385L, 383L, 601L, 66L, 663L, 470L, 15L, 736L, 16L, 651L, 
     402L, 271L, 126L, 492L, 493L, 137L, 740L, 727L, 629L, 431L, 648L, 178L, 51L, 225L, 
     560L, 511L, 157L, 415L, 630L, 559L, 262L, 58L, 742L, 543L, 707L, 258L, 408L, 276L, 
     173L, 447L, 521L, 641L, 79L, 365L, 125L, 147L, 703L, 754L, 8L, 163L, 486L, 688L, 
     498L, 757L, 180L, 211L, 579L, 541L, 696L, 732L, 550L, 767L, 295L, 144L, 297L, 691L, 
     612L, 684L, 451L, 490L, 80L, 370L, 112L, 514L, 473L, 656L, 90L, 723L, 38L, 44L, 366L, 
     435L, 427L, 332L, 662L, 386L, 421L, 256L, 30L, 123L, 245L, 114L, 449L, 689L, 177L, 
     98L, 422L, 335L, 113L, 567L, 10L, 191L, 224L, 384L, 571L, 516L, 586L, 728L, 410L, 
     55L, 654L, 323L, 190L, 724L, 334L, 407L, 562L, 563L, 619L, 718L, 54L, 653L, 584L, 
     658L, 581L, 583L, 229L, 652L, 655L, 590L, 589L, 167L, 721L, 356L, 734L, 75L, 279L, 
     254L, 572L, 508L, 39L, 758L, 747L, 645L, 593L, 428L, 83L, 70L, 460L, 85L, 690L, 28L, 
     436L, 673L, 463L, 552L, 131L, 587L, 695L, 64L, 204L, 62L, 234L, 753L, 197L, 265L, 
     694L, 380L, 327L, 390L, 311L, 438L, 20L, 296L, 399L, 24L, 610L, 614L, 14L, 577L, 
     533L, 95L, 354L, 756L, 22L, 710L, 675L, 700L, 132L, 750L, 286L, 120L, 284L)), test.inds = list(
         c(564L, 237L, 393L, 744L, 705L, 260L, 615L, 709L, 60L, 627L, 282L, 150L, 646L, 
         482L, 369L, 12L, 553L, 468L, 283L, 643L, 300L, 671L, 500L, 13L, 677L, 42L, 667L, 
         61L, 467L, 154L, 118L, 252L, 65L, 389L, 501L, 649L, 746L, 698L, 549L, 738L, 484L, 
         475L, 299L, 462L, 218L, 525L, 440L, 575L, 107L, 53L, 172L, 255L, 122L, 759L, 
         270L, 328L, 102L, 151L, 374L, 687L, 613L, 57L, 250L, 491L, 360L, 414L, 3L, 686L, 
         235L, 338L, 339L, 481L, 355L, 425L, 294L, 465L, 628L, 642L, 638L, 737L, 319L, 
         406L, 130L, 409L, 450L, 458L, 542L, 176L, 23L, 461L, 232L, 315L, 171L, 413L, 
         362L, 547L, 317L, 278L, 453L, 503L, 25L, 2L, 208L, 292L, 128L, 43L, 324L, 608L, 
         103L, 312L, 534L, 735L, 596L, 18L, 620L, 210L, 594L, 512L, 626L, 6L, 280L, 600L, 
         373L, 166L, 664L, 755L, 146L, 305L, 352L, 206L, 337L, 713L, 382L, 502L, 576L, 
         139L, 116L, 372L, 249L, 124L, 417L, 566L, 72L, 181L, 9L, 346L, 529L, 430L, 670L, 
         345L, 483L, 185L, 52L, 668L, 412L, 45L, 548L, 253L, 275L, 187L, 41L, 56L, 165L, 
         183L, 201L, 31L, 285L, 81L, 92L, 50L, 639L, 392L, 264L, 361L, 507L, 267L, 135L, 
         325L, 200L, 202L, 632L, 476L, 161L, 405L, 17L, 592L, 129L, 528L, 349L, 455L, 
         489L, 309L, 457L, 395L, 437L, 244L, 105L, 320L, 683L, 558L, 217L, 749L, 499L, 
         400L, 247L, 274L, 188L, 86L, 634L, 174L, 84L, 76L, 117L, 644L, 46L, 699L, 578L, 
         602L, 674L, 236L, 288L, 21L, 411L, 474L, 170L, 74L, 485L, 303L, 242L, 697L, 657L, 
         94L, 716L, 310L, 182L, 423L, 203L, 100L, 532L, 391L, 432L, 704L, 353L, 220L, 
         189L, 679L, 510L, 456L, 487L, 158L, 537L, 376L, 219L, 623L, 34L, 595L)), group = structure(integer(0), .Label = character(0), class = "factor")), class = "ResampleInstance"), 
         measures = list(structure(list(id = "acc", minimize = FALSE, properties = c("classif", 
         "classif.multi", "req.pred", "req.truth"), fun = function (task, model, pred, 
             feats, extra.args) 
         {
             measureACC(pred$data$truth, pred$data$response)
         }, extra.args = list(), best = 1, worst = 0, name = "Accuracy", note = "Defined as: mean(response == truth)", 
             aggr = structure(list(id = "test.mean", name = "Test mean", fun = function (task, 
                 perf.test, perf.train, measure, group, pred) 
             mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure")), 
         par.set = structure(list(pars = list(kernel = structure(list(id = "kernel", type = "discrete", 
             len = 1L, lower = NULL, upper = NULL, values = list(vanilladot = "vanilladot", 
                 polydot = "polydot", rbfdot = "rbfdot"), cnames = NULL, allow.inf = FALSE, 
             has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, 
             special.vals = list()), class = "Param")), forbidden = NULL), class = "ParamSet"), 
         bits.to.features = NULL, control = structure(list(same.resampling.instance = TRUE, 
             impute.val = 0, tune.threshold = FALSE, tune.threshold.args = list(), log.fun = function (learner, 
                 task, resampling, measures, par.set, control, opt.path, dob, x, y, remove.nas, 
                 stage, prev.stage) 
             {
                 x.string = paramValueToString(par.set, x, show.missing.values = !remove.nas)
                 if (inherits(learner, "ModelMultiplexer")) 
                     x.string = stri_replace_all(x.string, "", regex = stri_paste(x$selected.learner, 
                       "\\."))
                 logFunDefault(learner, task, resampling, measures, par.set, control, 
                     opt.path, dob, x.string, y, remove.nas, stage, prev.stage, prefixes = c("Tune-x", 
                       "Tune-y"))
             }, final.dw.perc = NULL, extra.args = list(resolution = 10L)), class = c("TuneControlGrid", 
         "TuneControl", "OptControl")), opt.path = structure(list(par.set = structure(list(
             pars = list(kernel = structure(list(id = "kernel", type = "discrete", len = 1L, 
                 lower = NULL, upper = NULL, values = list(vanilladot = "vanilladot", 
                     polydot = "polydot", rbfdot = "rbfdot"), cnames = NULL, allow.inf = FALSE, 
                 has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list()), class = "Param")), forbidden = NULL), class = "ParamSet"), 
             y.names = "acc.test.mean", minimize = c(acc.test.mean = FALSE), add.transformed.x = FALSE, 
             env = <environment>), class = c("OptPathDF", "OptPath")), show.info = FALSE, 
         remove.nas = TRUE, resample.fun = function (learner, task, resampling, measures, 
             weights = NULL, models = FALSE, extract, keep.pred = TRUE, ..., show.info = getMlrOption("show.info")) 
         {
             learner = checkLearner(learner)
             learner = setHyperPars(learner, ...)
             assertClass(task, classes = "Task")
             n = getTaskSize(task)
             if (inherits(resampling, "ResampleDesc")) 
                 resampling = makeResampleInstance(resampling, task = task)
             assertClass(resampling, classes = "ResampleInstance")
             measures = checkMeasures(measures, task)
             if (!is.null(weights)) {
                 assertNumeric(weights, len = n, any.missing = FALSE, lower = 0)
             }
             assertFlag(models)
             if (missing(extract)) 
                 extract = function(model) {
                 }
             else assertFunction(extract)
             assertFlag(show.info)
             r = resampling$size
             if (n != r) 
                 stop(stri_paste("Size of data set:", n, "and resampling instance:", r, 
                     "differ!", sep = " "))
             checkLearnerBeforeTrain(task, learner, weights)
             checkAggrsBeforeResample(measures, resampling$desc)
             rin = resampling
             more.args = list(learner = learner, task = task, rin = rin, weights = NULL, 
                 measures = measures, model = models, extract = extract, show.info = show.info)
             if (!is.null(weights)) {
                 more.args$weights = weights
             }
             else if (!is.null(getTaskWeights(task))) {
                 more.args$weights = getTaskWeights(task)
             }
             parallelLibrary("mlr", master = FALSE, level = "mlr.resample", show.info = FALSE)
             exportMlrOptions(level = "mlr.resample")
             if (show.info) {
                 messagef("Resampling: %s", rin$desc$id)
                 measure.lognames = extractSubList(measures, "id")
                 if (rin$desc$predict == "both") {
                     id.train = which(vlapply(measures, function(x) "req.train" %in% x$aggr$properties))
                     id.test = which(vlapply(measures, function(x) "req.test" %in% x$aggr$properties))
                     measure.lognames = c(stri_paste(measure.lognames[id.train], "train", 
                       sep = "."), stri_paste(measure.lognames[id.test], "test", sep = "."))
                 }
                 printResampleFormatLine("Measures:", measure.lognames)
             }
             time1 = Sys.time()
             iter.results = parallelMap(doResampleIteration, seq_len(rin$desc$iters), 
                 level = "mlr.resample", more.args = more.args)
             time2 = Sys.time()
             runtime = as.numeric(difftime(time2, time1, units = "secs"))
             addClasses(mergeResampleResult(learner$id, task, iter.results, measures, 
                 rin, models, extract, keep.pred, show.info, runtime), "ResampleResult")
         })
  8: measureTime({
         r = resample.fun(learner2, task, resampling, measures = measures, show.info = FALSE)
     })
  9: force(expr)
  10: resample.fun(learner2, task, resampling, measures = measures, show.info = FALSE)
  11: parallelMap(doResampleIteration, seq_len(rin$desc$iters), level = "mlr.resample", 
         more.args = more.args)
  12: options(parallelMap.nextmap = (getPMOptNextMap() + 1L))
  13: getPMOptNextMap()
  14: getPMOption("nextmap")
  15: getOption(sprintf("parallelMap.%s", opt), def)
  
  ── 47. Error: 1 numeric hyperparam with optimizer failure (@test_base_generateHy
  argument "def" is missing, with no default
  1: tuneParams("classif.ksvm", task = pid.task, resampling = rdesc, par.set = ps, control = ctrl, 
         measures = acc) at testthat/test_base_generateHyperParsEffect.R:94
  2: sel.func(learner, task, resampling, measures, par.set, control, opt.path, show.info, 
         resample.fun)
  3: evalOptimizationStatesTune(learner, task, resampling, measures, par.set, control, 
         opt.path, show.info, xs, dobs = seq_along(xs), eols = NA_integer_, remove.nas = TRUE, 
         resample.fun = resample.fun)
  4: evalOptimizationStates(learner, task, resampling, measures, par.set, NULL, control, 
         opt.path, show.info, states, dobs, eols, remove.nas, resample.fun, "mlr.tuneParams")
  5: parallelMap(evalOptimizationState, dobs, states, level = level, more.args = list(learner = learner, 
         task = task, resampling = resampling, measures = measures, par.set = par.set, 
         bits.to.features = bits.to.features, control = control, opt.path = opt.path, 
         show.info = show.info, remove.nas = remove.nas, resample.fun = resample.fun))
  6: mapply(fun2, ..., MoreArgs = more.args, SIMPLIFY = FALSE, USE.NAMES = FALSE)
  7: (function (learner, task, resampling, measures, par.set, bits.to.features, control, 
         opt.path, show.info, dob, state, remove.nas, resample.fun) 
     {
         setSlaveOptions()
         y = setNames(rep(NA_real_, length(measures)), vcapply(measures, measureAggrName))
         errmsg = NA_character_
         exec.time = NA_real_
         set.pars.ok = TRUE
         learner2 = learner
         threshold = NULL
         log.fun = control$log.fun
         err.dumps = list()
         if (inherits(control, "TuneControl") || inherits(control, "TuneMultiCritControl")) {
             state = setValueCNames(par.set, state)
             state = trafoValue(par.set, state)
             state2 = if (remove.nas) 
                 removeMissingValues(state)
             else state
             learner2 = try(setHyperPars(learner, par.vals = state2), silent = TRUE)
             if (is.error(learner2)) {
                 set.pars.ok = FALSE
                 errmsg = as.character(learner2)
                 if (show.info) 
                     messagef("[Tune-x] Setting hyperpars failed: %s", errmsg)
             }
         }
         else if (inherits(control, "FeatSelControl")) {
             task = subsetTask(task, features = bits.to.features(state, task))
         }
         if (show.info) 
             prev.stage = log.fun(learner, task, resampling, measures, par.set, control, 
                 opt.path, dob, state, NA_real_, remove.nas, stage = 1L)
         if (set.pars.ok) {
             exec.time = measureTime({
                 r = resample.fun(learner2, task, resampling, measures = measures, show.info = FALSE)
             })
             if (control$tune.threshold) {
                 th.args = control$tune.threshold.args
                 th.args$pred = r$pred
                 th.args$measure = measures[[1L]]
                 tune.th.res = do.call(tuneThreshold, th.args)
                 threshold = tune.th.res$th
                 y = performance(setThreshold(r$pred, threshold = threshold), measures = measures)
                 names(y) = names(r$aggr)
             }
             else {
                 y = r$aggr
             }
             errmsgs = as.character(t(r$err.msgs[, -1L]))
             notna = !is.na(errmsgs)
             if (any(notna)) 
                 errmsg = errmsgs[notna][1L]
             err.dumps = r$err.dumps
         }
         else {
             if (control$tune.threshold) 
                 threshold = NA_real_
         }
         if (show.info) 
             log.fun(learner, task, resampling, measures, par.set, control, opt.path, 
                 dob, state, y, remove.nas, stage = 2L, prev.stage = prev.stage)
         list(y = y, exec.time = exec.time, errmsg = errmsg, threshold = threshold, err.dumps = err.dumps)
     })(dots[[1L]][[2L]], dots[[2L]][[2L]], learner = structure(list(id = "classif.ksvm", 
         type = "classif", package = "kernlab", properties = c("twoclass", "multiclass", 
         "numerics", "factors", "prob", "class.weights"), par.set = structure(list(pars = list(
             scaled = structure(list(id = "scaled", type = "logical", len = 1L, lower = NULL, 
                 upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, 
                 allow.inf = FALSE, has.default = TRUE, default = TRUE, trafo = NULL, 
                 requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), type = structure(list(id = "type", type = "discrete", len = 1L, 
                 lower = NULL, upper = NULL, values = list(`C-svc` = "C-svc", `nu-svc` = "nu-svc", 
                     `C-bsvc` = "C-bsvc", `spoc-svc` = "spoc-svc", `kbb-svc` = "kbb-svc"), 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = "C-svc", 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), kernel = structure(list(
                 id = "kernel", type = "discrete", len = 1L, lower = NULL, upper = NULL, 
                 values = list(vanilladot = "vanilladot", polydot = "polydot", rbfdot = "rbfdot", 
                     tanhdot = "tanhdot", laplacedot = "laplacedot", besseldot = "besseldot", 
                     anovadot = "anovadot", splinedot = "splinedot"), cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = "rbfdot", trafo = NULL, requires = NULL, 
                 tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), C = structure(list(id = "C", type = "numeric", len = 1L, lower = 0, 
                 upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 1, trafo = NULL, requires = type %in% c("C-svc", "C-bsvc", 
                     "spoc-svc", "kbb-svc"), tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), nu = structure(list(id = "nu", type = "numeric", len = 1L, lower = 0, 
                 upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 0.2, trafo = NULL, requires = type == "nu-svc", tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), epsilon = structure(list(id = "epsilon", type = "numeric", len = 1L, 
                 lower = -Inf, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 0.1, trafo = NULL, requires = type %in% 
                     c("eps-svr", "nu-svr", "eps-bsvm"), tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), sigma = structure(list(
                 id = "sigma", type = "numeric", len = 1L, lower = 0, upper = Inf, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, 
                 trafo = NULL, requires = kernel %in% c("rbfdot", "anovadot", "besseldot", 
                     "laplacedot"), tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), degree = structure(list(id = "degree", type = "integer", len = 1L, 
                 lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 3L, trafo = NULL, requires = kernel %in% 
                     c("polydot", "anovadot", "besseldot"), tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), scale = structure(list(
                 id = "scale", type = "numeric", len = 1L, lower = 0, upper = Inf, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 1, trafo = NULL, 
                 requires = kernel %in% c("polydot", "tanhdot"), tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), offset = structure(list(
                 id = "offset", type = "numeric", len = 1L, lower = -Inf, upper = Inf, 
                 values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 1, trafo = NULL, requires = kernel %in% c("polydot", "tanhdot"), 
                 tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), order = structure(list(id = "order", type = "integer", len = 1L, 
                 lower = -Inf, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 1L, trafo = NULL, requires = kernel == 
                     "besseldot", tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), tol = structure(list(id = "tol", type = "numeric", len = 1L, lower = 0, 
                 upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 0.001, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), shrinking = structure(list(
                 id = "shrinking", type = "logical", len = 1L, lower = NULL, upper = NULL, 
                 values = list(`TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = TRUE, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), class.weights = structure(list(id = "class.weights", type = "numericvector", 
                 len = NA_integer_, lower = 0, upper = Inf, values = NULL, cnames = NULL, 
                 allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, 
                 requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), fit = structure(list(id = "fit", type = "logical", len = 1L, lower = NULL, 
                 upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, 
                 allow.inf = FALSE, has.default = TRUE, default = TRUE, trafo = NULL, 
                 requires = NULL, tunable = FALSE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), cache = structure(list(id = "cache", type = "integer", len = 1L, 
                 lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 40L, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             ))), forbidden = NULL), class = c("LearnerParamSet", "ParamSet")), par.vals = list(
             fit = FALSE), predict.type = "response", name = "Support Vector Machines", 
         short.name = "ksvm", note = "Kernel parameters have to be passed directly and not by using the `kpar` list in `ksvm`. Note that `fit` has been set to `FALSE` by default for speed.", 
         callees = "ksvm", help.list = list(sigma = "Argument of: kernlab::ksvm\n\nfor the ANOVA kernel \"anovadot\".", 
             degree = "Argument of: kernlab::ksvm\n\nfor the ANOVA kernel \"anovadot\".", 
             scale = "Argument of: kernlab::ksvm\n\nfor the Hyperbolic tangent kernel function \"tanhdot\"", 
             offset = "Argument of: kernlab::ksvm\n\nfor the Hyperbolic tangent kernel function \"tanhdot\"", 
             order = "Argument of: kernlab::ksvm\n\nfor the Bessel kernel \"besseldot\".", 
             scaled = "Argument of: kernlab::ksvm\n\nA logical vector indicating the variables to be scaled. If scaled is of length 1, the value is recycled as many times as needed and all non-binary variables are scaled. Per default, data are scaled internally (both x and y variables) to zero mean and unit variance. The center and scale values are returned and used for later predictions.", 
             type = "Argument of: kernlab::ksvm\n\nksvm can be used for classification , for regression, or for novelty detection. Depending on whether y is a factor or not, the default setting for type is C-svc or eps-svr, respectively, but can be overwritten by setting an explicit value. Valid options are:\n\nC-svc   C classification\n\nnu-svc  nu classification\n\nC-bsvc  bound-constraint svm classification\n\nspoc-svc  Crammer, Singer native multi-class\n\nkbb-svc  Weston, Watkins native multi-class\n\none-svc  novelty detection\n\neps-svr  epsilon regression\n\nnu-svr   nu regression\n\neps-bsvr  bound-constraint svm regression", 
             kernel = "Argument of: kernlab::ksvm\n\nthe kernel function used in training and predicting. This parameter can be set to any function, of class kernel, which computes the inner product in feature space between two vector arguments (see kernels). kernlab provides the most popular kernel functions which can be used by setting the kernel parameter to the following strings:\n\nrbfdot Radial Basis kernel \"Gaussian\"\n\npolydot Polynomial kernel\n\nvanilladot Linear kernel\n\ntanhdot Hyperbolic tangent kernel\n\nlaplacedot Laplacian kernel\n\nbesseldot Bessel kernel\n\nanovadot ANOVA RBF kernel\n\nsplinedot Spline kernel\n\nstringdot String kernel\n\nSetting the kernel parameter to \"matrix\" treats x as a kernel matrix calling the kernelMatrix interface. The kernel parameter can also be set to a user defined function of class kernel by passing the function name as an argument.", 
             C = "Argument of: kernlab::ksvm\n\ncost of constraints violation (default: 1) this is the ‘C’-constant of the regularization term in the Lagrange formulation.", 
             nu = "Argument of: kernlab::ksvm\n\nparameter needed for nu-svc, one-svc, and nu-svr. The nu parameter sets the upper bound on the training error and the lower bound on the fraction of data points to become Support Vectors (default: 0.2).", 
             epsilon = "Argument of: kernlab::ksvm\n\nepsilon in the insensitive-loss function used for eps-svr, nu-svr and eps-bsvm (default: 0.1)", 
             class.weights = "Argument of: kernlab::ksvm\n\na named vector of weights for the different classes, used for asymmetric class sizes. Not all factor levels have to be supplied (default weight: 1). All components have to be named.", 
             cache = "Argument of: kernlab::ksvm\n\ncache memory in MB (default 40)", 
             tol = "Argument of: kernlab::ksvm\n\ntolerance of termination criterion (default: 0.001)", 
             shrinking = "Argument of: kernlab::ksvm\n\noption whether to use the shrinking-heuristics (default: TRUE)", 
             fit = "Argument of: kernlab::ksvm\n\nindicates whether the fitted values should be computed and included in the model or not (default: TRUE)"), 
         class.weights.param = "class.weights", config = list(), fix.factors.prediction = FALSE), class = c("classif.ksvm", 
     "RLearnerClassif", "RLearner", "Learner")), task = structure(list(type = "classif", 
         env = <environment>, weights = NULL, blocking = NULL, coordinates = NULL, task.desc = structure(list(
             id = "PimaIndiansDiabetes-example", type = "classif", target = "diabetes", 
             size = 768L, n.feat = c(numerics = 8L, factors = 0L, ordered = 0L, functionals = 0L
             ), has.missings = FALSE, has.weights = FALSE, has.blocking = FALSE, has.coordinates = FALSE, 
             class.levels = c("neg", "pos"), positive = "pos", negative = "neg", class.distribution = structure(c(neg = 500L, 
             pos = 268L), .Dim = 2L, .Dimnames = list(c("neg", "pos")), class = "table")), class = c("ClassifTaskDesc", 
         "SupervisedTaskDesc", "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", 
     "Task")), resampling = structure(list(desc = structure(list(split = 0.666666666666667, 
         id = "holdout", iters = 1L, predict = "test", stratify = FALSE), class = c("HoldoutDesc", 
     "ResampleDesc")), size = 768L, train.inds = list(c(221L, 605L, 314L, 676L, 719L, 
     35L, 403L, 680L, 420L, 347L, 726L, 344L, 513L, 433L, 78L, 678L, 186L, 32L, 246L, 
     715L, 666L, 518L, 478L, 741L, 488L, 527L, 404L, 441L, 214L, 109L, 711L, 665L, 509L, 
     585L, 19L, 351L, 556L, 159L, 233L, 169L, 104L, 302L, 301L, 268L, 111L, 101L, 729L, 
     336L, 192L, 617L, 33L, 318L, 573L, 88L, 401L, 148L, 91L, 536L, 636L, 266L, 471L, 
     68L, 272L, 194L, 574L, 316L, 569L, 570L, 557L, 308L, 743L, 439L, 495L, 1L, 330L, 
     153L, 263L, 424L, 243L, 77L, 168L, 459L, 287L, 540L, 71L, 298L, 672L, 609L, 603L, 
     119L, 89L, 443L, 730L, 444L, 216L, 127L, 526L, 63L, 313L, 343L, 714L, 222L, 326L, 
     635L, 321L, 591L, 606L, 762L, 706L, 97L, 616L, 198L, 40L, 621L, 472L, 93L, 359L, 
     622L, 381L, 692L, 760L, 207L, 199L, 142L, 238L, 633L, 99L, 59L, 712L, 745L, 396L, 
     568L, 429L, 469L, 331L, 418L, 520L, 497L, 618L, 277L, 196L, 257L, 7L, 115L, 682L, 
     145L, 149L, 48L, 693L, 454L, 524L, 307L, 239L, 152L, 69L, 240L, 733L, 133L, 660L, 
     611L, 306L, 215L, 394L, 227L, 607L, 322L, 446L, 681L, 248L, 160L, 377L, 110L, 515L, 
     445L, 397L, 367L, 768L, 766L, 517L, 669L, 494L, 184L, 416L, 156L, 348L, 281L, 155L, 
     329L, 530L, 523L, 731L, 752L, 637L, 357L, 539L, 725L, 765L, 598L, 87L, 748L, 136L, 
     546L, 341L, 291L, 228L, 496L, 205L, 162L, 96L, 659L, 269L, 141L, 121L, 375L, 27L, 
     388L, 195L, 226L, 452L, 505L, 582L, 624L, 398L, 555L, 29L, 604L, 259L, 304L, 378L, 
     588L, 333L, 231L, 565L, 751L, 140L, 212L, 106L, 442L, 82L, 426L, 289L, 350L, 640L, 
     538L, 164L, 379L, 209L, 506L, 504L, 685L, 134L, 625L, 764L, 138L, 273L, 661L, 701L, 
     647L, 241L, 531L, 708L, 448L, 342L, 480L, 261L, 290L, 722L, 175L, 11L, 251L, 434L, 
     4L, 36L, 580L, 650L, 363L, 479L, 230L, 37L, 717L, 371L, 67L, 193L, 597L, 544L, 720L, 
     535L, 739L, 554L, 761L, 143L, 49L, 763L, 419L, 358L, 387L, 464L, 477L, 47L, 545L, 
     368L, 5L, 364L, 340L, 293L, 223L, 73L, 631L, 522L, 551L, 179L, 213L, 702L, 26L, 561L, 
     466L, 519L, 108L, 599L, 385L, 383L, 601L, 66L, 663L, 470L, 15L, 736L, 16L, 651L, 
     402L, 271L, 126L, 492L, 493L, 137L, 740L, 727L, 629L, 431L, 648L, 178L, 51L, 225L, 
     560L, 511L, 157L, 415L, 630L, 559L, 262L, 58L, 742L, 543L, 707L, 258L, 408L, 276L, 
     173L, 447L, 521L, 641L, 79L, 365L, 125L, 147L, 703L, 754L, 8L, 163L, 486L, 688L, 
     498L, 757L, 180L, 211L, 579L, 541L, 696L, 732L, 550L, 767L, 295L, 144L, 297L, 691L, 
     612L, 684L, 451L, 490L, 80L, 370L, 112L, 514L, 473L, 656L, 90L, 723L, 38L, 44L, 366L, 
     435L, 427L, 332L, 662L, 386L, 421L, 256L, 30L, 123L, 245L, 114L, 449L, 689L, 177L, 
     98L, 422L, 335L, 113L, 567L, 10L, 191L, 224L, 384L, 571L, 516L, 586L, 728L, 410L, 
     55L, 654L, 323L, 190L, 724L, 334L, 407L, 562L, 563L, 619L, 718L, 54L, 653L, 584L, 
     658L, 581L, 583L, 229L, 652L, 655L, 590L, 589L, 167L, 721L, 356L, 734L, 75L, 279L, 
     254L, 572L, 508L, 39L, 758L, 747L, 645L, 593L, 428L, 83L, 70L, 460L, 85L, 690L, 28L, 
     436L, 673L, 463L, 552L, 131L, 587L, 695L, 64L, 204L, 62L, 234L, 753L, 197L, 265L, 
     694L, 380L, 327L, 390L, 311L, 438L, 20L, 296L, 399L, 24L, 610L, 614L, 14L, 577L, 
     533L, 95L, 354L, 756L, 22L, 710L, 675L, 700L, 132L, 750L, 286L, 120L, 284L)), test.inds = list(
         c(564L, 237L, 393L, 744L, 705L, 260L, 615L, 709L, 60L, 627L, 282L, 150L, 646L, 
         482L, 369L, 12L, 553L, 468L, 283L, 643L, 300L, 671L, 500L, 13L, 677L, 42L, 667L, 
         61L, 467L, 154L, 118L, 252L, 65L, 389L, 501L, 649L, 746L, 698L, 549L, 738L, 484L, 
         475L, 299L, 462L, 218L, 525L, 440L, 575L, 107L, 53L, 172L, 255L, 122L, 759L, 
         270L, 328L, 102L, 151L, 374L, 687L, 613L, 57L, 250L, 491L, 360L, 414L, 3L, 686L, 
         235L, 338L, 339L, 481L, 355L, 425L, 294L, 465L, 628L, 642L, 638L, 737L, 319L, 
         406L, 130L, 409L, 450L, 458L, 542L, 176L, 23L, 461L, 232L, 315L, 171L, 413L, 
         362L, 547L, 317L, 278L, 453L, 503L, 25L, 2L, 208L, 292L, 128L, 43L, 324L, 608L, 
         103L, 312L, 534L, 735L, 596L, 18L, 620L, 210L, 594L, 512L, 626L, 6L, 280L, 600L, 
         373L, 166L, 664L, 755L, 146L, 305L, 352L, 206L, 337L, 713L, 382L, 502L, 576L, 
         139L, 116L, 372L, 249L, 124L, 417L, 566L, 72L, 181L, 9L, 346L, 529L, 430L, 670L, 
         345L, 483L, 185L, 52L, 668L, 412L, 45L, 548L, 253L, 275L, 187L, 41L, 56L, 165L, 
         183L, 201L, 31L, 285L, 81L, 92L, 50L, 639L, 392L, 264L, 361L, 507L, 267L, 135L, 
         325L, 200L, 202L, 632L, 476L, 161L, 405L, 17L, 592L, 129L, 528L, 349L, 455L, 
         489L, 309L, 457L, 395L, 437L, 244L, 105L, 320L, 683L, 558L, 217L, 749L, 499L, 
         400L, 247L, 274L, 188L, 86L, 634L, 174L, 84L, 76L, 117L, 644L, 46L, 699L, 578L, 
         602L, 674L, 236L, 288L, 21L, 411L, 474L, 170L, 74L, 485L, 303L, 242L, 697L, 657L, 
         94L, 716L, 310L, 182L, 423L, 203L, 100L, 532L, 391L, 432L, 704L, 353L, 220L, 
         189L, 679L, 510L, 456L, 487L, 158L, 537L, 376L, 219L, 623L, 34L, 595L)), group = structure(integer(0), .Label = character(0), class = "factor")), class = "ResampleInstance"), 
         measures = list(structure(list(id = "acc", minimize = FALSE, properties = c("classif", 
         "classif.multi", "req.pred", "req.truth"), fun = function (task, model, pred, 
             feats, extra.args) 
         {
             measureACC(pred$data$truth, pred$data$response)
         }, extra.args = list(), best = 1, worst = 0, name = "Accuracy", note = "Defined as: mean(response == truth)", 
             aggr = structure(list(id = "test.mean", name = "Test mean", fun = function (task, 
                 perf.test, perf.train, measure, group, pred) 
             mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure")), 
         par.set = structure(list(pars = list(C = structure(list(id = "C", type = "discrete", 
             len = 1L, lower = NULL, upper = NULL, values = list(`-1` = -1, `0.5` = 0.5, 
                 `1.5` = 1.5), cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
             default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list()), class = "Param")), 
             forbidden = NULL), class = "ParamSet"), bits.to.features = NULL, control = structure(list(
             same.resampling.instance = TRUE, impute.val = 0, tune.threshold = FALSE, 
             tune.threshold.args = list(), log.fun = function (learner, task, resampling, 
                 measures, par.set, control, opt.path, dob, x, y, remove.nas, stage, prev.stage) 
             {
                 x.string = paramValueToString(par.set, x, show.missing.values = !remove.nas)
                 if (inherits(learner, "ModelMultiplexer")) 
                     x.string = stri_replace_all(x.string, "", regex = stri_paste(x$selected.learner, 
                       "\\."))
                 logFunDefault(learner, task, resampling, measures, par.set, control, 
                     opt.path, dob, x.string, y, remove.nas, stage, prev.stage, prefixes = c("Tune-x", 
                       "Tune-y"))
             }, final.dw.perc = NULL, extra.args = list(resolution = 10L)), class = c("TuneControlGrid", 
         "TuneControl", "OptControl")), opt.path = structure(list(par.set = structure(list(
             pars = list(C = structure(list(id = "C", type = "discrete", len = 1L, lower = NULL, 
                 upper = NULL, values = list(`-1` = -1, `0.5` = 0.5, `1.5` = 1.5), cnames = NULL, 
                 allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, 
                 requires = NULL, tunable = TRUE, special.vals = list()), class = "Param")), 
             forbidden = NULL), class = "ParamSet"), y.names = "acc.test.mean", minimize = c(acc.test.mean = FALSE), 
             add.transformed.x = FALSE, env = <environment>), class = c("OptPathDF", "OptPath"
         )), show.info = FALSE, remove.nas = TRUE, resample.fun = function (learner, task, 
             resampling, measures, weights = NULL, models = FALSE, extract, keep.pred = TRUE, 
             ..., show.info = getMlrOption("show.info")) 
         {
             learner = checkLearner(learner)
             learner = setHyperPars(learner, ...)
             assertClass(task, classes = "Task")
             n = getTaskSize(task)
             if (inherits(resampling, "ResampleDesc")) 
                 resampling = makeResampleInstance(resampling, task = task)
             assertClass(resampling, classes = "ResampleInstance")
             measures = checkMeasures(measures, task)
             if (!is.null(weights)) {
                 assertNumeric(weights, len = n, any.missing = FALSE, lower = 0)
             }
             assertFlag(models)
             if (missing(extract)) 
                 extract = function(model) {
                 }
             else assertFunction(extract)
             assertFlag(show.info)
             r = resampling$size
             if (n != r) 
                 stop(stri_paste("Size of data set:", n, "and resampling instance:", r, 
                     "differ!", sep = " "))
             checkLearnerBeforeTrain(task, learner, weights)
             checkAggrsBeforeResample(measures, resampling$desc)
             rin = resampling
             more.args = list(learner = learner, task = task, rin = rin, weights = NULL, 
                 measures = measures, model = models, extract = extract, show.info = show.info)
             if (!is.null(weights)) {
                 more.args$weights = weights
             }
             else if (!is.null(getTaskWeights(task))) {
                 more.args$weights = getTaskWeights(task)
             }
             parallelLibrary("mlr", master = FALSE, level = "mlr.resample", show.info = FALSE)
             exportMlrOptions(level = "mlr.resample")
             if (show.info) {
                 messagef("Resampling: %s", rin$desc$id)
                 measure.lognames = extractSubList(measures, "id")
                 if (rin$desc$predict == "both") {
                     id.train = which(vlapply(measures, function(x) "req.train" %in% x$aggr$properties))
                     id.test = which(vlapply(measures, function(x) "req.test" %in% x$aggr$properties))
                     measure.lognames = c(stri_paste(measure.lognames[id.train], "train", 
                       sep = "."), stri_paste(measure.lognames[id.test], "test", sep = "."))
                 }
                 printResampleFormatLine("Measures:", measure.lognames)
             }
             time1 = Sys.time()
             iter.results = parallelMap(doResampleIteration, seq_len(rin$desc$iters), 
                 level = "mlr.resample", more.args = more.args)
             time2 = Sys.time()
             runtime = as.numeric(difftime(time2, time1, units = "secs"))
             addClasses(mergeResampleResult(learner$id, task, iter.results, measures, 
                 rin, models, extract, keep.pred, show.info, runtime), "ResampleResult")
         })
  8: measureTime({
         r = resample.fun(learner2, task, resampling, measures = measures, show.info = FALSE)
     })
  9: force(expr)
  10: resample.fun(learner2, task, resampling, measures = measures, show.info = FALSE)
  11: parallelMap(doResampleIteration, seq_len(rin$desc$iters), level = "mlr.resample", 
         more.args = more.args)
  12: options(parallelMap.nextmap = (getPMOptNextMap() + 1L))
  13: getPMOptNextMap()
  14: getPMOption("nextmap")
  15: getOption(sprintf("parallelMap.%s", opt), def)
  
  ── 48. Error: 1 numeric hyperparam with nested cv (@test_base_generateHyperParsE
  $ operator is invalid for atomic vectors
  1: resample(lrn, task = pid.task, resampling = cv2, extract = getTuneResult) at testthat/test_base_generateHyperParsEffect.R:126
  2: parallelMap(doResampleIteration, seq_len(rin$desc$iters), level = "mlr.resample", 
         more.args = more.args)
  3: mapply(fun2, ..., MoreArgs = more.args, SIMPLIFY = FALSE, USE.NAMES = FALSE)
  4: (function (learner, task, rin, i, measures, weights, model, extract, show.info) 
     {
         setSlaveOptions()
         train.i = rin$train.inds[[i]]
         test.i = rin$test.inds[[i]]
         calculateResampleIterationResult(learner = learner, task = task, i = i, train.i = train.i, 
             test.i = test.i, measures = measures, weights = weights, rdesc = rin$desc, 
             model = model, extract = extract, show.info = show.info)
     })(dots[[1L]][[1L]], learner = structure(list(id = "classif.ksvm.tuned", type = "classif", 
         package = "kernlab", properties = NULL, par.set = structure(list(pars = list(), 
             forbidden = NULL), class = "ParamSet"), par.vals = list(), predict.type = "response", 
         fix.factors.prediction = FALSE, next.learner = structure(list(id = "classif.ksvm", 
             type = "classif", package = "kernlab", properties = c("twoclass", "multiclass", 
             "numerics", "factors", "prob", "class.weights"), par.set = structure(list(
                 pars = list(scaled = structure(list(id = "scaled", type = "logical", 
                     len = 1L, lower = NULL, upper = NULL, values = list(`TRUE` = TRUE, 
                       `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = TRUE, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), type = structure(list(
                     id = "type", type = "discrete", len = 1L, lower = NULL, upper = NULL, 
                     values = list(`C-svc` = "C-svc", `nu-svc` = "nu-svc", `C-bsvc` = "C-bsvc", 
                       `spoc-svc` = "spoc-svc", `kbb-svc` = "kbb-svc"), cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = "C-svc", trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), kernel = structure(list(id = "kernel", type = "discrete", 
                     len = 1L, lower = NULL, upper = NULL, values = list(vanilladot = "vanilladot", 
                       polydot = "polydot", rbfdot = "rbfdot", tanhdot = "tanhdot", laplacedot = "laplacedot", 
                       besseldot = "besseldot", anovadot = "anovadot", splinedot = "splinedot"), 
                     cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = "rbfdot", 
                     trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), C = structure(list(
                     id = "C", type = "numeric", len = 1L, lower = 0, upper = Inf, values = NULL, 
                     cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 1, 
                     trafo = NULL, requires = type %in% c("C-svc", "C-bsvc", "spoc-svc", 
                       "kbb-svc"), tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), nu = structure(list(id = "nu", type = "numeric", len = 1L, 
                     lower = 0, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 0.2, trafo = NULL, requires = type == 
                       "nu-svc", tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), epsilon = structure(list(id = "epsilon", type = "numeric", 
                     len = 1L, lower = -Inf, upper = Inf, values = NULL, cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = 0.1, trafo = NULL, 
                     requires = type %in% c("eps-svr", "nu-svr", "eps-bsvm"), tunable = TRUE, 
                     special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), sigma = structure(list(id = "sigma", type = "numeric", len = 1L, 
                     lower = 0, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = FALSE, default = NULL, trafo = NULL, requires = kernel %in% 
                       c("rbfdot", "anovadot", "besseldot", "laplacedot"), tunable = TRUE, 
                     special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), degree = structure(list(id = "degree", type = "integer", len = 1L, 
                     lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 3L, trafo = NULL, requires = kernel %in% 
                       c("polydot", "anovadot", "besseldot"), tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), scale = structure(list(
                     id = "scale", type = "numeric", len = 1L, lower = 0, upper = Inf, 
                     values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = 1, trafo = NULL, requires = kernel %in% c("polydot", "tanhdot"), 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), offset = structure(list(id = "offset", type = "numeric", len = 1L, 
                     lower = -Inf, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 1, trafo = NULL, requires = kernel %in% 
                       c("polydot", "tanhdot"), tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), order = structure(list(
                     id = "order", type = "integer", len = 1L, lower = -Inf, upper = Inf, 
                     values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = 1L, trafo = NULL, requires = kernel == "besseldot", tunable = TRUE, 
                     special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), tol = structure(list(id = "tol", type = "numeric", len = 1L, 
                     lower = 0, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 0.001, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), shrinking = structure(list(id = "shrinking", type = "logical", 
                     len = 1L, lower = NULL, upper = NULL, values = list(`TRUE` = TRUE, 
                       `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = TRUE, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), class.weights = structure(list(
                     id = "class.weights", type = "numericvector", len = NA_integer_, 
                     lower = 0, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), fit = structure(list(id = "fit", type = "logical", len = 1L, 
                     lower = NULL, upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), 
                     cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = TRUE, 
                     trafo = NULL, requires = NULL, tunable = FALSE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), cache = structure(list(
                     id = "cache", type = "integer", len = 1L, lower = 1L, upper = Inf, 
                     values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = 40L, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param"))), forbidden = NULL), class = c("LearnerParamSet", 
             "ParamSet")), par.vals = list(fit = FALSE), predict.type = "response", name = "Support Vector Machines", 
             short.name = "ksvm", note = "Kernel parameters have to be passed directly and not by using the `kpar` list in `ksvm`. Note that `fit` has been set to `FALSE` by default for speed.", 
             callees = "ksvm", help.list = list(sigma = "Argument of: kernlab::ksvm\n\nfor the ANOVA kernel \"anovadot\".", 
                 degree = "Argument of: kernlab::ksvm\n\nfor the ANOVA kernel \"anovadot\".", 
                 scale = "Argument of: kernlab::ksvm\n\nfor the Hyperbolic tangent kernel function \"tanhdot\"", 
                 offset = "Argument of: kernlab::ksvm\n\nfor the Hyperbolic tangent kernel function \"tanhdot\"", 
                 order = "Argument of: kernlab::ksvm\n\nfor the Bessel kernel \"besseldot\".", 
                 scaled = "Argument of: kernlab::ksvm\n\nA logical vector indicating the variables to be scaled. If scaled is of length 1, the value is recycled as many times as needed and all non-binary variables are scaled. Per default, data are scaled internally (both x and y variables) to zero mean and unit variance. The center and scale values are returned and used for later predictions.", 
                 type = "Argument of: kernlab::ksvm\n\nksvm can be used for classification , for regression, or for novelty detection. Depending on whether y is a factor or not, the default setting for type is C-svc or eps-svr, respectively, but can be overwritten by setting an explicit value. Valid options are:\n\nC-svc   C classification\n\nnu-svc  nu classification\n\nC-bsvc  bound-constraint svm classification\n\nspoc-svc  Crammer, Singer native multi-class\n\nkbb-svc  Weston, Watkins native multi-class\n\none-svc  novelty detection\n\neps-svr  epsilon regression\n\nnu-svr   nu regression\n\neps-bsvr  bound-constraint svm regression", 
                 kernel = "Argument of: kernlab::ksvm\n\nthe kernel function used in training and predicting. This parameter can be set to any function, of class kernel, which computes the inner product in feature space between two vector arguments (see kernels). kernlab provides the most popular kernel functions which can be used by setting the kernel parameter to the following strings:\n\nrbfdot Radial Basis kernel \"Gaussian\"\n\npolydot Polynomial kernel\n\nvanilladot Linear kernel\n\ntanhdot Hyperbolic tangent kernel\n\nlaplacedot Laplacian kernel\n\nbesseldot Bessel kernel\n\nanovadot ANOVA RBF kernel\n\nsplinedot Spline kernel\n\nstringdot String kernel\n\nSetting the kernel parameter to \"matrix\" treats x as a kernel matrix calling the kernelMatrix interface. The kernel parameter can also be set to a user defined function of class kernel by passing the function name as an argument.", 
                 C = "Argument of: kernlab::ksvm\n\ncost of constraints violation (default: 1) this is the ‘C’-constant of the regularization term in the Lagrange formulation.", 
                 nu = "Argument of: kernlab::ksvm\n\nparameter needed for nu-svc, one-svc, and nu-svr. The nu parameter sets the upper bound on the training error and the lower bound on the fraction of data points to become Support Vectors (default: 0.2).", 
                 epsilon = "Argument of: kernlab::ksvm\n\nepsilon in the insensitive-loss function used for eps-svr, nu-svr and eps-bsvm (default: 0.1)", 
                 class.weights = "Argument of: kernlab::ksvm\n\na named vector of weights for the different classes, used for asymmetric class sizes. Not all factor levels have to be supplied (default weight: 1). All components have to be named.", 
                 cache = "Argument of: kernlab::ksvm\n\ncache memory in MB (default 40)", 
                 tol = "Argument of: kernlab::ksvm\n\ntolerance of termination criterion (default: 0.001)", 
                 shrinking = "Argument of: kernlab::ksvm\n\noption whether to use the shrinking-heuristics (default: TRUE)", 
                 fit = "Argument of: kernlab::ksvm\n\nindicates whether the fitted values should be computed and included in the model or not (default: TRUE)"), 
             class.weights.param = "class.weights", config = list(), fix.factors.prediction = FALSE), class = c("classif.ksvm", 
         "RLearnerClassif", "RLearner", "Learner")), model.subclass = "TuneModel", resampling = structure(list(
             split = 0.666666666666667, id = "holdout", iters = 1L, predict = "test", 
             stratify = FALSE), class = c("HoldoutDesc", "ResampleDesc")), measures = list(
             structure(list(id = "mmce", minimize = TRUE, properties = c("classif", "classif.multi", 
             "req.pred", "req.truth"), fun = function (task, model, pred, feats, extra.args) 
             {
                 measureMMCE(pred$data$truth, pred$data$response)
             }, extra.args = list(), best = 0, worst = 1, name = "Mean misclassification error", 
                 note = "Defined as: mean(response != truth)", aggr = structure(list(id = "test.mean", 
                     name = "Test mean", fun = function (task, perf.test, perf.train, 
                       measure, group, pred) 
                     mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure")), 
         opt.pars = structure(list(pars = list(C = structure(list(id = "C", type = "numeric", 
             len = 1L, lower = 0.01, upper = 2, values = NULL, cnames = NULL, allow.inf = FALSE, 
             has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, 
             special.vals = list()), class = "Param")), forbidden = NULL), class = "ParamSet"), 
         bit.names = character(0), bits.to.features = function () 
         {
         }, control = structure(list(same.resampling.instance = TRUE, impute.val = NULL, 
             tune.threshold = FALSE, tune.threshold.args = list(), log.fun = function (learner, 
                 task, resampling, measures, par.set, control, opt.path, dob, x, y, remove.nas, 
                 stage, prev.stage) 
             {
                 x.string = paramValueToString(par.set, x, show.missing.values = !remove.nas)
                 if (inherits(learner, "ModelMultiplexer")) 
                     x.string = stri_replace_all(x.string, "", regex = stri_paste(x$selected.learner, 
                       "\\."))
                 logFunDefault(learner, task, resampling, measures, par.set, control, 
                     opt.path, dob, x.string, y, remove.nas, stage, prev.stage, prefixes = c("Tune-x", 
                       "Tune-y"))
             }, final.dw.perc = NULL, extra.args = list(maxit = 5L), budget = 5L), class = c("TuneControlRandom", 
         "TuneControl", "OptControl")), show.info = FALSE), class = c("TuneWrapper", "OptWrapper", 
     "BaseWrapper", "Learner")), task = structure(list(type = "classif", env = <environment>, 
         weights = NULL, blocking = NULL, coordinates = NULL, task.desc = structure(list(
             id = "PimaIndiansDiabetes-example", type = "classif", target = "diabetes", 
             size = 768L, n.feat = c(numerics = 8L, factors = 0L, ordered = 0L, functionals = 0L
             ), has.missings = FALSE, has.weights = FALSE, has.blocking = FALSE, has.coordinates = FALSE, 
             class.levels = c("neg", "pos"), positive = "pos", negative = "neg", class.distribution = structure(c(neg = 500L, 
             pos = 268L), .Dim = 2L, .Dimnames = list(c("neg", "pos")), class = "table")), class = c("ClassifTaskDesc", 
         "SupervisedTaskDesc", "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", 
     "Task")), rin = structure(list(desc = structure(list(id = "cross-validation", iters = 2L, 
         predict = "test", stratify = FALSE), class = c("CVDesc", "ResampleDesc")), size = 768L, 
         train.inds = list(c(525L, 502L, 517L, 617L, 482L, 12L, 493L, 611L, 15L, 684L, 
         405L, 595L, 303L, 208L, 267L, 192L, 709L, 357L, 546L, 486L, 504L, 264L, 101L, 
         403L, 223L, 433L, 707L, 530L, 54L, 3L, 545L, 507L, 468L, 202L, 68L, 670L, 512L, 
         426L, 84L, 182L, 620L, 163L, 498L, 489L, 297L, 646L, 602L, 29L, 316L, 416L, 340L, 
         94L, 113L, 350L, 570L, 9L, 457L, 587L, 672L, 442L, 762L, 614L, 274L, 169L, 145L, 
         683L, 432L, 352L, 487L, 244L, 509L, 588L, 370L, 423L, 323L, 481L, 706L, 634L, 
         756L, 596L, 367L, 238L, 198L, 685L, 686L, 526L, 428L, 693L, 124L, 765L, 577L, 
         642L, 749L, 582L, 248L, 56L, 601L, 240L, 245L, 755L, 559L, 722L, 237L, 81L, 313L, 
         272L, 443L, 27L, 159L, 4L, 395L, 510L, 48L, 218L, 449L, 553L, 59L, 318L, 86L, 
         254L, 411L, 733L, 653L, 266L, 11L, 404L, 333L, 243L, 301L, 657L, 681L, 137L, 
         118L, 275L, 226L, 66L, 662L, 505L, 75L, 610L, 715L, 120L, 737L, 718L, 635L, 644L, 
         261L, 37L, 336L, 64L, 263L, 368L, 555L, 408L, 371L, 125L, 732L, 511L, 344L, 459L, 
         603L, 579L, 52L, 58L, 327L, 480L, 95L, 580L, 229L, 717L, 407L, 643L, 166L, 103L, 
         178L, 393L, 111L, 628L, 573L, 566L, 49L, 230L, 332L, 285L, 461L, 750L, 115L, 
         539L, 330L, 161L, 675L, 641L, 390L, 425L, 589L, 583L, 458L, 78L, 172L, 719L, 
         565L, 495L, 151L, 533L, 136L, 242L, 467L, 660L, 491L, 328L, 289L, 496L, 22L, 
         430L, 420L, 436L, 325L, 475L, 380L, 262L, 532L, 63L, 514L, 568L, 278L, 723L, 
         154L, 70L, 659L, 695L, 766L, 550L, 93L, 712L, 434L, 184L, 129L, 557L, 632L, 655L, 
         209L, 454L, 356L, 41L, 273L, 170L, 607L, 18L, 253L, 544L, 661L, 645L, 378L, 492L, 
         764L, 415L, 721L, 738L, 309L, 508L, 392L, 201L, 576L, 185L, 200L, 399L, 422L, 
         439L, 389L, 17L, 529L, 23L, 379L, 228L, 758L, 374L, 592L, 724L, 8L, 626L, 503L, 
         528L, 206L, 60L, 348L, 355L, 513L, 183L, 219L, 112L, 427L, 25L, 612L, 87L, 314L, 
         44L, 181L, 235L, 741L, 383L, 216L, 304L, 341L, 453L, 398L, 622L, 563L, 739L, 
         97L, 447L, 571L, 754L, 286L, 625L, 677L, 648L, 387L, 205L, 554L, 65L, 621L, 150L, 
         650L, 249L, 189L, 400L, 121L, 616L, 656L, 767L, 131L, 465L, 351L, 470L, 108L, 
         391L, 479L, 139L, 109L, 584L, 107L, 729L, 664L, 102L, 372L, 221L, 600L, 148L, 
         141L, 599L, 19L, 156L, 62L, 605L, 132L, 561L, 680L, 440L, 295L, 236L, 654L, 21L, 
         572L, 497L, 746L, 671L, 16L, 271L, 471L, 551L, 472L, 649L, 177L, 386L, 651L, 
         666L, 239L, 591L, 42L, 564L, 167L, 251L, 396L, 222L), c(702L, 623L, 98L, 191L, 
         252L, 310L, 613L, 196L, 619L, 347L, 153L, 212L, 697L, 164L, 364L, 77L, 751L, 
         269L, 90L, 35L, 193L, 349L, 36L, 640L, 560L, 213L, 91L, 424L, 494L, 321L, 38L, 
         241L, 519L, 326L, 402L, 753L, 460L, 381L, 7L, 734L, 224L, 679L, 345L, 82L, 51L, 
         287L, 437L, 691L, 106L, 740L, 366L, 506L, 446L, 71L, 604L, 727L, 194L, 667L, 
         521L, 13L, 33L, 682L, 541L, 569L, 516L, 45L, 638L, 360L, 329L, 26L, 419L, 720L, 
         338L, 477L, 538L, 466L, 96L, 673L, 524L, 292L, 232L, 698L, 179L, 92L, 615L, 217L, 
         375L, 726L, 246L, 293L, 259L, 358L, 520L, 704L, 67L, 714L, 463L, 152L, 361L, 
         531L, 197L, 234L, 255L, 736L, 499L, 418L, 76L, 85L, 105L, 578L, 122L, 312L, 307L, 
         748L, 382L, 147L, 455L, 451L, 157L, 233L, 639L, 658L, 742L, 647L, 618L, 409L, 
         203L, 688L, 594L, 282L, 280L, 414L, 730L, 725L, 257L, 731L, 689L, 484L, 401L, 
         268L, 133L, 317L, 117L, 138L, 342L, 540L, 83L, 146L, 175L, 575L, 456L, 296L, 
         290L, 14L, 768L, 79L, 474L, 188L, 123L, 53L, 362L, 215L, 334L, 674L, 501L, 127L, 
         88L, 663L, 631L, 258L, 283L, 31L, 204L, 438L, 549L, 298L, 130L, 24L, 606L, 527L, 
         220L, 431L, 302L, 104L, 534L, 562L, 636L, 128L, 711L, 354L, 231L, 288L, 142L, 
         324L, 80L, 692L, 627L, 256L, 696L, 55L, 536L, 547L, 713L, 763L, 260L, 143L, 34L, 
         227L, 1L, 500L, 708L, 306L, 703L, 728L, 276L, 207L, 43L, 490L, 155L, 629L, 300L, 
         413L, 744L, 590L, 162L, 609L, 444L, 165L, 633L, 110L, 445L, 335L, 265L, 2L, 99L, 
         311L, 574L, 211L, 552L, 747L, 435L, 743L, 745L, 757L, 462L, 69L, 160L, 279L, 
         40L, 652L, 168L, 149L, 429L, 567L, 284L, 586L, 543L, 452L, 376L, 294L, 388L, 
         50L, 476L, 687L, 74L, 176L, 135L, 523L, 195L, 32L, 47L, 190L, 450L, 473L, 73L, 
         558L, 669L, 518L, 291L, 421L, 210L, 630L, 369L, 119L, 126L, 89L, 144L, 343L, 
         270L, 464L, 320L, 700L, 5L, 186L, 598L, 28L, 485L, 319L, 250L, 30L, 57L, 694L, 
         187L, 384L, 394L, 337L, 10L, 483L, 535L, 114L, 710L, 759L, 441L, 100L, 72L, 585L, 
         116L, 20L, 690L, 410L, 339L, 735L, 214L, 171L, 247L, 699L, 716L, 140L, 225L, 
         397L, 39L, 593L, 678L, 597L, 537L, 6L, 417L, 277L, 412L, 760L, 676L, 701L, 61L, 
         624L, 353L, 331L, 548L, 665L, 761L, 752L, 556L, 281L, 299L, 346L, 46L, 174L, 
         158L, 488L, 637L, 363L, 359L, 173L, 668L, 469L, 478L, 305L, 406L, 365L, 542L, 
         705L, 315L, 308L, 515L, 373L, 134L, 377L, 322L, 385L, 522L, 448L, 608L, 199L, 
         180L, 581L)), test.inds = list(c(1L, 2L, 5L, 6L, 7L, 10L, 13L, 14L, 20L, 24L, 
         26L, 28L, 30L, 31L, 32L, 33L, 34L, 35L, 36L, 38L, 39L, 40L, 43L, 45L, 46L, 47L, 
         50L, 51L, 53L, 55L, 57L, 61L, 67L, 69L, 71L, 72L, 73L, 74L, 76L, 77L, 79L, 80L, 
         82L, 83L, 85L, 88L, 89L, 90L, 91L, 92L, 96L, 98L, 99L, 100L, 104L, 105L, 106L, 
         110L, 114L, 116L, 117L, 119L, 122L, 123L, 126L, 127L, 128L, 130L, 133L, 134L, 
         135L, 138L, 140L, 142L, 143L, 144L, 146L, 147L, 149L, 152L, 153L, 155L, 157L, 
         158L, 160L, 162L, 164L, 165L, 168L, 171L, 173L, 174L, 175L, 176L, 179L, 180L, 
         186L, 187L, 188L, 190L, 191L, 193L, 194L, 195L, 196L, 197L, 199L, 203L, 204L, 
         207L, 210L, 211L, 212L, 213L, 214L, 215L, 217L, 220L, 224L, 225L, 227L, 231L, 
         232L, 233L, 234L, 241L, 246L, 247L, 250L, 252L, 255L, 256L, 257L, 258L, 259L, 
         260L, 265L, 268L, 269L, 270L, 276L, 277L, 279L, 280L, 281L, 282L, 283L, 284L, 
         287L, 288L, 290L, 291L, 292L, 293L, 294L, 296L, 298L, 299L, 300L, 302L, 305L, 
         306L, 307L, 308L, 310L, 311L, 312L, 315L, 317L, 319L, 320L, 321L, 322L, 324L, 
         326L, 329L, 331L, 334L, 335L, 337L, 338L, 339L, 342L, 343L, 345L, 346L, 347L, 
         349L, 353L, 354L, 358L, 359L, 360L, 361L, 362L, 363L, 364L, 365L, 366L, 369L, 
         373L, 375L, 376L, 377L, 381L, 382L, 384L, 385L, 388L, 394L, 397L, 401L, 402L, 
         406L, 409L, 410L, 412L, 413L, 414L, 417L, 418L, 419L, 421L, 424L, 429L, 431L, 
         435L, 437L, 438L, 441L, 444L, 445L, 446L, 448L, 450L, 451L, 452L, 455L, 456L, 
         460L, 462L, 463L, 464L, 466L, 469L, 473L, 474L, 476L, 477L, 478L, 483L, 484L, 
         485L, 488L, 490L, 494L, 499L, 500L, 501L, 506L, 515L, 516L, 518L, 519L, 520L, 
         521L, 522L, 523L, 524L, 527L, 531L, 534L, 535L, 536L, 537L, 538L, 540L, 541L, 
         542L, 543L, 547L, 548L, 549L, 552L, 556L, 558L, 560L, 562L, 567L, 569L, 574L, 
         575L, 578L, 581L, 585L, 586L, 590L, 593L, 594L, 597L, 598L, 604L, 606L, 608L, 
         609L, 613L, 615L, 618L, 619L, 623L, 624L, 627L, 629L, 630L, 631L, 633L, 636L, 
         637L, 638L, 639L, 640L, 647L, 652L, 658L, 663L, 665L, 667L, 668L, 669L, 673L, 
         674L, 676L, 678L, 679L, 682L, 687L, 688L, 689L, 690L, 691L, 692L, 694L, 696L, 
         697L, 698L, 699L, 700L, 701L, 702L, 703L, 704L, 705L, 708L, 710L, 711L, 713L, 
         714L, 716L, 720L, 725L, 726L, 727L, 728L, 730L, 731L, 734L, 735L, 736L, 740L, 
         742L, 743L, 744L, 745L, 747L, 748L, 751L, 752L, 753L, 757L, 759L, 760L, 761L, 
         763L, 768L), c(3L, 4L, 8L, 9L, 11L, 12L, 15L, 16L, 17L, 18L, 19L, 21L, 22L, 23L, 
         25L, 27L, 29L, 37L, 41L, 42L, 44L, 48L, 49L, 52L, 54L, 56L, 58L, 59L, 60L, 62L, 
         63L, 64L, 65L, 66L, 68L, 70L, 75L, 78L, 81L, 84L, 86L, 87L, 93L, 94L, 95L, 97L, 
         101L, 102L, 103L, 107L, 108L, 109L, 111L, 112L, 113L, 115L, 118L, 120L, 121L, 
         124L, 125L, 129L, 131L, 132L, 136L, 137L, 139L, 141L, 145L, 148L, 150L, 151L, 
         154L, 156L, 159L, 161L, 163L, 166L, 167L, 169L, 170L, 172L, 177L, 178L, 181L, 
         182L, 183L, 184L, 185L, 189L, 192L, 198L, 200L, 201L, 202L, 205L, 206L, 208L, 
         209L, 216L, 218L, 219L, 221L, 222L, 223L, 226L, 228L, 229L, 230L, 235L, 236L, 
         237L, 238L, 239L, 240L, 242L, 243L, 244L, 245L, 248L, 249L, 251L, 253L, 254L, 
         261L, 262L, 263L, 264L, 266L, 267L, 271L, 272L, 273L, 274L, 275L, 278L, 285L, 
         286L, 289L, 295L, 297L, 301L, 303L, 304L, 309L, 313L, 314L, 316L, 318L, 323L, 
         325L, 327L, 328L, 330L, 332L, 333L, 336L, 340L, 341L, 344L, 348L, 350L, 351L, 
         352L, 355L, 356L, 357L, 367L, 368L, 370L, 371L, 372L, 374L, 378L, 379L, 380L, 
         383L, 386L, 387L, 389L, 390L, 391L, 392L, 393L, 395L, 396L, 398L, 399L, 400L, 
         403L, 404L, 405L, 407L, 408L, 411L, 415L, 416L, 420L, 422L, 423L, 425L, 426L, 
         427L, 428L, 430L, 432L, 433L, 434L, 436L, 439L, 440L, 442L, 443L, 447L, 449L, 
         453L, 454L, 457L, 458L, 459L, 461L, 465L, 467L, 468L, 470L, 471L, 472L, 475L, 
         479L, 480L, 481L, 482L, 486L, 487L, 489L, 491L, 492L, 493L, 495L, 496L, 497L, 
         498L, 502L, 503L, 504L, 505L, 507L, 508L, 509L, 510L, 511L, 512L, 513L, 514L, 
         517L, 525L, 526L, 528L, 529L, 530L, 532L, 533L, 539L, 544L, 545L, 546L, 550L, 
         551L, 553L, 554L, 555L, 557L, 559L, 561L, 563L, 564L, 565L, 566L, 568L, 570L, 
         571L, 572L, 573L, 576L, 577L, 579L, 580L, 582L, 583L, 584L, 587L, 588L, 589L, 
         591L, 592L, 595L, 596L, 599L, 600L, 601L, 602L, 603L, 605L, 607L, 610L, 611L, 
         612L, 614L, 616L, 617L, 620L, 621L, 622L, 625L, 626L, 628L, 632L, 634L, 635L, 
         641L, 642L, 643L, 644L, 645L, 646L, 648L, 649L, 650L, 651L, 653L, 654L, 655L, 
         656L, 657L, 659L, 660L, 661L, 662L, 664L, 666L, 670L, 671L, 672L, 675L, 677L, 
         680L, 681L, 683L, 684L, 685L, 686L, 693L, 695L, 706L, 707L, 709L, 712L, 715L, 
         717L, 718L, 719L, 721L, 722L, 723L, 724L, 729L, 732L, 733L, 737L, 738L, 739L, 
         741L, 746L, 749L, 750L, 754L, 755L, 756L, 758L, 762L, 764L, 765L, 766L, 767L)), 
         group = structure(integer(0), .Label = character(0), class = "factor")), class = "ResampleInstance"), 
         weights = NULL, measures = list(structure(list(id = "mmce", minimize = TRUE, 
             properties = c("classif", "classif.multi", "req.pred", "req.truth"), fun = function (task, 
                 model, pred, feats, extra.args) 
             {
                 measureMMCE(pred$data$truth, pred$data$response)
             }, extra.args = list(), best = 0, worst = 1, name = "Mean misclassification error", 
             note = "Defined as: mean(response != truth)", aggr = structure(list(id = "test.mean", 
                 name = "Test mean", fun = function (task, perf.test, perf.train, measure, 
                     group, pred) 
                 mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure")), 
         model = FALSE, extract = function (object) 
         {
             assertClass(object, "TuneModel")
             object$learner.model$opt.result
         }, show.info = FALSE)
  5: calculateResampleIterationResult(learner = learner, task = task, i = i, train.i = train.i, 
         test.i = test.i, measures = measures, weights = weights, rdesc = rin$desc, model = model, 
         extract = extract, show.info = show.info)
  6: isFailureModel(m)
  7: isFailureModel.BaseWrapperModel(m)
  8: isFailureModel(model$learner.model$next.model)
  
  ── 49. Error: 2 hyperparams (@test_base_generateHyperParsEffect.R#156)  ────────
  argument "def" is missing, with no default
  1: tuneParams(learn, task = pid.task, control = ctrl, measures = acc, resampling = rdesc, 
         par.set = ps, show.info = FALSE) at testthat/test_base_generateHyperParsEffect.R:156
  2: sel.func(learner, task, resampling, measures, par.set, control, opt.path, show.info, 
         resample.fun)
  3: evalOptimizationStatesTune(learner, task, resampling, measures, par.set, control, 
         opt.path, show.info, vals, dobs = seq_along(vals), eols = NA_integer_, remove.nas = TRUE, 
         resample.fun)
  4: evalOptimizationStates(learner, task, resampling, measures, par.set, NULL, control, 
         opt.path, show.info, states, dobs, eols, remove.nas, resample.fun, "mlr.tuneParams")
  5: parallelMap(evalOptimizationState, dobs, states, level = level, more.args = list(learner = learner, 
         task = task, resampling = resampling, measures = measures, par.set = par.set, 
         bits.to.features = bits.to.features, control = control, opt.path = opt.path, 
         show.info = show.info, remove.nas = remove.nas, resample.fun = resample.fun))
  6: mapply(fun2, ..., MoreArgs = more.args, SIMPLIFY = FALSE, USE.NAMES = FALSE)
  7: (function (learner, task, resampling, measures, par.set, bits.to.features, control, 
         opt.path, show.info, dob, state, remove.nas, resample.fun) 
     {
         setSlaveOptions()
         y = setNames(rep(NA_real_, length(measures)), vcapply(measures, measureAggrName))
         errmsg = NA_character_
         exec.time = NA_real_
         set.pars.ok = TRUE
         learner2 = learner
         threshold = NULL
         log.fun = control$log.fun
         err.dumps = list()
         if (inherits(control, "TuneControl") || inherits(control, "TuneMultiCritControl")) {
             state = setValueCNames(par.set, state)
             state = trafoValue(par.set, state)
             state2 = if (remove.nas) 
                 removeMissingValues(state)
             else state
             learner2 = try(setHyperPars(learner, par.vals = state2), silent = TRUE)
             if (is.error(learner2)) {
                 set.pars.ok = FALSE
                 errmsg = as.character(learner2)
                 if (show.info) 
                     messagef("[Tune-x] Setting hyperpars failed: %s", errmsg)
             }
         }
         else if (inherits(control, "FeatSelControl")) {
             task = subsetTask(task, features = bits.to.features(state, task))
         }
         if (show.info) 
             prev.stage = log.fun(learner, task, resampling, measures, par.set, control, 
                 opt.path, dob, state, NA_real_, remove.nas, stage = 1L)
         if (set.pars.ok) {
             exec.time = measureTime({
                 r = resample.fun(learner2, task, resampling, measures = measures, show.info = FALSE)
             })
             if (control$tune.threshold) {
                 th.args = control$tune.threshold.args
                 th.args$pred = r$pred
                 th.args$measure = measures[[1L]]
                 tune.th.res = do.call(tuneThreshold, th.args)
                 threshold = tune.th.res$th
                 y = performance(setThreshold(r$pred, threshold = threshold), measures = measures)
                 names(y) = names(r$aggr)
             }
             else {
                 y = r$aggr
             }
             errmsgs = as.character(t(r$err.msgs[, -1L]))
             notna = !is.na(errmsgs)
             if (any(notna)) 
                 errmsg = errmsgs[notna][1L]
             err.dumps = r$err.dumps
         }
         else {
             if (control$tune.threshold) 
                 threshold = NA_real_
         }
         if (show.info) 
             log.fun(learner, task, resampling, measures, par.set, control, opt.path, 
                 dob, state, y, remove.nas, stage = 2L, prev.stage = prev.stage)
         list(y = y, exec.time = exec.time, errmsg = errmsg, threshold = threshold, err.dumps = err.dumps)
     })(dots[[1L]][[1L]], dots[[2L]][[1L]], learner = structure(list(id = "classif.ksvm", 
         type = "classif", package = "kernlab", properties = c("twoclass", "multiclass", 
         "numerics", "factors", "prob", "class.weights"), par.set = structure(list(pars = list(
             scaled = structure(list(id = "scaled", type = "logical", len = 1L, lower = NULL, 
                 upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, 
                 allow.inf = FALSE, has.default = TRUE, default = TRUE, trafo = NULL, 
                 requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), type = structure(list(id = "type", type = "discrete", len = 1L, 
                 lower = NULL, upper = NULL, values = list(`C-svc` = "C-svc", `nu-svc` = "nu-svc", 
                     `C-bsvc` = "C-bsvc", `spoc-svc` = "spoc-svc", `kbb-svc` = "kbb-svc"), 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = "C-svc", 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), kernel = structure(list(
                 id = "kernel", type = "discrete", len = 1L, lower = NULL, upper = NULL, 
                 values = list(vanilladot = "vanilladot", polydot = "polydot", rbfdot = "rbfdot", 
                     tanhdot = "tanhdot", laplacedot = "laplacedot", besseldot = "besseldot", 
                     anovadot = "anovadot", splinedot = "splinedot"), cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = "rbfdot", trafo = NULL, requires = NULL, 
                 tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), C = structure(list(id = "C", type = "numeric", len = 1L, lower = 0, 
                 upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 1, trafo = NULL, requires = type %in% c("C-svc", "C-bsvc", 
                     "spoc-svc", "kbb-svc"), tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), nu = structure(list(id = "nu", type = "numeric", len = 1L, lower = 0, 
                 upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 0.2, trafo = NULL, requires = type == "nu-svc", tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), epsilon = structure(list(id = "epsilon", type = "numeric", len = 1L, 
                 lower = -Inf, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 0.1, trafo = NULL, requires = type %in% 
                     c("eps-svr", "nu-svr", "eps-bsvm"), tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), sigma = structure(list(
                 id = "sigma", type = "numeric", len = 1L, lower = 0, upper = Inf, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, 
                 trafo = NULL, requires = kernel %in% c("rbfdot", "anovadot", "besseldot", 
                     "laplacedot"), tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), degree = structure(list(id = "degree", type = "integer", len = 1L, 
                 lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 3L, trafo = NULL, requires = kernel %in% 
                     c("polydot", "anovadot", "besseldot"), tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), scale = structure(list(
                 id = "scale", type = "numeric", len = 1L, lower = 0, upper = Inf, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 1, trafo = NULL, 
                 requires = kernel %in% c("polydot", "tanhdot"), tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), offset = structure(list(
                 id = "offset", type = "numeric", len = 1L, lower = -Inf, upper = Inf, 
                 values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 1, trafo = NULL, requires = kernel %in% c("polydot", "tanhdot"), 
                 tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), order = structure(list(id = "order", type = "integer", len = 1L, 
                 lower = -Inf, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 1L, trafo = NULL, requires = kernel == 
                     "besseldot", tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), tol = structure(list(id = "tol", type = "numeric", len = 1L, lower = 0, 
                 upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 0.001, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), shrinking = structure(list(
                 id = "shrinking", type = "logical", len = 1L, lower = NULL, upper = NULL, 
                 values = list(`TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = TRUE, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), class.weights = structure(list(id = "class.weights", type = "numericvector", 
                 len = NA_integer_, lower = 0, upper = Inf, values = NULL, cnames = NULL, 
                 allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, 
                 requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), fit = structure(list(id = "fit", type = "logical", len = 1L, lower = NULL, 
                 upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, 
                 allow.inf = FALSE, has.default = TRUE, default = TRUE, trafo = NULL, 
                 requires = NULL, tunable = FALSE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), cache = structure(list(id = "cache", type = "integer", len = 1L, 
                 lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 40L, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             ))), forbidden = NULL), class = c("LearnerParamSet", "ParamSet")), par.vals = list(
             fit = FALSE, kernel = "rbfdot"), predict.type = "response", name = "Support Vector Machines", 
         short.name = "ksvm", note = "Kernel parameters have to be passed directly and not by using the `kpar` list in `ksvm`. Note that `fit` has been set to `FALSE` by default for speed.", 
         callees = "ksvm", help.list = list(sigma = "Argument of: kernlab::ksvm\n\nfor the ANOVA kernel \"anovadot\".", 
             degree = "Argument of: kernlab::ksvm\n\nfor the ANOVA kernel \"anovadot\".", 
             scale = "Argument of: kernlab::ksvm\n\nfor the Hyperbolic tangent kernel function \"tanhdot\"", 
             offset = "Argument of: kernlab::ksvm\n\nfor the Hyperbolic tangent kernel function \"tanhdot\"", 
             order = "Argument of: kernlab::ksvm\n\nfor the Bessel kernel \"besseldot\".", 
             scaled = "Argument of: kernlab::ksvm\n\nA logical vector indicating the variables to be scaled. If scaled is of length 1, the value is recycled as many times as needed and all non-binary variables are scaled. Per default, data are scaled internally (both x and y variables) to zero mean and unit variance. The center and scale values are returned and used for later predictions.", 
             type = "Argument of: kernlab::ksvm\n\nksvm can be used for classification , for regression, or for novelty detection. Depending on whether y is a factor or not, the default setting for type is C-svc or eps-svr, respectively, but can be overwritten by setting an explicit value. Valid options are:\n\nC-svc   C classification\n\nnu-svc  nu classification\n\nC-bsvc  bound-constraint svm classification\n\nspoc-svc  Crammer, Singer native multi-class\n\nkbb-svc  Weston, Watkins native multi-class\n\none-svc  novelty detection\n\neps-svr  epsilon regression\n\nnu-svr   nu regression\n\neps-bsvr  bound-constraint svm regression", 
             kernel = "Argument of: kernlab::ksvm\n\nthe kernel function used in training and predicting. This parameter can be set to any function, of class kernel, which computes the inner product in feature space between two vector arguments (see kernels). kernlab provides the most popular kernel functions which can be used by setting the kernel parameter to the following strings:\n\nrbfdot Radial Basis kernel \"Gaussian\"\n\npolydot Polynomial kernel\n\nvanilladot Linear kernel\n\ntanhdot Hyperbolic tangent kernel\n\nlaplacedot Laplacian kernel\n\nbesseldot Bessel kernel\n\nanovadot ANOVA RBF kernel\n\nsplinedot Spline kernel\n\nstringdot String kernel\n\nSetting the kernel parameter to \"matrix\" treats x as a kernel matrix calling the kernelMatrix interface. The kernel parameter can also be set to a user defined function of class kernel by passing the function name as an argument.", 
             C = "Argument of: kernlab::ksvm\n\ncost of constraints violation (default: 1) this is the ‘C’-constant of the regularization term in the Lagrange formulation.", 
             nu = "Argument of: kernlab::ksvm\n\nparameter needed for nu-svc, one-svc, and nu-svr. The nu parameter sets the upper bound on the training error and the lower bound on the fraction of data points to become Support Vectors (default: 0.2).", 
             epsilon = "Argument of: kernlab::ksvm\n\nepsilon in the insensitive-loss function used for eps-svr, nu-svr and eps-bsvm (default: 0.1)", 
             class.weights = "Argument of: kernlab::ksvm\n\na named vector of weights for the different classes, used for asymmetric class sizes. Not all factor levels have to be supplied (default weight: 1). All components have to be named.", 
             cache = "Argument of: kernlab::ksvm\n\ncache memory in MB (default 40)", 
             tol = "Argument of: kernlab::ksvm\n\ntolerance of termination criterion (default: 0.001)", 
             shrinking = "Argument of: kernlab::ksvm\n\noption whether to use the shrinking-heuristics (default: TRUE)", 
             fit = "Argument of: kernlab::ksvm\n\nindicates whether the fitted values should be computed and included in the model or not (default: TRUE)"), 
         class.weights.param = "class.weights", config = list(), fix.factors.prediction = FALSE), class = c("classif.ksvm", 
     "RLearnerClassif", "RLearner", "Learner")), task = structure(list(type = "classif", 
         env = <environment>, weights = NULL, blocking = NULL, coordinates = NULL, task.desc = structure(list(
             id = "PimaIndiansDiabetes-example", type = "classif", target = "diabetes", 
             size = 768L, n.feat = c(numerics = 8L, factors = 0L, ordered = 0L, functionals = 0L
             ), has.missings = FALSE, has.weights = FALSE, has.blocking = FALSE, has.coordinates = FALSE, 
             class.levels = c("neg", "pos"), positive = "pos", negative = "neg", class.distribution = structure(c(neg = 500L, 
             pos = 268L), .Dim = 2L, .Dimnames = list(c("neg", "pos")), class = "table")), class = c("ClassifTaskDesc", 
         "SupervisedTaskDesc", "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", 
     "Task")), resampling = structure(list(desc = structure(list(split = 0.666666666666667, 
         id = "holdout", iters = 1L, predict = "test", stratify = FALSE), class = c("HoldoutDesc", 
     "ResampleDesc")), size = 768L, train.inds = list(c(221L, 605L, 314L, 676L, 719L, 
     35L, 403L, 680L, 420L, 347L, 726L, 344L, 513L, 433L, 78L, 678L, 186L, 32L, 246L, 
     715L, 666L, 518L, 478L, 741L, 488L, 527L, 404L, 441L, 214L, 109L, 711L, 665L, 509L, 
     585L, 19L, 351L, 556L, 159L, 233L, 169L, 104L, 302L, 301L, 268L, 111L, 101L, 729L, 
     336L, 192L, 617L, 33L, 318L, 573L, 88L, 401L, 148L, 91L, 536L, 636L, 266L, 471L, 
     68L, 272L, 194L, 574L, 316L, 569L, 570L, 557L, 308L, 743L, 439L, 495L, 1L, 330L, 
     153L, 263L, 424L, 243L, 77L, 168L, 459L, 287L, 540L, 71L, 298L, 672L, 609L, 603L, 
     119L, 89L, 443L, 730L, 444L, 216L, 127L, 526L, 63L, 313L, 343L, 714L, 222L, 326L, 
     635L, 321L, 591L, 606L, 762L, 706L, 97L, 616L, 198L, 40L, 621L, 472L, 93L, 359L, 
     622L, 381L, 692L, 760L, 207L, 199L, 142L, 238L, 633L, 99L, 59L, 712L, 745L, 396L, 
     568L, 429L, 469L, 331L, 418L, 520L, 497L, 618L, 277L, 196L, 257L, 7L, 115L, 682L, 
     145L, 149L, 48L, 693L, 454L, 524L, 307L, 239L, 152L, 69L, 240L, 733L, 133L, 660L, 
     611L, 306L, 215L, 394L, 227L, 607L, 322L, 446L, 681L, 248L, 160L, 377L, 110L, 515L, 
     445L, 397L, 367L, 768L, 766L, 517L, 669L, 494L, 184L, 416L, 156L, 348L, 281L, 155L, 
     329L, 530L, 523L, 731L, 752L, 637L, 357L, 539L, 725L, 765L, 598L, 87L, 748L, 136L, 
     546L, 341L, 291L, 228L, 496L, 205L, 162L, 96L, 659L, 269L, 141L, 121L, 375L, 27L, 
     388L, 195L, 226L, 452L, 505L, 582L, 624L, 398L, 555L, 29L, 604L, 259L, 304L, 378L, 
     588L, 333L, 231L, 565L, 751L, 140L, 212L, 106L, 442L, 82L, 426L, 289L, 350L, 640L, 
     538L, 164L, 379L, 209L, 506L, 504L, 685L, 134L, 625L, 764L, 138L, 273L, 661L, 701L, 
     647L, 241L, 531L, 708L, 448L, 342L, 480L, 261L, 290L, 722L, 175L, 11L, 251L, 434L, 
     4L, 36L, 580L, 650L, 363L, 479L, 230L, 37L, 717L, 371L, 67L, 193L, 597L, 544L, 720L, 
     535L, 739L, 554L, 761L, 143L, 49L, 763L, 419L, 358L, 387L, 464L, 477L, 47L, 545L, 
     368L, 5L, 364L, 340L, 293L, 223L, 73L, 631L, 522L, 551L, 179L, 213L, 702L, 26L, 561L, 
     466L, 519L, 108L, 599L, 385L, 383L, 601L, 66L, 663L, 470L, 15L, 736L, 16L, 651L, 
     402L, 271L, 126L, 492L, 493L, 137L, 740L, 727L, 629L, 431L, 648L, 178L, 51L, 225L, 
     560L, 511L, 157L, 415L, 630L, 559L, 262L, 58L, 742L, 543L, 707L, 258L, 408L, 276L, 
     173L, 447L, 521L, 641L, 79L, 365L, 125L, 147L, 703L, 754L, 8L, 163L, 486L, 688L, 
     498L, 757L, 180L, 211L, 579L, 541L, 696L, 732L, 550L, 767L, 295L, 144L, 297L, 691L, 
     612L, 684L, 451L, 490L, 80L, 370L, 112L, 514L, 473L, 656L, 90L, 723L, 38L, 44L, 366L, 
     435L, 427L, 332L, 662L, 386L, 421L, 256L, 30L, 123L, 245L, 114L, 449L, 689L, 177L, 
     98L, 422L, 335L, 113L, 567L, 10L, 191L, 224L, 384L, 571L, 516L, 586L, 728L, 410L, 
     55L, 654L, 323L, 190L, 724L, 334L, 407L, 562L, 563L, 619L, 718L, 54L, 653L, 584L, 
     658L, 581L, 583L, 229L, 652L, 655L, 590L, 589L, 167L, 721L, 356L, 734L, 75L, 279L, 
     254L, 572L, 508L, 39L, 758L, 747L, 645L, 593L, 428L, 83L, 70L, 460L, 85L, 690L, 28L, 
     436L, 673L, 463L, 552L, 131L, 587L, 695L, 64L, 204L, 62L, 234L, 753L, 197L, 265L, 
     694L, 380L, 327L, 390L, 311L, 438L, 20L, 296L, 399L, 24L, 610L, 614L, 14L, 577L, 
     533L, 95L, 354L, 756L, 22L, 710L, 675L, 700L, 132L, 750L, 286L, 120L, 284L)), test.inds = list(
         c(564L, 237L, 393L, 744L, 705L, 260L, 615L, 709L, 60L, 627L, 282L, 150L, 646L, 
         482L, 369L, 12L, 553L, 468L, 283L, 643L, 300L, 671L, 500L, 13L, 677L, 42L, 667L, 
         61L, 467L, 154L, 118L, 252L, 65L, 389L, 501L, 649L, 746L, 698L, 549L, 738L, 484L, 
         475L, 299L, 462L, 218L, 525L, 440L, 575L, 107L, 53L, 172L, 255L, 122L, 759L, 
         270L, 328L, 102L, 151L, 374L, 687L, 613L, 57L, 250L, 491L, 360L, 414L, 3L, 686L, 
         235L, 338L, 339L, 481L, 355L, 425L, 294L, 465L, 628L, 642L, 638L, 737L, 319L, 
         406L, 130L, 409L, 450L, 458L, 542L, 176L, 23L, 461L, 232L, 315L, 171L, 413L, 
         362L, 547L, 317L, 278L, 453L, 503L, 25L, 2L, 208L, 292L, 128L, 43L, 324L, 608L, 
         103L, 312L, 534L, 735L, 596L, 18L, 620L, 210L, 594L, 512L, 626L, 6L, 280L, 600L, 
         373L, 166L, 664L, 755L, 146L, 305L, 352L, 206L, 337L, 713L, 382L, 502L, 576L, 
         139L, 116L, 372L, 249L, 124L, 417L, 566L, 72L, 181L, 9L, 346L, 529L, 430L, 670L, 
         345L, 483L, 185L, 52L, 668L, 412L, 45L, 548L, 253L, 275L, 187L, 41L, 56L, 165L, 
         183L, 201L, 31L, 285L, 81L, 92L, 50L, 639L, 392L, 264L, 361L, 507L, 267L, 135L, 
         325L, 200L, 202L, 632L, 476L, 161L, 405L, 17L, 592L, 129L, 528L, 349L, 455L, 
         489L, 309L, 457L, 395L, 437L, 244L, 105L, 320L, 683L, 558L, 217L, 749L, 499L, 
         400L, 247L, 274L, 188L, 86L, 634L, 174L, 84L, 76L, 117L, 644L, 46L, 699L, 578L, 
         602L, 674L, 236L, 288L, 21L, 411L, 474L, 170L, 74L, 485L, 303L, 242L, 697L, 657L, 
         94L, 716L, 310L, 182L, 423L, 203L, 100L, 532L, 391L, 432L, 704L, 353L, 220L, 
         189L, 679L, 510L, 456L, 487L, 158L, 537L, 376L, 219L, 623L, 34L, 595L)), group = structure(integer(0), .Label = character(0), class = "factor")), class = "ResampleInstance"), 
         measures = list(structure(list(id = "acc", minimize = FALSE, properties = c("classif", 
         "classif.multi", "req.pred", "req.truth"), fun = function (task, model, pred, 
             feats, extra.args) 
         {
             measureACC(pred$data$truth, pred$data$response)
         }, extra.args = list(), best = 1, worst = 0, name = "Accuracy", note = "Defined as: mean(response == truth)", 
             aggr = structure(list(id = "test.mean", name = "Test mean", fun = function (task, 
                 perf.test, perf.train, measure, group, pred) 
             mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure")), 
         par.set = structure(list(pars = list(C = structure(list(id = "C", type = "numeric", 
             len = 1L, lower = -5, upper = 5, values = NULL, cnames = NULL, allow.inf = FALSE, 
             has.default = FALSE, default = NULL, trafo = function (x) 
             2^x, requires = NULL, tunable = TRUE, special.vals = list()), class = "Param"), 
             sigma = structure(list(id = "sigma", type = "numeric", len = 1L, lower = -5, 
                 upper = 5, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                 default = NULL, trafo = function (x) 
                 2^x, requires = NULL, tunable = TRUE, special.vals = list()), class = "Param")), 
             forbidden = NULL), class = "ParamSet"), bits.to.features = NULL, control = structure(list(
             same.resampling.instance = TRUE, impute.val = 0, tune.threshold = FALSE, 
             tune.threshold.args = list(), log.fun = function (learner, task, resampling, 
                 measures, par.set, control, opt.path, dob, x, y, remove.nas, stage, prev.stage) 
             {
                 x.string = paramValueToString(par.set, x, show.missing.values = !remove.nas)
                 if (inherits(learner, "ModelMultiplexer")) 
                     x.string = stri_replace_all(x.string, "", regex = stri_paste(x$selected.learner, 
                       "\\."))
                 logFunDefault(learner, task, resampling, measures, par.set, control, 
                     opt.path, dob, x.string, y, remove.nas, stage, prev.stage, prefixes = c("Tune-x", 
                       "Tune-y"))
             }, final.dw.perc = NULL, extra.args = list(maxit = 5L), budget = 5L), class = c("TuneControlRandom", 
         "TuneControl", "OptControl")), opt.path = structure(list(par.set = structure(list(
             pars = list(C = structure(list(id = "C", type = "numeric", len = 1L, lower = -5, 
                 upper = 5, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                 default = NULL, trafo = function (x) 
                 2^x, requires = NULL, tunable = TRUE, special.vals = list()), class = "Param"), 
                 sigma = structure(list(id = "sigma", type = "numeric", len = 1L, lower = -5, 
                     upper = 5, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                     default = NULL, trafo = function (x) 
                     2^x, requires = NULL, tunable = TRUE, special.vals = list()), class = "Param")), 
             forbidden = NULL), class = "ParamSet"), y.names = "acc.test.mean", minimize = c(acc.test.mean = FALSE), 
             add.transformed.x = FALSE, env = <environment>), class = c("OptPathDF", "OptPath"
         )), show.info = FALSE, remove.nas = TRUE, resample.fun = function (learner, task, 
             resampling, measures, weights = NULL, models = FALSE, extract, keep.pred = TRUE, 
             ..., show.info = getMlrOption("show.info")) 
         {
             learner = checkLearner(learner)
             learner = setHyperPars(learner, ...)
             assertClass(task, classes = "Task")
             n = getTaskSize(task)
             if (inherits(resampling, "ResampleDesc")) 
                 resampling = makeResampleInstance(resampling, task = task)
             assertClass(resampling, classes = "ResampleInstance")
             measures = checkMeasures(measures, task)
             if (!is.null(weights)) {
                 assertNumeric(weights, len = n, any.missing = FALSE, lower = 0)
             }
             assertFlag(models)
             if (missing(extract)) 
                 extract = function(model) {
                 }
             else assertFunction(extract)
             assertFlag(show.info)
             r = resampling$size
             if (n != r) 
                 stop(stri_paste("Size of data set:", n, "and resampling instance:", r, 
                     "differ!", sep = " "))
             checkLearnerBeforeTrain(task, learner, weights)
             checkAggrsBeforeResample(measures, resampling$desc)
             rin = resampling
             more.args = list(learner = learner, task = task, rin = rin, weights = NULL, 
                 measures = measures, model = models, extract = extract, show.info = show.info)
             if (!is.null(weights)) {
                 more.args$weights = weights
             }
             else if (!is.null(getTaskWeights(task))) {
                 more.args$weights = getTaskWeights(task)
             }
             parallelLibrary("mlr", master = FALSE, level = "mlr.resample", show.info = FALSE)
             exportMlrOptions(level = "mlr.resample")
             if (show.info) {
                 messagef("Resampling: %s", rin$desc$id)
                 measure.lognames = extractSubList(measures, "id")
                 if (rin$desc$predict == "both") {
                     id.train = which(vlapply(measures, function(x) "req.train" %in% x$aggr$properties))
                     id.test = which(vlapply(measures, function(x) "req.test" %in% x$aggr$properties))
                     measure.lognames = c(stri_paste(measure.lognames[id.train], "train", 
                       sep = "."), stri_paste(measure.lognames[id.test], "test", sep = "."))
                 }
                 printResampleFormatLine("Measures:", measure.lognames)
             }
             time1 = Sys.time()
             iter.results = parallelMap(doResampleIteration, seq_len(rin$desc$iters), 
                 level = "mlr.resample", more.args = more.args)
             time2 = Sys.time()
             runtime = as.numeric(difftime(time2, time1, units = "secs"))
             addClasses(mergeResampleResult(learner$id, task, iter.results, measures, 
                 rin, models, extract, keep.pred, show.info, runtime), "ResampleResult")
         })
  8: measureTime({
         r = resample.fun(learner2, task, resampling, measures = measures, show.info = FALSE)
     })
  9: force(expr)
  10: resample.fun(learner2, task, resampling, measures = measures, show.info = FALSE)
  11: parallelMap(doResampleIteration, seq_len(rin$desc$iters), level = "mlr.resample", 
         more.args = more.args)
  12: options(parallelMap.nextmap = (getPMOptNextMap() + 1L))
  13: getPMOptNextMap()
  14: getPMOption("nextmap")
  15: getOption(sprintf("parallelMap.%s", opt), def)
  
  ── 50. Error: 2 hyperparams nested (@test_base_generateHyperParsEffect.R#225)  ─
  $ operator is invalid for atomic vectors
  1: resample(lrn, task = pid.task, resampling = cv2, extract = getTuneResult) at testthat/test_base_generateHyperParsEffect.R:225
  2: parallelMap(doResampleIteration, seq_len(rin$desc$iters), level = "mlr.resample", 
         more.args = more.args)
  3: mapply(fun2, ..., MoreArgs = more.args, SIMPLIFY = FALSE, USE.NAMES = FALSE)
  4: (function (learner, task, rin, i, measures, weights, model, extract, show.info) 
     {
         setSlaveOptions()
         train.i = rin$train.inds[[i]]
         test.i = rin$test.inds[[i]]
         calculateResampleIterationResult(learner = learner, task = task, i = i, train.i = train.i, 
             test.i = test.i, measures = measures, weights = weights, rdesc = rin$desc, 
             model = model, extract = extract, show.info = show.info)
     })(dots[[1L]][[1L]], learner = structure(list(id = "classif.ksvm.tuned", type = "classif", 
         package = "kernlab", properties = NULL, par.set = structure(list(pars = list(), 
             forbidden = NULL), class = "ParamSet"), par.vals = list(), predict.type = "response", 
         fix.factors.prediction = FALSE, next.learner = structure(list(id = "classif.ksvm", 
             type = "classif", package = "kernlab", properties = c("twoclass", "multiclass", 
             "numerics", "factors", "prob", "class.weights"), par.set = structure(list(
                 pars = list(scaled = structure(list(id = "scaled", type = "logical", 
                     len = 1L, lower = NULL, upper = NULL, values = list(`TRUE` = TRUE, 
                       `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = TRUE, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), type = structure(list(
                     id = "type", type = "discrete", len = 1L, lower = NULL, upper = NULL, 
                     values = list(`C-svc` = "C-svc", `nu-svc` = "nu-svc", `C-bsvc` = "C-bsvc", 
                       `spoc-svc` = "spoc-svc", `kbb-svc` = "kbb-svc"), cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = "C-svc", trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), kernel = structure(list(id = "kernel", type = "discrete", 
                     len = 1L, lower = NULL, upper = NULL, values = list(vanilladot = "vanilladot", 
                       polydot = "polydot", rbfdot = "rbfdot", tanhdot = "tanhdot", laplacedot = "laplacedot", 
                       besseldot = "besseldot", anovadot = "anovadot", splinedot = "splinedot"), 
                     cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = "rbfdot", 
                     trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), C = structure(list(
                     id = "C", type = "numeric", len = 1L, lower = 0, upper = Inf, values = NULL, 
                     cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 1, 
                     trafo = NULL, requires = type %in% c("C-svc", "C-bsvc", "spoc-svc", 
                       "kbb-svc"), tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), nu = structure(list(id = "nu", type = "numeric", len = 1L, 
                     lower = 0, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 0.2, trafo = NULL, requires = type == 
                       "nu-svc", tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), epsilon = structure(list(id = "epsilon", type = "numeric", 
                     len = 1L, lower = -Inf, upper = Inf, values = NULL, cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = 0.1, trafo = NULL, 
                     requires = type %in% c("eps-svr", "nu-svr", "eps-bsvm"), tunable = TRUE, 
                     special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), sigma = structure(list(id = "sigma", type = "numeric", len = 1L, 
                     lower = 0, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = FALSE, default = NULL, trafo = NULL, requires = kernel %in% 
                       c("rbfdot", "anovadot", "besseldot", "laplacedot"), tunable = TRUE, 
                     special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), degree = structure(list(id = "degree", type = "integer", len = 1L, 
                     lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 3L, trafo = NULL, requires = kernel %in% 
                       c("polydot", "anovadot", "besseldot"), tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), scale = structure(list(
                     id = "scale", type = "numeric", len = 1L, lower = 0, upper = Inf, 
                     values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = 1, trafo = NULL, requires = kernel %in% c("polydot", "tanhdot"), 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), offset = structure(list(id = "offset", type = "numeric", len = 1L, 
                     lower = -Inf, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 1, trafo = NULL, requires = kernel %in% 
                       c("polydot", "tanhdot"), tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), order = structure(list(
                     id = "order", type = "integer", len = 1L, lower = -Inf, upper = Inf, 
                     values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = 1L, trafo = NULL, requires = kernel == "besseldot", tunable = TRUE, 
                     special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), tol = structure(list(id = "tol", type = "numeric", len = 1L, 
                     lower = 0, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 0.001, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), shrinking = structure(list(id = "shrinking", type = "logical", 
                     len = 1L, lower = NULL, upper = NULL, values = list(`TRUE` = TRUE, 
                       `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = TRUE, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), class.weights = structure(list(
                     id = "class.weights", type = "numericvector", len = NA_integer_, 
                     lower = 0, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), fit = structure(list(id = "fit", type = "logical", len = 1L, 
                     lower = NULL, upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), 
                     cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = TRUE, 
                     trafo = NULL, requires = NULL, tunable = FALSE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), cache = structure(list(
                     id = "cache", type = "integer", len = 1L, lower = 1L, upper = Inf, 
                     values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = 40L, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param"))), forbidden = NULL), class = c("LearnerParamSet", 
             "ParamSet")), par.vals = list(fit = FALSE, kernel = "rbfdot"), predict.type = "response", 
             name = "Support Vector Machines", short.name = "ksvm", note = "Kernel parameters have to be passed directly and not by using the `kpar` list in `ksvm`. Note that `fit` has been set to `FALSE` by default for speed.", 
             callees = "ksvm", help.list = list(sigma = "Argument of: kernlab::ksvm\n\nfor the ANOVA kernel \"anovadot\".", 
                 degree = "Argument of: kernlab::ksvm\n\nfor the ANOVA kernel \"anovadot\".", 
                 scale = "Argument of: kernlab::ksvm\n\nfor the Hyperbolic tangent kernel function \"tanhdot\"", 
                 offset = "Argument of: kernlab::ksvm\n\nfor the Hyperbolic tangent kernel function \"tanhdot\"", 
                 order = "Argument of: kernlab::ksvm\n\nfor the Bessel kernel \"besseldot\".", 
                 scaled = "Argument of: kernlab::ksvm\n\nA logical vector indicating the variables to be scaled. If scaled is of length 1, the value is recycled as many times as needed and all non-binary variables are scaled. Per default, data are scaled internally (both x and y variables) to zero mean and unit variance. The center and scale values are returned and used for later predictions.", 
                 type = "Argument of: kernlab::ksvm\n\nksvm can be used for classification , for regression, or for novelty detection. Depending on whether y is a factor or not, the default setting for type is C-svc or eps-svr, respectively, but can be overwritten by setting an explicit value. Valid options are:\n\nC-svc   C classification\n\nnu-svc  nu classification\n\nC-bsvc  bound-constraint svm classification\n\nspoc-svc  Crammer, Singer native multi-class\n\nkbb-svc  Weston, Watkins native multi-class\n\none-svc  novelty detection\n\neps-svr  epsilon regression\n\nnu-svr   nu regression\n\neps-bsvr  bound-constraint svm regression", 
                 kernel = "Argument of: kernlab::ksvm\n\nthe kernel function used in training and predicting. This parameter can be set to any function, of class kernel, which computes the inner product in feature space between two vector arguments (see kernels). kernlab provides the most popular kernel functions which can be used by setting the kernel parameter to the following strings:\n\nrbfdot Radial Basis kernel \"Gaussian\"\n\npolydot Polynomial kernel\n\nvanilladot Linear kernel\n\ntanhdot Hyperbolic tangent kernel\n\nlaplacedot Laplacian kernel\n\nbesseldot Bessel kernel\n\nanovadot ANOVA RBF kernel\n\nsplinedot Spline kernel\n\nstringdot String kernel\n\nSetting the kernel parameter to \"matrix\" treats x as a kernel matrix calling the kernelMatrix interface. The kernel parameter can also be set to a user defined function of class kernel by passing the function name as an argument.", 
                 C = "Argument of: kernlab::ksvm\n\ncost of constraints violation (default: 1) this is the ‘C’-constant of the regularization term in the Lagrange formulation.", 
                 nu = "Argument of: kernlab::ksvm\n\nparameter needed for nu-svc, one-svc, and nu-svr. The nu parameter sets the upper bound on the training error and the lower bound on the fraction of data points to become Support Vectors (default: 0.2).", 
                 epsilon = "Argument of: kernlab::ksvm\n\nepsilon in the insensitive-loss function used for eps-svr, nu-svr and eps-bsvm (default: 0.1)", 
                 class.weights = "Argument of: kernlab::ksvm\n\na named vector of weights for the different classes, used for asymmetric class sizes. Not all factor levels have to be supplied (default weight: 1). All components have to be named.", 
                 cache = "Argument of: kernlab::ksvm\n\ncache memory in MB (default 40)", 
                 tol = "Argument of: kernlab::ksvm\n\ntolerance of termination criterion (default: 0.001)", 
                 shrinking = "Argument of: kernlab::ksvm\n\noption whether to use the shrinking-heuristics (default: TRUE)", 
                 fit = "Argument of: kernlab::ksvm\n\nindicates whether the fitted values should be computed and included in the model or not (default: TRUE)"), 
             class.weights.param = "class.weights", config = list(), fix.factors.prediction = FALSE), class = c("classif.ksvm", 
         "RLearnerClassif", "RLearner", "Learner")), model.subclass = "TuneModel", resampling = structure(list(
             split = 0.666666666666667, id = "holdout", iters = 1L, predict = "test", 
             stratify = FALSE), class = c("HoldoutDesc", "ResampleDesc")), measures = list(
             structure(list(id = "acc", minimize = FALSE, properties = c("classif", "classif.multi", 
             "req.pred", "req.truth"), fun = function (task, model, pred, feats, extra.args) 
             {
                 measureACC(pred$data$truth, pred$data$response)
             }, extra.args = list(), best = 1, worst = 0, name = "Accuracy", note = "Defined as: mean(response == truth)", 
                 aggr = structure(list(id = "test.mean", name = "Test mean", fun = function (task, 
                     perf.test, perf.train, measure, group, pred) 
                 mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure"), 
             structure(list(id = "mmce", minimize = TRUE, properties = c("classif", "classif.multi", 
             "req.pred", "req.truth"), fun = function (task, model, pred, feats, extra.args) 
             {
                 measureMMCE(pred$data$truth, pred$data$response)
             }, extra.args = list(), best = 0, worst = 1, name = "Mean misclassification error", 
                 note = "Defined as: mean(response != truth)", aggr = structure(list(id = "test.mean", 
                     name = "Test mean", fun = function (task, perf.test, perf.train, 
                       measure, group, pred) 
                     mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure")), 
         opt.pars = structure(list(pars = list(C = structure(list(id = "C", type = "numeric", 
             len = 1L, lower = -5, upper = 5, values = NULL, cnames = NULL, allow.inf = FALSE, 
             has.default = FALSE, default = NULL, trafo = function (x) 
             2^x, requires = NULL, tunable = TRUE, special.vals = list()), class = "Param"), 
             sigma = structure(list(id = "sigma", type = "numeric", len = 1L, lower = -5, 
                 upper = 5, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                 default = NULL, trafo = function (x) 
                 2^x, requires = NULL, tunable = TRUE, special.vals = list()), class = "Param")), 
             forbidden = NULL), class = "ParamSet"), bit.names = character(0), bits.to.features = function () 
         {
         }, control = structure(list(same.resampling.instance = TRUE, impute.val = NULL, 
             tune.threshold = FALSE, tune.threshold.args = list(), log.fun = function (learner, 
                 task, resampling, measures, par.set, control, opt.path, dob, x, y, remove.nas, 
                 stage, prev.stage) 
             {
                 x.string = paramValueToString(par.set, x, show.missing.values = !remove.nas)
                 if (inherits(learner, "ModelMultiplexer")) 
                     x.string = stri_replace_all(x.string, "", regex = stri_paste(x$selected.learner, 
                       "\\."))
                 logFunDefault(learner, task, resampling, measures, par.set, control, 
                     opt.path, dob, x.string, y, remove.nas, stage, prev.stage, prefixes = c("Tune-x", 
                       "Tune-y"))
             }, final.dw.perc = NULL, extra.args = list(maxit = 5L), budget = 5L), class = c("TuneControlRandom", 
         "TuneControl", "OptControl")), show.info = FALSE), class = c("TuneWrapper", "OptWrapper", 
     "BaseWrapper", "Learner")), task = structure(list(type = "classif", env = <environment>, 
         weights = NULL, blocking = NULL, coordinates = NULL, task.desc = structure(list(
             id = "PimaIndiansDiabetes-example", type = "classif", target = "diabetes", 
             size = 768L, n.feat = c(numerics = 8L, factors = 0L, ordered = 0L, functionals = 0L
             ), has.missings = FALSE, has.weights = FALSE, has.blocking = FALSE, has.coordinates = FALSE, 
             class.levels = c("neg", "pos"), positive = "pos", negative = "neg", class.distribution = structure(c(neg = 500L, 
             pos = 268L), .Dim = 2L, .Dimnames = list(c("neg", "pos")), class = "table")), class = c("ClassifTaskDesc", 
         "SupervisedTaskDesc", "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", 
     "Task")), rin = structure(list(desc = structure(list(id = "cross-validation", iters = 2L, 
         predict = "test", stratify = FALSE), class = c("CVDesc", "ResampleDesc")), size = 768L, 
         train.inds = list(c(525L, 502L, 517L, 617L, 482L, 12L, 493L, 611L, 15L, 684L, 
         405L, 595L, 303L, 208L, 267L, 192L, 709L, 357L, 546L, 486L, 504L, 264L, 101L, 
         403L, 223L, 433L, 707L, 530L, 54L, 3L, 545L, 507L, 468L, 202L, 68L, 670L, 512L, 
         426L, 84L, 182L, 620L, 163L, 498L, 489L, 297L, 646L, 602L, 29L, 316L, 416L, 340L, 
         94L, 113L, 350L, 570L, 9L, 457L, 587L, 672L, 442L, 762L, 614L, 274L, 169L, 145L, 
         683L, 432L, 352L, 487L, 244L, 509L, 588L, 370L, 423L, 323L, 481L, 706L, 634L, 
         756L, 596L, 367L, 238L, 198L, 685L, 686L, 526L, 428L, 693L, 124L, 765L, 577L, 
         642L, 749L, 582L, 248L, 56L, 601L, 240L, 245L, 755L, 559L, 722L, 237L, 81L, 313L, 
         272L, 443L, 27L, 159L, 4L, 395L, 510L, 48L, 218L, 449L, 553L, 59L, 318L, 86L, 
         254L, 411L, 733L, 653L, 266L, 11L, 404L, 333L, 243L, 301L, 657L, 681L, 137L, 
         118L, 275L, 226L, 66L, 662L, 505L, 75L, 610L, 715L, 120L, 737L, 718L, 635L, 644L, 
         261L, 37L, 336L, 64L, 263L, 368L, 555L, 408L, 371L, 125L, 732L, 511L, 344L, 459L, 
         603L, 579L, 52L, 58L, 327L, 480L, 95L, 580L, 229L, 717L, 407L, 643L, 166L, 103L, 
         178L, 393L, 111L, 628L, 573L, 566L, 49L, 230L, 332L, 285L, 461L, 750L, 115L, 
         539L, 330L, 161L, 675L, 641L, 390L, 425L, 589L, 583L, 458L, 78L, 172L, 719L, 
         565L, 495L, 151L, 533L, 136L, 242L, 467L, 660L, 491L, 328L, 289L, 496L, 22L, 
         430L, 420L, 436L, 325L, 475L, 380L, 262L, 532L, 63L, 514L, 568L, 278L, 723L, 
         154L, 70L, 659L, 695L, 766L, 550L, 93L, 712L, 434L, 184L, 129L, 557L, 632L, 655L, 
         209L, 454L, 356L, 41L, 273L, 170L, 607L, 18L, 253L, 544L, 661L, 645L, 378L, 492L, 
         764L, 415L, 721L, 738L, 309L, 508L, 392L, 201L, 576L, 185L, 200L, 399L, 422L, 
         439L, 389L, 17L, 529L, 23L, 379L, 228L, 758L, 374L, 592L, 724L, 8L, 626L, 503L, 
         528L, 206L, 60L, 348L, 355L, 513L, 183L, 219L, 112L, 427L, 25L, 612L, 87L, 314L, 
         44L, 181L, 235L, 741L, 383L, 216L, 304L, 341L, 453L, 398L, 622L, 563L, 739L, 
         97L, 447L, 571L, 754L, 286L, 625L, 677L, 648L, 387L, 205L, 554L, 65L, 621L, 150L, 
         650L, 249L, 189L, 400L, 121L, 616L, 656L, 767L, 131L, 465L, 351L, 470L, 108L, 
         391L, 479L, 139L, 109L, 584L, 107L, 729L, 664L, 102L, 372L, 221L, 600L, 148L, 
         141L, 599L, 19L, 156L, 62L, 605L, 132L, 561L, 680L, 440L, 295L, 236L, 654L, 21L, 
         572L, 497L, 746L, 671L, 16L, 271L, 471L, 551L, 472L, 649L, 177L, 386L, 651L, 
         666L, 239L, 591L, 42L, 564L, 167L, 251L, 396L, 222L), c(702L, 623L, 98L, 191L, 
         252L, 310L, 613L, 196L, 619L, 347L, 153L, 212L, 697L, 164L, 364L, 77L, 751L, 
         269L, 90L, 35L, 193L, 349L, 36L, 640L, 560L, 213L, 91L, 424L, 494L, 321L, 38L, 
         241L, 519L, 326L, 402L, 753L, 460L, 381L, 7L, 734L, 224L, 679L, 345L, 82L, 51L, 
         287L, 437L, 691L, 106L, 740L, 366L, 506L, 446L, 71L, 604L, 727L, 194L, 667L, 
         521L, 13L, 33L, 682L, 541L, 569L, 516L, 45L, 638L, 360L, 329L, 26L, 419L, 720L, 
         338L, 477L, 538L, 466L, 96L, 673L, 524L, 292L, 232L, 698L, 179L, 92L, 615L, 217L, 
         375L, 726L, 246L, 293L, 259L, 358L, 520L, 704L, 67L, 714L, 463L, 152L, 361L, 
         531L, 197L, 234L, 255L, 736L, 499L, 418L, 76L, 85L, 105L, 578L, 122L, 312L, 307L, 
         748L, 382L, 147L, 455L, 451L, 157L, 233L, 639L, 658L, 742L, 647L, 618L, 409L, 
         203L, 688L, 594L, 282L, 280L, 414L, 730L, 725L, 257L, 731L, 689L, 484L, 401L, 
         268L, 133L, 317L, 117L, 138L, 342L, 540L, 83L, 146L, 175L, 575L, 456L, 296L, 
         290L, 14L, 768L, 79L, 474L, 188L, 123L, 53L, 362L, 215L, 334L, 674L, 501L, 127L, 
         88L, 663L, 631L, 258L, 283L, 31L, 204L, 438L, 549L, 298L, 130L, 24L, 606L, 527L, 
         220L, 431L, 302L, 104L, 534L, 562L, 636L, 128L, 711L, 354L, 231L, 288L, 142L, 
         324L, 80L, 692L, 627L, 256L, 696L, 55L, 536L, 547L, 713L, 763L, 260L, 143L, 34L, 
         227L, 1L, 500L, 708L, 306L, 703L, 728L, 276L, 207L, 43L, 490L, 155L, 629L, 300L, 
         413L, 744L, 590L, 162L, 609L, 444L, 165L, 633L, 110L, 445L, 335L, 265L, 2L, 99L, 
         311L, 574L, 211L, 552L, 747L, 435L, 743L, 745L, 757L, 462L, 69L, 160L, 279L, 
         40L, 652L, 168L, 149L, 429L, 567L, 284L, 586L, 543L, 452L, 376L, 294L, 388L, 
         50L, 476L, 687L, 74L, 176L, 135L, 523L, 195L, 32L, 47L, 190L, 450L, 473L, 73L, 
         558L, 669L, 518L, 291L, 421L, 210L, 630L, 369L, 119L, 126L, 89L, 144L, 343L, 
         270L, 464L, 320L, 700L, 5L, 186L, 598L, 28L, 485L, 319L, 250L, 30L, 57L, 694L, 
         187L, 384L, 394L, 337L, 10L, 483L, 535L, 114L, 710L, 759L, 441L, 100L, 72L, 585L, 
         116L, 20L, 690L, 410L, 339L, 735L, 214L, 171L, 247L, 699L, 716L, 140L, 225L, 
         397L, 39L, 593L, 678L, 597L, 537L, 6L, 417L, 277L, 412L, 760L, 676L, 701L, 61L, 
         624L, 353L, 331L, 548L, 665L, 761L, 752L, 556L, 281L, 299L, 346L, 46L, 174L, 
         158L, 488L, 637L, 363L, 359L, 173L, 668L, 469L, 478L, 305L, 406L, 365L, 542L, 
         705L, 315L, 308L, 515L, 373L, 134L, 377L, 322L, 385L, 522L, 448L, 608L, 199L, 
         180L, 581L)), test.inds = list(c(1L, 2L, 5L, 6L, 7L, 10L, 13L, 14L, 20L, 24L, 
         26L, 28L, 30L, 31L, 32L, 33L, 34L, 35L, 36L, 38L, 39L, 40L, 43L, 45L, 46L, 47L, 
         50L, 51L, 53L, 55L, 57L, 61L, 67L, 69L, 71L, 72L, 73L, 74L, 76L, 77L, 79L, 80L, 
         82L, 83L, 85L, 88L, 89L, 90L, 91L, 92L, 96L, 98L, 99L, 100L, 104L, 105L, 106L, 
         110L, 114L, 116L, 117L, 119L, 122L, 123L, 126L, 127L, 128L, 130L, 133L, 134L, 
         135L, 138L, 140L, 142L, 143L, 144L, 146L, 147L, 149L, 152L, 153L, 155L, 157L, 
         158L, 160L, 162L, 164L, 165L, 168L, 171L, 173L, 174L, 175L, 176L, 179L, 180L, 
         186L, 187L, 188L, 190L, 191L, 193L, 194L, 195L, 196L, 197L, 199L, 203L, 204L, 
         207L, 210L, 211L, 212L, 213L, 214L, 215L, 217L, 220L, 224L, 225L, 227L, 231L, 
         232L, 233L, 234L, 241L, 246L, 247L, 250L, 252L, 255L, 256L, 257L, 258L, 259L, 
         260L, 265L, 268L, 269L, 270L, 276L, 277L, 279L, 280L, 281L, 282L, 283L, 284L, 
         287L, 288L, 290L, 291L, 292L, 293L, 294L, 296L, 298L, 299L, 300L, 302L, 305L, 
         306L, 307L, 308L, 310L, 311L, 312L, 315L, 317L, 319L, 320L, 321L, 322L, 324L, 
         326L, 329L, 331L, 334L, 335L, 337L, 338L, 339L, 342L, 343L, 345L, 346L, 347L, 
         349L, 353L, 354L, 358L, 359L, 360L, 361L, 362L, 363L, 364L, 365L, 366L, 369L, 
         373L, 375L, 376L, 377L, 381L, 382L, 384L, 385L, 388L, 394L, 397L, 401L, 402L, 
         406L, 409L, 410L, 412L, 413L, 414L, 417L, 418L, 419L, 421L, 424L, 429L, 431L, 
         435L, 437L, 438L, 441L, 444L, 445L, 446L, 448L, 450L, 451L, 452L, 455L, 456L, 
         460L, 462L, 463L, 464L, 466L, 469L, 473L, 474L, 476L, 477L, 478L, 483L, 484L, 
         485L, 488L, 490L, 494L, 499L, 500L, 501L, 506L, 515L, 516L, 518L, 519L, 520L, 
         521L, 522L, 523L, 524L, 527L, 531L, 534L, 535L, 536L, 537L, 538L, 540L, 541L, 
         542L, 543L, 547L, 548L, 549L, 552L, 556L, 558L, 560L, 562L, 567L, 569L, 574L, 
         575L, 578L, 581L, 585L, 586L, 590L, 593L, 594L, 597L, 598L, 604L, 606L, 608L, 
         609L, 613L, 615L, 618L, 619L, 623L, 624L, 627L, 629L, 630L, 631L, 633L, 636L, 
         637L, 638L, 639L, 640L, 647L, 652L, 658L, 663L, 665L, 667L, 668L, 669L, 673L, 
         674L, 676L, 678L, 679L, 682L, 687L, 688L, 689L, 690L, 691L, 692L, 694L, 696L, 
         697L, 698L, 699L, 700L, 701L, 702L, 703L, 704L, 705L, 708L, 710L, 711L, 713L, 
         714L, 716L, 720L, 725L, 726L, 727L, 728L, 730L, 731L, 734L, 735L, 736L, 740L, 
         742L, 743L, 744L, 745L, 747L, 748L, 751L, 752L, 753L, 757L, 759L, 760L, 761L, 
         763L, 768L), c(3L, 4L, 8L, 9L, 11L, 12L, 15L, 16L, 17L, 18L, 19L, 21L, 22L, 23L, 
         25L, 27L, 29L, 37L, 41L, 42L, 44L, 48L, 49L, 52L, 54L, 56L, 58L, 59L, 60L, 62L, 
         63L, 64L, 65L, 66L, 68L, 70L, 75L, 78L, 81L, 84L, 86L, 87L, 93L, 94L, 95L, 97L, 
         101L, 102L, 103L, 107L, 108L, 109L, 111L, 112L, 113L, 115L, 118L, 120L, 121L, 
         124L, 125L, 129L, 131L, 132L, 136L, 137L, 139L, 141L, 145L, 148L, 150L, 151L, 
         154L, 156L, 159L, 161L, 163L, 166L, 167L, 169L, 170L, 172L, 177L, 178L, 181L, 
         182L, 183L, 184L, 185L, 189L, 192L, 198L, 200L, 201L, 202L, 205L, 206L, 208L, 
         209L, 216L, 218L, 219L, 221L, 222L, 223L, 226L, 228L, 229L, 230L, 235L, 236L, 
         237L, 238L, 239L, 240L, 242L, 243L, 244L, 245L, 248L, 249L, 251L, 253L, 254L, 
         261L, 262L, 263L, 264L, 266L, 267L, 271L, 272L, 273L, 274L, 275L, 278L, 285L, 
         286L, 289L, 295L, 297L, 301L, 303L, 304L, 309L, 313L, 314L, 316L, 318L, 323L, 
         325L, 327L, 328L, 330L, 332L, 333L, 336L, 340L, 341L, 344L, 348L, 350L, 351L, 
         352L, 355L, 356L, 357L, 367L, 368L, 370L, 371L, 372L, 374L, 378L, 379L, 380L, 
         383L, 386L, 387L, 389L, 390L, 391L, 392L, 393L, 395L, 396L, 398L, 399L, 400L, 
         403L, 404L, 405L, 407L, 408L, 411L, 415L, 416L, 420L, 422L, 423L, 425L, 426L, 
         427L, 428L, 430L, 432L, 433L, 434L, 436L, 439L, 440L, 442L, 443L, 447L, 449L, 
         453L, 454L, 457L, 458L, 459L, 461L, 465L, 467L, 468L, 470L, 471L, 472L, 475L, 
         479L, 480L, 481L, 482L, 486L, 487L, 489L, 491L, 492L, 493L, 495L, 496L, 497L, 
         498L, 502L, 503L, 504L, 505L, 507L, 508L, 509L, 510L, 511L, 512L, 513L, 514L, 
         517L, 525L, 526L, 528L, 529L, 530L, 532L, 533L, 539L, 544L, 545L, 546L, 550L, 
         551L, 553L, 554L, 555L, 557L, 559L, 561L, 563L, 564L, 565L, 566L, 568L, 570L, 
         571L, 572L, 573L, 576L, 577L, 579L, 580L, 582L, 583L, 584L, 587L, 588L, 589L, 
         591L, 592L, 595L, 596L, 599L, 600L, 601L, 602L, 603L, 605L, 607L, 610L, 611L, 
         612L, 614L, 616L, 617L, 620L, 621L, 622L, 625L, 626L, 628L, 632L, 634L, 635L, 
         641L, 642L, 643L, 644L, 645L, 646L, 648L, 649L, 650L, 651L, 653L, 654L, 655L, 
         656L, 657L, 659L, 660L, 661L, 662L, 664L, 666L, 670L, 671L, 672L, 675L, 677L, 
         680L, 681L, 683L, 684L, 685L, 686L, 693L, 695L, 706L, 707L, 709L, 712L, 715L, 
         717L, 718L, 719L, 721L, 722L, 723L, 724L, 729L, 732L, 733L, 737L, 738L, 739L, 
         741L, 746L, 749L, 750L, 754L, 755L, 756L, 758L, 762L, 764L, 765L, 766L, 767L)), 
         group = structure(integer(0), .Label = character(0), class = "factor")), class = "ResampleInstance"), 
         weights = NULL, measures = list(structure(list(id = "mmce", minimize = TRUE, 
             properties = c("classif", "classif.multi", "req.pred", "req.truth"), fun = function (task, 
                 model, pred, feats, extra.args) 
             {
                 measureMMCE(pred$data$truth, pred$data$response)
             }, extra.args = list(), best = 0, worst = 1, name = "Mean misclassification error", 
             note = "Defined as: mean(response != truth)", aggr = structure(list(id = "test.mean", 
                 name = "Test mean", fun = function (task, perf.test, perf.train, measure, 
                     group, pred) 
                 mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure")), 
         model = FALSE, extract = function (object) 
         {
             assertClass(object, "TuneModel")
             object$learner.model$opt.result
         }, show.info = FALSE)
  5: calculateResampleIterationResult(learner = learner, task = task, i = i, train.i = train.i, 
         test.i = test.i, measures = measures, weights = weights, rdesc = rin$desc, model = model, 
         extract = extract, show.info = show.info)
  6: isFailureModel(m)
  7: isFailureModel.BaseWrapperModel(m)
  8: isFailureModel(model$learner.model$next.model)
  
  ── 51. Error: 2+ hyperparams (@test_base_generateHyperParsEffect.R#278)  ───────
  argument "def" is missing, with no default
  1: tuneParams(learn, task = pid.task, control = ctrl, measures = list(acc, setAggregation(acc, 
         train.mean)), resampling = rdesc, par.set = ps, show.info = FALSE) at testthat/test_base_generateHyperParsEffect.R:278
  2: sel.func(learner, task, resampling, measures, par.set, control, opt.path, show.info, 
         resample.fun)
  3: evalOptimizationStatesTune(learner, task, resampling, measures, par.set, control, 
         opt.path, show.info, vals, dobs = seq_along(vals), eols = NA_integer_, remove.nas = TRUE, 
         resample.fun)
  4: evalOptimizationStates(learner, task, resampling, measures, par.set, NULL, control, 
         opt.path, show.info, states, dobs, eols, remove.nas, resample.fun, "mlr.tuneParams")
  5: parallelMap(evalOptimizationState, dobs, states, level = level, more.args = list(learner = learner, 
         task = task, resampling = resampling, measures = measures, par.set = par.set, 
         bits.to.features = bits.to.features, control = control, opt.path = opt.path, 
         show.info = show.info, remove.nas = remove.nas, resample.fun = resample.fun))
  6: mapply(fun2, ..., MoreArgs = more.args, SIMPLIFY = FALSE, USE.NAMES = FALSE)
  7: (function (learner, task, resampling, measures, par.set, bits.to.features, control, 
         opt.path, show.info, dob, state, remove.nas, resample.fun) 
     {
         setSlaveOptions()
         y = setNames(rep(NA_real_, length(measures)), vcapply(measures, measureAggrName))
         errmsg = NA_character_
         exec.time = NA_real_
         set.pars.ok = TRUE
         learner2 = learner
         threshold = NULL
         log.fun = control$log.fun
         err.dumps = list()
         if (inherits(control, "TuneControl") || inherits(control, "TuneMultiCritControl")) {
             state = setValueCNames(par.set, state)
             state = trafoValue(par.set, state)
             state2 = if (remove.nas) 
                 removeMissingValues(state)
             else state
             learner2 = try(setHyperPars(learner, par.vals = state2), silent = TRUE)
             if (is.error(learner2)) {
                 set.pars.ok = FALSE
                 errmsg = as.character(learner2)
                 if (show.info) 
                     messagef("[Tune-x] Setting hyperpars failed: %s", errmsg)
             }
         }
         else if (inherits(control, "FeatSelControl")) {
             task = subsetTask(task, features = bits.to.features(state, task))
         }
         if (show.info) 
             prev.stage = log.fun(learner, task, resampling, measures, par.set, control, 
                 opt.path, dob, state, NA_real_, remove.nas, stage = 1L)
         if (set.pars.ok) {
             exec.time = measureTime({
                 r = resample.fun(learner2, task, resampling, measures = measures, show.info = FALSE)
             })
             if (control$tune.threshold) {
                 th.args = control$tune.threshold.args
                 th.args$pred = r$pred
                 th.args$measure = measures[[1L]]
                 tune.th.res = do.call(tuneThreshold, th.args)
                 threshold = tune.th.res$th
                 y = performance(setThreshold(r$pred, threshold = threshold), measures = measures)
                 names(y) = names(r$aggr)
             }
             else {
                 y = r$aggr
             }
             errmsgs = as.character(t(r$err.msgs[, -1L]))
             notna = !is.na(errmsgs)
             if (any(notna)) 
                 errmsg = errmsgs[notna][1L]
             err.dumps = r$err.dumps
         }
         else {
             if (control$tune.threshold) 
                 threshold = NA_real_
         }
         if (show.info) 
             log.fun(learner, task, resampling, measures, par.set, control, opt.path, 
                 dob, state, y, remove.nas, stage = 2L, prev.stage = prev.stage)
         list(y = y, exec.time = exec.time, errmsg = errmsg, threshold = threshold, err.dumps = err.dumps)
     })(dots[[1L]][[1L]], dots[[2L]][[1L]], learner = structure(list(id = "classif.ksvm", 
         type = "classif", package = "kernlab", properties = c("twoclass", "multiclass", 
         "numerics", "factors", "prob", "class.weights"), par.set = structure(list(pars = list(
             scaled = structure(list(id = "scaled", type = "logical", len = 1L, lower = NULL, 
                 upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, 
                 allow.inf = FALSE, has.default = TRUE, default = TRUE, trafo = NULL, 
                 requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), type = structure(list(id = "type", type = "discrete", len = 1L, 
                 lower = NULL, upper = NULL, values = list(`C-svc` = "C-svc", `nu-svc` = "nu-svc", 
                     `C-bsvc` = "C-bsvc", `spoc-svc` = "spoc-svc", `kbb-svc` = "kbb-svc"), 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = "C-svc", 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), kernel = structure(list(
                 id = "kernel", type = "discrete", len = 1L, lower = NULL, upper = NULL, 
                 values = list(vanilladot = "vanilladot", polydot = "polydot", rbfdot = "rbfdot", 
                     tanhdot = "tanhdot", laplacedot = "laplacedot", besseldot = "besseldot", 
                     anovadot = "anovadot", splinedot = "splinedot"), cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = "rbfdot", trafo = NULL, requires = NULL, 
                 tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), C = structure(list(id = "C", type = "numeric", len = 1L, lower = 0, 
                 upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 1, trafo = NULL, requires = type %in% c("C-svc", "C-bsvc", 
                     "spoc-svc", "kbb-svc"), tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), nu = structure(list(id = "nu", type = "numeric", len = 1L, lower = 0, 
                 upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 0.2, trafo = NULL, requires = type == "nu-svc", tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), epsilon = structure(list(id = "epsilon", type = "numeric", len = 1L, 
                 lower = -Inf, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 0.1, trafo = NULL, requires = type %in% 
                     c("eps-svr", "nu-svr", "eps-bsvm"), tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), sigma = structure(list(
                 id = "sigma", type = "numeric", len = 1L, lower = 0, upper = Inf, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, 
                 trafo = NULL, requires = kernel %in% c("rbfdot", "anovadot", "besseldot", 
                     "laplacedot"), tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), degree = structure(list(id = "degree", type = "integer", len = 1L, 
                 lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 3L, trafo = NULL, requires = kernel %in% 
                     c("polydot", "anovadot", "besseldot"), tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), scale = structure(list(
                 id = "scale", type = "numeric", len = 1L, lower = 0, upper = Inf, values = NULL, 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 1, trafo = NULL, 
                 requires = kernel %in% c("polydot", "tanhdot"), tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), offset = structure(list(
                 id = "offset", type = "numeric", len = 1L, lower = -Inf, upper = Inf, 
                 values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 1, trafo = NULL, requires = kernel %in% c("polydot", "tanhdot"), 
                 tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), order = structure(list(id = "order", type = "integer", len = 1L, 
                 lower = -Inf, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 1L, trafo = NULL, requires = kernel == 
                     "besseldot", tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), tol = structure(list(id = "tol", type = "numeric", len = 1L, lower = 0, 
                 upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 0.001, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), shrinking = structure(list(
                 id = "shrinking", type = "logical", len = 1L, lower = NULL, upper = NULL, 
                 values = list(`TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = TRUE, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), class.weights = structure(list(id = "class.weights", type = "numericvector", 
                 len = NA_integer_, lower = 0, upper = Inf, values = NULL, cnames = NULL, 
                 allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, 
                 requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), fit = structure(list(id = "fit", type = "logical", len = 1L, lower = NULL, 
                 upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, 
                 allow.inf = FALSE, has.default = TRUE, default = TRUE, trafo = NULL, 
                 requires = NULL, tunable = FALSE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), cache = structure(list(id = "cache", type = "integer", len = 1L, 
                 lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 40L, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             ))), forbidden = NULL), class = c("LearnerParamSet", "ParamSet")), par.vals = list(
             fit = FALSE, kernel = "besseldot"), predict.type = "response", name = "Support Vector Machines", 
         short.name = "ksvm", note = "Kernel parameters have to be passed directly and not by using the `kpar` list in `ksvm`. Note that `fit` has been set to `FALSE` by default for speed.", 
         callees = "ksvm", help.list = list(sigma = "Argument of: kernlab::ksvm\n\nfor the ANOVA kernel \"anovadot\".", 
             degree = "Argument of: kernlab::ksvm\n\nfor the ANOVA kernel \"anovadot\".", 
             scale = "Argument of: kernlab::ksvm\n\nfor the Hyperbolic tangent kernel function \"tanhdot\"", 
             offset = "Argument of: kernlab::ksvm\n\nfor the Hyperbolic tangent kernel function \"tanhdot\"", 
             order = "Argument of: kernlab::ksvm\n\nfor the Bessel kernel \"besseldot\".", 
             scaled = "Argument of: kernlab::ksvm\n\nA logical vector indicating the variables to be scaled. If scaled is of length 1, the value is recycled as many times as needed and all non-binary variables are scaled. Per default, data are scaled internally (both x and y variables) to zero mean and unit variance. The center and scale values are returned and used for later predictions.", 
             type = "Argument of: kernlab::ksvm\n\nksvm can be used for classification , for regression, or for novelty detection. Depending on whether y is a factor or not, the default setting for type is C-svc or eps-svr, respectively, but can be overwritten by setting an explicit value. Valid options are:\n\nC-svc   C classification\n\nnu-svc  nu classification\n\nC-bsvc  bound-constraint svm classification\n\nspoc-svc  Crammer, Singer native multi-class\n\nkbb-svc  Weston, Watkins native multi-class\n\none-svc  novelty detection\n\neps-svr  epsilon regression\n\nnu-svr   nu regression\n\neps-bsvr  bound-constraint svm regression", 
             kernel = "Argument of: kernlab::ksvm\n\nthe kernel function used in training and predicting. This parameter can be set to any function, of class kernel, which computes the inner product in feature space between two vector arguments (see kernels). kernlab provides the most popular kernel functions which can be used by setting the kernel parameter to the following strings:\n\nrbfdot Radial Basis kernel \"Gaussian\"\n\npolydot Polynomial kernel\n\nvanilladot Linear kernel\n\ntanhdot Hyperbolic tangent kernel\n\nlaplacedot Laplacian kernel\n\nbesseldot Bessel kernel\n\nanovadot ANOVA RBF kernel\n\nsplinedot Spline kernel\n\nstringdot String kernel\n\nSetting the kernel parameter to \"matrix\" treats x as a kernel matrix calling the kernelMatrix interface. The kernel parameter can also be set to a user defined function of class kernel by passing the function name as an argument.", 
             C = "Argument of: kernlab::ksvm\n\ncost of constraints violation (default: 1) this is the ‘C’-constant of the regularization term in the Lagrange formulation.", 
             nu = "Argument of: kernlab::ksvm\n\nparameter needed for nu-svc, one-svc, and nu-svr. The nu parameter sets the upper bound on the training error and the lower bound on the fraction of data points to become Support Vectors (default: 0.2).", 
             epsilon = "Argument of: kernlab::ksvm\n\nepsilon in the insensitive-loss function used for eps-svr, nu-svr and eps-bsvm (default: 0.1)", 
             class.weights = "Argument of: kernlab::ksvm\n\na named vector of weights for the different classes, used for asymmetric class sizes. Not all factor levels have to be supplied (default weight: 1). All components have to be named.", 
             cache = "Argument of: kernlab::ksvm\n\ncache memory in MB (default 40)", 
             tol = "Argument of: kernlab::ksvm\n\ntolerance of termination criterion (default: 0.001)", 
             shrinking = "Argument of: kernlab::ksvm\n\noption whether to use the shrinking-heuristics (default: TRUE)", 
             fit = "Argument of: kernlab::ksvm\n\nindicates whether the fitted values should be computed and included in the model or not (default: TRUE)"), 
         class.weights.param = "class.weights", config = list(), fix.factors.prediction = FALSE), class = c("classif.ksvm", 
     "RLearnerClassif", "RLearner", "Learner")), task = structure(list(type = "classif", 
         env = <environment>, weights = NULL, blocking = NULL, coordinates = NULL, task.desc = structure(list(
             id = "PimaIndiansDiabetes-example", type = "classif", target = "diabetes", 
             size = 768L, n.feat = c(numerics = 8L, factors = 0L, ordered = 0L, functionals = 0L
             ), has.missings = FALSE, has.weights = FALSE, has.blocking = FALSE, has.coordinates = FALSE, 
             class.levels = c("neg", "pos"), positive = "pos", negative = "neg", class.distribution = structure(c(neg = 500L, 
             pos = 268L), .Dim = 2L, .Dimnames = list(c("neg", "pos")), class = "table")), class = c("ClassifTaskDesc", 
         "SupervisedTaskDesc", "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", 
     "Task")), resampling = structure(list(desc = structure(list(split = 0.666666666666667, 
         id = "holdout", iters = 1L, predict = "both", stratify = FALSE), class = c("HoldoutDesc", 
     "ResampleDesc")), size = 768L, train.inds = list(c(221L, 605L, 314L, 676L, 719L, 
     35L, 403L, 680L, 420L, 347L, 726L, 344L, 513L, 433L, 78L, 678L, 186L, 32L, 246L, 
     715L, 666L, 518L, 478L, 741L, 488L, 527L, 404L, 441L, 214L, 109L, 711L, 665L, 509L, 
     585L, 19L, 351L, 556L, 159L, 233L, 169L, 104L, 302L, 301L, 268L, 111L, 101L, 729L, 
     336L, 192L, 617L, 33L, 318L, 573L, 88L, 401L, 148L, 91L, 536L, 636L, 266L, 471L, 
     68L, 272L, 194L, 574L, 316L, 569L, 570L, 557L, 308L, 743L, 439L, 495L, 1L, 330L, 
     153L, 263L, 424L, 243L, 77L, 168L, 459L, 287L, 540L, 71L, 298L, 672L, 609L, 603L, 
     119L, 89L, 443L, 730L, 444L, 216L, 127L, 526L, 63L, 313L, 343L, 714L, 222L, 326L, 
     635L, 321L, 591L, 606L, 762L, 706L, 97L, 616L, 198L, 40L, 621L, 472L, 93L, 359L, 
     622L, 381L, 692L, 760L, 207L, 199L, 142L, 238L, 633L, 99L, 59L, 712L, 745L, 396L, 
     568L, 429L, 469L, 331L, 418L, 520L, 497L, 618L, 277L, 196L, 257L, 7L, 115L, 682L, 
     145L, 149L, 48L, 693L, 454L, 524L, 307L, 239L, 152L, 69L, 240L, 733L, 133L, 660L, 
     611L, 306L, 215L, 394L, 227L, 607L, 322L, 446L, 681L, 248L, 160L, 377L, 110L, 515L, 
     445L, 397L, 367L, 768L, 766L, 517L, 669L, 494L, 184L, 416L, 156L, 348L, 281L, 155L, 
     329L, 530L, 523L, 731L, 752L, 637L, 357L, 539L, 725L, 765L, 598L, 87L, 748L, 136L, 
     546L, 341L, 291L, 228L, 496L, 205L, 162L, 96L, 659L, 269L, 141L, 121L, 375L, 27L, 
     388L, 195L, 226L, 452L, 505L, 582L, 624L, 398L, 555L, 29L, 604L, 259L, 304L, 378L, 
     588L, 333L, 231L, 565L, 751L, 140L, 212L, 106L, 442L, 82L, 426L, 289L, 350L, 640L, 
     538L, 164L, 379L, 209L, 506L, 504L, 685L, 134L, 625L, 764L, 138L, 273L, 661L, 701L, 
     647L, 241L, 531L, 708L, 448L, 342L, 480L, 261L, 290L, 722L, 175L, 11L, 251L, 434L, 
     4L, 36L, 580L, 650L, 363L, 479L, 230L, 37L, 717L, 371L, 67L, 193L, 597L, 544L, 720L, 
     535L, 739L, 554L, 761L, 143L, 49L, 763L, 419L, 358L, 387L, 464L, 477L, 47L, 545L, 
     368L, 5L, 364L, 340L, 293L, 223L, 73L, 631L, 522L, 551L, 179L, 213L, 702L, 26L, 561L, 
     466L, 519L, 108L, 599L, 385L, 383L, 601L, 66L, 663L, 470L, 15L, 736L, 16L, 651L, 
     402L, 271L, 126L, 492L, 493L, 137L, 740L, 727L, 629L, 431L, 648L, 178L, 51L, 225L, 
     560L, 511L, 157L, 415L, 630L, 559L, 262L, 58L, 742L, 543L, 707L, 258L, 408L, 276L, 
     173L, 447L, 521L, 641L, 79L, 365L, 125L, 147L, 703L, 754L, 8L, 163L, 486L, 688L, 
     498L, 757L, 180L, 211L, 579L, 541L, 696L, 732L, 550L, 767L, 295L, 144L, 297L, 691L, 
     612L, 684L, 451L, 490L, 80L, 370L, 112L, 514L, 473L, 656L, 90L, 723L, 38L, 44L, 366L, 
     435L, 427L, 332L, 662L, 386L, 421L, 256L, 30L, 123L, 245L, 114L, 449L, 689L, 177L, 
     98L, 422L, 335L, 113L, 567L, 10L, 191L, 224L, 384L, 571L, 516L, 586L, 728L, 410L, 
     55L, 654L, 323L, 190L, 724L, 334L, 407L, 562L, 563L, 619L, 718L, 54L, 653L, 584L, 
     658L, 581L, 583L, 229L, 652L, 655L, 590L, 589L, 167L, 721L, 356L, 734L, 75L, 279L, 
     254L, 572L, 508L, 39L, 758L, 747L, 645L, 593L, 428L, 83L, 70L, 460L, 85L, 690L, 28L, 
     436L, 673L, 463L, 552L, 131L, 587L, 695L, 64L, 204L, 62L, 234L, 753L, 197L, 265L, 
     694L, 380L, 327L, 390L, 311L, 438L, 20L, 296L, 399L, 24L, 610L, 614L, 14L, 577L, 
     533L, 95L, 354L, 756L, 22L, 710L, 675L, 700L, 132L, 750L, 286L, 120L, 284L)), test.inds = list(
         c(564L, 237L, 393L, 744L, 705L, 260L, 615L, 709L, 60L, 627L, 282L, 150L, 646L, 
         482L, 369L, 12L, 553L, 468L, 283L, 643L, 300L, 671L, 500L, 13L, 677L, 42L, 667L, 
         61L, 467L, 154L, 118L, 252L, 65L, 389L, 501L, 649L, 746L, 698L, 549L, 738L, 484L, 
         475L, 299L, 462L, 218L, 525L, 440L, 575L, 107L, 53L, 172L, 255L, 122L, 759L, 
         270L, 328L, 102L, 151L, 374L, 687L, 613L, 57L, 250L, 491L, 360L, 414L, 3L, 686L, 
         235L, 338L, 339L, 481L, 355L, 425L, 294L, 465L, 628L, 642L, 638L, 737L, 319L, 
         406L, 130L, 409L, 450L, 458L, 542L, 176L, 23L, 461L, 232L, 315L, 171L, 413L, 
         362L, 547L, 317L, 278L, 453L, 503L, 25L, 2L, 208L, 292L, 128L, 43L, 324L, 608L, 
         103L, 312L, 534L, 735L, 596L, 18L, 620L, 210L, 594L, 512L, 626L, 6L, 280L, 600L, 
         373L, 166L, 664L, 755L, 146L, 305L, 352L, 206L, 337L, 713L, 382L, 502L, 576L, 
         139L, 116L, 372L, 249L, 124L, 417L, 566L, 72L, 181L, 9L, 346L, 529L, 430L, 670L, 
         345L, 483L, 185L, 52L, 668L, 412L, 45L, 548L, 253L, 275L, 187L, 41L, 56L, 165L, 
         183L, 201L, 31L, 285L, 81L, 92L, 50L, 639L, 392L, 264L, 361L, 507L, 267L, 135L, 
         325L, 200L, 202L, 632L, 476L, 161L, 405L, 17L, 592L, 129L, 528L, 349L, 455L, 
         489L, 309L, 457L, 395L, 437L, 244L, 105L, 320L, 683L, 558L, 217L, 749L, 499L, 
         400L, 247L, 274L, 188L, 86L, 634L, 174L, 84L, 76L, 117L, 644L, 46L, 699L, 578L, 
         602L, 674L, 236L, 288L, 21L, 411L, 474L, 170L, 74L, 485L, 303L, 242L, 697L, 657L, 
         94L, 716L, 310L, 182L, 423L, 203L, 100L, 532L, 391L, 432L, 704L, 353L, 220L, 
         189L, 679L, 510L, 456L, 487L, 158L, 537L, 376L, 219L, 623L, 34L, 595L)), group = structure(integer(0), .Label = character(0), class = "factor")), class = "ResampleInstance"), 
         measures = list(structure(list(id = "acc", minimize = FALSE, properties = c("classif", 
         "classif.multi", "req.pred", "req.truth"), fun = function (task, model, pred, 
             feats, extra.args) 
         {
             measureACC(pred$data$truth, pred$data$response)
         }, extra.args = list(), best = 1, worst = 0, name = "Accuracy", note = "Defined as: mean(response == truth)", 
             aggr = structure(list(id = "test.mean", name = "Test mean", fun = function (task, 
                 perf.test, perf.train, measure, group, pred) 
             mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure"), 
             structure(list(id = "acc", minimize = FALSE, properties = c("classif", "classif.multi", 
             "req.pred", "req.truth"), fun = function (task, model, pred, feats, extra.args) 
             {
                 measureACC(pred$data$truth, pred$data$response)
             }, extra.args = list(), best = 1, worst = 0, name = "Accuracy", note = "Defined as: mean(response == truth)", 
                 aggr = structure(list(id = "train.mean", name = "Training mean", fun = function (task, 
                     perf.test, perf.train, measure, group, pred) 
                 mean(perf.train), properties = "req.train"), class = "Aggregation")), class = "Measure")), 
         par.set = structure(list(pars = list(C = structure(list(id = "C", type = "numeric", 
             len = 1L, lower = -5, upper = 5, values = NULL, cnames = NULL, allow.inf = FALSE, 
             has.default = FALSE, default = NULL, trafo = function (x) 
             2^x, requires = NULL, tunable = TRUE, special.vals = list()), class = "Param"), 
             sigma = structure(list(id = "sigma", type = "numeric", len = 1L, lower = -5, 
                 upper = 5, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                 default = NULL, trafo = function (x) 
                 2^x, requires = NULL, tunable = TRUE, special.vals = list()), class = "Param"), 
             degree = structure(list(id = "degree", type = "discrete", len = 1L, lower = NULL, 
                 upper = NULL, values = list(`2` = 2L, `3` = 3L, `4` = 4L, `5` = 5L), 
                 cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list()), class = "Param")), 
             forbidden = NULL), class = "ParamSet"), bits.to.features = NULL, control = structure(list(
             same.resampling.instance = TRUE, impute.val = c(0, Inf), tune.threshold = FALSE, 
             tune.threshold.args = list(), log.fun = function (learner, task, resampling, 
                 measures, par.set, control, opt.path, dob, x, y, remove.nas, stage, prev.stage) 
             {
                 x.string = paramValueToString(par.set, x, show.missing.values = !remove.nas)
                 if (inherits(learner, "ModelMultiplexer")) 
                     x.string = stri_replace_all(x.string, "", regex = stri_paste(x$selected.learner, 
                       "\\."))
                 logFunDefault(learner, task, resampling, measures, par.set, control, 
                     opt.path, dob, x.string, y, remove.nas, stage, prev.stage, prefixes = c("Tune-x", 
                       "Tune-y"))
             }, final.dw.perc = NULL, extra.args = list(maxit = 5L), budget = 5L), class = c("TuneControlRandom", 
         "TuneControl", "OptControl")), opt.path = structure(list(par.set = structure(list(
             pars = list(C = structure(list(id = "C", type = "numeric", len = 1L, lower = -5, 
                 upper = 5, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                 default = NULL, trafo = function (x) 
                 2^x, requires = NULL, tunable = TRUE, special.vals = list()), class = "Param"), 
                 sigma = structure(list(id = "sigma", type = "numeric", len = 1L, lower = -5, 
                     upper = 5, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                     default = NULL, trafo = function (x) 
                     2^x, requires = NULL, tunable = TRUE, special.vals = list()), class = "Param"), 
                 degree = structure(list(id = "degree", type = "discrete", len = 1L, lower = NULL, 
                     upper = NULL, values = list(`2` = 2L, `3` = 3L, `4` = 4L, `5` = 5L), 
                     cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, 
                     trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list()), class = "Param")), 
             forbidden = NULL), class = "ParamSet"), y.names = c("acc.test.mean", "acc.train.mean"
         ), minimize = c(acc.test.mean = FALSE, acc.train.mean = FALSE), add.transformed.x = FALSE, 
             env = <environment>), class = c("OptPathDF", "OptPath")), show.info = FALSE, 
         remove.nas = TRUE, resample.fun = function (learner, task, resampling, measures, 
             weights = NULL, models = FALSE, extract, keep.pred = TRUE, ..., show.info = getMlrOption("show.info")) 
         {
             learner = checkLearner(learner)
             learner = setHyperPars(learner, ...)
             assertClass(task, classes = "Task")
             n = getTaskSize(task)
             if (inherits(resampling, "ResampleDesc")) 
                 resampling = makeResampleInstance(resampling, task = task)
             assertClass(resampling, classes = "ResampleInstance")
             measures = checkMeasures(measures, task)
             if (!is.null(weights)) {
                 assertNumeric(weights, len = n, any.missing = FALSE, lower = 0)
             }
             assertFlag(models)
             if (missing(extract)) 
                 extract = function(model) {
                 }
             else assertFunction(extract)
             assertFlag(show.info)
             r = resampling$size
             if (n != r) 
                 stop(stri_paste("Size of data set:", n, "and resampling instance:", r, 
                     "differ!", sep = " "))
             checkLearnerBeforeTrain(task, learner, weights)
             checkAggrsBeforeResample(measures, resampling$desc)
             rin = resampling
             more.args = list(learner = learner, task = task, rin = rin, weights = NULL, 
                 measures = measures, model = models, extract = extract, show.info = show.info)
             if (!is.null(weights)) {
                 more.args$weights = weights
             }
             else if (!is.null(getTaskWeights(task))) {
                 more.args$weights = getTaskWeights(task)
             }
             parallelLibrary("mlr", master = FALSE, level = "mlr.resample", show.info = FALSE)
             exportMlrOptions(level = "mlr.resample")
             if (show.info) {
                 messagef("Resampling: %s", rin$desc$id)
                 measure.lognames = extractSubList(measures, "id")
                 if (rin$desc$predict == "both") {
                     id.train = which(vlapply(measures, function(x) "req.train" %in% x$aggr$properties))
                     id.test = which(vlapply(measures, function(x) "req.test" %in% x$aggr$properties))
                     measure.lognames = c(stri_paste(measure.lognames[id.train], "train", 
                       sep = "."), stri_paste(measure.lognames[id.test], "test", sep = "."))
                 }
                 printResampleFormatLine("Measures:", measure.lognames)
             }
             time1 = Sys.time()
             iter.results = parallelMap(doResampleIteration, seq_len(rin$desc$iters), 
                 level = "mlr.resample", more.args = more.args)
             time2 = Sys.time()
             runtime = as.numeric(difftime(time2, time1, units = "secs"))
             addClasses(mergeResampleResult(learner$id, task, iter.results, measures, 
                 rin, models, extract, keep.pred, show.info, runtime), "ResampleResult")
         })
  8: measureTime({
         r = resample.fun(learner2, task, resampling, measures = measures, show.info = FALSE)
     })
  9: force(expr)
  10: resample.fun(learner2, task, resampling, measures = measures, show.info = FALSE)
  11: parallelMap(doResampleIteration, seq_len(rin$desc$iters), level = "mlr.resample", 
         more.args = more.args)
  12: options(parallelMap.nextmap = (getPMOptNextMap() + 1L))
  13: getPMOptNextMap()
  14: getPMOption("nextmap")
  15: getOption(sprintf("parallelMap.%s", opt), def)
  
  ── 52. Error: generateLearningCurve (@test_base_generateLearningCurve.R#4)  ────
  argument "def" is missing, with no default
  1: generateLearningCurveData(list("classif.rpart", "classif.knn"), task = binaryclass.task, 
         percs = c(0.1, 0.3), measures = list(acc, timeboth)) at testthat/test_base_generateLearningCurve.R:4
  2: benchmark(dsws, task, resampling, measures, show.info = show.info)
  3: parallelMap(benchmarkParallel, task = grid$task, learner = grid$learner, more.args = list(learners = learners, 
         tasks = tasks, resamplings = resamplings, measures = measures, keep.pred = keep.pred, 
         models = models, show.info = show.info), level = plevel)
  4: mapply(fun2, ..., MoreArgs = more.args, SIMPLIFY = FALSE, USE.NAMES = FALSE)
  5: (function (task, learner, learners, tasks, resamplings, measures, keep.pred = TRUE, 
         models = TRUE, show.info) 
     {
         setSlaveOptions()
         if (show.info) 
             messagef("Task: %s, Learner: %s", task, learner)
         lrn = learners[[learner]]
         extract.this = getExtractor(lrn)
         r = resample(lrn, tasks[[task]], resamplings[[task]], measures = measures, models = models, 
             extract = extract.this, keep.pred = keep.pred, show.info = show.info)
         r$learner = lrn
         return(r)
     })(task = dots[[1L]][[1L]], learner = dots[[2L]][[1L]], learners = list(classif.rpart.1 = structure(list(
         id = "classif.rpart.1", type = "classif", package = c("mlr", "rpart"), properties = NULL, 
         par.set = structure(list(pars = list(dw.perc = structure(list(id = "dw.perc", 
             type = "numeric", len = 1L, lower = 0, upper = 1, values = NULL, cnames = NULL, 
             allow.inf = FALSE, has.default = TRUE, default = 1, trafo = NULL, requires = NULL, 
             tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), dw.stratify = structure(list(id = "dw.stratify", type = "logical", 
             len = 1L, lower = NULL, upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), 
             cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = FALSE, trafo = NULL, 
             requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param"))), forbidden = NULL), class = c("LearnerParamSet", "ParamSet")), par.vals = list(
             dw.perc = 0.1, dw.stratify = FALSE), predict.type = "response", fix.factors.prediction = FALSE, 
         next.learner = structure(list(id = "classif.rpart", type = "classif", package = "rpart", 
             properties = c("twoclass", "multiclass", "missings", "numerics", "factors", 
             "ordered", "prob", "weights", "featimp"), par.set = structure(list(pars = list(
                 minsplit = structure(list(id = "minsplit", type = "integer", len = 1L, 
                     lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 20L, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), minbucket = structure(list(id = "minbucket", type = "integer", 
                     len = 1L, lower = 1L, upper = Inf, values = NULL, cnames = NULL, 
                     allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), cp = structure(list(id = "cp", type = "numeric", len = 1L, 
                     lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 0.01, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), maxcompete = structure(list(id = "maxcompete", type = "integer", 
                     len = 1L, lower = 0L, upper = Inf, values = NULL, cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = 4L, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), maxsurrogate = structure(list(id = "maxsurrogate", type = "integer", 
                     len = 1L, lower = 0L, upper = Inf, values = NULL, cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = 5L, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), usesurrogate = structure(list(id = "usesurrogate", type = "discrete", 
                     len = 1L, lower = NULL, upper = NULL, values = list(`0` = 0L, `1` = 1L, 
                       `2` = 2L), cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = 2L, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), surrogatestyle = structure(list(
                     id = "surrogatestyle", type = "discrete", len = 1L, lower = NULL, 
                     upper = NULL, values = list(`0` = 0L, `1` = 1L), cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 0L, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), maxdepth = structure(list(id = "maxdepth", type = "integer", 
                     len = 1L, lower = 1L, upper = 30L, values = NULL, cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = 30L, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), xval = structure(list(id = "xval", type = "integer", len = 1L, 
                     lower = 0L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 10L, trafo = NULL, requires = NULL, 
                     tunable = FALSE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), parms = structure(list(id = "parms", type = "untyped", len = 1L, 
                     lower = NULL, upper = NULL, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param"))), forbidden = NULL), class = c("LearnerParamSet", "ParamSet"
             )), par.vals = list(xval = 0L), predict.type = "response", name = "Decision Tree", 
             short.name = "rpart", note = "`xval` has been set to `0` by default for speed.", 
             callees = c("rpart", "rpart.control"), help.list = list(minsplit = "Argument of: rpart::rpart.control\n\nthe minimum number of observations that must exist in a node in order for a split to be attempted.", 
                 minbucket = "Argument of: rpart::rpart.control\n\nthe minimum number of observations in any terminal <leaf> node. If only one of minbucket or minsplit is specified, the code either sets minsplit to minbucket*3 or minbucket to minsplit/3, as appropriate.", 
                 cp = "Argument of: rpart::rpart.control\n\ncomplexity parameter.  Any split that does not decrease the overall lack of fit by a factor of cp is not attempted.  For instance, with anova splitting, this means that the overall R-squared must increase by cp at each step. The main role of this parameter is to save computing time by pruning off splits that are obviously not worthwhile. Essentially,the user informs the program that any split which does not improve the fit by cp will likely be pruned off by cross-validation, and that hence the program need not pursue it.", 
                 maxcompete = "Argument of: rpart::rpart.control\n\nthe number of competitor splits retained in the output.  It is useful to know not just which split was chosen, but which variable came in second, third, etc.", 
                 maxsurrogate = "Argument of: rpart::rpart.control\n\nthe number of surrogate splits retained in the output.  If this is set to zero the compute time will be reduced, since approximately half of the computational time (other than setup) is used in the search for surrogate splits.", 
                 usesurrogate = "Argument of: rpart::rpart.control\n\nhow to use surrogates in the splitting process.  0 means display only; an observation with a missing value for the primary split rule is not sent further down the tree.  1 means use surrogates, in order, to split subjects missing the primary variable; if all surrogates are missing the observation is not split.  For value 2 ,if all surrogates are missing, then send the observation in the majority direction.  A value of 0 corresponds to the action of tree, and 2 to the recommendations of Breiman et.al (1984).", 
                 xval = "Argument of: rpart::rpart.control\n\nnumber of cross-validations.", 
                 surrogatestyle = "Argument of: rpart::rpart.control\n\ncontrols the selection of a best surrogate. If set to 0 (default) the program uses the total number of correct classification for a potential surrogate variable, if set to 1 it uses the percent correct, calculated over the non-missing values of the surrogate. The first option more severely penalizes covariates with a large number of missing values.", 
                 maxdepth = "Argument of: rpart::rpart.control\n\nSet the maximum depth of any node of the final tree, with the root node counted as depth 0.  Values greater than  30 rpart will give nonsense results on 32-bit machines.", 
                 parms = "Argument of: rpart::rpart\n\noptional parameters for the splitting function. Anova splitting has no parameters. Poisson splitting has a single parameter, the coefficient of variation of the prior distribution on the rates.  The default value is 1. Exponential splitting has the same parameter as Poisson. For classification splitting, the list can contain any of: the vector of prior probabilities (component prior), the loss matrix (component loss) or the splitting index (component split).  The priors must be positive and sum to 1.  The loss matrix must have zeros on the diagonal and positive off-diagonal elements.  The splitting index can be gini or information.  The default priors are proportional to the data counts, the losses default to 1, and the split defaults to gini."), 
             config = list(), fix.factors.prediction = FALSE), class = c("classif.rpart", 
         "RLearnerClassif", "RLearner", "Learner")), model.subclass = "DownsampleModel"), class = c("DownsampleWrapper", 
     "BaseWrapper", "Learner")), classif.rpart.2 = structure(list(id = "classif.rpart.2", 
         type = "classif", package = c("mlr", "rpart"), properties = NULL, par.set = structure(list(
             pars = list(dw.perc = structure(list(id = "dw.perc", type = "numeric", len = 1L, 
                 lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 1, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), dw.stratify = structure(list(id = "dw.stratify", type = "logical", len = 1L, 
                 lower = NULL, upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = FALSE, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param"))), forbidden = NULL), class = c("LearnerParamSet", 
         "ParamSet")), par.vals = list(dw.perc = 0.3, dw.stratify = FALSE), predict.type = "response", 
         fix.factors.prediction = FALSE, next.learner = structure(list(id = "classif.rpart", 
             type = "classif", package = "rpart", properties = c("twoclass", "multiclass", 
             "missings", "numerics", "factors", "ordered", "prob", "weights", "featimp"
             ), par.set = structure(list(pars = list(minsplit = structure(list(id = "minsplit", 
                 type = "integer", len = 1L, lower = 1L, upper = Inf, values = NULL, cnames = NULL, 
                 allow.inf = FALSE, has.default = TRUE, default = 20L, trafo = NULL, requires = NULL, 
                 tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), minbucket = structure(list(id = "minbucket", type = "integer", 
                 len = 1L, lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), cp = structure(list(id = "cp", type = "numeric", len = 1L, lower = 0, 
                 upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 0.01, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), maxcompete = structure(list(
                 id = "maxcompete", type = "integer", len = 1L, lower = 0L, upper = Inf, 
                 values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 4L, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), maxsurrogate = structure(list(
                 id = "maxsurrogate", type = "integer", len = 1L, lower = 0L, upper = Inf, 
                 values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 5L, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), usesurrogate = structure(list(
                 id = "usesurrogate", type = "discrete", len = 1L, lower = NULL, upper = NULL, 
                 values = list(`0` = 0L, `1` = 1L, `2` = 2L), cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 2L, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), surrogatestyle = structure(list(id = "surrogatestyle", type = "discrete", 
                 len = 1L, lower = NULL, upper = NULL, values = list(`0` = 0L, `1` = 1L), 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 0L, trafo = NULL, 
                 requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), maxdepth = structure(list(id = "maxdepth", type = "integer", len = 1L, 
                 lower = 1L, upper = 30L, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 30L, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), xval = structure(list(id = "xval", type = "integer", len = 1L, lower = 0L, 
                 upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 10L, trafo = NULL, requires = NULL, tunable = FALSE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), parms = structure(list(
                 id = "parms", type = "untyped", len = 1L, lower = NULL, upper = NULL, 
                 values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                 default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param"))), forbidden = NULL), class = c("LearnerParamSet", 
             "ParamSet")), par.vals = list(xval = 0L), predict.type = "response", name = "Decision Tree", 
             short.name = "rpart", note = "`xval` has been set to `0` by default for speed.", 
             callees = c("rpart", "rpart.control"), help.list = list(minsplit = "Argument of: rpart::rpart.control\n\nthe minimum number of observations that must exist in a node in order for a split to be attempted.", 
                 minbucket = "Argument of: rpart::rpart.control\n\nthe minimum number of observations in any terminal <leaf> node. If only one of minbucket or minsplit is specified, the code either sets minsplit to minbucket*3 or minbucket to minsplit/3, as appropriate.", 
                 cp = "Argument of: rpart::rpart.control\n\ncomplexity parameter.  Any split that does not decrease the overall lack of fit by a factor of cp is not attempted.  For instance, with anova splitting, this means that the overall R-squared must increase by cp at each step. The main role of this parameter is to save computing time by pruning off splits that are obviously not worthwhile. Essentially,the user informs the program that any split which does not improve the fit by cp will likely be pruned off by cross-validation, and that hence the program need not pursue it.", 
                 maxcompete = "Argument of: rpart::rpart.control\n\nthe number of competitor splits retained in the output.  It is useful to know not just which split was chosen, but which variable came in second, third, etc.", 
                 maxsurrogate = "Argument of: rpart::rpart.control\n\nthe number of surrogate splits retained in the output.  If this is set to zero the compute time will be reduced, since approximately half of the computational time (other than setup) is used in the search for surrogate splits.", 
                 usesurrogate = "Argument of: rpart::rpart.control\n\nhow to use surrogates in the splitting process.  0 means display only; an observation with a missing value for the primary split rule is not sent further down the tree.  1 means use surrogates, in order, to split subjects missing the primary variable; if all surrogates are missing the observation is not split.  For value 2 ,if all surrogates are missing, then send the observation in the majority direction.  A value of 0 corresponds to the action of tree, and 2 to the recommendations of Breiman et.al (1984).", 
                 xval = "Argument of: rpart::rpart.control\n\nnumber of cross-validations.", 
                 surrogatestyle = "Argument of: rpart::rpart.control\n\ncontrols the selection of a best surrogate. If set to 0 (default) the program uses the total number of correct classification for a potential surrogate variable, if set to 1 it uses the percent correct, calculated over the non-missing values of the surrogate. The first option more severely penalizes covariates with a large number of missing values.", 
                 maxdepth = "Argument of: rpart::rpart.control\n\nSet the maximum depth of any node of the final tree, with the root node counted as depth 0.  Values greater than  30 rpart will give nonsense results on 32-bit machines.", 
                 parms = "Argument of: rpart::rpart\n\noptional parameters for the splitting function. Anova splitting has no parameters. Poisson splitting has a single parameter, the coefficient of variation of the prior distribution on the rates.  The default value is 1. Exponential splitting has the same parameter as Poisson. For classification splitting, the list can contain any of: the vector of prior probabilities (component prior), the loss matrix (component loss) or the splitting index (component split).  The priors must be positive and sum to 1.  The loss matrix must have zeros on the diagonal and positive off-diagonal elements.  The splitting index can be gini or information.  The default priors are proportional to the data counts, the losses default to 1, and the split defaults to gini."), 
             config = list(), fix.factors.prediction = FALSE), class = c("classif.rpart", 
         "RLearnerClassif", "RLearner", "Learner")), model.subclass = "DownsampleModel"), class = c("DownsampleWrapper", 
     "BaseWrapper", "Learner")), classif.knn.1 = structure(list(id = "classif.knn.1", 
         type = "classif", package = c("mlr", "class"), properties = NULL, par.set = structure(list(
             pars = list(dw.perc = structure(list(id = "dw.perc", type = "numeric", len = 1L, 
                 lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 1, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), dw.stratify = structure(list(id = "dw.stratify", type = "logical", len = 1L, 
                 lower = NULL, upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = FALSE, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param"))), forbidden = NULL), class = c("LearnerParamSet", 
         "ParamSet")), par.vals = list(dw.perc = 0.1, dw.stratify = FALSE), predict.type = "response", 
         fix.factors.prediction = FALSE, next.learner = structure(list(id = "classif.knn", 
             type = "classif", package = "class", properties = c("twoclass", "multiclass", 
             "numerics"), par.set = structure(list(pars = list(k = structure(list(id = "k", 
                 type = "integer", len = 1L, lower = 1L, upper = Inf, values = NULL, cnames = NULL, 
                 allow.inf = FALSE, has.default = TRUE, default = 1L, trafo = NULL, requires = NULL, 
                 tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), l = structure(list(id = "l", type = "numeric", len = 1L, lower = 0L, 
                 upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 0L, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), prob = structure(list(
                 id = "prob", type = "logical", len = 1L, lower = NULL, upper = NULL, 
                 values = list(`TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = FALSE, trafo = NULL, requires = NULL, tunable = FALSE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), use.all = structure(list(id = "use.all", type = "logical", len = 1L, 
                 lower = NULL, upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = TRUE, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param"))), forbidden = NULL), class = c("LearnerParamSet", 
             "ParamSet")), par.vals = list(), predict.type = "response", name = "k-Nearest Neighbor", 
             short.name = "knn", note = "", callees = "knn", help.list = list(k = "Argument of: class::knn\n\nnumber of neighbours considered.", 
                 l = "Argument of: class::knn\n\nminimum vote for definite decision, otherwise doubt. (More precisely, less than k-l dissenting votes are allowed, even if k is increased by ties.)", 
                 prob = "Argument of: class::knn\n\nIf this is true, the proportion of the votes for the winning class are returned as attribute prob.", 
                 use.all = "Argument of: class::knn\n\ncontrols handling of ties. If true, all distances equal to the kth largest are included. If false, a random selection of distances equal to the kth is chosen to use exactly k neighbours."), 
             config = list(), fix.factors.prediction = FALSE), class = c("classif.knn", 
         "RLearnerClassif", "RLearner", "Learner")), model.subclass = "DownsampleModel"), class = c("DownsampleWrapper", 
     "BaseWrapper", "Learner")), classif.knn.2 = structure(list(id = "classif.knn.2", 
         type = "classif", package = c("mlr", "class"), properties = NULL, par.set = structure(list(
             pars = list(dw.perc = structure(list(id = "dw.perc", type = "numeric", len = 1L, 
                 lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 1, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), dw.stratify = structure(list(id = "dw.stratify", type = "logical", len = 1L, 
                 lower = NULL, upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = FALSE, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param"))), forbidden = NULL), class = c("LearnerParamSet", 
         "ParamSet")), par.vals = list(dw.perc = 0.3, dw.stratify = FALSE), predict.type = "response", 
         fix.factors.prediction = FALSE, next.learner = structure(list(id = "classif.knn", 
             type = "classif", package = "class", properties = c("twoclass", "multiclass", 
             "numerics"), par.set = structure(list(pars = list(k = structure(list(id = "k", 
                 type = "integer", len = 1L, lower = 1L, upper = Inf, values = NULL, cnames = NULL, 
                 allow.inf = FALSE, has.default = TRUE, default = 1L, trafo = NULL, requires = NULL, 
                 tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), l = structure(list(id = "l", type = "numeric", len = 1L, lower = 0L, 
                 upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 0L, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), prob = structure(list(
                 id = "prob", type = "logical", len = 1L, lower = NULL, upper = NULL, 
                 values = list(`TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = FALSE, trafo = NULL, requires = NULL, tunable = FALSE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), use.all = structure(list(id = "use.all", type = "logical", len = 1L, 
                 lower = NULL, upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = TRUE, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param"))), forbidden = NULL), class = c("LearnerParamSet", 
             "ParamSet")), par.vals = list(), predict.type = "response", name = "k-Nearest Neighbor", 
             short.name = "knn", note = "", callees = "knn", help.list = list(k = "Argument of: class::knn\n\nnumber of neighbours considered.", 
                 l = "Argument of: class::knn\n\nminimum vote for definite decision, otherwise doubt. (More precisely, less than k-l dissenting votes are allowed, even if k is increased by ties.)", 
                 prob = "Argument of: class::knn\n\nIf this is true, the proportion of the votes for the winning class are returned as attribute prob.", 
                 use.all = "Argument of: class::knn\n\ncontrols handling of ties. If true, all distances equal to the kth largest are included. If false, a random selection of distances equal to the kth is chosen to use exactly k neighbours."), 
             config = list(), fix.factors.prediction = FALSE), class = c("classif.knn", 
         "RLearnerClassif", "RLearner", "Learner")), model.subclass = "DownsampleModel"), class = c("DownsampleWrapper", 
     "BaseWrapper", "Learner"))), tasks = list(binary = structure(list(type = "classif", 
         env = <environment>, weights = NULL, blocking = NULL, coordinates = NULL, task.desc = structure(list(
             id = "binary", type = "classif", target = "Class", size = 208L, n.feat = c(numerics = 60L, 
             factors = 0L, ordered = 0L, functionals = 0L), has.missings = FALSE, has.weights = FALSE, 
             has.blocking = FALSE, has.coordinates = FALSE, class.levels = c("M", "R"), 
             positive = "M", negative = "R", class.distribution = structure(c(M = 111L, 
             R = 97L), .Dim = 2L, .Dimnames = list(c("M", "R")), class = "table")), class = c("ClassifTaskDesc", 
         "SupervisedTaskDesc", "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", 
     "Task"))), resamplings = list(binary = structure(list(desc = structure(list(split = 0.666666666666667, 
         id = "holdout", iters = 1L, predict = "test", stratify = FALSE), class = c("HoldoutDesc", 
     "ResampleDesc")), size = 208L, train.inds = list(c(60L, 164L, 85L, 182L, 192L, 10L, 
     107L, 180L, 111L, 91L, 190L, 90L, 133L, 112L, 20L, 174L, 48L, 9L, 63L, 181L, 168L, 
     130L, 120L, 184L, 121L, 187L, 100L, 108L, 53L, 27L, 172L, 160L, 122L, 140L, 5L, 83L, 
     131L, 38L, 55L, 40L, 24L, 70L, 69L, 61L, 26L, 23L, 171L, 76L, 43L, 137L, 8L, 167L, 
     125L, 19L, 87L, 32L, 194L, 114L, 135L, 56L, 99L, 14L, 57L, 169L, 118L, 65L, 116L, 
     115L, 195L, 62L, 105L, 154L, 97L, 1L, 64L, 30L, 51L, 81L, 46L, 15L, 153L, 206L, 201L, 
     148L, 13L, 54L, 185L, 109L, 202L, 21L, 16L, 77L, 145L, 161L, 37L, 22L, 88L, 11L, 
     52L, 149L, 143L, 36L, 110L, 101L, 132L, 92L, 94L, 139L, 42L, 129L, 103L, 196L, 6L, 
     199L, 68L, 147L, 104L, 159L, 126L, 151L, 58L, 28L, 179L, 155L, 128L, 82L, 124L, 158L, 
     12L, 170L, 49L, 166L, 106L, 176L, 39L, 78L, 208L, 75L)), test.inds = list(c(204L, 
     84L, 3L, 47L, 98L, 200L, 41L, 205L, 189L, 66L, 134L, 74L, 193L, 33L, 117L, 44L, 197L, 
     142L, 50L, 152L, 95L, 71L, 35L, 178L, 138L, 146L, 29L, 7L, 207L, 177L, 157L, 67L, 
     72L, 150L, 45L, 17L, 86L, 18L, 136L, 96L, 25L, 198L, 80L, 191L, 79L, 156L, 2L, 119L, 
     186L, 183L, 175L, 163L, 4L, 93L, 127L, 203L, 123L, 102L, 113L, 73L, 34L, 165L, 144L, 
     188L, 141L, 59L, 162L, 173L, 31L, 89L)), group = structure(integer(0), .Label = character(0), class = "factor")), class = "ResampleInstance")), 
         measures = list(structure(list(id = "acc", minimize = FALSE, properties = c("classif", 
         "classif.multi", "req.pred", "req.truth"), fun = function (task, model, pred, 
             feats, extra.args) 
         {
             measureACC(pred$data$truth, pred$data$response)
         }, extra.args = list(), best = 1, worst = 0, name = "Accuracy", note = "Defined as: mean(response == truth)", 
             aggr = structure(list(id = "test.mean", name = "Test mean", fun = function (task, 
                 perf.test, perf.train, measure, group, pred) 
             mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure"), 
             structure(list(id = "timeboth", minimize = TRUE, properties = c("classif", 
             "classif.multi", "multilabel", "regr", "surv", "costsens", "cluster", "req.model", 
             "req.pred"), fun = function (task, model, pred, feats, extra.args) 
             {
                 model$time + pred$time
             }, extra.args = list(), best = 0, worst = Inf, name = "timetrain + timepredict", 
                 note = "", aggr = structure(list(id = "test.mean", name = "Test mean", 
                     fun = function (task, perf.test, perf.train, measure, group, pred) 
                     mean(perf.test), properties = "req.test"), class = "Aggregation")), class = "Measure")), 
         keep.pred = TRUE, models = TRUE, show.info = FALSE)
  6: resample(lrn, tasks[[task]], resamplings[[task]], measures = measures, models = models, 
         extract = extract.this, keep.pred = keep.pred, show.info = show.info)
  7: parallelMap(doResampleIteration, seq_len(rin$desc$iters), level = "mlr.resample", 
         more.args = more.args)
  8: options(parallelMap.nextmap = (getPMOptNextMap() + 1L))
  9: getPMOptNextMap()
  10: getPMOption("nextmap")
  11: getOption(sprintf("parallelMap.%s", opt), def)
  
  ── 53. Error: generateLearningCurve works if single learner is passed (not wrapp
  argument "def" is missing, with no default
  1: generateLearningCurveData(makeLearner("classif.rpart"), task = binaryclass.task, 
         percs = c(0.1, 0.7), measures = list(acc, timeboth)) at testthat/test_base_generateLearningCurve.R:51
  2: benchmark(dsws, task, resampling, measures, show.info = show.info)
  3: parallelMap(benchmarkParallel, task = grid$task, learner = grid$learner, more.args = list(learners = learners, 
         tasks = tasks, resamplings = resamplings, measures = measures, keep.pred = keep.pred, 
         models = models, show.info = show.info), level = plevel)
  4: mapply(fun2, ..., MoreArgs = more.args, SIMPLIFY = FALSE, USE.NAMES = FALSE)
  5: (function (task, learner, learners, tasks, resamplings, measures, keep.pred = TRUE, 
         models = TRUE, show.info) 
     {
         setSlaveOptions()
         if (show.info) 
             messagef("Task: %s, Learner: %s", task, learner)
         lrn = learners[[learner]]
         extract.this = getExtractor(lrn)
         r = resample(lrn, tasks[[task]], resamplings[[task]], measures = measures, models = models, 
             extract = extract.this, keep.pred = keep.pred, show.info = show.info)
         r$learner = lrn
         return(r)
     })(task = dots[[1L]][[1L]], learner = dots[[2L]][[1L]], learners = list(classif.rpart.1 = structure(list(
         id = "classif.rpart.1", type = "classif", package = c("mlr", "rpart"), properties = NULL, 
         par.set = structure(list(pars = list(dw.perc = structure(list(id = "dw.perc", 
             type = "numeric", len = 1L, lower = 0, upper = 1, values = NULL, cnames = NULL, 
             allow.inf = FALSE, has.default = TRUE, default = 1, trafo = NULL, requires = NULL, 
             tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param")), dw.stratify = structure(list(id = "dw.stratify", type = "logical", 
             len = 1L, lower = NULL, upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), 
             cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = FALSE, trafo = NULL, 
             requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
         "Param"))), forbidden = NULL), class = c("LearnerParamSet", "ParamSet")), par.vals = list(
             dw.perc = 0.1, dw.stratify = FALSE), predict.type = "response", fix.factors.prediction = FALSE, 
         next.learner = structure(list(id = "classif.rpart", type = "classif", package = "rpart", 
             properties = c("twoclass", "multiclass", "missings", "numerics", "factors", 
             "ordered", "prob", "weights", "featimp"), par.set = structure(list(pars = list(
                 minsplit = structure(list(id = "minsplit", type = "integer", len = 1L, 
                     lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 20L, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), minbucket = structure(list(id = "minbucket", type = "integer", 
                     len = 1L, lower = 1L, upper = Inf, values = NULL, cnames = NULL, 
                     allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), cp = structure(list(id = "cp", type = "numeric", len = 1L, 
                     lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 0.01, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), maxcompete = structure(list(id = "maxcompete", type = "integer", 
                     len = 1L, lower = 0L, upper = Inf, values = NULL, cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = 4L, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), maxsurrogate = structure(list(id = "maxsurrogate", type = "integer", 
                     len = 1L, lower = 0L, upper = Inf, values = NULL, cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = 5L, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), usesurrogate = structure(list(id = "usesurrogate", type = "discrete", 
                     len = 1L, lower = NULL, upper = NULL, values = list(`0` = 0L, `1` = 1L, 
                       `2` = 2L), cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = 2L, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), class = c("LearnerParam", "Param")), surrogatestyle = structure(list(
                     id = "surrogatestyle", type = "discrete", len = 1L, lower = NULL, 
                     upper = NULL, values = list(`0` = 0L, `1` = 1L), cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 0L, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), maxdepth = structure(list(id = "maxdepth", type = "integer", 
                     len = 1L, lower = 1L, upper = 30L, values = NULL, cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = 30L, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), xval = structure(list(id = "xval", type = "integer", len = 1L, 
                     lower = 0L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 10L, trafo = NULL, requires = NULL, 
                     tunable = FALSE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param")), parms = structure(list(id = "parms", type = "untyped", len = 1L, 
                     lower = NULL, upper = NULL, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
                 "Param"))), forbidden = NULL), class = c("LearnerParamSet", "ParamSet"
             )), par.vals = list(xval = 0L), predict.type = "response", name = "Decision Tree", 
             short.name = "rpart", note = "`xval` has been set to `0` by default for speed.", 
             callees = c("rpart", "rpart.control"), help.list = list(minsplit = "Argument of: rpart::rpart.control\n\nthe minimum number of observations that must exist in a node in order for a split to be attempted.", 
                 minbucket = "Argument of: rpart::rpart.control\n\nthe minimum number of observations in any terminal <leaf> node. If only one of minbucket or minsplit is specified, the code either sets minsplit to minbucket*3 or minbucket to minsplit/3, as appropriate.", 
                 cp = "Argument of: rpart::rpart.control\n\ncomplexity parameter.  Any split that does not decrease the overall lack of fit by a factor of cp is not attempted.  For instance, with anova splitting, this means that the overall R-squared must increase by cp at each step. The main role of this parameter is to save computing time by pruning off splits that are obviously not worthwhile. Essentially,the user informs the program that any split which does not improve the fit by cp will likely be pruned off by cross-validation, and that hence the program need not pursue it.", 
                 maxcompete = "Argument of: rpart::rpart.control\n\nthe number of competitor splits retained in the output.  It is useful to know not just which split was chosen, but which variable came in second, third, etc.", 
                 maxsurrogate = "Argument of: rpart::rpart.control\n\nthe number of surrogate splits retained in the output.  If this is set to zero the compute time will be reduced, since approximately half of the computational time (other than setup) is used in the search for surrogate splits.", 
                 usesurrogate = "Argument of: rpart::rpart.control\n\nhow to use surrogates in the splitting process.  0 means display only; an observation with a missing value for the primary split rule is not sent further down the tree.  1 means use surrogates, in order, to split subjects missing the primary variable; if all surrogates are missing the observation is not split.  For value 2 ,if all surrogates are missing, then send the observation in the majority direction.  A value of 0 corresponds to the action of tree, and 2 to the recommendations of Breiman et.al (1984).", 
                 xval = "Argument of: rpart::rpart.control\n\nnumber of cross-validations.", 
                 surrogatestyle = "Argument of: rpart::rpart.control\n\ncontrols the selection of a best surrogate. If set to 0 (default) the program uses the total number of correct classification for a potential surrogate variable, if set to 1 it uses the percent correct, calculated over the non-missing values of the surrogate. The first option more severely penalizes covariates with a large number of missing values.", 
                 maxdepth = "Argument of: rpart::rpart.control\n\nSet the maximum depth of any node of the final tree, with the root node counted as depth 0.  Values greater than  30 rpart will give nonsense results on 32-bit machines.", 
                 parms = "Argument of: rpart::rpart\n\noptional parameters for the splitting function. Anova splitting has no parameters. Poisson splitting has a single parameter, the coefficient of variation of the prior distribution on the rates.  The default value is 1. Exponential splitting has the same parameter as Poisson. For classification splitting, the list can contain any of: the vector of prior probabilities (component prior), the loss matrix (component loss) or the splitting index (component split).  The priors must be positive and sum to 1.  The loss matrix must have zeros on the diagonal and positive off-diagonal elements.  The splitting index can be gini or information.  The default priors are proportional to the data counts, the losses default to 1, and the split defaults to gini."), 
             config = list(), fix.factors.prediction = FALSE), class = c("classif.rpart", 
         "RLearnerClassif", "RLearner", "Learner")), model.subclass = "DownsampleModel"), class = c("DownsampleWrapper", 
     "BaseWrapper", "Learner")), classif.rpart.2 = structure(list(id = "classif.rpart.2", 
         type = "classif", package = c("mlr", "rpart"), properties = NULL, par.set = structure(list(
             pars = list(dw.perc = structure(list(id = "dw.perc", type = "numeric", len = 1L, 
                 lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 1, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), dw.stratify = structure(list(id = "dw.stratify", type = "logical", len = 1L, 
                 lower = NULL, upper = NULL, values = list(`TRUE` = TRUE, `FALSE` = FALSE), 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = FALSE, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param"))), forbidden = NULL), class = c("LearnerParamSet", 
         "ParamSet")), par.vals = list(dw.perc = 0.7, dw.stratify = FALSE), predict.type = "response", 
         fix.factors.prediction = FALSE, next.learner = structure(list(id = "classif.rpart", 
             type = "classif", package = "rpart", properties = c("twoclass", "multiclass", 
             "missings", "numerics", "factors", "ordered", "prob", "weights", "featimp"
             ), par.set = structure(list(pars = list(minsplit = structure(list(id = "minsplit", 
                 type = "integer", len = 1L, lower = 1L, upper = Inf, values = NULL, cnames = NULL, 
                 allow.inf = FALSE, has.default = TRUE, default = 20L, trafo = NULL, requires = NULL, 
                 tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), minbucket = structure(list(id = "minbucket", type = "integer", 
                 len = 1L, lower = 1L, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), cp = structure(list(id = "cp", type = "numeric", len = 1L, lower = 0, 
                 upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 0.01, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), maxcompete = structure(list(
                 id = "maxcompete", type = "integer", len = 1L, lower = 0L, upper = Inf, 
                 values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 4L, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), maxsurrogate = structure(list(
                 id = "maxsurrogate", type = "integer", len = 1L, lower = 0L, upper = Inf, 
                 values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 5L, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), usesurrogate = structure(list(
                 id = "usesurrogate", type = "discrete", len = 1L, lower = NULL, upper = NULL, 
                 values = list(`0` = 0L, `1` = 1L, `2` = 2L), cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 2L, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), surrogatestyle = structure(list(id = "surrogatestyle", type = "discrete", 
                 len = 1L, lower = NULL, upper = NULL, values = list(`0` = 0L, `1` = 1L), 
                 cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 0L, trafo = NULL, 
                 requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam", 
             "Param")), maxdepth = structure(list(id = "maxdepth", type = "integer", len = 1L, 
                 lower = 1L, upper = 30L, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = TRUE, default = 30L, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
             )), xval = structure(list(id = "xval", type = "integer", len = 1L, lower = 0L, 
                 upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                 default = 10L, trafo = NULL, requires = NULL, tunable = FALSE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param")), parms = structure(list(
                 id = "parms", type = "untyped", len = 1L, lower = NULL, upper = NULL, 
                 values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                 default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), class = c("LearnerParam", "Param"))), forbidden = NULL), class = c("LearnerParamSet", 
             "ParamSet")), par.vals = list(xval = 0L), predict.type = "response", name = "Decision Tree", 
             short.name = "rpart", note = "`xval` has been set to `0` by default for speed.", 
             callees = c("rpart", "rpart.control"), help.list = list(minsplit = "Argument of: rpart::rpart.control\n\nthe minimum number of observations that must exist in a node in order for a split to be attempted.", 
                 minbucket = "Argument of: rpart::rpart.control\n\nthe minimum number of observations in any terminal <leaf> node. If only one of minbucket or minsplit is specified, the code either sets minsplit to minbucket*3 or minbucket to minsplit/3, as appropriate.", 
                 cp = "Argument of: rpart::rpart.control\n\ncomplexity parameter.  Any split that does not decrease the overall lack of fit by a factor of cp is not attempted.  For instance, with anova splitting, this means that the overall R-squared must increase by cp at each step. The main role of this parameter is to save computing time by pruning off splits that are obviously not worthwhile. Essentially,the user informs the program that any split which does not improve the fit by cp will likely be pruned off by cross-validation, and that hence the program need not pursue it.", 
                 maxcompete = "Argument of: rpart::rpart.control\n\nthe number of competitor splits retained in the output.  It is useful to know not just which split was chosen, but which variable came in second, third, etc.", 
                 maxsurrogate = "Argument of: rpart::rpart.control\n\nthe number of surrogate splits retained in the output.  If this is set to zero the compute time will be reduced, since approximately half of the computational time (other than setup) is used in the search for surrogate splits.", 
                 usesurrogate = "Argument of: rpart::rpart.control\n\nhow to use surrogates in the splitting process.  0 means display only; an observation with a missing value for the primary split rule is not sent further down the tree.  1 means use surrogates, in order, to split subjects missing the primary variable; if all surrogates are missing the observation is not split.  For value 2 ,if all surrogates are missing, then send the observation in the majority direction.  A value of 0 corresponds to the action of tree, and 2 to the recommendations of Breiman et.al (1984).", 
                 xval = "Argument of: rpart::rpart.control\n\nnumber of cross-validations.", 
                 surrogatestyle = "Argument of: rpart::rpart.control\n\ncontrols the selection of a best surrogate. If set to 0 (default) the program uses the total number of correct classification for a potential surrogate variable, if set to 1 it uses the percent correct, calculated over the non-missing values of the surrogate. The first option more severely penalizes covariates with a large number of missing values.", 
                 maxdepth = "Argument of: rpart::rpart.control\n\nSet the maximum depth of any node of the final tree, with the root node counted as depth 0.  Values greater than  30 rpart will give nonsense results on 32-bit machines.", 
                 parms = "Argument of: rpart::rpart\n\noptional parameters for the splitting function. Anova splitting has no parameters. Poisson splitting has a single parameter, the coefficient of variation of the prior distribution on the rates.  The default value is 1. Exponential splitting has the same parameter as Poisson. For classification splitting, the list can contain any of: the vector of prior probabilities (component prior), the loss matrix (component loss) or the splitting index (component split).  The priors must be positive and sum to 1.  The loss matrix must have zeros on the diagonal and positive off-diagonal elements.  The splitting index can be gini or information.  The default priors are proportional to the data counts, the losses default to 1, and the split defaults to gini."), 
             config = list(), fix.factors.prediction = FALSE), class = c("classif.rpart", 
         "RLearnerClassif", "RLearner", "Learner")), model.subclass = "DownsampleModel"), class = c("DownsampleWrapper", 
     "BaseWrapper", "Learner"))), tasks = list(binary = structure(list(type = "classif", 
         env = <environment>, weights = NULL, blocking = NULL, coordinates = NULL, task.desc = structure(list(
             id = "binary", type = "classif", target = "Class", size = 208L, n.feat = c(numerics = 60L, 
             factors = 0L, ordered = 0L, functionals = 0L), has.missings = FALSE, has.weights = FALSE, 
             has.blocking = FALSE, has.coordinates = FALSE, class.levels = c("M", "R"), 
             positive = "M", negative = "R", class.distribution = structure(c(M = 111L, 
             R = 97L), .Dim = 2L, .Dimnames = list(c("M", "R")), class = "table")), class = c("ClassifTaskDesc", 
         "SupervisedTaskDesc", "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", 
     "Task"))), resamplings = list(binary = structure(list(desc = structure(list(split = 0.666666666666667, 
         id = "holdout", iters = 1L, predict = "test", stratify = FALSE), class = c("HoldoutDesc", 
     "ResampleDesc")), size = 208L, train.inds = list(c(60L, 164L, 85L, 182L, 192L, 10L, 
     107L, 180L, 111L, 91L, 190L, 90L, 133L, 112L, 20L, 174L, 48L, 9L, 63L, 181L, 168L, 
     130L, 120L, 184L, 121L, 187L, 100L, 108L, 53L, 27L, 172L, 160L, 122L, 140L, 5L, 83L, 
     131L, 38L, 55L, 40L, 24L, 70L, 69L, 61L, 26L, 23L, 171L, 76L, 43L, 137L, 8L, 167L, 
     125L, 19L, 87L, 32L, 194L, 114L, 135L, 56L, 99L, 14L, 57L, 169L, 118L, 65L, 116L, 
     115L, 195L, 62L, 105L, 154L, 97L, 1L, 64L, 30L, 51L, 81L, 46L, 15L, 153L, 206L, 201L, 
     148L, 13L, 54L, 185L, 109L, 202L, 21L, 16L, 77L, 145L, 161L, 37L, 22L, 88L, 11L, 
     52L, 149L, 143L, 36L, 110L, 101L, 132L, 92L, 94L, 139L, 42L, 129L, 103L, 196L, 6L, 
     199L, 68L, 147L, 104L, 159L, 126L, 151L, 58L, 28L, 179L, 155L, 128L, 82L, 124L, 158L, 
     12L, 170L, 49L, 166L, 106L, 176L, 39L, 78L, 208L, 75L)), test.inds = list(c(204L, 
     84L, 3L, 47L, 98L, 200L, 41L, 205L, 189L, 66L, 134L, 74L, 193L, 33L, 117L, 44L, 197L, 
     142L, 50L, 152L, 95L, 71L, 35L, 178L, 138L, 146L, 29L, 7L, 207L, 177L, 157L, 67L, 
     72L, 150L, 45L, 17L, 86L, 18L, 136L, 96L, 25L, 198L, 80L, 191L, 79L, 156L, 2L, 119L, 
     186L, 183L, 175L, 163L, 4L, 93L, 127L, 203L, 123L, 102L, 113L, 73L, 34L, 165L, 144L, 
     188L, 141L, 59L, 162L, 173L, 31L, 89L)), group = structure(integer(0), .Label = character(0), class = "factor")), class = "ResampleInstance")), 
         measures = list(structure(list(id = "acc", minimize = FALSE, properties = c("classif", 
         "classif.multi", "req.p