ShinyStan

https://github.com/stan-dev/shinystan
Admin
ShinyStan is an interactive graphical interface for Bayesian MCMC diagnostics and posterior...
Tokens:9,750
Snippets:109
Trust Score:9.4
Update:6 months ago
Show doc for...
Tokens:
Raw
### Install shinystan from GitHub

Source: https://github.com/stan-dev/shinystan/wiki/Installing-the-R-package

Installs the development version of the package from GitHub with vignettes enabled.

```r
devtools::install_github("stan-dev/shinystan", build_vignettes = TRUE)
```

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

### Install rsconnect package

Source: https://github.com/stan-dev/shinystan/wiki/Usage:-deploying-to-ShinyApps

Install the rsconnect package if it is not already available in your R environment.

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

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

### Launch ShinyStan demo

Source: https://github.com/stan-dev/shinystan/blob/master/README.md

Load the library and start the interactive demo to explore ShinyStan functionality.

```r
library("shinystan")
launch_shinystan_demo()
```

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

### Install ShinyStan development version

Source: https://github.com/stan-dev/shinystan/blob/master/README.md

Install the latest development version from GitHub. Requires the devtools package.

```r
if (!require("devtools")) {
  install.packages("devtools")
}
devtools::install_github("stan-dev/shinystan", build_vignettes = TRUE)
```

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

### Install shinystan from CRAN

Source: https://github.com/stan-dev/shinystan/wiki/Installing-the-R-package

Use this command to install the stable version of the package from the CRAN repository.

```r
install.packages("shinystan")
```

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

### Install devtools dependency

Source: https://github.com/stan-dev/shinystan/wiki/Installing-the-R-package

Required to install packages directly from GitHub repositories.

```r
install.packages("devtools")
```

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

### model_code

Source: https://context7.com/stan-dev/shinystan/llms.txt

Get or set the model code associated with a shinystan object.

```APIDOC
## model_code

### Description
Get or set the model code associated with a shinystan object. Useful for non-Stan models like JAGS or BUGS.

### Parameters
- **sso** (shinystan object) - Required - The shinystan object.
- **code** (string) - Optional - The model code to set.
```

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

### model_name

Source: https://context7.com/stan-dev/shinystan/llms.txt

Get or change the model name associated with a shinystan object.

```APIDOC
## model_name

### Description
Get or change the model name associated with a shinystan object. The model name is displayed on the home page of the ShinyStan interface.

### Parameters
#### Request Body
- **sso** (shinystan object) - Required - The shinystan object.
- **name** (string) - Optional - The new name for the model.
```

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

### Get or Set Model Name in ShinyStan Objects

Source: https://context7.com/stan-dev/shinystan/llms.txt

The `model_name()` function retrieves or modifies the name of the model associated with a shinystan object. This name is displayed on the ShinyStan interface's home page.

```r
library(shinystan)
sso <- eight_schools

# View current model name
model_name(sso)
# [1] "eight_schools"

# Change the model name
sso <- model_name(sso, "Hierarchical Meta-Analysis: Eight Schools")
model_name(sso)
# [1] "Hierarchical Meta-Analysis: Eight Schools"
```

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

### Launch ShinyStan Application

Source: https://context7.com/stan-dev/shinystan/llms.txt

Initiate the interactive GUI using various MCMC output objects or the built-in demo.

```r
library(shinystan)

# Launch with a stanfit object (from rstan)
library(rstan)
fit <- stan(model_code = "parameters { real mu; } model { mu ~ normal(0, 1); }",
            iter = 2000, chains = 4)
my_sso <- launch_shinystan(fit)

# Launch with an existing shinystan object
launch_shinystan(my_sso)

# Launch and save any changes made in the app to a new object
sso_updated <- launch_shinystan(my_sso)

# Launch in RStudio's Viewer pane instead of browser
options(shinystan.rstudio = TRUE)
launch_shinystan(my_sso)

# Launch the built-in demo (eight schools hierarchical model)
demo_sso <- launch_shinystan_demo()
```

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

### Launch ShinyStan from a stanfit object

Source: https://github.com/stan-dev/shinystan/wiki/Usage:-stanfit-objects-(Stan-models)

Initializes the ShinyStan app using a stanfit object. The returned object can be optionally saved for later use.

```r
library("shinystan")
my_sso <- launch_shinystan(my_fit)
```

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

### sso_info

Source: https://context7.com/stan-dev/shinystan/llms.txt

Print a summary of metadata about a shinystan object.

```APIDOC
## sso_info

### Description
Print a summary of metadata about a shinystan object including number of parameters, chains, iterations, and whether model code and notes are present.

### Parameters
#### Request Body
- **sso** (shinystan object) - Required - The shinystan object to inspect.
```

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

### launch_shinystan

Source: https://context7.com/stan-dev/shinystan/llms.txt

Launches the ShinyStan interactive application in a web browser or RStudio viewer to explore and diagnose MCMC output.

```APIDOC
## launch_shinystan

### Description
Launch the ShinyStan interactive application in your web browser to explore and diagnose MCMC output. This is the primary entry point for using ShinyStan.

### Parameters
#### Arguments
- **sso** (shinystan/stanfit/stanreg/CmdStanMCMC) - Required - The object containing MCMC output to be explored.

### Request Example
launch_shinystan(fit)

### Response
- **Shiny Application** - Opens an interactive GUI in the browser or RStudio Viewer.
```

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

### deploy_shinystan

Source: https://context7.com/stan-dev/shinystan/llms.txt

Deploys a ShinyStan application to shinyapps.io.

```APIDOC
## deploy_shinystan

### Description
Deploy a ShinyStan application to shinyapps.io for sharing model diagnostics online.

### Parameters
- **sso** (shinystan object) - Required - The shinystan object.
- **appName** (string) - Required - Name of the application.
- **account** (string) - Optional - shinyapps.io account name.
- **ppcheck_data** (vector) - Optional - Observed data for posterior predictive checking.
- **ppcheck_yrep** (string) - Optional - Name of the parameter containing posterior predictive draws.
- **deploy** (boolean) - Optional - Whether to perform the actual deployment.
```

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

### Deploy ShinyStan Application

Source: https://context7.com/stan-dev/shinystan/llms.txt

Deploy model diagnostics to shinyapps.io. Includes options for posterior predictive checking data and testing deployment without uploading.

```r
library(shinystan)

# First, configure your shinyapps.io account (one-time setup)
# rsconnect::setAccountInfo(name = "your_username",
#                           token = "your_token",
#                           secret = "your_secret")

# Basic deployment
sso <- eight_schools
deploy_shinystan(sso, appName = "eight-schools-demo", account = "username")

# Deploy without specifying account (if only one account configured)
deploy_shinystan(sso, appName = "my-model-diagnostics")

# Deploy with posterior predictive checking data
# y is a vector of observed data
# yrep is the name of the parameter containing posterior predictive draws
y_observed <- c(28, 8, -3, 7, -1, 1, 18, 12)
deploy_shinystan(sso,
                 appName = "model-with-ppcheck",
                 ppcheck_data = y_observed,
                 ppcheck_yrep = "y_rep")

# Test deployment preparation without actually deploying
deploy_dir <- deploy_shinystan(sso,
                                appName = "test-model",
                                deploy = FALSE)
print(deploy_dir)  # Path to temporary directory with app files
```

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

### Fit Stan Model and Launch ShinyStan with RStan

Source: https://github.com/stan-dev/shinystan/blob/master/inst/ShinyStan/markdown/pp_check_tutorial.md

Fits a Stan model using RStan and then launches the ShinyStan interface for analysis. Ensure the Stan code is saved in 'stan_code.stan'.

```R
library(rstan)
library(ShinyStan)

# Prepare the data we'll need as a list
stan_data <- list(y = y, X = X, N = N, K = K)

# Fit the model
stanfit <- stan(file = "stan_code.stan", data = stan_data)

# Launch ShinyStan
launch_shinystan(stanfit)
```

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

### Summarize ShinyStan Object Information

Source: https://context7.com/stan-dev/shinystan/llms.txt

Use `sso_info()` to display a summary of metadata for a shinystan object, including parameter counts, chain and iteration numbers, and the presence of model code and user notes.

```r
library(shinystan)
sso <- eight_schools

# Print object information
sso_info(sso)
# sso
# ---------------------
# Model name: eight_schools
# Parameters: 11
# Parameter groups: 4
# Chains: 4
# Iterations: 1000
# Warmup: 500
# Has model code: TRUE
# Has user notes: FALSE
```

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

### Create ShinyStan Objects

Source: https://context7.com/stan-dev/shinystan/llms.txt

Convert various MCMC output formats into a shinystan object for analysis.

```r
library(shinystan)

# From a 3-D array (iterations x chains x parameters)
n_iter <- 1000
n_chains <- 4
n_params <- 3
posterior_array <- array(
  data = c(rnorm(n_iter * n_chains),      # mu
           rnorm(n_iter * n_chains, 2),    # sigma
           rgamma(n_iter * n_chains, 2)),  # tau
  dim = c(n_iter, n_chains, n_params),
  dimnames = list(NULL, NULL, c("mu", "sigma", "tau"))
)
sso <- as.shinystan(posterior_array,
                    model_name = "My Model",
                    warmup = 500)

# From a list of matrices (one per chain)
chain1 <- cbind(beta1 = rnorm(500), beta2 = rnorm(500), sigma = rexp(500))
chain2 <- cbind(beta1 = rnorm(500), beta2 = rnorm(500), sigma = rexp(500))
chain3 <- cbind(beta1 = rnorm(500), beta2 = rnorm(500), sigma = rexp(500))
sso <- as.shinystan(list(chain1, chain2, chain3),
                    model_name = "Regression Model",
                    warmup = 0)

# From a stanfit object with parameter subset
library(rstan)
fit <- stan_demo("eight_schools")
sso <- as.shinystan(fit, pars = c("mu", "tau", "theta"), model_name = "Eight Schools")

# From an mcmc.list object (coda package)
library(coda)
mcmc_chain1 <- mcmc(chain1)
mcmc_chain2 <- mcmc(chain2)
mcmc_list <- mcmc.list(mcmc_chain1, mcmc_chain2)
sso <- as.shinystan(mcmc_list, model_name = "JAGS Model", warmup = 100)

# From CmdStanR output
library(cmdstanr)
mod <- cmdstan_model("my_model.stan")
fit <- mod$sample(data = stan_data)
sso <- as.shinystan(fit, model_name = "CmdStan Model")

# Check if object is a shinystan object
is.shinystan(sso)  # Returns TRUE
```

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

### as.shinystan

Source: https://context7.com/stan-dev/shinystan/llms.txt

Creates a shinystan object from various input formats including 3-D arrays, lists of matrices, stanfit objects, and mcmc.list objects.

```APIDOC
## as.shinystan

### Description
Create a shinystan object from various input formats. This generic function is essential for preparing MCMC output for use with the ShinyStan interface.

### Parameters
#### Arguments
- **data** (array/list/stanfit/mcmc.list) - Required - The MCMC output data.
- **model_name** (string) - Optional - Name for the model.
- **warmup** (integer) - Optional - Number of warmup iterations.
- **pars** (vector) - Optional - Subset of parameters to include.

### Response
- **shinystan object** - An S4 object containing posterior samples and metadata.
```

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

### Deploy ShinyStan app

Source: https://github.com/stan-dev/shinystan/wiki/Usage:-deploying-to-ShinyApps

Use the deploy_shinystan function to upload a ShinyStan object to your shinyapps.io account.

```R
deploy_shinystan(sso, appName = "appname", account = "username")
```

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

### notes

Source: https://context7.com/stan-dev/shinystan/llms.txt

Add, view, or replace notes associated with a shinystan object.

```APIDOC
## notes

### Description
Add, view, or replace notes associated with a shinystan object. Notes appear on the Notepad page in the ShinyStan GUI.

### Parameters
#### Request Body
- **sso** (shinystan object) - Required - The shinystan object.
- **new_note** (string) - Optional - The note text to add.
- **replace** (boolean) - Optional - If TRUE, replaces all existing notes with the new note.
```

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

### retrieve

Source: https://context7.com/stan-dev/shinystan/llms.txt

Extracts summary statistics, diagnostics, and sampler parameters from a shinystan object programmatically.

```APIDOC
## retrieve

### Description
Extract summary statistics, diagnostics, and sampler parameters from a shinystan object programmatically. Provides access to Rhat, effective sample size, posterior means, and quantiles.

### Parameters
#### Arguments
- **sso** (shinystan) - Required - The shinystan object.
- **what** (string) - Required - The statistic to retrieve (e.g., "rhat", "n_eff", "mean", "quantiles").
- **pars** (vector) - Optional - Specific parameters to retrieve.

### Response
- **numeric/matrix** - The requested diagnostic or summary statistic.
```

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

### Generate a quantity using a custom function

Source: https://github.com/stan-dev/shinystan/wiki/Usage:-generating-new-quantities

Defines a custom function and applies it to an existing parameter to create a new one.

```r
invlogit <- function(x) 1 / (1 + exp(-x))
sso <- generate_quantity(sso, fun = invlogit, param1 = "beta", new_name = "gamma")
```

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

### Convert mcmc.list to ShinyStan object

Source: https://github.com/stan-dev/shinystan/wiki/Usage:-mcmc.list,-3D-array,-or-list-of-matrices

Converts an mcmc.list object to a shinystan object and launches the interface. Optional arguments include burnin and model_name.

```r
library("shinystan")
my_sso <- as.shinystan(my_mcmc)
my_sso <- launch_shinystan(my_sso)
```

```r
my_sso <- as.shinystan(my_mcmc, burnin = 100)
```

```r
my_sso <- as.shinystan(my_mcmc, burnin = 100, model_name = "Example")
```

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

### Generate a quantity using a built-in function

Source: https://github.com/stan-dev/shinystan/wiki/Usage:-generating-new-quantities

Applies a standard R function like plogis to an existing parameter to create a new one.

```r
sso <- generate_quantity(sso, fun = plogis, param1 = "beta", new_name = "gamma")
```

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

### Convert list of matrices to ShinyStan object

Source: https://github.com/stan-dev/shinystan/wiki/Usage:-mcmc.list,-3D-array,-or-list-of-matrices

Converts a list of matrices, where each matrix represents a chain, into a shinystan object.

```r
# Generate some fake data
n <- 100
chain1 <- cbind(beta1 = rnorm(n), beta2 = rnorm(n), sigma = rexp(n))
chain2 <- cbind(beta1 = rnorm(n), beta2 = rnorm(n), sigma = rexp(n))
my_sso <- as.shinystan(list(chain1, chain2), model_name = "Example")
```

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

### Manage Notes in ShinyStan Objects

Source: https://context7.com/stan-dev/shinystan/llms.txt

Use the `notes()` function to add, view, or replace notes associated with a shinystan object. Notes are appended by default; use `replace = TRUE` to overwrite existing notes.

```r
library(shinystan)
sso <- eight_schools

# View existing notes
notes(sso)

# Add a note (appends to existing notes)
sso <- notes(sso, "Model fit on 2024-01-15 using rstan 2.26.0")
sso <- notes(sso, "Prior: mu ~ normal(0, 10), tau ~ half-cauchy(0, 5)")

# View updated notes
cat(notes(sso))

# Replace all existing notes
sso <- notes(sso, "Fresh start with new notes.", replace = TRUE)
notes(sso)
```

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

### Update Old ShinyStan Objects

Source: https://context7.com/stan-dev/shinystan/llms.txt

The `update_sso()` function ensures a shinystan object created with a previous package version is compatible with the current version. Use this function if you encounter errors when loading older saved objects.

```r
library(shinystan)

# Load an old shinystan object
old_sso <- readRDS("my_old_shinystan_object.rds")

# Update to current version
sso <- update_sso(old_sso)

# If already up-to-date, returns the object unchanged with a message
sso <- update_sso(sso)
# sso already up-to-date.

# Save the updated object
saveRDS(sso, "my_updated_shinystan_object.rds")
```

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

### update_sso

Source: https://context7.com/stan-dev/shinystan/llms.txt

Update a shinystan object to be compatible with the current version.

```APIDOC
## update_sso

### Description
Update a shinystan object created with a previous version of the package to be compatible with the current version.

### Parameters
#### Request Body
- **sso** (shinystan object) - Required - The old shinystan object to update.
```

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

### Retrieve Diagnostic Metrics from ShinyStan Object

Source: https://context7.com/stan-dev/shinystan/llms.txt

Extract specific diagnostic metrics like divergent transitions, treedepth, and acceptance statistics from a ShinyStan object.

```r
# Proportion of divergent transitions per chain
retrieve(sso, "prop_divergent")
retrieve(sso, "divergent", inc_warmup = TRUE)

# Maximum treedepth per chain
retrieve(sso, "max_treedepth")

# Average acceptance probability per chain
retrieve(sso, "avg_accept_stat")

# Average stepsize per chain
retrieve(sso, "avg_stepsize")
```

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

### Retrieve Diagnostics and Statistics

Source: https://context7.com/stan-dev/shinystan/llms.txt

Extract specific metrics like Rhat, effective sample size, and posterior summaries from a shinystan object.

```r
library(shinystan)
sso <- eight_schools  # Built-in example object

# Get Rhat convergence statistics for all parameters
rhat_values <- retrieve(sso, "rhat")
print(rhat_values)

# Get Rhat for specific parameters
retrieve(sso, "Rhat", pars = c("mu", "tau"))

# Get effective sample sizes
retrieve(sso, "n_eff")
retrieve(sso, "ess", pars = c("theta[1]", "theta[2]"))

# Get posterior means and standard deviations
retrieve(sso, "mean")
retrieve(sso, "mean", pars = c("mu", "tau"))
retrieve(sso, "sd")

# Get Monte Carlo standard error
retrieve(sso, "mcse")
retrieve(sso, "se_mean", pars = "mu")

# Get posterior quantiles (2.5%, 25%, 50%, 75%, 97.5%)
quantiles <- retrieve(sso, "quantiles")
print(quantiles)
retrieve(sso, "quantiles", pars = c("mu", "tau"))

# Get posterior medians
retrieve(sso, "median")

# NUTS sampler diagnostics (Stan models only)
```

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

### Generate Fake Data in R

Source: https://github.com/stan-dev/shinystan/blob/master/inst/ShinyStan/markdown/pp_check_tutorial.md

Generates synthetic data for a linear regression model, including the number of observations, model matrix with an intercept and covariate, and the outcome variable.

```R
# Number of observations 
N <- 100

# Model matrix (with column of 1s for intercept and one covariate)
X <- cbind(Const = 1, X1 = rnorm(N))
K <- ncol(X)

# Generate fake outcome y
beta <- c(2, 1/2) # pick intercept and coefficient
sigma <- 1 # standard deviation
y <- rnorm(N, mean = X %*% beta, sd = sigma) # generate data
```

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

### Generate a quantity from two parameters

Source: https://github.com/stan-dev/shinystan/wiki/Usage:-generating-new-quantities

Uses a function of two variables to derive a new parameter from two existing parameters.

```r
sso <- generate_quantity(sso, fun = function(x,y) (x - y)^2,
                         param1 = "alpha", param2 = "beta", new_name = "delta")
```

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

### Generate Derived Parameters

Source: https://context7.com/stan-dev/shinystan/llms.txt

Add new parameters to a ShinyStan object by applying functions to existing parameters. This allows for post-hoc transformations without re-running the model.

```r
library(shinystan)
sso <- eight_schools

# Transform a single parameter
# Add tau squared
sso <- generate_quantity(sso,
                         fun = function(x) x^2,
                         param1 = "tau",
                         new_name = "tau_sq")

# Add log transformation of tau
sso <- generate_quantity(sso,
                         fun = log,
                         param1 = "tau",
                         new_name = "log_tau")

# Inverse logit transformation
inv_logit <- function(x) 1 / (1 + exp(-x))
sso <- generate_quantity(sso,
                         fun = inv_logit,
                         param1 = "mu",
                         new_name = "prob_mu")

# Combine two parameters
# Difference between two theta values
sso <- generate_quantity(sso,
                         fun = "-",
                         param1 = "theta[1]",
                         param2 = "theta[2]",
                         new_name = "theta1_minus_theta2")

# Squared difference
sso <- generate_quantity(sso,
                         fun = function(x, y) (x - y)^2,
                         param1 = "theta[1]",
                         param2 = "theta[2]",
                         new_name = "theta_sq_diff")

# Ratio of parameters
sso <- generate_quantity(sso,
                         fun = "/",
                         param1 = "theta[1]",
                         param2 = "tau",
                         new_name = "theta1_over_tau")

# Verify new parameters were added
print(sso@param_names)
```

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

### Add Model Code to ShinyStan Object

Source: https://github.com/stan-dev/shinystan/wiki/Usage:-storing-model-code

Use the `model_code` function to add custom model code to an existing ShinyStan object. This is useful when your model was not fit using Stan.

```r
my_code <- "
model {
  for (i in 1:length(Y)) {
  Y[i] ~ dpois(lambda[i])
  log(lambda[i]) <- inprod(X[i,], theta[])
}
  for (j in 1:J) {
    theta[j] ~ dt(0.0, 1.0, 1.0)
  }
}
"
sso <- model_code(sso, code = my_code)
```

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

### generate_quantity

Source: https://context7.com/stan-dev/shinystan/llms.txt

Adds a new derived parameter to a shinystan object based on a function of existing parameters.

```APIDOC
## generate_quantity

### Description
Add a new derived parameter to a shinystan object as a function of one or two existing parameters. This is useful for computing transformations, contrasts, or other quantities of interest post-hoc.

### Parameters
- **sso** (shinystan object) - Required - The shinystan object.
- **fun** (function) - Required - The function to apply to the parameters.
- **param1** (string) - Required - Name of the first parameter.
- **param2** (string) - Optional - Name of the second parameter.
- **new_name** (string) - Required - Name for the new derived parameter.

### Request Example
```r
sso <- generate_quantity(sso, fun = log, param1 = "tau", new_name = "log_tau")
```
```

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

### Manage Model Code Metadata

Source: https://context7.com/stan-dev/shinystan/llms.txt

Access or update the model code associated with a ShinyStan object, useful for non-Stan models like JAGS or BUGS.

```r
library(shinystan)
sso <- eight_schools

# View existing model code
cat(model_code(sso))

# Add model code (for non-Stan models)
jags_code <- "
model {
  for (i in 1:N) {
    y[i] ~ dnorm(mu + theta[school[i]], sigma_y)
  }
  for (j in 1:J) {
    theta[j] ~ dnorm(0, tau)
  }
  mu ~ dnorm(0, 0.001)
  sigma_y ~ dunif(0, 100)
  tau ~ dgamma(0.001, 0.001)
}
"
sso <- model_code(sso, code = jags_code)

# View the updated model code
cat(model_code(sso))
```

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

### Stan Linear Regression Model

Source: https://github.com/stan-dev/shinystan/blob/master/inst/ShinyStan/markdown/pp_check_tutorial.md

Defines a simple linear regression model in Stan, including data structures, parameters, prior distributions, likelihood, and posterior predictive simulations.

```Stan
data {
  int           N ; # integer, number of observations
  int           K ; # integer, number of columns in model matrix
  matrix[N,K]   X ; # N by K model matrix
  vector[N]     y ; # vector of N observations
}

parameters {
  real<lower=0> sigma ; # real number > 0, standard deviation
  vector[K]     beta ;  # K-vector of regression coefficients
}

model {
  beta ~ normal(0, 5) ;       # prior for betas
  sigma ~ cauchy(0, 2.5) ;    # prior for sigma
  y ~ normal(X*beta, sigma) ; # vectorized likelihood
}

generated quantities {
# Here we do the simulations from the posterior predictive distribution
  vector[N] y_rep ; # vector of same length as the data y
  for (n in 1:N) 
    y_rep[n] <- normal_rng(X[n]*beta, sigma) ;
}
```

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

### drop_parameters

Source: https://context7.com/stan-dev/shinystan/llms.txt

Removes specified parameters from a shinystan object to reduce memory usage.

```APIDOC
## drop_parameters

### Description
Remove parameters from a shinystan object to reduce its size and improve performance when only a subset of parameters is of interest.

### Parameters
- **sso** (shinystan object) - Required - The shinystan object.
- **pars** (vector) - Required - Character vector of parameter names to remove.

### Request Example
```r
sso_reduced <- drop_parameters(sso, pars = c("mu", "tau"))
```
```

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

### Drop Parameters from ShinyStan Object

Source: https://context7.com/stan-dev/shinystan/llms.txt

Remove parameters to reduce object size and improve performance. Note that individual elements of a vector cannot be removed, only the entire vector.

```r
library(shinystan)
sso <- eight_schools

# View current parameter names
print(sso@param_names)
# [1] "mu" "tau" "theta[1]" "theta[2]" ... "theta[8]" "log-posterior"

# Remove scalar parameters
sso_reduced <- drop_parameters(sso, pars = c("mu", "tau"))
print(sso_reduced@param_names)
# [1] "theta[1]" "theta[2]" ... "theta[8]" "log-posterior"

# Remove entire parameter vector (all elements of theta)
sso_minimal <- drop_parameters(sso, pars = "theta")
print(sso_minimal@param_names)
# [1] "mu" "tau" "log-posterior"

# Note: Cannot remove individual elements like "theta[1]"
# Note: Cannot remove "log-posterior"
```
Tokens:
Raw