# Explore treeheatr

#### Trang Le

#### 2020-11-19

treeheatr displays a more interpretable decision tree visualization by integrating a heatmap at its terminal nodes. Let’s explore the package treeheatr a little deeper and see what it can do!

    library(treeheatr)

## Let’s begin

with the penguins dataset! Running the `heat_tree()` function can be as simple as:

    # To avoid warnings, for now, apply na.omit():
    penguins <- na.omit(penguins)
    heat_tree(penguins, target_lab = 'species')

But we can adjust a few graphical parameters. We can also add a custom layout for a subset of the nodes by specifying it in the `custom_layout` parameter. And we can relax the p value threshold `p_thres` to include more features that might be less important in classifying the samples but still included in the decision tree, or set `show_all_feats = TRUE` to include all features, even the ones that were not used to build the tree.

    heat_tree(
      penguins, target_lab = 'species',
      target_cols = c('#E69F00', '#56B4E9', '#009E73'),
      # moving node 3 a bit to the left:
      custom_layout = data.frame(id = 3, x = 0.1, y = 0.5),
      show_all_feats = TRUE,
      panel_space = 0.05, target_space = 0.2, tree_space_bottom = 0.1, heat_rel_height = 0.4)

We can also customize our heattree by passing parameters through to different ggparty geoms. These list parameters are named `*_vars`. For example:

    heat_tree(
      penguins, target_lab = 'species',
      par_node_vars = list(
        label.size = 0.2,
        label.padding = ggplot2::unit(0.1, 'lines'),
        line_list = list(
          ggplot2::aes(label = paste('Node', id)),
          ggplot2::aes(label = splitvar),
          ggplot2::aes(label = paste('p =', formatC(p.value, format = 'e', digits = 2)))),
        line_gpar = list(
          list(size = 8),
          list(size = 8),
          list(size = 6)),
        id = 'inner'),
      terminal_vars = list(size = 0),
      cont_legend = TRUE, cate_legend = TRUE,
      edge_vars = list(size = 1, color = 'grey'))

What if we only want to show the decision tree? We can toggle this option using the `show` argument, which takes either `'heat-tree'`, `'heat-only'` or `'tree-only'`. For example:

    heat_tree(penguins, target_lab = 'species', show = 'tree-only')

We can also choose to display other features in the heatmap that may not be in the tree.

    heat_tree(penguins, target_lab = 'species', feats = c('body_mass_g', 'sex'))

`feats = NA` displays the tree with only the target label, which may be simple and still helpful:

    heat_tree(penguins, target_lab = 'species', feats = NA, heat_rel_height = 0.1)

## You’re the Warren Beatty of your `heat_tree()`

Anyone got that Food Wishes reference?

### Pre-train your tree

If the default conditional tree is not desired, you can create your tree (e.g. with `rpart`) and wrap `as.party()` around this object to plug into `heat_tree()`. As an example, we will examine the datasets of COVID-19 cases in Wuhan from 2020-01-10 to 2020-02-18 from a recent study.

    # # same tree as letting `x = train_covid`:
    # x <- partykit::ctree(Outcome ~ ., data = train_covid)

    # build tree using rpart:
    x <- partykit::as.party(rpart::rpart(Outcome ~ ., data = train_covid))

    heat_tree(x = x, label_map = c(`1` = 'Deceased', `0` = 'Survived'))

### Manually define your tree with `partysplit` and `partynode`

You can also manually define your own tree for the `custom_tree` argument following the partykit vignette. Let’s apply the tree structure in Figure 2 of the original study (only show the training set for now):

    library(partykit)

    # first argument indicates the index of the feature used for splitting
    split_ldh <- partysplit(1L, breaks = 365)
    split_crp <- partysplit(2L, breaks = 41.2)
    split_lymp <- partysplit(3L, breaks = 14.7)

    custom_tree <- partynode(1L, split = split_ldh , kids = list(
      partynode(2L, split = split_crp, kids = list(
        partynode(3L, info = 'Survival'),
        partynode(4L, split = split_lymp, kids = list(
          partynode(5L, info = 'Death'),
          partynode(6L, info = 'Survival'))))),
      partynode(7L, info = 'Death')))

    heat_tree(
      x = custom_tree,
      data_test = train_covid,
      print_eval = FALSE,
      target_lab = 'Outcome',
      label_map = c(`1` = 'Deceased', `0` = 'Survived'))

## Apply the learned tree on external/holdout/test/validation dataset

You can print measures evaluating the conditional decision tree’s performance by setting `print_eval = TRUE`. By defaults, we show 5 measures for classification tasks:

- Accuracy
- Balanced accuracy (BAL_ACCURACY)
- Kappa coefficient (KAP)
- Area under the receiver operating characteristics curve (ROC_AUC)
- Area under the precision recall curve (PR_AUC)

and 4 measures for regression tasks:

- R-squared (RSQ)
- Mean absolute error (MAE)
- Root mean squared error (RMSE)
- Concordance correlation coefficient (CCC).

You can also choose to show performance based on any other set of appropriate metrics listed on the yardstick reference page, for example, with

    metrics = yardstick::metric_set(yardstick::f_meas)

as a `heat_tree` argument to show the F score (a combination of precision and recall).

Warning: We do not recommend `print_eval` on the training set because these measures may gives you an over-optimistic view of how the tree performs (this would show pure training accuracy, not cross-validated).

Let’s now apply the custom tree we (or really, Yan et al.) designed earlier and see how it performs on the test set:

    heat_tree(
      x = custom_tree,
      data_test = test_covid,
      target_lab = 'Outcome',
      label_map = c(`1` = 'Death', `0` = 'Survival'),
      lev_fac = 3)

## Regression

In general, compared to classification, regression task is more difficult to interpret with a decision tree. However, a heatmap may shed some light on how the tree groups the samples in different terminal nodes. Also, removing the terminal node label may show the groups better. Here’s an example:

    heat_tree(x = galaxy,
              target_lab = 'target',
              task = 'regression',
              terminal_vars = NULL,
              tree_space_bottom = 0)

## Smart node layout

These extreme visualizations may not be very interpretable but serves the purpose of showing the ability to generalize of the node layout when the tree grows in size. The implemented smart layout weighs the x-position of the parent node according to the level of the child nodes as to avoid crossing of tree branches. This relative weight can be adjusted with the `lev_fac` parameter in `heat_tree()`. The default `lev_fac = 1.3` seems to provide aesthetically pleasing trees, independent of the tree size.

In this next figure, on the top, `lev_fac = 1` makes parent node perfectly in the middle of child nodes (note a few branch crossing), which contrasts `lev_fac = 1.3` (default) on the bottom.

    heat_tree(wine_quality_red, target_lab = 'target', lev_fac = 1, title = 'lev_fac = 1')
    heat_tree(wine_quality_red, target_lab = 'target', title = 'lev_fac = 1.3')

## Seriation

Unless you turn it off (`clust_feats = FALSE`, `clust_samps = FALSE`), treeheatr automatically performs grouping of features and samples when organizing the heatmap. Features are ordered within each of the two groups of features, continuous and categorical (including the target label, unless `clust_target = FALSE`). Samples are grouped within each terminal node of all features (not only the displayed features). treeheatr uses `cluster::daisy()` to compute distances with the Gower metric to incorporate both continuous and nominal categorical feature types. Now, `cluster::daisy()` may throw this warning if your dataset contains binary features:

`binary variable(s) treated as interval scaled`

but in general this is safe to ignore because the goal of seriation is to simply reduce the amount of stochasticity of the tree-based model and not to make precise inference about each group.

## Mixed data/feature types

As shown above in the penguins example, treeheatr supports mixed feature types.

For continuous variables/features, we can choose to either percentize (scale-rank), normalize (subtract the min and divide by the max) or scale (subtract the mean and divide by the standard deviation) each feature. Depending on what we want to show in the heatmap, one transformation method can be more effective than the other. Details on the strengths and weaknesses of different types of data transformation for heatmap display can be found in this vignette of the heatmaply package.

We highly recommend that, when dealing with mixed feature types, the user supply `feat_types` to indicate whether a feature should be considered ‘numeric’ (continuous) or ‘factor’ (categorical) as shown below. When `feat_types` is not specified, treeheatr automatically inferred each column type from the original dataset.