`weightit.fit.Rd`

`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 = "ps",
s.weights = NULL,
by.factor = NULL,
estimand = "ATE",
focal = NULL,
stabilize = FALSE,
ps = NULL,
moments = NULL,
int = FALSE,
subclass = NULL,
is.MSM.method = FALSE,
missing = NULL,
verbose = FALSE,
include.obj = FALSE,
...)
```

- covs
a numeric matrix of covariates.

- treat
a vector of treatment statuses.

- method
a string of length 1 containing the name of the method that will be used to estimate weights. See

`weightit()`

for allowable options. The default is`"ps"`

for propensity score weighting.- s.weights
a numeric vector of sampling weights. See the individual pages for each method for information on whether sampling weights can be supplied.

- by.factor
a factor variable for which weighting is to be done within levels. Corresponds to the

`by`

argument in`weightit()`

.- estimand
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.

- stabilize
`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`

.- focal
when multi-category treatments are used and ATT weights are requested, which group to consider the "treated" or focal group. This group will not be weighted, and the other groups will be weighted to be more like the focal group. Must be non-

`NULL`

if`estimand = "ATT"`

or`"ATC"`

.- ps
a vector of propensity scores. If specified,

`method`

will be ignored and set to`"ps"`

.- moments, int, subclass
arguments to customize the weight estimation. See

`weightit()`

for details.- is.MSM.method
see

`weightitMSM()`

. Typically can be ignored.- missing
`character`

; how missing data should be handled. The options depend on the`method`

used. If`NULL`

,`covs`

covs will be checked for`NA`

values, and if present,`missing`

will be set to`"ind"`

. If`""`

,`covs`

covs will not be checked for`NA`

values; this can be faster when it is known there are none.- verbose
whether to print additional information output by the fitting function.

- include.obj
whether to include in the output any fit objects created in the process of estimating the weights. For example, with

`method = "ps"`

, 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.

A `weightit.fit`

object with the following elements:

- weights
The estimated weights, one for each unit.

- ps
The estimated or provided propensity scores. Estimated propensity scores are returned for binary treatments and only when

`method`

is`"ps"`

,`"gbm"`

,`"cbps"`

,`"super"`

, or`"bart"`

.- fit.obj
When

`include.obj = TRUE`

, the fit object.- info
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.

`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 doesn't contain any 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.

```
library("cobalt")
data("lalonde", package = "cobalt")
#Balancing covariates between treatment groups (binary)
covs_mat <- as.matrix(lalonde[c("age", "educ", "married",
"nodegree", "re74", "re75")])
wf1 <- weightit.fit(covs_mat, treat = lalonde$treat,
method = "ps", estimand = "ATT")
str(wf1)
#> List of 4
#> $ weights: num [1:614] 1 1 1 1 1 1 1 1 1 1 ...
#> $ ps : num [1:614] 0.296 0.462 0.391 0.558 0.483 ...
#> $ fit.obj: NULL
#> $ info : Named list()
#> - attr(*, "class")= chr "weightit.fit"
```