CRAN Package Check Results for Package liquidSVM

Last updated on 2019-04-20 05:49:30 CEST.

Flavor Version Tinstall Tcheck Ttotal Status Flags
r-devel-linux-x86_64-debian-clang 1.2.2.1 55.19 67.75 122.94 OK
r-devel-linux-x86_64-debian-gcc 1.2.2.1 48.18 64.36 112.54 OK
r-devel-linux-x86_64-fedora-clang 1.2.2.1 162.97 NOTE
r-devel-linux-x86_64-fedora-gcc 1.2.2.1 148.96 OK
r-devel-windows-ix86+x86_64 1.2.2.1 121.00 99.00 220.00 NOTE --no-vignettes
r-patched-linux-x86_64 1.2.2.1 50.83 69.09 119.92 OK
r-patched-solaris-x86 1.2.2.1 255.80 NOTE
r-release-linux-x86_64 1.2.2.1 52.15 63.28 115.43 ERROR
r-release-windows-ix86+x86_64 1.2.2.1 94.00 131.00 225.00 NOTE --no-vignettes
r-release-osx-x86_64 1.2.2.1 NOTE
r-oldrel-windows-ix86+x86_64 1.2.2.1 92.00 128.00 220.00 NOTE --no-vignettes
r-oldrel-osx-x86_64 1.2.2.1 NOTE

Check Details

Version: 1.2.2.1
Check: installed package size
Result: NOTE
     installed size is 11.5Mb
     sub-directories of 1Mb or more:
     doc 2.2Mb
     libs 8.7Mb
Flavors: r-devel-linux-x86_64-fedora-clang, r-patched-solaris-x86, r-release-osx-x86_64, r-oldrel-osx-x86_64

Version: 1.2.2.1
Flags: --no-vignettes
Check: whether package can be installed
Result: NOTE
    Found the following notes/warnings:
     Non-staged installation was used
Flavor: r-devel-windows-ix86+x86_64

Version: 1.2.2.1
Flags: --no-vignettes
Check: installed package size
Result: NOTE
     installed size is 5.8Mb
     sub-directories of 1Mb or more:
     doc 2.2Mb
     libs 3.0Mb
Flavors: r-devel-windows-ix86+x86_64, r-release-windows-ix86+x86_64, r-oldrel-windows-ix86+x86_64

Version: 1.2.2.1
Check: tests
Result: ERROR
     Running ‘testthat.R’ [13s/14s]
    Running the tests in ‘tests/testthat.R’ failed.
    Complete output:
     > # Copyright 2015-2017 Philipp Thomann
     > #
     > # This file is part of liquidSVM.
     > #
     > # liquidSVM is free software: you can redistribute it and/or modify
     > # it under the terms of the GNU Affero General Public License as
     > # published by the Free Software Foundation, either version 3 of the
     > # License, or (at your option) any later version.
     > #
     > # liquidSVM is distributed in the hope that it will be useful,
     > # but WITHOUT ANY WARRANTY; without even the implied warranty of
     > # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
     > # GNU Affero General Public License for more details.
     > #
     > # You should have received a copy of the GNU Affero General Public License
     > # along with liquidSVM. If not, see <http://www.gnu.org/licenses/>.
     >
     > library(testthat)
     > library(liquidSVM)
     >
     > orig <- options(liquidSVM.warn.suboptimal=FALSE, liquidSVM.default.threads=1)
     >
     > test_check("liquidSVM")
     ── 1. Error: mlr-regr (@test-mlr.R#37) ────────────────────────────────────────
     no applicable method for 'trainLearner' applied to an object of class "c('regr.liquidSVM', 'RLearnerRegr', 'RLearner', 'Learner')"
     1: train(lrn, task) at testthat/test-mlr.R:37
     2: measureTime(fun1({
     learner.model = fun2(fun3(do.call(trainLearner, pars)))
     }))
     3: force(expr)
     4: fun1({
     learner.model = fun2(fun3(do.call(trainLearner, pars)))
     })
     5: fun2(fun3(do.call(trainLearner, pars)))
     6: fun3(do.call(trainLearner, pars))
     7: do.call(trainLearner, pars)
     8: (function (.learner, .task, .subset, .weights = NULL, ...)
     {
     UseMethod("trainLearner")
     })(.learner = structure(list(id = "regr.liquidSVM", type = "regr", package = "liquidSVM",
     properties = c("numerics", "factors"), par.set = structure(list(pars = list(scale = structure(list(
     id = "scale", type = "logical", len = 1L, lower = NULL, upper = NULL, values = list(
     `TRUE` = TRUE, `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, has.default = TRUE,
     default = TRUE, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(),
     when = "train"), class = c("LearnerParam", "Param")), kernel = structure(list(
     id = "kernel", type = "discrete", len = 1L, lower = NULL, upper = NULL, values = list(
     gauss_rbf = "gauss_rbf", poisson = "poisson"), cnames = NULL, allow.inf = FALSE,
     has.default = TRUE, default = "gauss_rbf", trafo = NULL, requires = NULL,
     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam",
     "Param")), partition_choice = structure(list(id = "partition_choice", type = "integer",
     len = 1L, lower = 0, upper = 6, values = NULL, cnames = NULL, allow.inf = FALSE,
     has.default = TRUE, default = 0, trafo = NULL, requires = NULL, tunable = TRUE,
     special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
     )), partition_param = structure(list(id = "partition_param", type = "numeric",
     len = 1L, lower = -Inf, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE,
     has.default = TRUE, default = -1, trafo = NULL, requires = partition_choice >=
     1L, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam",
     "Param")), grid_choice = structure(list(id = "grid_choice", type = "integer",
     len = 1L, lower = -2, upper = 2, values = NULL, cnames = NULL, allow.inf = FALSE,
     has.default = TRUE, default = 0, trafo = NULL, requires = NULL, tunable = TRUE,
     special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
     )), folds = structure(list(id = "folds", type = "integer", len = 1L, lower = 1,
     upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE,
     default = 5, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(),
     when = "train"), class = c("LearnerParam", "Param")), min_gamma = structure(list(
     id = "min_gamma", 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 = "train"), class = c("LearnerParam",
     "Param")), max_gamma = structure(list(id = "max_gamma", type = "numeric", len = 1L,
     lower = 0, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE,
     has.default = FALSE, default = NULL, trafo = NULL, requires = min_gamma <=
     max_gamma, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam",
     "Param")), gamma_steps = structure(list(id = "gamma_steps", type = "integer",
     len = 1L, lower = 0, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE,
     has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, tunable = TRUE,
     special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
     )), min_lambda = structure(list(id = "min_lambda", 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 = "train"), class = c("LearnerParam", "Param"
     )), max_lambda = structure(list(id = "max_lambda", type = "numeric", len = 1L,
     lower = 0, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE,
     has.default = FALSE, default = NULL, trafo = NULL, requires = min_lambda <=
     max_lambda, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam",
     "Param")), lambda_steps = structure(list(id = "lambda_steps", type = "integer",
     len = 1L, lower = 0, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE,
     has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, tunable = TRUE,
     special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
     )), retrain_method = structure(list(id = "retrain_method", type = "discrete",
     len = 1L, lower = NULL, upper = NULL, values = list(select_on_entire_train_Set = "select_on_entire_train_Set",
     select_on_each_fold = "select_on_each_fold"), cnames = NULL, allow.inf = FALSE,
     has.default = TRUE, default = "select_on_each_fold", trafo = NULL, requires = NULL,
     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam",
     "Param")), store_solutions_internally = structure(list(id = "store_solutions_internally",
     type = "logical", len = 1L, lower = NULL, upper = NULL, values = list(`TRUE` = TRUE,
     `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, has.default = TRUE,
     default = TRUE, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(),
     when = "train"), class = c("LearnerParam", "Param")), display = structure(list(
     id = "display", type = "integer", len = 1L, lower = 0, upper = 7, values = NULL,
     cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 0, trafo = NULL,
     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam",
     "Param")), threads = structure(list(id = "threads", type = "integer", len = 1L,
     lower = -1, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE,
     has.default = TRUE, default = 1, trafo = NULL, requires = NULL, tunable = TRUE,
     special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
     )), clip = structure(list(id = "clip", type = "numeric", len = 1L, lower = -1,
     upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE,
     default = -1, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(),
     when = "train"), class = c("LearnerParam", "Param"))), forbidden = NULL), class = c("LearnerParamSet",
     "ParamSet")), par.vals = list(display = 0), predict.type = "response", name = "Support Vector Machines",
     short.name = "liquidSVM", note = "FIXME make integrated cross-validation more accessible.",
     callees = character(0), help.list = list(), config = list(), fix.factors.prediction = FALSE), class = c("regr.liquidSVM",
     "RLearnerRegr", "RLearner", "Learner")), .task = structure(list(type = "regr", env = <environment>,
     weights = NULL, blocking = NULL, coordinates = NULL, task.desc = structure(list(
     id = "trees", type = "regr", target = "Volume", size = 31L, n.feat = c(numerics = 2L,
     factors = 0L, ordered = 0L, functionals = 0L), has.missings = FALSE, has.weights = FALSE,
     has.blocking = FALSE, has.coordinates = FALSE), class = c("RegrTaskDesc",
     "SupervisedTaskDesc", "TaskDesc"))), class = c("RegrTask", "SupervisedTask",
     "Task")), .subset = NULL, display = 0)
    
     ── 2. Error: mlr-class (@test-mlr.R#52) ───────────────────────────────────────
     no applicable method for 'trainLearner' applied to an object of class "c('classif.liquidSVM', 'RLearnerClassif', 'RLearner', 'Learner')"
     1: train(lrn, task) at testthat/test-mlr.R:52
     2: measureTime(fun1({
     learner.model = fun2(fun3(do.call(trainLearner, pars)))
     }))
     3: force(expr)
     4: fun1({
     learner.model = fun2(fun3(do.call(trainLearner, pars)))
     })
     5: fun2(fun3(do.call(trainLearner, pars)))
     6: fun3(do.call(trainLearner, pars))
     7: do.call(trainLearner, pars)
     8: (function (.learner, .task, .subset, .weights = NULL, ...)
     {
     UseMethod("trainLearner")
     })(.learner = structure(list(id = "classif.liquidSVM", type = "classif", package = "liquidSVM",
     properties = c("twoclass", "multiclass", "numerics", "factors", "prob", "class.weights"
     ), par.set = structure(list(pars = list(scale = structure(list(id = "scale",
     type = "logical", len = 1L, lower = NULL, upper = NULL, values = list(`TRUE` = TRUE,
     `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, has.default = TRUE,
     default = TRUE, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(),
     when = "train"), class = c("LearnerParam", "Param")), kernel = structure(list(
     id = "kernel", type = "discrete", len = 1L, lower = NULL, upper = NULL, values = list(
     gauss_rbf = "gauss_rbf", poisson = "poisson"), cnames = NULL, allow.inf = FALSE,
     has.default = TRUE, default = "gauss_rbf", trafo = NULL, requires = NULL,
     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam",
     "Param")), partition_choice = structure(list(id = "partition_choice", type = "integer",
     len = 1L, lower = 0, upper = 6, values = NULL, cnames = NULL, allow.inf = FALSE,
     has.default = TRUE, default = 0, trafo = NULL, requires = NULL, tunable = TRUE,
     special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
     )), partition_param = structure(list(id = "partition_param", type = "numeric",
     len = 1L, lower = -Inf, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE,
     has.default = TRUE, default = -1, trafo = NULL, requires = partition_choice >=
     1L, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam",
     "Param")), grid_choice = structure(list(id = "grid_choice", type = "integer",
     len = 1L, lower = -2, upper = 2, values = NULL, cnames = NULL, allow.inf = FALSE,
     has.default = TRUE, default = 0, trafo = NULL, requires = NULL, tunable = TRUE,
     special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
     )), folds = structure(list(id = "folds", type = "integer", len = 1L, lower = 1,
     upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE,
     default = 5, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(),
     when = "train"), class = c("LearnerParam", "Param")), min_gamma = structure(list(
     id = "min_gamma", 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 = "train"), class = c("LearnerParam",
     "Param")), max_gamma = structure(list(id = "max_gamma", type = "numeric", len = 1L,
     lower = 0, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE,
     has.default = FALSE, default = NULL, trafo = NULL, requires = min_gamma <=
     max_gamma, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam",
     "Param")), gamma_steps = structure(list(id = "gamma_steps", type = "integer",
     len = 1L, lower = 0, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE,
     has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, tunable = TRUE,
     special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
     )), min_lambda = structure(list(id = "min_lambda", 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 = "train"), class = c("LearnerParam", "Param"
     )), max_lambda = structure(list(id = "max_lambda", type = "numeric", len = 1L,
     lower = 0, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE,
     has.default = FALSE, default = NULL, trafo = NULL, requires = min_lambda <=
     max_lambda, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam",
     "Param")), lambda_steps = structure(list(id = "lambda_steps", type = "integer",
     len = 1L, lower = 0, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE,
     has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, tunable = TRUE,
     special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
     )), retrain_method = structure(list(id = "retrain_method", type = "discrete",
     len = 1L, lower = NULL, upper = NULL, values = list(select_on_entire_train_Set = "select_on_entire_train_Set",
     select_on_each_fold = "select_on_each_fold"), cnames = NULL, allow.inf = FALSE,
     has.default = TRUE, default = "select_on_each_fold", trafo = NULL, requires = NULL,
     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam",
     "Param")), store_solutions_internally = structure(list(id = "store_solutions_internally",
     type = "logical", len = 1L, lower = NULL, upper = NULL, values = list(`TRUE` = TRUE,
     `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, has.default = TRUE,
     default = TRUE, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(),
     when = "train"), class = c("LearnerParam", "Param")), display = structure(list(
     id = "display", type = "integer", len = 1L, lower = 0, upper = 7, values = NULL,
     cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 0, trafo = NULL,
     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam",
     "Param")), threads = structure(list(id = "threads", type = "integer", len = 1L,
     lower = -1, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE,
     has.default = TRUE, default = 1, trafo = NULL, requires = NULL, tunable = TRUE,
     special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
     )), mc_type = structure(list(id = "mc_type", type = "discrete", len = 1L, lower = NULL,
     upper = NULL, values = list(AvA_hinge = "AvA_hinge", OvA_ls = "OvA_ls", OvA_hinge = "OvA_hinge",
     AvA_ls = "AvA_ls"), cnames = NULL, allow.inf = FALSE, has.default = TRUE,
     default = "AvA_hinge", trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(),
     when = "train"), class = c("LearnerParam", "Param")), weights = structure(list(
     id = "weights", type = "numericvector", len = NA_integer_, lower = 0, upper = Inf,
     values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL,
     trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam",
     "Param"))), forbidden = NULL), class = c("LearnerParamSet", "ParamSet")), par.vals = list(
     display = 0), predict.type = "response", name = "Support Vector Machines",
     short.name = "liquidSVM", note = "FIXME make integrated cross-validation more accessible.",
     callees = character(0), help.list = list(), class.weights.param = "weights",
     config = list(), fix.factors.prediction = FALSE), class = c("classif.liquidSVM",
     "RLearnerClassif", "RLearner", "Learner")), .task = structure(list(type = "classif",
     env = <environment>, weights = NULL, blocking = NULL, coordinates = NULL, task.desc = structure(list(
     id = "iris", type = "classif", target = "Species", size = 150L, n.feat = c(numerics = 4L,
     factors = 0L, ordered = 0L, functionals = 0L), has.missings = FALSE, has.weights = FALSE,
     has.blocking = FALSE, has.coordinates = FALSE, class.levels = c("setosa",
     "versicolor", "virginica"), positive = NA_character_, negative = NA_character_,
     class.distribution = structure(c(setosa = 50L, versicolor = 50L, virginica = 50L
     ), .Dim = 3L, .Dimnames = structure(list(c("setosa", "versicolor", "virginica"
     )), .Names = ""), class = "table")), class = c("ClassifTaskDesc", "SupervisedTaskDesc",
     "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", "Task")), .subset = NULL,
     display = 0)
    
     ── 3. Error: mlr-class-prob (@test-mlr.R#67) ──────────────────────────────────
     no applicable method for 'trainLearner' applied to an object of class "c('classif.liquidSVM', 'RLearnerClassif', 'RLearner', 'Learner')"
     1: train(lrn, task) at testthat/test-mlr.R:67
     2: measureTime(fun1({
     learner.model = fun2(fun3(do.call(trainLearner, pars)))
     }))
     3: force(expr)
     4: fun1({
     learner.model = fun2(fun3(do.call(trainLearner, pars)))
     })
     5: fun2(fun3(do.call(trainLearner, pars)))
     6: fun3(do.call(trainLearner, pars))
     7: do.call(trainLearner, pars)
     8: (function (.learner, .task, .subset, .weights = NULL, ...)
     {
     UseMethod("trainLearner")
     })(.learner = structure(list(id = "classif.liquidSVM", type = "classif", package = "liquidSVM",
     properties = c("twoclass", "multiclass", "numerics", "factors", "prob", "class.weights"
     ), par.set = structure(list(pars = list(scale = structure(list(id = "scale",
     type = "logical", len = 1L, lower = NULL, upper = NULL, values = list(`TRUE` = TRUE,
     `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, has.default = TRUE,
     default = TRUE, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(),
     when = "train"), class = c("LearnerParam", "Param")), kernel = structure(list(
     id = "kernel", type = "discrete", len = 1L, lower = NULL, upper = NULL, values = list(
     gauss_rbf = "gauss_rbf", poisson = "poisson"), cnames = NULL, allow.inf = FALSE,
     has.default = TRUE, default = "gauss_rbf", trafo = NULL, requires = NULL,
     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam",
     "Param")), partition_choice = structure(list(id = "partition_choice", type = "integer",
     len = 1L, lower = 0, upper = 6, values = NULL, cnames = NULL, allow.inf = FALSE,
     has.default = TRUE, default = 0, trafo = NULL, requires = NULL, tunable = TRUE,
     special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
     )), partition_param = structure(list(id = "partition_param", type = "numeric",
     len = 1L, lower = -Inf, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE,
     has.default = TRUE, default = -1, trafo = NULL, requires = partition_choice >=
     1L, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam",
     "Param")), grid_choice = structure(list(id = "grid_choice", type = "integer",
     len = 1L, lower = -2, upper = 2, values = NULL, cnames = NULL, allow.inf = FALSE,
     has.default = TRUE, default = 0, trafo = NULL, requires = NULL, tunable = TRUE,
     special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
     )), folds = structure(list(id = "folds", type = "integer", len = 1L, lower = 1,
     upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = TRUE,
     default = 5, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(),
     when = "train"), class = c("LearnerParam", "Param")), min_gamma = structure(list(
     id = "min_gamma", 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 = "train"), class = c("LearnerParam",
     "Param")), max_gamma = structure(list(id = "max_gamma", type = "numeric", len = 1L,
     lower = 0, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE,
     has.default = FALSE, default = NULL, trafo = NULL, requires = min_gamma <=
     max_gamma, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam",
     "Param")), gamma_steps = structure(list(id = "gamma_steps", type = "integer",
     len = 1L, lower = 0, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE,
     has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, tunable = TRUE,
     special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
     )), min_lambda = structure(list(id = "min_lambda", 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 = "train"), class = c("LearnerParam", "Param"
     )), max_lambda = structure(list(id = "max_lambda", type = "numeric", len = 1L,
     lower = 0, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE,
     has.default = FALSE, default = NULL, trafo = NULL, requires = min_lambda <=
     max_lambda, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam",
     "Param")), lambda_steps = structure(list(id = "lambda_steps", type = "integer",
     len = 1L, lower = 0, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE,
     has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, tunable = TRUE,
     special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
     )), retrain_method = structure(list(id = "retrain_method", type = "discrete",
     len = 1L, lower = NULL, upper = NULL, values = list(select_on_entire_train_Set = "select_on_entire_train_Set",
     select_on_each_fold = "select_on_each_fold"), cnames = NULL, allow.inf = FALSE,
     has.default = TRUE, default = "select_on_each_fold", trafo = NULL, requires = NULL,
     tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam",
     "Param")), store_solutions_internally = structure(list(id = "store_solutions_internally",
     type = "logical", len = 1L, lower = NULL, upper = NULL, values = list(`TRUE` = TRUE,
     `FALSE` = FALSE), cnames = NULL, allow.inf = FALSE, has.default = TRUE,
     default = TRUE, trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(),
     when = "train"), class = c("LearnerParam", "Param")), display = structure(list(
     id = "display", type = "integer", len = 1L, lower = 0, upper = 7, values = NULL,
     cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = 0, trafo = NULL,
     requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam",
     "Param")), threads = structure(list(id = "threads", type = "integer", len = 1L,
     lower = -1, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE,
     has.default = TRUE, default = 1, trafo = NULL, requires = NULL, tunable = TRUE,
     special.vals = list(), when = "train"), class = c("LearnerParam", "Param"
     )), mc_type = structure(list(id = "mc_type", type = "discrete", len = 1L, lower = NULL,
     upper = NULL, values = list(AvA_hinge = "AvA_hinge", OvA_ls = "OvA_ls", OvA_hinge = "OvA_hinge",
     AvA_ls = "AvA_ls"), cnames = NULL, allow.inf = FALSE, has.default = TRUE,
     default = "AvA_hinge", trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(),
     when = "train"), class = c("LearnerParam", "Param")), weights = structure(list(
     id = "weights", type = "numericvector", len = NA_integer_, lower = 0, upper = Inf,
     values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, default = NULL,
     trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), class = c("LearnerParam",
     "Param"))), forbidden = NULL), class = c("LearnerParamSet", "ParamSet")), par.vals = list(
     display = 0), predict.type = "prob", name = "Support Vector Machines", short.name = "liquidSVM",
     note = "FIXME make integrated cross-validation more accessible.", callees = character(0),
     help.list = list(), class.weights.param = "weights", config = list(), fix.factors.prediction = FALSE), class = c("classif.liquidSVM",
     "RLearnerClassif", "RLearner", "Learner")), .task = structure(list(type = "classif",
     env = <environment>, weights = NULL, blocking = NULL, coordinates = NULL, task.desc = structure(list(
     id = "iris", type = "classif", target = "Species", size = 150L, n.feat = c(numerics = 4L,
     factors = 0L, ordered = 0L, functionals = 0L), has.missings = FALSE, has.weights = FALSE,
     has.blocking = FALSE, has.coordinates = FALSE, class.levels = c("setosa",
     "versicolor", "virginica"), positive = NA_character_, negative = NA_character_,
     class.distribution = structure(c(setosa = 50L, versicolor = 50L, virginica = 50L
     ), .Dim = 3L, .Dimnames = structure(list(c("setosa", "versicolor", "virginica"
     )), .Names = ""), class = "table")), class = c("ClassifTaskDesc", "SupervisedTaskDesc",
     "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", "Task")), .subset = NULL,
     display = 0)
    
     ══ testthat results ═══════════════════════════════════════════════════════════
     OK: 130 SKIPPED: 10 FAILED: 3
     1. Error: mlr-regr (@test-mlr.R#37)
     2. Error: mlr-class (@test-mlr.R#52)
     3. Error: mlr-class-prob (@test-mlr.R#67)
    
     Error: testthat unit tests failed
     Execution halted
Flavor: r-release-linux-x86_64