Running ‘run-base.R’ [10m/12m]
  Running ‘run-classif.R’
  Running ‘run-cluster.R’
  Running ‘run-featsel.R’
  Running ‘run-learners-classif.R’
  Running ‘run-learners-classiflabelswitch.R’
  Running ‘run-learners-cluster.R’
  Running ‘run-learners-general.R’
  Running ‘run-learners-multilabel.R’
  Running ‘run-learners-regr.R’
  Running ‘run-learners-surv.R’
  Running ‘run-multilabel.R’
  Running ‘run-parallel.R’
  Running ‘run-regr.R’
  Running ‘run-stack.R’
  Running ‘run-surv.R’
  Running ‘run-tune.R’
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
  1. Error: TuneWrapper passed predict hyper pars correctly to base learner (@test_base_TuneWrapper.R#51) 
  need at least two non-NA values to interpolate
  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()
         if (show.info) 
             messagef("[Resample] %s iter %i: ", rin$desc$id, i, .newline = FALSE)
         train.i = rin$train.inds[[i]]
         test.i = rin$test.inds[[i]]
         calculateResampleIterationResult(learner = learner, task = task, 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 = structure(list(), .Names = character(0)), 
             forbidden = NULL), .Names = c("pars", "forbidden"), class = "ParamSet"), 
         par.vals = structure(list(), .Names = character(0)), 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 = structure(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"), .Names = c("id", 
             "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
             "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", 
             "values", "cnames", "allow.inf", "has.default", "default", "trafo", "requires", 
             "tunable", "special.vals", "when"), class = c("LearnerParam", "Param")), 
                 exact = structure(list(id = "exact", type = "logical", len = 1L, lower = NULL, 
                     upper = NULL, values = structure(list(`TRUE` = TRUE, `FALSE` = FALSE), .Names = c("TRUE", 
                     "FALSE")), cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = FALSE, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "predict"), .Names = c("id", "type", "len", "lower", "upper", 
                 "values", "cnames", "allow.inf", "has.default", "default", "trafo", "requires", 
                 "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", 
                 "values", "cnames", "allow.inf", "has.default", "default", "trafo", "requires", 
                 "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), class = c("LearnerParam", 
                 "Param")), standardize = structure(list(id = "standardize", type = "logical", 
                     len = 1L, lower = NULL, upper = NULL, values = structure(list(`TRUE` = TRUE, 
                       `FALSE` = FALSE), .Names = c("TRUE", "FALSE")), cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = TRUE, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), class = c("LearnerParam", 
                 "Param")), intercept = structure(list(id = "intercept", type = "logical", 
                     len = 1L, lower = NULL, upper = NULL, values = structure(list(`TRUE` = TRUE, 
                       `FALSE` = FALSE), .Names = c("TRUE", "FALSE")), cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = TRUE, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), class = c("LearnerParam", 
                 "Param")), type.logistic = structure(list(id = "type.logistic", type = "discrete", 
                     len = 1L, lower = NULL, upper = NULL, values = structure(list(Newton = "Newton", 
                       modified.Newton = "modified.Newton"), .Names = c("Newton", "modified.Newton"
                     )), cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, 
                     trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), .Names = c("id", "type", "len", "lower", "upper", 
                 "values", "cnames", "allow.inf", "has.default", "default", "trafo", "requires", 
                 "tunable", "special.vals", "when"), class = c("LearnerParam", "Param"
                 )), type.multinomial = structure(list(id = "type.multinomial", type = "discrete", 
                     len = 1L, lower = NULL, upper = NULL, values = structure(list(ungrouped = "ungrouped", 
                       grouped = "grouped"), .Names = c("ungrouped", "grouped")), cnames = NULL, 
                     allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", 
                 "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), class = c("LearnerParam", 
                 "Param"))), .Names = c("alpha", "s", "exact", "nlambda", "lambda.min.ratio", 
             "lambda", "standardize", "intercept", "thresh", "dfmax", "pmax", "exclude", 
             "penalty.factor", "lower.limits", "upper.limits", "maxit", "type.logistic", 
             "type.multinomial", "fdev", "devmax", "eps", "big", "mnlam", "pmin", "exmx", 
             "prec", "mxit")), forbidden = NULL), .Names = c("pars", "forbidden"), class = c("LearnerParamSet", 
             "ParamSet")), par.vals = structure(list(s = 0.01), .Names = "s"), 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.", 
             config = list(), fix.factors.prediction = FALSE), .Names = c("id", "type", 
         "package", "properties", "par.set", "par.vals", "predict.type", "name", "short.name", 
         "note", "config", "fix.factors.prediction"), class = c("classif.glmnet", "RLearnerClassif", 
         "RLearner", "Learner")), model.subclass = "TuneModel", resampling = structure(list(
             split = 0.3, id = "holdout", iters = 1L, predict = "test", stratify = FALSE), .Names = c("split", 
         "id", "iters", "predict", "stratify"), 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"), .Names = c("id", "name", "fun", 
             "properties"), class = "Aggregation")), .Names = c("id", "minimize", "properties", 
         "fun", "extra.args", "best", "worst", "name", "note", "aggr"), class = "Measure")), 
         opt.pars = structure(list(pars = structure(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()), .Names = c("id", "type", "len", "lower", 
         "upper", "values", "cnames", "allow.inf", "has.default", "default", "trafo", 
         "requires", "tunable", "special.vals"), class = "Param")), .Names = "s"), forbidden = NULL), .Names = c("pars", 
         "forbidden"), 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 = structure(list(maxit = 1L), .Names = "maxit"), 
             budget = 1L), .Names = c("same.resampling.instance", "impute.val", "tune.threshold", 
         "tune.threshold.args", "log.fun", "final.dw.perc", "extra.args", "budget"), class = c("TuneControlRandom", 
         "TuneControl", "OptControl")), show.info = FALSE), .Names = c("id", "type", "package", 
     "properties", "par.set", "par.vals", "predict.type", "fix.factors.prediction", "next.learner", 
     "model.subclass", "resampling", "measures", "opt.pars", "bit.names", "bits.to.features", 
     "control", "show.info"), class = c("TuneWrapper", "OptWrapper", "BaseWrapper", "Learner"
     )), task = structure(list(type = "classif", env = <environment>, weights = NULL, 
         blocking = NULL, task.desc = structure(list(id = "binary", type = "classif", 
             target = "Class", size = 208L, n.feat = structure(c(60L, 0L, 0L), .Names = c("numerics", 
             "factors", "ordered")), has.missings = FALSE, has.weights = FALSE, has.blocking = FALSE, 
             class.levels = c("M", "R"), positive = "M", negative = "R"), .Names = c("id", 
         "type", "target", "size", "n.feat", "has.missings", "has.weights", "has.blocking", 
         "class.levels", "positive", "negative"), class = c("ClassifTaskDesc", "SupervisedTaskDesc", 
         "TaskDesc"))), .Names = c("type", "env", "weights", "blocking", "task.desc"), class = c("ClassifTask", 
     "SupervisedTask", "Task")), rin = structure(list(desc = structure(list(split = 0.3, 
         id = "holdout", iters = 1L, predict = "test", stratify = FALSE), .Names = c("split", 
     "id", "iters", "predict", "stratify"), 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")), .Names = c("desc", 
     "size", "train.inds", "test.inds", "group"), 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"), .Names = c("id", "name", "fun", 
             "properties"), class = "Aggregation")), .Names = c("id", "minimize", "properties", 
         "fun", "extra.args", "best", "worst", "name", "note", "aggr"), class = "Measure")), 
         model = FALSE, extract = function (model) 
         {
         }, show.info = FALSE)
  5: calculateResampleIterationResult(learner = learner, task = task, 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)))
  11: fun3(do.call(trainLearner, pars))
  12: do.call(trainLearner, pars)
  13: (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 = structure(list(), .Names = character(0)), 
             forbidden = NULL), .Names = c("pars", "forbidden"), class = "ParamSet"), 
         par.vals = structure(list(), .Names = character(0)), 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 = structure(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"), .Names = c("id", 
             "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
             "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", 
             "values", "cnames", "allow.inf", "has.default", "default", "trafo", "requires", 
             "tunable", "special.vals", "when"), class = c("LearnerParam", "Param")), 
                 exact = structure(list(id = "exact", type = "logical", len = 1L, lower = NULL, 
                     upper = NULL, values = structure(list(`TRUE` = TRUE, `FALSE` = FALSE), .Names = c("TRUE", 
                     "FALSE")), cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = FALSE, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "predict"), .Names = c("id", "type", "len", "lower", "upper", 
                 "values", "cnames", "allow.inf", "has.default", "default", "trafo", "requires", 
                 "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", 
                 "values", "cnames", "allow.inf", "has.default", "default", "trafo", "requires", 
                 "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), class = c("LearnerParam", 
                 "Param")), standardize = structure(list(id = "standardize", type = "logical", 
                     len = 1L, lower = NULL, upper = NULL, values = structure(list(`TRUE` = TRUE, 
                       `FALSE` = FALSE), .Names = c("TRUE", "FALSE")), cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = TRUE, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), class = c("LearnerParam", 
                 "Param")), intercept = structure(list(id = "intercept", type = "logical", 
                     len = 1L, lower = NULL, upper = NULL, values = structure(list(`TRUE` = TRUE, 
                       `FALSE` = FALSE), .Names = c("TRUE", "FALSE")), cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = TRUE, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), class = c("LearnerParam", 
                 "Param")), type.logistic = structure(list(id = "type.logistic", type = "discrete", 
                     len = 1L, lower = NULL, upper = NULL, values = structure(list(Newton = "Newton", 
                       modified.Newton = "modified.Newton"), .Names = c("Newton", "modified.Newton"
                     )), cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, 
                     trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), .Names = c("id", "type", "len", "lower", "upper", 
                 "values", "cnames", "allow.inf", "has.default", "default", "trafo", "requires", 
                 "tunable", "special.vals", "when"), class = c("LearnerParam", "Param"
                 )), type.multinomial = structure(list(id = "type.multinomial", type = "discrete", 
                     len = 1L, lower = NULL, upper = NULL, values = structure(list(ungrouped = "ungrouped", 
                       grouped = "grouped"), .Names = c("ungrouped", "grouped")), cnames = NULL, 
                     allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", 
                 "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), class = c("LearnerParam", 
                 "Param"))), .Names = c("alpha", "s", "exact", "nlambda", "lambda.min.ratio", 
             "lambda", "standardize", "intercept", "thresh", "dfmax", "pmax", "exclude", 
             "penalty.factor", "lower.limits", "upper.limits", "maxit", "type.logistic", 
             "type.multinomial", "fdev", "devmax", "eps", "big", "mnlam", "pmin", "exmx", 
             "prec", "mxit")), forbidden = NULL), .Names = c("pars", "forbidden"), class = c("LearnerParamSet", 
             "ParamSet")), par.vals = structure(list(s = 0.01), .Names = "s"), 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.", 
             config = list(), fix.factors.prediction = FALSE), .Names = c("id", "type", 
         "package", "properties", "par.set", "par.vals", "predict.type", "name", "short.name", 
         "note", "config", "fix.factors.prediction"), class = c("classif.glmnet", "RLearnerClassif", 
         "RLearner", "Learner")), model.subclass = "TuneModel", resampling = structure(list(
             split = 0.3, id = "holdout", iters = 1L, predict = "test", stratify = FALSE), .Names = c("split", 
         "id", "iters", "predict", "stratify"), 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"), .Names = c("id", "name", "fun", 
             "properties"), class = "Aggregation")), .Names = c("id", "minimize", "properties", 
         "fun", "extra.args", "best", "worst", "name", "note", "aggr"), class = "Measure")), 
         opt.pars = structure(list(pars = structure(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()), .Names = c("id", "type", "len", "lower", 
         "upper", "values", "cnames", "allow.inf", "has.default", "default", "trafo", 
         "requires", "tunable", "special.vals"), class = "Param")), .Names = "s"), forbidden = NULL), .Names = c("pars", 
         "forbidden"), 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 = structure(list(maxit = 1L), .Names = "maxit"), 
             budget = 1L), .Names = c("same.resampling.instance", "impute.val", "tune.threshold", 
         "tune.threshold.args", "log.fun", "final.dw.perc", "extra.args", "budget"), class = c("TuneControlRandom", 
         "TuneControl", "OptControl")), show.info = FALSE), .Names = c("id", "type", "package", 
     "properties", "par.set", "par.vals", "predict.type", "fix.factors.prediction", "next.learner", 
     "model.subclass", "resampling", "measures", "opt.pars", "bit.names", "bits.to.features", 
     "control", "show.info"), class = c("TuneWrapper", "OptWrapper", "BaseWrapper", "Learner"
     )), .task = structure(list(type = "classif", env = <environment>, weights = NULL, 
         blocking = NULL, task.desc = structure(list(id = "binary", type = "classif", 
             target = "Class", size = 208L, n.feat = structure(c(60L, 0L, 0L), .Names = c("numerics", 
             "factors", "ordered")), has.missings = FALSE, has.weights = FALSE, has.blocking = FALSE, 
             class.levels = c("M", "R"), positive = "M", negative = "R"), .Names = c("id", 
         "type", "target", "size", "n.feat", "has.missings", "has.weights", "has.blocking", 
         "class.levels", "positive", "negative"), class = c("ClassifTaskDesc", "SupervisedTaskDesc", 
         "TaskDesc"))), .Names = c("type", "env", "weights", "blocking", "task.desc"), class = c("ClassifTask", 
     "SupervisedTask", "Task")), .subset = 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))
  14: trainLearner.TuneWrapper(.learner = structure(list(id = "classif.glmnet.tuned", type = "classif", 
         package = "glmnet", properties = NULL, par.set = structure(list(pars = structure(list(), .Names = character(0)), 
             forbidden = NULL), .Names = c("pars", "forbidden"), class = "ParamSet"), 
         par.vals = structure(list(), .Names = character(0)), 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 = structure(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"), .Names = c("id", 
             "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
             "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", 
             "values", "cnames", "allow.inf", "has.default", "default", "trafo", "requires", 
             "tunable", "special.vals", "when"), class = c("LearnerParam", "Param")), 
                 exact = structure(list(id = "exact", type = "logical", len = 1L, lower = NULL, 
                     upper = NULL, values = structure(list(`TRUE` = TRUE, `FALSE` = FALSE), .Names = c("TRUE", 
                     "FALSE")), cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = FALSE, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "predict"), .Names = c("id", "type", "len", "lower", "upper", 
                 "values", "cnames", "allow.inf", "has.default", "default", "trafo", "requires", 
                 "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", 
                 "values", "cnames", "allow.inf", "has.default", "default", "trafo", "requires", 
                 "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), class = c("LearnerParam", 
                 "Param")), standardize = structure(list(id = "standardize", type = "logical", 
                     len = 1L, lower = NULL, upper = NULL, values = structure(list(`TRUE` = TRUE, 
                       `FALSE` = FALSE), .Names = c("TRUE", "FALSE")), cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = TRUE, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), class = c("LearnerParam", 
                 "Param")), intercept = structure(list(id = "intercept", type = "logical", 
                     len = 1L, lower = NULL, upper = NULL, values = structure(list(`TRUE` = TRUE, 
                       `FALSE` = FALSE), .Names = c("TRUE", "FALSE")), cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = TRUE, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), class = c("LearnerParam", 
                 "Param")), type.logistic = structure(list(id = "type.logistic", type = "discrete", 
                     len = 1L, lower = NULL, upper = NULL, values = structure(list(Newton = "Newton", 
                       modified.Newton = "modified.Newton"), .Names = c("Newton", "modified.Newton"
                     )), cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, 
                     trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), .Names = c("id", "type", "len", "lower", "upper", 
                 "values", "cnames", "allow.inf", "has.default", "default", "trafo", "requires", 
                 "tunable", "special.vals", "when"), class = c("LearnerParam", "Param"
                 )), type.multinomial = structure(list(id = "type.multinomial", type = "discrete", 
                     len = 1L, lower = NULL, upper = NULL, values = structure(list(ungrouped = "ungrouped", 
                       grouped = "grouped"), .Names = c("ungrouped", "grouped")), cnames = NULL, 
                     allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", 
                 "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), class = c("LearnerParam", 
                 "Param"))), .Names = c("alpha", "s", "exact", "nlambda", "lambda.min.ratio", 
             "lambda", "standardize", "intercept", "thresh", "dfmax", "pmax", "exclude", 
             "penalty.factor", "lower.limits", "upper.limits", "maxit", "type.logistic", 
             "type.multinomial", "fdev", "devmax", "eps", "big", "mnlam", "pmin", "exmx", 
             "prec", "mxit")), forbidden = NULL), .Names = c("pars", "forbidden"), class = c("LearnerParamSet", 
             "ParamSet")), par.vals = structure(list(s = 0.01), .Names = "s"), 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.", 
             config = list(), fix.factors.prediction = FALSE), .Names = c("id", "type", 
         "package", "properties", "par.set", "par.vals", "predict.type", "name", "short.name", 
         "note", "config", "fix.factors.prediction"), class = c("classif.glmnet", "RLearnerClassif", 
         "RLearner", "Learner")), model.subclass = "TuneModel", resampling = structure(list(
             split = 0.3, id = "holdout", iters = 1L, predict = "test", stratify = FALSE), .Names = c("split", 
         "id", "iters", "predict", "stratify"), 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"), .Names = c("id", "name", "fun", 
             "properties"), class = "Aggregation")), .Names = c("id", "minimize", "properties", 
         "fun", "extra.args", "best", "worst", "name", "note", "aggr"), class = "Measure")), 
         opt.pars = structure(list(pars = structure(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()), .Names = c("id", "type", "len", "lower", 
         "upper", "values", "cnames", "allow.inf", "has.default", "default", "trafo", 
         "requires", "tunable", "special.vals"), class = "Param")), .Names = "s"), forbidden = NULL), .Names = c("pars", 
         "forbidden"), 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 = structure(list(maxit = 1L), .Names = "maxit"), 
             budget = 1L), .Names = c("same.resampling.instance", "impute.val", "tune.threshold", 
         "tune.threshold.args", "log.fun", "final.dw.perc", "extra.args", "budget"), class = c("TuneControlRandom", 
         "TuneControl", "OptControl")), show.info = FALSE), .Names = c("id", "type", "package", 
     "properties", "par.set", "par.vals", "predict.type", "fix.factors.prediction", "next.learner", 
     "model.subclass", "resampling", "measures", "opt.pars", "bit.names", "bits.to.features", 
     "control", "show.info"), class = c("TuneWrapper", "OptWrapper", "BaseWrapper", "Learner"
     )), .task = structure(list(type = "classif", env = <environment>, weights = NULL, 
         blocking = NULL, task.desc = structure(list(id = "binary", type = "classif", 
             target = "Class", size = 208L, n.feat = structure(c(60L, 0L, 0L), .Names = c("numerics", 
             "factors", "ordered")), has.missings = FALSE, has.weights = FALSE, has.blocking = FALSE, 
             class.levels = c("M", "R"), positive = "M", negative = "R"), .Names = c("id", 
         "type", "target", "size", "n.feat", "has.missings", "has.weights", "has.blocking", 
         "class.levels", "positive", "negative"), class = c("ClassifTaskDesc", "SupervisedTaskDesc", 
         "TaskDesc"))), .Names = c("type", "env", "weights", "blocking", "task.desc"), class = c("ClassifTask", 
     "SupervisedTask", "Task")), .subset = 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))
  15: tuneParams(.learner$next.learner, .task, .learner$resampling, .learner$measures, 
         .learner$opt.pars, .learner$control, .learner$show.info)
  16: sel.func(learner, task, resampling, measures, par.set, control, opt.path, show.info, 
         resample.fun)
  17: 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)
  18: evalOptimizationStates(learner, task, resampling, measures, par.set, NULL, control, 
         opt.path, show.info, states, dobs, eols, remove.nas, resample.fun, "mlr.tuneParams")
  19: 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))
  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 = structure(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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", 
             "values", "cnames", "allow.inf", "has.default", "default", "trafo", "requires", 
             "tunable", "special.vals", "when"), class = c("LearnerParam", "Param")), 
             exact = structure(list(id = "exact", type = "logical", len = 1L, lower = NULL, 
                 upper = NULL, values = structure(list(`TRUE` = TRUE, `FALSE` = FALSE), .Names = c("TRUE", 
                 "FALSE")), cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = FALSE, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "predict"), .Names = c("id", "type", "len", "lower", "upper", 
             "values", "cnames", "allow.inf", "has.default", "default", "trafo", "requires", 
             "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), class = c("LearnerParam", "Param")), standardize = structure(list(
                 id = "standardize", type = "logical", len = 1L, lower = NULL, upper = NULL, 
                 values = structure(list(`TRUE` = TRUE, `FALSE` = FALSE), .Names = c("TRUE", 
                 "FALSE")), cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = TRUE, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), class = c("LearnerParam", "Param")), intercept = structure(list(
                 id = "intercept", type = "logical", len = 1L, lower = NULL, upper = NULL, 
                 values = structure(list(`TRUE` = TRUE, `FALSE` = FALSE), .Names = c("TRUE", 
                 "FALSE")), cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = TRUE, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), class = c("LearnerParam", "Param")), type.logistic = structure(list(
                 id = "type.logistic", type = "discrete", len = 1L, lower = NULL, upper = NULL, 
                 values = structure(list(Newton = "Newton", modified.Newton = "modified.Newton"), .Names = c("Newton", 
                 "modified.Newton")), cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                 default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), class = c("LearnerParam", "Param")), type.multinomial = structure(list(
                 id = "type.multinomial", type = "discrete", len = 1L, lower = NULL, upper = NULL, 
                 values = structure(list(ungrouped = "ungrouped", grouped = "grouped"), .Names = c("ungrouped", 
                 "grouped")), cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), 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"), .Names = c("id", 
             "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
             "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", 
             "lower", "upper", "values", "cnames", "allow.inf", "has.default", "default", 
             "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", 
             "lower", "upper", "values", "cnames", "allow.inf", "has.default", "default", 
             "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", 
             "lower", "upper", "values", "cnames", "allow.inf", "has.default", "default", 
             "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", 
             "lower", "upper", "values", "cnames", "allow.inf", "has.default", "default", 
             "trafo", "requires", "tunable", "special.vals", "when"), class = c("LearnerParam", 
             "Param"))), .Names = c("alpha", "s", "exact", "nlambda", "lambda.min.ratio", 
         "lambda", "standardize", "intercept", "thresh", "dfmax", "pmax", "exclude", "penalty.factor", 
         "lower.limits", "upper.limits", "maxit", "type.logistic", "type.multinomial", 
         "fdev", "devmax", "eps", "big", "mnlam", "pmin", "exmx", "prec", "mxit")), forbidden = NULL), .Names = c("pars", 
         "forbidden"), class = c("LearnerParamSet", "ParamSet")), par.vals = structure(list(
             s = 0.01), .Names = "s"), 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.", 
         config = list(), fix.factors.prediction = FALSE), .Names = c("id", "type", "package", 
     "properties", "par.set", "par.vals", "predict.type", "name", "short.name", "note", 
     "config", "fix.factors.prediction"), class = c("classif.glmnet", "RLearnerClassif", 
     "RLearner", "Learner")), task = structure(list(type = "classif", env = <environment>, 
         weights = NULL, blocking = NULL, task.desc = structure(list(id = "binary", type = "classif", 
             target = "Class", size = 62L, n.feat = structure(c(60L, 0L, 0L), .Names = c("numerics", 
             "factors", "ordered")), has.missings = FALSE, has.weights = FALSE, has.blocking = FALSE, 
             class.levels = c("M", "R"), positive = "M", negative = "R"), .Names = c("id", 
         "type", "target", "size", "n.feat", "has.missings", "has.weights", "has.blocking", 
         "class.levels", "positive", "negative"), class = c("ClassifTaskDesc", "SupervisedTaskDesc", 
         "TaskDesc"))), .Names = c("type", "env", "weights", "blocking", "task.desc"), class = c("ClassifTask", 
     "SupervisedTask", "Task")), resampling = structure(list(desc = structure(list(split = 0.3, 
         id = "holdout", iters = 1L, predict = "test", stratify = FALSE), .Names = c("split", 
     "id", "iters", "predict", "stratify"), 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")), .Names = c("desc", 
     "size", "train.inds", "test.inds", "group"), 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"), .Names = c("id", "name", "fun", 
             "properties"), class = "Aggregation")), .Names = c("id", "minimize", "properties", 
         "fun", "extra.args", "best", "worst", "name", "note", "aggr"), class = "Measure")), 
         par.set = structure(list(pars = structure(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()), .Names = c("id", "type", "len", "lower", "upper", 
         "values", "cnames", "allow.inf", "has.default", "default", "trafo", "requires", 
         "tunable", "special.vals"), class = "Param")), .Names = "s"), forbidden = NULL), .Names = c("pars", 
         "forbidden"), 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 = structure(list(maxit = 1L), .Names = "maxit"), 
             budget = 1L), .Names = c("same.resampling.instance", "impute.val", "tune.threshold", 
         "tune.threshold.args", "log.fun", "final.dw.perc", "extra.args", "budget"), class = c("TuneControlRandom", 
         "TuneControl", "OptControl")), opt.path = structure(list(par.set = structure(list(
             pars = structure(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()), .Names = c("id", "type", "len", "lower", "upper", 
             "values", "cnames", "allow.inf", "has.default", "default", "trafo", "requires", 
             "tunable", "special.vals"), class = "Param")), .Names = "s"), forbidden = NULL), .Names = c("pars", 
         "forbidden"), class = "ParamSet"), y.names = "mmce.test.mean", minimize = structure(TRUE, .Names = "mmce.test.mean"), 
             add.transformed.x = FALSE, env = <environment>), .Names = c("par.set", "y.names", 
         "minimize", "add.transformed.x", "env"), 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")
             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: mapply(fun2, ..., MoreArgs = more.args, SIMPLIFY = FALSE, USE.NAMES = FALSE)
  27: (function (learner, task, rin, i, measures, weights, model, extract, show.info) 
     {
         setSlaveOptions()
         if (show.info) 
             messagef("[Resample] %s iter %i: ", rin$desc$id, i, .newline = FALSE)
         train.i = rin$train.inds[[i]]
         test.i = rin$test.inds[[i]]
         calculateResampleIterationResult(learner = learner, task = task, 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", type = "classif", 
         package = "glmnet", properties = c("numerics", "factors", "prob", "twoclass", 
         "multiclass", "weights"), par.set = structure(list(pars = structure(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"), .Names = c("id", 
         "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
         "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
         "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
         "special.vals", "when"), class = c("LearnerParam", "Param")), exact = structure(list(
             id = "exact", type = "logical", len = 1L, lower = NULL, upper = NULL, values = structure(list(
                 `TRUE` = TRUE, `FALSE` = FALSE), .Names = c("TRUE", "FALSE")), cnames = NULL, 
             allow.inf = FALSE, has.default = TRUE, default = FALSE, trafo = NULL, requires = NULL, 
             tunable = TRUE, special.vals = list(), when = "predict"), .Names = c("id", 
         "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
         "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", 
         "upper", "values", "cnames", "allow.inf", "has.default", "default", "trafo", 
         "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", 
         "upper", "values", "cnames", "allow.inf", "has.default", "default", "trafo", 
         "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", 
         "upper", "values", "cnames", "allow.inf", "has.default", "default", "trafo", 
         "requires", "tunable", "special.vals", "when"), class = c("LearnerParam", "Param"
         )), standardize = structure(list(id = "standardize", type = "logical", len = 1L, 
             lower = NULL, upper = NULL, values = structure(list(`TRUE` = TRUE, `FALSE` = FALSE), .Names = c("TRUE", 
             "FALSE")), cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = TRUE, 
             trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), .Names = c("id", 
         "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
         "default", "trafo", "requires", "tunable", "special.vals", "when"), class = c("LearnerParam", 
         "Param")), intercept = structure(list(id = "intercept", type = "logical", len = 1L, 
             lower = NULL, upper = NULL, values = structure(list(`TRUE` = TRUE, `FALSE` = FALSE), .Names = c("TRUE", 
             "FALSE")), cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = TRUE, 
             trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), .Names = c("id", 
         "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
         "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", 
         "upper", "values", "cnames", "allow.inf", "has.default", "default", "trafo", 
         "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
         "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
         "special.vals", "when"), 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"), .Names = c("id", 
         "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
         "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", 
         "upper", "values", "cnames", "allow.inf", "has.default", "default", "trafo", 
         "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", 
         "upper", "values", "cnames", "allow.inf", "has.default", "default", "trafo", 
         "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
         "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
         "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
         "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
         "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
         "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
         "special.vals", "when"), class = c("LearnerParam", "Param")), type.logistic = structure(list(
             id = "type.logistic", type = "discrete", len = 1L, lower = NULL, upper = NULL, 
             values = structure(list(Newton = "Newton", modified.Newton = "modified.Newton"), .Names = c("Newton", 
             "modified.Newton")), cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
             default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
             when = "train"), .Names = c("id", "type", "len", "lower", "upper", "values", 
         "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
         "special.vals", "when"), class = c("LearnerParam", "Param")), type.multinomial = structure(list(
             id = "type.multinomial", type = "discrete", len = 1L, lower = NULL, upper = NULL, 
             values = structure(list(ungrouped = "ungrouped", grouped = "grouped"), .Names = c("ungrouped", 
             "grouped")), cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, 
             trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), .Names = c("id", 
         "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
         "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
         "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
         "special.vals", "when"), 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"), .Names = c("id", 
         "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
         "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
         "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
         "special.vals", "when"), 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"), .Names = c("id", 
         "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
         "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
         "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
         "special.vals", "when"), 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"), .Names = c("id", 
         "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
         "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
         "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
         "special.vals", "when"), 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"), .Names = c("id", 
         "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
         "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
         "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
         "special.vals", "when"), class = c("LearnerParam", "Param"))), .Names = c("alpha", 
         "s", "exact", "nlambda", "lambda.min.ratio", "lambda", "standardize", "intercept", 
         "thresh", "dfmax", "pmax", "exclude", "penalty.factor", "lower.limits", "upper.limits", 
         "maxit", "type.logistic", "type.multinomial", "fdev", "devmax", "eps", "big", 
         "mnlam", "pmin", "exmx", "prec", "mxit")), forbidden = NULL), .Names = c("pars", 
         "forbidden"), class = c("LearnerParamSet", "ParamSet")), par.vals = structure(list(
             s = 0.0251183277992532), .Names = "s"), 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.", 
         config = list(), fix.factors.prediction = FALSE), .Names = c("id", "type", "package", 
     "properties", "par.set", "par.vals", "predict.type", "name", "short.name", "note", 
     "config", "fix.factors.prediction"), class = c("classif.glmnet", "RLearnerClassif", 
     "RLearner", "Learner")), task = structure(list(type = "classif", env = <environment>, 
         weights = NULL, blocking = NULL, task.desc = structure(list(id = "binary", type = "classif", 
             target = "Class", size = 62L, n.feat = structure(c(60L, 0L, 0L), .Names = c("numerics", 
             "factors", "ordered")), has.missings = FALSE, has.weights = FALSE, has.blocking = FALSE, 
             class.levels = c("M", "R"), positive = "M", negative = "R"), .Names = c("id", 
         "type", "target", "size", "n.feat", "has.missings", "has.weights", "has.blocking", 
         "class.levels", "positive", "negative"), class = c("ClassifTaskDesc", "SupervisedTaskDesc", 
         "TaskDesc"))), .Names = c("type", "env", "weights", "blocking", "task.desc"), class = c("ClassifTask", 
     "SupervisedTask", "Task")), rin = structure(list(desc = structure(list(split = 0.3, 
         id = "holdout", iters = 1L, predict = "test", stratify = FALSE), .Names = c("split", 
     "id", "iters", "predict", "stratify"), 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")), .Names = c("desc", 
     "size", "train.inds", "test.inds", "group"), 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"), .Names = c("id", "name", "fun", 
             "properties"), class = "Aggregation")), .Names = c("id", "minimize", "properties", 
         "fun", "extra.args", "best", "worst", "name", "note", "aggr"), class = "Measure")), 
         model = FALSE, extract = function (model) 
         {
         }, show.info = FALSE)
  28: calculateResampleIterationResult(learner = learner, task = task, train.i = train.i, 
         test.i = test.i, measures = measures, weights = weights, rdesc = rin$desc, model = model, 
         extract = extract, show.info = show.info)
  29: predict(m, task, subset = test.i)
  30: predict.WrappedModel(m, task, subset = test.i)
  31: measureTime(fun1({
         p = fun2(fun3(do.call(predictLearner2, pars)))
     }))
  32: force(expr)
  33: fun1({
         p = fun2(fun3(do.call(predictLearner2, pars)))
     })
  34: evalVis(expr)
  35: withVisible(eval(expr, pf))
  36: eval(expr, pf)
  37: eval(expr, pf)
  38: fun2(fun3(do.call(predictLearner2, pars)))
  39: fun3(do.call(predictLearner2, pars))
  40: do.call(predictLearner2, pars)
  41: (function (.learner, .model, .newdata, ...) 
     {
         if (.learner$fix.factors.prediction) {
             fls = .model$factor.levels
             ns = names(fls)
             ns = intersect(colnames(.newdata), ns)
             fls = fls[ns]
             if (length(ns) > 0L) 
                 .newdata[ns] = mapply(factor, x = .newdata[ns], levels = fls, SIMPLIFY = FALSE)
         }
         p = predictLearner(.learner, .model, .newdata, ...)
         p = checkPredictLearnerOutput(.learner, .model, p)
         return(p)
     })(.learner = structure(list(id = "classif.glmnet", type = "classif", package = "glmnet", 
         properties = c("numerics", "factors", "prob", "twoclass", "multiclass", "weights"
         ), par.set = structure(list(pars = structure(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"), .Names = c("id", 
         "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
         "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
         "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
         "special.vals", "when"), class = c("LearnerParam", "Param")), exact = structure(list(
             id = "exact", type = "logical", len = 1L, lower = NULL, upper = NULL, values = structure(list(
                 `TRUE` = TRUE, `FALSE` = FALSE), .Names = c("TRUE", "FALSE")), cnames = NULL, 
             allow.inf = FALSE, has.default = TRUE, default = FALSE, trafo = NULL, requires = NULL, 
             tunable = TRUE, special.vals = list(), when = "predict"), .Names = c("id", 
         "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
         "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", 
         "upper", "values", "cnames", "allow.inf", "has.default", "default", "trafo", 
         "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", 
         "upper", "values", "cnames", "allow.inf", "has.default", "default", "trafo", 
         "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", 
         "upper", "values", "cnames", "allow.inf", "has.default", "default", "trafo", 
         "requires", "tunable", "special.vals", "when"), class = c("LearnerParam", "Param"
         )), standardize = structure(list(id = "standardize", type = "logical", len = 1L, 
             lower = NULL, upper = NULL, values = structure(list(`TRUE` = TRUE, `FALSE` = FALSE), .Names = c("TRUE", 
             "FALSE")), cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = TRUE, 
             trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), .Names = c("id", 
         "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
         "default", "trafo", "requires", "tunable", "special.vals", "when"), class = c("LearnerParam", 
         "Param")), intercept = structure(list(id = "intercept", type = "logical", len = 1L, 
             lower = NULL, upper = NULL, values = structure(list(`TRUE` = TRUE, `FALSE` = FALSE), .Names = c("TRUE", 
             "FALSE")), cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = TRUE, 
             trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), .Names = c("id", 
         "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
         "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", 
         "upper", "values", "cnames", "allow.inf", "has.default", "default", "trafo", 
         "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
         "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
         "special.vals", "when"), 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"), .Names = c("id", 
         "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
         "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", 
         "upper", "values", "cnames", "allow.inf", "has.default", "default", "trafo", 
         "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", 
         "upper", "values", "cnames", "allow.inf", "has.default", "default", "trafo", 
         "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
         "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
         "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
         "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
         "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
         "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
         "special.vals", "when"), class = c("LearnerParam", "Param")), type.logistic = structure(list(
             id = "type.logistic", type = "discrete", len = 1L, lower = NULL, upper = NULL, 
             values = structure(list(Newton = "Newton", modified.Newton = "modified.Newton"), .Names = c("Newton", 
             "modified.Newton")), cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
             default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
             when = "train"), .Names = c("id", "type", "len", "lower", "upper", "values", 
         "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
         "special.vals", "when"), class = c("LearnerParam", "Param")), type.multinomial = structure(list(
             id = "type.multinomial", type = "discrete", len = 1L, lower = NULL, upper = NULL, 
             values = structure(list(ungrouped = "ungrouped", grouped = "grouped"), .Names = c("ungrouped", 
             "grouped")), cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, 
             trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), .Names = c("id", 
         "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
         "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
         "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
         "special.vals", "when"), 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"), .Names = c("id", 
         "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
         "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
         "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
         "special.vals", "when"), 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"), .Names = c("id", 
         "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
         "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
         "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
         "special.vals", "when"), 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"), .Names = c("id", 
         "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
         "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
         "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
         "special.vals", "when"), 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"), .Names = c("id", 
         "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
         "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
         "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
         "special.vals", "when"), class = c("LearnerParam", "Param"))), .Names = c("alpha", 
         "s", "exact", "nlambda", "lambda.min.ratio", "lambda", "standardize", "intercept", 
         "thresh", "dfmax", "pmax", "exclude", "penalty.factor", "lower.limits", "upper.limits", 
         "maxit", "type.logistic", "type.multinomial", "fdev", "devmax", "eps", "big", 
         "mnlam", "pmin", "exmx", "prec", "mxit")), forbidden = NULL), .Names = c("pars", 
         "forbidden"), class = c("LearnerParamSet", "ParamSet")), par.vals = structure(list(
             s = 0.0251183277992532), .Names = "s"), 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.", 
         config = list(), fix.factors.prediction = FALSE), .Names = c("id", "type", "package", 
     "properties", "par.set", "par.vals", "predict.type", "name", "short.name", "note", 
     "config", "fix.factors.prediction"), class = c("classif.glmnet", "RLearnerClassif", 
     "RLearner", "Learner")), .model = structure(list(learner = structure(list(id = "classif.glmnet", 
         type = "classif", package = "glmnet", properties = c("numerics", "factors", "prob", 
         "twoclass", "multiclass", "weights"), par.set = structure(list(pars = structure(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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", 
             "values", "cnames", "allow.inf", "has.default", "default", "trafo", "requires", 
             "tunable", "special.vals", "when"), class = c("LearnerParam", "Param")), 
             exact = structure(list(id = "exact", type = "logical", len = 1L, lower = NULL, 
                 upper = NULL, values = structure(list(`TRUE` = TRUE, `FALSE` = FALSE), .Names = c("TRUE", 
                 "FALSE")), cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = FALSE, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "predict"), .Names = c("id", "type", "len", "lower", "upper", 
             "values", "cnames", "allow.inf", "has.default", "default", "trafo", "requires", 
             "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), class = c("LearnerParam", "Param")), standardize = structure(list(
                 id = "standardize", type = "logical", len = 1L, lower = NULL, upper = NULL, 
                 values = structure(list(`TRUE` = TRUE, `FALSE` = FALSE), .Names = c("TRUE", 
                 "FALSE")), cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = TRUE, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), class = c("LearnerParam", "Param")), intercept = structure(list(
                 id = "intercept", type = "logical", len = 1L, lower = NULL, upper = NULL, 
                 values = structure(list(`TRUE` = TRUE, `FALSE` = FALSE), .Names = c("TRUE", 
                 "FALSE")), cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = TRUE, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), class = c("LearnerParam", "Param")), type.logistic = structure(list(
                 id = "type.logistic", type = "discrete", len = 1L, lower = NULL, upper = NULL, 
                 values = structure(list(Newton = "Newton", modified.Newton = "modified.Newton"), .Names = c("Newton", 
                 "modified.Newton")), cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                 default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), class = c("LearnerParam", "Param")), type.multinomial = structure(list(
                 id = "type.multinomial", type = "discrete", len = 1L, lower = NULL, upper = NULL, 
                 values = structure(list(ungrouped = "ungrouped", grouped = "grouped"), .Names = c("ungrouped", 
                 "grouped")), cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), 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"), .Names = c("id", 
             "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
             "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", 
             "lower", "upper", "values", "cnames", "allow.inf", "has.default", "default", 
             "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", 
             "lower", "upper", "values", "cnames", "allow.inf", "has.default", "default", 
             "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", 
             "lower", "upper", "values", "cnames", "allow.inf", "has.default", "default", 
             "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", 
             "lower", "upper", "values", "cnames", "allow.inf", "has.default", "default", 
             "trafo", "requires", "tunable", "special.vals", "when"), class = c("LearnerParam", 
             "Param"))), .Names = c("alpha", "s", "exact", "nlambda", "lambda.min.ratio", 
         "lambda", "standardize", "intercept", "thresh", "dfmax", "pmax", "exclude", "penalty.factor", 
         "lower.limits", "upper.limits", "maxit", "type.logistic", "type.multinomial", 
         "fdev", "devmax", "eps", "big", "mnlam", "pmin", "exmx", "prec", "mxit")), forbidden = NULL), .Names = c("pars", 
         "forbidden"), class = c("LearnerParamSet", "ParamSet")), par.vals = structure(list(
             s = 0.0251183277992532), .Names = "s"), 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.", 
         config = list(), fix.factors.prediction = FALSE), .Names = c("id", "type", "package", 
     "properties", "par.set", "par.vals", "predict.type", "name", "short.name", "note", 
     "config", "fix.factors.prediction"), class = c("classif.glmnet", "RLearnerClassif", 
     "RLearner", "Learner")), learner.model = structure(list(a0 = structure(c(0.22314355131421, 
     0.22314355131421, 0.22314355131421, 0.22314355131421, 0.22314355131421), .Names = c("s0", 
     "s1", "s2", "s3", "s4")), beta = <S4 object of class structure("dgCMatrix", package = "Matrix")>, 
         df = c(0, 0, 0, 0, 0), dim = c(60L, 5L), lambda = c(NaN, NaN, NaN, NaN, NaN), 
         dev.ratio = c(2.53231395323395e-16, 3.94643255846773e-16, 3.94643255846773e-16, 
         3.94643255846773e-16, 3.94643255846773e-16), nulldev = 24.7306167575036, npasses = 6L, 
         jerr = 0L, offset = FALSE, classnames = c("M", "R"), call = (function (x, y, 
             family = c("gaussian", "binomial", "poisson", "multinomial", "cox", "mgaussian"), 
             weights, offset = NULL, alpha = 1, nlambda = 100, lambda.min.ratio = ifelse(nobs < 
                 nvars, 0.01, 1e-04), lambda = NULL, standardize = TRUE, intercept = TRUE, 
             thresh = 1e-07, dfmax = nvars + 1, pmax = min(dfmax * 2 + 20, nvars), exclude, 
             penalty.factor = rep(1, nvars), lower.limits = -Inf, upper.limits = Inf, 
             maxit = 1e+05, type.gaussian = ifelse(nvars < 500, "covariance", "naive"), 
             type.logistic = c("Newton", "modified.Newton"), standardize.response = FALSE, 
             type.multinomial = c("ungrouped", "grouped")) 
         {
             family = match.arg(family)
             if (alpha > 1) {
                 warning("alpha >1; set to 1")
                 alpha = 1
             }
             if (alpha < 0) {
                 warning("alpha<0; set to 0")
                 alpha = 0
             }
             alpha = as.double(alpha)
             this.call = match.call()
             nlam = as.integer(nlambda)
             y = drop(y)
             np = dim(x)
             if (is.null(np) | (np[2] <= 1)) 
                 stop("x should be a matrix with 2 or more columns")
             nobs = as.integer(np[1])
             if (missing(weights)) 
                 weights = rep(1, nobs)
             else if (length(weights) != nobs) 
                 stop(paste("number of elements in weights (", length(weights), ") not equal to the number of rows of x (", 
                     nobs, ")", sep = ""))
             nvars = as.integer(np[2])
             dimy = dim(y)
             nrowy = ifelse(is.null(dimy), length(y), dimy[1])
             if (nrowy != nobs) 
                 stop(paste("number of observations in y (", nrowy, ") not equal to the number of rows of x (", 
                     nobs, ")", sep = ""))
             vnames = colnames(x)
             if (is.null(vnames)) 
                 vnames = paste("V", seq(nvars), sep = "")
             ne = as.integer(dfmax)
             nx = as.integer(pmax)
             if (missing(exclude)) 
                 exclude = integer(0)
             if (any(penalty.factor == Inf)) {
                 exclude = c(exclude, seq(nvars)[penalty.factor == Inf])
                 exclude = sort(unique(exclude))
             }
             if (length(exclude) > 0) {
                 jd = match(exclude, seq(nvars), 0)
                 if (!all(jd > 0)) 
                     stop("Some excluded variables out of range")
                 penalty.factor[jd] = 1
                 jd = as.integer(c(length(jd), jd))
             }
             else jd = as.integer(0)
             vp = as.double(penalty.factor)
             internal.parms = glmnet.control()
             if (any(lower.limits > 0)) {
                 stop("Lower limits should be non-positive")
             }
             if (any(upper.limits < 0)) {
                 stop("Upper limits should be non-negative")
             }
             lower.limits[lower.limits == -Inf] = -internal.parms$big
             upper.limits[upper.limits == Inf] = internal.parms$big
             if (length(lower.limits) < nvars) {
                 if (length(lower.limits) == 1) 
                     lower.limits = rep(lower.limits, nvars)
                 else stop("Require length 1 or nvars lower.limits")
             }
             else lower.limits = lower.limits[seq(nvars)]
             if (length(upper.limits) < nvars) {
                 if (length(upper.limits) == 1) 
                     upper.limits = rep(upper.limits, nvars)
                 else stop("Require length 1 or nvars upper.limits")
             }
             else upper.limits = upper.limits[seq(nvars)]
             cl = rbind(lower.limits, upper.limits)
             if (any(cl == 0)) {
                 fdev = glmnet.control()$fdev
                 if (fdev != 0) {
                     glmnet.control(fdev = 0)
                     on.exit(glmnet.control(fdev = fdev))
                 }
             }
             storage.mode(cl) = "double"
             isd = as.integer(standardize)
             intr = as.integer(intercept)
             if (!missing(intercept) && family == "cox") 
                 warning("Cox model has no intercept")
             jsd = as.integer(standardize.response)
             thresh = as.double(thresh)
             if (is.null(lambda)) {
                 if (lambda.min.ratio >= 1) 
                     stop("lambda.min.ratio should be less than 1")
                 flmin = as.double(lambda.min.ratio)
                 ulam = double(1)
             }
             else {
                 flmin = as.double(1)
                 if (any(lambda < 0)) 
                     stop("lambdas should be non-negative")
                 ulam = as.double(rev(sort(lambda)))
                 nlam = as.integer(length(lambda))
             }
             is.sparse = FALSE
             ix = jx = NULL
             if (inherits(x, "sparseMatrix")) {
                 is.sparse = TRUE
                 x = as(x, "CsparseMatrix")
                 x = as(x, "dgCMatrix")
                 ix = as.integer(x@p + 1)
                 jx = as.integer(x@i + 1)
                 x = as.double(x@x)
             }
             kopt = switch(match.arg(type.logistic), Newton = 0, modified.Newton = 1)
             if (family == "multinomial") {
                 type.multinomial = match.arg(type.multinomial)
                 if (type.multinomial == "grouped") 
                     kopt = 2
             }
             kopt = as.integer(kopt)
             fit = switch(family, gaussian = elnet(x, is.sparse, ix, jx, y, weights, offset, 
                 type.gaussian, alpha, nobs, nvars, jd, vp, cl, ne, nx, nlam, flmin, ulam, 
                 thresh, isd, intr, vnames, maxit), poisson = fishnet(x, is.sparse, ix, 
                 jx, y, weights, offset, alpha, nobs, nvars, jd, vp, cl, ne, nx, nlam, 
                 flmin, ulam, thresh, isd, intr, vnames, maxit), binomial = lognet(x, 
                 is.sparse, ix, jx, y, weights, offset, alpha, nobs, nvars, jd, vp, cl, 
                 ne, nx, nlam, flmin, ulam, thresh, isd, intr, vnames, maxit, kopt, family), 
                 multinomial = lognet(x, is.sparse, ix, jx, y, weights, offset, alpha, 
                     nobs, nvars, jd, vp, cl, ne, nx, nlam, flmin, ulam, thresh, isd, 
                     intr, vnames, maxit, kopt, family), cox = coxnet(x, is.sparse, ix, 
                     jx, y, weights, offset, alpha, nobs, nvars, jd, vp, cl, ne, nx, nlam, 
                     flmin, ulam, thresh, isd, vnames, maxit), mgaussian = mrelnet(x, 
                     is.sparse, ix, jx, y, weights, offset, alpha, nobs, nvars, jd, vp, 
                     cl, ne, nx, nlam, flmin, ulam, thresh, isd, jsd, intr, vnames, maxit))
             if (is.null(lambda)) 
                 fit$lambda = fix.lam(fit$lambda)
             fit$call = this.call
             fit$nobs = nobs
             class(fit) = c(class(fit), "glmnet")
             fit
         })(x = structure(c(0.0223, 0.0211, 0.0346, 0.0388, 0.0188, 0.0378, 0.0151, 0.1088, 
         0.0084, 0.0201, 0.0283, 0.0096, 0.0164, 0.0087, 0.0315, 0.0195, 0.0235, 0.0072, 
         0.0375, 0.0319, 0.0509, 0.0324, 0.037, 0.0318, 0.032, 0.1278, 0.0153, 0.0116, 
         0.0599, 0.0404, 0.0627, 0.0046, 0.0252, 0.0142, 0.0291, 0.0027, 0.0484, 0.0415, 
         0.0079, 0.0688, 0.0953, 0.0423, 0.0599, 0.0926, 0.0291, 0.0123, 0.0656, 0.0682, 
         0.0738, 0.0081, 0.0167, 0.0181, 0.0749, 0.0089, 0.0475, 0.0286, 0.0243, 0.0898, 
         0.0824, 0.035, 0.105, 0.1234, 0.0432, 0.0245, 0.0229, 0.0688, 0.0608, 0.023, 
         0.0479, 0.0406, 0.0519, 0.0061, 0.0647, 0.0121, 0.0432, 0.1267, 0.0249, 0.1787, 
         0.1163, 0.1276, 0.0951, 0.0547, 0.0839, 0.0887, 0.0233, 0.0586, 0.0902, 0.0391, 
         0.0227, 0.042, 0.0591, 0.0438, 0.0735, 0.1515, 0.0488, 0.1635, 0.1734, 0.1731, 
         0.0752, 0.0208, 0.1673, 0.0932, 0.1048, 0.0682, 0.1057, 0.0249, 0.0834, 0.0865, 
         0.0753, 0.1299, 0.0938, 0.2134, 0.1424, 0.0887, 0.1679, 0.1948, 0.0414, 0.0891, 
         0.1154, 0.0955, 0.1338, 0.0993, 0.1024, 0.0892, 0.0677, 0.1182, 0.0098, 0.139, 
         0.1134, 0.2613, 0.1972, 0.0817, 0.1119, 0.4262, 0.0259, 0.0836, 0.1098, 0.214, 
         0.0644, 0.0717, 0.1209, 0.0973, 0.2002, 0.0999, 0.0684, 0.0695, 0.1228, 0.2832, 
         0.1873, 0.1779, 0.0889, 0.6828, 0.0692, 0.1335, 0.137, 0.2546, 0.1522, 0.0576, 
         0.1241, 0.084, 0.2876, 0.1976, 0.1487, 0.0568, 0.1508, 0.2718, 0.1806, 0.2053, 
         0.1205, 0.5761, 0.1753, 0.1199, 0.1767, 0.2952, 0.078, 0.0818, 0.1533, 0.1191, 
         0.3674, 0.2318, 0.1156, 0.0869, 0.1809, 0.3645, 0.2139, 0.3135, 0.0847, 0.4733, 
         0.197, 0.1742, 0.1995, 0.4025, 0.1791, 0.1315, 0.2128, 0.1522, 0.2974, 0.2472, 
         0.1654, 0.1935, 0.239, 0.3934, 0.1523, 0.3118, 0.1518, 0.2362, 0.1167, 0.1387, 
         0.2869, 0.5148, 0.2681, 0.1862, 0.2536, 0.1322, 0.0837, 0.288, 0.3833, 0.1478, 
         0.2947, 0.3843, 0.1975, 0.3686, 0.2305, 0.1023, 0.1683, 0.2042, 0.3275, 0.4901, 
         0.1788, 0.2789, 0.2686, 0.1434, 0.1912, 0.2126, 0.3598, 0.1871, 0.2866, 0.4677, 
         0.4844, 0.3885, 0.2793, 0.2904, 0.0814, 0.258, 0.3769, 0.4127, 0.1039, 0.2579, 
         0.2803, 0.1244, 0.504, 0.0708, 0.1713, 0.1994, 0.401, 0.5364, 0.7298, 0.585, 
         0.3404, 0.4713, 0.2179, 0.2616, 0.4169, 0.3575, 0.198, 0.224, 0.1886, 0.0653, 
         0.6352, 0.1194, 0.1136, 0.3283, 0.5325, 0.4823, 0.7807, 0.7868, 0.4527, 0.4659, 
         0.5121, 0.2097, 0.5036, 0.3447, 0.3234, 0.2568, 0.1485, 0.089, 0.6804, 0.2808, 
         0.0349, 0.6861, 0.5486, 0.4835, 0.7906, 0.9739, 0.695, 0.1415, 0.7231, 0.2532, 
         0.618, 0.3068, 0.3748, 0.2933, 0.216, 0.1226, 0.7505, 0.4221, 0.3796, 0.5814, 
         0.5823, 0.5862, 0.6122, 1, 0.8807, 0.0849, 0.7776, 0.3213, 0.8025, 0.2945, 0.2586, 
         0.2991, 0.2417, 0.1846, 0.6595, 0.5279, 0.7401, 0.25, 0.6041, 0.7579, 0.42, 0.9843, 
         0.9154, 0.3257, 0.6222, 0.4327, 0.9333, 0.4351, 0.368, 0.3924, 0.2989, 0.388, 
         0.4509, 0.5857, 0.9925, 0.1734, 0.6749, 0.6997, 0.2807, 0.861, 0.7542, 0.9007, 
         0.3501, 0.476, 0.9399, 0.7264, 0.3508, 0.4691, 0.3341, 0.3658, 0.2964, 0.6153, 
         0.9802, 0.3363, 0.7084, 0.6918, 0.5148, 0.8443, 0.6736, 0.9312, 0.3733, 0.5328, 
         0.9275, 0.8147, 0.5606, 0.5665, 0.3786, 0.2297, 0.4019, 0.6753, 0.889, 0.5588, 
         0.789, 0.8633, 0.7569, 0.9061, 0.7146, 0.4856, 0.2622, 0.6057, 0.945, 0.8103, 
         0.5231, 0.6464, 0.3956, 0.261, 0.6794, 0.7873, 0.6712, 0.6592, 0.9284, 0.9107, 
         0.8596, 0.5847, 0.8335, 0.1346, 0.3776, 0.6696, 0.8328, 0.6665, 0.5469, 0.6774, 
         0.5232, 0.4193, 0.8297, 0.8974, 0.4286, 0.7012, 0.9781, 0.9346, 1, 0.4033, 0.7701, 
         0.1604, 0.7361, 0.7476, 0.7773, 0.6958, 0.6954, 0.7577, 0.6913, 0.5848, 1, 0.9828, 
         0.3374, 0.8099, 0.9738, 0.7884, 0.8457, 0.5946, 0.6993, 0.2737, 0.8673, 0.893, 
         0.7007, 0.7748, 0.6352, 0.8856, 0.7868, 0.5643, 0.824, 1, 0.7366, 0.8901, 1, 
         0.8585, 0.6797, 0.6793, 0.6543, 0.5609, 0.8223, 0.9405, 0.6154, 0.8688, 0.6757, 
         0.9419, 0.8337, 0.5448, 0.7115, 0.846, 0.9611, 0.8745, 0.9702, 0.9261, 0.6971, 
         0.6389, 0.504, 0.3654, 0.7772, 1, 0.581, 1, 0.8499, 1, 0.9199, 0.4772, 0.7726, 
         0.6055, 0.7353, 0.7887, 0.9956, 0.708, 0.5843, 0.5002, 0.4926, 0.6139, 0.7862, 
         0.9785, 0.4454, 0.9941, 0.8025, 0.8564, 1, 0.6897, 0.6124, 0.3036, 0.4856, 0.8725, 
         0.8235, 0.5779, 0.4772, 0.5578, 0.4992, 0.547, 0.5652, 0.8473, 0.3707, 0.8793, 
         0.6563, 0.679, 0.899, 0.9797, 0.4936, 0.0144, 0.1594, 0.9376, 0.602, 0.5215, 
         0.5201, 0.4831, 0.4161, 0.8474, 0.3635, 0.7639, 0.2891, 0.6482, 0.8591, 0.5587, 
         0.6456, 1, 0.5648, 0.2526, 0.3007, 0.892, 0.5342, 0.4505, 0.4241, 0.4729, 0.1631, 
         0.5638, 0.3534, 0.6701, 0.2185, 0.5876, 0.6655, 0.4147, 0.5967, 0.9546, 0.4906, 
         0.4335, 0.4096, 0.7508, 0.4867, 0.3129, 0.1592, 0.3318, 0.0404, 0.5443, 0.3865, 
         0.4989, 0.1711, 0.6408, 0.5369, 0.2946, 0.4355, 0.8835, 0.182, 0.4918, 0.317, 
         0.6832, 0.3526, 0.1448, 0.1668, 0.3969, 0.0637, 0.5086, 0.337, 0.3718, 0.3578, 
         0.4972, 0.3118, 0.2025, 0.2997, 0.7662, 0.1811, 0.5409, 0.3305, 0.761, 0.1566, 
         0.1046, 0.0588, 0.3894, 0.2962, 0.6253, 0.1693, 0.2196, 0.3947, 0.2755, 0.3763, 
         0.0688, 0.2294, 0.6547, 0.1107, 0.5961, 0.3408, 0.9017, 0.0946, 0.182, 0.3967, 
         0.2314, 0.3609, 0.8497, 0.2627, 0.1416, 0.2867, 0.03, 0.2801, 0.1171, 0.1866, 
         0.5447, 0.4603, 0.5248, 0.2186, 1, 0.1613, 0.1519, 0.7147, 0.1036, 0.1866, 0.8406, 
         0.3195, 0.268, 0.2401, 0.3356, 0.0875, 0.2157, 0.0922, 0.4593, 0.665, 0.3777, 
         0.2463, 0.9123, 0.2824, 0.1017, 0.7319, 0.1312, 0.0476, 0.842, 0.1388, 0.263, 
         0.3619, 0.3167, 0.3319, 0.2216, 0.1829, 0.4679, 0.6423, 0.2369, 0.2726, 0.7388, 
         0.339, 0.1438, 0.3509, 0.0864, 0.1497, 0.9136, 0.1048, 0.3104, 0.3314, 0.4133, 
         0.4237, 0.2776, 0.1743, 0.1987, 0.2166, 0.172, 0.168, 0.5915, 0.3019, 0.1986, 
         0.0589, 0.2569, 0.2405, 0.7713, 0.1681, 0.3392, 0.3763, 0.6281, 0.1801, 0.2309, 
         0.2452, 0.0699, 0.1951, 0.1878, 0.2792, 0.4057, 0.2945, 0.2039, 0.269, 0.3179, 
         0.198, 0.4882, 0.191, 0.2123, 0.4767, 0.4977, 0.3743, 0.1444, 0.2407, 0.1493, 
         0.4947, 0.325, 0.2558, 0.3019, 0.2978, 0.2778, 0.42, 0.2649, 0.3175, 0.3724, 
         0.1174, 0.117, 0.4059, 0.2613, 0.4627, 0.1513, 0.2518, 0.1713, 0.4925, 0.2575, 
         0.174, 0.2331, 0.2676, 0.2879, 0.3874, 0.2714, 0.2379, 0.4469, 0.0933, 0.2655, 
         0.3661, 0.4697, 0.1614, 0.1745, 0.3184, 0.1654, 0.4041, 0.2423, 0.2121, 0.2931, 
         0.2055, 0.1331, 0.244, 0.1713, 0.1716, 0.4586, 0.0856, 0.2203, 0.232, 0.4806, 
         0.2494, 0.1756, 0.1685, 0.26, 0.2402, 0.2706, 0.1099, 0.2298, 0.2069, 0.114, 
         0.2, 0.0584, 0.1559, 0.4491, 0.0951, 0.1541, 0.145, 0.4921, 0.3202, 0.1424, 0.0675, 
         0.3846, 0.1392, 0.2323, 0.0985, 0.2391, 0.1625, 0.131, 0.2307, 0.123, 0.1556, 
         0.5616, 0.0986, 0.1464, 0.1017, 0.5294, 0.2265, 0.0908, 0.1186, 0.3754, 0.1779, 
         0.1724, 0.1271, 0.191, 0.1216, 0.1433, 0.1886, 0.22, 0.0422, 0.4305, 0.0956, 
         0.1044, 0.1111, 0.2216, 0.1146, 0.0138, 0.1833, 0.2414, 0.1946, 0.1457, 0.1459, 
         0.1096, 0.1013, 0.0624, 0.196, 0.2198, 0.0493, 0.0945, 0.0426, 0.1225, 0.0655, 
         0.1401, 0.0476, 0.0469, 0.1878, 0.1077, 0.1723, 0.1175, 0.1164, 0.03, 0.0744, 
         0.01, 0.1701, 0.1074, 0.0476, 0.0794, 0.0407, 0.0745, 0.0271, 0.1888, 0.0943, 
         0.048, 0.1114, 0.0224, 0.1522, 0.0868, 0.0777, 0.0171, 0.0386, 0.0098, 0.1366, 
         0.0423, 0.0219, 0.0274, 0.0106, 0.049, 0.0244, 0.0947, 0.0824, 0.0159, 0.031, 
         0.0155, 0.0929, 0.0392, 0.0439, 0.0383, 0.005, 0.0131, 0.0398, 0.0162, 0.0059, 
         0.0154, 0.0179, 0.0224, 0.0179, 0.0134, 0.0171, 0.0045, 0.0143, 0.0187, 0.0179, 
         0.0131, 0.0061, 0.0053, 0.0146, 0.0152, 0.0143, 0.0093, 0.0086, 0.014, 0.0056, 
         0.0032, 0.0109, 0.031, 0.0244, 0.0015, 0.0138, 0.0125, 0.0242, 0.0092, 0.0145, 
         0.009, 0.004, 0.0255, 0.0093, 0.0046, 0.0061, 0.0455, 0.0236, 0.0076, 0.0147, 
         0.0237, 0.0258, 0.0052, 0.0108, 0.0028, 0.0083, 0.0078, 0.0128, 0.0042, 0.0122, 
         0.0071, 0.0033, 0.0044, 0.0015, 0.0213, 0.0114, 0.0045, 0.017, 0.0078, 0.0143, 
         0.0038, 0.0062, 0.0067, 0.0037, 0.0071, 0.0145, 0.0153, 0.0107, 0.0263, 0.0113, 
         0.0078, 0.0084, 0.0082, 0.0136, 0.0056, 0.0158, 0.0144, 0.0226, 0.0079, 0.0044, 
         0.012, 0.0095, 0.0081, 0.0058, 0.0106, 0.0112, 0.0079, 0.003, 0.0102, 0.0128, 
         0.0124, 0.0117, 0.0075, 0.0046, 0.017, 0.0187, 0.0114, 0.0072, 0.0012, 0.0105, 
         0.0034, 0.0049, 0.002, 0.0102, 0.0111, 0.0057, 0.0065, 0.0054, 0.0167, 0.006, 
         0.0037, 0.0073, 0.0012, 0.0185, 0.005, 7e-04, 0.0022, 0.003, 0.0064, 0.0065, 
         0.0105, 0.0052, 0.0107, 0.009, 0.0061, 0.0011, 0.0103, 0.0058, 0.0045, 0.0054, 
         0.0109, 0.011, 0.003, 0.0054, 0.0058, 0.0132, 0.0037, 0.0093, 0.0049, 0.0024, 
         0.0068, 0.0057, 0.0062, 0.0019, 0.0205, 0.0031, 0.0029, 0.0033, 0.0036, 0.0094, 
         0.0064, 0.0035, 0.0042, 0.0068, 0.0036, 0.0059, 0.007, 0.0079, 0.0097, 0.0068, 
         0.0043, 0.0023, 0.0178, 0.0072, 8e-04, 0.0045, 0.0043, 0.0078, 0.0058, 1e-04, 
         0.0067, 0.0108, 0.0012, 0.0022, 0.008, 0.0031, 0.0067, 0.0024, 0.0053, 0.0062, 
         0.0187, 0.0045, 0.0018, 0.0079, 0.0018, 0.0112, 0.003, 0.0055, 0.0012, 0.009, 
         0.0037), .Dim = c(18L, 60L), .Dimnames = list(c("9", "43", "121", "125", "87", 
         "85", "27", "137", "32", "56", "114", "184", "140", "53", "192", "69", "90", 
         "164"), c("V1", "V2", "V3", "V4", "V5", "V6", "V7", "V8", "V9", "V10", "V11", 
         "V12", "V13", "V14", "V15", "V16", "V17", "V18", "V19", "V20", "V21", "V22", 
         "V23", "V24", "V25", "V26", "V27", "V28", "V29", "V30", "V31", "V32", "V33", 
         "V34", "V35", "V36", "V37", "V38", "V39", "V40", "V41", "V42", "V43", "V44", 
         "V45", "V46", "V47", "V48", "V49", "V50", "V51", "V52", "V53", "V54", "V55", 
         "V56", "V57", "V58", "V59", "V60"))), y = structure(c(2L, 2L, 1L, 1L, 2L, 2L, 
         2L, 1L, 2L, 2L, 1L, 1L, 1L, 2L, 1L, 2L, 2L, 1L), .Label = c("M", "R"), class = "factor"), 
             family = "binomial"), nobs = 18L), .Names = c("a0", "beta", "df", "dim", 
     "lambda", "dev.ratio", "nulldev", "npasses", "jerr", "offset", "classnames", "call", 
     "nobs"), class = c("lognet", "glmnet"), mlr.train.info = structure(list(factors = structure(list(), .Names = character(0)), 
         ordered = structure(list(), .Names = character(0)), restore.levels = FALSE, factors.to.dummies = FALSE, 
         ordered.to.int = FALSE), .Names = c("factors", "ordered", "restore.levels", "factors.to.dummies", 
     "ordered.to.int"), class = "FixDataInfo")), task.desc = structure(list(id = "binary", 
         type = "classif", target = "Class", size = 62L, n.feat = structure(c(60L, 0L, 
         0L), .Names = c("numerics", "factors", "ordered")), has.missings = FALSE, has.weights = FALSE, 
         has.blocking = FALSE, class.levels = c("M", "R"), positive = "M", negative = "R"), .Names = c("id", 
     "type", "target", "size", "n.feat", "has.missings", "has.weights", "has.blocking", 
     "class.levels", "positive", "negative"), class = c("ClassifTaskDesc", "SupervisedTaskDesc", 
     "TaskDesc")), subset = c(18L, 49L, 25L, 53L, 55L, 3L, 30L, 50L, 56L, 60L, 58L, 24L, 
     34L, 29L, 5L, 43L, 12L, 2L), features = c("V1", "V2", "V3", "V4", "V5", "V6", "V7", 
     "V8", "V9", "V10", "V11", "V12", "V13", "V14", "V15", "V16", "V17", "V18", "V19", 
     "V20", "V21", "V22", "V23", "V24", "V25", "V26", "V27", "V28", "V29", "V30", "V31", 
     "V32", "V33", "V34", "V35", "V36", "V37", "V38", "V39", "V40", "V41", "V42", "V43", 
     "V44", "V45", "V46", "V47", "V48", "V49", "V50", "V51", "V52", "V53", "V54", "V55", 
     "V56", "V57", "V58", "V59", "V60"), factor.levels = structure(list(Class = c("M", 
     "R")), .Names = "Class"), time = 0.0350000000000001, dump = NULL), .Names = c("learner", 
     "learner.model", "task.desc", "subset", "features", "factor.levels", "time", "dump"
     ), class = "WrappedModel"), .newdata = structure(list(V1 = c(0.0137, 0.1083, 0.027, 
     0.0115, 0.0333, 0.0203, 0.0443, 0.0132, 0.0235, 0.0329, 0.0394, 0.0201, 0.1371, 0.0202, 
     0.0126, 0.053, 0.0164, 0.0373, 0.0411, 0.0216, 0.0091, 0.0519, 0.0134, 0.021, 0.0201, 
     0.0099, 0.0968, 0.0261, 0.0423, 0.0126, 0.0409, 0.0179, 0.031, 0.013, 0.0331, 0.0762, 
     0.0428, 0.0158, 0.1313, 0.009, 0.0125, 0.0086, 0.0209, 0.0162), V2 = c(0.0297, 0.107, 
     0.0092, 0.015, 0.0221, 0.0121, 0.0446, 0.008, 0.022, 0.0216, 0.042, 0.0026, 0.1226, 
     0.0104, 0.0519, 0.0885, 0.0173, 0.0281, 0.0277, 0.0215, 0.0213, 0.0548, 0.0172, 0.0121, 
     0.0423, 0.0484, 0.0821, 0.0266, 0.0321, 0.0149, 0.0421, 0.0136, 0.0221, 6e-04, 0.0423, 
     0.0666, 0.0555, 0.0239, 0.2339, 0.0062, 0.0152, 0.0215, 0.0191, 0.0041), V3 = c(0.0116, 
     0.0257, 0.0145, 0.0136, 0.027, 0.038, 0.0235, 0.0188, 0.0167, 0.0386, 0.0446, 0.0138, 
     0.1385, 0.0325, 0.0621, 0.1997, 0.0347, 0.0232, 0.0604, 0.0273, 0.0206, 0.0842, 0.0178, 
     0.0203, 0.0554, 0.0299, 0.0629, 0.0223, 0.0709, 0.0641, 0.0573, 0.0408, 0.0433, 0.0088, 
     0.0474, 0.0481, 0.0708, 0.015, 0.3059, 0.0253, 0.0218, 0.0242, 0.0411, 0.0239), V4 = c(0.0082, 
     0.0837, 0.0278, 0.0076, 0.0481, 0.0128, 0.1008, 0.0141, 0.0516, 0.0627, 0.0551, 0.0062, 
     0.1484, 0.0239, 0.0518, 0.2604, 0.007, 0.0225, 0.0525, 0.0139, 0.0505, 0.0319, 0.0363, 
     0.1036, 0.0783, 0.0297, 0.0608, 0.0749, 0.0108, 0.1732, 0.013, 0.0633, 0.0191, 0.0456, 
     0.0818, 0.0394, 0.0618, 0.0494, 0.4264, 0.0489, 0.0175, 0.0445, 0.0321, 0.0441), 
         V5 = c(0.0241, 0.0748, 0.0412, 0.0211, 0.0679, 0.0537, 0.2252, 0.0436, 0.0746, 
         0.1158, 0.0597, 0.0133, 0.1776, 0.0807, 0.1072, 0.3225, 0.0187, 0.0179, 0.0489, 
         0.0357, 0.0657, 0.1158, 0.0444, 0.1675, 0.062, 0.0652, 0.0617, 0.1364, 0.107, 
         0.2565, 0.0183, 0.0596, 0.0964, 0.0525, 0.0835, 0.059, 0.1215, 0.0988, 0.401, 
         0.1197, 0.0362, 0.0667, 0.0698, 0.063), V6 = c(0.0253, 0.1125, 0.0757, 0.1058, 
         0.0981, 0.0874, 0.2611, 0.0668, 0.1121, 0.1482, 0.1416, 0.0151, 0.1428, 0.1529, 
         0.2587, 0.2247, 0.0671, 0.0733, 0.0385, 0.0785, 0.0795, 0.0922, 0.0744, 0.0418, 
         0.0871, 0.1077, 0.1207, 0.1513, 0.0973, 0.2559, 0.1019, 0.0808, 0.1827, 0.0778, 
         0.0756, 0.0649, 0.1524, 0.1425, 0.1791, 0.1589, 0.0696, 0.0771, 0.1579, 0.0921
         ), V7 = c(0.0279, 0.3322, 0.1026, 0.1023, 0.0843, 0.1021, 0.2061, 0.0609, 0.1258, 
         0.2054, 0.0956, 0.0541, 0.1773, 0.1154, 0.2304, 0.0617, 0.1056, 0.0841, 0.0611, 
         0.0906, 0.097, 0.1027, 0.08, 0.0723, 0.1201, 0.2363, 0.0944, 0.1316, 0.0961, 
         0.2947, 0.1054, 0.209, 0.1106, 0.0931, 0.0374, 0.1209, 0.1543, 0.1463, 0.1853, 
         0.1392, 0.0873, 0.0499, 0.1438, 0.1368), V8 = c(0.013, 0.459, 0.1138, 0.044, 
         0.1172, 0.0852, 0.1668, 0.0131, 0.1717, 0.1605, 0.0802, 0.021, 0.2161, 0.0608, 
         0.2067, 0.2287, 0.0697, 0.1031, 0.1117, 0.0908, 0.0872, 0.0613, 0.0456, 0.0828, 
         0.2707, 0.2385, 0.4223, 0.1654, 0.1323, 0.411, 0.107, 0.3465, 0.1702, 0.0941, 
         0.0961, 0.2467, 0.0391, 0.1219, 0.0055, 0.0987, 0.0616, 0.0906, 0.1402, 0.1078
         ), V9 = c(0.0489, 0.5526, 0.0794, 0.0931, 0.0759, 0.1136, 0.1801, 0.0899, 0.3074, 
         0.2532, 0.1618, 0.0505, 0.163, 0.1317, 0.3416, 0.095, 0.0962, 0.0993, 0.1237, 
         0.1151, 0.0743, 0.1465, 0.0368, 0.0494, 0.1206, 0.0075, 0.5744, 0.1864, 0.2462, 
         0.4983, 0.2302, 0.5276, 0.2804, 0.1711, 0.0548, 0.3564, 0.061, 0.1697, 0.1929, 
         0.0955, 0.1252, 0.1229, 0.3048, 0.1552), V10 = c(0.0874, 0.5966, 0.152, 0.0734, 
         0.092, 0.1747, 0.3083, 0.0922, 0.3199, 0.2672, 0.2558, 0.1097, 0.2067, 0.137, 
         0.4284, 0.074, 0.0251, 0.0802, 0.23, 0.0973, 0.0837, 0.2838, 0.125, 0.0686, 0.0279, 
         0.1882, 0.5025, 0.2013, 0.2696, 0.592, 0.2259, 0.5965, 0.4432, 0.1483, 0.0193, 
         0.4459, 0.0113, 0.1923, 0.2231, 0.1895, 0.1302, 0.1185, 0.3914, 0.1779), V11 = c(0.11, 
         0.5304, 0.1675, 0.074, 0.1475, 0.2198, 0.3794, 0.1445, 0.2946, 0.3056, 0.3078, 
         0.0841, 0.4257, 0.0843, 0.3015, 0.161, 0.0801, 0.1564, 0.137, 0.1203, 0.1579, 
         0.2802, 0.2405, 0.1125, 0.2251, 0.1456, 0.3488, 0.289, 0.3412, 0.5832, 0.2373, 
         0.6254, 0.5222, 0.1532, 0.0897, 0.4152, 0.1255, 0.2361, 0.2907, 0.1896, 0.0888, 
         0.0775, 0.3504, 0.2164), V12 = c(0.1084, 0.2251, 0.137, 0.0622, 0.0522, 0.2721, 
         0.5364, 0.1475, 0.2484, 0.3161, 0.3404, 0.0942, 0.5484, 0.0269, 0.1207, 0.2226, 
         0.1056, 0.2565, 0.1335, 0.1102, 0.0898, 0.3086, 0.2325, 0.1741, 0.2615, 0.1892, 
         0.17, 0.365, 0.4292, 0.5419, 0.3323, 0.4507, 0.5611, 0.11, 0.1734, 0.3952, 0.2473, 
         0.2719, 0.2259, 0.2547, 0.05, 0.1101, 0.3669, 0.2568), V13 = c(0.1094, 0.2402, 
         0.1361, 0.1055, 0.1119, 0.2105, 0.6173, 0.2087, 0.251, 0.2314, 0.34, 0.1204, 
         0.7131, 0.1254, 0.3299, 0.2703, 0.1266, 0.2624, 0.2137, 0.1192, 0.0309, 0.2657, 
         0.2523, 0.271, 0.177, 0.3176, 0.2076, 0.351, 0.3682, 0.5472, 0.3827, 0.3693, 
         0.5379, 0.089, 0.1936, 0.4256, 0.3011, 0.3049, 0.3136, 0.4073, 0.0628, 0.1042, 
         0.3943, 0.3089), V14 = c(0.1023, 0.2689, 0.1345, 0.1183, 0.097, 0.1727, 0.7842, 
         0.2558, 0.1806, 0.2067, 0.3951, 0.042, 0.7003, 0.3046, 0.5707, 0.3365, 0.089, 
         0.1179, 0.1526, 0.1762, 0.1856, 0.3801, 0.1472, 0.3087, 0.3709, 0.134, 0.3087, 
         0.3495, 0.394, 0.5314, 0.484, 0.2864, 0.4048, 0.1236, 0.2803, 0.4135, 0.3747, 
         0.2986, 0.3302, 0.2988, 0.1274, 0.0853, 0.3311, 0.3829), V15 = c(0.0601, 0.6646, 
         0.2144, 0.1721, 0.1174, 0.204, 0.8392, 0.2603, 0.1413, 0.1804, 0.3352, 0.0031, 
         0.6777, 0.5584, 0.6962, 0.4266, 0.0198, 0.0597, 0.0775, 0.239, 0.2969, 0.5626, 
         0.0669, 0.3575, 0.4533, 0.2169, 0.4224, 0.4325, 0.2965, 0.4981, 0.6812, 0.1635, 
         0.2245, 0.1197, 0.3313, 0.4528, 0.452, 0.2226, 0.366, 0.2901, 0.0801, 0.0456, 
         0.3331, 0.4393), V16 = c(0.0906, 0.6632, 0.5354, 0.2584, 0.1678, 0.1786, 0.9016, 
         0.1985, 0.3019, 0.2808, 0.2252, 0.0162, 0.7939, 0.7973, 0.9751, 0.4144, 0.1133, 
         0.1563, 0.1196, 0.2138, 0.2032, 0.4376, 0.11, 0.4998, 0.5553, 0.2458, 0.5312, 
         0.5398, 0.3172, 0.6985, 0.7555, 0.0422, 0.1784, 0.1145, 0.502, 0.5326, 0.5392, 
         0.1745, 0.3956, 0.5326, 0.0742, 0.1304, 0.3002, 0.5335), V17 = c(0.1313, 0.1674, 
         0.683, 0.3232, 0.1642, 0.1318, 1, 0.2394, 0.3635, 0.4423, 0.2086, 0.0624, 0.9382, 
         0.8341, 1, 0.5655, 0.2826, 0.2241, 0.0903, 0.1929, 0.1264, 0.2617, 0.2353, 0.6011, 
         0.4616, 0.2589, 0.2436, 0.6237, 0.2825, 0.8292, 0.9522, 0.1785, 0.2297, 0.2137, 
         0.636, 0.7306, 0.6588, 0.2459, 0.4386, 0.4022, 0.2048, 0.269, 0.2324, 0.5996), 
         V18 = c(0.2758, 0.0837, 0.56, 0.3817, 0.1205, 0.226, 0.8911, 0.3134, 0.3887, 
         0.5947, 0.2248, 0.2127, 0.8925, 0.8057, 0.9293, 0.6921, 0.3234, 0.3586, 0.0689, 
         0.1765, 0.1655, 0.1199, 0.3282, 0.647, 0.3797, 0.2786, 0.1884, 0.6876, 0.305, 
         0.7839, 0.9826, 0.4394, 0.272, 0.2838, 0.7096, 0.6193, 0.7113, 0.31, 0.467, 0.1571, 
         0.295, 0.2947, 0.1381, 0.6728), V19 = c(0.366, 0.4331, 0.3093, 0.4243, 0.0494, 
         0.2358, 0.8753, 0.4077, 0.298, 0.6601, 0.3382, 0.3436, 0.9146, 0.8616, 0.621, 
         0.8547, 0.3238, 0.1792, 0.2071, 0.0746, 0.1661, 0.6676, 0.4416, 0.8067, 0.345, 
         0.2298, 0.1908, 0.7329, 0.2408, 0.8215, 0.8871, 0.695, 0.5209, 0.364, 0.8333, 
         0.2032, 0.7602, 0.3572, 0.5255, 0.3024, 0.3193, 0.3669, 0.345, 0.7309), V20 = c(0.5269, 
         0.8718, 0.3226, 0.4217, 0.1544, 0.3107, 0.7886, 0.4529, 0.2219, 0.5844, 0.4578, 
         0.3813, 0.7832, 0.8769, 0.4586, 0.9234, 0.4333, 0.3256, 0.2975, 0.1265, 0.2091, 
         0.9402, 0.5167, 0.9008, 0.2665, 0.0656, 0.8321, 0.8107, 0.542, 0.9363, 0.8268, 
         0.8097, 0.6898, 0.543, 0.873, 0.4636, 0.8672, 0.4283, 0.3735, 0.3907, 0.4567, 
         0.4948, 0.4428, 0.8092), V21 = c(0.581, 0.7992, 0.443, 0.4449, 0.3485, 0.3906, 
         0.7156, 0.4893, 0.1624, 0.4539, 0.6474, 0.3825, 0.796, 0.9413, 0.5001, 0.9171, 
         0.6068, 0.6079, 0.2836, 0.2005, 0.231, 0.7832, 0.6508, 0.8906, 0.2395, 0.1441, 
         1, 0.8396, 0.6802, 1, 0.7561, 0.855, 0.8202, 0.6673, 0.8073, 0.4148, 0.8416, 
         0.4268, 0.2243, 0.3542, 0.5959, 0.6275, 0.489, 0.8941), V22 = c(0.6181, 0.3712, 
         0.5573, 0.4075, 0.6146, 0.3631, 0.7581, 0.5666, 0.1343, 0.4789, 0.6708, 0.4764, 
         0.7983, 0.9403, 0.5032, 1, 0.7652, 0.6988, 0.3353, 0.1571, 0.446, 0.5352, 0.7793, 
         0.9338, 0.1127, 0.1179, 0.4076, 0.8632, 0.632, 0.9224, 0.8217, 0.8717, 0.878, 
         0.7979, 0.7507, 0.4292, 0.7974, 0.3735, 0.1973, 0.4438, 0.7101, 0.8162, 0.3677, 
         0.9668), V23 = c(0.5875, 0.1703, 0.5782, 0.3306, 0.9146, 0.4809, 0.6372, 0.6234, 
         0.2046, 0.5646, 0.7007, 0.6313, 0.7716, 0.9409, 0.7082, 0.9532, 0.9203, 0.8391, 
         0.3622, 0.2605, 0.6634, 0.6809, 0.7978, 1, 0.2556, 0.1668, 0.096, 0.8747, 0.5824, 
         0.7839, 0.6967, 0.8601, 0.76, 0.9273, 0.7526, 0.573, 0.8385, 0.4585, 0.4337, 
         0.6414, 0.8225, 0.9237, 0.4379, 1), V24 = c(0.4639, 0.1611, 0.6173, 0.4012, 0.9364, 
         0.6531, 0.321, 0.6741, 0.3791, 0.5281, 0.7619, 0.7523, 0.6615, 1, 0.842, 0.9101, 
         0.9719, 0.8553, 0.3202, 0.5386, 0.6933, 0.9174, 0.7786, 0.9102, 0.5169, 0.1783, 
         0.1928, 0.9607, 0.6805, 0.547, 0.6444, 0.9201, 0.7616, 0.9027, 0.7298, 0.5399, 
         0.9317, 0.6094, 0.6532, 0.4601, 0.8425, 0.871, 0.4864, 0.9893), V25 = c(0.5424, 
         0.2086, 0.8132, 0.4466, 0.8677, 0.7812, 0.2076, 0.8282, 0.5771, 0.7115, 0.7745, 
         0.8675, 0.486, 0.9725, 0.8109, 0.8337, 0.9207, 0.771, 0.3452, 0.844, 0.7663, 
         0.7613, 0.8587, 0.8496, 0.3779, 0.2476, 0.2419, 0.9716, 0.5984, 0.4562, 0.6948, 
         0.8729, 0.7152, 0.9192, 0.6177, 0.3161, 0.8555, 0.7221, 0.507, 0.6009, 0.9065, 
         0.8052, 0.6207, 0.9376), V26 = c(0.7367, 0.2847, 0.9819, 0.5218, 0.8772, 0.8395, 
         0.2279, 0.8823, 0.7545, 1, 0.6767, 0.8788, 0.5572, 0.9309, 0.769, 0.7053, 0.7545, 
         0.6215, 0.3562, 1, 0.8206, 0.822, 0.9321, 0.7867, 0.4082, 0.257, 0.379, 0.9121, 
         0.8412, 0.5922, 0.8014, 0.8084, 0.7288, 1, 0.4946, 0.2285, 0.6162, 0.7595, 0.2796, 
         0.869, 0.9802, 0.8756, 0.7256, 0.8991), V27 = c(0.9089, 0.2211, 0.9823, 0.7552, 
         0.8553, 0.918, 0.3309, 0.9196, 0.8406, 0.9564, 0.7373, 0.7901, 0.4697, 0.9351, 
         0.8105, 0.6534, 0.8289, 0.5736, 0.3892, 0.8684, 0.7049, 0.8872, 0.9454, 0.7688, 
         0.5353, 0.1036, 0.2893, 0.8576, 0.9911, 0.5448, 0.6053, 0.8694, 0.8686, 0.9821, 
         0.4531, 0.6995, 0.4139, 0.8706, 0.4163, 0.8345, 1, 1, 0.6624, 0.9184), V28 = c(1, 
         0.6134, 0.9166, 0.9503, 0.8833, 0.9769, 0.2847, 0.8965, 0.8547, 0.609, 0.7834, 
         0.8357, 0.564, 0.7317, 0.6203, 0.4483, 0.8907, 0.4402, 0.6622, 0.6742, 0.756, 
         0.6091, 0.8645, 0.7718, 0.5116, 0.5356, 0.3451, 0.8798, 0.9187, 0.3971, 0.6084, 
         0.8411, 0.9509, 0.9092, 0.4099, 1, 0.3269, 1, 0.595, 0.7669, 0.8752, 0.9858, 
         0.7689, 0.9128), V29 = c(0.8247, 0.5807, 0.7423, 1, 1, 0.8937, 0.1949, 0.7549, 
         0.9036, 0.5112, 0.9619, 0.9631, 0.4517, 0.4421, 0.2356, 0.246, 0.7309, 0.4056, 
         0.9254, 0.5537, 0.7466, 0.2967, 0.722, 0.6268, 0.4544, 0.7124, 0.3777, 0.772, 
         0.8005, 0.0882, 0.8877, 0.5793, 0.8348, 0.8184, 0.454, 0.7262, 0.3108, 0.9815, 
         0.5242, 0.5081, 0.7583, 0.9427, 0.7981, 0.7811), V30 = c(0.5441, 0.6925, 0.7736, 
         0.9084, 0.8296, 0.7022, 0.1671, 0.6736, 1, 0.4, 1, 0.9619, 0.3369, 0.3244, 0.2595, 
         0.202, 0.6896, 0.4411, 1, 0.4638, 0.6387, 0.1103, 0.485, 0.4301, 0.4258, 0.6291, 
         0.5213, 0.5711, 0.6713, 0.2385, 0.8557, 0.3754, 0.573, 0.6962, 0.4124, 0.4724, 
         0.2554, 0.7187, 0.4178, 0.462, 0.6616, 0.8114, 0.8577, 0.6018), V31 = c(0.3349, 
         0.3825, 0.8473, 0.8283, 0.6601, 0.65, 0.1025, 0.6463, 0.9646, 0.0482, 0.8086, 
         0.9236, 0.2684, 0.4161, 0.6299, 0.1446, 0.5829, 0.513, 0.8528, 0.3609, 0.4846, 
         0.1318, 0.1357, 0.2077, 0.3869, 0.4756, 0.2316, 0.4264, 0.5632, 0.2005, 0.5563, 
         0.3485, 0.4363, 0.59, 0.3139, 0.5103, 0.3367, 0.5848, 0.3714, 0.538, 0.5786, 
         0.6987, 0.9273, 0.3765), V32 = c(0.0877, 0.4303, 0.7352, 0.7571, 0.5499, 0.5069, 
         0.1362, 0.5007, 0.7912, 0.1852, 0.5558, 0.8903, 0.2339, 0.4611, 0.6762, 0.0994, 
         0.4935, 0.5965, 0.6297, 0.2055, 0.3328, 0.0624, 0.2951, 0.1198, 0.3939, 0.6015, 
         0.3335, 0.286, 0.7332, 0.0587, 0.2897, 0.4639, 0.4289, 0.5447, 0.3194, 0.5459, 
         0.4465, 0.4192, 0.2375, 0.5375, 0.5128, 0.681, 0.7009, 0.33), V33 = c(0.16, 0.7791, 
         0.6671, 0.7262, 0.5716, 0.3903, 0.2212, 0.3663, 0.6412, 0.2186, 0.5409, 0.9708, 
         0.3052, 0.4031, 0.2903, 0.151, 0.3101, 0.7272, 0.525, 0.162, 0.5356, 0.099, 0.4715, 
         0.166, 0.4661, 0.7208, 0.4781, 0.3114, 0.6038, 0.2544, 0.3638, 0.6495, 0.424, 
         0.5142, 0.3692, 0.2881, 0.5, 0.3756, 0.0863, 0.3844, 0.4776, 0.6591, 0.4851, 
         0.228), V34 = c(0.4169, 0.8703, 0.6083, 0.6152, 0.6859, 0.3009, 0.1124, 0.2298, 
         0.5986, 0.1436, 0.4988, 0.9647, 0.3016, 0.3, 0.4393, 0.2392, 0.0306, 0.6539, 
         0.4012, 0.2092, 0.8741, 0.4006, 0.6036, 0.2618, 0.3974, 0.6234, 0.6116, 0.2066, 
         0.2575, 0.2009, 0.4786, 0.6901, 0.3156, 0.5389, 0.3776, 0.0981, 0.5111, 0.3263, 
         0.1437, 0.3601, 0.4994, 0.6954, 0.3409, 0.0212), V35 = c(0.6576, 1, 0.6239, 0.568, 
         0.6825, 0.1565, 0.1677, 0.1362, 0.6835, 0.1757, 0.3108, 0.7892, 0.2753, 0.2459, 
         0.8529, 0.4434, 0.0244, 0.5902, 0.2901, 0.31, 0.8573, 0.3666, 0.8083, 0.3862, 
         0.2194, 0.5725, 0.6705, 0.1165, 0.0349, 0.0329, 0.2908, 0.5666, 0.1287, 0.5531, 
         0.4469, 0.1951, 0.5194, 0.1944, 0.2896, 0.7402, 0.5197, 0.729, 0.1406, 0.1117
         ), V36 = c(0.739, 0.9212, 0.5972, 0.5757, 0.5142, 0.0985, 0.1039, 0.2123, 0.7771, 
         0.1428, 0.2897, 0.5307, 0.1041, 0.1348, 0.718, 0.5023, 0.1108, 0.5393, 0.2007, 
         0.2344, 0.6718, 0.105, 0.987, 0.3958, 0.1816, 0.7523, 0.7375, 0.0185, 0.1799, 
         0.1547, 0.0899, 0.5188, 0.1477, 0.5318, 0.4777, 0.4181, 0.4619, 0.1394, 0.4577, 
         0.7761, 0.5071, 0.668, 0.1147, 0.1788), V37 = c(0.7963, 0.9386, 0.5715, 0.5324, 
         0.275, 0.22, 0.2562, 0.2395, 0.8084, 0.1644, 0.2244, 0.2718, 0.1757, 0.2541, 
         0.4801, 0.4441, 0.1594, 0.4897, 0.3356, 0.1058, 0.3446, 0.1915, 0.88, 0.3248, 
         0.1023, 0.8712, 0.7356, 0.1302, 0.3039, 0.1212, 0.2043, 0.506, 0.2062, 0.4826, 
         0.4716, 0.4604, 0.4234, 0.167, 0.3725, 0.3858, 0.4577, 0.5917, 0.1433, 0.2373
         ), V38 = c(0.7493, 0.9303, 0.5242, 0.3672, 0.1358, 0.2243, 0.2624, 0.2673, 0.7426, 
         0.3089, 0.096, 0.1953, 0.3156, 0.2255, 0.5856, 0.4571, 0.1371, 0.4081, 0.4799, 
         0.0383, 0.315, 0.393, 0.6411, 0.2302, 0.2108, 0.9252, 0.7792, 0.248, 0.476, 0.2446, 
         0.1707, 0.3885, 0.24, 0.379, 0.4664, 0.3217, 0.4372, 0.1275, 0.3372, 0.0667, 
         0.3505, 0.4899, 0.182, 0.2843), V39 = c(0.6795, 0.7314, 0.2924, 0.1669, 0.1551, 
         0.2736, 0.2236, 0.2865, 0.6295, 0.3648, 0.2287, 0.1374, 0.3603, 0.1598, 0.4993, 
         0.3927, 0.0696, 0.4145, 0.6147, 0.0528, 0.2702, 0.4288, 0.4276, 0.325, 0.3253, 
         0.9709, 0.6788, 0.1637, 0.5756, 0.3171, 0.0407, 0.3762, 0.5173, 0.1831, 0.3893, 
         0.2828, 0.4277, 0.1666, 0.3803, 0.3684, 0.1845, 0.3439, 0.3605, 0.2241), V40 = c(0.4713, 
         0.4791, 0.1536, 0.0866, 0.2646, 0.2152, 0.118, 0.206, 0.5708, 0.4441, 0.3228, 
         0.3105, 0.2736, 0.1485, 0.2866, 0.29, 0.0452, 0.6003, 0.6246, 0.1291, 0.2598, 
         0.2546, 0.2702, 0.4022, 0.3697, 0.9297, 0.5259, 0.1103, 0.4254, 0.3195, 0.1286, 
         0.3738, 0.5168, 0.175, 0.4255, 0.243, 0.4433, 0.2574, 0.4181, 0.6114, 0.189, 
         0.2366, 0.5529, 0.2715), V41 = c(0.2355, 0.2087, 0.2003, 0.0646, 0.1994, 0.2438, 
         0.1103, 0.1659, 0.4433, 0.3859, 0.3454, 0.379, 0.1301, 0.0845, 0.0601, 0.3408, 
         0.062, 0.7196, 0.4973, 0.2241, 0.2742, 0.1151, 0.2642, 0.4344, 0.2912, 0.8995, 
         0.2762, 0.2144, 0.5046, 0.3051, 0.1581, 0.2605, 0.1491, 0.1679, 0.4064, 0.1979, 
         0.37, 0.2258, 0.3603, 0.351, 0.1967, 0.1716, 0.5988, 0.3363), V42 = c(0.1704, 
         0.2016, 0.2031, 0.1891, 0.1883, 0.3154, 0.2831, 0.2633, 0.3361, 0.2813, 0.3882, 
         0.4105, 0.2458, 0.0569, 0.1167, 0.499, 0.1421, 0.6633, 0.3492, 0.1915, 0.3594, 
         0.2196, 0.3342, 0.4008, 0.301, 0.7911, 0.1545, 0.2033, 0.7179, 0.0836, 0.2191, 
         0.1591, 0.2407, 0.0674, 0.3712, 0.2444, 0.3324, 0.2777, 0.2711, 0.2312, 0.1041, 
         0.1013, 0.5077, 0.2546), V43 = c(0.2728, 0.1669, 0.2207, 0.2683, 0.2746, 0.2112, 
         0.2385, 0.2552, 0.3795, 0.1238, 0.324, 0.3355, 0.3404, 0.0855, 0.2737, 0.3632, 
         0.1597, 0.6287, 0.2662, 0.1587, 0.4382, 0.1879, 0.4335, 0.337, 0.2563, 0.56, 
         0.2019, 0.1887, 0.6163, 0.1266, 0.1701, 0.1875, 0.3415, 0.0609, 0.3863, 0.1847, 
         0.2564, 0.1613, 0.1653, 0.2195, 0.055, 0.0766, 0.5512, 0.1867), V44 = c(0.4016, 
         0.2872, 0.1778, 0.2887, 0.1651, 0.0991, 0.0255, 0.1696, 0.495, 0.0953, 0.0926, 
         0.2998, 0.1753, 0.1262, 0.2812, 0.1387, 0.1384, 0.4087, 0.3137, 0.0942, 0.246, 
         0.1437, 0.4542, 0.2518, 0.1927, 0.2838, 0.2231, 0.137, 0.5663, 0.1381, 0.0971, 
         0.2267, 0.4494, 0.0375, 0.2802, 0.0841, 0.2527, 0.1335, 0.1951, 0.3051, 0.0492, 
         0.0845, 0.5027, 0.216), V45 = c(0.4125, 0.4374, 0.1353, 0.2341, 0.0575, 0.0594, 
         0.1967, 0.1467, 0.4373, 0.1201, 0.1173, 0.2748, 0.0679, 0.1153, 0.2078, 0.18, 
         0.0372, 0.3212, 0.4282, 0.084, 0.0758, 0.2146, 0.396, 0.2101, 0.2062, 0.4407, 
         0.4221, 0.1376, 0.5749, 0.1136, 0.2217, 0.1577, 0.4624, 0.0533, 0.1283, 0.0692, 
         0.2137, 0.1976, 0.2811, 0.1937, 0.0622, 0.026, 0.7034, 0.1278), V46 = c(0.347, 
         0.3097, 0.1373, 0.1668, 0.0695, 0.194, 0.1483, 0.1286, 0.2404, 0.0825, 0.0566, 
         0.2024, 0.1062, 0.057, 0.066, 0.1299, 0.0688, 0.2518, 0.4262, 0.067, 0.0187, 
         0.236, 0.2525, 0.1181, 0.1751, 0.5507, 0.3067, 0.0307, 0.3593, 0.0516, 0.2732, 
         0.1211, 0.2001, 0.0278, 0.1117, 0.0528, 0.1789, 0.1234, 0.2246, 0.157, 0.0505, 
         0.0333, 0.5904, 0.0768), V47 = c(0.2739, 0.1578, 0.0749, 0.1015, 0.0598, 0.1937, 
         0.0434, 0.0926, 0.1128, 0.0618, 0.0766, 0.1043, 0.0643, 0.0426, 0.0491, 0.0523, 
         0.0867, 0.1482, 0.3511, 0.0342, 0.0797, 0.1125, 0.1084, 0.115, 0.0841, 0.4331, 
         0.1329, 0.0373, 0.2526, 0.0073, 0.1874, 0.0883, 0.0775, 0.0179, 0.1303, 0.0357, 
         0.101, 0.1554, 0.1921, 0.0479, 0.0247, 0.0205, 0.4069, 0.107), V48 = c(0.179, 
         0.0553, 0.0472, 0.1195, 0.0456, 0.1082, 0.0627, 0.0716, 0.1654, 0.0141, 0.0969, 
         0.0453, 0.0532, 0.0425, 0.0345, 0.0817, 0.0513, 0.0988, 0.2458, 0.0469, 0.0748, 
         0.0254, 0.0372, 0.055, 0.1035, 0.2905, 0.1349, 0.0606, 0.2299, 0.0278, 0.1062, 
         0.085, 0.1232, 0.0114, 0.0787, 0.0085, 0.0528, 0.1057, 0.15, 0.0538, 0.0219, 
         0.0309, 0.2761, 0.0946), V49 = c(0.0922, 0.0334, 0.0325, 0.0704, 0.0021, 0.0336, 
         0.0513, 0.0325, 0.0933, 0.0108, 0.0588, 0.0337, 0.0531, 0.0235, 0.0172, 0.0469, 
         0.0092, 0.0317, 0.1259, 0.0357, 0.0367, 0.0285, 0.0286, 0.0293, 0.0641, 0.1981, 
         0.1057, 0.0399, 0.1271, 0.0372, 0.0665, 0.0355, 0.0783, 0.0073, 0.0436, 0.023, 
         0.0453, 0.049, 0.0665, 0.0146, 0.0102, 0.0101, 0.1584, 0.0636), V50 = c(0.0276, 
         0.0209, 0.0179, 0.0167, 0.0068, 0.0177, 0.0473, 0.0258, 0.0225, 0.0124, 0.005, 
         0.0122, 0.0272, 6e-04, 0.0287, 0.0114, 0.0198, 0.0269, 0.0327, 0.0136, 0.0155, 
         0.0178, 0.0099, 0.0183, 0.0153, 0.0779, 0.0499, 0.0169, 0.0356, 0.0121, 0.0405, 
         0.0219, 0.0089, 0.0116, 0.0224, 0.0046, 0.0118, 0.0097, 0.0193, 0.0068, 0.0047, 
         0.0095, 0.051, 0.0227), V51 = c(0.0169, 0.0172, 0.0045, 0.0107, 0.0036, 0.0209, 
         0.0248, 0.0136, 0.0214, 0.0104, 0.0118, 0.0072, 0.0171, 0.0188, 0.0027, 0.0299, 
         0.0118, 0.0066, 0.0181, 0.0082, 0.03, 0.0052, 0.0046, 0.0104, 0.0081, 0.0396, 
         0.0206, 0.0135, 0.0367, 0.0153, 0.0113, 0.0086, 0.0249, 0.0092, 0.0133, 0.0156, 
         9e-04, 0.0223, 0.0156, 0.0187, 0.0019, 0.0047, 0.0054, 0.0128), V52 = c(0.0081, 
         0.018, 0.0084, 0.0091, 0.0022, 0.0134, 0.0274, 0.0044, 0.0221, 0.0095, 0.0146, 
         0.0108, 0.0118, 0.0127, 0.0208, 0.0244, 0.009, 8e-04, 0.0217, 0.014, 0.0112, 
         0.0081, 0.0094, 0.0117, 0.0191, 0.0173, 0.0073, 0.0222, 0.0176, 0.0092, 0.0028, 
         0.0123, 0.0204, 0.0078, 0.0078, 0.0031, 0.0142, 0.0121, 0.0362, 0.0059, 0.0041, 
         0.0072, 0.0078, 0.0173), V53 = c(0.004, 0.011, 0.001, 0.0016, 0.0032, 0.0094, 
         0.0205, 0.0028, 0.0152, 0.0151, 0.004, 0.007, 0.0129, 0.0081, 0.0048, 0.0199, 
         0.0223, 0.0045, 0.0038, 0.0044, 0.0112, 0.012, 0.0048, 0.0101, 0.0182, 0.0149, 
         0.0081, 0.0175, 0.0035, 0.0035, 0.0036, 0.006, 0.0059, 0.0041, 0.0174, 0.0054, 
         0.0179, 0.0108, 0.021, 0.0095, 0.0074, 0.0054, 0.0201, 0.0135), V54 = c(0.0025, 
         0.0234, 0.0018, 0.0084, 0.006, 0.0047, 0.0141, 0.0021, 0.0083, 0.0059, 0.0114, 
         0.0063, 0.0344, 0.0067, 0.0199, 0.0257, 0.0179, 0.0024, 0.0019, 0.0052, 0.0102, 
         0.0045, 0.0047, 0.0061, 0.016, 0.0115, 0.0303, 0.0127, 0.0093, 0.0098, 0.0105, 
         0.0187, 0.0053, 0.0013, 0.0176, 0.0105, 0.0079, 0.0057, 0.0154, 0.0194, 0.003, 
         0.0022, 0.0104, 0.0114), V55 = c(0.0036, 0.0276, 0.0068, 0.0064, 0.0054, 0.0045, 
         0.0185, 0.0022, 0.0058, 0.0015, 0.0032, 0.003, 0.0065, 0.0043, 0.0126, 0.0082, 
         0.0084, 6e-04, 0.0065, 0.0073, 0.0026, 0.0121, 0.0016, 0.0031, 0.029, 0.0202, 
         0.019, 0.0022, 0.0121, 0.0121, 0.012, 0.0111, 0.0079, 0.0011, 0.0038, 0.011, 
         0.006, 0.0028, 0.018, 0.008, 0.005, 0.0016, 0.0039, 0.0062), V56 = c(0.0058, 
         0.0032, 0.0039, 0.0026, 0.0063, 0.0042, 0.0055, 0.0048, 0.0023, 0.0053, 0.0062, 
         0.0011, 0.0067, 0.0065, 0.0022, 0.0151, 0.0068, 0.0073, 0.0132, 0.0021, 0.0097, 
         0.0097, 8e-04, 0.0099, 0.009, 0.0139, 0.0212, 0.0124, 0.0075, 6e-04, 0.0087, 
         0.0126, 0.0037, 0.0045, 0.0129, 0.0015, 0.0131, 0.0079, 0.0013, 0.0152, 0.0048, 
         0.0029, 0.0031, 0.0157), V57 = c(0.0067, 0.0084, 0.012, 0.0029, 0.0143, 0.0028, 
         0.0045, 0.0138, 0.0057, 0.0016, 0.0101, 7e-04, 0.0022, 0.0049, 0.0037, 0.0171, 
         0.0032, 0.0096, 0.0108, 0.0047, 0.0098, 0.0085, 0.0042, 0.008, 0.0242, 0.0029, 
         0.0126, 0.0054, 0.0056, 0.0181, 0.0061, 0.0081, 0.0015, 0.0039, 0.0066, 0.0072, 
         0.0089, 0.0034, 0.0106, 0.0158, 0.0017, 0.0058, 0.0062, 0.0088), V58 = c(0.0035, 
         0.0122, 0.0132, 0.0037, 0.0132, 0.0036, 0.0115, 0.014, 0.0052, 0.0042, 0.0068, 
         0.0024, 0.0079, 0.0054, 0.0034, 0.0146, 0.0035, 0.0054, 0.005, 0.0024, 0.0043, 
         0.0047, 0.0024, 0.0107, 0.0224, 0.016, 0.0201, 0.0021, 0.0021, 0.0094, 0.0061, 
         0.0155, 0.0056, 0.0022, 0.0044, 0.0048, 0.0084, 0.0046, 0.0127, 0.0053, 0.0041, 
         0.005, 0.0087, 0.0036), V59 = c(0.0043, 0.0082, 0.007, 0.007, 0.0051, 0.0013, 
         0.0152, 0.0028, 0.0027, 0.0053, 0.0053, 0.0057, 0.0146, 0.0073, 0.0114, 0.0134, 
         0.0056, 0.0085, 0.0085, 9e-04, 0.0071, 0.0048, 0.0027, 0.0161, 0.019, 0.0106, 
         0.021, 0.0028, 0.0043, 0.0116, 0.003, 0.016, 0.0067, 0.0023, 0.0134, 0.0107, 
         0.0113, 0.0022, 0.0178, 0.0189, 0.0086, 0.0024, 0.007, 0.0053), V60 = c(0.0033, 
         0.0143, 0.0088, 0.0041, 0.0041, 0.0016, 0.01, 0.0064, 0.0021, 0.0074, 0.0087, 
         0.0044, 0.0051, 0.0054, 0.0077, 0.0056, 0.004, 0.006, 0.0044, 0.0017, 0.0108, 
         0.0053, 0.0041, 0.0133, 0.0096, 0.0134, 0.0041, 0.0023, 0.0017, 0.0063, 0.0078, 
         0.0085, 0.0054, 0.0016, 0.0092, 0.0094, 0.0049, 0.0021, 0.0231, 0.0102, 0.0058, 
         0.003, 0.0042, 0.003)), .Names = c("V1", "V2", "V3", "V4", "V5", "V6", "V7", 
     "V8", "V9", "V10", "V11", "V12", "V13", "V14", "V15", "V16", "V17", "V18", "V19", 
     "V20", "V21", "V22", "V23", "V24", "V25", "V26", "V27", "V28", "V29", "V30", "V31", 
     "V32", "V33", "V34", "V35", "V36", "V37", "V38", "V39", "V40", "V41", "V42", "V43", 
     "V44", "V45", "V46", "V47", "V48", "V49", "V50", "V51", "V52", "V53", "V54", "V55", 
     "V56", "V57", "V58", "V59", "V60"), class = "data.frame", row.names = c("168", "135", 
     "19", "24", "38", "194", "131", "55", "160", "174", "180", "26", "130", "76", "91", 
     "112", "10", "48", "167", "70", "40", "8", "171", "111", "100", "23", "133", "120", 
     "182", "20", "83", "172", "181", "61", "107", "5", "108", "190", "99", "14", "60", 
     "63", "187", "122")), s = 0.0251183277992532)
  42: predictLearner(.learner, .model, .newdata, ...)
  43: predictLearner.classif.glmnet(.learner, .model, .newdata, ...)
  44: predict(.model$learner.model, newx = .newdata, type = "response", ...)
  45: predict.lognet(.model$learner.model, newx = .newdata, type = "response", ...)
  46: NextMethod("predict")
  47: predict.glmnet(.model$learner.model, newx = .newdata, type = "response", ...)
  48: lambda.interp(lambda, s)
  49: approx(lambda, seq(lambda), sfrac)
  50: stop("need at least two non-NA values to interpolate")
  
  2. Error: MultilabelBinaryRelevanceWrapper with glmnet (@test_base_multilabel.R#60) 
  need at least two non-NA values to interpolate
  1: predict(mod, multilabel.task) at testthat/test_base_multilabel.R:60
  2: predict.WrappedModel(mod, multilabel.task)
  3: measureTime(fun1({
         p = fun2(fun3(do.call(predictLearner2, pars)))
     }))
  4: force(expr)
  5: fun1({
         p = fun2(fun3(do.call(predictLearner2, pars)))
     })
  6: evalVis(expr)
  7: withVisible(eval(expr, pf))
  8: eval(expr, pf)
  9: eval(expr, pf)
  10: fun2(fun3(do.call(predictLearner2, pars)))
  11: fun3(do.call(predictLearner2, pars))
  12: do.call(predictLearner2, pars)
  13: (function (.learner, .model, .newdata, ...) 
     {
         if (.learner$fix.factors.prediction) {
             fls = .model$factor.levels
             ns = names(fls)
             ns = intersect(colnames(.newdata), ns)
             fls = fls[ns]
             if (length(ns) > 0L) 
                 .newdata[ns] = mapply(factor, x = .newdata[ns], levels = fls, SIMPLIFY = FALSE)
         }
         p = predictLearner(.learner, .model, .newdata, ...)
         p = checkPredictLearnerOutput(.learner, .model, p)
         return(p)
     })(.learner = structure(list(id = "multilabel.classif.glmnet", type = "multilabel", 
         package = "glmnet", properties = NULL, par.set = structure(list(pars = structure(list(), .Names = character(0)), 
             forbidden = NULL), .Names = c("pars", "forbidden"), class = "ParamSet"), 
         par.vals = structure(list(), .Names = character(0)), 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 = structure(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"), .Names = c("id", "type", "len", "lower", "upper", 
                 "values", "cnames", "allow.inf", "has.default", "default", "trafo", "requires", 
                 "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", 
                 "values", "cnames", "allow.inf", "has.default", "default", "trafo", "requires", 
                 "tunable", "special.vals", "when"), class = c("LearnerParam", "Param"
                 )), exact = structure(list(id = "exact", type = "logical", len = 1L, 
                     lower = NULL, upper = NULL, values = structure(list(`TRUE` = TRUE, 
                       `FALSE` = FALSE), .Names = c("TRUE", "FALSE")), cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = FALSE, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "predict"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", 
                 "values", "cnames", "allow.inf", "has.default", "default", "trafo", "requires", 
                 "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), class = c("LearnerParam", 
                 "Param")), standardize = structure(list(id = "standardize", type = "logical", 
                     len = 1L, lower = NULL, upper = NULL, values = structure(list(`TRUE` = TRUE, 
                       `FALSE` = FALSE), .Names = c("TRUE", "FALSE")), cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = TRUE, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), class = c("LearnerParam", 
                 "Param")), intercept = structure(list(id = "intercept", type = "logical", 
                     len = 1L, lower = NULL, upper = NULL, values = structure(list(`TRUE` = TRUE, 
                       `FALSE` = FALSE), .Names = c("TRUE", "FALSE")), cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = TRUE, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), class = c("LearnerParam", 
                 "Param")), type.logistic = structure(list(id = "type.logistic", type = "discrete", 
                     len = 1L, lower = NULL, upper = NULL, values = structure(list(Newton = "Newton", 
                       modified.Newton = "modified.Newton"), .Names = c("Newton", "modified.Newton"
                     )), cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, 
                     trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), .Names = c("id", "type", "len", "lower", "upper", 
                 "values", "cnames", "allow.inf", "has.default", "default", "trafo", "requires", 
                 "tunable", "special.vals", "when"), class = c("LearnerParam", "Param"
                 )), type.multinomial = structure(list(id = "type.multinomial", type = "discrete", 
                     len = 1L, lower = NULL, upper = NULL, values = structure(list(ungrouped = "ungrouped", 
                       grouped = "grouped"), .Names = c("ungrouped", "grouped")), cnames = NULL, 
                     allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", 
                 "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), class = c("LearnerParam", 
                 "Param"))), .Names = c("alpha", "s", "exact", "nlambda", "lambda.min.ratio", 
             "lambda", "standardize", "intercept", "thresh", "dfmax", "pmax", "exclude", 
             "penalty.factor", "lower.limits", "upper.limits", "maxit", "type.logistic", 
             "type.multinomial", "fdev", "devmax", "eps", "big", "mnlam", "pmin", "exmx", 
             "prec", "mxit")), forbidden = NULL), .Names = c("pars", "forbidden"), class = c("LearnerParamSet", 
             "ParamSet")), par.vals = structure(list(s = 0.01), .Names = "s"), 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.", 
             config = list(), fix.factors.prediction = FALSE), .Names = c("id", "type", 
         "package", "properties", "par.set", "par.vals", "predict.type", "name", "short.name", 
         "note", "config", "fix.factors.prediction"), class = c("classif.glmnet", "RLearnerClassif", 
         "RLearner", "Learner")), model.subclass = c("MultilabelBinaryRelevanceModel", 
         "HomogeneousEnsembleModel")), .Names = c("id", "type", "package", "properties", 
     "par.set", "par.vals", "predict.type", "fix.factors.prediction", "next.learner", 
     "model.subclass"), class = c("MultilabelBinaryRelevanceWrapper", "HomogeneousEnsemble", 
     "BaseWrapper", "Learner")), .model = structure(list(learner = structure(list(id = "multilabel.classif.glmnet", 
         type = "multilabel", package = "glmnet", properties = NULL, par.set = structure(list(
             pars = structure(list(), .Names = character(0)), forbidden = NULL), .Names = c("pars", 
         "forbidden"), class = "ParamSet"), par.vals = structure(list(), .Names = character(0)), 
         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 = structure(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"), .Names = c("id", "type", 
                 "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", 
                 "values", "cnames", "allow.inf", "has.default", "default", "trafo", "requires", 
                 "tunable", "special.vals", "when"), class = c("LearnerParam", "Param"
                 )), exact = structure(list(id = "exact", type = "logical", len = 1L, 
                     lower = NULL, upper = NULL, values = structure(list(`TRUE` = TRUE, 
                       `FALSE` = FALSE), .Names = c("TRUE", "FALSE")), cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = FALSE, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "predict"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", 
                 "values", "cnames", "allow.inf", "has.default", "default", "trafo", "requires", 
                 "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), class = c("LearnerParam", 
                 "Param")), standardize = structure(list(id = "standardize", type = "logical", 
                     len = 1L, lower = NULL, upper = NULL, values = structure(list(`TRUE` = TRUE, 
                       `FALSE` = FALSE), .Names = c("TRUE", "FALSE")), cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = TRUE, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), class = c("LearnerParam", 
                 "Param")), intercept = structure(list(id = "intercept", type = "logical", 
                     len = 1L, lower = NULL, upper = NULL, values = structure(list(`TRUE` = TRUE, 
                       `FALSE` = FALSE), .Names = c("TRUE", "FALSE")), cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = TRUE, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), class = c("LearnerParam", 
                 "Param")), type.logistic = structure(list(id = "type.logistic", type = "discrete", 
                     len = 1L, lower = NULL, upper = NULL, values = structure(list(Newton = "Newton", 
                       modified.Newton = "modified.Newton"), .Names = c("Newton", "modified.Newton"
                     )), cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, 
                     trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), .Names = c("id", "type", "len", "lower", "upper", 
                 "values", "cnames", "allow.inf", "has.default", "default", "trafo", "requires", 
                 "tunable", "special.vals", "when"), class = c("LearnerParam", "Param"
                 )), type.multinomial = structure(list(id = "type.multinomial", type = "discrete", 
                     len = 1L, lower = NULL, upper = NULL, values = structure(list(ungrouped = "ungrouped", 
                       grouped = "grouped"), .Names = c("ungrouped", "grouped")), cnames = NULL, 
                     allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", 
                 "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), class = c("LearnerParam", 
                 "Param"))), .Names = c("alpha", "s", "exact", "nlambda", "lambda.min.ratio", 
                 "lambda", "standardize", "intercept", "thresh", "dfmax", "pmax", "exclude", 
                 "penalty.factor", "lower.limits", "upper.limits", "maxit", "type.logistic", 
                 "type.multinomial", "fdev", "devmax", "eps", "big", "mnlam", "pmin", 
                 "exmx", "prec", "mxit")), forbidden = NULL), .Names = c("pars", "forbidden"
             ), class = c("LearnerParamSet", "ParamSet")), par.vals = structure(list(s = 0.01), .Names = "s"), 
             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.", 
             config = list(), fix.factors.prediction = FALSE), .Names = c("id", "type", 
         "package", "properties", "par.set", "par.vals", "predict.type", "name", "short.name", 
         "note", "config", "fix.factors.prediction"), class = c("classif.glmnet", "RLearnerClassif", 
         "RLearner", "Learner")), model.subclass = c("MultilabelBinaryRelevanceModel", 
         "HomogeneousEnsembleModel")), .Names = c("id", "type", "package", "properties", 
     "par.set", "par.vals", "predict.type", "fix.factors.prediction", "next.learner", 
     "model.subclass"), class = c("MultilabelBinaryRelevanceWrapper", "HomogeneousEnsemble", 
     "BaseWrapper", "Learner")), learner.model = structure(list(next.model = structure(list(
         y1 = structure(list(learner = structure(list(id = "classif.glmnet", type = "classif", 
             package = "glmnet", properties = c("numerics", "factors", "prob", "twoclass", 
             "multiclass", "weights"), par.set = structure(list(pars = structure(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"), .Names = c("id", "type", "len", "lower", "upper", 
                 "values", "cnames", "allow.inf", "has.default", "default", "trafo", "requires", 
                 "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", 
                 "values", "cnames", "allow.inf", "has.default", "default", "trafo", "requires", 
                 "tunable", "special.vals", "when"), class = c("LearnerParam", "Param"
                 )), exact = structure(list(id = "exact", type = "logical", len = 1L, 
                     lower = NULL, upper = NULL, values = structure(list(`TRUE` = TRUE, 
                       `FALSE` = FALSE), .Names = c("TRUE", "FALSE")), cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = FALSE, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "predict"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", 
                 "values", "cnames", "allow.inf", "has.default", "default", "trafo", "requires", 
                 "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), class = c("LearnerParam", 
                 "Param")), standardize = structure(list(id = "standardize", type = "logical", 
                     len = 1L, lower = NULL, upper = NULL, values = structure(list(`TRUE` = TRUE, 
                       `FALSE` = FALSE), .Names = c("TRUE", "FALSE")), cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = TRUE, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), class = c("LearnerParam", 
                 "Param")), intercept = structure(list(id = "intercept", type = "logical", 
                     len = 1L, lower = NULL, upper = NULL, values = structure(list(`TRUE` = TRUE, 
                       `FALSE` = FALSE), .Names = c("TRUE", "FALSE")), cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = TRUE, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), class = c("LearnerParam", 
                 "Param")), type.logistic = structure(list(id = "type.logistic", type = "discrete", 
                     len = 1L, lower = NULL, upper = NULL, values = structure(list(Newton = "Newton", 
                       modified.Newton = "modified.Newton"), .Names = c("Newton", "modified.Newton"
                     )), cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, 
                     trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), .Names = c("id", "type", "len", "lower", "upper", 
                 "values", "cnames", "allow.inf", "has.default", "default", "trafo", "requires", 
                 "tunable", "special.vals", "when"), class = c("LearnerParam", "Param"
                 )), type.multinomial = structure(list(id = "type.multinomial", type = "discrete", 
                     len = 1L, lower = NULL, upper = NULL, values = structure(list(ungrouped = "ungrouped", 
                       grouped = "grouped"), .Names = c("ungrouped", "grouped")), cnames = NULL, 
                     allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", 
                 "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), class = c("LearnerParam", 
                 "Param"))), .Names = c("alpha", "s", "exact", "nlambda", "lambda.min.ratio", 
             "lambda", "standardize", "intercept", "thresh", "dfmax", "pmax", "exclude", 
             "penalty.factor", "lower.limits", "upper.limits", "maxit", "type.logistic", 
             "type.multinomial", "fdev", "devmax", "eps", "big", "mnlam", "pmin", "exmx", 
             "prec", "mxit")), forbidden = NULL), .Names = c("pars", "forbidden"), class = c("LearnerParamSet", 
             "ParamSet")), par.vals = structure(list(s = 0.01), .Names = "s"), 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.", 
             config = list(), fix.factors.prediction = FALSE), .Names = c("id", "type", 
         "package", "properties", "par.set", "par.vals", "predict.type", "name", "short.name", 
         "note", "config", "fix.factors.prediction"), class = c("classif.glmnet", "RLearnerClassif", 
         "RLearner", "Learner")), learner.model = structure(list(a0 = structure(c(-6.24500451351686e-17, 
         -6.24500451351686e-17, -6.24500451351686e-17, -6.24500451351686e-17, -6.24500451351686e-17
         ), .Names = c("s0", "s1", "s2", "s3", "s4")), beta = <S4 object of class structure("dgCMatrix", package = "Matrix")>, 
             df = c(0, 0, 0, 0, 0), dim = c(7L, 5L), lambda = c(NaN, NaN, NaN, NaN, NaN
             ), dev.ratio = c(0, 0, 0, 0, 0), nulldev = 207.944154167984, npasses = 6L, 
             jerr = 0L, offset = FALSE, classnames = c("FALSE", "TRUE"), call = (function (x, 
                 y, family = c("gaussian", "binomial", "poisson", "multinomial", "cox", 
                     "mgaussian"), weights, offset = NULL, alpha = 1, nlambda = 100, lambda.min.ratio = ifelse(nobs < 
                     nvars, 0.01, 1e-04), lambda = NULL, standardize = TRUE, intercept = TRUE, 
                 thresh = 1e-07, dfmax = nvars + 1, pmax = min(dfmax * 2 + 20, nvars), 
                 exclude, penalty.factor = rep(1, nvars), lower.limits = -Inf, upper.limits = Inf, 
                 maxit = 1e+05, type.gaussian = ifelse(nvars < 500, "covariance", "naive"), 
                 type.logistic = c("Newton", "modified.Newton"), standardize.response = FALSE, 
                 type.multinomial = c("ungrouped", "grouped")) 
             {
                 family = match.arg(family)
                 if (alpha > 1) {
                     warning("alpha >1; set to 1")
                     alpha = 1
                 }
                 if (alpha < 0) {
                     warning("alpha<0; set to 0")
                     alpha = 0
                 }
                 alpha = as.double(alpha)
                 this.call = match.call()
                 nlam = as.integer(nlambda)
                 y = drop(y)
                 np = dim(x)
                 if (is.null(np) | (np[2] <= 1)) 
                     stop("x should be a matrix with 2 or more columns")
                 nobs = as.integer(np[1])
                 if (missing(weights)) 
                     weights = rep(1, nobs)
                 else if (length(weights) != nobs) 
                     stop(paste("number of elements in weights (", length(weights), ") not equal to the number of rows of x (", 
                       nobs, ")", sep = ""))
                 nvars = as.integer(np[2])
                 dimy = dim(y)
                 nrowy = ifelse(is.null(dimy), length(y), dimy[1])
                 if (nrowy != nobs) 
                     stop(paste("number of observations in y (", nrowy, ") not equal to the number of rows of x (", 
                       nobs, ")", sep = ""))
                 vnames = colnames(x)
                 if (is.null(vnames)) 
                     vnames = paste("V", seq(nvars), sep = "")
                 ne = as.integer(dfmax)
                 nx = as.integer(pmax)
                 if (missing(exclude)) 
                     exclude = integer(0)
                 if (any(penalty.factor == Inf)) {
                     exclude = c(exclude, seq(nvars)[penalty.factor == Inf])
                     exclude = sort(unique(exclude))
                 }
                 if (length(exclude) > 0) {
                     jd = match(exclude, seq(nvars), 0)
                     if (!all(jd > 0)) 
                       stop("Some excluded variables out of range")
                     penalty.factor[jd] = 1
                     jd = as.integer(c(length(jd), jd))
                 }
                 else jd = as.integer(0)
                 vp = as.double(penalty.factor)
                 internal.parms = glmnet.control()
                 if (any(lower.limits > 0)) {
                     stop("Lower limits should be non-positive")
                 }
                 if (any(upper.limits < 0)) {
                     stop("Upper limits should be non-negative")
                 }
                 lower.limits[lower.limits == -Inf] = -internal.parms$big
                 upper.limits[upper.limits == Inf] = internal.parms$big
                 if (length(lower.limits) < nvars) {
                     if (length(lower.limits) == 1) 
                       lower.limits = rep(lower.limits, nvars)
                     else stop("Require length 1 or nvars lower.limits")
                 }
                 else lower.limits = lower.limits[seq(nvars)]
                 if (length(upper.limits) < nvars) {
                     if (length(upper.limits) == 1) 
                       upper.limits = rep(upper.limits, nvars)
                     else stop("Require length 1 or nvars upper.limits")
                 }
                 else upper.limits = upper.limits[seq(nvars)]
                 cl = rbind(lower.limits, upper.limits)
                 if (any(cl == 0)) {
                     fdev = glmnet.control()$fdev
                     if (fdev != 0) {
                       glmnet.control(fdev = 0)
                       on.exit(glmnet.control(fdev = fdev))
                     }
                 }
                 storage.mode(cl) = "double"
                 isd = as.integer(standardize)
                 intr = as.integer(intercept)
                 if (!missing(intercept) && family == "cox") 
                     warning("Cox model has no intercept")
                 jsd = as.integer(standardize.response)
                 thresh = as.double(thresh)
                 if (is.null(lambda)) {
                     if (lambda.min.ratio >= 1) 
                       stop("lambda.min.ratio should be less than 1")
                     flmin = as.double(lambda.min.ratio)
                     ulam = double(1)
                 }
                 else {
                     flmin = as.double(1)
                     if (any(lambda < 0)) 
                       stop("lambdas should be non-negative")
                     ulam = as.double(rev(sort(lambda)))
                     nlam = as.integer(length(lambda))
                 }
                 is.sparse = FALSE
                 ix = jx = NULL
                 if (inherits(x, "sparseMatrix")) {
                     is.sparse = TRUE
                     x = as(x, "CsparseMatrix")
                     x = as(x, "dgCMatrix")
                     ix = as.integer(x@p + 1)
                     jx = as.integer(x@i + 1)
                     x = as.double(x@x)
                 }
                 kopt = switch(match.arg(type.logistic), Newton = 0, modified.Newton = 1)
                 if (family == "multinomial") {
                     type.multinomial = match.arg(type.multinomial)
                     if (type.multinomial == "grouped") 
                       kopt = 2
                 }
                 kopt = as.integer(kopt)
                 fit = switch(family, gaussian = elnet(x, is.sparse, ix, jx, y, weights, 
                     offset, type.gaussian, alpha, nobs, nvars, jd, vp, cl, ne, nx, nlam, 
                     flmin, ulam, thresh, isd, intr, vnames, maxit), poisson = fishnet(x, 
                     is.sparse, ix, jx, y, weights, offset, alpha, nobs, nvars, jd, vp, 
                     cl, ne, nx, nlam, flmin, ulam, thresh, isd, intr, vnames, maxit), 
                     binomial = lognet(x, is.sparse, ix, jx, y, weights, offset, alpha, 
                       nobs, nvars, jd, vp, cl, ne, nx, nlam, flmin, ulam, thresh, isd, 
                       intr, vnames, maxit, kopt, family), multinomial = lognet(x, is.sparse, 
                       ix, jx, y, weights, offset, alpha, nobs, nvars, jd, vp, cl, ne, 
                       nx, nlam, flmin, ulam, thresh, isd, intr, vnames, maxit, kopt, 
                       family), cox = coxnet(x, is.sparse, ix, jx, y, weights, offset, 
                       alpha, nobs, nvars, jd, vp, cl, ne, nx, nlam, flmin, ulam, thresh, 
                       isd, vnames, maxit), mgaussian = mrelnet(x, is.sparse, ix, jx, 
                       y, weights, offset, alpha, nobs, nvars, jd, vp, cl, ne, nx, nlam, 
                       flmin, ulam, thresh, isd, jsd, intr, vnames, maxit))
                 if (is.null(lambda)) 
                     fit$lambda = fix.lam(fit$lambda)
                 fit$call = this.call
                 fit$nobs = nobs
                 class(fit) = c(class(fit), "glmnet")
                 fit
             })(x = structure(c(5.1, 4.9, 4.7, 4.6, 5, 5.4, 4.6, 5, 4.4, 4.9, 5.4, 4.8, 
             4.8, 4.3, 5.8, 5.7, 5.4, 5.1, 5.7, 5.1, 5.4, 5.1, 4.6, 5.1, 4.8, 5, 5, 5.2, 
             5.2, 4.7, 4.8, 5.4, 5.2, 5.5, 4.9, 5, 5.5, 4.9, 4.4, 5.1, 5, 4.5, 4.4, 5, 
             5.1, 4.8, 5.1, 4.6, 5.3, 5, 7, 6.4, 6.9, 5.5, 6.5, 5.7, 6.3, 4.9, 6.6, 5.2, 
             5, 5.9, 6, 6.1, 5.6, 6.7, 5.6, 5.8, 6.2, 5.6, 5.9, 6.1, 6.3, 6.1, 6.4, 6.6, 
             6.8, 6.7, 6, 5.7, 5.5, 5.5, 5.8, 6, 5.4, 6, 6.7, 6.3, 5.6, 5.5, 5.5, 6.1, 
             5.8, 5, 5.6, 5.7, 5.7, 6.2, 5.1, 5.7, 6.3, 5.8, 7.1, 6.3, 6.5, 7.6, 4.9, 
             7.3, 6.7, 7.2, 6.5, 6.4, 6.8, 5.7, 5.8, 6.4, 6.5, 7.7, 7.7, 6, 6.9, 5.6, 
             7.7, 6.3, 6.7, 7.2, 6.2, 6.1, 6.4, 7.2, 7.4, 7.9, 6.4, 6.3, 6.1, 7.7, 6.3, 
             6.4, 6, 6.9, 6.7, 6.9, 5.8, 6.8, 6.7, 6.7, 6.3, 6.5, 6.2, 5.9, 3.5, 3, 3.2, 
             3.1, 3.6, 3.9, 3.4, 3.4, 2.9, 3.1, 3.7, 3.4, 3, 3, 4, 4.4, 3.9, 3.5, 3.8, 
             3.8, 3.4, 3.7, 3.6, 3.3, 3.4, 3, 3.4, 3.5, 3.4, 3.2, 3.1, 3.4, 4.1, 4.2, 
             3.1, 3.2, 3.5, 3.6, 3, 3.4, 3.5, 2.3, 3.2, 3.5, 3.8, 3, 3.8, 3.2, 3.7, 3.3, 
             3.2, 3.2, 3.1, 2.3, 2.8, 2.8, 3.3, 2.4, 2.9, 2.7, 2, 3, 2.2, 2.9, 2.9, 3.1, 
             3, 2.7, 2.2, 2.5, 3.2, 2.8, 2.5, 2.8, 2.9, 3, 2.8, 3, 2.9, 2.6, 2.4, 2.4, 
             2.7, 2.7, 3, 3.4, 3.1, 2.3, 3, 2.5, 2.6, 3, 2.6, 2.3, 2.7, 3, 2.9, 2.9, 2.5, 
             2.8, 3.3, 2.7, 3, 2.9, 3, 3, 2.5, 2.9, 2.5, 3.6, 3.2, 2.7, 3, 2.5, 2.8, 3.2, 
             3, 3.8, 2.6, 2.2, 3.2, 2.8, 2.8, 2.7, 3.3, 3.2, 2.8, 3, 2.8, 3, 2.8, 3.8, 
             2.8, 2.8, 2.6, 3, 3.4, 3.1, 3, 3.1, 3.1, 3.1, 2.7, 3.2, 3.3, 3, 2.5, 3, 3.4, 
             3, 1.4, 1.4, 1.3, 1.5, 1.4, 1.7, 1.4, 1.5, 1.4, 1.5, 1.5, 1.6, 1.4, 1.1, 
             1.2, 1.5, 1.3, 1.4, 1.7, 1.5, 1.7, 1.5, 1, 1.7, 1.9, 1.6, 1.6, 1.5, 1.4, 
             1.6, 1.6, 1.5, 1.5, 1.4, 1.5, 1.2, 1.3, 1.4, 1.3, 1.5, 1.3, 1.3, 1.3, 1.6, 
             1.9, 1.4, 1.6, 1.4, 1.5, 1.4, 4.7, 4.5, 4.9, 4, 4.6, 4.5, 4.7, 3.3, 4.6, 
             3.9, 3.5, 4.2, 4, 4.7, 3.6, 4.4, 4.5, 4.1, 4.5, 3.9, 4.8, 4, 4.9, 4.7, 4.3, 
             4.4, 4.8, 5, 4.5, 3.5, 3.8, 3.7, 3.9, 5.1, 4.5, 4.5, 4.7, 4.4, 4.1, 4, 4.4, 
             4.6, 4, 3.3, 4.2, 4.2, 4.2, 4.3, 3, 4.1, 6, 5.1, 5.9, 5.6, 5.8, 6.6, 4.5, 
             6.3, 5.8, 6.1, 5.1, 5.3, 5.5, 5, 5.1, 5.3, 5.5, 6.7, 6.9, 5, 5.7, 4.9, 6.7, 
             4.9, 5.7, 6, 4.8, 4.9, 5.6, 5.8, 6.1, 6.4, 5.6, 5.1, 5.6, 6.1, 5.6, 5.5, 
             4.8, 5.4, 5.6, 5.1, 5.1, 5.9, 5.7, 5.2, 5, 5.2, 5.4, 5.1, 0.2, 0.2, 0.2, 
             0.2, 0.2, 0.4, 0.3, 0.2, 0.2, 0.1, 0.2, 0.2, 0.1, 0.1, 0.2, 0.4, 0.4, 0.3, 
             0.3, 0.3, 0.2, 0.4, 0.2, 0.5, 0.2, 0.2, 0.4, 0.2, 0.2, 0.2, 0.2, 0.4, 0.1, 
             0.2, 0.2, 0.2, 0.2, 0.1, 0.2, 0.2, 0.3, 0.3, 0.2, 0.6, 0.4, 0.3, 0.2, 0.2, 
             0.2, 0.2, 1.4, 1.5, 1.5, 1.3, 1.5, 1.3, 1.6, 1, 1.3, 1.4, 1, 1.5, 1, 1.4, 
             1.3, 1.4, 1.5, 1, 1.5, 1.1, 1.8, 1.3, 1.5, 1.2, 1.3, 1.4, 1.4, 1.7, 1.5, 
             1, 1.1, 1, 1.2, 1.6, 1.5, 1.6, 1.5, 1.3, 1.3, 1.3, 1.2, 1.4, 1.2, 1, 1.3, 
             1.2, 1.3, 1.3, 1.1, 1.3, 2.5, 1.9, 2.1, 1.8, 2.2, 2.1, 1.7, 1.8, 1.8, 2.5, 
             2, 1.9, 2.1, 2, 2.4, 2.3, 1.8, 2.2, 2.3, 1.5, 2.3, 2, 2, 1.8, 2.1, 1.8, 1.8, 
             1.8, 2.1, 1.6, 1.9, 2, 2.2, 1.5, 1.4, 2.3, 2.4, 1.8, 1.8, 2.1, 2.4, 2.3, 
             1.9, 2.3, 2.5, 2.3, 1.9, 2, 2.3, 1.8, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
             1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
             1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
             1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
             1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
             1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
             1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1), .Dim = c(150L, 7L), .Dimnames = list(
                 c("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", 
                 "14", "15", "16", "17", "18", "19", "20", "21", "22", "23", "24", "25", 
                 "26", "27", "28", "29", "30", "31", "32", "33", "34", "35", "36", "37", 
                 "38", "39", "40", "41", "42", "43", "44", "45", "46", "47", "48", "49", 
                 "50", "51", "52", "53", "54", "55", "56", "57", "58", "59", "60", "61", 
                 "62", "63", "64", "65", "66", "67", "68", "69", "70", "71", "72", "73", 
                 "74", "75", "76", "77", "78", "79", "80", "81", "82", "83", "84", "85", 
                 "86", "87", "88", "89", "90", "91", "92", "93", "94", "95", "96", "97", 
                 "98", "99", "100", "101", "102", "103", "104", "105", "106", "107", "108", 
                 "109", "110", "111", "112", "113", "114", "115", "116", "117", "118", 
                 "119", "120", "121", "122", "123", "124", "125", "126", "127", "128", 
                 "129", "130", "131", "132", "133", "134", "135", "136", "137", "138", 
                 "139", "140", "141", "142", "143", "144", "145", "146", "147", "148", 
                 "149", "150"), c("Sepal.Length", "Sepal.Width", "Petal.Length", "Petal.Width", 
                 "Species.setosa", "Species.versicolor", "Species.virginica"))), y = structure(c(2L, 
             1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 
             2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 
             1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 
             2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 
             1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 
             2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 
             1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 
             2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L), .Label = c("FALSE", 
             "TRUE"), class = "factor"), family = "binomial"), nobs = 150L), .Names = c("a0", 
         "beta", "df", "dim", "lambda", "dev.ratio", "nulldev", "npasses", "jerr", "offset", 
         "classnames", "call", "nobs"), class = c("lognet", "glmnet"), mlr.train.info = structure(list(
             factors = structure(list(Species = c("setosa", "versicolor", "virginica")), .Names = "Species"), 
             ordered = structure(list(), .Names = character(0)), restore.levels = FALSE, 
             factors.to.dummies = TRUE, ordered.to.int = FALSE), .Names = c("factors", 
         "ordered", "restore.levels", "factors.to.dummies", "ordered.to.int"), class = "FixDataInfo")), 
             task.desc = structure(list(id = "y1", type = "classif", target = "y1", size = 150L, 
                 n.feat = structure(c(4L, 1L, 0L), .Names = c("numerics", "factors", "ordered"
                 )), has.missings = FALSE, has.weights = FALSE, has.blocking = FALSE, 
                 class.levels = c("FALSE", "TRUE"), positive = "FALSE", negative = "TRUE"), .Names = c("id", 
             "type", "target", "size", "n.feat", "has.missings", "has.weights", "has.blocking", 
             "class.levels", "positive", "negative"), class = c("ClassifTaskDesc", "SupervisedTaskDesc", 
             "TaskDesc")), subset = 1:150, features = c("Sepal.Length", "Sepal.Width", 
             "Petal.Length", "Petal.Width", "Species"), factor.levels = structure(list(
                 Species = c("setosa", "versicolor", "virginica"), y1 = c("FALSE", "TRUE"
                 )), .Names = c("Species", "y1")), time = 0.6099999999999, dump = NULL), .Names = c("learner", 
         "learner.model", "task.desc", "subset", "features", "factor.levels", "time", 
         "dump"), class = "WrappedModel"), y2 = structure(list(learner = structure(list(
             id = "classif.glmnet", type = "classif", package = "glmnet", properties = c("numerics", 
             "factors", "prob", "twoclass", "multiclass", "weights"), par.set = structure(list(
                 pars = structure(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"), .Names = c("id", "type", 
                 "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", 
                 "values", "cnames", "allow.inf", "has.default", "default", "trafo", "requires", 
                 "tunable", "special.vals", "when"), class = c("LearnerParam", "Param"
                 )), exact = structure(list(id = "exact", type = "logical", len = 1L, 
                     lower = NULL, upper = NULL, values = structure(list(`TRUE` = TRUE, 
                       `FALSE` = FALSE), .Names = c("TRUE", "FALSE")), cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = FALSE, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "predict"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", 
                 "values", "cnames", "allow.inf", "has.default", "default", "trafo", "requires", 
                 "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), class = c("LearnerParam", 
                 "Param")), standardize = structure(list(id = "standardize", type = "logical", 
                     len = 1L, lower = NULL, upper = NULL, values = structure(list(`TRUE` = TRUE, 
                       `FALSE` = FALSE), .Names = c("TRUE", "FALSE")), cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = TRUE, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), class = c("LearnerParam", 
                 "Param")), intercept = structure(list(id = "intercept", type = "logical", 
                     len = 1L, lower = NULL, upper = NULL, values = structure(list(`TRUE` = TRUE, 
                       `FALSE` = FALSE), .Names = c("TRUE", "FALSE")), cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = TRUE, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), class = c("LearnerParam", 
                 "Param")), type.logistic = structure(list(id = "type.logistic", type = "discrete", 
                     len = 1L, lower = NULL, upper = NULL, values = structure(list(Newton = "Newton", 
                       modified.Newton = "modified.Newton"), .Names = c("Newton", "modified.Newton"
                     )), cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, 
                     trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), .Names = c("id", "type", "len", "lower", "upper", 
                 "values", "cnames", "allow.inf", "has.default", "default", "trafo", "requires", 
                 "tunable", "special.vals", "when"), class = c("LearnerParam", "Param"
                 )), type.multinomial = structure(list(id = "type.multinomial", type = "discrete", 
                     len = 1L, lower = NULL, upper = NULL, values = structure(list(ungrouped = "ungrouped", 
                       grouped = "grouped"), .Names = c("ungrouped", "grouped")), cnames = NULL, 
                     allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, 
                     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", 
                 "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), class = c("LearnerParam", 
                 "Param"))), .Names = c("alpha", "s", "exact", "nlambda", "lambda.min.ratio", 
                 "lambda", "standardize", "intercept", "thresh", "dfmax", "pmax", "exclude", 
                 "penalty.factor", "lower.limits", "upper.limits", "maxit", "type.logistic", 
                 "type.multinomial", "fdev", "devmax", "eps", "big", "mnlam", "pmin", 
                 "exmx", "prec", "mxit")), forbidden = NULL), .Names = c("pars", "forbidden"
             ), class = c("LearnerParamSet", "ParamSet")), par.vals = structure(list(s = 0.01), .Names = "s"), 
             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.", 
             config = list(), fix.factors.prediction = FALSE), .Names = c("id", "type", 
         "package", "properties", "par.set", "par.vals", "predict.type", "name", "short.name", 
         "note", "config", "fix.factors.prediction"), class = c("classif.glmnet", "RLearnerClassif", 
         "RLearner", "Learner")), learner.model = structure(list(a0 = structure(c(-6.24500451351686e-17, 
         -6.24500451351686e-17, -6.24500451351686e-17, -6.24500451351686e-17, -6.24500451351686e-17
         ), .Names = c("s0", "s1", "s2", "s3", "s4")), beta = <S4 object of class structure("dgCMatrix", package = "Matrix")>, 
             df = c(0, 0, 0, 0, 0), dim = c(7L, 5L), lambda = c(NaN, NaN, NaN, NaN, NaN
             ), dev.ratio = c(0, 0, 0, 0, 0), nulldev = 207.944154167984, npasses = 6L, 
             jerr = 0L, offset = FALSE, classnames = c("FALSE", "TRUE"), call = (function (x, 
                 y, family = c("gaussian", "binomial", "poisson", "multinomial", "cox", 
                     "mgaussian"), weights, offset = NULL, alpha = 1, nlambda = 100, lambda.min.ratio = ifelse(nobs < 
                     nvars, 0.01, 1e-04), lambda = NULL, standardize = TRUE, intercept = TRUE, 
                 thresh = 1e-07, dfmax = nvars + 1, pmax = min(dfmax * 2 + 20, nvars), 
                 exclude, penalty.factor = rep(1, nvars), lower.limits = -Inf, upper.limits = Inf, 
                 maxit = 1e+05, type.gaussian = ifelse(nvars < 500, "covariance", "naive"), 
                 type.logistic = c("Newton", "modified.Newton"), standardize.response = FALSE, 
                 type.multinomial = c("ungrouped", "grouped")) 
             {
                 family = match.arg(family)
                 if (alpha > 1) {
                     warning("alpha >1; set to 1")
                     alpha = 1
                 }
                 if (alpha < 0) {
                     warning("alpha<0; set to 0")
                     alpha = 0
                 }
                 alpha = as.double(alpha)
                 this.call = match.call()
                 nlam = as.integer(nlambda)
                 y = drop(y)
                 np = dim(x)
                 if (is.null(np) | (np[2] <= 1)) 
                     stop("x should be a matrix with 2 or more columns")
                 nobs = as.integer(np[1])
                 if (missing(weights)) 
                     weights = rep(1, nobs)
                 else if (length(weights) != nobs) 
                     stop(paste("number of elements in weights (", length(weights), ") not equal to the number of rows of x (", 
                       nobs, ")", sep = ""))
                 nvars = as.integer(np[2])
                 dimy = dim(y)
                 nrowy = ifelse(is.null(dimy), length(y), dimy[1])
                 if (nrowy != nobs) 
                     stop(paste("number of observations in y (", nrowy, ") not equal to the number of rows of x (", 
                       nobs, ")", sep = ""))
                 vnames = colnames(x)
                 if (is.null(vnames)) 
                     vnames = paste("V", seq(nvars), sep = "")
                 ne = as.integer(dfmax)
                 nx = as.integer(pmax)
                 if (missing(exclude)) 
                     exclude = integer(0)
                 if (any(penalty.factor == Inf)) {
                     exclude = c(exclude, seq(nvars)[penalty.factor == Inf])
                     exclude = sort(unique(exclude))
                 }
                 if (length(exclude) > 0) {
                     jd = match(exclude, seq(nvars), 0)
                     if (!all(jd > 0)) 
                       stop("Some excluded variables out of range")
                     penalty.factor[jd] = 1
                     jd = as.integer(c(length(jd), jd))
                 }
                 else jd = as.integer(0)
                 vp = as.double(penalty.factor)
                 internal.parms = glmnet.control()
                 if (any(lower.limits > 0)) {
                     stop("Lower limits should be non-positive")
                 }
                 if (any(upper.limits < 0)) {
                     stop("Upper limits should be non-negative")
                 }
                 lower.limits[lower.limits == -Inf] = -internal.parms$big
                 upper.limits[upper.limits == Inf] = internal.parms$big
                 if (length(lower.limits) < nvars) {
                     if (length(lower.limits) == 1) 
                       lower.limits = rep(lower.limits, nvars)
                     else stop("Require length 1 or nvars lower.limits")
                 }
                 else lower.limits = lower.limits[seq(nvars)]
                 if (length(upper.limits) < nvars) {
                     if (length(upper.limits) == 1) 
                       upper.limits = rep(upper.limits, nvars)
                     else stop("Require length 1 or nvars upper.limits")
                 }
                 else upper.limits = upper.limits[seq(nvars)]
                 cl = rbind(lower.limits, upper.limits)
                 if (any(cl == 0)) {
                     fdev = glmnet.control()$fdev
                     if (fdev != 0) {
                       glmnet.control(fdev = 0)
                       on.exit(glmnet.control(fdev = fdev))
                     }
                 }
                 storage.mode(cl) = "double"
                 isd = as.integer(standardize)
                 intr = as.integer(intercept)
                 if (!missing(intercept) && family == "cox") 
                     warning("Cox model has no intercept")
                 jsd = as.integer(standardize.response)
                 thresh = as.double(thresh)
                 if (is.null(lambda)) {
                     if (lambda.min.ratio >= 1) 
                       stop("lambda.min.ratio should be less than 1")
                     flmin = as.double(lambda.min.ratio)
                     ulam = double(1)
                 }
                 else {
                     flmin = as.double(1)
                     if (any(lambda < 0)) 
                       stop("lambdas should be non-negative")
                     ulam = as.double(rev(sort(lambda)))
                     nlam = as.integer(length(lambda))
                 }
                 is.sparse = FALSE
                 ix = jx = NULL
                 if (inherits(x, "sparseMatrix")) {
                     is.sparse = TRUE
                     x = as(x, "CsparseMatrix")
                     x = as(x, "dgCMatrix")
                     ix = as.integer(x@p + 1)
                     jx = as.integer(x@i + 1)
                     x = as.double(x@x)
                 }
                 kopt = switch(match.arg(type.logistic), Newton = 0, modified.Newton = 1)
                 if (family == "multinomial") {
                     type.multinomial = match.arg(type.multinomial)
                     if (type.multinomial == "grouped") 
                       kopt = 2
                 }
                 kopt = as.integer(kopt)
                 fit = switch(family, gaussian = elnet(x, is.sparse, ix, jx, y, weights, 
                     offset, type.gaussian, alpha, nobs, nvars, jd, vp, cl, ne, nx, nlam, 
                     flmin, ulam, thresh, isd, intr, vnames, maxit), poisson = fishnet(x, 
                     is.sparse, ix, jx, y, weights, offset, alpha, nobs, nvars, jd, vp, 
                     cl, ne, nx, nlam, flmin, ulam, thresh, isd, intr, vnames, maxit), 
                     binomial = lognet(x, is.sparse, ix, jx, y, weights, offset, alpha, 
                       nobs, nvars, jd, vp, cl, ne, nx, nlam, flmin, ulam, thresh, isd, 
                       intr, vnames, maxit, kopt, family), multinomial = lognet(x, is.sparse, 
                       ix, jx, y, weights, offset, alpha, nobs, nvars, jd, vp, cl, ne, 
                       nx, nlam, flmin, ulam, thresh, isd, intr, vnames, maxit, kopt, 
                       family), cox = coxnet(x, is.sparse, ix, jx, y, weights, offset, 
                       alpha, nobs, nvars, jd, vp, cl, ne, nx, nlam, flmin, ulam, thresh, 
                       isd, vnames, maxit), mgaussian = mrelnet(x, is.sparse, ix, jx, 
                       y, weights, offset, alpha, nobs, nvars, jd, vp, cl, ne, nx, nlam, 
                       flmin, ulam, thresh, isd, jsd, intr, vnames, maxit))
                 if (is.null(lambda)) 
                     fit$lambda = fix.lam(fit$lambda)
                 fit$call = this.call
                 fit$nobs = nobs
                 class(fit) = c(class(fit), "glmnet")
                 fit
             })(x = structure(c(5.1, 4.9, 4.7, 4.6, 5, 5.4, 4.6, 5, 4.4, 4.9, 5.4, 4.8, 
             4.8, 4.3, 5.8, 5.7, 5.4, 5.1, 5.7, 5.1, 5.4, 5.1, 4.6, 5.1, 4.8, 5, 5, 5.2, 
             5.2, 4.7, 4.8, 5.4, 5.2, 5.5, 4.9, 5, 5.5, 4.9, 4.4, 5.1, 5, 4.5, 4.4, 5, 
             5.1, 4.8, 5.1, 4.6, 5.3, 5, 7, 6.4, 6.9, 5.5, 6.5, 5.7, 6.3, 4.9, 6.6, 5.2, 
             5, 5.9, 6, 6.1, 5.6, 6.7, 5.6, 5.8, 6.2, 5.6, 5.9, 6.1, 6.3, 6.1, 6.4, 6.6, 
             6.8, 6.7, 6, 5.7, 5.5, 5.5, 5.8, 6, 5.4, 6, 6.7, 6.3, 5.6, 5.5, 5.5, 6.1, 
             5.8, 5, 5.6, 5.7, 5.7, 6.2, 5.1, 5.7, 6.3, 5.8, 7.1, 6.3, 6.5, 7.6, 4.9, 
             7.3, 6.7, 7.2, 6.5, 6.4, 6.8, 5.7, 5.8, 6.4, 6.5, 7.7, 7.7, 6, 6.9, 5.6, 
             7.7, 6.3, 6.7, 7.2, 6.2, 6.1, 6.4, 7.2, 7.4, 7.9, 6.4, 6.3, 6.1, 7.7, 6.3, 
             6.4, 6, 6.9, 6.7, 6.9, 5.8, 6.8, 6.7, 6.7, 6.3, 6.5, 6.2, 5.9, 3.5, 3, 3.2, 
             3.1, 3.6, 3.9, 3.4, 3.4, 2.9, 3.1, 3.7, 3.4, 3, 3, 4, 4.4, 3.9, 3.5, 3.8, 
             3.8, 3.4, 3.7, 3.6, 3.3, 3.4, 3, 3.4, 3.5, 3.4, 3.2, 3.1, 3.4, 4.1, 4.2, 
             3.1, 3.2, 3.5, 3.6, 3, 3.4, 3.5, 2.3, 3.2, 3.5, 3.8, 3, 3.8, 3.2, 3.7, 3.3, 
             3.2, 3.2, 3.1, 2.3, 2.8, 2.8, 3.3, 2.4, 2.9, 2.7, 2, 3, 2.2, 2.9, 2.9, 3.1, 
             3, 2.7, 2.2, 2.5, 3.2, 2.8, 2.5, 2.8, 2.9, 3, 2.8, 3, 2.9, 2.6, 2.4, 2.4, 
             2.7, 2.7, 3, 3.4, 3.1, 2.3, 3, 2.5, 2.6, 3, 2.6, 2.3, 2.7, 3, 2.9, 2.9, 2.5, 
             2.8, 3.3, 2.7, 3, 2.9, 3, 3, 2.5, 2.9, 2.5, 3.6, 3.2, 2.7, 3, 2.5, 2.8, 3.2, 
             3, 3.8, 2.6, 2.2, 3.2, 2.8, 2.8, 2.7, 3.3, 3.2, 2.8, 3, 2.8, 3, 2.8, 3.8, 
             2.8, 2.8, 2.6, 3, 3.4, 3.1, 3, 3.1, 3.1, 3.1, 2.7, 3.2, 3.3, 3, 2.5, 3, 3.4, 
             3, 1.4, 1.4, 1.3, 1.5, 1.4, 1.7, 1.4, 1.5, 1.4, 1.5, 1.5, 1.6, 1.4, 1.1, 
             1.2, 1.5, 1.3, 1.4, 1.7, 1.5, 1.7, 1.5, 1, 1.7, 1.9, 1.6, 1.6, 1.5, 1.4, 
             1.6, 1.6, 1.5, 1.5, 1.4, 1.5, 1.2, 1.3, 1.4, 1.3, 1.5, 1.3, 1.3, 1.3, 1.6, 
             1.9, 1.4, 1.6, 1.4, 1.5, 1.4, 4.7, 4.5, 4.9, 4, 4.6, 4.5, 4.7, 3.3, 4.6, 
             3.9, 3.5, 4.2, 4, 4.7, 3.6, 4.4, 4.5, 4.1, 4.5, 3.9, 4.8, 4, 4.9, 4.7, 4.3, 
             4.4, 4.8, 5, 4.5, 3.5, 3.8, 3.7, 3.9, 5.1, 4.5, 4.5, 4.7, 4.4, 4.1, 4, 4.4, 
             4.6, 4, 3.3, 4.2, 4.2, 4.2, 4.3, 3, 4.1, 6, 5.1, 5.9, 5.6, 5.8, 6.6, 4.5, 
             6.3, 5.8, 6.1, 5.1, 5.3, 5.5, 5, 5.1, 5.3, 5.5, 6.7, 6.9, 5, 5.7, 4.9, 6.7, 
             4.9, 5.7, 6, 4.8, 4.9, 5.6, 5.8, 6.1, 6.4, 5.6, 5.1, 5.6, 6.1, 5.6, 5.5, 
             4.8, 5.4, 5.6, 5.1, 5.1, 5.9, 5.7, 5.2, 5, 5.2, 5.4, 5.1, 0.2, 0.2, 0.2, 
             0.2, 0.2, 0.4, 0.3, 0.2, 0.2, 0.1, 0.2, 0.2, 0.1, 0.1, 0.2, 0.4, 0.4, 0.3, 
             0.3, 0.3, 0.2, 0.4, 0.2, 0.5, 0.2, 0.2, 0.4, 0.2, 0.2, 0.2, 0.2, 0.4, 0.1, 
             0.2, 0.2, 0.2, 0.2, 0.1, 0.2, 0.2, 0.3, 0.3, 0.2, 0.6, 0.4, 0.3, 0.2, 0.2, 
             0.2, 0.2, 1.4, 1.5, 1.5, 1.3, 1.5, 1.3, 1.6, 1, 1.3, 1.4, 1, 1.5, 1, 1.4, 
             1.3, 1.4, 1.5, 1, 1.5, 1.1, 1.8, 1.3, 1.5, 1.2, 1.3, 1.4, 1.4, 1.7, 1.5, 
             1, 1.1, 1, 1.2, 1.6, 1.5, 1.6, 1.5, 1.3, 1.3, 1.3, 1.2, 1.4, 1.2, 1, 1.3, 
             1.2, 1.3, 1.3, 1.1, 1.3, 2.5, 1.9, 2.1, 1.8, 2.2, 2.1, 1.7, 1.8, 1.8, 2.5, 
             2, 1.9, 2.1, 2, 2.4, 2.3, 1.8, 2.2, 2.3, 1.5, 2.3, 2, 2, 1.8, 2.1, 1.8, 1.8, 
             1.8, 2.1, 1.6, 1.9, 2, 2.2, 1.5, 1.4, 2.3, 2.4, 1.8, 1.8, 2.1, 2.4, 2.3, 
             1.9, 2.3, 2.5, 2.3, 1.9, 2, 2.3, 1.8, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
             1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
             1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
             1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
             1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
             1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
             1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1), .Dim = c(150L, 7L), .Dimnames = list(
                 c("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", 
                 "14", "15", "16", "17", "18", "19", "20", "21", "22", "23", "24", "25", 
                 "26", "27", "28", "29", "30", "31", "32", "33", "34", "35", "36", "37", 
                 "38", "39", "40", "41", "42", "43", "44", "45", "46", "47", "48", "49", 
                 "50", "51", "52", "53", "54", "55", "56", "57", "58", "59", "60", "61", 
                 "62", "63", "64", "65", "66", "67", "68", "69", "70", "71", "72", "73", 
                 "74", "75", "76", "77", "78", "79", "80", "81", "82", "83", "84", "85", 
                 "86", "87", "88", "89", "90", "91", "92", "93", "94", "95", "96", "97", 
                 "98", "99", "100", "101", "102", "103", "104", "105", "106", "107", "108", 
                 "109", "110", "111", "112", "113", "114", "115", "116", "117", "118", 
                 "119", "120", "121", "122", "123", "124", "125", "126", "127", "128", 
                 "129", "130", "131", "132", "133", "134", "135", "136", "137", "138", 
                 "139", "140", "141", "142", "143", "144", "145", "146", "147", "148", 
                 "149", "150"), c("Sepal.Length", "Sepal.Width", "Petal.Length", "Petal.Width", 
                 "Species.setosa", "Species.versicolor", "Species.virginica"))), y = structure(c(1L, 
             2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 
             1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 
             2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 
             1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 
             2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 
             1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 
             2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 
             1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L), .Label = c("FALSE", 
             "TRUE"), class = "factor"), family = "binomial"), nobs = 150L), .Names = c("a0", 
         "beta", "df", "dim", "lambda", "dev.ratio", "nulldev", "npasses", "jerr", "offset", 
         "classnames", "call", "nobs"), class = c("lognet", "glmnet"), mlr.train.info = structure(list(
             factors = structure(list(Species = c("setosa", "versicolor", "virginica")), .Names = "Species"), 
             ordered = structure(list(), .Names = character(0)), restore.levels = FALSE, 
             factors.to.dummies = TRUE, ordered.to.int = FALSE), .Names = c("factors", 
         "ordered", "restore.levels", "factors.to.dummies", "ordered.to.int"), class = "FixDataInfo")), 
             task.desc = structure(list(id = "y2", type = "classif", target = "y2", size = 150L, 
                 n.feat = structure(c(4L, 1L, 0L), .Names = c("numerics", "factors", "ordered"
                 )), has.missings = FALSE, has.weights = FALSE, has.blocking = FALSE, 
                 class.levels = c("FALSE", "TRUE"), positive = "FALSE", negative = "TRUE"), .Names = c("id", 
             "type", "target", "size", "n.feat", "has.missings", "has.weights", "has.blocking", 
             "class.levels", "positive", "negative"), class = c("ClassifTaskDesc", "SupervisedTaskDesc", 
             "TaskDesc")), subset = 1:150, features = c("Sepal.Length", "Sepal.Width", 
             "Petal.Length", "Petal.Width", "Species"), factor.levels = structure(list(
                 Species = c("setosa", "versicolor", "virginica"), y2 = c("FALSE", "TRUE"
                 )), .Names = c("Species", "y2")), time = 0.182999999999993, dump = NULL), .Names = c("learner", 
         "learner.model", "task.desc", "subset", "features", "factor.levels", "time", 
         "dump"), class = "WrappedModel")), .Names = c("y1", "y2"))), .Names = "next.model", class = c("MultilabelBinaryRelevanceModel", 
     "HomogeneousEnsembleModel", "HomogeneousEnsembleModel", "ChainModel", "WrappedModel"
     )), task.desc = structure(list(id = "multilabel", type = "multilabel", target = c("y1", 
     "y2"), size = 150L, n.feat = structure(c(4L, 1L, 0L), .Names = c("numerics", "factors", 
     "ordered")), has.missings = FALSE, has.weights = FALSE, has.blocking = FALSE, class.levels = c("y1", 
     "y2")), .Names = c("id", "type", "target", "size", "n.feat", "has.missings", "has.weights", 
     "has.blocking", "class.levels"), class = c("MultilabelTaskDesc", "SupervisedTaskDesc", 
     "TaskDesc")), subset = 1:150, features = c("Sepal.Length", "Sepal.Width", "Petal.Length", 
     "Petal.Width", "Species"), factor.levels = structure(list(Species = c("setosa", "versicolor", 
     "virginica")), .Names = "Species"), time = 0.846000000000004, dump = NULL), .Names = c("learner", 
     "learner.model", "task.desc", "subset", "features", "factor.levels", "time", "dump"
     ), class = c("MultilabelBinaryRelevanceModel", "HomogeneousEnsembleModel", "BaseWrapperModel", 
     "WrappedModel")), .newdata = structure(list(Sepal.Length = c(5.1, 4.9, 4.7, 4.6, 
     5, 5.4, 4.6, 5, 4.4, 4.9, 5.4, 4.8, 4.8, 4.3, 5.8, 5.7, 5.4, 5.1, 5.7, 5.1, 5.4, 
     5.1, 4.6, 5.1, 4.8, 5, 5, 5.2, 5.2, 4.7, 4.8, 5.4, 5.2, 5.5, 4.9, 5, 5.5, 4.9, 4.4, 
     5.1, 5, 4.5, 4.4, 5, 5.1, 4.8, 5.1, 4.6, 5.3, 5, 7, 6.4, 6.9, 5.5, 6.5, 5.7, 6.3, 
     4.9, 6.6, 5.2, 5, 5.9, 6, 6.1, 5.6, 6.7, 5.6, 5.8, 6.2, 5.6, 5.9, 6.1, 6.3, 6.1, 
     6.4, 6.6, 6.8, 6.7, 6, 5.7, 5.5, 5.5, 5.8, 6, 5.4, 6, 6.7, 6.3, 5.6, 5.5, 5.5, 6.1, 
     5.8, 5, 5.6, 5.7, 5.7, 6.2, 5.1, 5.7, 6.3, 5.8, 7.1, 6.3, 6.5, 7.6, 4.9, 7.3, 6.7, 
     7.2, 6.5, 6.4, 6.8, 5.7, 5.8, 6.4, 6.5, 7.7, 7.7, 6, 6.9, 5.6, 7.7, 6.3, 6.7, 7.2, 
     6.2, 6.1, 6.4, 7.2, 7.4, 7.9, 6.4, 6.3, 6.1, 7.7, 6.3, 6.4, 6, 6.9, 6.7, 6.9, 5.8, 
     6.8, 6.7, 6.7, 6.3, 6.5, 6.2, 5.9), Sepal.Width = c(3.5, 3, 3.2, 3.1, 3.6, 3.9, 3.4, 
     3.4, 2.9, 3.1, 3.7, 3.4, 3, 3, 4, 4.4, 3.9, 3.5, 3.8, 3.8, 3.4, 3.7, 3.6, 3.3, 3.4, 
     3, 3.4, 3.5, 3.4, 3.2, 3.1, 3.4, 4.1, 4.2, 3.1, 3.2, 3.5, 3.6, 3, 3.4, 3.5, 2.3, 
     3.2, 3.5, 3.8, 3, 3.8, 3.2, 3.7, 3.3, 3.2, 3.2, 3.1, 2.3, 2.8, 2.8, 3.3, 2.4, 2.9, 
     2.7, 2, 3, 2.2, 2.9, 2.9, 3.1, 3, 2.7, 2.2, 2.5, 3.2, 2.8, 2.5, 2.8, 2.9, 3, 2.8, 
     3, 2.9, 2.6, 2.4, 2.4, 2.7, 2.7, 3, 3.4, 3.1, 2.3, 3, 2.5, 2.6, 3, 2.6, 2.3, 2.7, 
     3, 2.9, 2.9, 2.5, 2.8, 3.3, 2.7, 3, 2.9, 3, 3, 2.5, 2.9, 2.5, 3.6, 3.2, 2.7, 3, 2.5, 
     2.8, 3.2, 3, 3.8, 2.6, 2.2, 3.2, 2.8, 2.8, 2.7, 3.3, 3.2, 2.8, 3, 2.8, 3, 2.8, 3.8, 
     2.8, 2.8, 2.6, 3, 3.4, 3.1, 3, 3.1, 3.1, 3.1, 2.7, 3.2, 3.3, 3, 2.5, 3, 3.4, 3), 
         Petal.Length = c(1.4, 1.4, 1.3, 1.5, 1.4, 1.7, 1.4, 1.5, 1.4, 1.5, 1.5, 1.6, 
         1.4, 1.1, 1.2, 1.5, 1.3, 1.4, 1.7, 1.5, 1.7, 1.5, 1, 1.7, 1.9, 1.6, 1.6, 1.5, 
         1.4, 1.6, 1.6, 1.5, 1.5, 1.4, 1.5, 1.2, 1.3, 1.4, 1.3, 1.5, 1.3, 1.3, 1.3, 1.6, 
         1.9, 1.4, 1.6, 1.4, 1.5, 1.4, 4.7, 4.5, 4.9, 4, 4.6, 4.5, 4.7, 3.3, 4.6, 3.9, 
         3.5, 4.2, 4, 4.7, 3.6, 4.4, 4.5, 4.1, 4.5, 3.9, 4.8, 4, 4.9, 4.7, 4.3, 4.4, 4.8, 
         5, 4.5, 3.5, 3.8, 3.7, 3.9, 5.1, 4.5, 4.5, 4.7, 4.4, 4.1, 4, 4.4, 4.6, 4, 3.3, 
         4.2, 4.2, 4.2, 4.3, 3, 4.1, 6, 5.1, 5.9, 5.6, 5.8, 6.6, 4.5, 6.3, 5.8, 6.1, 5.1, 
         5.3, 5.5, 5, 5.1, 5.3, 5.5, 6.7, 6.9, 5, 5.7, 4.9, 6.7, 4.9, 5.7, 6, 4.8, 4.9, 
         5.6, 5.8, 6.1, 6.4, 5.6, 5.1, 5.6, 6.1, 5.6, 5.5, 4.8, 5.4, 5.6, 5.1, 5.1, 5.9, 
         5.7, 5.2, 5, 5.2, 5.4, 5.1), Petal.Width = c(0.2, 0.2, 0.2, 0.2, 0.2, 0.4, 0.3, 
         0.2, 0.2, 0.1, 0.2, 0.2, 0.1, 0.1, 0.2, 0.4, 0.4, 0.3, 0.3, 0.3, 0.2, 0.4, 0.2, 
         0.5, 0.2, 0.2, 0.4, 0.2, 0.2, 0.2, 0.2, 0.4, 0.1, 0.2, 0.2, 0.2, 0.2, 0.1, 0.2, 
         0.2, 0.3, 0.3, 0.2, 0.6, 0.4, 0.3, 0.2, 0.2, 0.2, 0.2, 1.4, 1.5, 1.5, 1.3, 1.5, 
         1.3, 1.6, 1, 1.3, 1.4, 1, 1.5, 1, 1.4, 1.3, 1.4, 1.5, 1, 1.5, 1.1, 1.8, 1.3, 
         1.5, 1.2, 1.3, 1.4, 1.4, 1.7, 1.5, 1, 1.1, 1, 1.2, 1.6, 1.5, 1.6, 1.5, 1.3, 1.3, 
         1.3, 1.2, 1.4, 1.2, 1, 1.3, 1.2, 1.3, 1.3, 1.1, 1.3, 2.5, 1.9, 2.1, 1.8, 2.2, 
         2.1, 1.7, 1.8, 1.8, 2.5, 2, 1.9, 2.1, 2, 2.4, 2.3, 1.8, 2.2, 2.3, 1.5, 2.3, 2, 
         2, 1.8, 2.1, 1.8, 1.8, 1.8, 2.1, 1.6, 1.9, 2, 2.2, 1.5, 1.4, 2.3, 2.4, 1.8, 1.8, 
         2.1, 2.4, 2.3, 1.9, 2.3, 2.5, 2.3, 1.9, 2, 2.3, 1.8), Species = structure(c(1L, 
         1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 
         1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 
         1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 
         2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 
         2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 3L, 
         3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 
         3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 
         3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L), .Label = c("setosa", "versicolor", "virginica"
         ), class = "factor")), .Names = c("Sepal.Length", "Sepal.Width", "Petal.Length", 
     "Petal.Width", "Species"), class = "data.frame", row.names = c(NA, 150L)), s = 0.01)
  14: predictLearner(.learner, .model, .newdata, ...)
  15: predictLearner.MultilabelBinaryRelevanceWrapper(.learner, .model, .newdata, ...)
  16: asMatrixCols(lapply(models, f))
  17: assertList(xs)
  18: checkList(x, types, any.missing, all.missing, len, min.len, max.len, unique, names, 
         null.ok)
  19: .Call(c_check_list, x, any.missing, all.missing, len, min.len, max.len, unique, names, 
         null.ok) %and% checkListTypes(x, types)
  20: lapply(models, f)
  21: FUN(X[[i]], ...)
  22: getPredictionResponse(predict(m, newdata = .newdata, subset = .subset, ...))
  23: predict(m, newdata = .newdata, subset = .subset, ...)
  24: predict.WrappedModel(m, newdata = .newdata, subset = .subset, ...)
  25: measureTime(fun1({
         p = fun2(fun3(do.call(predictLearner2, pars)))
     }))
  26: force(expr)
  27: fun1({
         p = fun2(fun3(do.call(predictLearner2, pars)))
     })
  28: evalVis(expr)
  29: withVisible(eval(expr, pf))
  30: eval(expr, pf)
  31: eval(expr, pf)
  32: fun2(fun3(do.call(predictLearner2, pars)))
  33: fun3(do.call(predictLearner2, pars))
  34: do.call(predictLearner2, pars)
  35: (function (.learner, .model, .newdata, ...) 
     {
         if (.learner$fix.factors.prediction) {
             fls = .model$factor.levels
             ns = names(fls)
             ns = intersect(colnames(.newdata), ns)
             fls = fls[ns]
             if (length(ns) > 0L) 
                 .newdata[ns] = mapply(factor, x = .newdata[ns], levels = fls, SIMPLIFY = FALSE)
         }
         p = predictLearner(.learner, .model, .newdata, ...)
         p = checkPredictLearnerOutput(.learner, .model, p)
         return(p)
     })(.learner = structure(list(id = "classif.glmnet", type = "classif", package = "glmnet", 
         properties = c("numerics", "factors", "prob", "twoclass", "multiclass", "weights"
         ), par.set = structure(list(pars = structure(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"), .Names = c("id", 
         "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
         "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
         "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
         "special.vals", "when"), class = c("LearnerParam", "Param")), exact = structure(list(
             id = "exact", type = "logical", len = 1L, lower = NULL, upper = NULL, values = structure(list(
                 `TRUE` = TRUE, `FALSE` = FALSE), .Names = c("TRUE", "FALSE")), cnames = NULL, 
             allow.inf = FALSE, has.default = TRUE, default = FALSE, trafo = NULL, requires = NULL, 
             tunable = TRUE, special.vals = list(), when = "predict"), .Names = c("id", 
         "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
         "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", 
         "upper", "values", "cnames", "allow.inf", "has.default", "default", "trafo", 
         "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", 
         "upper", "values", "cnames", "allow.inf", "has.default", "default", "trafo", 
         "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", 
         "upper", "values", "cnames", "allow.inf", "has.default", "default", "trafo", 
         "requires", "tunable", "special.vals", "when"), class = c("LearnerParam", "Param"
         )), standardize = structure(list(id = "standardize", type = "logical", len = 1L, 
             lower = NULL, upper = NULL, values = structure(list(`TRUE` = TRUE, `FALSE` = FALSE), .Names = c("TRUE", 
             "FALSE")), cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = TRUE, 
             trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), .Names = c("id", 
         "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
         "default", "trafo", "requires", "tunable", "special.vals", "when"), class = c("LearnerParam", 
         "Param")), intercept = structure(list(id = "intercept", type = "logical", len = 1L, 
             lower = NULL, upper = NULL, values = structure(list(`TRUE` = TRUE, `FALSE` = FALSE), .Names = c("TRUE", 
             "FALSE")), cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = TRUE, 
             trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), .Names = c("id", 
         "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
         "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", 
         "upper", "values", "cnames", "allow.inf", "has.default", "default", "trafo", 
         "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
         "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
         "special.vals", "when"), 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"), .Names = c("id", 
         "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
         "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", 
         "upper", "values", "cnames", "allow.inf", "has.default", "default", "trafo", 
         "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", 
         "upper", "values", "cnames", "allow.inf", "has.default", "default", "trafo", 
         "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
         "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
         "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", 
         "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
         "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
         "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
         "special.vals", "when"), class = c("LearnerParam", "Param")), type.logistic = structure(list(
             id = "type.logistic", type = "discrete", len = 1L, lower = NULL, upper = NULL, 
             values = structure(list(Newton = "Newton", modified.Newton = "modified.Newton"), .Names = c("Newton", 
             "modified.Newton")), cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
             default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
             when = "train"), .Names = c("id", "type", "len", "lower", "upper", "values", 
         "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
         "special.vals", "when"), class = c("LearnerParam", "Param")), type.multinomial = structure(list(
             id = "type.multinomial", type = "discrete", len = 1L, lower = NULL, upper = NULL, 
             values = structure(list(ungrouped = "ungrouped", grouped = "grouped"), .Names = c("ungrouped", 
             "grouped")), cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, 
             trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), .Names = c("id", 
         "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
         "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
         "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
         "special.vals", "when"), 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"), .Names = c("id", 
         "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
         "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
         "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
         "special.vals", "when"), 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"), .Names = c("id", 
         "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
         "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
         "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
         "special.vals", "when"), 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"), .Names = c("id", 
         "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
         "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
         "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
         "special.vals", "when"), 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"), .Names = c("id", 
         "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
         "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
         "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
         "special.vals", "when"), class = c("LearnerParam", "Param"))), .Names = c("alpha", 
         "s", "exact", "nlambda", "lambda.min.ratio", "lambda", "standardize", "intercept", 
         "thresh", "dfmax", "pmax", "exclude", "penalty.factor", "lower.limits", "upper.limits", 
         "maxit", "type.logistic", "type.multinomial", "fdev", "devmax", "eps", "big", 
         "mnlam", "pmin", "exmx", "prec", "mxit")), forbidden = NULL), .Names = c("pars", 
         "forbidden"), class = c("LearnerParamSet", "ParamSet")), par.vals = structure(list(
             s = 0.01), .Names = "s"), 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.", 
         config = list(), fix.factors.prediction = FALSE), .Names = c("id", "type", "package", 
     "properties", "par.set", "par.vals", "predict.type", "name", "short.name", "note", 
     "config", "fix.factors.prediction"), class = c("classif.glmnet", "RLearnerClassif", 
     "RLearner", "Learner")), .model = structure(list(learner = structure(list(id = "classif.glmnet", 
         type = "classif", package = "glmnet", properties = c("numerics", "factors", "prob", 
         "twoclass", "multiclass", "weights"), par.set = structure(list(pars = structure(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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", 
             "values", "cnames", "allow.inf", "has.default", "default", "trafo", "requires", 
             "tunable", "special.vals", "when"), class = c("LearnerParam", "Param")), 
             exact = structure(list(id = "exact", type = "logical", len = 1L, lower = NULL, 
                 upper = NULL, values = structure(list(`TRUE` = TRUE, `FALSE` = FALSE), .Names = c("TRUE", 
                 "FALSE")), cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = FALSE, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "predict"), .Names = c("id", "type", "len", "lower", "upper", 
             "values", "cnames", "allow.inf", "has.default", "default", "trafo", "requires", 
             "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), class = c("LearnerParam", "Param")), standardize = structure(list(
                 id = "standardize", type = "logical", len = 1L, lower = NULL, upper = NULL, 
                 values = structure(list(`TRUE` = TRUE, `FALSE` = FALSE), .Names = c("TRUE", 
                 "FALSE")), cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = TRUE, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), class = c("LearnerParam", "Param")), intercept = structure(list(
                 id = "intercept", type = "logical", len = 1L, lower = NULL, upper = NULL, 
                 values = structure(list(`TRUE` = TRUE, `FALSE` = FALSE), .Names = c("TRUE", 
                 "FALSE")), cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = TRUE, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), class = c("LearnerParam", "Param")), type.logistic = structure(list(
                 id = "type.logistic", type = "discrete", len = 1L, lower = NULL, upper = NULL, 
                 values = structure(list(Newton = "Newton", modified.Newton = "modified.Newton"), .Names = c("Newton", 
                 "modified.Newton")), cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                 default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), class = c("LearnerParam", "Param")), type.multinomial = structure(list(
                 id = "type.multinomial", type = "discrete", len = 1L, lower = NULL, upper = NULL, 
                 values = structure(list(ungrouped = "ungrouped", grouped = "grouped"), .Names = c("ungrouped", 
                 "grouped")), cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL, 
                 trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                 when = "train"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), 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"), .Names = c("id", "type", "len", "lower", "upper", "values", 
             "cnames", "allow.inf", "has.default", "default", "trafo", "requires", "tunable", 
             "special.vals", "when"), 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"), .Names = c("id", 
             "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
             "default", "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", 
             "lower", "upper", "values", "cnames", "allow.inf", "has.default", "default", 
             "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", 
             "lower", "upper", "values", "cnames", "allow.inf", "has.default", "default", 
             "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", 
             "lower", "upper", "values", "cnames", "allow.inf", "has.default", "default", 
             "trafo", "requires", "tunable", "special.vals", "when"), 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"), .Names = c("id", "type", "len", 
             "lower", "upper", "values", "cnames", "allow.inf", "has.default", "default", 
             "trafo", "requires", "tunable", "special.vals", "when"), class = c("LearnerParam", 
             "Param"))), .Names = c("alpha", "s", "exact", "nlambda", "lambda.min.ratio", 
         "lambda", "standardize", "intercept", "thresh", "dfmax", "pmax", "exclude", "penalty.factor", 
         "lower.limits", "upper.limits", "maxit", "type.logistic", "type.multinomial", 
         "fdev", "devmax", "eps", "big", "mnlam", "pmin", "exmx", "prec", "mxit")), forbidden = NULL), .Names = c("pars", 
         "forbidden"), class = c("LearnerParamSet", "ParamSet")), par.vals = structure(list(
             s = 0.01), .Names = "s"), 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.", 
         config = list(), fix.factors.prediction = FALSE), .Names = c("id", "type", "package", 
     "properties", "par.set", "par.vals", "predict.type", "name", "short.name", "note", 
     "config", "fix.factors.prediction"), class = c("classif.glmnet", "RLearnerClassif", 
     "RLearner", "Learner")), learner.model = structure(list(a0 = structure(c(-6.24500451351686e-17, 
     -6.24500451351686e-17, -6.24500451351686e-17, -6.24500451351686e-17, -6.24500451351686e-17
     ), .Names = c("s0", "s1", "s2", "s3", "s4")), beta = <S4 object of class structure("dgCMatrix", package = "Matrix")>, 
         df = c(0, 0, 0, 0, 0), dim = c(7L, 5L), lambda = c(NaN, NaN, NaN, NaN, NaN), 
         dev.ratio = c(0, 0, 0, 0, 0), nulldev = 207.944154167984, npasses = 6L, jerr = 0L, 
         offset = FALSE, classnames = c("FALSE", "TRUE"), call = (function (x, y, family = c("gaussian", 
             "binomial", "poisson", "multinomial", "cox", "mgaussian"), weights, offset = NULL, 
             alpha = 1, nlambda = 100, lambda.min.ratio = ifelse(nobs < nvars, 0.01, 1e-04), 
             lambda = NULL, standardize = TRUE, intercept = TRUE, thresh = 1e-07, dfmax = nvars + 
                 1, pmax = min(dfmax * 2 + 20, nvars), exclude, penalty.factor = rep(1, 
                 nvars), lower.limits = -Inf, upper.limits = Inf, maxit = 1e+05, type.gaussian = ifelse(nvars < 
                 500, "covariance", "naive"), type.logistic = c("Newton", "modified.Newton"), 
             standardize.response = FALSE, type.multinomial = c("ungrouped", "grouped")) 
         {
             family = match.arg(family)
             if (alpha > 1) {
                 warning("alpha >1; set to 1")
                 alpha = 1
             }
             if (alpha < 0) {
                 warning("alpha<0; set to 0")
                 alpha = 0
             }
             alpha = as.double(alpha)
             this.call = match.call()
             nlam = as.integer(nlambda)
             y = drop(y)
             np = dim(x)
             if (is.null(np) | (np[2] <= 1)) 
                 stop("x should be a matrix with 2 or more columns")
             nobs = as.integer(np[1])
             if (missing(weights)) 
                 weights = rep(1, nobs)
             else if (length(weights) != nobs) 
                 stop(paste("number of elements in weights (", length(weights), ") not equal to the number of rows of x (", 
                     nobs, ")", sep = ""))
             nvars = as.integer(np[2])
             dimy = dim(y)
             nrowy = ifelse(is.null(dimy), length(y), dimy[1])
             if (nrowy != nobs) 
                 stop(paste("number of observations in y (", nrowy, ") not equal to the number of rows of x (", 
                     nobs, ")", sep = ""))
             vnames = colnames(x)
             if (is.null(vnames)) 
                 vnames = paste("V", seq(nvars), sep = "")
             ne = as.integer(dfmax)
             nx = as.integer(pmax)
             if (missing(exclude)) 
                 exclude = integer(0)
             if (any(penalty.factor == Inf)) {
                 exclude = c(exclude, seq(nvars)[penalty.factor == Inf])
                 exclude = sort(unique(exclude))
             }
             if (length(exclude) > 0) {
                 jd = match(exclude, seq(nvars), 0)
                 if (!all(jd > 0)) 
                     stop("Some excluded variables out of range")
                 penalty.factor[jd] = 1
                 jd = as.integer(c(length(jd), jd))
             }
             else jd = as.integer(0)
             vp = as.double(penalty.factor)
             internal.parms = glmnet.control()
             if (any(lower.limits > 0)) {
                 stop("Lower limits should be non-positive")
             }
             if (any(upper.limits < 0)) {
                 stop("Upper limits should be non-negative")
             }
             lower.limits[lower.limits == -Inf] = -internal.parms$big
             upper.limits[upper.limits == Inf] = internal.parms$big
             if (length(lower.limits) < nvars) {
                 if (length(lower.limits) == 1) 
                     lower.limits = rep(lower.limits, nvars)
                 else stop("Require length 1 or nvars lower.limits")
             }
             else lower.limits = lower.limits[seq(nvars)]
             if (length(upper.limits) < nvars) {
                 if (length(upper.limits) == 1) 
                     upper.limits = rep(upper.limits, nvars)
                 else stop("Require length 1 or nvars upper.limits")
             }
             else upper.limits = upper.limits[seq(nvars)]
             cl = rbind(lower.limits, upper.limits)
             if (any(cl == 0)) {
                 fdev = glmnet.control()$fdev
                 if (fdev != 0) {
                     glmnet.control(fdev = 0)
                     on.exit(glmnet.control(fdev = fdev))
                 }
             }
             storage.mode(cl) = "double"
             isd = as.integer(standardize)
             intr = as.integer(intercept)
             if (!missing(intercept) && family == "cox") 
                 warning("Cox model has no intercept")
             jsd = as.integer(standardize.response)
             thresh = as.double(thresh)
             if (is.null(lambda)) {
                 if (lambda.min.ratio >= 1) 
                     stop("lambda.min.ratio should be less than 1")
                 flmin = as.double(lambda.min.ratio)
                 ulam = double(1)
             }
             else {
                 flmin = as.double(1)
                 if (any(lambda < 0)) 
                     stop("lambdas should be non-negative")
                 ulam = as.double(rev(sort(lambda)))
                 nlam = as.integer(length(lambda))
             }
             is.sparse = FALSE
             ix = jx = NULL
             if (inherits(x, "sparseMatrix")) {
                 is.sparse = TRUE
                 x = as(x, "CsparseMatrix")
                 x = as(x, "dgCMatrix")
                 ix = as.integer(x@p + 1)
                 jx = as.integer(x@i + 1)
                 x = as.double(x@x)
             }
             kopt = switch(match.arg(type.logistic), Newton = 0, modified.Newton = 1)
             if (family == "multinomial") {
                 type.multinomial = match.arg(type.multinomial)
                 if (type.multinomial == "grouped") 
                     kopt = 2
             }
             kopt = as.integer(kopt)
             fit = switch(family, gaussian = elnet(x, is.sparse, ix, jx, y, weights, offset, 
                 type.gaussian, alpha, nobs, nvars, jd, vp, cl, ne, nx, nlam, flmin, ulam, 
                 thresh, isd, intr, vnames, maxit), poisson = fishnet(x, is.sparse, ix, 
                 jx, y, weights, offset, alpha, nobs, nvars, jd, vp, cl, ne, nx, nlam, 
                 flmin, ulam, thresh, isd, intr, vnames, maxit), binomial = lognet(x, 
                 is.sparse, ix, jx, y, weights, offset, alpha, nobs, nvars, jd, vp, cl, 
                 ne, nx, nlam, flmin, ulam, thresh, isd, intr, vnames, maxit, kopt, family), 
                 multinomial = lognet(x, is.sparse, ix, jx, y, weights, offset, alpha, 
                     nobs, nvars, jd, vp, cl, ne, nx, nlam, flmin, ulam, thresh, isd, 
                     intr, vnames, maxit, kopt, family), cox = coxnet(x, is.sparse, ix, 
                     jx, y, weights, offset, alpha, nobs, nvars, jd, vp, cl, ne, nx, nlam, 
                     flmin, ulam, thresh, isd, vnames, maxit), mgaussian = mrelnet(x, 
                     is.sparse, ix, jx, y, weights, offset, alpha, nobs, nvars, jd, vp, 
                     cl, ne, nx, nlam, flmin, ulam, thresh, isd, jsd, intr, vnames, maxit))
             if (is.null(lambda)) 
                 fit$lambda = fix.lam(fit$lambda)
             fit$call = this.call
             fit$nobs = nobs
             class(fit) = c(class(fit), "glmnet")
             fit
         })(x = structure(c(5.1, 4.9, 4.7, 4.6, 5, 5.4, 4.6, 5, 4.4, 4.9, 5.4, 4.8, 4.8, 
         4.3, 5.8, 5.7, 5.4, 5.1, 5.7, 5.1, 5.4, 5.1, 4.6, 5.1, 4.8, 5, 5, 5.2, 5.2, 4.7, 
         4.8, 5.4, 5.2, 5.5, 4.9, 5, 5.5, 4.9, 4.4, 5.1, 5, 4.5, 4.4, 5, 5.1, 4.8, 5.1, 
         4.6, 5.3, 5, 7, 6.4, 6.9, 5.5, 6.5, 5.7, 6.3, 4.9, 6.6, 5.2, 5, 5.9, 6, 6.1, 
         5.6, 6.7, 5.6, 5.8, 6.2, 5.6, 5.9, 6.1, 6.3, 6.1, 6.4, 6.6, 6.8, 6.7, 6, 5.7, 
         5.5, 5.5, 5.8, 6, 5.4, 6, 6.7, 6.3, 5.6, 5.5, 5.5, 6.1, 5.8, 5, 5.6, 5.7, 5.7, 
         6.2, 5.1, 5.7, 6.3, 5.8, 7.1, 6.3, 6.5, 7.6, 4.9, 7.3, 6.7, 7.2, 6.5, 6.4, 6.8, 
         5.7, 5.8, 6.4, 6.5, 7.7, 7.7, 6, 6.9, 5.6, 7.7, 6.3, 6.7, 7.2, 6.2, 6.1, 6.4, 
         7.2, 7.4, 7.9, 6.4, 6.3, 6.1, 7.7, 6.3, 6.4, 6, 6.9, 6.7, 6.9, 5.8, 6.8, 6.7, 
         6.7, 6.3, 6.5, 6.2, 5.9, 3.5, 3, 3.2, 3.1, 3.6, 3.9, 3.4, 3.4, 2.9, 3.1, 3.7, 
         3.4, 3, 3, 4, 4.4, 3.9, 3.5, 3.8, 3.8, 3.4, 3.7, 3.6, 3.3, 3.4, 3, 3.4, 3.5, 
         3.4, 3.2, 3.1, 3.4, 4.1, 4.2, 3.1, 3.2, 3.5, 3.6, 3, 3.4, 3.5, 2.3, 3.2, 3.5, 
         3.8, 3, 3.8, 3.2, 3.7, 3.3, 3.2, 3.2, 3.1, 2.3, 2.8, 2.8, 3.3, 2.4, 2.9, 2.7, 
         2, 3, 2.2, 2.9, 2.9, 3.1, 3, 2.7, 2.2, 2.5, 3.2, 2.8, 2.5, 2.8, 2.9, 3, 2.8, 
         3, 2.9, 2.6, 2.4, 2.4, 2.7, 2.7, 3, 3.4, 3.1, 2.3, 3, 2.5, 2.6, 3, 2.6, 2.3, 
         2.7, 3, 2.9, 2.9, 2.5, 2.8, 3.3, 2.7, 3, 2.9, 3, 3, 2.5, 2.9, 2.5, 3.6, 3.2, 
         2.7, 3, 2.5, 2.8, 3.2, 3, 3.8, 2.6, 2.2, 3.2, 2.8, 2.8, 2.7, 3.3, 3.2, 2.8, 3, 
         2.8, 3, 2.8, 3.8, 2.8, 2.8, 2.6, 3, 3.4, 3.1, 3, 3.1, 3.1, 3.1, 2.7, 3.2, 3.3, 
         3, 2.5, 3, 3.4, 3, 1.4, 1.4, 1.3, 1.5, 1.4, 1.7, 1.4, 1.5, 1.4, 1.5, 1.5, 1.6, 
         1.4, 1.1, 1.2, 1.5, 1.3, 1.4, 1.7, 1.5, 1.7, 1.5, 1, 1.7, 1.9, 1.6, 1.6, 1.5, 
         1.4, 1.6, 1.6, 1.5, 1.5, 1.4, 1.5, 1.2, 1.3, 1.4, 1.3, 1.5, 1.3, 1.3, 1.3, 1.6, 
         1.9, 1.4, 1.6, 1.4, 1.5, 1.4, 4.7, 4.5, 4.9, 4, 4.6, 4.5, 4.7, 3.3, 4.6, 3.9, 
         3.5, 4.2, 4, 4.7, 3.6, 4.4, 4.5, 4.1, 4.5, 3.9, 4.8, 4, 4.9, 4.7, 4.3, 4.4, 4.8, 
         5, 4.5, 3.5, 3.8, 3.7, 3.9, 5.1, 4.5, 4.5, 4.7, 4.4, 4.1, 4, 4.4, 4.6, 4, 3.3, 
         4.2, 4.2, 4.2, 4.3, 3, 4.1, 6, 5.1, 5.9, 5.6, 5.8, 6.6, 4.5, 6.3, 5.8, 6.1, 5.1, 
         5.3, 5.5, 5, 5.1, 5.3, 5.5, 6.7, 6.9, 5, 5.7, 4.9, 6.7, 4.9, 5.7, 6, 4.8, 4.9, 
         5.6, 5.8, 6.1, 6.4, 5.6, 5.1, 5.6, 6.1, 5.6, 5.5, 4.8, 5.4, 5.6, 5.1, 5.1, 5.9, 
         5.7, 5.2, 5, 5.2, 5.4, 5.1, 0.2, 0.2, 0.2, 0.2, 0.2, 0.4, 0.3, 0.2, 0.2, 0.1, 
         0.2, 0.2, 0.1, 0.1, 0.2, 0.4, 0.4, 0.3, 0.3, 0.3, 0.2, 0.4, 0.2, 0.5, 0.2, 0.2, 
         0.4, 0.2, 0.2, 0.2, 0.2, 0.4, 0.1, 0.2, 0.2, 0.2, 0.2, 0.1, 0.2, 0.2, 0.3, 0.3, 
         0.2, 0.6, 0.4, 0.3, 0.2, 0.2, 0.2, 0.2, 1.4, 1.5, 1.5, 1.3, 1.5, 1.3, 1.6, 1, 
         1.3, 1.4, 1, 1.5, 1, 1.4, 1.3, 1.4, 1.5, 1, 1.5, 1.1, 1.8, 1.3, 1.5, 1.2, 1.3, 
         1.4, 1.4, 1.7, 1.5, 1, 1.1, 1, 1.2, 1.6, 1.5, 1.6, 1.5, 1.3, 1.3, 1.3, 1.2, 1.4, 
         1.2, 1, 1.3, 1.2, 1.3, 1.3, 1.1, 1.3, 2.5, 1.9, 2.1, 1.8, 2.2, 2.1, 1.7, 1.8, 
         1.8, 2.5, 2, 1.9, 2.1, 2, 2.4, 2.3, 1.8, 2.2, 2.3, 1.5, 2.3, 2, 2, 1.8, 2.1, 
         1.8, 1.8, 1.8, 2.1, 1.6, 1.9, 2, 2.2, 1.5, 1.4, 2.3, 2.4, 1.8, 1.8, 2.1, 2.4, 
         2.3, 1.9, 2.3, 2.5, 2.3, 1.9, 2, 2.3, 1.8, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
         0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
         1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 
         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1), .Dim = c(150L, 
         7L), .Dimnames = list(c("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", 
         "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23", "24", 
         "25", "26", "27", "28", "29", "30", "31", "32", "33", "34", "35", "36", "37", 
         "38", "39", "40", "41", "42", "43", "44", "45", "46", "47", "48", "49", "50", 
         "51", "52", "53", "54", "55", "56", "57", "58", "59", "60", "61", "62", "63", 
         "64", "65", "66", "67", "68", "69", "70", "71", "72", "73", "74", "75", "76", 
         "77", "78", "79", "80", "81", "82", "83", "84", "85", "86", "87", "88", "89", 
         "90", "91", "92", "93", "94", "95", "96", "97", "98", "99", "100", "101", "102", 
         "103", "104", "105", "106", "107", "108", "109", "110", "111", "112", "113", 
         "114", "115", "116", "117", "118", "119", "120", "121", "122", "123", "124", 
         "125", "126", "127", "128", "129", "130", "131", "132", "133", "134", "135", 
         "136", "137", "138", "139", "140", "141", "142", "143", "144", "145", "146", 
         "147", "148", "149", "150"), c("Sepal.Length", "Sepal.Width", "Petal.Length", 
         "Petal.Width", "Species.setosa", "Species.versicolor", "Species.virginica"))), 
             y = structure(c(2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 
             1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 
             2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 
             1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 
             2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 
             1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 
             2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 
             1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 2L, 1L, 
             2L, 1L), .Label = c("FALSE", "TRUE"), class = "factor"), family = "binomial"), 
         nobs = 150L), .Names = c("a0", "beta", "df", "dim", "lambda", "dev.ratio", "nulldev", 
     "npasses", "jerr", "offset", "classnames", "call", "nobs"), class = c("lognet", "glmnet"
     ), mlr.train.info = structure(list(factors = structure(list(Species = c("setosa", 
     "versicolor", "virginica")), .Names = "Species"), ordered = structure(list(), .Names = character(0)), 
         restore.levels = FALSE, factors.to.dummies = TRUE, ordered.to.int = FALSE), .Names = c("factors", 
     "ordered", "restore.levels", "factors.to.dummies", "ordered.to.int"), class = "FixDataInfo")), 
         task.desc = structure(list(id = "y1", type = "classif", target = "y1", size = 150L, 
             n.feat = structure(c(4L, 1L, 0L), .Names = c("numerics", "factors", "ordered"
             )), has.missings = FALSE, has.weights = FALSE, has.blocking = FALSE, class.levels = c("FALSE", 
             "TRUE"), positive = "FALSE", negative = "TRUE"), .Names = c("id", "type", 
         "target", "size", "n.feat", "has.missings", "has.weights", "has.blocking", "class.levels", 
         "positive", "negative"), class = c("ClassifTaskDesc", "SupervisedTaskDesc", "TaskDesc"
         )), subset = 1:150, features = c("Sepal.Length", "Sepal.Width", "Petal.Length", 
         "Petal.Width", "Species"), factor.levels = structure(list(Species = c("setosa", 
         "versicolor", "virginica"), y1 = c("FALSE", "TRUE")), .Names = c("Species", "y1"
         )), time = 0.6099999999999, dump = NULL), .Names = c("learner", "learner.model", 
     "task.desc", "subset", "features", "factor.levels", "time", "dump"), class = "WrappedModel"), 
         .newdata = structure(list(Sepal.Length = c(5.1, 4.9, 4.7, 4.6, 5, 5.4, 4.6, 5, 
         4.4, 4.9, 5.4, 4.8, 4.8, 4.3, 5.8, 5.7, 5.4, 5.1, 5.7, 5.1, 5.4, 5.1, 4.6, 5.1, 
         4.8, 5, 5, 5.2, 5.2, 4.7, 4.8, 5.4, 5.2, 5.5, 4.9, 5, 5.5, 4.9, 4.4, 5.1, 5, 
         4.5, 4.4, 5, 5.1, 4.8, 5.1, 4.6, 5.3, 5, 7, 6.4, 6.9, 5.5, 6.5, 5.7, 6.3, 4.9, 
         6.6, 5.2, 5, 5.9, 6, 6.1, 5.6, 6.7, 5.6, 5.8, 6.2, 5.6, 5.9, 6.1, 6.3, 6.1, 6.4, 
         6.6, 6.8, 6.7, 6, 5.7, 5.5, 5.5, 5.8, 6, 5.4, 6, 6.7, 6.3, 5.6, 5.5, 5.5, 6.1, 
         5.8, 5, 5.6, 5.7, 5.7, 6.2, 5.1, 5.7, 6.3, 5.8, 7.1, 6.3, 6.5, 7.6, 4.9, 7.3, 
         6.7, 7.2, 6.5, 6.4, 6.8, 5.7, 5.8, 6.4, 6.5, 7.7, 7.7, 6, 6.9, 5.6, 7.7, 6.3, 
         6.7, 7.2, 6.2, 6.1, 6.4, 7.2, 7.4, 7.9, 6.4, 6.3, 6.1, 7.7, 6.3, 6.4, 6, 6.9, 
         6.7, 6.9, 5.8, 6.8, 6.7, 6.7, 6.3, 6.5, 6.2, 5.9), Sepal.Width = c(3.5, 3, 3.2, 
         3.1, 3.6, 3.9, 3.4, 3.4, 2.9, 3.1, 3.7, 3.4, 3, 3, 4, 4.4, 3.9, 3.5, 3.8, 3.8, 
         3.4, 3.7, 3.6, 3.3, 3.4, 3, 3.4, 3.5, 3.4, 3.2, 3.1, 3.4, 4.1, 4.2, 3.1, 3.2, 
         3.5, 3.6, 3, 3.4, 3.5, 2.3, 3.2, 3.5, 3.8, 3, 3.8, 3.2, 3.7, 3.3, 3.2, 3.2, 3.1, 
         2.3, 2.8, 2.8, 3.3, 2.4, 2.9, 2.7, 2, 3, 2.2, 2.9, 2.9, 3.1, 3, 2.7, 2.2, 2.5, 
         3.2, 2.8, 2.5, 2.8, 2.9, 3, 2.8, 3, 2.9, 2.6, 2.4, 2.4, 2.7, 2.7, 3, 3.4, 3.1, 
         2.3, 3, 2.5, 2.6, 3, 2.6, 2.3, 2.7, 3, 2.9, 2.9, 2.5, 2.8, 3.3, 2.7, 3, 2.9, 
         3, 3, 2.5, 2.9, 2.5, 3.6, 3.2, 2.7, 3, 2.5, 2.8, 3.2, 3, 3.8, 2.6, 2.2, 3.2, 
         2.8, 2.8, 2.7, 3.3, 3.2, 2.8, 3, 2.8, 3, 2.8, 3.8, 2.8, 2.8, 2.6, 3, 3.4, 3.1, 
         3, 3.1, 3.1, 3.1, 2.7, 3.2, 3.3, 3, 2.5, 3, 3.4, 3), Petal.Length = c(1.4, 1.4, 
         1.3, 1.5, 1.4, 1.7, 1.4, 1.5, 1.4, 1.5, 1.5, 1.6, 1.4, 1.1, 1.2, 1.5, 1.3, 1.4, 
         1.7, 1.5, 1.7, 1.5, 1, 1.7, 1.9, 1.6, 1.6, 1.5, 1.4, 1.6, 1.6, 1.5, 1.5, 1.4, 
         1.5, 1.2, 1.3, 1.4, 1.3, 1.5, 1.3, 1.3, 1.3, 1.6, 1.9, 1.4, 1.6, 1.4, 1.5, 1.4, 
         4.7, 4.5, 4.9, 4, 4.6, 4.5, 4.7, 3.3, 4.6, 3.9, 3.5, 4.2, 4, 4.7, 3.6, 4.4, 4.5, 
         4.1, 4.5, 3.9, 4.8, 4, 4.9, 4.7, 4.3, 4.4, 4.8, 5, 4.5, 3.5, 3.8, 3.7, 3.9, 5.1, 
         4.5, 4.5, 4.7, 4.4, 4.1, 4, 4.4, 4.6, 4, 3.3, 4.2, 4.2, 4.2, 4.3, 3, 4.1, 6, 
         5.1, 5.9, 5.6, 5.8, 6.6, 4.5, 6.3, 5.8, 6.1, 5.1, 5.3, 5.5, 5, 5.1, 5.3, 5.5, 
         6.7, 6.9, 5, 5.7, 4.9, 6.7, 4.9, 5.7, 6, 4.8, 4.9, 5.6, 5.8, 6.1, 6.4, 5.6, 5.1, 
         5.6, 6.1, 5.6, 5.5, 4.8, 5.4, 5.6, 5.1, 5.1, 5.9, 5.7, 5.2, 5, 5.2, 5.4, 5.1), 
             Petal.Width = c(0.2, 0.2, 0.2, 0.2, 0.2, 0.4, 0.3, 0.2, 0.2, 0.1, 0.2, 0.2, 
             0.1, 0.1, 0.2, 0.4, 0.4, 0.3, 0.3, 0.3, 0.2, 0.4, 0.2, 0.5, 0.2, 0.2, 0.4, 
             0.2, 0.2, 0.2, 0.2, 0.4, 0.1, 0.2, 0.2, 0.2, 0.2, 0.1, 0.2, 0.2, 0.3, 0.3, 
             0.2, 0.6, 0.4, 0.3, 0.2, 0.2, 0.2, 0.2, 1.4, 1.5, 1.5, 1.3, 1.5, 1.3, 1.6, 
             1, 1.3, 1.4, 1, 1.5, 1, 1.4, 1.3, 1.4, 1.5, 1, 1.5, 1.1, 1.8, 1.3, 1.5, 1.2, 
             1.3, 1.4, 1.4, 1.7, 1.5, 1, 1.1, 1, 1.2, 1.6, 1.5, 1.6, 1.5, 1.3, 1.3, 1.3, 
             1.2, 1.4, 1.2, 1, 1.3, 1.2, 1.3, 1.3, 1.1, 1.3, 2.5, 1.9, 2.1, 1.8, 2.2, 
             2.1, 1.7, 1.8, 1.8, 2.5, 2, 1.9, 2.1, 2, 2.4, 2.3, 1.8, 2.2, 2.3, 1.5, 2.3, 
             2, 2, 1.8, 2.1, 1.8, 1.8, 1.8, 2.1, 1.6, 1.9, 2, 2.2, 1.5, 1.4, 2.3, 2.4, 
             1.8, 1.8, 2.1, 2.4, 2.3, 1.9, 2.3, 2.5, 2.3, 1.9, 2, 2.3, 1.8), Species = structure(c(1L, 
             1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 
             1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 
             1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 
             2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 
             2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 
             2L, 2L, 2L, 2L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 
             3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 
             3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L), .Label = c("setosa", 
             "versicolor", "virginica"), class = "factor")), .Names = c("Sepal.Length", 
         "Sepal.Width", "Petal.Length", "Petal.Width", "Species"), row.names = c(NA, 150L
         ), class = "data.frame"), s = 0.01)
  36: predictLearner(.learner, .model, .newdata, ...)
  37: predictLearner.classif.glmnet(.learner, .model, .newdata, ...)
  38: predict(.model$learner.model, newx = .newdata, type = "class", ...)
  39: predict.lognet(.model$learner.model, newx = .newdata, type = "class", ...)
  40: NextMethod("predict")
  41: predict.glmnet(.model$learner.model, newx = .newdata, type = "class", ...)
  42: lambda.interp(lambda, s)
  43: approx(lambda, seq(lambda), sfrac)
  44: stop("need at least two non-NA values to interpolate")
  
  testthat results ================================================================
  OK: 2712 SKIPPED: 2 FAILED: 2
  1. Error: TuneWrapper passed predict hyper pars correctly to base learner (@test_base_TuneWrapper.R#51) 
  2. Error: MultilabelBinaryRelevanceWrapper with glmnet (@test_base_multilabel.R#60) 
  
  Error: testthat unit tests failed
  Execution halted