`R/blend_predictions.R`

`blend_predictions.Rd`

Evaluates a data stack by fitting a regularized model on the assessment predictions from each candidate member to predict the true outcome.

This process determines the "stacking coefficients" of the model stack. The stacking coefficients are used to weight the predictions from each candidate (represented by a unique column in the data stack), and are given by the betas of a LASSO model fitting the true outcome with the predictions given in the remaining columns of the data stack.

Candidates with non-zero stacking coefficients are model stack
members, and need to be trained on the full training set (rather
than just the assessment set) with `fit_members()`

. This function
is typically used after a number of calls to `add_candidates()`

.

blend_predictions( data_stack, penalty = 10^(-6:-1), mixture = 1, non_negative = TRUE, metric = NULL, control = tune::control_grid(), ... )

data_stack | A |
---|---|

penalty | A numeric vector of proposed values for total amount of
regularization used in member weighting. Higher penalties will generally
result in fewer members being included in the resulting model stack, and
vice versa. The package will tune over a grid formed from the cross
product of the |

mixture | A number between zero and one (inclusive) giving the
proportion of L1 regularization (i.e. lasso) in the model. |

non_negative | A logical giving whether to restrict stacking
coefficients to non-negative values. If |

metric | A call to |

control | An object inheriting from |

... | Additional arguments. Currently ignored. |

A `model_stack`

object—while `model_stack`

s largely contain the
same elements as `data_stack`

s, the primary data objects shift from the
assessment set predictions to the member models.

Note that a regularized linear model is one of many possible
learning algorithms that could be used to fit a stacked ensemble
model. For implementations of additional ensemble learning algorithms, see
`h2o::h2o.stackedEnsemble()`

and `SuperLearner::SuperLearner()`

.

This package provides some resampling objects and datasets for use in examples and vignettes derived from a study on 1212 red-eyed tree frog embryos!

Red-eyed tree frog (RETF) embryos can hatch earlier than their normal 7ish days if they detect potential predator threat. Researchers wanted to determine how, and when, these tree frog embryos were able to detect stimulus from their environment. To do so, they subjected the embryos at varying developmental stages to "predator stimulus" by jiggling the embryos with a blunt probe. Beforehand, though some of the embryos were treated with gentamicin, a compound that knocks out their lateral line (a sensory organ.) Researcher Julie Jung and her crew found that these factors inform whether an embryo hatches prematurely or not!

Note that the data included with the stacks package is not necessarily a representative or unbiased subset of the complete dataset, and is only for demonstrative purposes.

`reg_folds`

and `class_folds`

are `rset`

cross-fold validation objects
from `rsample`

, splitting the training data into for the regression
and classification model objects, respectively. `tree_frogs_reg_test`

and
`tree_frogs_class_test`

are the analogous testing sets.

`reg_res_lr`

, `reg_res_svm`

, and `reg_res_sp`

contain regression tuning results
for a linear regression, support vector machine, and spline model, respectively,
fitting `latency`

(i.e. how long the embryos took to hatch in response
to the jiggle) in the `tree_frogs`

data, using most all of the other
variables as predictors. Note that the data underlying these models is
filtered to include data only from embryos that hatched in response to
the stimulus.

`class_res_rf`

and `class_res_nn`

contain multiclass classification tuning
results for a random forest and neural network classification model,
respectively, fitting `reflex`

(a measure of ear function) in the
data using most all of the other variables as predictors.

`log_res_rf`

and `log_res_nn`

, contain binary classification tuning results
for a random forest and neural network classification model, respectively,
fitting `hatched`

(whether or not the embryos hatched in response
to the stimulus) using most all of the other variables as predictors.

See `?example_data`

to learn more about these objects, as well as browse
the source code that generated them.

Other core verbs:
`add_candidates()`

,
`fit_members()`

,
`stacks()`

# \donttest{ # see the "Example Data" section above for # clarification on the objects used in these examples! # put together a data stack reg_st <- stacks() %>% add_candidates(reg_res_lr) %>% add_candidates(reg_res_svm) %>% add_candidates(reg_res_sp) reg_st#> # A data stack with 3 model definitions and 15 candidate members: #> # reg_res_lr: 1 model configuration #> # reg_res_svm: 5 model configurations #> # reg_res_sp: 9 model configurations #> # Outcome: latency (numeric)# evaluate the data stack reg_st %>% blend_predictions()#>#> #>#> #>#> #>#> # A tibble: 5 x 3 #> member type weight #> <chr> <chr> <dbl> #> 1 reg_res_svm_1_1 svm_rbf 0.443 #> 2 reg_res_sp_4_1 linear_reg 0.275 #> 3 reg_res_svm_1_3 svm_rbf 0.270 #> 4 reg_res_sp_9_1 linear_reg 0.0779 #> 5 reg_res_sp_2_1 linear_reg 0.0410#> #># include fewer models by proposing higher penalties reg_st %>% blend_predictions(penalty = c(.5, 1))#>#> #>#> #>#> #>#> # A tibble: 5 x 3 #> member type weight #> <chr> <chr> <dbl> #> 1 reg_res_svm_1_1 svm_rbf 0.435 #> 2 reg_res_svm_1_3 svm_rbf 0.251 #> 3 reg_res_sp_4_1 linear_reg 0.243 #> 4 reg_res_sp_9_1 linear_reg 0.0901 #> 5 reg_res_sp_2_1 linear_reg 0.0575#> #># allow for negative stacking coefficients # with the non_negative argument reg_st %>% blend_predictions(non_negative = FALSE)#>#> #>#> #>#> #>#> # A tibble: 10 x 3 #> member type weight #> <chr> <chr> <dbl> #> 1 reg_res_sp_8_1 linear_reg 2.06 #> 2 reg_res_sp_4_1 linear_reg 0.473 #> 3 reg_res_svm_1_1 svm_rbf 0.468 #> 4 reg_res_sp_9_1 linear_reg 0.266 #> 5 reg_res_svm_1_3 svm_rbf 0.152 #> 6 reg_res_sp_7_1 linear_reg 0.108 #> 7 reg_res_svm_1_4 svm_rbf -0.0165 #> 8 reg_res_sp_6_1 linear_reg -0.550 #> 9 reg_res_sp_3_1 linear_reg -1.91 #> 10 reg_res_svm_1_2 svm_rbf -7.37#> #># use a custom metric in tuning the lasso penalty library(yardstick) reg_st %>% blend_predictions(metric = metric_set(rmse))#>#> #>#> #>#> #>#> # A tibble: 5 x 3 #> member type weight #> <chr> <chr> <dbl> #> 1 reg_res_svm_1_1 svm_rbf 0.442 #> 2 reg_res_svm_1_3 svm_rbf 0.265 #> 3 reg_res_sp_4_1 linear_reg 0.261 #> 4 reg_res_sp_9_1 linear_reg 0.0860 #> 5 reg_res_sp_2_1 linear_reg 0.0480#> #># pass control options for stack blending reg_st %>% blend_predictions( control = tune::control_grid(allow_par = TRUE) )#>#> #>#> #>#> #>#> # A tibble: 5 x 3 #> member type weight #> <chr> <chr> <dbl> #> 1 reg_res_svm_1_1 svm_rbf 0.443 #> 2 reg_res_sp_4_1 linear_reg 0.275 #> 3 reg_res_svm_1_3 svm_rbf 0.270 #> 4 reg_res_sp_9_1 linear_reg 0.0779 #> 5 reg_res_sp_2_1 linear_reg 0.0410#> #># the process looks the same with # multinomial classification models class_st <- stacks() %>% add_candidates(class_res_nn) %>% add_candidates(class_res_rf) %>% blend_predictions()#> ! Bootstrap03: preprocessor 1/1, model 1/1: from glmnet Fortran code (error code -77); ...#> ! Bootstrap06: preprocessor 1/1, model 1/1: from glmnet Fortran code (error code -70); ...#> ! Bootstrap07: preprocessor 1/1, model 1/1: from glmnet Fortran code (error code -72); ...#> ! Bootstrap16: preprocessor 1/1, model 1/1: from glmnet Fortran code (error code -68); ...#> ! Bootstrap18: preprocessor 1/1, model 1/1: from glmnet Fortran code (error code -89); ...#> ! Bootstrap21: preprocessor 1/1, model 1/1: from glmnet Fortran code (error code -56); ...#> ! Bootstrap22: preprocessor 1/1, model 1/1: from glmnet Fortran code (error code -66); ...#> ! Bootstrap24: preprocessor 1/1, model 1/1: from glmnet Fortran code (error code -61); ...class_st#>#> #>#> #>#>#> #>#> # A tibble: 10 x 4 #> member type weight class #> <chr> <chr> <dbl> <chr> #> 1 .pred_full_class_res_nn_1_1 mlp 28.8 full #> 2 .pred_mid_class_res_rf_1_01 rand_forest 10.9 mid #> 3 .pred_mid_class_res_nn_1_1 mlp 7.82 mid #> 4 .pred_mid_class_res_rf_1_04 rand_forest 5.76 low #> 5 .pred_mid_class_res_rf_1_08 rand_forest 5.53 low #> 6 .pred_mid_class_res_rf_1_07 rand_forest 4.48 low #> 7 .pred_mid_class_res_rf_1_05 rand_forest 1.80 mid #> 8 .pred_mid_class_res_rf_1_10 rand_forest 1.36 mid #> 9 .pred_mid_class_res_rf_1_02 rand_forest 0.552 low #> 10 .pred_full_class_res_rf_1_04 rand_forest 0.284 mid#> #># ...or binomial classification models log_st <- stacks() %>% add_candidates(log_res_nn) %>% add_candidates(log_res_rf) %>% blend_predictions() log_st#>#> #>#> #>#> #>#> # A tibble: 4 x 3 #> member type weight #> <chr> <chr> <dbl> #> 1 .pred_yes_log_res_nn_1_1 mlp 6.11 #> 2 .pred_yes_log_res_rf_1_09 rand_forest 1.85 #> 3 .pred_yes_log_res_rf_1_05 rand_forest 1.45 #> 4 .pred_yes_log_res_rf_1_06 rand_forest 0.836#> #># }