weightit.fit() dispatches one of the weight estimation methods
determined by method. It is an internal function called by weightit() and
should probably not be used except in special cases. Unlike weightit(),
weightit.fit() does not accept a formula and data frame interface and
instead requires the covariates and treatment to be supplied as a numeric
matrix and atomic vector, respectively. In this way, weightit.fit() is to
weightit() what lm.fit() is to lm() - a thinner, slightly faster
interface that performs minimal argument checking.
weightit.fit(
covs,
treat,
method = "glm",
s.weights = NULL,
by.factor = NULL,
estimand = "ATE",
focal = NULL,
stabilize = FALSE,
ps = NULL,
moments = NULL,
int = FALSE,
subclass = NULL,
missing = NULL,
verbose = FALSE,
include.obj = FALSE,
...
)A weightit.fit object with the following elements:
The estimated weights, one for each unit.
The values of the treatment variable.
The estimand requested.
The weight estimation method specified.
The estimated or provided propensity scores. Estimated propensity scores are
returned for binary treatments and only when method is "glm", "gbm", "cbps", "ipt", "super", or "bart". The propensity score corresponds to the predicted probability of being treated; see section estimand and focal in Details at weightit() for how the treated group is determined.
The provided sampling weights.
The focal treatment level if the ATT or ATC was requested.
When
include.obj = TRUE, the fit object.
Additional information about the fitting. See the individual methods pages for what is included.
The weightit.fit object does not have specialized print(), summary(),
or plot() methods. It is simply a list containing the above components. Use
as.weightit() to convert it to a weightit object, which does have these
methods. See Examples.
a numeric matrix of covariates.
a vector of treatment statuses.
a string containing the name of the method that will be used to
estimate weights. See weightit() for allowable options. The default is
"glm" for propensity score weighting using a generalized linear model to
estimate the propensity score.
a numeric vector of sampling weights. See the individual pages for each method for information on whether sampling weights can be supplied.
a factor variable for which weighting is to be done within
levels. Corresponds to the by argument in weightit().
the desired estimand. For binary and multi-category
treatments, can be "ATE", "ATT", "ATC", and, for some methods,
"ATO", "ATM", or "ATOS". The default for both is "ATE". This
argument is ignored for continuous treatments. See the individual pages for
each method for more information on which estimands are allowed with each
method and what literature to read to interpret these estimands.
when estimand is set to "ATT" or "ATC", which group to
consider the "treated" or "control" group. This group will not be weighted,
and the other groups will be weighted to resemble the focal group. If
specified, estimand will automatically be set to "ATT" (with a warning
if estimand is not "ATT" or "ATC"). See section estimand and
focal in Details at weightit().
logical; whether or not to stabilize the weights. For the
methods that involve estimating propensity scores, this involves
multiplying each unit's weight by the proportion of units in their
treatment group. Default is FALSE. Note this differs from its use with
weightit().
a vector of propensity scores. If specified, method will be
ignored and set to "glm".
arguments to customize the weight estimation. See
weightit() for details.
character; how missing data should be handled. The options
depend on the method used. If NULL, covs will be checked for NA
values, and if present, missing will be set to "ind". If "", covs
will not be checked for NA values; this can be faster when it is known
there are none.
logical; whether to print additional information output by
the fitting function.
logical; whether to include in the output any fit
objects created in the process of estimating the weights. For example, with
method = "glm", the glm objects containing the propensity score model
will be included. See the individual pages for each method for information
on what object will be included if TRUE.
other arguments for functions called by weightit.fit() that
control aspects of fitting that are not covered by the above arguments.
weightit.fit() is called by weightit() after the arguments to
weightit() have been checked and processed. weightit.fit() dispatches the
function used to actually estimate the weights, passing on the supplied
arguments directly. weightit.fit() is not meant to be used by anyone other
than experienced users who have a specific use case in mind. The returned
object contains limited information about the supplied arguments or details
of the estimation method; all that is processed by weightit().
Less argument checking or processing occurs in weightit.fit() than does in
weightit(), which means supplying incorrect arguments can result in errors,
crashes, and invalid weights, and error and warning messages may not be
helpful in diagnosing the problem. weightit.fit() does check to make sure
weights were actually estimated, though.
weightit.fit() may be most useful in speeding up simulation simulation
studies that use weightit() because the covariates can be supplied as a
numeric matrix, which is often how they are generated in simulations, without
having to go through the potentially slow process of extracting the
covariates and treatment from a formula and data frame. If the user is
certain the arguments are valid (e.g., by ensuring the estimated weights are
consistent with those estimated from weightit() with the same arguments),
less time needs to be spent on processing the arguments. Also, the returned
object is much smaller than a weightit object because the covariates are
not returned alongside the weights.
weightit(), which you should use for estimating weights unless you
know better.
as.weightit() for converting a weightit.fit object to a weightit
object.
library("cobalt")
data("lalonde", package = "cobalt")
# Balancing covariates between treatment groups (binary)
covs <- lalonde[c("age", "educ", "race", "married",
"nodegree", "re74", "re75")]
## Create covs matrix, splitting any factors using
## cobalt::splitfactor()
covs_mat <- as.matrix(splitfactor(covs))
WF1 <- weightit.fit(covs_mat, treat = lalonde$treat,
method = "glm", estimand = "ATT")
str(WF1)
# Converting to a weightit object for use with
# summary() and bal.tab()
W1 <- as.weightit(WF1, covs = covs)
W1
summary(W1)
bal.tab(W1)
Run the code above in your browser using DataLab