stanfit.stan(file, model_name = "anon_model", model_code = "",
fit = NA, data = list(), pars = NA, chains = 4,
iter = 2000, warmup = floor(iter/2), thin = 1,
init = "random", seed = sample.int(.Machine$integer.max, 1),
algorithm = c("NUTS", "HMC", "Fixed_param"), control = NULL,
sample_file = NULL, diagnostic_file = NULL,
save_dso = TRUE,
verbose = FALSE, include = TRUE,
cores = getOption("mc.cores", 1L),
open_progress = interactive() && !isatty(stdout()) &&
!identical(Sys.getenv("RSTUDIO"), "1"),
...,
boost_lib = NULL,
eigen_lib = NULL)model_code or t"anon_model". However, the model name would be derived from
file or model_code (if model_code is the name
of a character string object) if <file is not specified.
When fit is specified, the model cstanfit derived from
a previous fit; defaults to NA.
If fit is not NA, the compiled model associated with the fitted result
is re-used; thus the time that list or environment
providing the data for the model or a character vector
for all the names of objects used as data.
See the notes below.NA indicating all parameters in the model. If include = TRUE, only
samples for parameters given in pars are stored in the fitted re0, string "0" or "random",
a function that returns a named list, or a list of named list.
"0": initialize all to be zero on the unconstrained support;
"random": rantempdir() is used.tempdir() is used.
When there TRUE, indicating whether the
dynamic shared object (DSO) compiled from the C++ code for the model
will be saved or not. If TRUE, we can draw samples from
the same model in another Rsession usinTRUE or FALSE: flag indicating whether
to print intermediate output from Stan on the console, which might
be helpful for model debugging.list of parameters to control the sampler's
behavior. It defaults to NULL so all the default values are used.
First, the following are adaptation parameters for sampling algorithms.
These are parameters used TRUE indicating
whether to include or exclude the parameters given by the
pars argument. If FALSE, only entire multidimensional
parameters can be excluded, rather than particmc.cores option
to be as many processors as the hardware and RAM allow (up to the
number of chains).cores > 1 but is recommended to be TRUE in interactive
use so that the progress of the chains will be redirected to a file
that is automatically opened for inspection. For verchain_id(integer)init_r(double, positive)test_grad(logical)append_samples(logical)stanfit. However, if cores > 1
and there is an error for any of the chains, then the error(s) are printed. If
all chains have errors and an error occurs before or during sampling, the returned
object does not contain samples. But the compiled binary object for the
model is still included, so we can reuse the returned object for another
sampling.stan does all of the work of fitting a
Stan model and returning the results as an instance of stanfit.
First, it translates the Stan model to C++ code. Second, the
C++ code is compiled into a binary shared object, which
is loaded into the current Rsession (an object
of S4 class stanmodel is created). Finally, samples
are drawn and wrapped in an object of S4 class stanfit,
which provides functions such as print, summary, and plot
to inspect and retrieve the results of the fitted model. stan can also be used to sample again from a fitted model under
different settings (e.g., different iter) by providing
argument fit. In this case, the compiled C++ code
for the model is reused.
The Stan Development Team
CmdStan Interface User's Guide.
stanc for translating model code in Stan modeling language to C++,
sampling for sampling, and stanfit see extract and as.array.stanfit for extracting
samples from stanfit objects.
#### example 1
library(rstan)
scode <- "
parameters {
real y[2];
}
model {
y[1] ~ normal(0, 1);
y[2] ~ double_exponential(0, 2);
}
"
fit1 <- stan(model_code = scode, iter = 10, verbose = FALSE)
print(fit1)
fit2 <- stan(fit = fit1, iter = 10000, verbose = FALSE)
## extract samples as a list of arrays
e2 <- extract(fit2, permuted = TRUE)
## using as.array on the stanfit object to get samples
a2 <- as.array(fit2)
#### example 2
#### the result of this package is included in the package
excode <- '
transformed data {
real y[20];
y[1] <- 0.5796; y[2] <- 0.2276; y[3] <- -0.2959;
y[4] <- -0.3742; y[5] <- 0.3885; y[6] <- -2.1585;
y[7] <- 0.7111; y[8] <- 1.4424; y[9] <- 2.5430;
y[10] <- 0.3746; y[11] <- 0.4773; y[12] <- 0.1803;
y[13] <- 0.5215; y[14] <- -1.6044; y[15] <- -0.6703;
y[16] <- 0.9459; y[17] <- -0.382; y[18] <- 0.7619;
y[19] <- 0.1006; y[20] <- -1.7461;
}
parameters {
real mu;
real<lower=0, upper=10> sigma;
vector[2] z[3];
real<lower=0> alpha;
}
model {
y ~ normal(mu, sigma);
for (i in 1:3)
z[i] ~ normal(0, 1);
alpha ~ exponential(2);
}
'
exfit <- stan(model_code = excode, save_dso = FALSE, iter = 500)
print(exfit)
plot(exfit)
## examples of specify argument `init` for function stan
## define a function to generate initial values that can
## be fed to function stan's argument `init`
# function form 1 without arguments
initf1 <- function() {
list(mu = 1, sigma = 4, z = array(rnorm(6), dim = c(3,2)), alpha = 1)
}
# function form 2 with an argument named `chain_id`
initf2 <- function(chain_id = 1) {
# cat("chain_id =", chain_id, "\n")
list(mu = 1, sigma = 4, z = array(rnorm(6), dim = c(3,2)), alpha = chain_id)
}
# generate a list of lists to specify initial values
n_chains <- 4
init_ll <- lapply(1:n_chains, function(id) initf2(chain_id = id))
exfit0 <- stan(model_code = excode, init = initf1)
stan(fit = exfit0, init = initf2)
stan(fit = exfit0, init = init_ll, chains = n_chains)Run the code above in your browser using DataLab