Blog Post 4 - An Introduction To Tidymodels

Packages

We’ll load five packages: tidymodes, kableExtra, tidyverse, skimr and tibble. Tidymodels will be the star of this post.

library(tidymodels)
library(kableExtra)
library(tidyverse)
library(skimr)
library(tibble)

Data

We will use customer churn data for our analysis. After loading the data and the skimr package provides us a great data overview.

Skimr is a great package and we see that we have a pretty clean data set, with only a handful of missing values (TotalCharges).

telco <- readr::read_csv("WA_Fn-UseC_-Telco-Customer-Churn.csv")

telco %>% 
  skimr::skim()

Variable type: character

Variable type: numeric

Train Test Split

resample is a core package in tidymodels. It provides a streamlined way to create a randmised training and test split of the original data. If we want to achieve an 80:20 split the inputs to the resample function are straightforward: data = telco, prop = 0.80. We also set a seed so we can reproduce the results. With that we get an 80:20 split - of the 7,043 total customers, 5,626 have been assigned to the training set and 1,406 to the test set. We now have created our training set = train_tbl and our test set = test_tbl. That was easy.

set.seed(seed = 4763) 
train_test_split <-
  rsample::initial_split(
    data = telco,     
    prop = 0.80   
  ) 
train_test_split

## <Training/Validation/Total>
## <5635/1408/7043>

train_tbl <- train_test_split %>% training() 
test_tbl  <- train_test_split %>% testing()

Recipes

tidymodels via the recipes package uses a cooking metaphor for data preprocessing - missing values, imputation, centering and scaling and one-hot-encoding.

The first step is to create our recipe. This is were we will define the transformations we want to apply to our data. For our blog post we’ll simply change all of the characters variables to factors, but there a lot more we could do.

Next we prep the recipe by mixing transforms with the data. This can all be included in a function.

recipe_simple <- function(dataset) {
  recipe(Churn ~ ., data = dataset) %>%
    step_string2factor(all_nominal(), -all_outcomes()) %>%
    prep(data = dataset)
}

recipe_prepped <- recipe_simple(dataset= train_tbl)

The final step in the process, to continue with the cooking metaphor, is to bake the recipe. This is how our preprocessing steps are applied to the data.

train_baked <- bake(recipe_prepped, new_data = train_tbl)
test_baked  <- bake(recipe_prepped, new_data = test_tbl)

Build The Model

tidymodels leans on the parsnip package for its model building. parsnip offers a unified API that allows access to a variety of analytic packages without the requirement of learning the syntax for each package. It only takes three simple steps to fit models:

• Pick the type of Model - we are going to use logistic regression
• Specify the engin - we’ll use glm
• Define the model specification / formula and data - We’ll use MonthChargesk, tenure and gender

logistic_glm<-
  logistic_reg(mode="classification") %>% 
  set_engine("glm") %>% 
  fit(Churn ~ MonthlyCharges + tenure + gender, data = train_baked)

If we wanted to switch to a different engine, all we would have to do change the set_engine argument to the desired tool and parsnip handles all dirty work behind the scenes - I said unified API!

• set_engine(“glmnet”)
• set_engine(“lm”)
• set_engine(“spark”)
• set_engine(“keras”)

There’s a long list of engines we can use.

Model Evaluation

After building our model, its time to evaluation the results. This is where the yardstick packages comes in. yardstick provide a simple way to calculate several popular assessment measures. But before we can do that we’ll need some predictions. We get our predictions by passing the test_baked data to the predict function

predictions_glm <- logistic_glm %>%
  predict(new_data = test_baked) %>%
  bind_cols(test_baked %>% select(Churn))

Now with our freshly minted predictions there are several metrics that can be used to evaluate the performance of our classification model. For the sake of simplicity we will focus on some the metrics I introduced in Blog Post 3 - Accuracy, Precision Recall and F1_Score. You may remember that all these measures are derived from the Confusion Matirx, a table that describes the performance of a classification model.

Refer back to Blog Post 3 if you need a refresher on the Confusion Matrix.

Tah Dah

Now with just a few more lines of code with have a Confussion Matrix that can be leveraged to calculate additional metrics.

predictions_glm %>%
  conf_mat(Churn, .pred_class) %>%
  pluck(1) %>%
  as_tibble() %>%
  ggplot(aes(Prediction, Truth, alpha = n)) +
  geom_tile(show.legend = FALSE) +
  geom_text(aes(label = n), colour = "white", alpha = 1, size = 8)

predictions_glm %>%
  metrics(Churn, .pred_class) %>%
  select(-.estimator) %>%
  filter(.metric == "accuracy") 

## # A tibble: 1 x 2
##   .metric  .estimate
##   <chr>        <dbl>
## 1 accuracy     0.786

tibble(
  "precision" = 
     precision(predictions_glm, Churn, .pred_class) %>%
     select(.estimate),
  "recall" = 
     recall(predictions_glm, Churn, .pred_class) %>%
     select(.estimate)
) %>%
  unnest() %>%
  kable()

## Warning: `cols` is now required.
## Please use `cols = c(precision, recall)`

predictions_glm %>%
  f_meas(Churn, .pred_class) %>%
  select(-.estimator) %>%
  kable()

Wrap Up

That a quick introuduction to tidymodels. I you are interested in a more detailed explanation you might want to checkout the talk at the recent: rstudioConference

Thanks for reading.