R: Partial Dependence Plots for BART

pdbart {dbarts} | R Documentation

## Partial Dependence Plots for BART

### Description

Run `bart` at test observations constructed so that a plot can be created displaying the effect of a single variable (`pdbart`) or pair of variables (`pd2bart`). Note that if y is a binary with P(Y=1 | x) = F(f(x)), F the standard normal cdf, then the plots are all on the f scale.

### Usage

    pdbart(x.train, y.train,
           xind = NULL,
           levs = NULL, levquants = c(0.05, seq(0.1, 0.9, 0.1), 0.95),
           pl = TRUE, plquants = c(0.05, 0.95),
           ...)

    ## S3 method for class 'pdbart'
    plot(x,
         xind = seq_len(length(x$fd)),
         plquants = c(0.05, 0.95), cols = c('black', 'blue'),
         ...)

    pd2bart(x.train, y.train,
            xind = NULL,
            levs = NULL, levquants = c(0.05, seq(0.1, 0.9, 0.1), 0.95),
            pl = TRUE, plquants = c(0.05, 0.95),
            ...)

    ## S3 method for class 'pd2bart'
    plot(x,
         plquants = c(0.05, 0.95), contour.color = 'white',
         justmedian = TRUE,
         ...)

### Arguments

`x.train` | Explanatory variables for training (in sample) data. Can be any valid input to `bart`, such as a matrix or a formula. Also accepted are fitted `bart` models or `dbartsSampler` with `keepTrees` equal to `TRUE`.
`y.train` | Dependent variable for training (in sample) data. Can be a numeric vector or, when passing `x.train` as a formula, a `data.frame` or other object used to find variables. Not required if `x.train` is a fitted model or sampler.
`xind` | Integer, character vector, or the right-hand side of a formula indicating which variables are to be plotted. In `pdbart`, corresponds to the variables (columns of `x.train`) for which a plot is to be constructed. In `plot.pdbart`, corresponds to the indices in list returned by `pdbart` for which plot is to be constructed. In `pd2bart`, the indicies of a pair of variables (columns of `x.train`) to plot. If `NULL` a default of all columns is used for `pdbart` and the first two columns is used for `pd2bart`.
`levs` | Gives the values of a variable at which the plot is to be constructed. Must be a list, where the ith component gives the values for the ith variable. In `pdbart`, it should have same length as `xind`. In `pd2bart`, it should have length 2. See also argument `levquants`.
`levquants` | If `levs` in `NULL`, the values of each variable used in the plot is set to the quantiles (in `x.train`) indicated by levquants. Must be a vector of numeric type.
`pl` | For `pdbart` and `pd2bart`, if `TRUE`, plot is subsequently made (by calling `plot.*`).
`plquants` | In the plots, beliefs about f(x) are indicated by plotting the posterior median and a lower and upper quantile. `plquants` is a double vector of length two giving the lower and upper quantiles.
`...` | Additional arguments. In `pdbart` and `pd2bart`, arguments are passed on to `bart`. In `plot.pdbart`, they are passed on to `plot`. In `plot.pd2bart`, they are passed on to `image`.
`x` | For `plot.*`, object returned from `pdbart` or `pd2bart`.
`cols` | Vector of two colors. The first color is for the median of f, while the second color is for the upper and lower quantiles.
`contour.color` | Color for contours plotted on top of the image.
`justmedian` | A logical where if `TRUE` just one plot is created for the median of f(x) draws. If `FALSE`, three plots are created one for the median and two additional ones for the lower and upper quantiles. In this case, `mfrow` is set to `c(1,3)`.

### Details

We divide the predictor vector x into a subgroup of interest, x_s and the complement x_c = x - x_s. A prediction f(x) can then be written as f(x_s, x_c). To estimate the effect of x_s on the prediction, Friedman suggests the partial dependence function

f_s(x_s) = (1/n) ∑_{i=1}\^n f(x_s,x_{ic})

where x_{ic} is the ith observation of x_c in the data. Note that (x_s, x_{ic}) will generally not be one of the observed data points. Using BART it is straightforward to then estimate and even obtain uncertainty bounds for f_s(x_s). A draw of f*_s(x_s) from the induced BART posterior on f_s(x_s) is obtained by simply computing f*_s(x_s) as a byproduct of each MCMC draw f*. The median (or average) of these MCMC draws f*_s(x_s) then yields an estimate of f_s(x_s), and lower and upper quantiles can be used to obtain intervals for f_s(x_s).

In `pdbart` x_s consists of a single variable in x and in `pd2bart` it is a pair of variables.

This is a computationally intensive procedure. For example, in `pdbart`, to compute the partial dependence plot for 5 x_s values, we need to compute f(x_s, x_c) for all possible (x_s, x_{ic}) and there would be 5n of these where n is the sample size. All of that computation would be done for each kept BART draw. For this reason running BART with `keepevery` larger than 1 (eg. 10) makes the procedure much faster.

### Value

The plot methods produce the plots and don't return anything.

`pdbart` and `pd2bart` return lists with components given below. The list returned by `pdbart` is assigned class `pdbart` and the list returned by `pd2bart` is assigned class `pd2bart`.

`fd` | A matrix whose (i, j) value is the ith draw of f_s(x_s) for the jth value of x_s. “fd” is for “function draws”. For `pdbart` `fd` is actually a list whose kth component is the matrix described above corresponding to the kth variable chosen by argument xind.\ The number of columns in each matrix will equal the number of values given in the corresponding component of argument `levs` (or number of values in `levquants`). For `pd2bart`, `fd` is a single matrix. The columns correspond to all possible pairs of values for the pair of variables indicated by `xind`. That is, all possible (x_i, x_j) where x_i is a value in the levs component corresponding to the first x and x_j is a value in the levs components corresponding to the second one. The first x changes first.
`levs` | The list of levels used, each component corresponding to a variable. If argument `levs` was supplied it is unchanged. Otherwise, the levels in `levs` are as constructed using argument `levquants`.
`xlbs` | A vector of character strings which are the plotting labels used for the variables.

The remaining components returned in the list are the same as in the value of `bart`. They are simply passed on from the BART run used to create the partial dependence plot. The function `plot.bart` can be applied to the object returned by `pdbart` or `pd2bart` to examine the BART run.

### Author(s)

Hugh Chipman: hugh.chipman@acadiau.ca.
Robert McCulloch: robert.mcculloch@chicagogsb.edu.

### References

Chipman, H., George, E., and McCulloch, R. (2006) BART: Bayesian Additive Regression Trees.

Chipman, H., George, E., and McCulloch R. (2006) Bayesian Ensemble Learning.

both of the above at: http://www.rob-mcculloch.org/

Friedman, J.H. (2001) Greedy function approximation: A gradient boosting machine. The Annals of Statistics, 29, 1189–1232.

### Examples

    ## Not run:
    ## simulate data
    f <- function(x) { return(0.5 * x[,1] + 2 * x[,2] * x[,3]) }

    sigma <- 0.2
    n     <- 100

    set.seed(27)
    x <- matrix(2 * runif(n * 3) -1, ncol = 3)
    colnames(x) <- c('rob', 'hugh', 'ed')

    Ey <- f(x)
    y  <- rnorm(n, Ey, sigma)

    ## first two plot regions are for pdbart, third for pd2bart
    par(mfrow = c(1, 3))

    ## pdbart: one dimensional partial dependence plot
    set.seed(99)
    pdb1 <-
      pdbart(x, y, xind = c(1, 2),
             levs = list(seq(-1, 1, 0.2), seq(-1, 1, 0.2)),
             pl = FALSE, keepevery = 10, ntree = 100)
    plot(pdb1, ylim = c(-0.6,.6))

    ## pd2bart: two dimensional partial dependence plot
    set.seed(99)
    pdb2 <-
      pd2bart(x, y, xind = c(2, 3),
              levquants = c(0.05, 0.1, 0.25, 0.5, 0.75, 0.9, 0.95),
              pl = FALSE, ntree = 100, keepevery = 10, verbose = FALSE)
    plot(pdb2)

    ## compare BART fit to linear model and truth = Ey
    lmFit  <- lm(y ~., data.frame(x, y))
    fitmat <- cbind(y, Ey, lmFit$fitted, pdb1$yhat.train.mean)
    colnames(fitmat) <- c('y', 'Ey', 'lm', 'bart')
    print(cor(fitmat))

    ## example showing the use of a pre-fitted model
    df <- data.frame(y, x)
    set.seed(99)
    bartFit <- bart(y ~ rob + hugh + ed, df,
                    keepevery = 10, ntree = 100, keeptrees = TRUE)
    pdb1 <- pdbart(bartFit, xind = rob + ed, pl = FALSE)

    ## End(Not run)

[Package dbarts version 0.9-20 Index]