---
title: "Classification Models With stacks"
output: rmarkdown::html_vignette
vignette: >
  %\VignetteIndexEntry{Classification Models With stacks}
  %\VignetteEngine{knitr::rmarkdown}
  %\VignetteEncoding{UTF-8}
---

```{r}
#| include: false
knitr::opts_chunk$set(
  collapse = TRUE,
  comment = "#>"
)
```

In this vignette, we'll tackle a multiclass classification problem using the stacks package. This vignette assumes that you're familiar with tidymodels "proper," as well as the basic grammar of the package, and have seen it implemented on numeric data; if this is not the case, check out the "Getting Started With stacks" vignette!

```{r}
#| label: setup
#| eval: false
library(tidymodels)
library(stacks)
```

```{r}
#| label: packages
#| include: false
library(tune)
library(rsample)
library(parsnip)
library(workflows)
library(recipes)
library(stacks)
library(purrr)
library(dplyr)
library(tidyr)
library(ggplot2)
```

```{r}
#| include: false
if (rlang::is_installed("ranger") && 
    rlang::is_installed("nnet") &&
    rlang::is_installed("kernlab") &&
    rlang::is_installed("yardstick")) {
  run <- TRUE
  library(yardstick)
} else {
  run <- FALSE
}

knitr::opts_chunk$set(
  eval = run
)
```


In this example, we'll make use of the `tree_frogs` data exported with `stacks`, giving experimental results on hatching behavior of 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!

In this article, we'll use most all of the variables in `tree_frogs` to predict `reflex`, a measure of ear function called the vestibulo-ocular reflex (VOR), categorized into bins. Ear function increases from factor levels "low", to "mid", to "full".

```{r}
#| message: false
#| warning: false
data("tree_frogs")

# subset the data
tree_frogs <- tree_frogs |>
  select(-c(clutch, latency))
```

Let's plot the data to get a sense for how separable these groups are.

```{r}
#| message: false
#| warning: false
#| fig-alt: 'A ggplot scatterplot with categorical variable treatment, embryo age in
#|   seconds on the y axis, and points colored by response. The ages range from 350,000
#|   to 500,000 seconds, and the two treatments are control and gentamicin. There are
#|   three responses: low, mid, and full. All of the embryos beyond a certain age have
#|   a full response, while the low and mid responses are well-intermixed regardless
#|   of age or treatment.'
theme_set(theme_bw())

ggplot(tree_frogs) +
  aes(x = treatment, y = age, color = reflex) +
  geom_jitter() +
  labs(
    y = "Embryo Age (s)",
    x = "treatment",
    color = "Response"
  )
```

It looks like the embryo age is pretty effective at picking out embryos with full VOR function, but the problem gets tougher for the less developed embryos! Let's see how well the stacked ensemble can classify these tree frogs.

# Defining candidate ensemble members

As in the numeric prediction setting, defining the candidate ensemble members is undoubtedly the longest part of the ensembling process with stacks. First, splitting up the training data, generating resamples, and setting some options that will be used by each model definition.

```{r}
# some setup: resampling and a basic recipe
set.seed(1)

tree_frogs_split <- initial_split(tree_frogs)
tree_frogs_train <- training(tree_frogs_split)
tree_frogs_test  <- testing(tree_frogs_split)

folds <- rsample::vfold_cv(tree_frogs_train, v = 5)

tree_frogs_rec <- 
  recipe(reflex ~ ., data = tree_frogs_train) |>
  step_dummy(all_nominal_predictors(), -reflex) |>
  step_zv(all_predictors())

tree_frogs_wflow <- 
  workflow() |> 
  add_recipe(tree_frogs_rec)
```

We also need to use the same control settings as in the numeric response setting:

```{r}
ctrl_grid <- control_stack_grid()
```

We'll define two different model definitions to try to predict `reflex`—a random forest and a neural network.

Starting out with a random forest:

```{r}
#| message: false
#| warning: false
rand_forest_spec <- 
  rand_forest(
    mtry = tune(),
    min_n = tune(),
    trees = 500
  ) |>
  set_mode("classification") |>
  set_engine("ranger")

rand_forest_wflow <-
  tree_frogs_wflow |>
  add_model(rand_forest_spec)

rand_forest_res <- 
  tune_grid(
    object = rand_forest_wflow, 
    resamples = folds, 
    grid = 10,
    control = ctrl_grid
  )
```

Now, moving on to the neural network model definition:

```{r}
#| message: false
#| warning: false
nnet_spec <-
  mlp(hidden_units = tune(), penalty = tune(), epochs = tune()) |>
  set_mode("classification") |>
  set_engine("nnet")

nnet_rec <- 
  tree_frogs_rec |> 
  step_normalize(all_predictors())

nnet_wflow <- 
  tree_frogs_wflow |>
  add_model(nnet_spec) |>
  update_recipe(nnet_rec)

nnet_res <-
  tune_grid(
    object = nnet_wflow, 
    resamples = folds, 
    grid = 10,
    control = ctrl_grid
  )
```

With these model definitions fully specified, we're ready to start putting together an ensemble!

# Putting together a stack

Building the stacked ensemble, now, only takes a few lines:

```{r}
#| message: false
#| warning: false
tree_frogs_model_st <- 
  # initialize the stack
  stacks() |>
  # add candidate members
  add_candidates(rand_forest_res) |>
  add_candidates(nnet_res) |>
  # determine how to combine their predictions
  blend_predictions() |>
  # fit the candidates with nonzero stacking coefficients
  fit_members()

tree_frogs_model_st
```

To make sure that we have the right trade-off between minimizing the number of members and optimizing performance, we can use the `autoplot()` method: 

```{r}
#| label: penalty-plot
#| fig-alt: 'A ggplot line plot. The x axis shows the degree of penalization, ranging
#|   from 1e-06 to 1e-01, and the y axis displays the mean of three different metrics.
#|   The plots are faceted by metric type, with three facets: accuracy, number of members,
#|   and ROC AUC. The plots generally show that, as penalization increases, the error
#|   increases, though fewer members are included in the model. A dashed line at a penalty
#|   of 1e-05 indicates that the stack has chosen a smaller degree of penalization.'
autoplot(tree_frogs_model_st)
```

To show the relationship more directly: 

```{r}
#| label: members-plot
#| fig-alt: A similarly formatted ggplot line plot, showing that greater numbers of members
#|   result in higher accuracy.
autoplot(tree_frogs_model_st, type = "members")
```

If these results were not good enough, `blend_predictions()` could be called again with different values of `penalty`. As it is, `blend_predictions()` picks the penalty parameter with the numerically optimal results. To see the top results: 

```{r}
#| label: weight-plot
#| fig-alt: A ggplot bar plot, giving the stacking coefficient on the x axis and member
#|   on the y axis. Bars corresponding to neural networks are shown in red, while random
#|   forest bars are shown in blue. Generally, the neural network tends to accentuate
#|   features of the 'low' response, while the random forest does so for the 'mid' response.
autoplot(tree_frogs_model_st, type = "weights")
```

There are multiple facets since the ensemble members can have different effects on different classes. 

To identify which model configurations were assigned what stacking coefficients, we can make use of the `collect_parameters()` function:

```{r}
collect_parameters(tree_frogs_model_st, "rand_forest_res")
```

This object is now ready to predict with new data!

```{r}
#| eval: false
tree_frogs_pred <-
  tree_frogs_test |>
  bind_cols(predict(tree_frogs_model_st, ., type = "prob"))
```

Computing the ROC AUC for the model:

```{r}
#| eval: false
yardstick::roc_auc(
  tree_frogs_pred,
  truth = reflex,
  contains(".pred_")
  )
```

Looks like our predictions were pretty strong! How do the stacks predictions perform, though, as compared to the members' predictions? We can use the `members` argument to generate predictions from each of the ensemble members.

```{r}
tree_frogs_pred <-
  tree_frogs_test |>
  select(reflex) |>
  bind_cols(
    predict(
      tree_frogs_model_st,
      tree_frogs_test,
      type = "class",
      members = TRUE
      )
    )

tree_frogs_pred

map(
  colnames(tree_frogs_pred),
  ~mean(tree_frogs_pred$reflex == pull(tree_frogs_pred, .x))
) |>
  set_names(colnames(tree_frogs_pred)) |>
  as_tibble() |>
  pivot_longer(c(everything(), -reflex))
```

Voilà! You've now made use of the stacks package to predict tree frog embryo ear function using a stacked ensemble!  
