R: Causal forest

causal_forest {grf} | R Documentation

## Causal forest

### Description

Trains a causal forest that can be used to estimate conditional average treatment effects tau(X). When the treatment assignment W is binary and unconfounded, we have tau(X) = E[Y(1) - Y(0) | X = x], where Y(0) and Y(1) are potential outcomes corresponding to the two possible treatment states. When W is continuous, we effectively estimate an average partial effect Cov[Y, W | X = x] / Var[W | X = x], and interpret it as a treatment effect given unconfoundedness.

### Usage

    causal_forest(X, Y, W, Y.hat = NULL, W.hat = NULL,
      sample.weights = NULL, orthog.boosting = FALSE,
      sample.fraction = 0.5, mtry = NULL, num.trees = 2000,
      min.node.size = NULL, honesty = TRUE, honesty.fraction = NULL,
      ci.group.size = 2, alpha = NULL, imbalance.penalty = NULL,
      stabilize.splits = TRUE, clusters = NULL,
      samples.per.cluster = NULL, tune.parameters = FALSE,
      num.fit.trees = 200, num.fit.reps = 50, num.optimize.reps = 1000,
      compute.oob.predictions = TRUE, num.threads = NULL, seed = NULL)

### Arguments

`X` | The covariates used in the causal regression.
`Y` | The outcome (must be a numeric vector with no NAs).
`W` | The treatment assignment (must be a binary or real numeric vector with no NAs).
`Y.hat` | Estimates of the expected responses E[Y | Xi], marginalizing over treatment. If Y.hat = NULL, these are estimated using a separate regression forest. See section 6.1.1 of the GRF paper for further discussion of this quantity.
`W.hat` | Estimates of the treatment propensities E[W | Xi]. If W.hat = NULL, these are estimated using a separate regression forest.
`sample.weights` | (experimental) Weights given to each sample in estimation. If NULL, each observation receives the same weight. Note: To avoid introducing confounding, weights should be independent of the potential outcomes given X.
`orthog.boosting` | (experimental) If TRUE, then when Y.hat = NULL or W.hat is NULL, the missing quantities are estimated using boosted regression forests. The number of boosting steps is selected automatically.
`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.
`mtry` | Number of variables tried for each split.
`num.trees` | Number of trees grown in the forest. Note: Getting accurate confidence intervals generally requires more trees than getting accurate predictions.
`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.
`honesty` | Whether to use honest splitting (i.e., sub-sample splitting).
`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. When using the defaults (honesty = TRUE and honesty.fraction = NULL), half of the data will be used for determining splits
`ci.group.size` | The forest will grow ci.group.size trees on each subsample. In order to provide confidence intervals, ci.group.size must be at least 2.
`alpha` | A tuning parameter that controls the maximum imbalance of a split.
`imbalance.penalty` | A tuning parameter that controls how harshly imbalanced splits are penalized.
`stabilize.splits` | Whether or not the treatment should be taken into account when determining the imbalance of a split.
`clusters` | Vector of integers or factors specifying which cluster each observation corresponds to.
`samples.per.cluster` | If sampling by cluster, the number of observations to be sampled from each cluster when training a tree. If NULL, we set samples.per.cluster to the size of the smallest cluster. If some clusters are smaller than samples.per.cluster, the whole cluster is used every time the cluster is drawn. Note that clusters with less than samples.per.cluster observations get relatively smaller weight than others in training the forest, i.e., the contribution of a given cluster to the final forest scales with the minimum of the number of observations in the cluster and samples.per.cluster.
`tune.parameters` | If true, NULL parameters are tuned by cross-validation; if false NULL parameters are set to defaults.
`num.fit.trees` | The number of trees in each 'mini forest' used to fit the tuning model.
`num.fit.reps` | The number of forests used to fit the tuning model.
`num.optimize.reps` | The number of random parameter values considered when using the model to select the optimal parameters.
`compute.oob.predictions` | Whether OOB predictions on training set should be precomputed.
`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 causal forest object. If tune.parameters is enabled, then tuning information will be included through the 'tuning.output' attribute.

### Examples

    ## Not run:
    # Train a causal forest.
    n = 50; p = 10
    X = matrix(rnorm(n*p), n, p)
    W = rbinom(n, 1, 0.5)
    Y = pmax(X[,1], 0) * W + X[,2] + pmin(X[,3], 0) + rnorm(n)
    c.forest = causal_forest(X, Y, W)

    # Predict using the forest.
    X.test = matrix(0, 101, p)
    X.test[,1] = seq(-2, 2, length.out = 101)
    c.pred = predict(c.forest, X.test)

    # Predict on out-of-bag training samples.
    c.pred = predict(c.forest)

    # Predict with confidence intervals; growing more trees is now recommended.
    c.forest = causal_forest(X, Y, W, num.trees = 4000)
    c.pred = predict(c.forest, X.test, estimate.variance = TRUE)

    # In some examples, pre-fitting models for Y and W separately may
    # be helpful (e.g., if different models use different covariates).
    # In some applications, one may even want to get Y.hat and W.hat
    # using a completely different method (e.g., boosting).
    n = 2000; p = 20
    X = matrix(rnorm(n * p), n, p)
    TAU = 1 / (1 + exp(-X[, 3]))
    W = rbinom(n, 1, 1 / (1 + exp(-X[, 1] - X[, 2])))
    Y = pmax(X[, 2] + X[, 3], 0) + rowMeans(X[, 4:6]) / 2 + W * TAU + rnorm(n)

    forest.W = regression_forest(X, W, tune.parameters = TRUE)
    W.hat = predict(forest.W)$predictions

    forest.Y = regression_forest(X, Y, tune.parameters = TRUE)
    Y.hat = predict(forest.Y)$predictions

    forest.Y.varimp = variable_importance(forest.Y)

    # Note: Forests may have a hard time when trained on very few variables
    # (e.g., ncol(X) = 1, 2, or 3). We recommend not being too aggressive
    # in selection.
    selected.vars = which(forest.Y.varimp / mean(forest.Y.varimp) > 0.2)

    tau.forest = causal_forest(X[,selected.vars], Y, W,
                               W.hat = W.hat, Y.hat = Y.hat,
                               tune.parameters = TRUE)
    tau.hat = predict(tau.forest)$predictions

    ## End(Not run)

[Package grf version 0.10.3 Index]