chapter-14.Rmd

# Classification Trees and Rule-Based Models

```{r chapter-14-startup, include = FALSE}
knitr::opts_chunk$set(fig.path = "figures/")
library(rpart)
library(ranger)
library(baguette)
library(C50)
library(rlang)
library(vctrs)
library(tidymodels)

caching <- TRUE

cores <- parallel::detectCores()
if (!grepl("mingw32", R.Version()$platform)) {
 library(doMC)
 registerDoMC(cores = cores)
} else {
  library(doParallel)
  cl <- makePSOCKcluster(cores)
  registerDoParallel(cl)
}

source("extras/overlay_roc_curves.R")
```


The R packages used in this chapter are: `r pkg_text(c("tidymodels", "C50", "rpart", "baguette",
"xgboost", "ranger"))`. 



```{r chapter-14-data}
library(tidymodels)
data(grants)

ls(pattern = "grants")

load("RData/grants_split.RData")

grants_split
nrow(grants_test)
```



##  Basic Classification Trees

use cart to show how to get dummy variables or not with trees

```{r chapter-14-tree-preproc}
library(workflowsets)
tree_ind_rec <- 
 recipe(class ~ ., data = grants_other) %>% 
 step_dummy(all_nominal_predictors(), one_hot = TRUE) %>% 
 step_zv(all_predictors())

tree_vars <- selectors(outcomes = class, predictors = everything())
```

```{r chapter-14-cart, cache = caching}
cart_spec <-
 decision_tree(cost_complexity = tune(), min_n = tune()) %>% 
 set_mode("classification") %>% 
 set_engine("rpart")

cart_grid <-
        tidyr::crossing(
          cost_complexity = 10 ^ seq(-4, 0, length.out = 20),
          min_n = (1:10) * 2
        )

gd_ctrl <- control_grid(save_pred = TRUE, save_workflow = TRUE, 
                             parallel_over = "everything")

cart_wflow_set <- 
 workflow_set(
  preproc = list(none = tree_vars, indicators = tree_ind_rec),
  models =  list(cart = cart_spec),
  cross = TRUE
 ) %>% 
 workflow_map(resamples = grants_split, seed = 1401, grid = cart_grid,
              control = gd_ctrl, verbose = TRUE)
```

```{r chapter-14-cart-plot}
autoplot(cart_wflow_set, metric = "roc_auc") + facet_wrap(~ wflow_id)
```



```{r chapter-14-cart-results}
cart_wflow_set %>% 
  mutate(metrics = map(result, collect_metrics)) %>% 
  select(wflow_id, preproc, metrics) %>% 
  unnest(cols = metrics)  %>% 
  filter(.metric == "roc_auc") %>% 
  mutate(`cost_complexity (log-10)` = log10(cost_complexity)) %>% 
  select(`cost_complexity (log-10)`, min_n, mean, preproc, wflow_id) %>% 
  pivot_longer(
    cols = c(`cost_complexity (log-10)`, min_n),
    values_to = "value",
    names_to = "parameter"
  ) %>%
  ggplot(aes(x = value, y = mean, col = preproc)) + 
  geom_point(alpha = .3) + 
  facet_wrap(~ parameter, scales = "free_x")
```




```{r chapter-14-fig-05}
model_predictions <- 
  cart_wflow_set %>% 
  collect_predictions(select_best = TRUE, metric = "roc_auc")  

overlay_roc_curves(model_predictions, highlight = "indicators_cart") 
```


## Rule-Based Models


```{r chapter-14-c5-rules, cache = caching}
library(rules)
rules_spec <-
 C5_rules(min_n = tune()) %>% 
 set_mode("classification") %>% 
 set_engine("C5.0")

rules_grid <- tibble(min_n = 1:10)

rules_wflow <- 
 workflow() %>% 
 add_model(rules_spec) %>% 
 add_variables(outcomes = class, predictors = everything())

set.seed(1401)
rules_tune <- 
 rules_wflow %>% 
 tune_grid(resamples = grants_split, grid = rules_grid,
              control = gd_ctrl)
```


```{r chapter-14-rule-plot}
autoplot(rules_tune, metric = "roc_auc")
```

```{r chapter-14-rules-roc}
model_predictions <- 
  as_workflow_set(none_rules = rules_tune) %>% 
  collect_predictions(select_best = TRUE, metric = "roc_auc") %>% 
  bind_rows(model_predictions)

overlay_roc_curves(model_predictions, highlight = "none_rules") 
```


## Bagged Trees

```{r chapter-14-bagging-cart, cache = caching}
cart_bag_spec <-
 bag_tree() %>% 
 set_mode("classification") %>% 
 set_engine("rpart", times = 50)

cart_bag_wflow <- 
 workflow() %>% 
 add_model(cart_bag_spec) %>% 
 add_variables(outcomes = class, predictors = everything())

rs_ctrl <- control_resamples(save_pred = TRUE, save_workflow = TRUE)

set.seed(1401)
cart_bag_resamp <- 
 cart_bag_wflow %>% 
 fit_resamples(resamples = grants_split,  control = rs_ctrl)
```


```{r chapter-14-fig-07}
model_predictions <- 
  as_workflow_set(none_cart_bag = cart_bag_resamp) %>% 
  collect_predictions(select_best = TRUE, metric = "roc_auc") %>% 
  bind_rows(model_predictions)

overlay_roc_curves(model_predictions, highlight = "none_cart_bag") 
```


## Random Forests


```{r chapter-14-rf, cache = caching}
rf_spec <-
 rand_forest(mtry = tune(), min_n = tune(), trees = 100) %>% 
 set_mode("classification") %>% 
 set_engine("ranger")

rf_wflow <- 
 workflow() %>% 
 add_model(rf_spec) %>% 
 add_variables(outcomes = class, predictors = everything())

set.seed(1401)
rf_tune <- 
 rf_wflow %>% 
 tune_grid(resamples = grants_split, grid = 25, control = gd_ctrl)
```


```{r chapter-14-rf-plot}
autoplot(rf_tune, metric = "roc_auc")
```

```{r chapter-14-fig-08}
model_predictions <- 
  as_workflow_set(none_rf = rf_tune) %>% 
  collect_predictions(select_best = TRUE, metric = "roc_auc") %>% 
  bind_rows(model_predictions)

overlay_roc_curves(model_predictions, highlight = "none_rf") 
```


## Boosting


```{r chapter-14-xgb, cache = caching}
xgboost_spec <-
 boost_tree(min_n = tune(), trees = tune(), tree_depth = tune(), 
            learn_rate = tune(), loss_reduction = tune(), sample_size = tune()) %>% 
 set_mode("classification") %>% 
 set_engine("xgboost")

xgboost_wflow <- 
 workflow() %>% 
 add_model(xgboost_spec) %>% 
 add_recipe(tree_ind_rec)

set.seed(1401)
xgboost_tune <- 
 xgboost_wflow %>% 
 tune_grid(resamples = grants_split, grid = 25, control = gd_ctrl)
```

one point at 0.50

```{r chapter-14-xgb-plot, warning = FALSE}
autoplot(xgboost_tune, metric = "roc_auc") + ylim(c(.85, .95))
```

```{r chapter-14-fig-09}
model_predictions <- 
  as_workflow_set(none_xgboost = xgboost_tune) %>% 
  collect_predictions(select_best = TRUE, metric = "roc_auc") %>% 
  bind_rows(model_predictions)

overlay_roc_curves(model_predictions, highlight = "none_xgboost") 
```



## C5.0



```{r chapter-14-c50, cache = caching}
C5_spec <-
 boost_tree(min_n = tune(), trees = tune()) %>% 
 set_mode("classification") %>% 
 set_engine("C5.0")

C5_wflow <- 
 workflow() %>% 
 add_model(C5_spec) %>% 
 add_variables(outcomes = class, predictors = everything())

set.seed(1401)
C5_tune <- 
 C5_wflow %>% 
 tune_grid(resamples = grants_split, grid = 25, control = gd_ctrl)
```


```{r chapter-14-fig-13-a}
autoplot(C5_tune, metric = "roc_auc")
```

```{r chapter-14-fig-13-b}
model_predictions <- 
  as_workflow_set(none_C5 = C5_tune) %>% 
  collect_predictions(select_best = TRUE, metric = "roc_auc") %>% 
  bind_rows(model_predictions)

overlay_roc_curves(model_predictions, highlight = "none_C5") 
```


```{r chapter-14-teardown, include = FALSE}
if (grepl("mingw32", R.Version()$platform)) {
 stopCluster(cl)
} 

save(C5_tune, cart_wflow_set, cart_wflow_set, rf_tune, rules_tune, 
     xgboost_tune, cart_bag_resamp,
     version = 2, compress = "xz", file = "RData/chapter_14.RData")
```