Parent class for
PipeOps that aggregate predictions. Implements the
private$.predict() methods necessary
PipeOp and requires deriving classes to create the
R6Class inheriting from
PipeOpEnsemble$new(innum = 0, collect_multiplicity = FALSE, id, param_set = ParamSet$new(), param_vals = list(), packages = character(0), prediction_type = "Prediction")
Determines the number of input channels. If
innum is 0 (default), a vararg input channel is created that can take an arbitrary number of inputs.
TRUE, the input is a
Multiplicity collecting channel. This means, a
Multiplicity input, instead of multiple normal inputs, is accepted and the members are aggregated. This requires
innum to be 0.
Identifier of the resulting object.
param_vals :: named
List of hyperparameter settings, overwriting the hyperparameter settings that would otherwise be set during construction. Default
Set of packages required for this
PipeOp. These packages are loaded during
$predict(), but not attached.
predict entry of the
$output type specifications.
"Prediction" (default) or one of its subclasses, e.g.
"PredictionClassif", and correspond to the type accepted by
PipeOpEnsemble has multiple input channels depending on the
innum construction argument, named
innum is nonzero; if
innum is 0, there is only one vararg input channel named
All input channels take only
NULL during training and take a
Prediction during prediction.
PipeOpEnsemble has one output channel named
NULL during training and a
Prediction during prediction.
The output during prediction is in some way a weighted averaged representation of the input.
$state is left empty (
Relative weights of input predictions. If this has length 1, it is ignored and weighs all inputs equally. Otherwise it must have length equal to the number of connected inputs. Initialized to 1 (equal weights).
The commonality of ensemble methods using
PipeOpEnsemble is that they take a
NULL-input during training and save an empty
$state. They can be
used following a set of
PipeOps to perform (possibly weighted) prediction averaging. See e.g.
PipeOpRegrAvg which both inherit from this class.
Should it be necessary to use the output of preceding
during the "training" phase, then
PipeOpEnsemble should not be used. In fact, if training time behaviour of a
Learner is important, then
one should use a
PipeOpLearnerCV instead of a
PipeOpLearner, and the ensemble can be created with a
Learner encapsulated by a
LearnerRegrAvg for examples.
Only fields inherited from
Methods inherited from
PipeOp as well as:
weighted_avg_prediction(inputs, weights, row_ids, truth)
Predictions that correspond to the weighted average of incoming
Predictions. This is
private$.predict() with cleaned and sanity-checked values:
inputs are guaranteed to fit together,
truth are guaranteed to be the same as each one in
weights is guaranteed to have the same length as
This method is abstract, it must be implemented by deriving classes.
Other Multiplicity PipeOps: