Skip to contents

Learner Torch Module

Source: R/LearnerTorchModule.R
mlr_learners.module.Rd

Wraps a torch::nn_module into a LearnerTorch, so an architecture written directly in torch can be trained, resampled and tuned like any other mlr3 learner without going through a Graph of PipeOpTorch operators. This is the shortest path from an existing torch model to mlr3, and the natural choice for an architecture whose forward pass is easier to write as code than to assemble from operators. The module receives the task's features as its arguments, which ingress_tokens maps.

Dictionary

This Learner can be instantiated using the sugar function lrn():

lrn("classif.module", ...)
lrn("regr.module", ...)

Properties

  • Supported task types: 'classif', 'regr'

  • Predict Types:

    • classif: 'response', 'prob'

    • regr: 'response'

  • Feature Types: “logical”, “integer”, “numeric”, “character”, “factor”, “ordered”, “POSIXct”, “Date”, “lazy_tensor”

  • Required Packages: mlr3, mlr3torch, torch

See also

Other Learner: GraphLearnerTorch, as_learner_torch(), mlr_learners.ft_transformer, mlr_learners.mlp, mlr_learners.tab_resnet, mlr_learners.tabm, mlr_learners.torch_featureless, mlr_learners_torch, mlr_learners_torch_image, mlr_learners_torch_model

Super classes

mlr3::Learner -> LearnerTorch -> LearnerTorchModule

Methods

Public methods

Inherited methods

LearnerTorchModule$new()

Creates a new instance of this R6 class.

Usage

LearnerTorchModule$new(
  module_generator = NULL,
  param_set = NULL,
  ingress_tokens = NULL,
  task_type,
  properties = NULL,
  optimizer = NULL,
  loss = NULL,
  callbacks = list(),
  packages = character(0),
  feature_types = NULL,
  predict_types = NULL,
  target_batchgetter = NULL
)

Arguments

module_generator

(function or nn_module_generator)
A nn_module_generator or function returning an nn_module. Both must take as argument the task for which to construct the network. Other arguments to its initialize method can be provided as parameters.

param_set

(NULL or ParamSet)
If provided, contains the parameters for the module_generator. If NULL, parameters will be inferred from the module_generator.

ingress_tokens

(list of TorchIngressToken())
A list with ingress tokens that defines how the dataset will be defined. The names must correspond to the arguments of the network's forward method. For numeric, categorical, and lazy tensor features, you can use ingress_num(), ingress_categ(), and ingress_ltnsr() to create them.

task_type

(character(1))
The task type, either "classif" or "regr".

task_type

(character(1))
The task type.

properties

(NULL or character())
The properties of the learner. Defaults to all available properties for the given task type.

optimizer

(TorchOptimizer)
The optimizer to use for training. Per default, adam is used.

loss

(TorchLoss)
The loss used to train the network. Per default, mse is used for regression and cross_entropy for classification.

callbacks

(list() of TorchCallbacks)
The callbacks. Must have unique ids.

packages

(character())
The R packages this object depends on.

feature_types

(NULL or character())
The feature types. Defaults to all available feature types.

predict_types

(character())
The predict types. See mlr_reflections$learner_predict_types for available values.

target_batchgetter

(function() or NULL)
Converts the target columns of a batch into the target tensor y that the loss is applied to. Takes an argument data, a data.table with only the target columns, and optionally an argument x, the named list of feature tensors of the batch, which is what a target that is a function of the input needs, see get_target_batchgetter(). If NULL (default), it is taken from the task via get_target_batchgetter(), which the built-in task types provide, but a TaskTorch only if it has no target at all, in which case the batches have no y element.

LearnerTorchModule$clone()

The objects of this class are cloneable with this method.

Usage

LearnerTorchModule$clone(deep = FALSE)

Arguments

deep

Whether to make a deep clone.

Examples

nn_one_layer = nn_module("nn_one_layer",
  initialize = function(task, size_hidden) {
    self$first = nn_linear(task$n_features, size_hidden)
    self$second = nn_linear(size_hidden, output_dim_for(task))
  },
  # argument x corresponds to the ingress token x
  forward = function(x) {
    x = self$first(x)
    x = nnf_relu(x)
    self$second(x)
  }
)
learner = lrn("classif.module",
  module_generator = nn_one_layer,
  ingress_tokens = list(x = ingress_num()),
  epochs = 10,
  size_hidden = 20,
  batch_size = 16
)
task = tsk("iris")
learner$train(task)
learner$network
#> An `nn_module` containing 163 parameters.
#> 
#> ── Modules ─────────────────────────────────────────────────────────────────────
#> • first: <nn_linear> #100 parameters
#> • second: <nn_linear> #63 parameters