}}
\describe{
+\item{\code{marshaled}}{(\code{logical(1)})\cr
+Whether the learner is marshaled.}
+
\item{\code{network}}{(\code{\link[torch:nn_module]{nn_module()}})\cr
The network (only available after training).}
@@ -128,6 +138,8 @@ Shortcut for \code{learner$model$callbacks$history}.}
\item \href{#method-LearnerTorch-new}{\code{LearnerTorch$new()}}
\item \href{#method-LearnerTorch-format}{\code{LearnerTorch$format()}}
\item \href{#method-LearnerTorch-print}{\code{LearnerTorch$print()}}
+\item \href{#method-LearnerTorch-marshal}{\code{LearnerTorch$marshal()}}
+\item \href{#method-LearnerTorch-unmarshal}{\code{LearnerTorch$unmarshal()}}
\item \href{#method-LearnerTorch-clone}{\code{LearnerTorch$clone()}}
}
}
@@ -254,6 +266,48 @@ Currently unused.}
}
}
\if{html}{\out{
}}
+\if{html}{\out{
}}
+\if{latex}{\out{\hypertarget{method-LearnerTorch-marshal}{}}}
+\subsection{Method \code{marshal()}}{
+Marshal the learner.
+\subsection{Usage}{
+\if{html}{\out{
}}\preformatted{LearnerTorch$marshal(...)}\if{html}{\out{
}}
+}
+
+\subsection{Arguments}{
+\if{html}{\out{
}}
+\describe{
+\item{\code{...}}{(any)\cr
+Additional parameters.}
+}
+\if{html}{\out{
}}
+}
+\subsection{Returns}{
+self
+}
+}
+\if{html}{\out{
}}
+\if{html}{\out{
}}
+\if{latex}{\out{\hypertarget{method-LearnerTorch-unmarshal}{}}}
+\subsection{Method \code{unmarshal()}}{
+Unmarshal the learner.
+\subsection{Usage}{
+\if{html}{\out{
}}\preformatted{LearnerTorch$unmarshal(...)}\if{html}{\out{
}}
+}
+
+\subsection{Arguments}{
+\if{html}{\out{
}}
+\describe{
+\item{\code{...}}{(any)\cr
+Additional parameters.}
+}
+\if{html}{\out{
}}
+}
+\subsection{Returns}{
+self
+}
+}
+\if{html}{\out{
}}
\if{html}{\out{
}}
\if{latex}{\out{\hypertarget{method-LearnerTorch-clone}{}}}
\subsection{Method \code{clone()}}{
diff --git a/man/mlr_learners_torch_image.Rd b/man/mlr_learners_torch_image.Rd
index 36bb8938..57695857 100644
--- a/man/mlr_learners_torch_image.Rd
+++ b/man/mlr_learners_torch_image.Rd
@@ -42,7 +42,9 @@ Other Learner:
mlr3::Learner$reset()
mlr3::Learner$train()
mlr3torch::LearnerTorch$format()
+
mlr3torch::LearnerTorch$marshal()
mlr3torch::LearnerTorch$print()
+
mlr3torch::LearnerTorch$unmarshal()
}}
diff --git a/man/mlr_learners_torch_model.Rd b/man/mlr_learners_torch_model.Rd
index af40d4db..91c60c2f 100644
--- a/man/mlr_learners_torch_model.Rd
+++ b/man/mlr_learners_torch_model.Rd
@@ -86,7 +86,9 @@ Other Graph Network:
mlr3::Learner$reset()
mlr3::Learner$train()
mlr3torch::LearnerTorch$format()
+
mlr3torch::LearnerTorch$marshal()
mlr3torch::LearnerTorch$print()
+
mlr3torch::LearnerTorch$unmarshal()
}}
diff --git a/tests/testthat/helper_autotest.R b/tests/testthat/helper_autotest.R
index f8c26741..0af1c9cd 100644
--- a/tests/testthat/helper_autotest.R
+++ b/tests/testthat/helper_autotest.R
@@ -133,8 +133,8 @@ expect_pipeop_torch = function(graph, id, task, module_class = id, exclude_args
# parameters must only ce active during training
- walk(po_test$param_set$params, function(p) {
- if (!(("train" %in% p$tags) && !("predict" %in% p$tags))) {
+ walk(po_test$param_set$tags, function(tags) {
+ if (!(("train" %in% tags) && !("predict" %in% tags))) {
stopf("Parameters of PipeOps inheriting from PipeOpTorch must only be active during training.")
}
})
@@ -332,8 +332,8 @@ expect_pipeop_torch_preprocess = function(obj, shapes_in, exclude = character(0)
expect_class(obj, "PipeOpTaskPreprocTorch")
# a) Check that all parameters but stages have tags train and predict (this should hold in basically all cases)
# parameters must only ce active during training
- walk(obj$param_set$params, function(p) {
- if (!(("train" %in% p$tags) && !("predict" %in% p$tags))) {
+ walk(obj$param_set$tags, function(tags) {
+ if (!(("train" %in% tags) && !("predict" %in% tags))) {
stopf("Parameters of PipeOps inheriting from PipeOpTorch must only be active during training.")
}
})
diff --git a/tests/testthat/helper_functions.R b/tests/testthat/helper_functions.R
index 090a702b..c0dfe9b4 100644
--- a/tests/testthat/helper_functions.R
+++ b/tests/testthat/helper_functions.R
@@ -32,91 +32,7 @@ expect_man_exists = function(man) {
}
# expect that 'one' is a deep clone of 'two'
-expect_deep_clone = function(one, two) {
- # is equal
- expect_equal(one, two)
- visited = new.env()
- visited_b = new.env()
- expect_references_differ = function(a, b, path) {
-
- force(path)
- if (length(path) > 400) {
- stop("Recursion too deep in expect_deep_clone()")
- }
-
- # don't go in circles
- addr_a = data.table::address(a)
- addr_b = data.table::address(b)
- if (!is.null(visited[[addr_a]])) {
- return(invisible(NULL))
- }
- visited[[addr_a]] = path
- visited_b[[addr_b]] = path
-
- #if (inherits(a, "nn_module_generator") || inherits(a, "torch_optimizer_generator")) {
- # stopf("Not implemented yet")
- #}
- if (inherits(a, "R6ClassGenerator")) {
- return(NULL)
- }
-
- # follow attributes, even for non-recursive objects
- if (utils::tail(path, 1) != "[attributes]" && !is.null(base::attributes(a))) {
- expect_references_differ(base::attributes(a), base::attributes(b), c(path, "[attributes]"))
- }
-
- # don't recurse if there is nowhere to go
- if (!base::is.recursive(a)) {
- return(invisible(NULL))
- }
-
- # check that environments differ
- if (base::is.environment(a)) {
- # some special environments
- if (identical(a, baseenv()) || identical(a, globalenv()) || identical(a, emptyenv())) {
- return(invisible(NULL))
- }
- if (length(path) > 1 && R6::is.R6(a) && "clone" %nin% names(a)) {
- return(invisible(NULL)) # don't check if smth is not cloneable
- }
- if (identical(utils::tail(path, 1), c("[element train_task] 'train_task'"))) {
- return(invisible(NULL)) # workaround for https://github.com/mlr-org/mlr3/issues/382
- }
- if (identical(utils::tail(path, 1), c("[element fallback] 'fallback'"))) {
- return(invisible(NULL)) # workaround for https://github.com/mlr-org/mlr3/issues/511
- }
- label = sprintf("Object addresses differ at path %s", paste0(path, collapse = "->"))
- expect_true(addr_a != addr_b, label = label)
- expect_null(visited_b[[addr_a]], label = label)
- } else {
- a = unclass(a)
- b = unclass(b)
- }
- # recurse
- if (base::is.function(a)) {
- return(invisible(NULL))
- ## # maybe this is overdoing it
- ## expect_references_differ(base::formals(a), base::formals(b), c(path, "[function args]"))
- ## expect_references_differ(base::body(a), base::body(b), c(path, "[function body]"))
- }
- objnames = base::names(a)
- if (is.null(objnames) || anyDuplicated(objnames)) {
- index = seq_len(base::length(a))
- } else {
- index = objnames
- if (base::is.environment(a)) {
- index = Filter(function(x) !bindingIsActive(x, a), index)
- }
- }
- for (i in index) {
- if (utils::tail(path, 1) == "[attributes]" && i %in% c("srcref", "srcfile", ".Environment")) next
- expect_references_differ(base::`[[`(a, i), base::`[[`(b, i), c(path, sprintf("[element %s]%s", i,
- if (!is.null(objnames)) sprintf(" '%s'", if (is.character(index)) i else objnames[[i]]) else "")))
- }
- }
- expect_references_differ(one, two, "ROOT")
-}
expect_shallow_clone = function(one, two) {
expect_equal(one, two)
@@ -158,15 +74,29 @@ expect_valid_pipeop_param_set = function(po, check_ps_default_values = TRUE) {
ps = po$param_set
expect_true(every(ps$tags, function(x) length(intersect(c("train", "predict"), x)) > 0L))
- uties = ps$params[ps$ids("ParamUty")]
- if (length(uties)) {
- test_value = NO_DEF # custom_checks should fail for NO_DEF
- results = map(uties, function(uty) {
- uty$custom_check(test_value)
- })
- expect_true(all(map_lgl(results, function(result) {
- length(result) == 1L && (is.character(result) || result == TRUE) # result == TRUE is necessary because default is function(x) TRUE
- })), label = "custom_check returns string on failure")
+ if (mlr3pipelines:::paradox_info$is_old) {
+ uties = ps$params[ps$ids("ParamUty")]
+ if (length(uties)) {
+ test_value = NO_DEF # custom_checks should fail for NO_DEF
+ results = map(uties, function(uty) {
+ uty$custom_check(test_value)
+ })
+ expect_true(all(map_lgl(results, function(result) {
+ length(result) == 1L && (is.character(result) || result == TRUE) # result == TRUE is necessary because default is function(x) TRUE
+ })), label = "custom_check returns string on failure")
+ }
+ } else {
+ uties = ps$ids("ParamUty")
+ if (length(uties)) {
+ test_value = NO_DEF # custom_checks should fail for NO_DEF
+ results = map(uties, function(uty) {
+ psn = ps$subset(uty, allow_dangling_dependencies = TRUE)
+ psn$check(structure(list(test_value), names = uty))
+ })
+ expect_true(all(map_lgl(results, function(result) {
+ length(result) == 1L && (is.character(result) || result == TRUE) # result == TRUE is necessary because default is function(x) TRUE
+ })), label = "custom_check returns string on failure")
+ }
}
if (check_ps_default_values) {
diff --git a/tests/testthat/helper_mlr3pipelines.R b/tests/testthat/helper_mlr3pipelines.R
new file mode 100644
index 00000000..80e29708
--- /dev/null
+++ b/tests/testthat/helper_mlr3pipelines.R
@@ -0,0 +1,100 @@
+library("mlr3pipelines")
+library("checkmate")
+library("testthat")
+library("R6")
+library("mlr3misc")
+library("paradox")
+
+lapply(list.files(system.file("testthat", package = "mlr3pipelines"), pattern = "^helper.*\\.[rR]", full.names = TRUE), source)
+
+mlr_helpers = list.files(system.file("testthat", package = "mlr3pipelines"), pattern = "^helper.*\\.[rR]", full.names = TRUE)
+lapply(mlr_helpers, FUN = source)
+
+# expect that 'one' is a deep clone of 'two'
+expect_deep_clone = function(one, two) {
+ # is equal
+ expect_equal(one, two)
+ visited = new.env()
+ visited_b = new.env()
+ expect_references_differ = function(a, b, path) {
+
+ force(path)
+ if (length(path) > 400) {
+ stop("Recursion too deep in expect_deep_clone()")
+ }
+
+ # don't go in circles
+ addr_a = data.table::address(a)
+ addr_b = data.table::address(b)
+ if (!is.null(visited[[addr_a]])) {
+ return(invisible(NULL))
+ }
+ visited[[addr_a]] = path
+ visited_b[[addr_b]] = path
+
+ #if (inherits(a, "nn_module_generator") || inherits(a, "torch_optimizer_generator")) {
+ # stopf("Not implemented yet")
+ #}
+ if (inherits(a, "R6ClassGenerator")) {
+ return(NULL)
+ }
+
+ # follow attributes, even for non-recursive objects
+ if (utils::tail(path, 1) != "[attributes]" && !is.null(base::attributes(a))) {
+ expect_references_differ(base::attributes(a), base::attributes(b), c(path, "[attributes]"))
+ }
+
+ # don't recurse if there is nowhere to go
+ if (!base::is.recursive(a)) {
+ return(invisible(NULL))
+ }
+
+ # check that environments differ
+ if (base::is.environment(a)) {
+ # some special environments
+ if (identical(a, baseenv()) || identical(a, globalenv()) || identical(a, emptyenv())) {
+ return(invisible(NULL))
+ }
+ if (length(path) > 1 && R6::is.R6(a) && "clone" %nin% names(a)) {
+ return(invisible(NULL)) # don't check if smth is not cloneable
+ }
+ if (identical(utils::tail(path, 1), c("[element train_task] 'train_task'"))) {
+ return(invisible(NULL)) # workaround for https://github.com/mlr-org/mlr3/issues/382
+ }
+ if (identical(utils::tail(path, 1), c("[element fallback] 'fallback'"))) {
+ return(invisible(NULL)) # workaround for https://github.com/mlr-org/mlr3/issues/511
+ }
+ label = sprintf("Object addresses differ at path %s", paste0(path, collapse = "->"))
+ expect_true(addr_a != addr_b, label = label)
+ expect_null(visited_b[[addr_a]], label = label)
+ } else {
+ a = unclass(a)
+ b = unclass(b)
+ }
+
+ # recurse
+ if (base::is.function(a)) {
+ return(invisible(NULL))
+ ## # maybe this is overdoing it
+ ## expect_references_differ(base::formals(a), base::formals(b), c(path, "[function args]"))
+ ## expect_references_differ(base::body(a), base::body(b), c(path, "[function body]"))
+ }
+ objnames = base::names(a)
+ if (is.null(objnames) || anyDuplicated(objnames)) {
+ index = seq_len(base::length(a))
+ } else {
+ index = objnames
+ if (base::is.environment(a)) {
+ index = Filter(function(x) !bindingIsActive(x, a), index)
+ }
+ }
+ for (i in index) {
+ if (utils::tail(path, 1) == "[attributes]" && i %in% c("srcref", "srcfile", ".Environment")) next
+ expect_references_differ(base::`[[`(a, i), base::`[[`(b, i), c(path, sprintf("[element %s]%s", i,
+ if (!is.null(objnames)) sprintf(" '%s'", if (is.character(index)) i else objnames[[i]]) else "")))
+ }
+ }
+ expect_references_differ(one, two, "ROOT")
+}
+
+
diff --git a/tests/testthat/test_LearnerTorch.R b/tests/testthat/test_LearnerTorch.R
index 6a2a6d42..79b4a7bb 100644
--- a/tests/testthat/test_LearnerTorch.R
+++ b/tests/testthat/test_LearnerTorch.R
@@ -24,7 +24,7 @@ test_that("Basic tests: Classification", {
expect_equal(learner$id, "classif.test1")
expect_equal(learner$label, "Test1 Learner")
expect_set_equal(learner$feature_types, c("numeric", "integer"))
- expect_set_equal(learner$properties, c("multiclass", "twoclass"))
+ expect_set_equal(learner$properties, c("multiclass", "twoclass", "marshal"))
# default predict types are correct
expect_set_equal(learner$predict_types, c("response", "prob"))
@@ -48,7 +48,7 @@ test_that("Basic tests: Regression", {
expect_equal(learner$id, "regr.test1")
expect_equal(learner$label, "Test1 Learner")
expect_set_equal(learner$feature_types, c("numeric", "integer"))
- expect_set_equal(learner$properties, c())
+ expect_set_equal(learner$properties, "marshal")
# default predict types are correct
expect_set_equal(learner$predict_types, "response")
@@ -167,8 +167,8 @@ test_that("the state of a trained network contains what it should", {
expect_permutation(names(learner$model), c("seed", "network", "optimizer", "loss_fn", "task_col_info", "callbacks"))
expect_true(is.integer(learner$model$seed))
expect_class(learner$model$network, "nn_module")
- expect_class(learner$model$loss_fn, "nn_l1_loss")
- expect_class(learner$model$optimizer, "optim_sgd")
+ expect_class(learner$model$loss_fn, "list")
+ expect_class(learner$model$optimizer, "list")
expect_list(learner$model$callbacks, types = "CallbackSet", len = 1L)
expect_equal(names(learner$model$callbacks), "history1")
expect_true(is.integer(learner$model$seed))
@@ -387,6 +387,23 @@ test_that("resample() works", {
expect_r6(rr, "ResampleResult")
})
+test_that("callr encapsulation and marshaling", {
+ task = tsk("mtcars")$filter(1:5)
+ learner = lrn("regr.mlp", batch_size = 150, epochs = 1, device = "cpu", encapsulate = c(train = "callr"),
+ neurons = 20
+ )
+ learner$train(task)
+ expect_false(learner$marshaled)
+ learner$marshal()$unmarshal()
+ expect_prediction(learner$predict(task))
+
+ learner = lrn("regr.mlp", batch_size = 150, epochs = 1, device = "cpu", encapsulate = c(train = "callr"),
+ neurons = 20
+ )
+ learner$train(task)
+ expect_prediction(learner$predict(task))
+})
+
test_that("Input verification works during `$train()` (train-predict shapes work together)", {
task = nano_mnist()
diff --git a/tests/testthat/test_LearnerTorchFeatureless.R b/tests/testthat/test_LearnerTorchFeatureless.R
index bd0f29a6..ead9def0 100644
--- a/tests/testthat/test_LearnerTorchFeatureless.R
+++ b/tests/testthat/test_LearnerTorchFeatureless.R
@@ -11,7 +11,7 @@ test_that("dataset_featureless works", {
test_that("Basic checks: Classification", {
learner = lrn("classif.torch_featureless")
expect_learner_torch(learner)
- expect_set_equal(learner$properties, c("twoclass", "multiclass", "missings", "featureless"))
+ expect_set_equal(learner$properties, c("twoclass", "multiclass", "missings", "featureless", "marshal"))
})
test_that("LearnerTorchFeatureless works", {
@@ -28,5 +28,5 @@ test_that("LearnerTorchFeatureless works", {
test_that("Basic checks: Regression", {
learner = lrn("regr.torch_featureless")
expect_learner_torch(learner)
- expect_set_equal(learner$properties, c("missings", "featureless"))
+ expect_set_equal(learner$properties, c("missings", "featureless", "marshal"))
})
diff --git a/tests/testthat/test_PipeOpTaskPreprocTorch.R b/tests/testthat/test_PipeOpTaskPreprocTorch.R
index 5b16bd83..4c967095 100644
--- a/tests/testthat/test_PipeOpTaskPreprocTorch.R
+++ b/tests/testthat/test_PipeOpTaskPreprocTorch.R
@@ -166,13 +166,13 @@ test_that("shapes_out", {
test_that("lazy tensor modified as expected", {
d = data.table(
y = 1:10,
- x = as_lazy_tensor(rnorm(10))
+ x = as_lazy_tensor(1:10)
)
taskin = as_task_regr(d, target = "y")
po_test = po("preproc_torch", fn = crate(function(x, a) x + a), param_set = ps(a = p_int(tags = c("train", "required"))),
- a = -10, rowwise = FALSE, stages_init = "both")
+ a = 10, rowwise = FALSE, stages_init = "both")
taskout_train = po_test$train(list(taskin))[[1L]]
taskout_pred = po_test$predict(list(taskin))[[1L]]
@@ -193,7 +193,7 @@ test_that("lazy tensor modified as expected", {
expect_equal(
as_array(materialize(taskin$data(cols = "x")[[1L]], rbind = TRUE)),
- as_array(materialize(taskout_train$data(cols = "x")[[1L]], rbind = TRUE) + 10),
+ as_array(materialize(taskout_train$data(cols = "x")[[1L]], rbind = TRUE) - 10),
tolerance = 1e-5
)
})
diff --git a/tests/testthat/test_PipeOpTorchModel.R b/tests/testthat/test_PipeOpTorchModel.R
index f45ab707..47b8754a 100644
--- a/tests/testthat/test_PipeOpTorchModel.R
+++ b/tests/testthat/test_PipeOpTorchModel.R
@@ -44,14 +44,13 @@ test_that("Manual test: Classification and Regression", {
expect_class(obj$state, "LearnerTorchModel")
expect_class(obj$state$model$network, c("nn_graph", "nn_module"))
# Defaults are used
- expect_class(obj$state$model$optimizer, "optim_adam")
- expect_class(obj$state$model$loss_fn, "nn_cross_entropy_loss")
+ expect_class(obj$state$model$optimizer, "list")
+ expect_class(obj$state$model$loss_fn, "list")
# It is possible to change parameter values
md$optimizer = t_opt("adagrad", lr = 0.123)
obj = po("torch_model_classif", epochs = 0, batch_size = 2)
obj$train(list(md))
- expect_class(obj$state$model$optimizer, "optim_adagrad")
expect_true(obj$state$state$param_vals$opt.lr == 0.123)
expect_true(obj$state$state$param_vals$batch_size == 2)
diff --git a/tests/testthat/test_TorchCallback.R b/tests/testthat/test_TorchCallback.R
index 7c075688..721de328 100644
--- a/tests/testthat/test_TorchCallback.R
+++ b/tests/testthat/test_TorchCallback.R
@@ -14,7 +14,7 @@ test_that("Basic checks", {
Cbt4 = R6Class("CallbackSetTest4", public = list(initialize = function(x) NULL))
tcb41 = TorchCallback$new(Cbt4)
expect_identical(tcb41$param_set$ids(), "x")
- expect_class(tcb41$param_set$params$x, "ParamUty")
+ expect_equal(tcb41$param_set$params[list("x"), "cls", on = "id"][[1L]], "ParamUty")
ps42 = ps(x = p_int())
tcb42 = TorchCallback$new(Cbt4, param_set = ps42)
diff --git a/tests/testthat/test_TorchDescriptor.R b/tests/testthat/test_TorchDescriptor.R
index b2ac893e..8a2aaf16 100644
--- a/tests/testthat/test_TorchDescriptor.R
+++ b/tests/testthat/test_TorchDescriptor.R
@@ -9,7 +9,7 @@ test_that("TorchDescriptor basic checks", {
)
# train tag is added
- expect_true("train" %in% descriptor$param_set$params$reduction$tags)
+ expect_true("train" %in% descriptor$param_set$tags$reduction)
expect_identical(descriptor$generator, nn_mse_loss)
expect_identical(descriptor$id, "mse")
expect_identical(descriptor$param_set$ids(), "reduction")
diff --git a/tests/testthat/test_autotests.R b/tests/testthat/test_autotests.R
index a17c8e8a..756a56d7 100644
--- a/tests/testthat/test_autotests.R
+++ b/tests/testthat/test_autotests.R
@@ -171,6 +171,6 @@ test_that("expect_torch_callback works", {
)
)
cbd = as_torch_callback(CallbackSetD)
- expect_error(expect_torch_callback(cbd, check_man = FALSE), regexp = "not equal to")
+ expect_error(expect_torch_callback(cbd, check_man = FALSE))
})