Confidence Intervals

For any model fit by glm, add_ci() may compute confidence intervals for predictions using either a parametric method or a bootstrap. The parametric method computes confidence intervals on the scale of the linear predictor Xβ and transforms the intervals to the response level through the inverse link function g⁻¹. Confidence intervals on the linear predictor level are computed using a Normal distribution for Logistic and Poisson regressions or a t distribution otherwise. (This is consistent with the default behavior for the predict.glm function.) The intervals are given by the following expressions:

$$ \begin{equation} g^{-1}\left(x'\hat{\beta} \pm z_{1 - \alpha/2} \sqrt{\hat{\sigma}^2x'(X'X)^{-1} x}\right) \end{equation} $$

for Binomial and Poisson GLMs or

$$ \begin{equation} \label{eq:glmci} g^{-1}\left(x'\hat{\beta} \pm t_{1 - \alpha/2, n-p-1} \sqrt{\hat{\sigma}^2x'(X'X)^{-1} x}\right) \end{equation} $$

for other generalized linear models. In these expressions, we regard X as the model matrix from the original fit, and x as the “new data” matrix. The default method is parametric and is called with add_ci(data, fit, ...). This is the method we generally recommend for constructing confidence intervals for model predictions.

The bootstrap method is called with add_ci(df, fit, type = "boot", ...) and was included originally for making comparisons against the parametric method. There are multiple methods of bootstrap for regression models (resampling cases, resampling residuals, parametric, etc.). The bootstrap method employed by ciTools in add_ci.glm() resamples cases and iteratively refits the model (using the default behavior of boot::boot) to determine confidence intervals. After collecting the bootstrap replicates, a bias-corrected and accelerated (BCa) bootstrap confidence interval is formed for each point in the sample df.

Although there are several methods for computing bootstrap confidence intervals, we don’t provide options to compute all of these types of intervals in ciTools. BCa intervals are slightly larger than parametric intervals, but are less biased than other types of bootstrapped intervals, including percentile based intervals. We may consider adding more types of bootstrap intervals to ciTools in the future.

x <- rnorm(100, mean = 5)
y <- rbinom(n = 100, size = 1, prob = invlogit(-20 + 4*x))
df <- data.frame(x = x, y = y)
fit <- glm(y ~ x, family = binomial)

df1 <- add_ci(df, fit, names = c("lwr", "upr"), alpha = 0.1) %>%
    mutate(type = "parametric")

df2 <- add_ci(df, fit, type = "boot", names = c("lwr", "upr"), alpha = 0.1, nSims = 500) %>%
    mutate(type = "bootstrap")

df <- bind_rows(df1, df2)

ggplot(df, aes(x = x, y = y)) +
    ggtitle("Logistic Regression", subtitle = "Model fit (black line) and confidence intervals (gray)") +
    geom_jitter(height = 0.01) +
    geom_ribbon(aes(ymin = lwr, ymax = upr), alpha = 0.4) +
    geom_line(aes(x =x , y = pred), size = 2) +
    facet_grid(~type)

## New names:
## • `x` -> `x...1`
## • `y` -> `y...2`
## • `pred` -> `pred...3`
## • `type` -> `type...6`
## • `x` -> `x...7`
## • `y` -> `y...8`
## • `pred` -> `pred...9`
## • `type` -> `type...12`

Prediction Intervals

Generally, parametric prediction intervals for GLMs are not available. The solution ciTools takes is to perform a parametric bootstrap on the model fit, then take quantiles on the bootstrapped data produced for each observation. The procedure is performed via arm::sim. The method of the parametric bootstrap is described by the following algorithm:

1. Fit the GLM, and collect the regression statistics β̂ and $\hat{\mathrm{Cov}}(\hat{\beta})$. Set the number of simulations, M.

2. Simulate M draws of the regression coefficients, β̂_*, from $N(\hat{\beta}, \hat{\mathrm{Cov}}(\hat{\beta}))$, where $\hat{\mathrm{Cov}}(\hat{\beta}) = \hat{\sigma}^2 (X'X)^{-1}$.

3. Simulate [y_*|x] from the response distribution with mean g⁻¹(xβ̂_*) and a variance determined by the response distribution.

4. Determine the α/2 and 1 − α/2 quantiles of the simulated response [y_*|x] for each x.

The parametric bootstrap method propagates the uncertainty in the regression effects β̂ into the simulated draws from the predictive distribution.

Generally, there are many different ways to calculate the quantiles of an empirical distribution, but the approach that ciTools takes ensures that estimated quantiles lie in the support set of the response. The choice we make corresponds to setting type = 1 in quantile().

We have seen in our simulations that the parametric bootstrap provides interval estimates with approximately nominal probability coverage. The unfortunate side effect of opting to construct prediction intervals through a parametric bootstrap is that the parameters of the predictive distributions need to hard coded for each model. For this reason, ciTools does not have complete coverage of all models one could fit with glm.

One exception to this scheme are GLMs with Gaussian errors. In this case we may parametrically calculate prediction intervals. Under Gaussian errors, glm() permits the use of the link functions “identity”, “log”, and “inverse”. The corresponding models are given by the following expressions:

$$ \begin{equation} \label{eq:gauss-link} \begin{split} y = X\beta + \epsilon\\ y = \exp(X\beta) + \epsilon \\ y = \frac{1}{X\beta} + \epsilon \end{split} \end{equation} $$

The conditional response distribution in each case may be written y ∼ N(g⁻¹(Xβ), σ²), and prediction intervals may be computed parametrically. Parametric prediction intervals are therefore constructed via

$$ \begin{equation} \label{eq:gauss-pi} g^{-1}(x'\beta) \pm t_{1-\alpha/2, n-p-1} \sqrt{\hat{\sigma}^2 + \hat{\sigma}^2x'(X'X)^{-1}x} \end{equation} $$

for Gaussian GLMs. As in the linear model, σ̂² estimates the predictive uncertainty and σ̂²x(X′X)⁻¹x estimates the inferential uncertainty in the fitted values. Note that g⁻¹(Xβ̂) is a maximum likelihood estimate for the parameter g⁻¹(Xβ), by the functional invariance of maximum likelihood estimation.

At this point, the only GLMs that we support with add_pi() are Guassian, Poisson, Binomial, Gamma, and Quasipoisson (all of which need to be fit with glm()). The models not supported by add_pi.glm are inverse Gaussian, Quasi, and Quasi-binomial.

Poisson Example

Poisson regression is usually the first line of defense against count data, so we wish to present a complete example of quantifying uncertainty for this type of model with ciTools. For simplicity we fit a model on fake data.

We use rnorm to generate a covariate, but the randomness of x has no bearing on the model.

x <- rnorm(100, mean = 0)
y <- rpois(n = 100, lambda = exp(1.5 + 0.5*x))
df <- data.frame(x = x, y = y)
fit <- glm(y ~ x , family = poisson(link = "log"))

As seen previously, the commands in ciTools are “pipeable”. Here, we compute confidence and prediction intervals for a model fit at the 90% level. The warning message only serves to remind the user that precise quantiles cannot be formed for non-continuous distributions.

df_ints <- df %>%
  add_ci(fit, names = c("lcb", "ucb"), alpha = 0.1) %>%
  add_pi(fit, names = c("lpb", "upb"), alpha = 0.1, nSims = 20000) %>%
  head()

## Warning in add_pi.glm(., fit, names = c("lpb", "upb"), alpha = 0.1, nSims =
## 20000): The response is not continuous, so Prediction Intervals are approximate

As with other methods available in ciTools the requested statistics are computed, appended to the data frame, and returned to the user as a data frame.

df_ints %>%
    ggplot(aes(x = x, y = y)) +
    geom_point(size = 2) +
    ggtitle("Poisson Regression", subtitle = "Model fit (black line), with prediction intervals (gray), confidence intervals (dark gray)") +
    geom_line(aes(x = x, y = pred), size = 1.2) +
    geom_ribbon(aes(ymin = lcb, ymax = ucb), alpha = 0.4) +
    geom_ribbon(aes(ymin = lpb, ymax = upb), alpha = 0.2)

Since the response y is count data, and the method we used to determine the intervals involves simulation, we find that ciTools will produce “jagged” bounds when all the intervals are plotted simultaneously. Increasing the number of simulations using the nSims argument in add_pi can help reduce some of this unsightliness.

We may also wish to compute response-level probabilities and quantiles. ciTools can also handle these estimates with add_probs() and add_quantile() respectively. We use the same parametric bootstrap approach for estimating quantiles and probabilities that we employed for add_pi(). Once again, an error message reminds the user that their support is not continuous.

df %>%
  add_probs(fit, q = 10) %>%
  add_quantile(fit, p = 0.4) %>%
  head()

## Warning in add_probs.glm(., fit, q = 10): The response is not continuous, so
## estimated probabilities are only approximate

## Warning in add_quantile.glm(., fit, p = 0.4): The response is not continuous,
## so estimated quantiles are only approximate

##            x y     pred prob_less_than10 quantile0.4
## 1 -1.2725648 7 2.145159           0.9995           2
## 2 -0.3948852 0 3.492482           0.9965           3
## 3  0.1444020 4 4.711910           0.9755           4
## 4  0.0745726 6 4.532688           0.9780           4
## 5 -1.6400189 3 1.749197           1.0000           1
## 6  0.1952983 4 4.846988           0.9750           4

x <- runif(n = 100, min = 0, max = 2)
mu <- exp(1 + x)
y <- rnegbin(n = 100, mu = mu, theta = mu/(5 - 1))

df <- data.frame(x = x, y = y)
fit <- glm(y ~ x, family = quasipoisson(link = "log"))
summary(fit)$dispersion

## [1] 3.73578

df_ints <- add_ci(df, fit, names = c("lcb", "ucb"), alpha = 0.05) %>%
    add_pi(fit, names = c("lpb", "upb"), alpha = 0.1, nSims = 20000)

## Warning in add_pi.glm(., fit, names = c("lpb", "upb"), alpha = 0.1, nSims =
## 20000): The response is not continuous, so Prediction Intervals are approximate

ggplot(df_ints, aes(x = x, y = y)) +
    ggtitle("Quasipoisson Regression", subtitle = "Model fit (black line), with Prediction intervals (gray), Confidence intervals (dark gray)") +
    geom_point(size = 2) +
    geom_line(aes(x = x, y = pred), size = 1.2) +
    geom_ribbon(aes(ymin = lcb, ymax = ucb), alpha = 0.4) +
    geom_ribbon(aes(ymin = lpb, ymax = upb), alpha = 0.2)

Simulation Study for Prediction Intervals

A simulation study was performed to examine the empirical coverage probabilities of prediction intervals formed using the parametric bootstrap. We focus on these intervals because we could not find results in the literature addressing their performance. Our simulation is not comprehensive, so users of ciTools should exercise care when using these methods. In each simulation, a simple y = g⁻¹(mx + b) model is fit on a variable number of observations.

New observations were generated from the true model to determine if the empirical coverage was close to the nominal level. The mean interval width was also recorded, as were standard errors of the estimated coverage and mean interval width.

Note that in contrast to a study of confidence intervals, we do not expect interval widths to shrink to 0 as sample size tends to infinity. This is due to the predictive error in the conditional response distribution, which is not a factor in the construction of confidence intervals.

We take the same approach in the simulation study of each of the four models described below:

1. Set a sequence of sample sizes e.g. n = 20, 50, 100, ....
2. For each sample size, set a model matrix
3. Then loop …
   • Generate a response vector from the true model
   • Fit a GLM to the simulated response y with the fixed model matrix
   • Calculate a prediction interval for y_new given x₀, the midpoint of the range of x using 2000 bootstrap replicates.
   • Store the width of this prediction interval.
   • Generate a response y_new|x₀ from the true model and determine if the new response is in the PI.
4. Repeat Step 3 M times.

pois <- read.csv("pois_pi_results.csv") %>%
  dplyr::select(-total_time) %>%
  rename(nominal_level = level) %>%
  dplyr::select(sample_size, everything())
knitr::kable(pois)

neg_bin <- read.csv("negbin_pi_results.csv") %>%
  dplyr::select(-total_time) %>%
  rename(nominal_level = level) %>%
  dplyr::select(sample_size, everything())
knitr::kable(neg_bin)

gam <- read.csv("gamma_pi_results.csv") %>%
  dplyr::select(-total_time) %>%
  rename(nominal_level = level) %>%
  dplyr::select(sample_size, everything())

knitr::kable(gam)

norm_log <- read.csv("gaussian_pi_loglink_results.csv") %>%
  dplyr::select(-total_time) %>%
  rename(nominal_level = level) %>%
  dplyr::select(sample_size, everything())
knitr::kable(norm_log)

Summary

ciTools is a versatile R package that helps users quantify uncertainty about their generalized linear models. Creating interval estimates that are amenable to plotting is now as simple as fitting a GLM. To date, we provide coverage for many common GLMs used by practitioners. For the models covered by ciTools, our simulations show that our confidence and prediction intervals are trustworthy.

There is still work to be done on this portion of ciTools. We would like to

1. Include more parametric methods for prediction intervals.

2. Add facilities to handle CIs and PIs when offset terms are present in the model fit.

3. Further study interval estimates pertaining to the negative binomial model.

4. Produce a simulation study that compares parametric vs. bootstrap intervals for GLMs.

5. Offer alternative prediction intervals e.g. the shortest intervals that contain 95% of the simulated data.

6. Include options beyond BCa for creating bootstrap confidence intervals.

sessionInfo()

## R version 4.4.2 (2024-10-31)
## Platform: x86_64-pc-linux-gnu
## Running under: Ubuntu 24.04.1 LTS
## 
## Matrix products: default
## BLAS:   /usr/lib/x86_64-linux-gnu/openblas-pthread/libblas.so.3 
## LAPACK: /usr/lib/x86_64-linux-gnu/openblas-pthread/libopenblasp-r0.3.26.so;  LAPACK version 3.12.0
## 
## locale:
##  [1] LC_CTYPE=en_US.UTF-8       LC_NUMERIC=C              
##  [3] LC_TIME=en_US.UTF-8        LC_COLLATE=C              
##  [5] LC_MONETARY=en_US.UTF-8    LC_MESSAGES=en_US.UTF-8   
##  [7] LC_PAPER=en_US.UTF-8       LC_NAME=C                 
##  [9] LC_ADDRESS=C               LC_TELEPHONE=C            
## [11] LC_MEASUREMENT=en_US.UTF-8 LC_IDENTIFICATION=C       
## 
## time zone: Etc/UTC
## tzcode source: system (glibc)
## 
## attached base packages:
## [1] stats     graphics  grDevices utils     datasets  methods   base     
## 
## other attached packages:
## [1] arm_1.14-4     lme4_1.1-36    Matrix_1.7-2   MASS_7.3-64    knitr_1.49    
## [6] ggplot2_3.5.1  ciTools_0.6.1  dplyr_1.1.4    rmarkdown_2.29
## 
## loaded via a namespace (and not attached):
##  [1] sass_0.4.9        generics_0.1.3    lattice_0.22-6    digest_0.6.37    
##  [5] magrittr_2.0.3    evaluate_1.0.3    grid_4.4.2        fastmap_1.2.0    
##  [9] jsonlite_1.8.9    scales_1.3.0      jquerylib_0.1.4   abind_1.4-8      
## [13] reformulas_0.4.0  Rdpack_2.6.2      cli_3.6.3         rlang_1.1.5      
## [17] rbibutils_2.3     munsell_0.5.1     splines_4.4.2     withr_3.0.2      
## [21] cachem_1.1.0      yaml_2.3.10       tools_4.4.2       nloptr_2.1.1     
## [25] coda_0.19-4.1     minqa_1.2.8       colorspace_2.1-1  boot_1.3-31      
## [29] buildtools_1.0.0  vctrs_0.6.5       R6_2.5.1          lifecycle_1.0.4  
## [33] pkgconfig_2.0.3   pillar_1.10.1     bslib_0.8.0       gtable_0.3.6     
## [37] glue_1.8.0        Rcpp_1.0.14       xfun_0.50         tibble_3.2.1     
## [41] tidyselect_1.2.1  sys_3.4.3         farver_2.1.2      htmltools_0.5.8.1
## [45] nlme_3.1-167      labeling_0.4.3    maketools_1.3.1   compiler_4.4.2