The Data

Examples of lmeresampler functions will use hierarchical linear models fit using jsp728, a data set containing information about 728 students (level-1) from 50 primary (elementary) schools in inner London (level-2) that were part of the Junior School Project (JSP). The data was collected by the University of Bristol Centre for Multilevel Modeling. For more information about the variables, see ?jsp728.

We will work with vcmodA for lme4, and vcmodB for nlme. Each of these two-level models predicts mathAge11 (the student’s math score at age 11) and contains the same 3 fixed effects: mathAge8 (the student’s math score at age 8), gender (the student’s gender), and class (the student’s father’s social class, a factor with two levels: manual and nonmanual). They also both have a random intercept for school. The models are as follows:

library(lme4)
vcmodA <- lme4::lmer(mathAge11 ~ mathAge8 + gender + class + (1 | school), data = jsp728)

library(nlme)
vcmodB <- nlme::lme(mathAge11 ~ mathAge8 + gender + class, random = ~1|school, data = jsp728)

The Call

In order to perform the bootstrap, the user must call the bootstrap() function. The function contains several required parameters for the user to specify when making the call:

• model: the LME model to be bootstrapped.

• .f: a function that will compute the statistics of interest (for example, to have the bootstrap return the fixed effects estimates, specify .f = fixef).

• type: a character string specifying what type of bootstrap should be executed. Possible values are "parametric", "residual", "case", "wild", or "reb". More information about each bootstrap type may be found in the following sections.

• B: the number of bootstrap resamples to be performed.

Additional parameters are required by specific bootstrap methods:

• resample: a logical vector specifying whether each level of the data set should be resampled in the cases bootstrap. The levels should be specified from the highest level (largest cluster) of the hierarchy to the lowest (observation-level). For example, for students within a school, specify the school level first, then the student level.

• reb_type: an integer value specifying what kind of REB (random effects block) bootstrap should be performed. More on what the differences between the REB bootstrap types are may be found in section 5 of this vignette.

• hccme: a character string specifying which heteroscedasticity consistent covariance matrix (HCCME) estimator to use in the Wild bootstrap. Current options include "hc2" and "hc3", the two estimators recommended by Modugno and Giannerini (2015).

  \[\begin{align} {\tt hc2} &: \tilde{\boldmath{v}}_i = {\rm diag} \left( \boldmath{I}_{n_i} - \boldmath{H}_i \right)^{-1/2} \circ \boldmath{r}_i\\ {\tt hc3} &: \tilde{\boldmath{v}}_i = {\rm diag} \left( \boldmath{I}_{n_i} - \boldmath{H}_i \right) \circ \boldmath{r}_i, \end{align}\]

  where \(\boldmath{H}_i = \boldmath{X}_i \left(\boldmath{X}_i^\prime \boldmath{X}_i \right)^\prime \boldmath{X}_i^\prime\), the \(i\)th diagonal block of the orthogonal projection matrix, and \(\boldmath{r}_i\) is the vector of marginal residuals for group \(i\).

• aux.dist: a character string specifying which auxillary distribution to use in the wild bootstrap. Current options include "mammen", "rademacher", "norm", "webb", and "gamma", the distributions outlined by Roodman et al. (2019).

NEED TO UPDATE!! \[\begin{align} {\tt f1}: w_i &= \begin{cases} -(\sqrt{5} - 1)/2 & \text{ with probability } p=(\sqrt{5}+1) / (2 \sqrt{5})\\ (\sqrt{5} + 1)/2 & \text{ with probability } 1-p\\ \end{cases}\\ {\tt f2}: w_i &= \begin{cases} -1 & \text{ with probability } 0.5\\ 1 & \text{ with probability } 0.5,\\ \end{cases} \end{align}\]

Examples

# let's set .f = fixef to specify that we want only the fixed effects bootstrapped

# lme4
lmer_par_boot <- bootstrap(vcmodA, .f = fixef, type = "parametric", B = 100)

# nlme
lme_par_boot  <- bootstrap(vcmodB, .f = fixef, type = "parametric", B = 100)

Let’s also take a look at the structure of the lmeresamp objects returned by a bootstrap call.

bootstrap() output

Regardless of the type of bootstrap performed, the output of bootstrap() will be an lmeresamp object that is formatted as a list of length 13. Notice that some of the objects come from the call itself, while others are calculated for the user using the bootstrapped values.

names(lmer_par_boot)
#>  [1] "observed"   "model"      ".f"         "replicates" "stats"     
#>  [6] "B"          "data"       "seed"       "type"       "call"      
#> [11] "message"    "warning"    "error"

• observed: the estimated values for the model parameters,

• model: the fitted model, formatted as the default merMod or lme object,

• .f: the function call,

• replicates: a B \(\times \ p\) data frame of bootstrap values for each of the \(p\) model parameters,

• stats: a tibble containing the observed, rep.mean (bootstrap mean), se (bootstrap standard error), and bias values for each model parameter,

• B: the number of bootstrap resamples performed,

• data: the data with which the model was fit,

• seed: a vector of randomly generated seeds that are used by the bootstrap,

• type: the type of bootstrap executed,

• call: the call to bootstrap() that the user,

• message: a list of length B giving any messages generated during refitting. An entry will be NULL if no message was generated,

• warning: a list of length B giving any warnings generated during refitting. An entry will be NULL if no message was generated, and

• error: a list of length B giving any errors generated during refitting. An entry will be NULL if no message was generated,

Notice that the elements message, warning, and error allow you to eliminate any iterations that might be problematic, such as if the model did not converge.

Examples

# lme4
# resample the schools, but not the students
lmer_case_boot <- bootstrap(vcmodA, .f = fixef, type = "case", B = 100, resample = c(TRUE, FALSE))

# nlme
# do not resample the schools, but resample the students
lme_cases_boot1 <- bootstrap(vcmodB, .f = fixef, type = "case", B = 100, resample = c(FALSE, TRUE))

# nlme
# resample both the schools and the students
lme_cases_boot2 <- bootstrap(vcmodB, .f = fixef, type = "case", B = 100, resample = c(TRUE, TRUE))

Examples

# lme4
lmer_res_boot <- bootstrap(vcmodA, .f = fixef, type = "residual", B = 100)

# nlme
lme_res_boot <- bootstrap(vcmodB, .f = fixef, type = "residual", B = 100)

Examples

# lme4
lmer_wild_boot <- bootstrap(vcmodA, .f = fixef, type = "wild", hccme = "hc2", aux.dist = "mammen", B = 100)
lmer_wild_boot <- bootstrap(vcmodA, .f = fixef, type = "wild", hccme = "hc3", aux.dist = "mammen", B = 100)

# nlme
lme_wild_boot <- bootstrap(vcmodB, .f = fixef, type = "wild", hccme = "hc2", aux.dist = "rademacher", B = 100)
lme_wild_boot <- bootstrap(vcmodB, .f = fixef, type = "wild", hccme = "hc3", aux.dist = "rademacher", B = 100)

Examples

# lme4
lmer_reb_boot0 <- bootstrap(vcmodA, .f = fixef, type = "reb", B = 100, reb_type = 0)
lmer_reb_boot1 <- bootstrap(vcmodA, .f = fixef, type = "reb", B = 100, reb_type = 1)

# nlme
lme_reb_boot2  <- bootstrap(vcmodB, .f = fixef, type = "reb", B = 100, reb_type = 2)

The summary() function

The syntax of the summary() function is similar to the default. The object to be summarized must be the object returned by the bootstrap() call, an lmeresamp object.

summary(lmer_reb_boot1)
#> Bootstrap type: reb1 
#> 
#> Number of resamples: 100 
#> 
#>             term   observed   rep.mean         se         bias
#> 1    (Intercept) 14.1577509 14.1249153 0.83253442 -0.032835674
#> 2       mathAge8  0.6388895  0.6422244 0.02951628  0.003334942
#> 3        genderM -0.3571922 -0.3665807 0.32741055 -0.009388492
#> 4 classnonmanual  0.7200815  0.6941127 0.38675507 -0.025968819
#> 
#> There were 0 messages, 0 warnings, and 0 errors.

The print() Function

The print() function in lmeresampler also follows the syntax of the default print() function. In lmeresampler, print() calls summary() to return information about the bootstrap() call. In addition, if the user would like to print confidence intervals for the object, setting ci = TRUE in print() will call the confint() function and set method = "all" and level = 0.95. If not all of the intervals are of interest or a different confidence level is required, it is recommended that the user directly call confint() on the bootstrap object.

print(lmer_reb_boot0)
#> Bootstrap type: reb0 
#> 
#> Number of resamples: 100 
#> 
#>             term   observed   rep.mean         se          bias
#> 1    (Intercept) 14.1577509 14.2052833 0.74490750  0.0475323733
#> 2       mathAge8  0.6388895  0.6386967 0.02556154 -0.0001927539
#> 3        genderM -0.3571922 -0.3366081 0.34345567  0.0205841512
#> 4 classnonmanual  0.7200815  0.7153171 0.37534918 -0.0047644196
#> 
#> There were 0 messages, 0 warnings, and 0 errors.

print(lme_reb_boot2, ci = TRUE) 
#> Bootstrap type: reb2 
#> 
#> Number of resamples: 100 
#> 
#>                  term   observed   rep.mean        se         bias
#> 1    beta.(Intercept) 14.1577509 14.1577509 0.6495736 0.000000e+00
#> 2       beta.mathAge8  0.6388895  0.6388895 0.0227206 1.110223e-16
#> 3        beta.genderM -0.3571922 -0.3571922 0.3322461 0.000000e+00
#> 4 beta.classnonmanual  0.7200815  0.7200815 0.3590808 0.000000e+00
#> 5      vc.(Intercept)  3.3122380  3.3122380 0.9107288 4.440892e-16
#> 6                 vc2 19.7280582 19.7280582 1.1907404 0.000000e+00
#> 
#> There were 0 messages, 0 warnings, and 0 errors.
#> # A tibble: 18 × 6
#>    term                estimate    lower  upper type  level
#>    <chr>                  <dbl>    <dbl>  <dbl> <chr> <dbl>
#>  1 beta.(Intercept)      14.2   12.9     15.4   norm   0.95
#>  2 beta.mathAge8          0.639  0.594    0.683 norm   0.95
#>  3 beta.genderM          -0.357 -1.01     0.294 norm   0.95
#>  4 beta.classnonmanual    0.720  0.0163   1.42  norm   0.95
#>  5 vc.(Intercept)         3.31   1.53     5.10  norm   0.95
#>  6 vc2                   19.7   17.4     22.1   norm   0.95
#>  7 beta.(Intercept)      14.2   13.0     15.4   basic  0.95
#>  8 beta.mathAge8          0.639  0.593    0.680 basic  0.95
#>  9 beta.genderM          -0.357 -1.07     0.251 basic  0.95
#> 10 beta.classnonmanual    0.720  0.107    1.43  basic  0.95
#> 11 vc.(Intercept)         3.31   1.43     4.91  basic  0.95
#> 12 vc2                   19.7   17.4     21.8   basic  0.95
#> 13 beta.(Intercept)      14.2   12.9     15.3   perc   0.95
#> 14 beta.mathAge8          0.639  0.598    0.685 perc   0.95
#> 15 beta.genderM          -0.357 -0.966    0.355 perc   0.95
#> 16 beta.classnonmanual    0.720  0.00760  1.33  perc   0.95
#> 17 vc.(Intercept)         3.31   1.71     5.20  perc   0.95
#> 18 vc2                   19.7   17.7     22.0   perc   0.95

The confint() Function

Similarly, the syntax of the confint() function resembles the default. The object for which confidence are calculated must be the lmeresamp object returned by the bootstrap() call. The type of confidence interval may be specified with type, for which possible values include: "basic" (basic bootstrap interval), "norm" (normal bootstrap interval), "perc" (percentile bootstrap interval), and "all" (all of aforementioned methods, and the default if method is unspecified). The level at which the confidence interval is to be computed may be specified with level, which defaults to 0.95 if unspecified.

# all ci types, 0.95 confidence level
confint(lme_reb_boot2)
#> # A tibble: 18 × 6
#>    term                estimate    lower  upper type  level
#>    <chr>                  <dbl>    <dbl>  <dbl> <chr> <dbl>
#>  1 beta.(Intercept)      14.2   12.9     15.4   norm   0.95
#>  2 beta.mathAge8          0.639  0.594    0.683 norm   0.95
#>  3 beta.genderM          -0.357 -1.01     0.294 norm   0.95
#>  4 beta.classnonmanual    0.720  0.0163   1.42  norm   0.95
#>  5 vc.(Intercept)         3.31   1.53     5.10  norm   0.95
#>  6 vc2                   19.7   17.4     22.1   norm   0.95
#>  7 beta.(Intercept)      14.2   13.0     15.4   basic  0.95
#>  8 beta.mathAge8          0.639  0.593    0.680 basic  0.95
#>  9 beta.genderM          -0.357 -1.07     0.251 basic  0.95
#> 10 beta.classnonmanual    0.720  0.107    1.43  basic  0.95
#> 11 vc.(Intercept)         3.31   1.43     4.91  basic  0.95
#> 12 vc2                   19.7   17.4     21.8   basic  0.95
#> 13 beta.(Intercept)      14.2   12.9     15.3   perc   0.95
#> 14 beta.mathAge8          0.639  0.598    0.685 perc   0.95
#> 15 beta.genderM          -0.357 -0.966    0.355 perc   0.95
#> 16 beta.classnonmanual    0.720  0.00760  1.33  perc   0.95
#> 17 vc.(Intercept)         3.31   1.71     5.20  perc   0.95
#> 18 vc2                   19.7   17.7     22.0   perc   0.95

# 90% percentile bootstrap intervals
confint(lmer_reb_boot0, method = "perc", level= 0.90)
#> # A tibble: 12 × 6
#>    term           estimate  lower  upper type  level
#>    <chr>             <dbl>  <dbl>  <dbl> <chr> <dbl>
#>  1 (Intercept)      14.2   12.9   15.3   norm    0.9
#>  2 mathAge8          0.639  0.597  0.681 norm    0.9
#>  3 genderM          -0.357 -0.943  0.187 norm    0.9
#>  4 classnonmanual    0.720  0.107  1.34  norm    0.9
#>  5 (Intercept)      14.2   13.0   15.3   basic   0.9
#>  6 mathAge8          0.639  0.605  0.678 basic   0.9
#>  7 genderM          -0.357 -0.915  0.183 basic   0.9
#>  8 classnonmanual    0.720  0.131  1.32  basic   0.9
#>  9 (Intercept)      14.2   13.0   15.3   perc    0.9
#> 10 mathAge8          0.639  0.599  0.673 perc    0.9
#> 11 genderM          -0.357 -0.897  0.200 perc    0.9
#> 12 classnonmanual    0.720  0.124  1.31  perc    0.9

The plot() function

Finally, the plot() function creates a density plot of bootstrap estimates for a default (the first bootstrap statistic, often the intercept) or specified parameter. The bottom of the graph also contains 66% and 95% percentile intervals for the covariate.

Examples

plot(lmer_par_boot) # defaults to printing first variable

plot(lmer_par_boot, "mathAge8") # plot mathAge8 variable

plot(lmer_par_boot, 1) # plots first variable

The density plots are rendered via ggplot2, so axis labels and titles can be altered in the usual way, via labs().

The Idea

Parallelization (also known as parallel computing, parallel processing, or executing “in parallel”) is the idea of splitting a process into sub-processes that execute at the same time. This is of interest in the context of bootstrapping because bootstrapping is often both computation-heavy and time-consuming.

Using parallelization, the processes behind bootstrap() can be executed on multiple computer cores, depending on the makeup of the machine you are using. To check how many cores your machine has, run parallel::detectCores(). This will output the number of cores your CPU “logically” has, which is twice more than the number of cores it physically has. The number of logical cores is the number of cores you may actually use when working in parallel (the more cores you have available to you, the better!). We recommend using multiple cores when possible, without using all/most of your CPU’s cores, which it needs to run everything, not just your IDE (e.g., RStudio). However, if your machine only has one core, parallelization is neither useful nor possible.

Performance

It is important to note that while the number of cores used with parallelization will be some scalar multiple of the default number of one core used for non-parallel processing, the runtime of parallel processes will not be increased by that same scalar. That is, running a process on two cores does not yield a runtime that is twice as fast as running the same process on one core. This is because parallelization takes some overhead to split the processes, so while runtime will substantially improve, it will not correspond exactly to the number of cores being used.

There are two types of parallelization techniques: forking (also known as multicore) and clustering. While forking tends to be slightly faster, it cannot be executed on Windows operating systems; thus, we will spend our time documenting clustering, which is system-agnostic. For more information on how to use forking with parallelization, check out the parallel package.

Implementation

We implement our parallel processing using Steve Weston and Rich Calaway’s guide on jointly using doParallel and foreach, as the code is both concise and simple enough for those without much experience with parallelization. While doParallel and foreach default to multicore (forking) functionality when using parallel computing on UNIX operating systems and snow (clustering) functionality on Windows systems, in order to be as explicit as possible, we will outline our examples using clustering. For more information on forking, please see Weston and Calaway’s guide, “Getting Started with doParallel and foreach”.

The basic idea with clusters is that they execute tasks as a “cluster” of computers, which means that each cluster needs to be fed in information separately. For this reason, clustering has more overhead than forking. Both doParallel and foreach use what Weston and Calaway call “snow-like functionality”, meaning that while the clustering is done using these two packages, it uses the syntax from snow (a now deprecated package). Clusters also need to be “made” and “stopped” with each call to a foreach() loop and doParallel, to explicitly tell the CPU when to begin and end the parallelization.

Examples

With all of this in mind, let’s explore an example using lmeresampler. Notice that we have the user implement the parallelization with the bootstrap() call itself, rather than doing it within lmeresampler itself. Thus, a modified, parallelized, call to bootstrap() is as follows:

library(purrr)
library(foreach)
library(doParallel)
set.seed(1234)
numCores <- 2

cl <- makeCluster(numCores, type = "PSOCK") # make a socket cluster
doParallel::registerDoParallel(cl)          # how the CPU knows to run in parallel
clusterCall(cl, function(x) .libPaths(x), .libPaths())
#> [[1]]
#> [1] "/private/var/folders/p0/kzl82ys143d1wd2kfj24jm_8000pww/T/RtmpfIq1Ry/Rinst128dc6beaf90a"      
#> [2] "/private/var/folders/p0/kzl82ys143d1wd2kfj24jm_8000pww/T/RtmpVRsEB5/temp_libpathe78118a21769"
#> [3] "/Library/Frameworks/R.framework/Versions/4.1/Resources/library"                              
#> 
#> [[2]]
#> [1] "/private/var/folders/p0/kzl82ys143d1wd2kfj24jm_8000pww/T/RtmpfIq1Ry/Rinst128dc6beaf90a"      
#> [2] "/private/var/folders/p0/kzl82ys143d1wd2kfj24jm_8000pww/T/RtmpVRsEB5/temp_libpathe78118a21769"
#> [3] "/Library/Frameworks/R.framework/Versions/4.1/Resources/library"

b_parallel2 <- foreach(B = rep(250, 2), 
                       .combine = combine_lmeresamp,
                       .packages = c("lmeresampler", "lme4")) %dopar% {
                         bootstrap(vcmodA, .f = fixef, type = "parametric", B = B)
                       }

stopCluster(cl)

Let’s compare the runtime of the above b_parallel2 with the same bootstrap run without parallelization. Note that differences in runtime will be somewhat arbitrary for a small number of resamples (say, 100), and will become more pronounced as the number of resamples increases (to 1000, for example), in favor of the parallelized bootstrap.

system.time(b_nopar  <- bootstrap(vcmodA, .f = fixef, type = "parametric", B = 5000))
#>    user  system elapsed 
#>  48.966   0.357  49.719

numCores <- 2
cl <- makeCluster(numCores, type = "PSOCK")
doParallel::registerDoParallel(cl) 
clusterCall(cl, function(x) .libPaths(x), .libPaths())
#> [[1]]
#> [1] "/private/var/folders/p0/kzl82ys143d1wd2kfj24jm_8000pww/T/RtmpfIq1Ry/Rinst128dc6beaf90a"      
#> [2] "/private/var/folders/p0/kzl82ys143d1wd2kfj24jm_8000pww/T/RtmpVRsEB5/temp_libpathe78118a21769"
#> [3] "/Library/Frameworks/R.framework/Versions/4.1/Resources/library"                              
#> 
#> [[2]]
#> [1] "/private/var/folders/p0/kzl82ys143d1wd2kfj24jm_8000pww/T/RtmpfIq1Ry/Rinst128dc6beaf90a"      
#> [2] "/private/var/folders/p0/kzl82ys143d1wd2kfj24jm_8000pww/T/RtmpVRsEB5/temp_libpathe78118a21769"
#> [3] "/Library/Frameworks/R.framework/Versions/4.1/Resources/library"

system.time({
  b_parallel2 <- foreach(B = rep(2500, 2), 
                         .combine = combine_lmeresamp,
                         .packages = c("lmeresampler", "lme4", "purrr", "dplyr")) %dopar% {
                           bootstrap(vcmodA, .f = fixef, type = "parametric", B = B)
                         }
})
#>    user  system elapsed 
#>   0.063   0.009  28.044

stopCluster(cl) 

Pretty useful stuff! The above can be applied to all bootstrap types and models fit using both lme4 and nlme.