9.5 Framework Comparison
Before diving deeper, we give a short introduction to PipeOps.
9.5.1 An introduction to “PipeOp”s
In this example, we create a linear Pipeline. After scaling all input features, we rotate our data using principal component analysis. After this transformation, we use a simple Decision Tree learner for classification.
As exemplary data, we will use the “
iris” classification task.
This object contains the famous iris dataset and some meta-information, such as the target variable.
library("mlr3") = mlr_tasks$get("iris")task
We quickly split our data into a train and a test set:
= sample(seq_len(task$nrow), 30) test.idx = setdiff(seq_len(task$nrow), test.idx) train.idx # Set task to only use train indexes $row_roles$use = train.idxtask
A Pipeline (or
Graph) contains multiple pipeline operators (“
PipeOp”s), where each
PipeOp transforms the data when it flows through it.
For this use case, we require 3 transformations:
PipeOpthat scales the data
PipeOpthat performs PCA
PipeOpthat contains the Decision Tree learner
A list of available
PipeOps can be obtained from
##  "boxcox" "branch" "chunk" ##  "classbalancing" "classifavg" "classweights" ##  "colapply" "collapsefactors" "colroles" ##  "copy" "datefeatures" "encode" ##  "encodeimpact" "encodelmer" "featureunion" ##  "filter" "fixfactors" "histbin" ##  "ica" "imputeconstant" "imputehist" ##  "imputelearner" "imputemean" "imputemedian" ##  "imputemode" "imputeoor" "imputesample" ##  "kernelpca" "learner" "learner_cv" ##  "missind" "modelmatrix" "multiplicityexply" ##  "multiplicityimply" "mutate" "nmf" ##  "nop" "ovrsplit" "ovrunite" ##  "pca" "proxy" "quantilebin" ##  "randomprojection" "randomresponse" "regravg" ##  "removeconstants" "renamecolumns" "replicate" ##  "scale" "scalemaxabs" "scalerange" ##  "select" "smote" "spatialsign" ##  "subsample" "targetinvert" "targetmutate" ##  "targettrafoscalerange" "textvectorizer" "threshold" ##  "tunethreshold" "unbranch" "vtreat" ##  "yeojohnson"
First we define the required
= PipeOpScale$new() op1 = PipeOpPCA$new() op2 = PipeOpLearner$new(learner = mlr_learners$get("classif.rpart"))op3
126.96.36.199 A quick glance into a PipeOp
In order to get a better understanding of what the respective PipeOps do, we quickly look at one of them in detail:
The most important slots in a PipeOp are:
$train(): A function used to train the PipeOp.
$predict(): A function used to predict with the PipeOp.
$predict() functions define the core functionality of our PipeOp.
In many cases, in order to not leak information from the training set into the test set it is imperative to treat train and test data separately.
For this we require a
$train() function that learns the appropriate transformations from the training set and a
$predict() function that applies the transformation on future data.
In the case of
PipeOpPCA this means the following:
$train()learns a rotation matrix from its input and saves this matrix to an additional slot,
$state. It returns the rotated input data stored in a new
$predict()uses the rotation matrix stored in
$statein order to rotate future, unseen data. It returns those in a new
188.8.131.52 Constructing the Pipeline
We can now connect the
PipeOps constructed earlier to a Pipeline.
We can do this using the
= op1 %>>% op2 %>>% op3linear_pipeline
The result of this operation is a “
Graph connects the input and output of each
PipeOp to the following
This allows us to specify linear processing pipelines.
In this case, we connect the output of the scaling PipeOp to the input of the PCA PipeOp and the output of the PCA PipeOp to the input of PipeOpLearner.
We can now train the
Graph using the
## $classif.rpart.output ## NULL
When we now train the graph, the data flows through the graph as follows:
- The Task flows into the
PipeOpscales each column in the data contained in the Task and returns a new Task that contains the scaled data to its output.
- The scaled Task flows into the
PipeOpPCA. PCA transforms the data and returns a (possibly smaller) Task, that contains the transformed data.
- This transformed data then flows into the learner, in our case classif.rpart. It is then used to train the learner, and as a result saves a model that can be used to predict new data.
In order to predict on new data, we need to save the relevant transformations our data went through while training.
As a result, each
PipeOp saves a state, where information required to appropriately transform future data is stored.
In our case, this is mean and standard deviation of each column for
PipeOpScale, the PCA rotation matrix for
PipeOpPCA and the learned model for
# predict on test.idx $row_roles$use = test.idx task$predict(task)linear_pipeline
## $classif.rpart.output ## <PredictionClassif> for 30 observations: ## row_id truth response ## 108 virginica virginica ## 40 setosa setosa ## 20 setosa setosa ## --- ## 110 virginica virginica ## 31 setosa setosa ## 141 virginica virginica
9.5.2 mlr3pipelines vs. mlr
While mlr wrappers are generally less verbose and require a little less code, this heavily inhibits flexibility. As an example, wrappers can generally not process data in parallel.
library("mlr") # We first create a learner = makeLearner("classif.rpart") lrn # Wrap this learner in a FilterWrapper = makeFilterWrapper(lrn, fw.abs = 2L) lrn.wrp # And wrap the resulting wrapped learner into an ImputeWrapper. = makeImputeWrapper(lrn.wrp) lrn.wrp # Afterwards, we can train the resulting learner on a task train(lrn, iris.task)
library("mlr3") library("mlr3pipelines") library("mlr3filters") = PipeOpImpute$new() impute = PipeOpFilter$new(filter = FilterVariance$new(), param_vals = list(filter.nfeat = 2L)) filter = PipeOpLearner$new(mlr_learners$get("classif.rpart")) rpart # Assemble the Pipeline = impute %>>% filter %>>% rpart pipeline # And convert to a 'GraphLearner' = GraphLearner$new(id = "Pipeline", pipeline)learner
The fact that mlr’s wrappers have to be applied inside-out, i.e. in the reverse order is often confusing.
This is way more straight-forward in
mlr3pipelines, where we simply chain the different methods using
mlr3pipelines offers way greater possibilities with respect to the kinds of Pipelines that can be constructed.
mlr3pipelines, we allow for the construction of parallel and conditional pipelines.
This was previously not possible.
9.5.3 mlr3pipelines vs. sklearn.pipeline.Pipeline
In order to broaden the horizon, we compare to Python sklearn’s
sklearn.pipeline.Pipeline sequentially applies a list of transforms before fitting a final estimator.
Intermediate steps of the pipeline are
transforms, i.e. steps that can learn from the data, but also transform the data while it flows through it.
The purpose of the pipeline is to assemble several steps that can be cross-validated together while setting different parameters.
For this, it enables setting parameters of the various steps.
It is thus conceptually very similar to mlr3pipelines.
Similarly to mlr3pipelines, we can tune over a full
Pipeline using various tuning methods.
Pipeline mainly supports linear pipelines.
This means, that it can execute parallel steps, such as for example Bagging, but it does not support conditional execution, i.e.
At the same time, the different
transforms in the pipeline can be cached, which makes tuning over the configuration space of a
Pipeline more efficient, as executing some steps multiple times can be avoided.
We compare functionality available in both mlr3pipelines and
sklearn.pipeline.Pipeline to give a comparison.
The following example obtained from the sklearn documentation showcases a Pipeline that first Selects a feature and performs PCA on the original data, concatenates the resulting datasets and applies a Support Vector Machine.
from sklearn.pipeline import Pipeline, FeatureUnion from sklearn.model_selection import GridSearchCV from sklearn.svm import SVC from sklearn.datasets import load_iris from sklearn.decomposition import PCA from sklearn.feature_selection import SelectKBest = load_iris() iris = iris.data, iris.target X, y # This dataset is way too high-dimensional. Better do PCA: = PCA(n_components=2) pca # Maybe some original features where good, too? = SelectKBest(k=1) selection # Build estimator from PCA and Univariate selection: = FeatureUnion([("pca", pca), ("univ_select", selection)]) combined_features # Use combined features to transform dataset: = combined_features.fit(X, y).transform(X) X_features = SVC(kernel="linear") svm # Do grid search over k, n_components and C: = Pipeline([("features", combined_features), ("svm", svm)]) pipeline = dict(features__pca__n_components=[1, 2, 3], param_grid =[1, 2], features__univ_select__k=[0.1, 1, 10]) svm__C = GridSearchCV(pipeline, param_grid=param_grid, cv=5, verbose=10) grid_search grid_search.fit(X, y)
library("mlr3verse") = mlr_tasks$get("iris") iris # Build the steps = PipeOpCopy$new(2) copy = PipeOpPCA$new() pca = PipeOpFilter$new(filter = FilterVariance$new()) selection = PipeOpFeatureUnion$new(2) union = PipeOpLearner$new(mlr_learners$get("classif.svm", param_vals = list(kernel = "linear"))) svm # Assemble the Pipeline = copy %>>% gunion(list(pca, selection)) %>>% union %>>% svm pipeline = GraphLearner$new(id = "Pipeline", pipeline) learner # For tuning, we define the resampling and the Parameter Space = mlr_resamplings$get("cv", param_vals = list(folds = 5L)) resampling library("paradox") = ps( param_set classif.svm.cost = p_dbl(lower = 0.1, upper = 1), pca.rank = p_int(lower = 1, upper = 3), variance.filter.nfeat = p_int(lower = 1, upper = 2) ) ) = PerformanceEvaluator$new(iris, learner, resampling, param_set) pe = TerminatorEvaluations$new(60) terminator = TunerGridSearch$new(pe, terminator, resolution = 10)$tune() tuner # Set the learner to the optimal values and train $param_set$values = tuner$tune_result()$valueslearner
In summary, we can achieve similar results with a comparable number of lines, while at the same time offering greater flexibility with respect to which kinds of pipelines we want to optimize over.
At the same time, experiments using
mlr3 can now be arbitrarily parallelized using
9.5.4 mlr3pipelines vs recipes
recipes is a new package, that covers some of the same applications steps as mlr3pipelines.
Both packages feature the possibility to connect different pre- and post-processing methods using a pipe-operator.
As the recipes package tightly integrates with the tidymodels ecosystem, much of the functionality integrated there can be used in
We compare recipes to mlr3pipelines using an example from the recipes vignette.
The aim of the analysis is to predict whether customers pay back their loans given some information on the customers. In order to do this, we build a model that does the following:
- It first imputes missing values using k-nearest neighbors
- All factor variables are converted to numerics using dummy encoding
- The data is first centered then scaled.
In order to validate the algorithm, data is first split into a train and test set using
The recipe trained on the train data (see steps above) is then applied to the test data.
library("tidymodels") library("rsample") data("credit_data", package = "modeldata") set.seed(55) = initial_split(credit_data) train_test_split = training(train_test_split) credit_train = testing(train_test_split) credit_test = recipe(Status ~ ., data = credit_train) %>% rec step_knnimpute(all_predictors()) %>% step_dummy(all_predictors(), -all_numeric()) %>% step_center(all_numeric()) %>% step_scale(all_numeric()) = prep(rec, training = credit_train) trained_rec # Apply to train and test set <- bake(trained_rec, new_data = credit_train) train_data <- bake(trained_rec, new_data = credit_test)test_data
Afterwards, the transformed data can be used during train and predict:
# Train = rand_forest(mtry = 12, trees = 200, mode = "classification") %>% rf set_engine("ranger", importance = 'impurity') %>% fit(Status ~ ., data = train_data) # Predict = predict(rf, test_data)prds
The same analysis can be performed in mlr3pipelines.
Note, that for now we do not impute via
knn but instead via sampling.
library("data.table") library("mlr3") library("mlr3learners") library("mlr3pipelines") data("credit_data", package = "modeldata") set.seed(55) # Create the task = TaskClassif$new(id = "credit_task", target = "Status", tsk backend = as_data_backend(data.table(credit_data))) # Build up the Pipeline: = PipeOpImputeSample$new(id = "impute") %>>% g $new(param_vals = list(method = "one-hot")) %>>% PipeOpEncode$new() %>>% PipeOpScale$new(mlr_learners$get("classif.ranger", PipeOpLearnerparam_vals = list(num.trees = 200, mtry = 12)) # We can visualize what happens to the data using the `plot` function: $plot() g # And we can use `mlr3's` full functionality be wrapping the Graph into a GraphLearner. glrn = GraphLearner$new(g) resample(tsk, glrn, mlr_resamplings$get("holdout"))