In tidymodels/parsnip: A Common API to Modeling and Analysis Functions

library(utils)
library(ggplot2)
theme_set(theme_bw())

These examples show how to fit and predict with different combinations of model, mode, and engine. As a reminder, in parsnip,

• the model type differentiates basic modeling approaches, such as random forests, logistic regression, linear support vector machines, etc.,

• the mode denotes in what kind of modeling context it will be used (most commonly, classification or regression), and

• the computational engine indicates how the model is fit, such as with a specific R package implementation or even methods outside of R like Keras or Stan.

The following examples use consistent data sets throughout. For regression, we use the Chicago ridership data. For classification, we use an artificial data set for a binary example and the Palmer penguins data for a multiclass example.

bart() models

With the "dbarts" engine

Regression Example (dbarts)

r knitr::spin_child("template-reg-chicago.R")

We can define the model with specific parameters:

r bt_reg_spec <- bart(trees = 15) %>% # This model can be used for classification or regression, so set mode set_mode("regression") %>% set_engine("dbarts") bt_reg_spec

Now we create the model fit object:

r set.seed(1) bt_reg_fit <- bt_reg_spec %>% fit(ridership ~ ., data = Chicago_train) bt_reg_fit

The holdout data can be predicted:

r predict(bt_reg_fit, Chicago_test)

Classification Example (dbarts)

r knitr::spin_child("template-cls-two-class.R")

We can define the model with specific parameters:

r bt_cls_spec <- bart(trees = 15) %>% # This model can be used for classification or regression, so set mode set_mode("classification") %>% set_engine("dbarts") bt_cls_spec

Now we create the model fit object:

r set.seed(1) bt_cls_fit <- bt_cls_spec %>% fit(Class ~ ., data = data_train) bt_cls_fit

The holdout data can be predicted for both hard class predictions and probabilities. We'll bind these together into one tibble:

r bind_cols( predict(bt_cls_fit, data_test), predict(bt_cls_fit, data_test, type = "prob") )

boost_tree() models

With the "xgboost" engine

Regression Example (xgboost)

r knitr::spin_child("template-reg-chicago.R")

We can define the model with specific parameters:

r bt_reg_spec <- boost_tree(trees = 15) %>% # This model can be used for classification or regression, so set mode set_mode("regression") %>% set_engine("xgboost") bt_reg_spec

Now we create the model fit object:

r set.seed(1) bt_reg_fit <- bt_reg_spec %>% fit(ridership ~ ., data = Chicago_train) bt_reg_fit

The holdout data can be predicted:

r predict(bt_reg_fit, Chicago_test)

Classification Example (xgboost)

r knitr::spin_child("template-cls-two-class.R")

We can define the model with specific parameters:

r bt_cls_spec <- boost_tree(trees = 15) %>% # This model can be used for classification or regression, so set mode set_mode("classification") %>% set_engine("xgboost") bt_cls_spec

Now we create the model fit object:

r set.seed(1) bt_cls_fit <- bt_cls_spec %>% fit(Class ~ ., data = data_train) bt_cls_fit

The holdout data can be predicted for both hard class predictions and probabilities. We'll bind these together into one tibble:

r bind_cols( predict(bt_cls_fit, data_test), predict(bt_cls_fit, data_test, type = "prob") )

With the "C5.0" engine

Classification Example (C5.0)

r knitr::spin_child("template-cls-two-class.R")

We can define the model with specific parameters:

r bt_cls_spec <- boost_tree(trees = 15) %>% set_mode("classification") %>% set_engine("C5.0") bt_cls_spec

Now we create the model fit object:

r set.seed(1) bt_cls_fit <- bt_cls_spec %>% fit(Class ~ ., data = data_train) bt_cls_fit

The holdout data can be predicted for both hard class predictions and probabilities. We'll bind these together into one tibble:

r bind_cols( predict(bt_cls_fit, data_test), predict(bt_cls_fit, data_test, type = "prob") )

decision_tree() models

With the "rpart" engine

Regression Example (rpart)

r knitr::spin_child("template-reg-chicago.R")

We can define the model with specific parameters:

r dt_reg_spec <- decision_tree(tree_depth = 30) %>% # This model can be used for classification or regression, so set mode set_mode("regression") %>% set_engine("rpart") dt_reg_spec

Now we create the model fit object:

r set.seed(1) dt_reg_fit <- dt_reg_spec %>% fit(ridership ~ ., data = Chicago_train) dt_reg_fit

The holdout data can be predicted:

r predict(dt_reg_fit, Chicago_test)

Classification Example (rpart)

r knitr::spin_child("template-cls-two-class.R")

We can define the model with specific parameters:

r dt_cls_spec <- decision_tree(tree_depth = 30) %>% # This model can be used for classification or regression, so set mode set_mode("classification") %>% set_engine("rpart") dt_cls_spec

Now we create the model fit object:

r set.seed(1) dt_cls_fit <- dt_cls_spec %>% fit(Class ~ ., data = data_train) dt_cls_fit

The holdout data can be predicted for both hard class predictions and probabilities. We'll bind these together into one tibble:

r bind_cols( predict(dt_cls_fit, data_test), predict(dt_cls_fit, data_test, type = "prob") )

With the "C5.0" engine

Classification Example (C5.0)

r knitr::spin_child("template-cls-two-class.R")

We can define the model with specific parameters:

r dt_cls_spec <- decision_tree(min_n = 2) %>% set_mode("classification") %>% set_engine("C5.0") dt_cls_spec

Now we create the model fit object:

r set.seed(1) dt_cls_fit <- dt_cls_spec %>% fit(Class ~ ., data = data_train) dt_cls_fit

The holdout data can be predicted for both hard class predictions and probabilities. We'll bind these together into one tibble:

r bind_cols( predict(dt_cls_fit, data_test), predict(dt_cls_fit, data_test, type = "prob") )

gen_additive_mod() models

With the "mgcv" engine

Regression Example (mgcv)

r knitr::spin_child("template-reg-chicago.R")

We can define the model with specific parameters:

r gam_reg_spec <- gen_additive_mod(select_features = FALSE, adjust_deg_free = 10) %>% # This model can be used for classification or regression, so set mode set_mode("regression") %>% set_engine("mgcv") gam_reg_spec

Now we create the model fit object:

r set.seed(1) gam_reg_fit <- gam_reg_spec %>% fit(ridership ~ Clark_Lake + Quincy_Wells, data = Chicago_train) gam_reg_fit

The holdout data can be predicted:

r predict(gam_reg_fit, Chicago_test)

Classification Example (mgcv)

r knitr::spin_child("template-cls-two-class.R")

We can define the model with specific parameters:

r gam_cls_spec <- gen_additive_mod(select_features = FALSE, adjust_deg_free = 10) %>% # This model can be used for classification or regression, so set mode set_mode("classification") %>% set_engine("mgcv") gam_cls_spec

Now we create the model fit object:

r set.seed(1) gam_cls_fit <- gam_cls_spec %>% fit(Class ~ A + B, data = data_train) gam_cls_fit

The holdout data can be predicted for both hard class predictions and probabilities. We'll bind these together into one tibble:

r bind_cols( predict(gam_cls_fit, data_test), predict(gam_cls_fit, data_test, type = "prob") )

linear_reg() models

With the "lm" engine

Regression Example (lm)

r knitr::spin_child("template-reg-chicago.R")

We can define the model with specific parameters:

r linreg_reg_spec <- linear_reg() %>% set_engine("lm") linreg_reg_spec

Now we create the model fit object:

r set.seed(1) linreg_reg_fit <- linreg_reg_spec %>% fit(ridership ~ ., data = Chicago_train) linreg_reg_fit

The holdout data can be predicted:

r predict(linreg_reg_fit, Chicago_test)

With the "glm" engine

Regression Example (glm)

r knitr::spin_child("template-reg-chicago.R")

We can define the model with specific parameters:

r linreg_reg_spec <- linear_reg() %>% set_engine("glm") linreg_reg_spec

Now we create the model fit object:

r set.seed(1) linreg_reg_fit <- linreg_reg_spec %>% fit(ridership ~ ., data = Chicago_train) linreg_reg_fit

The holdout data can be predicted:

r predict(linreg_reg_fit, Chicago_test)

With the "glmnet" engine

Regression Example (glmnet)

r knitr::spin_child("template-reg-chicago.R")

We can define the model with specific parameters:

r linreg_reg_spec <- linear_reg(penalty = 0.1) %>% set_engine("glmnet") linreg_reg_spec

Now we create the model fit object:

r set.seed(1) linreg_reg_fit <- linreg_reg_spec %>% fit(ridership ~ ., data = Chicago_train) linreg_reg_fit

The holdout data can be predicted:

r predict(linreg_reg_fit, Chicago_test)

With the "keras" engine

Regression Example (keras)

r knitr::spin_child("template-reg-chicago.R")

We can define the model with specific parameters:

r linreg_reg_spec <- linear_reg(penalty = 0.1) %>% set_engine("keras") linreg_reg_spec

Now we create the model fit object:

r set.seed(1) linreg_reg_fit <- linreg_reg_spec %>% fit(ridership ~ ., data = Chicago_train) linreg_reg_fit

The holdout data can be predicted:

r predict(linreg_reg_fit, Chicago_test)

With the "stan" engine

Regression Example (stan)

r knitr::spin_child("template-reg-chicago.R")

We can define the model with specific parameters:

r linreg_reg_spec <- linear_reg() %>% set_engine("stan") linreg_reg_spec

Now we create the model fit object:

r set.seed(1) linreg_reg_fit <- linreg_reg_spec %>% fit(ridership ~ ., data = Chicago_train) linreg_reg_fit

The holdout data can be predicted:

r predict(linreg_reg_fit, Chicago_test)

With the "quantreg" engine

Quantile regression Example (quantreg)

r knitr::spin_child("template-reg-sacramento.R")

We can define the model but should set the model mode. Also, for these models the levels of the distirunbtion that we would like to predict need to specified with the mode using the quantile_levels argument. Let's predict the 0.25, 0.50, and 0.75 quantiles:

r linreg_quant_spec <- linear_reg() %>% set_engine("quantreg") %>% set_mode("quantile regression", quantile_levels = (1:3) / 4) linreg_quant_spec

Now we create the model fit object:

r set.seed(1) linreg_quant_fit <- linreg_quant_spec %>% fit(price ~ sqft, data = sac_train) linreg_quant_fit

The holdout data can be predicted:

r quant_pred <- predict(linreg_quant_fit, sac_test) quant_pred

.pred_quantile is a vector type that contains all of the quartile predictions for each row. You can convert this to a rectangular data set using either of:

```r as.matrix(quant_pred$.pred_quantile)

# or as_tibble(quant_pred$.pred_quantile) ```

With the "brulee" engine

Regression Example (brulee)

r knitr::spin_child("template-reg-chicago.R")

We can define the model with specific parameters:

r linreg_reg_spec <- linear_reg() %>% set_engine("brulee") linreg_reg_spec

Now we create the model fit object:

r set.seed(1) linreg_reg_fit <- linreg_reg_spec %>% fit(ridership ~ ., data = Chicago_train) linreg_reg_fit

The holdout data can be predicted:

r predict(linreg_reg_fit, Chicago_test)

logistic_reg() models

With the "glm" engine

Classification Example (glm)

r knitr::spin_child("template-cls-two-class.R")

We can define the model with specific parameters:

r logreg_cls_spec <- logistic_reg() %>% set_engine("glm") logreg_cls_spec

Now we create the model fit object:

r set.seed(1) logreg_cls_fit <- logreg_cls_spec %>% fit(Class ~ ., data = data_train) logreg_cls_fit

The holdout data can be predicted for both hard class predictions and probabilities. We'll bind these together into one tibble:

r bind_cols( predict(logreg_cls_fit, data_test), predict(logreg_cls_fit, data_test, type = "prob") )

With the "glmnet" engine

Classification Example (glmnet)

r knitr::spin_child("template-cls-two-class.R")

We can define the model with specific parameters:

r logreg_cls_spec <- logistic_reg(penalty = 0.1) %>% set_engine("glmnet") logreg_cls_spec

Now we create the model fit object:

r set.seed(1) logreg_cls_fit <- logreg_cls_spec %>% fit(Class ~ ., data = data_train) logreg_cls_fit

The holdout data can be predicted for both hard class predictions and probabilities. We'll bind these together into one tibble:

r bind_cols( predict(logreg_cls_fit, data_test), predict(logreg_cls_fit, data_test, type = "prob") )

With the "keras" engine

Classification Example (keras)

r knitr::spin_child("template-cls-two-class.R")

We can define the model with specific parameters:

r logreg_cls_spec <- logistic_reg(penalty = 0.1) %>% set_engine("keras") logreg_cls_spec

Now we create the model fit object:

r set.seed(1) logreg_cls_fit <- logreg_cls_spec %>% fit(Class ~ ., data = data_train) logreg_cls_fit

The holdout data can be predicted for both hard class predictions and probabilities. We'll bind these together into one tibble:

r bind_cols( predict(logreg_cls_fit, data_test), predict(logreg_cls_fit, data_test, type = "prob") )

With the "LiblineaR" engine

Classification Example (LiblineaR)

r knitr::spin_child("template-cls-two-class.R")

We can define the model with specific parameters:

r logreg_cls_spec <- logistic_reg(penalty = 0.1) %>% set_engine("LiblineaR") logreg_cls_spec

Now we create the model fit object:

r set.seed(1) logreg_cls_fit <- logreg_cls_spec %>% fit(Class ~ ., data = data_train) logreg_cls_fit

The holdout data can be predicted for both hard class predictions and probabilities. We'll bind these together into one tibble:

r bind_cols( predict(logreg_cls_fit, data_test), predict(logreg_cls_fit, data_test, type = "prob") )

With the "stan" engine

Classification Example (stan)

r knitr::spin_child("template-cls-two-class.R")

We can define the model with specific parameters:

r logreg_cls_spec <- logistic_reg() %>% set_engine("stan") logreg_cls_spec

Now we create the model fit object:

r set.seed(1) logreg_cls_fit <- logreg_cls_spec %>% fit(Class ~ ., data = data_train) logreg_cls_fit

The holdout data can be predicted for both hard class predictions and probabilities. We'll bind these together into one tibble:

r bind_cols( predict(logreg_cls_fit, data_test), predict(logreg_cls_fit, data_test, type = "prob") )

With the "brulee" engine

Classification Example (brulee)

r knitr::spin_child("template-cls-two-class.R")

We can define the model with specific parameters:

r logreg_cls_spec <- logistic_reg() %>% set_engine("brulee") logreg_cls_spec

Now we create the model fit object:

r set.seed(1) logreg_cls_fit <- logreg_cls_spec %>% fit(Class ~ ., data = data_train) logreg_cls_fit

The holdout data can be predicted for both hard class predictions and probabilities. We'll bind these together into one tibble:

r bind_cols( predict(logreg_cls_fit, data_test), predict(logreg_cls_fit, data_test, type = "prob") )

mars() models

With the "earth" engine

Regression Example (earth)

r knitr::spin_child("template-reg-chicago.R")

We can define the model with specific parameters:

r mars_reg_spec <- mars(prod_degree = 1, prune_method = "backward") %>% # This model can be used for classification or regression, so set mode set_mode("regression") %>% set_engine("earth") mars_reg_spec

Now we create the model fit object:

r set.seed(1) mars_reg_fit <- mars_reg_spec %>% fit(ridership ~ ., data = Chicago_train) mars_reg_fit

The holdout data can be predicted:

r predict(mars_reg_fit, Chicago_test)

Classification Example (earth)

r knitr::spin_child("template-cls-two-class.R")

We can define the model with specific parameters:

r mars_cls_spec <- mars(prod_degree = 1, prune_method = "backward") %>% # This model can be used for classification or regression, so set mode set_mode("classification") %>% set_engine("earth") mars_cls_spec

Now we create the model fit object:

r set.seed(1) mars_cls_fit <- mars_cls_spec %>% fit(Class ~ ., data = data_train) mars_cls_fit

The holdout data can be predicted for both hard class predictions and probabilities. We'll bind these together into one tibble:

r bind_cols( predict(mars_cls_fit, data_test), predict(mars_cls_fit, data_test, type = "prob") )

mlp() models

With the "nnet" engine

Regression Example (nnet)

r knitr::spin_child("template-reg-chicago.R")

We can define the model with specific parameters:

r mlp_reg_spec <- mlp(penalty = 0, epochs = 100) %>% # This model can be used for classification or regression, so set mode set_mode("regression") %>% set_engine("nnet") mlp_reg_spec

Now we create the model fit object:

r set.seed(1) mlp_reg_fit <- mlp_reg_spec %>% fit(ridership ~ ., data = Chicago_train) mlp_reg_fit

The holdout data can be predicted:

r predict(mlp_reg_fit, Chicago_test)

Classification Example (nnet)

r knitr::spin_child("template-cls-two-class.R")

We can define the model with specific parameters:

r mlp_cls_spec <- mlp(penalty = 0, epochs = 100) %>% # This model can be used for classification or regression, so set mode set_mode("classification") %>% set_engine("nnet") mlp_cls_spec

Now we create the model fit object:

r set.seed(1) mlp_cls_fit <- mlp_cls_spec %>% fit(Class ~ ., data = data_train) mlp_cls_fit

The holdout data can be predicted for both hard class predictions and probabilities. We'll bind these together into one tibble:

r bind_cols( predict(mlp_cls_fit, data_test), predict(mlp_cls_fit, data_test, type = "prob") )

With the "keras" engine

Regression Example (keras)

r knitr::spin_child("template-reg-chicago.R")

We can define the model with specific parameters:

r mlp_reg_spec <- mlp(penalty = 0, epochs = 20) %>% # This model can be used for classification or regression, so set mode set_mode("regression") %>% set_engine("keras") mlp_reg_spec

Now we create the model fit object:

r set.seed(1) mlp_reg_fit <- mlp_reg_spec %>% fit(ridership ~ ., data = Chicago_train) mlp_reg_fit

The holdout data can be predicted:

r predict(mlp_reg_fit, Chicago_test)

Classification Example (keras)

r knitr::spin_child("template-cls-two-class.R")

We can define the model with specific parameters:

r mlp_cls_spec <- mlp(penalty = 0, epochs = 20) %>% # This model can be used for classification or regression, so set mode set_mode("classification") %>% set_engine("keras") mlp_cls_spec

Now we create the model fit object:

r set.seed(1) mlp_cls_fit <- mlp_cls_spec %>% fit(Class ~ ., data = data_train) mlp_cls_fit

The holdout data can be predicted for both hard class predictions and probabilities. We'll bind these together into one tibble:

r bind_cols( predict(mlp_cls_fit, data_test), predict(mlp_cls_fit, data_test, type = "prob") )

With the "brulee" engine

Regression Example (brulee)

r knitr::spin_child("template-reg-chicago.R")

We can define the model with specific parameters:

r mlp_reg_spec <- mlp(penalty = 0, epochs = 100) %>% # This model can be used for classification or regression, so set mode set_mode("regression") %>% set_engine("brulee") mlp_reg_spec

Now we create the model fit object:

r set.seed(1) mlp_reg_fit <- mlp_reg_spec %>% fit(ridership ~ ., data = Chicago_train) mlp_reg_fit

The holdout data can be predicted:

r predict(mlp_reg_fit, Chicago_test)

Classification Example (brulee)

r knitr::spin_child("template-cls-two-class.R")

We can define the model with specific parameters:

r mlp_cls_spec <- mlp(penalty = 0, epochs = 100) %>% # This model can be used for classification or regression, so set mode set_mode("classification") %>% set_engine("brulee") mlp_cls_spec

Now we create the model fit object:

r set.seed(1) mlp_cls_fit <- mlp_cls_spec %>% fit(Class ~ ., data = data_train) mlp_cls_fit

The holdout data can be predicted for both hard class predictions and probabilities. We'll bind these together into one tibble:

r bind_cols( predict(mlp_cls_fit, data_test), predict(mlp_cls_fit, data_test, type = "prob") )

With the "brulee_two_layer" engine

Regression Example (brulee_two_layer)

r knitr::spin_child("template-reg-chicago.R")

We can define the model with specific parameters:

r mlp_reg_spec <- mlp(penalty = 0, epochs = 10) %>% # This model can be used for classification or regression, so set mode set_mode("regression") %>% set_engine("brulee_two_layer", hidden_units_2 = 2) mlp_reg_spec

Now we create the model fit object:

r set.seed(13) mlp_reg_fit <- mlp_reg_spec %>% fit(ridership ~ ., data = Chicago_train) mlp_reg_fit

The holdout data can be predicted:

r predict(mlp_reg_fit, Chicago_test)

Classification Example (brulee_two_layer)

r knitr::spin_child("template-cls-two-class.R")

We can define the model with specific parameters:

r mlp_cls_spec <- mlp(penalty = 0, epochs = 10) %>% # This model can be used for classification or regression, so set mode set_mode("classification") %>% set_engine("brulee_two_layer", hidden_units_2 = 2) mlp_cls_spec

Now we create the model fit object:

r set.seed(12) mlp_cls_fit <- mlp_cls_spec %>% fit(Class ~ ., data = data_train) mlp_cls_fit

The holdout data can be predicted for both hard class predictions and probabilities. We'll bind these together into one tibble:

r bind_cols( predict(mlp_cls_fit, data_test), predict(mlp_cls_fit, data_test, type = "prob") )

multinom_reg() models

With the "glmnet" engine

Classification Example (glmnet)

r knitr::spin_child("template-cls-multi-class.R")

We can define the model with specific parameters:

r mr_cls_spec <- multinom_reg(penalty = 0.1) %>% set_engine("glmnet") mr_cls_spec

Now we create the model fit object:

r set.seed(1) mr_cls_fit <- mr_cls_spec %>% fit(island ~ ., data = penguins_train) mr_cls_fit

The holdout data can be predicted for both hard class predictions and probabilities. We'll bind these together into one tibble:

r bind_cols( predict(mr_cls_fit, penguins_test), predict(mr_cls_fit, penguins_test, type = "prob") )

With the "keras" engine

Classification Example (keras)

r knitr::spin_child("template-cls-multi-class.R")

We can define the model with specific parameters:

r mr_cls_spec <- multinom_reg(penalty = 0.1) %>% set_engine("keras") mr_cls_spec

Now we create the model fit object:

r set.seed(1) mr_cls_fit <- mr_cls_spec %>% fit(island ~ ., data = penguins_train) mr_cls_fit

The holdout data can be predicted for both hard class predictions and probabilities. We'll bind these together into one tibble:

r bind_cols( predict(mr_cls_fit, penguins_test), predict(mr_cls_fit, penguins_test, type = "prob") )

With the "nnet" engine

Classification Example (nnet)

r knitr::spin_child("template-cls-multi-class.R")

We can define the model with specific parameters:

r mr_cls_spec <- multinom_reg(penalty = 0.1) %>% set_engine("nnet") mr_cls_spec

Now we create the model fit object:

r set.seed(1) mr_cls_fit <- mr_cls_spec %>% fit(island ~ ., data = penguins_train) mr_cls_fit

The holdout data can be predicted for both hard class predictions and probabilities. We'll bind these together into one tibble:

r bind_cols( predict(mr_cls_fit, penguins_test), predict(mr_cls_fit, penguins_test, type = "prob") )

With the "brulee" engine

Classification Example (brulee)

r knitr::spin_child("template-cls-multi-class.R")

We can define the model with specific parameters:

r mr_cls_spec <- multinom_reg(penalty = 0.1) %>% set_engine("brulee") mr_cls_spec

Now we create the model fit object:

r set.seed(1) mr_cls_fit <- mr_cls_spec %>% fit(island ~ ., data = penguins_train) mr_cls_fit

The holdout data can be predicted for both hard class predictions and probabilities. We'll bind these together into one tibble:

r bind_cols( predict(mr_cls_fit, penguins_test), predict(mr_cls_fit, penguins_test, type = "prob") )

nearest_neighbor() models

With the "kknn" engine

Regression Example (kknn)

r knitr::spin_child("template-reg-chicago.R")

We can define the model with specific parameters:

r knn_reg_spec <- nearest_neighbor(neighbors = 5, weight_func = "triangular") %>% # This model can be used for classification or regression, so set mode set_mode("regression") %>% set_engine("kknn") knn_reg_spec

Now we create the model fit object:

r knn_reg_fit <- knn_reg_spec %>% fit(ridership ~ ., data = Chicago_train) knn_reg_fit

The holdout data can be predicted:

r predict(knn_reg_fit, Chicago_test)

Classification Example (kknn)

r knitr::spin_child("template-cls-two-class.R")

Since there are two classes, we'll use an odd number of neighbors to avoid ties:

r knn_cls_spec <- nearest_neighbor(neighbors = 11, weight_func = "triangular") %>% # This model can be used for classification or regression, so set mode set_mode("classification") %>% set_engine("kknn") knn_cls_spec

Now we create the model fit object:

r knn_cls_fit <- knn_cls_spec %>% fit(Class ~ ., data = data_train) knn_cls_fit

The holdout data can be predicted for both hard class predictions and probabilities. We'll bind these together into one tibble:

r bind_cols( predict(knn_cls_fit, data_test), predict(knn_cls_fit, data_test, type = "prob") )

rand_forest() models

With the "ranger" engine

Regression Example (ranger)

r knitr::spin_child("template-reg-chicago.R")

We can define the model with specific parameters:

r rf_reg_spec <- rand_forest(trees = 200, min_n = 5) %>% # This model can be used for classification or regression, so set mode set_mode("regression") %>% set_engine("ranger") rf_reg_spec

Now we create the model fit object:

r set.seed(1) rf_reg_fit <- rf_reg_spec %>% fit(ridership ~ ., data = Chicago_train) rf_reg_fit

The holdout data can be predicted:

r predict(rf_reg_fit, Chicago_test)

Classification Example (ranger)

r knitr::spin_child("template-cls-two-class.R")

We can define the model with specific parameters:

r rf_cls_spec <- rand_forest(trees = 200, min_n = 5) %>% # This model can be used for classification or regression, so set mode set_mode("classification") %>% set_engine("ranger") rf_cls_spec

Now we create the model fit object:

r set.seed(1) rf_cls_fit <- rf_cls_spec %>% fit(Class ~ ., data = data_train) rf_cls_fit

The holdout data can be predicted for both hard class predictions and probabilities. We'll bind these together into one tibble:

r bind_cols( predict(rf_cls_fit, data_test), predict(rf_cls_fit, data_test, type = "prob") )

With the "randomForest" engine

Regression Example (randomForest)

r knitr::spin_child("template-reg-chicago.R")

We can define the model with specific parameters:

r rf_reg_spec <- rand_forest(trees = 200, min_n = 5) %>% # This model can be used for classification or regression, so set mode set_mode("regression") %>% set_engine("randomForest") rf_reg_spec

Now we create the model fit object:

r set.seed(1) rf_reg_fit <- rf_reg_spec %>% fit(ridership ~ ., data = Chicago_train) rf_reg_fit

The holdout data can be predicted:

r predict(rf_reg_fit, Chicago_test)

Classification Example (randomForest)

r knitr::spin_child("template-cls-two-class.R")

We can define the model with specific parameters:

r rf_cls_spec <- rand_forest(trees = 200, min_n = 5) %>% # This model can be used for classification or regression, so set mode set_mode("classification") %>% set_engine("randomForest") rf_cls_spec

Now we create the model fit object:

r set.seed(1) rf_cls_fit <- rf_cls_spec %>% fit(Class ~ ., data = data_train) rf_cls_fit

The holdout data can be predicted for both hard class predictions and probabilities. We'll bind these together into one tibble:

r bind_cols( predict(rf_cls_fit, data_test), predict(rf_cls_fit, data_test, type = "prob") )

svm_linear() models

With the "LiblineaR" engine

Regression Example (LiblineaR)

r knitr::spin_child("template-reg-chicago.R")

We can define the model with specific parameters:

r svm_reg_spec <- svm_linear(cost = 1, margin = 0.1) %>% # This model can be used for classification or regression, so set mode set_mode("regression") %>% set_engine("LiblineaR") svm_reg_spec

Now we create the model fit object:

r set.seed(1) svm_reg_fit <- svm_reg_spec %>% fit(ridership ~ ., data = Chicago_train) svm_reg_fit

The holdout data can be predicted:

r predict(svm_reg_fit, Chicago_test)

Classification Example (LiblineaR)

r knitr::spin_child("template-cls-two-class.R")

We can define the model with specific parameters:

r svm_cls_spec <- svm_linear(cost = 1) %>% # This model can be used for classification or regression, so set mode set_mode("classification") %>% set_engine("LiblineaR") svm_cls_spec

Now we create the model fit object:

r set.seed(1) svm_cls_fit <- svm_cls_spec %>% fit(Class ~ ., data = data_train) svm_cls_fit

The holdout data can be predicted for hard class predictions.

r predict(svm_cls_fit, data_test)

With the "kernlab" engine

Regression Example (kernlab)

r knitr::spin_child("template-reg-chicago.R")

We can define the model with specific parameters:

r svm_reg_spec <- svm_linear(cost = 1, margin = 0.1) %>% # This model can be used for classification or regression, so set mode set_mode("regression") %>% set_engine("kernlab") svm_reg_spec

Now we create the model fit object:

r set.seed(1) svm_reg_fit <- svm_reg_spec %>% fit(ridership ~ ., data = Chicago_train) svm_reg_fit

The holdout data can be predicted:

r predict(svm_reg_fit, Chicago_test)

Classification Example (kernlab)

r knitr::spin_child("template-cls-two-class.R")

We can define the model with specific parameters:

r svm_cls_spec <- svm_linear(cost = 1) %>% # This model can be used for classification or regression, so set mode set_mode("classification") %>% set_engine("kernlab") svm_cls_spec

Now we create the model fit object:

r set.seed(1) svm_cls_fit <- svm_cls_spec %>% fit(Class ~ ., data = data_train) svm_cls_fit

The holdout data can be predicted for both hard class predictions and probabilities. We'll bind these together into one tibble:

r bind_cols( predict(svm_cls_fit, data_test), predict(svm_cls_fit, data_test, type = "prob") )

svm_poly() models

With the "kernlab" engine

Regression Example (kernlab)

r knitr::spin_child("template-reg-chicago.R")

We can define the model with specific parameters:

r svm_reg_spec <- svm_poly(cost = 1, margin = 0.1) %>% # This model can be used for classification or regression, so set mode set_mode("regression") %>% set_engine("kernlab") svm_reg_spec

Now we create the model fit object:

r set.seed(1) svm_reg_fit <- svm_reg_spec %>% fit(ridership ~ ., data = Chicago_train) svm_reg_fit

The holdout data can be predicted:

r predict(svm_reg_fit, Chicago_test)

Classification Example (kernlab)

r knitr::spin_child("template-cls-two-class.R")

We can define the model with specific parameters:

r svm_cls_spec <- svm_poly(cost = 1) %>% # This model can be used for classification or regression, so set mode set_mode("classification") %>% set_engine("kernlab") svm_cls_spec

Now we create the model fit object:

r set.seed(1) svm_cls_fit <- svm_cls_spec %>% fit(Class ~ ., data = data_train) svm_cls_fit

The holdout data can be predicted for both hard class predictions and probabilities. We'll bind these together into one tibble:

r bind_cols( predict(svm_cls_fit, data_test), predict(svm_cls_fit, data_test, type = "prob") )

svm_rbf() models

With the "kernlab" engine

Regression Example (kernlab)

r knitr::spin_child("template-reg-chicago.R")

We can define the model with specific parameters:

r svm_reg_spec <- svm_rbf(cost = 1, margin = 0.1) %>% # This model can be used for classification or regression, so set mode set_mode("regression") %>% set_engine("kernlab") svm_reg_spec

Now we create the model fit object:

r set.seed(1) svm_reg_fit <- svm_reg_spec %>% fit(ridership ~ ., data = Chicago_train) svm_reg_fit

The holdout data can be predicted:

r predict(svm_reg_fit, Chicago_test)

Classification Example (kernlab)

r knitr::spin_child("template-cls-two-class.R")

We can define the model with specific parameters:

r svm_cls_spec <- svm_rbf(cost = 1) %>% # This model can be used for classification or regression, so set mode set_mode("classification") %>% set_engine("kernlab") svm_cls_spec

Now we create the model fit object:

r set.seed(1) svm_cls_fit <- svm_cls_spec %>% fit(Class ~ ., data = data_train) svm_cls_fit

The holdout data can be predicted for both hard class predictions and probabilities. We'll bind these together into one tibble:

r bind_cols( predict(svm_cls_fit, data_test), predict(svm_cls_fit, data_test, type = "prob") )

tidymodels/parsnip documentation built on Feb. 19, 2025, 2:10 a.m.