R2jags

https://github.com/suyusung/r2jags
Admin
R2jags provides wrapper functions to implement Bayesian analysis using MCMC in JAGS, with features...
Tokens:8,361
Snippets:53
Trust Score:6.5
Update:6 months ago
Show doc for...
Tokens:
Raw
### Install R2jags Dependencies on Windows

Source: https://github.com/suyusung/r2jags/blob/master/README.md

Installs necessary dependencies for R2jags on Windows machines, including Rtools, which is required for compiling packages. This step should be performed before installing R2jags using remotes on Windows.

```R
pkgs <- c("MASS", "Rtools", "remotes")
repos <- "https://cran.rstudio.com"
install.packages(pkgs, repos = repos, dependencies = "Depends")
```

--------------------------------

### Specify BUGS Models in R2jags

Source: https://context7.com/suyusung/r2jags/llms.txt

Illustrates two methods for specifying BUGS models in R2jags: using an external text file and using an R function. The R function method is recommended for better reproducibility. The example defines a hierarchical model for school effects.

```R
library(R2jags)

# Method 1: Model as external file (content shown in comments)
# Save this to "schools.txt":
# model {
#   for (j in 1:J) {
#     y[j] ~ dnorm(theta[j], tau.y[j])
#     tau.y[j] <- pow(sd[j], -2)
#   }
#   for (j in 1:J) {
#     theta[j] ~ dnorm(mu, tau)
#   }
#   tau <- pow(sigma, -2)
#   mu ~ dnorm(0.0, 1.0E-6)
#   sigma ~ dunif(0, 1000)
# }

# Method 2: Model as R function (recommended for reproducibility)
schoolsmodel <- function() {
  for (j in 1:J) {
    y[j] ~ dnorm(theta[j], tau.y[j])   # Likelihood
    tau.y[j] <- pow(sd[j], -2)          # Precision = 1/variance
  }
  for (j in 1:J) {
    theta[j] ~ dnorm(mu, tau)           # Hierarchical prior
  }
  tau <- pow(sigma, -2)
  mu ~ dnorm(0.0, 1.0E-6)               # Vague normal prior
  sigma ~ dunif(0, 1000)                # Vague uniform prior
}

# Data and initialization
J <- 8
y <- c(28.4, 7.9, -2.8, 6.8, -0.6, 0.6, 18.0, 12.2)
sd <- c(14.9, 10.2, 16.3, 11.0, 9.4, 11.4, 10.4, 17.6)

jags.data <- list(y = y, sd = sd, J = J)
jags.params <- c("mu", "sigma", "theta")
jags.inits <- function() {
  list(mu = rnorm(1), sigma = runif(1), theta = rnorm(J))
}

# Run with function-based model specification
jagsfit <- jags(
  data = jags.data,
  inits = jags.inits,
  parameters.to.save = jags.params,
  model.file = schoolsmodel,   # Pass R function directly
  n.chains = 3,
  n.iter = 5000,
  digits = 5                   # Precision for model file output
)

print(jagsfit)
```

--------------------------------

### Install R2jags from CRAN

Source: https://github.com/suyusung/r2jags/blob/master/README.md

Installs the stable release version of the R2jags package from the Comprehensive R Archive Network (CRAN). This is the recommended method for most users.

```R
install.packages("R2jags")
```

--------------------------------

### Install R2jags Development Version using remotes

Source: https://github.com/suyusung/r2jags/blob/master/README.md

Installs the development version of the R2jags package directly from its GitHub repository using the 'remotes' package. This method allows for easy installation of the latest code.

```R
install.packages("remotes")
remotes::install_github("giabaio/R2jags",ref="devel")
```

--------------------------------

### Install R2jags Development Version from r-universe.dev

Source: https://github.com/suyusung/r2jags/blob/master/README.md

Installs the development version of the R2jags package from the r-universe.dev repository. This version may contain newer features or bug fixes but is less stable than the CRAN release.

```R
install.packages(
  'R2jags', 
  repos = c('https://giabaio.r-universe.dev', 'https://cloud.r-project.org')
)
```

--------------------------------

### Run MCMC Analysis with jags()

Source: https://context7.com/suyusung/r2jags/llms.txt

Demonstrates how to execute a Bayesian model using the jags() function. It covers data preparation, parameter selection, initial value definition, and execution with specific MCMC settings.

```R
library(R2jags)
J <- 8
y <- c(28.4, 7.9, -2.8, 6.8, -0.6, 0.6, 18.0, 12.2)
sd <- c(14.9, 10.2, 16.3, 11.0, 9.4, 11.4, 10.4, 17.6)
jags.data <- list(y = y, sd = sd, J = J)
jags.params <- c("mu", "sigma", "theta")
jags.inits <- function() {
  list(mu = rnorm(1), sigma = runif(1), theta = rnorm(J))
}
model.file <- system.file(package = "R2jags", "model", "schools.txt")
jagsfit <- jags(
  data = jags.data,
  inits = jags.inits,
  parameters.to.save = jags.params,
  model.file = model.file,
  n.chains = 3,
  n.iter = 5000,
  n.burnin = 2500,
  n.thin = 1,
  DIC = TRUE
)
print(jagsfit, digits = 3, intervals = c(0.025, 0.5, 0.975))
```

--------------------------------

### Configure R2jags Default Options

Source: https://context7.com/suyusung/r2jags/llms.txt

Sets the global options for the R2jags package, including progress bar style, verbosity, and program output printing. These settings should be configured before running model simulations to ensure consistent behavior.

```R
options(r2j.pb = "text")
options(r2j.quiet = FALSE)
options(r2j.print.program = TRUE)
```

--------------------------------

### Automatic Convergence Detection with autojags()

Source: https://context7.com/suyusung/r2jags/llms.txt

Illustrates the use of autojags() to iteratively update a model until the Gelman-Rubin Rhat statistic indicates convergence across all parameters.

```R
library(R2jags)
J <- 8
y <- c(28.4, 7.9, -2.8, 6.8, -0.6, 0.6, 18.0, 12.2)
sd <- c(14.9, 10.2, 16.3, 11.0, 9.4, 11.4, 10.4, 17.6)
jags.data <- list(y = y, sd = sd, J = J)
jags.params <- c("mu", "sigma", "theta")
jags.inits <- function() {
  list(mu = rnorm(1), sigma = runif(1), theta = rnorm(J))
}
model.file <- system.file(package = "R2jags", "model", "schools.txt")
jagsfit <- jags(
  data = jags.data,
  inits = jags.inits,
  parameters.to.save = jags.params,
  model.file = model.file,
  n.chains = 3,
  n.iter = 1000,
  n.burnin = 500
)
```

--------------------------------

### Execute Parallel MCMC Chains with jags.parallel()

Source: https://context7.com/suyusung/r2jags/llms.txt

Shows how to accelerate MCMC sampling by distributing chains across multiple CPU cores using jags.parallel(). This is ideal for computationally intensive models.

```R
library(R2jags)
J <- 8
y <- c(28.4, 7.9, -2.8, 6.8, -0.6, 0.6, 18.0, 12.2)
sd <- c(14.9, 10.2, 16.3, 11.0, 9.4, 11.4, 10.4, 17.6)
jags.data <- list(y = y, sd = sd, J = J)
jags.params <- c("mu", "sigma", "theta")
jags.inits <- function() {
  list(mu = rnorm(1), sigma = runif(1), theta = rnorm(J))
}
model.file <- system.file(package = "R2jags", "model", "schools.txt")
jagsfit.parallel <- jags.parallel(
  data = jags.data,
  inits = jags.inits,
  parameters.to.save = jags.params,
  model.file = model.file,
  n.chains = 4,
  n.cluster = 4,
  n.iter = 10000,
  n.burnin = 5000,
  n.thin = 2,
  DIC = TRUE,
  jags.seed = 12345
)
print(jagsfit.parallel, digits = 3)
plot(jagsfit.parallel)
```

--------------------------------

### Accessing Posterior Distributions and Summaries in R2jags

Source: https://context7.com/suyusung/r2jags/llms.txt

Demonstrates how to access posterior means, credible intervals, and dimensions of parameters from an R2jags model fit. It also shows how to calculate custom posterior probabilities and summaries using R functions like `apply` and `quantile`.

```R
mean(mu)
quantile(sigma, c(0.025, 0.975))
dim(theta)
mean(theta[, 1] > theta[, 2])
school_effects <- apply(theta, 2, function(x) {
  c(mean = mean(x), sd = sd(x),
    q2.5 = quantile(x, 0.025),
    q97.5 = quantile(x, 0.975))
})
print(t(school_effects))
detach.jags()
```

--------------------------------

### traceplot - MCMC Chain Visualization

Source: https://context7.com/suyusung/r2jags/llms.txt

Displays trace plots showing the sampled values across iterations for each parameter.

```APIDOC
## traceplot(object, varname, match.head, mfrow, col, ask)

### Description
Displays trace plots showing the sampled values across iterations for each parameter, with separate lines for each chain. Essential for visually assessing convergence.

### Method
Function Call

### Parameters
#### Arguments
- **object** (rjags) - Required - The jags model object.
- **varname** (vector) - Optional - Specific variables to plot.
- **match.head** (boolean) - Optional - Whether to match variables by the beginning of their name.
- **mfrow** (vector) - Optional - Layout for the plots.
- **col** (vector) - Optional - Colors for chains.

### Request Example
traceplot(jagsfit, varname = c("mu", "sigma"), ask = FALSE)

### Response
#### Success Response (200)
- **plot** (graphic) - R graphical output displaying trace plots.
```

--------------------------------

### jags() - Run JAGS MCMC Analysis

Source: https://context7.com/suyusung/r2jags/llms.txt

Executes a Bayesian model using JAGS, returning an object containing posterior samples and convergence diagnostics.

```APIDOC
## Function: jags()

### Description
The primary function to run JAGS models. It takes data, initial values, and a model file to perform MCMC sampling.

### Parameters
- **data** (list) - Required - Named list of data required by the JAGS model.
- **inits** (function/list) - Optional - Initial values for the MCMC chains.
- **parameters.to.save** (vector) - Required - Character vector of parameter names to monitor.
- **model.file** (string) - Required - Path to the text file containing the JAGS model definition.
- **n.chains** (integer) - Optional - Number of MCMC chains to run.
- **n.iter** (integer) - Optional - Total number of iterations per chain.
- **n.burnin** (integer) - Optional - Number of iterations to discard as burn-in.

### Response
Returns an 'rjags' object containing posterior samples, summary statistics, and convergence diagnostics (Rhat, DIC).
```

--------------------------------

### Configure Global Options for R2jags

Source: https://context7.com/suyusung/r2jags/llms.txt

This snippet demonstrates how to set global options for the R2jags package to control the display of progress bars, compilation messages, and output formatting. These settings can be applied at the beginning of an R session to affect all subsequent JAGS calls.

```R
library(R2jags)

# Suppress progress bar (useful for Rmarkdown/scripts)
options(r2j.pb = "none")

# Suppress compilation messages
options(r2j.quiet = TRUE)

# Don't print software name in output
options(r2j.print.program = FALSE)

# Run model with quiet settings
J <- 8
y <- c(28.4, 7.9, -2.8, 6.8, -0.6, 0.6, 18.0, 12.2)
sd <- c(14.9, 10.2, 16.3, 11.0, 9.4, 11.4, 10.4, 17.6)

jags.data <- list(y = y, sd = sd, J = J)
jags.params <- c("mu", "sigma", "theta")
model.file <- system.file(package = "R2jags", "model", "schools.txt")

jagsfit <- jags(
  data = jags.data,
  inits = NULL,                # Let JAGS generate initial values
  parameters.to.save = jags.params,
  model.file = model.file,
  n.chains = 3,
  n.iter = 5000
)

# Print with custom quantile intervals
print(jagsfit, digits = 2, intervals = c(0.05, 0.5, 0.95))
```

--------------------------------

### Convert R2jags Output to Coda MCMC Objects

Source: https://context7.com/suyusung/r2jags/llms.txt

This snippet shows how to run a JAGS model using R2jags and then convert the resulting 'rjags' object into a 'coda mcmc.list' object. This conversion allows for the use of extensive diagnostic and plotting functions from the 'coda' package, such as summary statistics, convergence diagnostics (Gelman-Rubin, Geweke), and various plots (trace, density, autocorrelation).

```R
library(R2jags)
library(coda)

J <- 8
y <- c(28.4, 7.9, -2.8, 6.8, -0.6, 0.6, 18.0, 12.2)
sd <- c(14.9, 10.2, 16.3, 11.0, 9.4, 11.4, 10.4, 17.6)

jags.data <- list(y = y, sd = sd, J = J)
jags.params <- c("mu", "sigma", "theta")
jags.inits <- function() {
  list(mu = rnorm(1), sigma = runif(1), theta = rnorm(J))
}
model.file <- system.file(package = "R2jags", "model", "schools.txt")

jagsfit <- jags(
  data = jags.data,
  inits = jags.inits,
  parameters.to.save = jags.params,
  model.file = model.file,
  n.chains = 3,
  n.iter = 5000
)

mcmc.samples <- as.mcmc(jagsfit)

summary(mcmc.samples)
gelman.diag(mcmc.samples)
effectiveSize(mcmc.samples)
autocorr.diag(mcmc.samples)
geweke.diag(mcmc.samples)

plot(mcmc.samples)
densplot(mcmc.samples)
autocorr.plot(mcmc.samples)
crosscorr.plot(mcmc.samples)
```

--------------------------------

### autojags() - Automatic Convergence Detection

Source: https://context7.com/suyusung/r2jags/llms.txt

Iteratively updates a JAGS model until the Gelman-Rubin Rhat statistic indicates convergence.

```APIDOC
## Function: autojags()

### Description
Automatically continues running a model until all monitored parameters reach convergence (Rhat < threshold).

### Parameters
- **object** (rjags) - Required - An existing jags object to update.
- **n.update** (integer) - Optional - Number of iterations to add in each update step.
- **n.iter** (integer) - Optional - Maximum total iterations allowed.

### Response
Returns an updated 'rjags' object that meets convergence criteria.
```

--------------------------------

### Visualize MCMC Convergence with traceplot in R

Source: https://context7.com/suyusung/r2jags/llms.txt

The traceplot function in R2jags displays MCMC trace plots for each parameter, showing sampled values across iterations for each chain. This is crucial for visually assessing convergence. The function takes a JAGS fit object and can plot all parameters or specific ones. Dependencies include the R2jags package.

```R
library(R2jags)

# Run JAGS model
J <- 8
y <- c(28.4, 7.9, -2.8, 6.8, -0.6, 0.6, 18.0, 12.2)
sd <- c(14.9, 10.2, 16.3, 11.0, 9.4, 11.4, 10.4, 17.6)

jags.data <- list(y = y, sd = sd, J = J)
jags.params <- c("mu", "sigma", "theta")
jags.inits <- function() {
  list(mu = rnorm(1), sigma = runif(1), theta = rnorm(J))
}
model.file <- system.file(package = "R2jags", "model", "schools.txt")

jagsfit <- jags(
  data = jags.data,
  inits = jags.inits,
  parameters.to.save = jags.params,
  model.file = model.file,
  n.chains = 3,
  n.iter = 5000
)

# Plot trace for all parameters (cycles through each)
traceplot(jagsfit, ask = TRUE)

# Plot trace for specific parameters only
traceplot(
  jagsfit,
  varname = c("mu", "sigma"),
  match.head = TRUE,      # Match by beginning of variable name
  mfrow = c(2, 1),        # 2 rows, 1 column layout
  col = c("red", "blue", "green"),  # Colors for each chain
  ask = FALSE
)
```

--------------------------------

### jags.parallel() - Parallel MCMC Processing

Source: https://context7.com/suyusung/r2jags/llms.txt

Distributes MCMC chains across multiple CPU cores to accelerate Bayesian inference.

```APIDOC
## Function: jags.parallel()

### Description
Runs JAGS models in parallel, assigning each MCMC chain to a separate cluster node to improve performance.

### Parameters
- **n.cluster** (integer) - Required - Number of CPU cores/clusters to utilize.
- **jags.seed** (integer) - Optional - Seed for reproducibility across parallel chains.
- **...** (args) - Same parameters as the standard jags() function.

### Response
Returns an 'rjags' object with combined results from all parallel chains.
```

--------------------------------

### Access Posterior Samples with attach.jags in R

Source: https://context7.com/suyusung/r2jags/llms.txt

The attach.jags function in R2jags attaches posterior simulation arrays from an rjags object to the R search path, making parameter samples directly accessible as R objects. This simplifies post-processing and custom analyses. It requires an rjags fit object and an option to overwrite existing objects. Dependencies include the R2jags package.

```R
library(R2jags)

# Run JAGS model
J <- 8
y <- c(28.4, 7.9, -2.8, 6.8, -0.6, 0.6, 18.0, 12.2)
sd <- c(14.9, 10.2, 16.3, 11.0, 9.4, 11.4, 10.4, 17.6)

jags.data <- list(y = y, sd = sd, J = J)
jags.params <- c("mu", "sigma", "theta")
jags.inits <- function() {
  list(mu = rnorm(1), sigma = runif(1), theta = rnorm(J))
}
model.file <- system.file(package = "R2jags", "model", "schools.txt")

jagsfit <- jags(
  data = jags.data,
  inits = jags.inits,
  parameters.to.save = jags.params,
  model.file = model.file,
  n.chains = 3,
  n.iter = 5000
)

# Attach posterior samples to search path
attach.jags(jagsfit, overwrite = TRUE)
```

--------------------------------

### Hierarchical Normal-Normal BUGS Model

Source: https://github.com/suyusung/r2jags/blob/master/inst/model/schools.txt

This BUGS model defines a hierarchical structure for 8 schools. It calculates the likelihood for each school's observed data and estimates the population mean and standard deviation using non-informative priors.

```BUGS
model {
  for (j in 1:J){                      # J=8, the number of schools
    y[j] ~ dnorm (theta[j], tau.y[j])  # data model:  the likelihood
    tau.y[j] <- pow(sd[j], -2)         # tau = 1/sigma^2
  }
  for (j in 1:J){
    theta[j] ~ dnorm (mu, tau)         # hierarchical model for theta
  }
  tau <- pow(sigma, -2)                # tau = 1/sigma^2
  mu ~ dnorm (0.0, 1.0E-6)             # noninformative prior on mu
  sigma ~ dunif (0, 1000)              # noninformative prior on sigma
}
```

--------------------------------

### recompile - Restore Saved JAGS Session

Source: https://context7.com/suyusung/r2jags/llms.txt

Recompiles a previously saved rjags object, restoring the JAGS model state for continued sampling.

```APIDOC
## recompile(object, n.iter, progress.bar)

### Description
Recompiles a previously saved rjags object, restoring the JAGS model state for continued sampling. Useful for resuming analysis from saved R sessions.

### Method
Function Call

### Parameters
#### Arguments
- **object** (rjags) - Required - The loaded rjags object.
- **n.iter** (integer) - Optional - Adaptation iterations.

### Request Example
recompile(object = jagsfit, n.iter = 100)

### Response
#### Success Response (200)
- **object** (rjags) - Returns the recompiled rjags object ready for further sampling.
```

--------------------------------

### Restore Saved JAGS Session with recompile in R

Source: https://context7.com/suyusung/r2jags/llms.txt

The recompile function in R2jags restores a previously saved rjags object, re-initializing the JAGS model state for continued sampling. This is useful for resuming analysis from saved R sessions or after serialization. It requires an rjags object and can perform adaptation iterations. Dependencies include the R2jags package.

```R
library(R2jags)

# Create and run initial model
J <- 8
y <- c(28.4, 7.9, -2.8, 6.8, -0.6, 0.6, 18.0, 12.2)
sd <- c(14.9, 10.2, 16.3, 11.0, 9.4, 11.4, 10.4, 17.6)

jags.data <- list(y = y, sd = sd, J = J)
jags.params <- c("mu", "sigma", "theta")
jags.inits <- function() {
  list(mu = rnorm(1), sigma = runif(1), theta = rnorm(J))
}
model.file <- system.file(package = "R2jags", "model", "schools.txt")

jagsfit <- jags(
  data = jags.data,
  inits = jags.inits,
  parameters.to.save = jags.params,
  model.file = model.file,
  n.chains = 3,
  n.iter = 2000
)

# Save the object to disk
saveRDS(jagsfit, "jagsfit_saved.rds")

# Later: reload and recompile
jagsfit <- readRDS("jagsfit_saved.rds")
recompile(
  object = jagsfit,
  n.iter = 100,           # Adaptation iterations
  progress.bar = "text"
)

# Continue with additional sampling
jagsfit.continued <- update(jagsfit, n.iter = 3000)
print(jagsfit.continued)
```

--------------------------------

### update.rjags - Update MCMC Samples

Source: https://context7.com/suyusung/r2jags/llms.txt

Continues sampling from an existing rjags object to generate additional posterior samples.

```APIDOC
## update(object, n.iter, n.thin, progress.bar)

### Description
Continues sampling from an existing rjags object to generate additional posterior samples. This is useful when initial runs haven't achieved convergence or when more samples are needed for inference.

### Method
Function Call

### Parameters
#### Arguments
- **object** (rjags) - Required - The existing jags model object.
- **n.iter** (integer) - Required - Number of additional iterations to run.
- **n.thin** (integer) - Optional - Thinning interval for monitoring.
- **progress.bar** (string) - Optional - Type of progress bar (e.g., "text").

### Request Example
update(object = jagsfit, n.iter = 5000, n.thin = 2, progress.bar = "text")

### Response
#### Success Response (200)
- **object** (rjags) - Returns an updated rjags object with extended posterior samples.
```

--------------------------------

### Update MCMC Samples with update.rjags in R

Source: https://context7.com/suyusung/r2jags/llms.txt

The update function in R2jags continues sampling from an existing rjags object to generate additional posterior samples. This is useful for achieving convergence or obtaining more samples. It preserves the model state and extends the MCMC chain. Dependencies include the R2jags package and an initial JAGS fit object.

```R
library(R2jags)

# Initial short run
J <- 8
y <- c(28.4, 7.9, -2.8, 6.8, -0.6, 0.6, 18.0, 12.2)
sd <- c(14.9, 10.2, 16.3, 11.0, 9.4, 11.4, 10.4, 17.6)

jags.data <- list(y = y, sd = sd, J = J)
jags.params <- c("mu", "sigma", "theta")
jags.inits <- function() {
  list(mu = rnorm(1), sigma = runif(1), theta = rnorm(J))
}
model.file <- system.file(package = "R2jags", "model", "schools.txt")

jagsfit <- jags(
  data = jags.data,
  inits = jags.inits,
  parameters.to.save = jags.params,
  model.file = model.file,
  n.chains = 3,
  n.iter = 2000,
  n.burnin = 1000
)

# Continue sampling with 5000 more iterations
jagsfit.updated <- update(
  object = jagsfit,
  n.iter = 5000,
  n.thin = 2,
  progress.bar = "text"
)

# View updated results
print(jagsfit.updated)
```

--------------------------------

### Auto-update MCMC until Convergence (Rhat < 1.1) in R

Source: https://context7.com/suyusung/r2jags/llms.txt

The autojags function automatically updates MCMC samples from a JAGS model until the R-hat statistic falls below a specified threshold (e.g., 1.1). It takes an existing JAGS fit object and iteratively increases the number of iterations. Dependencies include the R2jags package. The output is a JAGS fit object with updated samples.

```R
jagsfit.auto <- autojags(
  object = jagsfit,
  n.iter = 1000,          # Iterations per update cycle
  n.thin = 1,
  Rhat = 1.1,             # Convergence threshold
  n.update = 10,          # Maximum number of update cycles
  progress.bar = "text"
)

# Check final convergence
print(jagsfit.auto)
```
Tokens:
Raw