add convert oml dataset to mlr3

R/convertOMLDataSetToMlr3.R

@@ -0,0 +1,123 @@
+#' @title Convert an OpenML data set to mlr3 task.
+#'
+#' @description
+#' Converts an \code{\link{OMLDataSet}} to a \code{\link[mlr3]{Task}}.
+#'
+#' @param obj [\code{\link{OMLDataSet}}]\cr
+#' The object that should be converted.
+#' @param mlr.task.id [\code{character(1)}]\cr
+#' Id string for \code{\link[mlr3]{Task}} object.
+#' The strings \code{<oml.data.name>}, \code{<oml.data.id>} and \code{<oml.data.version>}
+#' will be replaced by their respective values contained in the \code{\link{OMLDataSet}} object.
+#' Default is \code{<oml.data.name>}.
+#' @param task.type [\code{character(1)}]\cr
+#' As we only pass the data set, we need to define the task type manually.
+#' Possible are: \dQuote{Supervised Classification}, \dQuote{Supervised Regression},
+#' \dQuote{Survival Analysis}.
+#' Default is \code{NULL} which means to guess it from the target column in the
+#' data set. If that is a factor or a logical, we choose classification.
+#' If it is numeric we choose regression. In all other cases an error is thrown.
+#' @param target [\code{character}]\cr
+#' The target for the classification/regression task.
+#' Default is the \code{default.target.attribute} of the \code{\link{OMLDataSetDescription}}.
+#' @param ignore.flagged.attributes [\code{logical(1)}]\cr
+#' Should those features that are listed in the data set description slot \dQuote{ignore.attribute}
+#' be removed?
+#' Default is \code{TRUE}.
+#' @param drop.levels [\code{logical(1)}]\cr
+#' Should empty factor levels be dropped in the data?
+#' Default is \code{TRUE}.
+#' @param fix.colnames [\code{logical(1)}]\cr
+#' Should colnames of the data be fixed using \code{\link[base]{make.names}}?
+#' Default is \code{TRUE}.
+#' @template arg_verbosity
+#' @return [\code{\link[mlr3]{Task}}].
+#' @family data set-related functions
+#' @example /inst/examples/convertOMLDataSetToMlr3.R
+#' @export
+convertOMLDataSetToMlr3 = function(
+ obj,
+ mlr.task.id = "<oml.data.name>",
+ task.type = NULL,
+ target = obj$desc$default.target.attribute,
+ ignore.flagged.attributes = TRUE,
+ drop.levels = TRUE,
+ fix.colnames = TRUE,
+ verbosity = NULL) {
+
+ assertClass(obj, "OMLDataSet")
+ assertSubset(target, obj$colnames.new)
+ assertFlag(ignore.flagged.attributes)
+ assertFlag(drop.levels)
+
+ data = obj$data
+ desc = obj$desc
+
+ # no task type? guess it by looking at target
+ if (is.null(task.type))
+ task.type = guessTaskType(data[, target])
+ assertChoice(task.type, getValidTaskTypes())
+
+ # remove ignored attributes from data
+ if (any(!is.na(desc$ignore.attribute)) & ignore.flagged.attributes) {
+ keep.cols = obj$colnames.old %nin% desc$ignore.attribute
+ data = data[, keep.cols, drop = FALSE]
+ }
+
+ # drop levels
+ if (drop.levels)
+ data = droplevels(data)
+
+ # fix colnames using make.names
+ if (fix.colnames) {
+ colnames(data) = make.names(colnames(data), unique = TRUE)
+ target = make.names(target, unique = TRUE)
+ }
+
+ # get fixup verbose setting for mlr
+ if (is.null(verbosity))
+ verbosity = getOMLConfig()$verbosity
+ fixup = ifelse(verbosity == 0L, "quiet", "warn")
+
+ mlr.task = switch(task.type,
+ "Supervised Classification" = mlr3::TaskClassif$new(id = desc$name, backend = data, target = target),
+ "Supervised Regression" = mlr3::TaskRegr$new(id = desc$name, backend = data, target = target),
+ "Survival Analysis" = mlr3survival::TaskSurv$new(id = desc$name, backend = data, target = target),
+ stopf("Encountered currently unsupported task type: %s", task.type)
+ )
+
+ if (!is.null(mlr.task.id))
+ mlr.task$id = replaceOMLDataSetString(mlr.task.id, obj)
+
+ return(mlr.task)
+}
+
+replaceOMLDataSetString = function(string, data.set) {
+ string = stri_replace_all_fixed(string, "<oml.data.id>", data.set$desc$id)
+ string = stri_replace_all_fixed(string, "<oml.data.name>", data.set$desc$name)
+ stri_replace_all_fixed(string, "<oml.data.version>", data.set$desc$version)
+}
+
+# @title Helper to guess task type from target column format.
+#
+# @param target [vector]
+# Vector of target values.
+# @return [character(1)]
+guessTaskType = function(target) {
+ if (inherits(target, "data.frame")) {
+ assertDataFrame(target, types = "logical")
+ return("Multilabel")
+ } else {
+ if (is.factor(target) | is.logical(target))
+ return("Supervised Classification")
+ if (is.numeric(target))
+ return("Supervised Regression")
+ }
+
+ stopf("Cannot guess task.type from data!")
+}
+
+getValidTaskTypes = function() {
+ c("Supervised Classification", "Supervised Regression", "Survival Analysis", "Multilabel")
+}
+

R/convertOMLSplitsToMlr3.R

@@ -0,0 +1,24 @@
+convertOMLSplitsToMlr3 = function(estim.proc, mlr.task, predict = "both") {
+ type = estim.proc$type
+ n.repeats = estim.proc$parameters[["number_repeats"]]
+ n.folds = estim.proc$parameters[["number_folds"]]
+ percentage = as.numeric(estim.proc$parameters[["percentage"]])
+ data.splits = estim.proc$data.splits
+ stratified = estim.proc$parameters[["stratified_sampling"]]
+ stratified = ifelse(is.null(stratified), FALSE, stratified == "true")
+
+ if (type == "crossvalidation") {
+ if (n.repeats == 1L)
+ mlr.rdesc = mlr3::rsmp("cv", folds = n.folds, stratify = stratified)
+ else
+ mlr.rdesc = mlr3::rsmp("repeated_cv", reps = n.repeats, folds = n.folds, stratify = stratified)
+ mlr.rin = mlr.rdesc$instantiate(mlr.task)
+ } else if (type == "holdout") {
+ mlr.rdesc = mlr3::rsmp("holdout")
+ mlr.rin = mlr.rdesc$instantiate(task = mlr.task)
+ n.folds = 1
+ } else {
+ stopf("Unsupported estimation procedure type: %s", type)
+ }
+ return(mlr.rin)
+}

inst/examples/convertOMLDataSetToMlr3.R

@@ -0,0 +1,5 @@
+# \dontrun{
+# library("mlr3")
+# autosOML = getOMLDataSet(data.id = 9)
+# autosMlr3 = convertOMLDataSetToMlr3(autosOML)
+# }

tests/testthat/test_local_convertOMLDataSetToMlr3.R

@@ -0,0 +1,45 @@
+context("convertOMLDataSetToMlr3")
+
+test_that("convertOMLDataSetToMlr3", {
+ with_test_cache({
+ ds = getOMLDataSet(10)
+
+ expect_is_mlr_task = function(mlr.task, ds) {
+ expect_equal(mlr.task$task_type, "classif")
+ expect_equal(mlr.task$nrow, nrow(ds$data))
+ expect_equal(ds$desc$default.target.attribute, mlr.task$target_names)
+ }
+
+ # now create the task
+ mlr.task = convertOMLDataSetToMlr3(ds)
+ expect_equal(mlr.task$task_type, "classif")
+
+ # now modify dataset by hand (no more server calls) to check
+ # ignore attributes stuff:
+ # Define the first two attributes as ignored attributes
+ ds$desc$ignore.attribute = colnames(ds$data[, 1:2])
+
+ mlr.task = convertOMLDataSetToMlr3(ds, ignore.flagged.attributes = TRUE)
+ expect_is_mlr_task(mlr.task, ds)
+ # we removed two attributes (and the target column is not considered here)
+ #expect_equal(sum(mlr.task$task.desc$n.feat), ncol(ds$data) - 3L)
+ expect_equal(mlr.task$ncol, ncol(ds$data) - 2L)
+
+ # pass faulty parameters
+ expect_error(convertOMLDataSetToMlr3(ds, task.type = "Nonexistent task type"), "element of")
+
+ # check setting mlr task id
+ expect_equal(convertOMLDataSetToMlr3(ds)$id, ds$desc$name)
+ expect_equal(convertOMLDataSetToMlr3(ds, mlr.task.id = "<oml.data.name>.<oml.data.id>")$id,
+ sprintf("%s.%s", ds$desc$name, ds$desc$id))
+ expect_equal(convertOMLDataSetToMlr3(ds, mlr.task.id = "test")$id, "test")
+ expect_equal(convertOMLDataSetToMlr3(ds, mlr.task.id = "<oml.data.id>")$id, as.character(ds$desc$id))
+ expect_equal(convertOMLDataSetToMlr3(ds, mlr.task.id = "<oml.data.name>")$id, as.character(ds$desc$name))
+ expect_equal(convertOMLDataSetToMlr3(ds, mlr.task.id = "<oml.data.version>")$id, as.character(ds$desc$version))
+ expect_equal(convertOMLDataSetToMlr3(ds, mlr.task.id = "<oml.task.id>")$id, "<oml.task.id>")
+
+ # check if conversion to regression task works
+ ds$desc$target.features = ds$desc$default.target.attribute = "no_of_nodes_in"
+ expect_equal(convertOMLDataSetToMlr3(ds)$task_type, "regr")
+ })
+})

tests/testthat/test_local_convertOMLSplitsToMlr3.R

@@ -0,0 +1,25 @@
+context("convertOMLSplitsToMlr3")
+
+test_that("convertOMLSplitsToMlr3", {
+ with_test_cache({
+ task = getOMLTask(59)
+ mlr.task = convertOMLTaskToMlr3(task)$mlr.task
+
+ oml.types = c("crossvalidation", "holdout")
+ mlr.types = c("cv", "holdout")
+
+ for (i in seq_along(oml.types)) {
+ task$input$estimation.procedure$type = oml.types[i]
+ if (oml.types[i] == "holdout") {
+ task$input$estimation.procedure$parameters$percentage = "50"
+ }
+ splits = convertOMLSplitsToMlr3(task$input$estimation.procedure, mlr.task)
+ expect_is(splits, "Resampling")
+ expect_equal(splits$id, mlr.types[i])
+ }
+
+ # pass invalid estim.proc
+ task$input$estimation.procedure$type = "blabla"
+ expect_error(convertOMLSplitsToMlr3(task$input$estimation.procedure, mlr.task), "Unsupported estimation procedure type: blabla")
+ })
+})