Merge branch 'master' into ppl_bagging_with_replacement

Author: mb706

.github/workflows/dev-cmd-check.yml

@@ -0,0 +1,45 @@
+# dev cmd check workflow of the mlr3 ecosystem v0.1.0
+# https://github.com/mlr-org/actions
+on:
+  workflow_dispatch:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+name: dev-check
+
+jobs:
+  check-package:
+    runs-on: ${{ matrix.config.os }}
+
+    name: ${{ matrix.config.dev-package }}
+
+    env:
+      GITHUB_PAT: ${{ secrets.GITHUB_TOKEN }}
+
+    strategy:
+      fail-fast: false
+      matrix:
+        config:
+          - {os: ubuntu-latest, r: 'release', dev-package: "mlr-org/bbotk', 'mlr-org/mlr3learners', 'mlr-org/paradox"}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - uses: r-lib/actions/setup-r@v2
+        with:
+          r-version: ${{ matrix.config.r }}
+
+      - uses: r-lib/actions/setup-r-dependencies@v2
+        with:
+          extra-packages: any::rcmdcheck
+          needs: check
+
+      - name: Install dev versions
+        run: pak::pkg_install(c('${{ matrix.config.dev-package }}'))
+        shell: Rscript {0}
+
+      - uses: r-lib/actions/check-r-package@v2

NEWS.md

@@ -1,6 +1,12 @@
 # mlr3pipelines 0.5.0-9000
 
 * `pipeline_bagging()` gets the `replace` argument.
+* Compatibility with upcoming paradox release
+
+# mlr3pipelines 0.5.0-2
+
+* Avoid unnecessarily large serializations of `ppl("robustify")` pipelines.
+* Made tests and examples compatible with mlr3 update.
 
 # mlr3pipelines 0.5.0-1
 

R/LearnerAvg.R

@@ -58,12 +58,12 @@
 LearnerClassifAvg = R6Class("LearnerClassifAvg", inherit = LearnerClassif,
   public = list(
     initialize = function(id = "classif.avg") {
-      ps = ParamSet$new(params = list(
-        ParamUty$new("measure", custom_check = check_class_or_character("MeasureClassif", mlr_measures), tags = "train"),
-        ParamUty$new("optimizer", custom_check = check_optimizer, tags = "train"),
-        ParamUty$new("log_level", tags = "train",
+      ps = ps(
+        measure = p_uty(custom_check = check_class_or_character("MeasureClassif", mlr_measures), tags = "train"),
+        optimizer = p_uty(custom_check = check_optimizer, tags = "train"),
+        log_level = p_uty(tags = "train",
           function(x) check_string(x) %check||% check_integerish(x))
-      ))
+      )
       ps$values = list(measure = "classif.ce", optimizer = "nloptr", log_level = "warn")
       super$initialize(
         id = id,
@@ -132,12 +132,12 @@ LearnerClassifAvg = R6Class("LearnerClassifAvg", inherit = LearnerClassif,
 LearnerRegrAvg = R6Class("LearnerRegrAvg", inherit = LearnerRegr,
   public = list(
     initialize = function(id = "regr.avg") {
-      ps = ParamSet$new(params = list(
-        ParamUty$new("measure", custom_check = check_class_or_character("MeasureRegr", mlr_measures), tags = "train"),
-        ParamUty$new("optimizer", custom_check = check_optimizer, tags = "train"),
-        ParamUty$new("log_level", tags = "train",
+      ps = ps(
+        measure = p_uty(custom_check = check_class_or_character("MeasureRegr", mlr_measures), tags = "train"),
+        optimizer = p_uty(custom_check = check_optimizer, tags = "train"),
+        log_level = p_uty(tags = "train",
           function(x) check_string(x) %check||% check_integerish(x))
-      ))
+      )
       ps$values = list(measure = "regr.mse", optimizer = "nloptr", log_level = "warn")
       super$initialize(
         id = id,
@@ -185,10 +185,9 @@ optimize_weights_learneravg = function(self, task, n_weights, data) {
       }
 
       pars = self$param_set$get_values(tags = "train")
-      ps = ParamSet$new(params = imap(data, function(x, n) {
-        if (is.numeric(n)) n = paste0("w.", n)
-        ParamDbl$new(id = n, lower = 0, upper = 1)
-      }))
+      pl = rep(list(p_dbl(0, 1)), length(data))
+      names(pl) = names(data) %??% paste0("w.", seq_along(data))
+      ps = do.call(ps, pl)
       optimizer = pars$optimizer
       if (inherits(optimizer, "character")) {
         optimizer = bbotk::opt(optimizer)
@@ -198,7 +197,7 @@ optimize_weights_learneravg = function(self, task, n_weights, data) {
       }
       measure = pars$measure
       if (is.character(measure)) measure = msr(measure)
-      codomain = ParamSet$new(list(ParamDbl$new(id = measure$id, tags = ifelse(measure$minimize, "minimize", "maximize"))))
+      codomain = do.call(paradox::ps, structure(list(p_dbl(tags = ifelse(measure$minimize, "minimize", "maximize"))), names = measure$id))
       objfun = bbotk::ObjectiveRFun$new(
         fun = function(xs) learneravg_objfun(xs, task = task, measure = measure, avg_weight_fun = self$weighted_average_prediction, data = data),
         domain = ps, codomain = codomain

R/PipeOp.R

@@ -38,7 +38,7 @@
 #'
 #' @section Construction:
 #' ```
-#' PipeOp$new(id, param_set = ParamSet$new(), param_vals = list(), input, output, packages = character(0), tags = character(0))
+#' PipeOp$new(id, param_set = ps(), param_vals = list(), input, output, packages = character(0), tags = character(0))
 #' ```
 #'
 #' * `id` :: `character(1)`\cr
@@ -236,7 +236,7 @@ PipeOp = R6Class("PipeOp",
     .result = NULL,
     tags = NULL,
 
-    initialize = function(id, param_set = ParamSet$new(), param_vals = list(), input, output, packages = character(0), tags = "abstract") {
+    initialize = function(id, param_set = ps(), param_vals = list(), input, output, packages = character(0), tags = "abstract") {
       if (inherits(param_set, "ParamSet")) {
         private$.param_set = assert_param_set(param_set)
         private$.param_set_source = NULL
@@ -338,7 +338,7 @@ PipeOp = R6Class("PipeOp",
     id = function(val) {
       if (!missing(val)) {
         private$.id = val
-        if (!is.null(private$.param_set)) {
+        if (paradox_info$is_old && !is.null(private$.param_set)) {
           # private$.param_set may be NULL if it is constructed dynamically by active binding
           private$.param_set$set_id = val
         }
@@ -353,7 +353,7 @@ PipeOp = R6Class("PipeOp",
         } else {
           private$.param_set = sourcelist[[1]]
         }
-        if (!is.null(self$id)) {
+        if (paradox_info$is_old && !is.null(self$id)) {
           private$.param_set$set_id = self$id
         }
       }

R/PipeOpBoxCox.R

@@ -65,12 +65,12 @@ PipeOpBoxCox = R6Class("PipeOpBoxCox",
   inherit = PipeOpTaskPreproc,
   public = list(
     initialize = function(id = "boxcox", param_vals = list()) {
-      ps = ParamSet$new(params = list(
-        ParamLgl$new("standardize", default = TRUE, tags = c("train", "boxcox")),
-        ParamDbl$new("eps", default = 0.001, lower = 0, tags = c("train", "boxcox")),
-        ParamDbl$new("lower", tags = c("train", "boxcox")),
-        ParamDbl$new("upper", tags = c("train", "boxcox"))
-      ))
+      ps = ps(
+        standardize = p_lgl(default = TRUE, tags = c("train", "boxcox")),
+        eps = p_dbl(default = 0.001, lower = 0, tags = c("train", "boxcox")),
+        lower = p_dbl(tags = c("train", "boxcox")),
+        upper = p_dbl(tags = c("train", "boxcox"))
+      )
       super$initialize(id, param_set = ps, param_vals = param_vals,
         packages = "bestNormalize", feature_types = c("numeric", "integer"))
     }

R/PipeOpBranch.R

@@ -19,9 +19,9 @@
 #' * `options` :: `numeric(1)` | `character`\cr
 #'   If `options` is an integer number, it determines the number of
 #'   output channels / options that are created, named `output1`...`output<n>`. The
-#'   `$selection` parameter will then be a [`ParamInt`].
+#'   `$selection` parameter will then be an integer.
 #'   If `options` is a `character`, it determines the names of channels directly.
-#'   The `$selection` parameter will then be a [`ParamFct`].
+#'   The `$selection` parameter will then be factorial.
 #' * `id` :: `character(1)`\cr
 #'   Identifier of resulting object, default `"branch"`.
 #' * `param_vals` :: named `list`\cr
@@ -90,14 +90,14 @@ PipeOpBranch = R6Class("PipeOpBranch",
       )
       if (is.numeric(options)) {
         options = round(options)
-        param = ParamInt$new("selection", lower = 1L, upper = options, tags = c("train", "predict", "required"))
+        param = p_int(lower = 1L, upper = options, tags = c("train", "predict", "required"))
         options = rep_suffix("output", options)
         initval = 1
       } else {
-        param = ParamFct$new("selection", levels = options, tags = c("train", "predict", "required"))
+        param = p_fct(options, tags = c("train", "predict", "required"))
         initval = options[1]
       }
-      ps = ParamSet$new(params = list(param))
+      ps = ps(selection = param)
       ps$values$selection = initval
       super$initialize(id, ps, param_vals,
         input = data.table(name = "input", train = "*", predict = "*"),

R/PipeOpChunk.R

@@ -64,9 +64,9 @@ PipeOpChunk = R6Class("PipeOpChunk",
   public = list(
     initialize = function(outnum, id = "chunk", param_vals = list()) {
       outnum = assert_int(outnum, lower = 1L)
-      ps = ParamSet$new(params = list(
-        ParamLgl$new("shuffle", tags = "train")
-      ))
+      ps = ps(
+        shuffle = p_lgl(tags = "train")
+      )
       ps$values = list(shuffle = TRUE)
       super$initialize(id,
         param_set = ps, param_vals = param_vals,

R/PipeOpClassBalancing.R

@@ -104,14 +104,12 @@ PipeOpClassBalancing = R6Class("PipeOpClassBalancing",
 
   public = list(
     initialize = function(id = "classbalancing", param_vals = list()) {
-      ps = ParamSet$new(params = list(
-        ParamDbl$new("ratio", lower = 0, upper = Inf, tags = "train"),
-        ParamFct$new("reference",
-          levels = c("all", "major", "minor", "nonmajor", "nonminor", "one"), tags = "train"),
-        ParamFct$new("adjust",
-          levels = c("all", "major", "minor", "nonmajor", "nonminor", "upsample", "downsample"), tags = "train"),
-        ParamLgl$new("shuffle", tags = "train")
-      ))
+      ps = ps(
+        ratio = p_dbl(lower = 0, upper = Inf, tags = "train"),
+        reference = p_fct(c("all", "major", "minor", "nonmajor", "nonminor", "one"), tags = "train"),
+        adjust = p_fct(c("all", "major", "minor", "nonmajor", "nonminor", "upsample", "downsample"), tags = "train"),
+        shuffle = p_lgl(tags = "train")
+      )
       ps$values = list(ratio = 1, reference = "all", adjust = "all", shuffle = TRUE)
       super$initialize(id, param_set = ps, param_vals = param_vals, can_subset_cols = FALSE, task_type = "TaskClassif", tags = "imbalanced data")
     }

R/PipeOpClassWeights.R

@@ -71,9 +71,9 @@ PipeOpClassWeights = R6Class("PipeOpClassWeights",
 
   public = list(
     initialize = function(id = "classweights", param_vals = list()) {
-      ps = ParamSet$new(params = list(
-        ParamDbl$new("minor_weight", lower = 0, upper = Inf, tags = "train")
-      ))
+      ps = ps(
+        minor_weight = p_dbl(lower = 0, upper = Inf, tags = "train")
+      )
       ps$values = list(minor_weight = 1)
       super$initialize(id, param_set = ps, param_vals = param_vals, can_subset_cols = FALSE, task_type = "TaskClassif", tags = "imbalanced data")
     }

R/PipeOpColApply.R

@@ -92,9 +92,9 @@ PipeOpColApply = R6Class("PipeOpColApply",
   inherit = PipeOpTaskPreprocSimple,
   public = list(
     initialize = function(id = "colapply", param_vals = list()) {
-      ps = ParamSet$new(params = list(
-        ParamUty$new("applicator", custom_check = check_function, tags = c("train", "predict"))
-      ))
+      ps = ps(
+        applicator = p_uty(custom_check = check_function, tags = c("train", "predict"))
+      )
       ps$values = list(applicator = identity)
       super$initialize(id, ps, param_vals = param_vals)
     }