Tutorial: Creating FFTs for heart disease

Step 1: Install and load the FFTrees package

We can install FFTrees from CRAN using install.packages(). (We only need to do this once.)

# Install the package from CRAN:
install.packages("FFTrees")

To use the package, we first need to load it into your current R session. We load the package using library():

# Load the package:
library(FFTrees)

The FFTrees package contains several vignettes that guide through the package’s functionality (like this one). To open the main guide, run FFTrees.guide():

# Open the main package guide: 
FFTrees.guide()

Step 2: Create FFTs from training data (and test on testing data)

In this example, we will create FFTs from a heart disease data set. The training data are in an object called heart.train, and the testing data are in an object called heart.test. For these data, we will predict diagnosis, a binary criterion that indicates whether each patient has or does not have heart disease (i.e., is at high-risk or low-risk).

To create an FFTrees object, we use the function FFTrees() with two main arguments:

1. formula expects a formula indicating a binary criterion variable as a function of one or more predictor variable(s) to be considered for the tree. The shorthand formula = diagnosis ~ . means to include all predictor variables.

2. data specifies the training data used to construct the FFTs (which must include the criterion variable).

Here is how we can construct our first FFTs:

# Create an FFTrees object:
heart.fft <- FFTrees(formula = diagnosis ~ .,           # Criterion and (all) predictors
                     data = heart.train,                # Training data
                     data.test = heart.test,            # Testing data
                     main = "Heart Disease",            # General label
                     decision.labels = c("Low-Risk", "High-Risk")  # Decision labels (False/True)
                     )

Evaluating this expression runs code that examines the data, optimizes thresholds based on our current goals for each cue, and creates and evaluates 7 FFTs. The resulting FFTrees object that contains the tree definitions, their decisions, and their performance statistics, are assigned to the heart.fft object.

Step 3: Inspect and summarize FFTs

Now we can inspect and summarize the generated decision trees. We will start by printing the FFTrees object to return basic information to the console:

# Print an FFTrees object:
heart.fft

#> Heart Disease
#> FFTrees 
#> - Trees: 7 fast-and-frugal trees predicting diagnosis
#> - Cost of outcomes:  hi = 0,  fa = 1,  mi = 1,  cr = 0
#> - Cost of cues: 
#>      age      sex       cp trestbps     chol      fbs  restecg  thalach 
#>        1        1        1        1        1        1        1        1 
#>    exang  oldpeak    slope       ca     thal 
#>        1        1        1        1        1 
#> 
#> FFT #1: Definition
#> [1] If thal = {rd,fd}, decide High-Risk.
#> [2] If cp != {a}, decide Low-Risk.
#> [3] If ca > 0, decide High-Risk, otherwise, decide Low-Risk.
#> 
#> FFT #1: Training Accuracy
#> Training data: N = 150, Pos (+) = 66 (44%) 
#> 
#> |          | True + | True - | Totals:
#> |----------|--------|--------|
#> | Decide + | hi  54 | fa  18 |      72
#> | Decide - | mi  12 | cr  66 |      78
#> |----------|--------|--------|
#>   Totals:        66       84   N = 150
#> 
#> acc  = 80.0%   ppv  = 75.0%   npv  = 84.6%
#> bacc = 80.2%   sens = 81.8%   spec = 78.6%
#> 
#> FFT #1: Training Speed, Frugality, and Cost
#> mcu = 1.74,  pci = 0.87
#> cost_dec = 0.200,  cost_cue = 1.740,  cost = 1.940

The output tells us several pieces of information:

• The tree with the highest weighted sensitivity wacc with a sensitivity weight of 0.5 is selected as the best tree.

• Here, the best tree, FFT #1 uses three cues: thal, cp, and ca.

• Several summary statistics for this tree in training and test data are summarized.

All statistics to evaluate each tree can be derived from a 2 x 2 confusion table:

Table 1: A 2x2 confusion table illustrating the types of frequency counts for 4 possible outcomes.

For definitions of all accuracy statistics, see the accuracy statistics vignette.

Step 4: Visualise the final FFT

We use plot(x) to visualize an FFT (from an FFTrees object x). Using data = "train" evaluates an FFT for training data (fitting), whereas data = "test" predicts the performance of an FFT for a different dataset:

# Plot predictions of the best FFT when applied to test data:
plot(heart.fft,      # An FFTrees object
     data = "test")  # data to use (i.e., either "train" or "test")?

# Plot only the tree, without accuracy statistics:
plot(heart.fft, what = "tree")

# plot(heart.fft, stats = FALSE)  #  The 'stats' argument has been deprecated.

# Plot cue accuracies (for training data) in ROC space:
plot(heart.fft, what = "cues")

#> Plotting cue training statistics:
#> — Cue accuracies ranked by bacc

Advanced functions

Creating sets of FFTs and evaluating them on data by printing and plotting individual FFTs provides the core functionality of FFTrees. However, the package also provides more advanced functions for accessing, defining, using and evaluating FFTs.

# Show the names of all outputs in heart.fft:
names(heart.fft)

#> [1] "criterion_name" "cue_names"      "formula"        "trees"         
#> [5] "data"           "params"         "competition"    "cues"

# Predict classifications for a new dataset:
predict(heart.fft, 
        newdata = heartdisease)