R: Quantile forest

quantile_forest {grf} | R Documentation

## Quantile forest

### Description

Trains a regression forest that can be used to estimate quantiles of the conditional distribution of Y given X = x.

### Usage

    quantile_forest(X, Y, num.trees = 2000, quantiles = c(0.1, 0.5, 0.9),
      regression.splitting = FALSE, clusters = NULL,
      equalize.cluster.weights = FALSE, sample.fraction = 0.5,
      mtry = min(ceiling(sqrt(ncol(X)) + 20), ncol(X)), min.node.size = 5,
      honesty = TRUE, honesty.fraction = 0.5,
      honesty.prune.leaves = TRUE, alpha = 0.05, imbalance.penalty = 0,
      num.threads = NULL, seed = runif(1, 0, .Machine$integer.max))

### Arguments

`X` | The covariates used in the quantile regression.
`Y` | The outcome.
`num.trees` | Number of trees grown in the forest. Note: Getting accurate confidence intervals generally requires more trees than getting accurate predictions. Default is 2000.
`quantiles` | Vector of quantiles used to calibrate the forest. Default is (0.1, 0.5, 0.9).
`regression.splitting` | Whether to use regression splits when growing trees instead of specialized splits based on the quantiles (the default). Setting this flag to true corresponds to the approach to quantile forests from Meinshausen (2006). Default is FALSE.
`clusters` | Vector of integers or factors specifying which cluster each observation corresponds to. Default is NULL (ignored).
`equalize.cluster.weights` | If FALSE, each unit is given the same weight (so that bigger clusters get more weight). If TRUE, each cluster is given equal weight in the forest. In this case, during training, each tree uses the same number of observations from each drawn cluster: If the smallest cluster has K units, then when we sample a cluster during training, we only give a random K elements of the cluster to the tree-growing procedure. When estimating average treatment effects, each observation is given weight 1/cluster size, so that the total weight of each cluster is the same.
`sample.fraction` | Fraction of the data used to build each tree. Note: If honesty = TRUE, these subsamples will further be cut by a factor of honesty.fraction. Default is 0.5.
`mtry` | Number of variables tried for each split. Default is √ p + 20 where p is the number of variables.
`min.node.size` | A target for the minimum number of observations in each tree leaf. Note that nodes with size smaller than min.node.size can occur, as in the original randomForest package. Default is 5.
`honesty` | Whether to use honest splitting (i.e., sub-sample splitting). Default is TRUE. For a detailed description of honesty, honesty.fraction, honesty.prune.leaves, and recommendations for parameter tuning, see the grf algorithm reference.
`honesty.fraction` | The fraction of data that will be used for determining splits if honesty = TRUE. Corresponds to set J1 in the notation of the paper. Default is 0.5 (i.e. half of the data is used for determining splits).
`honesty.prune.leaves` | If TRUE, prunes the estimation sample tree such that no leaves are empty. If FALSE, keep the same tree as determined in the splits sample (if an empty leave is encountered, that tree is skipped and does not contribute to the estimate). Setting this to FALSE may improve performance on small/marginally powered data, but requires more trees (note: tuning does not adjust the number of trees). Only applies if honesty is enabled. Default is TRUE.
`alpha` | A tuning parameter that controls the maximum imbalance of a split. Default is 0.05.
`imbalance.penalty` | A tuning parameter that controls how harshly imbalanced splits are penalized. Default is 0.
`num.threads` | Number of threads used in training. By default, the number of threads is set to the maximum hardware concurrency.
`seed` | The seed of the C++ random number generator.

### Value

A trained quantile forest object.

### Examples

    ## Not run:
    # Generate data.
    n <- 50
    p <- 10
    X <- matrix(rnorm(n * p), n, p)
    X.test <- matrix(0, 101, p)
    X.test[, 1] <- seq(-2, 2, length.out = 101)
    Y <- X[, 1] * rnorm(n)

    # Train a quantile forest.
    q.forest <- quantile_forest(X, Y, quantiles = c(0.1, 0.5, 0.9))

    # Make predictions.
    q.hat <- predict(q.forest, X.test)

    # Make predictions for different quantiles than those used in training.
    q.hat <- predict(q.forest, X.test, quantiles = c(0.1, 0.9))

    # Train a quantile forest using regression splitting instead of quantile-based
    # splits, emulating the approach in Meinshausen (2006).
    meins.forest <- quantile_forest(X, Y, regression.splitting = TRUE)

    # Make predictions for the desired quantiles.
    q.hat <- predict(meins.forest, X.test, quantiles = c(0.1, 0.5, 0.9))

    ## End(Not run)

[Package grf version 1.0.0 Index]