NIMBLE https://r-nimble.org/blog/ An R package for programming with BUGS models and compiling parts of R quarto-1.7.31 Wed, 18 Feb 2026 08:00:00 GMT Version 1.4.1 of NIMBLE released NIMBLE Development Team https://r-nimble.org/blog/version-1-4-1-of-nimble-released.html We’ve released the newest version of NIMBLE on CRAN and on our website. NIMBLE is a system for building and sharing analysis methods for statistical models, especially for hierarchical models and computationally-intensive methods (such as MCMC, Laplace approximation, and SMC).

Version 1.4.1 is a micro release that primarily addresses some minor issues, but it also includes:

  • An MCMC sampler for sampling elements of partially observed multivariate normal random variables, e.g., if one has some elements of a data vector that are missing.
  • The ability to change the MCMC thinning interval when continuing an MCMC.

Please see the release notes on our website for more details.

]]> release announcement R https://r-nimble.org/blog/version-1-4-1-of-nimble-released.html Wed, 18 Feb 2026 08:00:00 GMT Using nimbleQuad for maximum likelihood estimation and deterministic posterior approximation Paul van Dam-Bates and Christopher Paciorek https://r-nimble.org/blog/nimbleQuad.html

Introduction

The new nimbleQuad package provides quadrature-based inference methods that use Laplace and Adaptive Gauss-Hermite Quadrature (AGHQ) approximation. It has two main components:

  1. Laplace and AGHQ approximations for marginalizing over latent nodes (e.g., random effects) to perform approximate maximum likelihood estimation.
  2. Deterministic nested quadrature methods for posterior approximation using Laplace approximation for the inner marginalization of the latent nodes and general quadrature methods for outer marginalization of the parameter nodes. These methods borrow ideas from the popular INLA approach (Rue, Martino, and Chopin 2009) and from the extended Gaussian latent model approach provided in the R aghq package (Stringer, Brown, and Stafford 2023).

The first component was present in the core nimble package until version 1.4.0. The second component is a new feature.

By providing these methods in the NIMBLE system, via nimbleQuad, users can use the methods on models constructed using the NIMBLE model language (which extends the BUGS model language) and can also customize and extend the algorithms.

In this document we will introduce some of the workflow and show the flexibility available when using buildNestedApprox for posterior approximations.

Additional details about nimbleQuad can be found in the NIMBLE User Manual and the nimbleQuad vignette.

What is NIMBLE?

NIMBLE is a system for writing hierarchical statistical models and algorithms. It is distributed as the R package, nimble. NIMBLE includes:

  1. A dialect of the BUGS model language that is extensible. NIMBLE uses almost the same model code as WinBUGS, OpenBUGS, and JAGS. Being “extensible” means that it is possible to write new functions and distributions and use them in your models.

  2. An algorithm library including Markov chain Monte Carlo (MCMC) and other methods.

  3. A compiler that generates C++ for each model and algorithm, compiles the C++, and lets you use it from R. You don’t need to know anything about C++ to use nimble.

Illustrative Example

For this vignette we will use the salamander example from the R package glmmTMB. Example usage of this model can be seen by running ?glmmTMB. The data are repeated counts, , of salamanders at multiple sites, which are zero-inflated. Some of the sites are mined, and some are not (). Based on glmmTMB, we can analyze these data as

The maximum likelihood estimator can be found with glmmTMB.

library(glmmTMB)
data(Salamanders)
fit_tmb <- glmmTMB(count ~ spp * mined + (1|site), zi=~1, family=poisson, data=Salamanders)

We can also fit this model in INLA to get the approximate posterior using the “zeroinflatedpoisson1” model family.

library(INLA)
fit_inla <- inla( count ~ spp * mined + f(site, model="iid"), 
  quantiles = c(.025,.25,.5,.75,.975), family= "zeroinflatedpoisson1", data=Salamanders,
  control.inla = list(int.strategy = "ccd"))

Building a GLMM in NIMBLE

To write this model in NIMBLE we will first write a zero-inflated Poisson distribution that marginalizes over the indirectly observed discrete value . When , is a discrete latent variable. In order to use the methods in nimbleQuad, all the latent variables in this model must be continuous.

nimbleQuad relies on automatic differentiation (AD) to take derivatives. To include AD in a nimbleFunction we must set buildDerivs = 'run'.

A nimbleFunction, rZIP, to simulate from the distribution is also provided for convenience, although this is not strictly needed for this model to fit.

library(nimbleQuad)
dZIP <- nimbleFunction(
 run = function(x = double(), lambda = double(),
                zeroProb = double(), log = logical(0, default = 0)) {
   returnType(double())
   ## For use with AD, we cannot use an `if` statement to handle the mixture.
   prob <- zeroProb * dbinom(x, size = 1, prob = 0) + (1 - zeroProb) * dpois(x, lambda)
   if (log) return(log(prob))
     return(prob)
   },
   buildDerivs = 'run'   # Needed when used with AD-based algorithms.
)

rZIP <- nimbleFunction(
 run = function(n = integer(), lambda = double(), zeroProb = double()) {
   returnType(double())
   isStructuralZero <- rbinom(1, prob = zeroProb, size = 1)
   if (isStructuralZero) return(0)
   return(rpois(1, lambda))
})

We will use prior distributions to match the default priors in the INLA model that was fit above to allow direct comparison of results. See inla.priors.used(fit_inla) for a description of the default priors. INLA places a logit-normal prior on . For convenience, we will write our own logit-normal prior. In this case, we explicitly register the distribution to tell NIMBLE the range of possible values, needed for use in NIMBLE’s parameter transformation system.

dlogitnormal = nimbleFunction(
  run = function(x = double(), mean = double(), sd = double(), 
      log = logical(0, default = 0)){
    ans <- dnorm(logit(x), mean = mean, sd = sd, log = TRUE) - log(x) - log(1-x)
    returnType(double())
    if(log) return(ans)
    else return(exp(ans))
  },
  buildDerivs = 'run'
)

registerDistributions(list(
  dlogitnormal = list(BUGSdist = "dlogitnormal(mean, sd)", range = c(0,1))
))
  [Warning] Random generation function for dlogitnormal is not available. NIMBLE is generating a placeholder function, rlogitnormal, that will invoke an error if an algorithm needs to simulate from this distribution. Some algorithms (such as random-walk Metropolis MCMC sampling) will work without the ability to simulate from the distribution.  If simulation is needed, provide a nimbleFunction (with no setup code) to do it.

If not trying to use the same model as INLA, one might choose different priors, and one would not necessarily need to define the logit-normal distribution.

Following INLA, we use a completely flat prior on the intercept dflat, a gamma prior on precision tau_re and a logit-normal on p. We can now write the model code, and then provide constants and data to build the model.

code <- nimbleCode({
  beta[1] ~ dflat()
  for( i in 2:np ) 
    beta[i] ~ dnorm(0, tau = 0.001) 
  tau_re ~ dgamma(shape = 1, rate = 5e-5)
  p ~ dlogitnormal(mean = -1, sd = 1/sqrt(0.2))
  
  for(i in 1:nsites) 
    re[i] ~ dnorm(0, tau = tau_re)

  for( i in 1:nobs ){
    log(lam[i]) <- sum(beta[1:np]*X[i,1:np]) + re[site[i]]
    count[i] ~ dZIP(lambda = lam[i], zeroProb = p)
  }
})

nimconst <- list()
nimconst$X <- as.matrix(model.matrix( ~ spp * mined, data = Salamanders ))
nimconst$np <- ncol(nimconst$X)
nimconst$nobs <- nrow(nimconst$X)
nimconst$site <- as.numeric(factor(Salamanders$site))
nimconst$nsites <- max(nimconst$site)

nimdata <- list()
nimdata$count <- Salamanders$count

inits <- list(p = .29,
  tau_re = 3,
  re = rnorm(nimconst$nsites,0,0.1),
  beta = rnorm(nimconst$np))

m <- nimbleModel(code, data = nimdata, constants = nimconst, inits = inits, buildDerivs = TRUE)
Defining model
  [Note] Registering 'dZIP' as a distribution based on its use in BUGS code. If you make changes to the nimbleFunctions for the distribution, you must call 'deregisterDistributions' before using the distribution in BUGS code for those changes to take effect.
Building model
Setting data and initial values
Running calculate on model
  [Note] Any error reports that follow may simply reflect missing values in model variables.
Checking model sizes and dimensions
cm <- compileNimble(m)
Compiling
  [Note] This may take a minute.
  [Note] Use 'showCompilerOutput = TRUE' to see C++ compilation details.

Note that since nimbleQuad methods use NIMBLE’s automatic differentiation (AD) system, we set buildDerivs = TRUE when building the nimble model.

Using the Laplace Approximation

We can find the maximum likelihood estimate by using buildLaplace (or buildAGHQ if we want more quadrature nodes for marginalizing over the random effects, as discussed below).

laplace <- buildLaplace(model = m)
Building 23 individual Laplace approximations (one dot for each): .......................
claplace <- compileNimble(laplace)
Compiling
  [Note] This may take a minute.
  [Note] Use 'showCompilerOutput = TRUE' to see C++ compilation details.
nimble_fit <- runLaplace(claplace)

NIMBLE reports that it is able to use 23 separate (one-dimensional) Laplace approximations (because the random effects, plus their data dependencies, are conditionally independent).

Let’s compare the results with glmmTMB. The results are very similar.

nimble_params <- nimble_fit$summary$params
nimble_fixef <- nimble_params[grep("beta", rownames(nimble_params)),]

plot(nimble_fixef[, "estimate"], fixef(fit_tmb)$cond, 
  xlab = "NIMBLE Estimate", ylab = "glmmTMB Estimate")
abline(a = 0, b = 1, lty = 2)

# logit(p):
fit_tmb$fit$par["betazi"]     # TMB
   betazi 
-0.933805 
logit(nimble_params["p",1])   # NIMBLE
[1] -0.9338518
# tau_re
exp(-2*fit_tmb$fit$par["theta"])  # TMB
   theta 
3.646564 
nimble_params["tau_re",1]         # NIMBLE
[1] 3.646879

It can be helpful to check the Laplace approximation at the MLE by increasing the number of quadrature nodes using AGHQ. If the likelihood is very different when increasing the number of quadrature nodes, that indicates that Laplace was not a good approximation to the marginal likelihood. In this particular case, since we have have conditionally independent random effects (and therefore a set of 1-dimensional AGHQ approximations), increasing the number of quadrature nodes will be relatively quick, but in other cases it can be very slow.

claplace$calcLogLik(nimble_fit$summary$params[, 'estimate'], trans = FALSE)
[1] -881.9147
claplace$updateSettings(nQuad = 5)
claplace$calcLogLik(nimble_fit$summary$params[, 'estimate'], trans = FALSE)
[1] -881.8752
claplace$updateSettings(nQuad = 11)
claplace$calcLogLik(nimble_fit$summary$params[, 'estimate'], trans = FALSE)
[1] -881.8749

Posterior Approximation

Posterior approximation is done by buildNestedApprox (to build the approximation) and runNestedApprox (to calculate the approximation). Note that the setup for buildNestedApproxis similar to buildLaplace except that we refer to the combination of random effects and fixed effects as latentNodes and the hyperparameters as paramNodes, which we will refer to more generally as the “parameters”. Including fixed effects with the random effects reduces the dimension of the outer quadrature, which reduces computation time. However, in some cases one may want to include the fixed effects in the paramNodes, as the choice of where to include the fixed effects can affect statistical performance. If the user does not specify latentNodes and paramNodes, NIMBLE will automatically determine them based on the graphical structure of the model, and the user can check that a reasonable determination has been made.

approx <- buildNestedApprox(model = m, 
                            paramNodes = c('p', 'tau_re'), 
                            latentNodes = c('beta', 're'))
Building nested posterior approximation for the following node sets:
  - parameter nodes: p, tau_re
  - latent nodes: beta (14 elements), re (23 elements)
  with AGHQ grid for the parameters and Laplace approximation for the latent nodes.
Building Laplace approximation.
capprox <- compileNimble(approx, project = m)
Compiling
  [Note] This may take a minute.
  [Note] Use 'showCompilerOutput = TRUE' to see C++ compilation details.

We then use runNestedApprox to run the basic approximation and apply various methods to the output object to carry out further inference. The steps include:

  1. Find posterior mode of the parameters using Laplace (or AGHQ) to marginalize over the latent nodes.
  2. Use an integration-free method analogous to that of INLA to quickly approximate the marginal posterior distribution of each parameter (Martins et al. 2013).
  3. Calculate the posterior density of the parameters across the parameter quadrature grid (the default grid uses the CCD (central composite design) approach when the number of parameters is greater than two). In addition, a quadrature-based marginal log likelihood is produced based on this computation.
  4. Sample from the joint posterior of the latentNodes using a mixture of multivariate normal distributions with mean, covariance, and weights obtained at each grid point in the parameter quadrature grid.

Using the integration-free method is the fastest way to produce marginal posterior density estimates of the parameters. Following the methodology of INLA, this is done by using an asymmetric multivariate normal distribution to approximate the posterior density of the parameters.

If more accuracy is required, quadrature can be used such as AGHQ to marginalize over the other parameters (similar to the R package aghq). Here the user can choose between AGHQ, CCD, sparse AGHQ, or a user-provided quadrature rule, as discussed further below). Marginal density values are computed at a fixed set of points and then a spline is used for computations with the univariate density.

For inference on the latent nodes, at each point in the parameter grid, Laplace is used to marginalize the latent nodes to calculate the posterior density for the point, which requires an inner optimization. This can be computationally expensive (particularly with a large number of latent nodes), scaling with the number of grid points. CCD is the default (as is done in INLA) because it scales well to higher dimensions. Alternatively, an AGHQ grid can be used. This will be computationally more expensive because there are more grid points but potentially more accurate. The user can also provide their own grid. By default, we do not do compute the parameter grid when calling runNestedApprox unless requested, because the integration-free estimates do not require it. However, it is necessary for inference on the latent nodes and is done automatically when the latent nodes are sampled (via sampleLatents).

Here is the initial (integration-free) inference for the parameters. We compare results to samples from a long HMC (MCMC) run.

result <- runNestedApprox(approx = capprox)
Finding posterior mode for parameter(s).
result
Model (hyper)parameters: 
            mean         sd      2.5%       25%       50%      75%     97.5%
p      0.2829532 0.03213737 0.2223163 0.2607501 0.2822413 0.304266 0.3480409
tau_re 4.2832265 2.21980867 1.4690074 2.7377845 3.7993353 5.280151 9.9046828

Marginal log-likelihood (asymmetric Gaussian approximation): -957.392(*)
  (*) Invalid for improper priors and may not be useful for non-informative priors.
par(mfrow = c(1,2))

result$plotMarginal("tau_re", xlim = c(0,17), lwd=2)
lines(hmc_tau_re$x, inla.dmarginal(hmc_tau_re$x, fit_inla$marginals.hyperpar[[2]]), col = 'red')
lines(hmc_tau_re, col = 'green')
legend("topright", legend = c("NIMBLE\nnested approx", "INLA", "HMC"),
  col = c('black','red','green'), lty = rep(1,3), cex = 0.75, bty = 'n')

result$plotMarginal("p", lwd=2)
lines(hmc_p$x, inla.dmarginal(hmc_p$x, fit_inla$marginals.hyperpar[[1]]), col = 'red')
lines(hmc_p, col = 'green')

The nested approximation and INLA results match MCMC well, though for some reason the densities plotted by INLA don’t quite integrate to one and therefore lies above the other two lines.

Here is the sampling-based inference for the latent nodes. The density estimates match HMC reasonably well, but not quite as well as INLA for the fixed effects.

# remove these lines later
# hmc_beta1 <- density(samples_hmc[ , 'beta[1]'])
# hmc_beta2 <- density(samples_hmc[ , 'beta[2]'])
# hmc_re1 <- density(samples_hmc[ , 're[1]'])

result$sampleLatents(10000)
Calculating inner AGHQ/Laplace approximation at 9 parameter (outer)
  grid points (one dot per point): .........
par(mfrow = c(1,3))
plot(density(result$samples[, "beta[1]"]), main = "", xlab = "beta[1]")
lines(hmc_beta1$x, inla.dmarginal(hmc_beta1$x, fit_inla$marginals.fixed[[1]]), col = 'red')
lines(hmc_beta1, col = 'green')
plot(density(result$samples[, "beta[2]"]), main = "", xlab = "beta[2]")
lines(hmc_beta2$x, inla.dmarginal(hmc_beta2$x, fit_inla$marginals.fixed[[2]]), col = 'red')
lines(hmc_beta2, col = 'green')
plot(density(result$samples[, "re[1]"]), main = "", xlab = "re[1]")
lines(hmc_re1$x, inla.dmarginal(hmc_re1$x, fit_inla$marginals.random[[1]][[1]]), col = 'red')
lines(hmc_re1, col = 'green')

Improving the Parameter Marginals

Although the integration-free method is fast and performs reasonably well, it may be that the user wishes to get a more exact marginal. This is done individually for each parameter of interest, marginalizing over the remaining parameters using an outer quadrature rule (AGHQ, CCD, AGHQSPARSE, USER), with AGHQ as the default. We choose the number of quadrature points for marginalization (nQuad) as well as the number of points along a grid to evaluate the marginal (nMarginalGrid). Increasing either can improve performance but at the expense of additional computation and generally with diminishing improvement.

result  # Original (integration-free) parameter estimates
Model (hyper)parameters: 
            mean         sd      2.5%       25%       50%      75%     97.5%
p      0.2829532 0.03213737 0.2223163 0.2607501 0.2822413 0.304266 0.3480409
tau_re 4.2832265 2.21980867 1.4690074 2.7377845 3.7993353 5.280151 9.9046828

Marginal log-likelihood (asymmetric Gaussian approximation): -957.392(*)
Marginal log-likelihood (grid-based): -957.3845(*)
  (*) Invalid for improper priors and may not be useful for non-informative priors.
result$improveParamMarginals(nodes = c('tau_re', 'p'),
  nMarginalGrid = 9, nQuad = 3, quadRule = "AGHQ")
Approximating 2 individual parameter marginal densities via AGHQ:
  - calculating inner AGHQ/Laplace approximation at (9) marginal points
    with 3 quadrature grid points (one dot per grid point): (1)...(2)...(3)...(4)...(5)...(6)...(7)...(8)...(9)...
  - calculating inner AGHQ/Laplace approximation at (9) marginal points
    with 3 quadrature grid points (one dot per grid point): (1)...(2)...(3)...(4)...(5)...(6)...(7)...(8)...(9)...
Model (hyper)parameters: 
            mean         sd     2.5%       25%       50%       75%     97.5%
p      0.2829161 0.03233042 0.220414 0.2608876 0.2826332 0.3046184  0.347118
tau_re 4.3240215 2.34440791 1.450420 2.7365618 3.8040399 5.3028558 10.249151

Marginal log-likelihood (asymmetric Gaussian approximation): -957.392(*)
Marginal log-likelihood (grid-based): -957.3845(*)
  (*) Invalid for improper priors and may not be useful for non-informative priors.

Comparing to the quantiles from the integration-free approach, the differences are generally minor, but there is a noticeable difference in the right tail for tau_re.

Customizing the Quadrature Grid

For the salamanders example, we have two parameters, for which nimbleQuad defaults to using AGHQ as the parameter grid. The grid points are skewed based on the skew from the asymmetric multivariate normal approximation, and then scaled using spectral decomposition (or Cholesky decomposition).

For more than two parameters, nimbleQuad defaults to using a CCD grid, also used by INLA.

The user may also provide their own parameter grid. This must be written as a nimbleFunction with some specific components and is described in the nimbleQuad vignette.

Sampling from the posterior over parameters

The user may also choose to sample from the asymmetric multivariate normal approximation to make inference about the parameters. This can be particularly useful when making inference on parameters with dimension changes (e.g., proportions with a Dirichlet prior or elements of a covariance matrix, such as one with a Wishart or LKJ prior) or generally making inference about functionals of multiple parameters.

samples_params <- result$sampleParams(10000)
result$plotMarginal("tau_re", xlim = c(0,17), lwd=2)
lines(density(samples_params[,2]), col = 'black', lty = 2)
lines(hmc_tau_re, col = 'green')
legend("topright", legend = c("nested approx", "nested approx, samples", "HMC"),
  col = c('black','black','green'), lty = c(1,2,1), bty = 'n')

Model selection and the marginal likelihood

With proper priors, one can calculate , the marginal likelihood, which is useful for model selection. This is reported with the nested approximation results, initially using an asymmetric multivariate normal approximation to the joint posterior of the parameters. An an improved estimate based on quadrature over the parameter grid (by default using AGHQ) can be obtained using the calcMarginalLogLikImproved method of the nested approximation object.

However, much caution is warranted. The quantity is ill-defined when the prior is improper. Furthermore, even with proper priors, if the prior is diffuse, the integral will generally average over values of the parameters that give very poor fits to the data, which can produce misleading results for model selection.

References

Martins, Thiago G, Daniel Simpson, Finn Lindgren, and Håvard Rue. 2013. “Bayesian Computing with INLA: New Features.” Computational Statistics & Data Analysis 67: 68–83.
Rue, Håvard, Sara Martino, and Nicolas Chopin. 2009. “Approximate Bayesian Inference for Latent Gaussian Models by Using Integrated Nested Laplace Approximations.” Journal of the Royal Statistical Society Series B: Statistical Methodology 71 (2): 319–92.
Stringer, Alex, Patrick Brown, and Jamie Stafford. 2023. “Fast, Scalable Approximations to Posterior Distributions in Extended Latent Gaussian Models.” Journal of Computational and Graphical Statistics 32 (1): 84–98.
]]> R tutorial https://r-nimble.org/blog/nimbleQuad.html Thu, 29 Jan 2026 08:00:00 GMT Using derived quantities in NIMBLE’s MCMC system NIMBLE Development Team https://r-nimble.org/blog/derived-quantities.html NIMBLE is a system for building and sharing analysis methods for statistical models, especially for hierarchical models and computationally-intensive methods (such as MCMC, Laplace approximation, and sequential Monte Carlo).

As of version 1.4.0, NIMBLE allows one to specify “derived quantities” to calculate or record additional quantities of interest during an MCMC. Potential derived quantities include:

  • posterior means,
  • posterior variances,
  • log-probabilities (log-density values) for single or (summed) groups of nodes,
  • posterior predictive samples for predictive nodes, and
  • arbitrary calculations by providing a user-defined nimbleFunction that follows the required specification.

By using derived quantities, users can avoid adding additional nodes to the model itself and can potentially reduce how much is stored during an MCMC run and saved as output from the run, thereby reducing memory and disk use.

We’ll give a brief example of saving log-probability (log-posterior-density) values summed over a set of nodes in a simple Poisson random effects model.

library(nimble)
pumpCode <- nimbleCode({ 
    for(i in 1:N) {
        theta[i] ~ dgamma(alpha, beta)
        lambda[i] <- theta[i]*t[i]
        x[i] ~ dpois(lambda[i])
    }
    alpha ~ dexp(1.0)
    beta ~ dgamma(0.1, 1.0)
})

pumpConsts <- list(N = 10,
                   t = c(94.3, 15.7, 62.9, 126, 5.24,
                         31.4, 1.05, 1.05, 2.1, 10.5))
pumpData <- list(x = c(5, 1, 5, 14, 3, 19, 1, 1, 4, 22))
pumpInits <- list(alpha = 1, beta = 1,
                  theta = rep(0.1, pumpConsts$N))
pumpModel <- nimbleModel(pumpCode, pumpConsts, pumpData, pumpInits)
Defining model
Building model
Setting data and initial values
Running calculate on model
  [Note] Any error reports that follow may simply reflect missing values in model variables.
Checking model sizes and dimensions

Now we add the logProb derived quantity, specified directly as an argument to configureMCMC.

conf <- configureMCMC(pumpModel, logProb = c('alpha', 'beta'))
===== Monitors =====
thin = 1: alpha, beta
===== Samplers =====
RW sampler (1)
  - alpha
conjugate sampler (11)
  - beta
  - theta[]  (10 elements)
===== DerivedQ =====
- logProb (1)
conf$printDerivedQuantities()
[1] derived quantity: logProb,  execution interval: thin,  nodes: c(alpha, beta)

When we run the MCMC, we see the derived quantities are saved as an element of the output list, in addition to the usual posterior samples of the parameters.

mcmc <- buildMCMC(conf)

cPumpModel <- compileNimble(pumpModel)
Compiling
  [Note] This may take a minute.
  [Note] Use 'showCompilerOutput = TRUE' to see C++ compilation details.
cmcmc <- compileNimble(mcmc)
Compiling
  [Note] This may take a minute.
  [Note] Use 'showCompilerOutput = TRUE' to see C++ compilation details.
runMCMC(cmcmc, niter = 100, thin = 20)
running chain 1...
|-------------|-------------|-------------|-------------|
|-------------------------------------------------------|
$samples
         alpha      beta
[1,] 0.7434957 0.8437510
[2,] 0.5046057 0.8152505
[3,] 0.5201513 1.3765454
[4,] 1.1023278 2.2564913
[5,] 1.4316249 2.1598157

$derived
$derived$logProb
          alpha      beta
[1,] -0.7434957 -2.943556
[2,] -0.5046057 -2.884129
[3,] -0.5201513 -3.916877
[4,] -1.1023278 -5.241634
[5,] -1.4316249 -5.105549

We could also have added the logProb derived quantity to an existing MCMC configuration argument (and also illustrating that one can modify the interval at which recording is done):

conf <- configureMCMC(pumpModel)
conf$addDerivedQuantity('logProb', nodes = c('alpha', 'beta'), interval = 10)

The operation of every derived quantity function is governed by an interval parameter. Each derived quantity function is executed at the end of every interval MCMC iterations (and only for iterations after the burnin period). The default value for interval is given by the thin interval of the MCMC. For example, if interval = 1 (regardless of the thin value), then that derived quantity function will execute at the end of every MCMC sampling iteration.

Note that user-defined derived quantity nimbleFunctions provide a general way for a user to intervene at the end of an MCMC iteration and do something. This would often be recording a value (to be returned at the end of the MCMC) or updating some summary statistic, but the derived quantities system doesn’t require this, giving users flexibility.

More details can be found in the NIMBLE User Manual and via help(derived).

]]> announcement R tutorial https://r-nimble.org/blog/derived-quantities.html Tue, 27 Jan 2026 08:00:00 GMT Version 1.4.0 of NIMBLE released, plus new quadrature-based functionality in nimbleQuad package NIMBLE Development Team https://r-nimble.org/blog/version-1-4-0-of-nimble-released.html We’ve released the newest version of NIMBLE on CRAN and on our website. NIMBLE is a system for building and sharing analysis methods for statistical models, especially for hierarchical models and computationally-intensive methods (such as MCMC, Laplace approximation, and SMC).

Version 1.4.0 provides important new and improved functionality, plus some bug fixes and improved error trapping.

The new and improved functionality includes:

  • A new INLA-like deterministic nested posterior approximation whose methodology borrows from both INLA and the extended latent Gaussian models approach of the aghq package in R. This new approximation and NIMBLE’s existing Laplace and AGHQ approximation now live in a new package, nimbleQuad, rather than in the core nimble package.
  • A new system for computing and storing “derived quantities” during MCMC execution, allowing users to record additional quantities of interest at every saved MCMC iteration (i.e., following the thinning interval, or some other user-chosen interval). Derived quantities provided by NIMBLE include means, variances, model log-densities, and predictive nodes. Users can also define their own derived quantities.
  • Matrix exponential functionality via expm and expAv.
  • The ability to provide multiple code chunks to nimbleCode for greater flexibility in composing models.
  • Greatly improved efficiency and memory use of AD system and making efficiency improvements to Laplace/AGHQ approximation.

In addition to the new and improved functionality above, other bug fixes, improved error trapping, and enhancements include:

  • Removing some documentation references to “BUGS” when referring to models.
  • Allowing users to turn off model$checkBasics via a new option.
  • Better handling inconsistencies between inits and dimensions.
  • Making minor improvements to the Pólya-gamma sampler.
  • Generalizing the system of dynamically generating conjugate MCMC samplers, to allow for multivariate parameters of dependent distributions to have distinct sizes from the dependent node itself .
  • Making MCEM append new samples when increasing sample size using the ascent-based method, rather than starting a new sample.

Please see the release notes on our website for more details.

]]> release announcement R https://r-nimble.org/blog/version-1-4-0-of-nimble-released.html Wed, 14 Jan 2026 08:00:00 GMT announcing the nimbleMacros package and the use of macros in NIMBLE models NIMBLE Development Team https://r-nimble.org/blog/announcing-the-nimblemacros-package-and-the-use-of-macros-in-nimble-models.html Recent versions of NIMBLE now include the ability to use macros in models. NIMBLE is a system for building and sharing analysis methods for statistical models, especially for hierarchical models and computationally-intensive methods (such as MCMC, Laplace approximation, and SMC).

A NIMBLE macro is a succinct syntax that expands to create the NIMBLE model code for part or all of a model.

We recently released the first version of the nimbleMacros package on CRAN, which provides an initial set of macros available to users and developers. As an example, one could set up the code for a linear mixed effects model by using the LM (“linear model”) macro like this:

library(nimbleMacros)
code <- nimbleCode({
  LM(weight[1:N] ~ Time + (1|Chick))
})

with the formula syntax mimicking that of the lme4 package. After building the model based on the code object, you can see the model code produced after the macro is expanded with model$getCode(). The nimbleMacros package also includes macros for creating linear predictors and for loops, and we plan to add additional macros in the future.

Developers can use the tools in nimble itself to create their own macros. See Section 12.4 of the NIMBLE user manual, the nimbleMacros vignette, or help(buildMacro) for more information.

]]> announcement release R https://r-nimble.org/blog/announcing-the-nimblemacros-package-and-the-use-of-macros-in-nimble-models.html Wed, 19 Mar 2025 07:00:00 GMT Version 1.3.0 of NIMBLE released NIMBLE Development Team https://r-nimble.org/blog/version-1-3-0-of-nimble-released.html We’ve released the newest version of NIMBLE on CRAN and on our website. NIMBLE is a system for building and sharing analysis methods for statistical models, especially for hierarchical models and computationally-intensive methods (such as MCMC, Laplace approximation, and SMC).

Version 1.3.0 provides some new and improved functionality, plus some bug fixes and improved error trapping.

The new and improved functionality includes:

  • A new multivariate sampler, the Barker proposal sampler (sampler_barker). We encourage users to try this sampler in place of the block Metropolis RW_block sampler and let us know how well it works. The Barker sampler uses gradient information and may improve adaptation behavior, including
    better mixing when parameters are on different scales or the initialproposal scale is too large.
  • An improved Laplace/AGHQ implementation that includes use of the nlminb optimizer for both inner and outer optimization (for better optimization performance), improved messaging and output naming, returning the log-likelihood and degrees of freedom for model selection calculations, and unified control of optimization method and other controls at either the build stage or through the updateSettings method.
  • The addition of the BOBYQA optimization method through nimOptim, registered via nimOptimMethod.

In addition to the new and improved functionality above, other bug fixes, improved error trapping, and enhancements include:

  • Preventing the use of nimbleFunction method names and nimbleFunction names that conflict with names in the nimble language (DSL).
  • More carefully checking for and warning of cases of NaN and non-finite log probability values in various samplers that in some cases may indicate invalid MCMC sampling.
  • More carefully handling of NaN and non-finite log probability values in the CRP sampler.
  • Error trapping cases of dynamic indices producing a non-scalar result in AD-enabled models and provide a suggested work-around.
  • Error trapping use of a non-existent nimbleList.
  • Preventing use of a single seed when running multiple chains via runMCMC.
  • Improving messaging related to lack of derivative support for functions.
  • Adding information about model macros to the manual.
  • Fixing bug in caching values in the CRP sampler when maximum number of clusters is exceeded, which would have caused incorrect sampling (albeit with the user having been warned that they should increase the maximum number of clusters).
  • Fixing an issue preventing use of nimbleList elements in nimCat.
  • Preventing an adaptation interval of one for various block samplers for which an interval of one leads to an error.
  • Allowing runLaplace to use an uncompiled Laplace object.

Please see the release notes on our website for more details.

]]> release announcement R https://r-nimble.org/blog/version-1-3-0-of-nimble-released.html Sat, 21 Dec 2024 08:00:00 GMT Version 1.2.1 of NIMBLE released NIMBLE Development Team https://r-nimble.org/blog/version-1-2-1-of-nimble-released.html We’ve released the newest version of NIMBLE on CRAN and on our website. NIMBLE is a system for building and sharing analysis methods for statistical models, especially for hierarchical models and computationally-intensive methods (such as MCMC, Laplace approximation, and SMC).

This is a micro release that primarily addresses some packaging changes requested by CRAN. In addition, this release includes:

  • A multinomial MCMC sampler, sampler_RW_multinomial, for random variables following a multinomial distribution.
  • Some enhancements to error trapping and warning messages.
  • A variety of minor bug fixes.
]]> release announcement R https://r-nimble.org/blog/version-1-2-1-of-nimble-released.html Wed, 31 Jul 2024 07:00:00 GMT Version 1.2.0 of NIMBLE released NIMBLE Development Team https://r-nimble.org/blog/version-1-2-0-of-nimble-released.html We’ve released the newest version of NIMBLE on CRAN and on our website. NIMBLE is a system for building and sharing analysis methods for statistical models, especially for hierarchical models and computationally-intensive methods (such as MCMC, Laplace approximation, and SMC).

This release provides provides extensive new functionality, including:

  • A Pólya-gamma sampler, sampler_polyagamma, for conjugate sampling of linear predictor parameters in logistic regression model specifications, including handling zero inflation and stochastic design matrices. This sampler must be added to an MCMC configuration manually.
  • A new sampler, sampler_noncentered, which samples the mean or standard deviation of a set of random effect values in a transformed space such that the random effects are deterministically shifted or scaled given new values of their hyperparameters. For random effects written in a centered parameterization, sampling is performed as if they had been written in a noncentered parameterization, thereby enabling a variant on the Yu and Meng (2011) interweaving sampling strategy of sampling in both parameterizations.This sampler must be added to an MCMC configuration manually.
  • Adaptive Gauss-Hermite quadrature (AGHQ) for integrating over continuous latent effects, as an extension of NIMBLE’s Laplace approximation functionality. We also add user-friendly R functions, runLaplace and runAGHQ, for using Laplace and AGHQ approximation for maximum likelihood estimation.
  • A more flexible optimization system via nimOptim, with support for nlminb built in as well as the capability for users to provide potentially arbitrary optimization functions in R.
  • Allowing the use of nimbleFunctions with setup code in models, either for user-defined functions via <- or for user-defined distributions via ~. This supports holding large objects outside of model nodes for use in models.
  • A completely revamped MCEM algorithm, using automatic derivatives in the maximization when possible, fixing a bug so that any parts of the model not connected to the latent states are included in MLE calculations, giving greater control and adding minor extensions to the ascent-based MCEM approach, and converting buildMCEM to be a nimbleFunction rather than an R function.

In addition to the new functionality above, other enhancements and bug fixes include:

  • Improving the speed of MCMC and MCMC building in certain cases.
  • Adding an argument to buildMCMC controlling whether to initialize values in the model.
  • Providing the ability to control the number of digits printed in C++ output.
  • Allowing use of a categorical MCMC sampler with user-specified dcat-like distributions.
  • Warning of use of backward indexing in models.
  • Improve documentation of the LKJ distribution and of advanced aspects of writing code for derivative tracking using the AD system.
  • Fixing an insufficient check for conjugacy in stick-breaking specifications of Bayesian nonparametric distributions.
  • Fixing compilation failures occurring on Red Hat Linux.
  • Reenabling functionality for user-provided Eigen library and related updates to the autoconf configuration used in package building.
  • Enhancing functionality to support model macros, which will be fully released and documented in the future.
  • Removing deprecated is.na.vec and is.nan.vec functions.
  • Improving some warnings and error messages.

Please see the release notes on our website for more details.

]]> release announcement https://r-nimble.org/blog/version-1-2-0-of-nimble-released.html Fri, 14 Jun 2024 07:00:00 GMT Version 1.1.0 of NIMBLE released NIMBLE Development Team https://r-nimble.org/blog/version-1-1-0-of-nimble-released.html We’ve released the newest version of NIMBLE on CRAN and on our website. NIMBLE is a system for building and sharing analysis methods for statistical models, especially for hierarchical models and computationally-intensive methods (such as MCMC,Laplace approximation, and SMC).

This release provides new functionality as well as various bug fixes and improved error trapping, including:

  • Improving our automatic differentiation (AD) system so it can be used in a wider range of models, including models with stochastic indexing, discrete latent states, and CAR distributions. Support for AD for these models means that HMC sampling and Laplace approximation can be used.
  • Allowing distributions and functions (whether user-defined or built-in) that lack AD support (such as dinterval, dconstraint, and truncated distributions) to be used and compiled in AD-enabled models. The added flexibility increases the range of models in which one can use AD methods (HMC or Laplace) on some parts of a model and other samplers or methods on other parts.
  • Adding nimIntegrate to the NIMBLE language, providing one-dimensional numerical integration via adaptive quadrature, equivalent to R’s integrate. This can, for example, be used in a user-defined function or distribution for use in model code, such as to implement certain point process or survival models that involve a one-dimensional integral.
  • Adding a “prior samples” MCMC sampler, which uses an existing set of numerical samples to define the prior distribution of model node(s).
  • Better support of the dCRP distribution in non-standard model structures.
  • Adding error trapping to prevent accidental use of C++ keywords as model variable names.
  • Removing the RW_multinomial MCMC sampler, which was found to generate incorrect posterior results (in cases when a latent state followed a multinomial distribution)
  • Fixing a bug in conjugacy checking in a case of subsets of multivariate nodes.
  • Fixing is.na and is.nan to operate in the expected vectorized fashion.
  • Improving documentation of AD, nimbleHMC, and nimbleSMC in the manual.
  • Updating Eigen (the C++ linear algebra library used by nimble) to version 3.4.0.

Please see the release notes on our website for more details.

]]> release announcement R https://r-nimble.org/blog/version-1-1-0-of-nimble-released.html Sun, 04 Feb 2024 08:00:00 GMT nimbleHMC version 0.2.0 released, providing improved HMC performance NIMBLE Development Team https://r-nimble.org/blog/nimblehmc-version-0-2-0-released-providing-improved-hmc-performance.html nimbleHMC provides Hamiltonian Monte Carlo samplers for use with NIMBLE, in particular NUTS samplers. NIMBLE’s HMC samplers can be flexibly assigned to a subset of model parameters, allowing users to consider various sampling configurations.

We’ve released version 0.2.0 of nimbleHMC, which includes a new default NUTS sampler inspired by Stan’s implementation of NUTS. It also provides an updated version of our previous NUTS sampler (which is based on the original Hoffman and Gelman paper, and is now called the ‘NUTS_classic’ sampler in NIMBLE) that fixes performance issues in version 0.1.1.

]]> release announcement R https://r-nimble.org/blog/nimblehmc-version-0-2-0-released-providing-improved-hmc-performance.html Wed, 20 Sep 2023 07:00:00 GMT Version 1.0.1 of NIMBLE released, fixing a bug in version 1.0.0 affecting certain models NIMBLE Development Team https://r-nimble.org/blog/version-1-0-1-of-nimble-released-fixing-a-bug-in-version-1-0-0-affecting-certain-models.html We’ve released the newest version of NIMBLE on CRAN and on our website. NIMBLE is a system for building and sharing analysis methods for statistical models, especially for hierarchical models and computationally-intensive methods (such as MCMC and SMC).

Version 1.0.1 follows shortly after 1.0.0 and fixes an issue and a bug introduced in version 1.0.0 causing data to be set incorrectly in certain models.

Both cases occur only when a variable (e.g., x) contains both stochastic nodes (e.g. x[2] ~ <some distribution>) and either deterministic nodes (e.g. x[3] <- <some calculation>) or right-hand-side-only nodes (e.g. x[4] appears only on the right-hand-side, like an explanatory value).

The issue involves a change of behavior (relative to previous nimble versions) when both setting data values for some nodes and initial values for other nodes within the same variable (that satisfies the previous condition). Data values for right-hand-side-only nodes were replaced by initial values (inits) if both were provided. Version 1.0.1 reverts to previous behavior that data values are not replaced by initial values in that situation.

The bug involves models where (for a variable satisfying the previous condition) not every scalar element within the variable is used as a node and some of the nodes in the variable are data. In that situation, data values may be set incorrectly. This could typically occur in models with autoregressive structure directly on some data nodes (such as may be the case for capture-recapture models involving many individual capture histories within the same variable, indexed by individual and time, with some individuals not present for the entire time series, resulting in unused scalar elements of the variable).

Please see the release notes on our website for more details.

]]> release announcement R https://r-nimble.org/blog/version-1-0-1-of-nimble-released-fixing-a-bug-in-version-1-0-0-affecting-certain-models.html Wed, 21 Jun 2023 07:00:00 GMT Version 1.0.0 of NIMBLE released, providing automatic differentiation, Laplace approximation, and HMC sampling NIMBLE Development Team https://r-nimble.org/blog/version-1-0-0-of-nimble-released-providing-automatic-differentiation-laplace-approximation-and-hmc-sampling.html We’ve released the newest version of NIMBLE on CRAN and on our website. NIMBLE is a system for building and sharing analysis methods for statistical models, especially for hierarchical models and computationally-intensive methods (such as MCMC and SMC).

Version 1.0.0 provides substantial new functionality. This includes:

  • A Laplace approximation algorithm that allows one to find the MLE for model parameters based on approximating the marginal likelihood in models with continuous random effects/latent process values.
  • A Hamiltonian Monte Carlo (HMC) MCMC sampler implementing the NUTS algorithm (available in the newly-released nimbleHMC package).
  • Support in NIMBLE’s algorithm programming system to obtain derivatives of functions and arbitrary calculations within models.
  • A parameter transformation system allowing algorithms to work in unconstrained parameter spaces when model parameters have constrained domains.

These are documented via the R help system and a new section at the end of our User Manual. We’re excited for users to try out the new features and let us know of their experiences. In particular, given these major additions to the NIMBLE system, we anticipate the possibility of minor glitches. The best place to reach out for support is still the nimble-users list.

In addition to the new functionality above, other enhancements and bug fixes include:

  • Fixing a bug (previously reported in a nimble-users message) giving incorrect results in NIMBLE’s cross-validation function (runCrossValidate) for all but the ‘predictive’ loss function for NIMBLE versions 0.10.0 – 0.13.2.
  • Fixing a bug in conjugacy checking causing incorrect identification of conjugate relationships in models with unusual uses of subsets, supersets, and slices of multivariate normal nodes.
  • Improving control of the addSampler method for MCMC.
  • Improving the WAIC system in a few small ways.
  • Enhancing error trapping and warning messages.

Please see the NEWS file in the package source for more details.

]]> release announcement R https://r-nimble.org/blog/version-1-0-0-of-nimble-released-providing-automatic-differentiation-laplace-approximation-and-hmc-sampling.html Wed, 31 May 2023 07:00:00 GMT Version 0.13.1 of NIMBLE released NIMBLE Development Team https://r-nimble.org/blog/version-0-13-1-of-nimble-released.html We’ve released the newest version of NIMBLE on CRAN and on our website. This version is purely a bug fix release that fixes a bug introduced in our new handling of predictive nodes in version 0.13.0 (released in November). If you installed version 0.13.0, please upgrade to 0.13.1.

]]> release announcement R https://r-nimble.org/blog/version-0-13-1-of-nimble-released.html Mon, 19 Dec 2022 08:00:00 GMT Bug in newly-released version 0.13.0 affecting MCMC for models with predictive nodes NIMBLE Development Team https://r-nimble.org/blog/bug-in-newly-released-version-0-13-0-affecting-mcmc-for-models-with-predictive-nodes.html We recently released version 0.13.0, which has some improvements in how we handle predictive nodes in NIMBLE’s MCMC engine.

Unfortunately, we realized (thanks to a user post from a couple days ago) that there is a bug in this new approach to predictive nodes.

If you haven’t upgraded to version 0.13.0, simply wait to upgrade until we release a bug fix in 0.13.1 in the next couple weeks.

If you have upgraded to version 0.13.0 and if you have run an MCMC on a model that both (1) has predictive nodes and (2) has multivariate nodes, then the bug might affect your results. Please set:

nimbleOptions(MCMCusePredictiveDependenciesInCalculations = TRUE)

and then reconfigure/rebuild and rerun your MCMC. The option above will ensure that the MCMC behaves as it would in previous versions of NIMBLE.

]]> announcement R https://r-nimble.org/blog/bug-in-newly-released-version-0-13-0-affecting-mcmc-for-models-with-predictive-nodes.html Thu, 08 Dec 2022 08:00:00 GMT Version 0.13.0 of NIMBLE released NIMBLE Development Team https://r-nimble.org/blog/version-0-13-0-of-nimble-released.html We’ve released the newest version of NIMBLE on CRAN and on our website. NIMBLE is a system for building and sharing analysis methods for statistical models, especially for hierarchical models and computationally-intensive methods (such as MCMC and SMC).

Version 0.13.0 provides new functionality (in particular improved handling of predictive nodes in MCMC) and minor bug fixes, including:

  • Thoroughly revamping handling of posterior predictive nodes in the MCMC system, in particular that MCMC samplers, by default, will now exclude predictive dependencies from internal sampler calculations. This should improve MCMC mixing for models with predictive nodes. Posterior predictive nodes are now sampled conditional on all other model nodes at the end of each MCMC iteration.
  • Adding functionality to the MCMC configuration system, including a new replaceSamplers method and updates to the arguments for the addSamplers method.
  • Adding an option to the WAIC system to allow additional burnin (in addition to standard MCMC burnin) before calculating online WAIC, thereby allowing inspection of initial samples without forcing them to be used for WAIC.
  • Warning users of unused constants during model building.
  • Fixing bugs that prevented use of variables starting with “logProb” or named “i” in model code.
  • Fixing a bug to prevent infinite recursion in particular cases in conjugacy checking.
  • Fixing a bug in simulating from dcar_normal nodes when multiple nodes passed to simulate.

Please see the release notes on our website for more details.

]]> release announcement R https://r-nimble.org/blog/version-0-13-0-of-nimble-released.html Tue, 29 Nov 2022 08:00:00 GMT We’re looking for a programmer NIMBLE Development Team https://r-nimble.org/blog/were-looking-for-a-programmer.html The NIMBLE project anticipates having some funding for a part-time programmer to implement statistical algorithms and make improvements in nimble’s core code. Examples may include building adaptive Gaussian quadrature in nimble’s programming system and expanding nimble’s hierarchical model system. Remote work is possible. This is not a formal job solicitation, but please send a CV/resume to nimble.stats@gmail.com if you are interested so we can have you on our list. Important skills will be experience with hierarchical statistical modeling algorithms, R programming, and nimble itself. Experience with C++ will be helpful but not required.

]]> announcement R https://r-nimble.org/blog/were-looking-for-a-programmer.html Fri, 07 Oct 2022 07:00:00 GMT NIMBLE virtual short course, January 4-6, 2023 NIMBLE Development Team https://r-nimble.org/blog/nimble-virtual-short-course-january-4-6-2023.html We’ll be holding a virtual training workshop on NIMBLE, January 4-6, 2023 from 8 am to 1 pm US Pacific (California) time each day. NIMBLE is a system for building and sharing analysis methods for statistical models, especially for hierarchical models and computationally-intensive methods (such as MCMC and SMC).

Recently we added support for automatic differentiation (AD) to NIMBLE in a beta release, and the workshop will cover NIMBLE’s AD capabilities in detail.

The workshop will cover the following material:

  • the basic concepts and workflows for using NIMBLE and converting BUGS or JAGS models to work in NIMBLE.
  • overview of different MCMC sampling strategies and how to use them in NIMBLE, including Hamiltonian Monte Carlo (HMC).
  • writing new distributions and functions for more flexible modeling and more efficient computation.
  • tips and tricks for improving computational efficiency.
  • using advanced model components, including Bayesian non-parametric distributions (based on Dirichlet process priors), conditional auto-regressive (CAR) models for spatially correlated random fields, Laplace approximation, and reversible jump samplers for variable selection.
  • an introduction to programming new algorithms in NIMBLE.
  • use of automatic differentiation (AD) in algorithms.
  • calling R and compiled C++ code from compiled NIMBLE models or functions.

If you are interested in attending, please pre-register. Registration fees will be $125 (regular) or $50 (student). We are also offering a process (see the pre-registration form) for students to request a fee waiver.

The workshop will assume attendees have a basic understanding of hierarchical/Bayesian models and MCMC, the BUGS (or JAGS) model language, and some familiarity with R.

]]> education announcement R https://r-nimble.org/blog/nimble-virtual-short-course-january-4-6-2023.html Thu, 08 Sep 2022 07:00:00 GMT Beta version of NIMBLE with automatic differentiation, including HMC sampling and Laplace approximation NIMBLE Development Team https://r-nimble.org/blog/beta-version-of-nimble-with-automatic-differentiation-including-hmc-sampling-and-laplace-approximation.html We’re excited to announce that NIMBLE now supports automatic differentiation (AD), also known as algorithmic differentiation, in a beta version available on our website. In this beta version, NIMBLE now provides:

  • Hamiltonian Monte Carlo (HMC) sampling for an entire parameter vector or arbitrary subsets of the parameter vector (i.e., combined with other samplers for the remaining parameters).
  • Laplace approximation for approximate integration over latent states in a model, allowing maximum likelihood estimation and MCMC based on the marginal likelihood (via the RW_llFunction samplers).
  • The ability for users and algorithm developers to write nimbleFunctions that calculate derivatives of functions, including many but not all mathematical operations that are supported in the NIMBLE language.

We’re making this beta release available to allow our users to test and evaluate the AD functionality and the new algorithms, but it is not recommended for production use at this stage. So please give it a try, and let us know of any problems or suggestions you have, either via the nimble-users list, bug reports to our GitHub repository, or email to nimble.stats@gmail.com.

You can download the beta version and view an [extensive draft manual]https://r-nimble.org/ADuserManual_draft/chapter_AD.html) for the AD functionality.

We plan to release this functionality in the next NIMBLE release on CRAN in the coming months.

]]> announcement release R https://r-nimble.org/blog/beta-version-of-nimble-with-automatic-differentiation-including-hmc-sampling-and-laplace-approximation.html Fri, 15 Jul 2022 07:00:00 GMT Version 0.12.2 of NIMBLE released, including an important bug fix for some models using Bayesian nonparametrics with the dCRP distribution NIMBLE Development Team https://r-nimble.org/blog/version-0-12-2-of-nimble-released-including-an-important-bug-fix-for-some-models-using-bayesian-nonparametrics-with-the-dcrp-distribution.html We’ve released the newest version of NIMBLE on CRAN and on our website. NIMBLE is a system for building and sharing analysis methods for statistical models, especially for hierarchical models and computationally-intensive methods (such as MCMC and SMC).

Version 0.12.2 is a bug fix release. In particular, this release fixes a bug in our Bayesian nonparametric distribution (BNP) functionality that gives incorrect MCMC results for some models, specifically when using the dCRP distribution when the parameters of the mixture components (i.e., the clusters) have hyperparameters (i.e., the base measure parameters) that are unknown and sampled during the MCMC. Here is an example basic model structure that is affected by the bug:

k[1:n] ~ dCRP(alpha, n) for(i in 1:n) { y[i] ~ dnorm(mu[k[i]], 1) mu[i] ~ dnorm(mu0, 1) ## mixture component parameters with hyperparameter } mu0 ~ dnorm(0, 1) ## unknown cluster hyperparameter

(There is no problem without the hyperparameter layer - i.e., if mu0 is a fixed value – which is the situation in many models.)

We strongly encourage users using models with this type of structure to rerun their analyses, and we apologize for this issue.

Other changes in this release include:

  • Fixing an issue with reversible jump variable selection under a similar situation to the BNP issue discussed above (in particular where there are unknown hyperparameters of the regression coefficients being considered, which would likely be an unusual use case).
  • Fixing a bug preventing setup of conjugate samplers for dwishart or dinvwishart nodes when using dynamic indexing.
  • Fixing a bug preventing use of truncation bounds specified via data or constants.
  • Fixing a bug preventing MCMC sampling with the LKJ prior for 2×2 matrices.
  • Fixing a bug in runCrossValidate affecting extraction of multivariate nodes.
  • Fixing a bug producing incorrect subset assignment into logical vectors in nimbleFunction code.
  • Fixing a bug preventing use of nimbleExternalCall with a constant expression.
  • Fixing a bug preventing use of recursion in nimbleFunctions without setup code.

Please see the release notes on our website for more details.

]]> release announcement R https://r-nimble.org/blog/version-0-12-2-of-nimble-released-including-an-important-bug-fix-for-some-models-using-bayesian-nonparametrics-with-the-dcrp-distribution.html Fri, 04 Mar 2022 08:00:00 GMT NIMBLE in-person short course, June 1-3, Lisbon, Portugal Chris Paciorek https://r-nimble.org/blog/nimble-in-person-short-course-june-1-3-lisbon-portugal.html We’ll be holding a in-person training workshop on NIMBLE, June 1-3, 2022, in Lisbon, Portugal, sponsored by the Centro de Estatística e Aplicações at the Universidade Lisboa (CEAUL).

NIMBLE is a system for building and sharing analysis methods for statistical models, especially for hierarchical models and computationally-intensive methods (such as MCMC and SMC).

More details and registration are available at the workshop website. No previous NIMBLE experience is required, but the workshop will assume some familiarity with hierarchical models, Markov chain Monte Carlo (MCMC), and R.

]]> education announcement R https://r-nimble.org/blog/nimble-in-person-short-course-june-1-3-lisbon-portugal.html Wed, 02 Mar 2022 08:00:00 GMT