Target Transformation Base Class

Base class for handling target transformation operations. Target transformations are different from feature transformation because they have to be "inverted" after prediction. The target is transformed during the training phase and information to invert this transformation is sent along to PipeOpTargetInvert which then inverts this transformation during the prediction phase. This inversion may need info about both the training and the prediction data.

Users can overload up to four private$-functions: .get_state() (optional), .transform() (mandatory), .train_invert() (optional), and .invert() (mandatory).

Format

Abstract R6Class inheriting from PipeOp.

Construction

PipeOpTargetTrafo$new(id, param_set = ps(), param_vals = list() packages = character(0), task_type_in = "Task", task_type_out = task_type_in, tags = NULL)

id :: character(1)
Identifier of resulting object. See $id slot of PipeOp.
param_set :: ParamSet
Parameter space description. This should be created by the subclass and given to super$initialize().
param_vals :: named list
List of hyperparameter settings, overwriting the hyperparameter settings given in param_set. The subclass should have its own param_vals parameter and pass it on to super$initialize(). Default list().
task_type_in :: character(1)
The class of Task that should be accepted as input. This should generally be a character(1) identifying a type of Task, e.g. "Task", "TaskClassif" or "TaskRegr" (or another subclass introduced by other packages). Default is "Task".
task_type_out :: character(1)
The class of Task that is produced as output. This should generally be a character(1) identifying a type of Task, e.g. "Task", "TaskClassif" or "TaskRegr" (or another subclass introduced by other packages). Default is the value of task_type_in.
packages :: character
Set of all required packages for the PipeOp's methods. See $packages slot. Default is character(0).
tags :: character | NULL
Tags of the resulting PipeOp. This is added to the tag "target transform". Default NULL.

Input and Output Channels

PipeOpTargetTrafo has one input channels named "input" taking a Task (or whatever class was specified by the task_type during construction) both during training and prediction.

PipeOpTargetTrafo has two output channels named "fun" and "output". During training, "fun" returns NULL and during prediction, "fun" returns a function that can later be used to invert the transformation done during training according to the overloaded .train_invert() and .invert() functions. "output" returns the modified input Task (or task_type) according to the overloaded transform() function both during training and prediction.

State

The $state is a named list and should be returned explicitly by the user in the overloaded .get_state() function.

Internals

PipeOpTargetTrafo is an abstract class inheriting from PipeOp. It implements the private$.train() and private$.predict() functions. These functions perform checks and go on to call .get_state(), .transform(), .train_invert(). .invert() is packaged and sent along the "fun" output to be applied to a Prediction by PipeOpTargetInvert. A subclass of PipeOpTargetTrafo should implement these functions and be used in combination with PipeOpTargetInvert.

Fields

Fields inherited from PipeOp.

Methods

Methods inherited from PipeOp, as well as:

.get_state(task)
(Task) -> list
Called by PipeOpTargetTrafo's implementation of private$.train(). Takes a single Task as input and returns a list to set the $state. .get_state() will be called a single time during training right before .transform() is called. The return value (i.e. the $state) should contain info needed in .transform() as well as in .invert().
The base implementation returns list() and should be overloaded if setting the state is desired.
.transform(task, phase)
(Task, character(1)) -> Task
Called by PipeOpTargetTrafo's implementation of private$.train() and private$.predict(). Takes a single Task as input and modifies it. This should typically consist of calculating a new target and modifying the Task by using the convert_task function. .transform() will be called during training and prediction because the target (and if needed also type) of the input Task must be transformed both times. Note that unlike $.train(), the argument is not a list but a singular Task, and the return object is also not a list but a singular Task. The phase argument is "train" during training phase and "predict" during prediction phase and can be used to enable different behaviour during training and prediction. When phase is "train", the $state slot (as previously set by .get_state()) may also be modified, alternatively or in addition to overloading .get_state().
The input should not be cloned and if possible should be changed in-place.
This function is abstract and should be overloaded by inheriting classes.
.train_invert(task)
(Task) -> any
Called by PipeOpTargetTrafo's implementation of private$.predict(). Takes a single Task as input and returns an arbitrary value that will be given as predict_phase_state to .invert(). This should not modify the input Task .
The base implementation returns a list with a single element, the $truth column of the Task, and should be overloaded if a more training-phase-dependent state is desired.
.invert(prediction, predict_phase_state)
(Prediction, any) -> Prediction
Takes a Prediction and a predict_phase_state object as input and inverts the prediction. This function is sent as "fun" to PipeOpTargetInvert.
This function is abstract and should be overloaded by inheriting classes. Care should be taken that the predict_type of the Prediction being inverted is handled well.
.invert_help(predict_phase_state)
(predict_phase_state object) -> function
Helper function that packages .invert() that can later be used for the inversion.