API¶
stan ([file, model_name, model_code, fit, ...]) 
Fit a model using Stan. 
stanc ([file, charset, model_code, ...]) 
Translate Stan model specification into C++ code. 
StanModel ([file, charset, model_name, ...]) 
Model described in Stan’s modeling language compiled from C++ code. 
StanFit4model instances are also documented on this page.

pystan.
stan
(file=None, model_name='anon_model', model_code=None, fit=None, data=None, pars=None, chains=4, iter=2000, warmup=None, thin=1, init='random', seed=None, algorithm=None, control=None, sample_file=None, diagnostic_file=None, verbose=False, boost_lib=None, eigen_lib=None, n_jobs=1, **kwargs)[source]¶ Fit a model using Stan.
Parameters: file : string {‘filename’, filelike object}
Model code must found via one of the following parameters: file or model_code.
If file is a filename, the string passed as an argument is expected to be a filename containing the Stan model specification.
If file is a file object, the object passed must have a ‘read’ method (filelike object) that is called to fetch the Stan model specification.
charset : string, optional
If bytes or files are provided, this charset is used to decode. ‘utf8’ by default.
model_code : string
A string containing the Stan model specification. Alternatively, the model may be provided with the parameter file.
model_name: string, optional :
A string naming the model. If none is provided ‘anon_model’ is the default. However, if file is a filename, then the filename will be used to provide a name. ‘anon_model’ by default.
fit : StanFit instance
An instance of StanFit derived from a previous fit, None by default. If fit is not None, the compiled model associated with a previous fit is reused and recompilation is avoided.
data : dict
A Python dictionary providing the data for the model. Variables for Stan are stored in the dictionary as expected. Variable names are the keys and the values are their associated values. Stan only accepts certain kinds of values; see Notes.
pars : list of string, optional
A list of strings indicating parameters of interest. By default all parameters specified in the model will be stored.
chains : int, optional
Positive integer specifying number of chains. 4 by default.
iter : int, 2000 by default
Positive integer specifying how many iterations for each chain including warmup.
warmup : int, iter//2 by default
Positive integer specifying number of warmup (aka burin) iterations. As warmup also specifies the number of iterations used for stepsize adaption, warmup samples should not be used for inference.
thin : int, optional
Positive integer specifying the period for saving samples. Default is 1.
init : {0, ‘0’, ‘random’, function returning dict, list of dict}, optional
Specifies how initial parameter values are chosen:  0 or ‘0’ initializes all to be zero on the unconstrained support.  ‘random’ generates random initial values. An optional parameter
init_r controls the range of randomly generated initial values for parameters in terms of their unconstrained support;
 list of size equal to the number of chains (chains), where the
list contains a dict with initial parameter values;
 function returning a dict with initial parameter values. The
function may take an optional argument chain_id.
seed : int or np.random.RandomState, optional
The seed, a positive integer for random number generation. Only one seed is needed when multiple chains are used, as the other chain’s seeds are generated from the first chain’s to prevent dependency among random number streams. By default, seed is
random.randint(0, MAX_UINT)
.algorithm : {“NUTS”, “HMC”, “Fixed_param”}, optional
One of the algorithms that are implemented in Stan such as the NoUTurn sampler (NUTS, Hoffman and Gelman 2011) and static HMC.
sample_file : string, optional
File name specifying where samples for all parameters and other saved quantities will be written. If not provided, no samples will be written. If the folder given is not writable, a temporary directory will be used. When there are multiple chains, an underscore and chain number are appended to the file name. By default do not write samples to file.
diagnostic_file : string, optional
File name specifying where diagnostic information should be written. By default no diagnostic information is recorded.
boost_lib : string, optional
The path to a version of the Boost C++ library to use instead of the one supplied with PyStan.
eigen_lib : string, optional
The path to a version of the Eigen C++ library to use instead of the one in the supplied with PyStan.
verbose : boolean, optional
Indicates whether intermediate output should be piped to the console. This output may be useful for debugging. False by default.
control : dict, optional
A dictionary of parameters to control the sampler’s behavior. Default values are used if control is not specified. The following are adaptation parameters for sampling algorithms.
These are parameters used in Stan with similar names:
 adapt_engaged : bool
 adapt_gamma : float, positive, default 0.05
 adapt_delta : float, between 0 and 1, default 0.8
 adapt_kappa : float, between default 0.75
 adapt_t0 : float, positive, default 10
 adapt_init_buffer : int, positive, defaults to 75
 adapt_term_buffer : int, positive, defaults to 50
 adapt_window : int, positive, defaults to 25
In addition, the algorithm HMC (called ‘static HMC’ in Stan) and NUTS share the following parameters:
 stepsize: float, positive
 stepsize_jitter: float, between 0 and 1
 metric : str, {“unit_e”, “diag_e”, “dense_e”}
In addition, depending on which algorithm is used, different parameters can be set as in Stan for sampling. For the algorithm HMC we can set
 int_time: float, positive
For algorithm NUTS, we can set
 max_treedepth : int, positive
n_jobs : int, optional
Sample in parallel. If 1 all CPUs are used. If 1, no parallel computing code is used at all, which is useful for debugging.
Returns: fit : StanFit instance
Other Parameters: chain_id : int, optional
chain_id can be a vector to specify the chain_id for all chains or an integer. For the former case, they should be unique. For the latter, the sequence of integers starting from the given chain_id are used for all chains.
init_r : float, optional
init_r is only valid if init == “random”. In this case, the intial values are simulated from [init_r, init_r] rather than using the default interval (see the manual of (Cmd)Stan).
test_grad: bool, optional :
If test_grad is
True
, Stan will not do any sampling. Instead, the gradient calculation is tested and printed out and the fitted StanFit4Model object is in test gradient mode. By default, it isFalse
.append_samples`: bool, optional :
refresh`: int, optional :
Argument refresh can be used to control how to indicate the progress during sampling (i.e. show the progress every code{refresh} iterations). By default, refresh is max(iter/10, 1).
obfuscate_model_name : boolean, optional
obfuscate_model_name is only valid if fit is None. True by default. If False the model name in the generated C++ code will not be made unique by the insertion of randomly generated characters. Generally it is recommended that this parameter be left as True.
Examples
>>> from pystan import stan >>> import numpy as np >>> model_code = ''' ... parameters { ... real y[2]; ... } ... model { ... y[1] ~ normal(0, 1); ... y[2] ~ double_exponential(0, 2); ... }''' >>> fit1 = stan(model_code=model_code, iter=10) >>> print(fit1) >>> 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); ... }''' >>> >>> def initfun1(): ... return dict(mu=1, sigma=4, z=np.random.normal(size=(3, 2)), alpha=1) >>> exfit0 = stan(model_code=excode, init=initfun1) >>> def initfun2(chain_id=1): ... return dict(mu=1, sigma=4, z=np.random.normal(size=(3, 2)), alpha=1 + chain_id) >>> exfit1 = stan(model_code=excode, init=initfun2)

pystan.
stanc
(file=None, charset='utf8', model_code=None, model_name='anon_model', verbose=False, obfuscate_model_name=True)[source]¶ Translate Stan model specification into C++ code.
Parameters: file : {string, file}, optional
If filename, the string passed as an argument is expected to be a filename containing the Stan model specification.
If file, the object passed must have a ‘read’ method (filelike object) that is called to fetch the Stan model specification.
charset : string, ‘utf8’ by default
If bytes or files are provided, this charset is used to decode.
model_code : string, optional
A string containing the Stan model specification. Alternatively, the model may be provided with the parameter file.
model_name: string, ‘anon_model’ by default :
A string naming the model. If none is provided ‘anon_model’ is the default. However, if file is a filename, then the filename will be used to provide a name.
verbose : boolean, False by default
Indicates whether intermediate output should be piped to the console. This output may be useful for debugging.
obfuscate_model_name : boolean, True by default
If False the model name in the generated C++ code will not be made unique by the insertion of randomly generated characters. Generally it is recommended that this parameter be left as True.
Returns: stanc_ret : dict
A dictionary with the following keys: model_name, model_code, cpp_code, and status. Status indicates the success of the translation from Stan code into C++ code (success = 0, error = 1).
Notes
C++ reserved words and Stan reserved words may not be used for variable names; see the Stan User’s Guide for a complete list.
References
The Stan Development Team (2013) Stan Modeling Language User’s Guide and Reference Manual. <http://mcstan.org/>.
Examples
>>> stanmodelcode = ''' ... data { ... int<lower=0> N; ... real y[N]; ... } ... ... parameters { ... real mu; ... } ... ... model { ... mu ~ normal(0, 10); ... y ~ normal(mu, 1); ... } ... ''' >>> r = stanc(model_code=stanmodelcode, model_name = "normal1") >>> sorted(r.keys()) ['cppcode', 'model_code', 'model_cppname', 'model_name', 'status'] >>> r['model_name'] 'normal1'

class
pystan.
StanModel
(file=None, charset='utf8', model_name='anon_model', model_code=None, stanc_ret=None, boost_lib=None, eigen_lib=None, verbose=False, obfuscate_model_name=True, extra_compile_args=None)[source]¶ Model described in Stan’s modeling language compiled from C++ code.
Instances of StanModel are typically created indirectly by the functions stan and stanc.
Parameters: file : string {‘filename’, ‘file’}
If filename, the string passed as an argument is expected to be a filename containing the Stan model specification.
If file, the object passed must have a ‘read’ method (filelike object) that is called to fetch the Stan model specification.
charset : string, ‘utf8’ by default
If bytes or files are provided, this charset is used to decode.
model_name: string, ‘anon_model’ by default :
A string naming the model. If none is provided ‘anon_model’ is the default. However, if file is a filename, then the filename will be used to provide a name.
model_code : string
A string containing the Stan model specification. Alternatively, the model may be provided with the parameter file.
stanc_ret : dict
A dict returned from a previous call to stanc which can be used to specify the model instead of using the parameter file or model_code.
boost_lib : string
The path to a version of the Boost C++ library to use instead of the one supplied with PyStan.
eigen_lib : string
The path to a version of the Eigen C++ library to use instead of the one in the supplied with PyStan.
verbose : boolean, False by default
Indicates whether intermediate output should be piped to the console. This output may be useful for debugging.
kwargs : keyword arguments
Additional arguments passed to stanc.
Notes
More details of Stan, including the full user’s guide and reference manual can be found at <URL: http://mcstan.org/>.
There are three ways to specify the model’s code for stan_model.
parameter model_code, containing a string to whose value is the Stan model specification,
parameter file, indicating a file (or a connection) from which to read the Stan model specification, or
 parameter stanc_ret, indicating the reuse of a model
generated in a previous call to stanc.
References
The Stan Development Team (2013) Stan Modeling Language User’s Guide and Reference Manual. <URL: http://mcstan.org/>.
Examples
>>> model_code = 'parameters {real y;} model {y ~ normal(0,1);}' >>> model_code; m = StanModel(model_code=model_code) ... 'parameters ... >>> m.model_name 'anon_model'
Attributes
model_name (string) model_code (string) Stan code for the model. model_cpp (string) C++ code for the model. module (builtins.module) Python module created by compiling the C++ code for the model. Methods
sampling
([data, pars, chains, iter, warmup, ...])Draw samples from the model. optimizing
([data, seed, init, sample_file, ...])Obtain a point estimate by maximizing the joint posterior. show Print the Stan model specification. get_cppcode Return the C++ code for the module. get_cxxflags Return the ‘CXXFLAGS’ used for compiling the model. 
optimizing
(data=None, seed=None, init='random', sample_file=None, algorithm=None, verbose=False, as_vector=True, **kwargs)[source]¶ Obtain a point estimate by maximizing the joint posterior.
Parameters: data : dict
A Python dictionary providing the data for the model. Variables for Stan are stored in the dictionary as expected. Variable names are the keys and the values are their associated values. Stan only accepts certain kinds of values; see Notes.
seed : int or np.random.RandomState, optional
The seed, a positive integer for random number generation. Only one seed is needed when multiple chains are used, as the other chain’s seeds are generated from the first chain’s to prevent dependency among random number streams. By default, seed is
random.randint(0, MAX_UINT)
.init : {0, ‘0’, ‘random’, function returning dict, list of dict}, optional
Specifies how initial parameter values are chosen:  0 or ‘0’ initializes all to be zero on the unconstrained support.  ‘random’ generates random initial values. An optional parameter
init_r controls the range of randomly generated initial values for parameters in terms of their unconstrained support;
 list of size equal to the number of chains (chains), where the list contains a dict with initial parameter values;
 function returning a dict with initial parameter values. The function may take an optional argument chain_id.
sample_file : string, optional
File name specifying where samples for all parameters and other saved quantities will be written. If not provided, no samples will be written. If the folder given is not writable, a temporary directory will be used. When there are multiple chains, an underscore and chain number are appended to the file name. By default do not write samples to file.
algorithm : {“LBFGS”, “BFGS”, “Newton”}, optional
Name of optimization algorithm to be used. Default is LBFGS.
verbose : boolean, optional
Indicates whether intermediate output should be piped to the console. This output may be useful for debugging. False by default.
as_vector : boolean, optional
Indicates an OrderedDict will be returned rather than a nested dictionary with keys ‘par’ and ‘value’.
Returns: optim : OrderedDict
Depending on as_vector, returns either an OrderedDict having parameters as keys and point estimates as values or an OrderedDict with components ‘par’ and ‘value’.
optim['par']
is a dictionary of point estimates, indexed by the parameter name.optim['value']
stores the value of the logposterior (up to an additive constant, thelp__
in Stan) corresponding to the point identified by `optim`[‘par’].Other Parameters: iter : int, optional
The maximum number of iterations.
save_iterations : bool, optional
refresh : int, optional
init_alpha : float, optional
For BFGS and LBFGS, default is 0.001
tol_obj : float, optional
For BFGS and LBFGS, default is 1e12.
tol_grad : float, optional
For BFGS and LBFGS, default is 1e8.
tol_param : float, optional
For BFGS and LBFGS, default is 1e8.
tol_rel_grad : float, optional
For BFGS and LBFGS, default is 1e7.
history_size : int, optional
For LBFGS, default is 5.
Refer to the manuals for both CmdStan and Stan for more details. :
Examples
>>> from pystan import StanModel >>> m = StanModel(model_code='parameters {real y;} model {y ~ normal(0,1);}') >>> f = m.optimizing()

sampling
(data=None, pars=None, chains=4, iter=2000, warmup=None, thin=1, seed=None, init='random', sample_file=None, diagnostic_file=None, verbose=False, algorithm=None, control=None, n_jobs=1, **kwargs)[source]¶ Draw samples from the model.
Parameters: data : dict
A Python dictionary providing the data for the model. Variables for Stan are stored in the dictionary as expected. Variable names are the keys and the values are their associated values. Stan only accepts certain kinds of values; see Notes.
pars : list of string, optional
A list of strings indicating parameters of interest. By default all parameters specified in the model will be stored.
chains : int, optional
Positive integer specifying number of chains. 4 by default.
iter : int, 2000 by default
Positive integer specifying how many iterations for each chain including warmup.
warmup : int, iter//2 by default
Positive integer specifying number of warmup (aka burin) iterations. As warmup also specifies the number of iterations used for stepsize adaption, warmup samples should not be used for inference.
thin : int, 1 by default
Positive integer specifying the period for saving samples.
seed : int or np.random.RandomState, optional
The seed, a positive integer for random number generation. Only one seed is needed when multiple chains are used, as the other chain’s seeds are generated from the first chain’s to prevent dependency among random number streams. By default, seed is
random.randint(0, MAX_UINT)
.algorithm : {“NUTS”, “HMC”, “Fixed_param”}, optional
One of algorithms that are implemented in Stan such as the NoUTurn sampler (NUTS, Hoffman and Gelman 2011), static HMC, or
Fixed_param
.init : {0, ‘0’, ‘random’, function returning dict, list of dict}, optional
Specifies how initial parameter values are chosen: 0 or ‘0’ initializes all to be zero on the unconstrained support; ‘random’ generates random initial values; list of size equal to the number of chains (chains), where the list contains a dict with initial parameter values; function returning a dict with initial parameter values. The function may take an optional argument chain_id.
sample_file : string, optional
File name specifying where samples for all parameters and other saved quantities will be written. If not provided, no samples will be written. If the folder given is not writable, a temporary directory will be used. When there are multiple chains, an underscore and chain number are appended to the file name. By default do not write samples to file.
verbose : boolean, False by default
Indicates whether intermediate output should be piped to the console. This output may be useful for debugging.
control : dict, optional
A dictionary of parameters to control the sampler’s behavior. Default values are used if control is not specified. The following are adaptation parameters for sampling algorithms.
These are parameters used in Stan with similar names:
 adapt_engaged : bool, default True
 adapt_gamma : float, positive, default 0.05
 adapt_delta : float, between 0 and 1, default 0.8
 adapt_kappa : float, between default 0.75
 adapt_t0 : float, positive, default 10
In addition, the algorithm HMC (called ‘static HMC’ in Stan) and NUTS share the following parameters:
 stepsize: float, positive
 stepsize_jitter: float, between 0 and 1
 metric : str, {“unit_e”, “diag_e”, “dense_e”}
In addition, depending on which algorithm is used, different parameters can be set as in Stan for sampling. For the algorithm HMC we can set
 int_time: float, positive
For algorithm NUTS, we can set
 max_treedepth : int, positive
n_jobs : int, optional
Sample in parallel. If 1 all CPUs are used. If 1, no parallel computing code is used at all, which is useful for debugging.
Returns: fit : StanFit4Model
Instance containing the fitted results.
Other Parameters: chain_id : int or iterable of int, optional
chain_id can be a vector to specify the chain_id for all chains or an integer. For the former case, they should be unique. For the latter, the sequence of integers starting from the given chain_id are used for all chains.
init_r : float, optional
init_r is only valid if init == “random”. In this case, the intial values are simulated from [init_r, init_r] rather than using the default interval (see the manual of Stan).
test_grad: bool, optional :
If test_grad is
True
, Stan will not do any sampling. Instead, the gradient calculation is tested and printed out and the fitted StanFit4Model object is in test gradient mode. By default, it isFalse
.append_samples`: bool, optional :
refresh`: int, optional :
Argument refresh can be used to control how to indicate the progress during sampling (i.e. show the progress every code{refresh} iterations). By default, refresh is max(iter/10, 1).
Examples
>>> from pystan import StanModel >>> m = StanModel(model_code='parameters {real y;} model {y ~ normal(0,1);}') >>> m.sampling(iter=100)

vb
(data=None, pars=None, iter=10000, seed=None, init='random', sample_file=None, diagnostic_file=None, verbose=False, algorithm=None, **kwargs)[source]¶ Call Stan’s variational Bayes methods.
Parameters: data : dict
A Python dictionary providing the data for the model. Variables for Stan are stored in the dictionary as expected. Variable names are the keys and the values are their associated values. Stan only accepts certain kinds of values; see Notes.
pars : list of string, optional
A list of strings indicating parameters of interest. By default all parameters specified in the model will be stored.
seed : int or np.random.RandomState, optional
The seed, a positive integer for random number generation. Only one seed is needed when multiple chains are used, as the other chain’s seeds are generated from the first chain’s to prevent dependency among random number streams. By default, seed is
random.randint(0, MAX_UINT)
.sample_file : string, optional
File name specifying where samples for all parameters and other saved quantities will be written. If not provided, samples will be written to a temporary file and read back in. If the folder given is not writable, a temporary directory will be used. When there are multiple chains, an underscore and chain number are appended to the file name. By default do not write samples to file.
diagnostic_file : string, optional
File name specifying where diagnostics for the variational fit will be written.
iter : int, 10000 by default
Positive integer specifying how many iterations for each chain including warmup.
algorithm : {‘meanfield’, ‘fullrank’}
algorithm}{One of “meanfield” and “fullrank” indicating which variational inference algorithm is used. meanfield: meanfield approximation; fullrank: fullrank covariance. The default is ‘meanfield’.
verbose : boolean, False by default
Indicates whether intermediate output should be piped to the console. This output may be useful for debugging.
Other optional parameters, refer to the manuals for both CmdStan :
and Stan. :
 `iter`: the maximum number of iterations, defaults to 10000 :
 `grad_samples` the number of samples for Monte Carlo enumerate of :
gradients, defaults to 1.
 `elbo_samples` the number of samples for Monte Carlo estimate of ELBO :
(objective function), defaults to 100. (ELBO stands for “the evidence lower bound”.)
 `eta` positive stepsize weighting parameters for variational :
inference but is ignored if adaptation is engaged, which is the case by default.
 `adapt_engaged` flag indicating whether to automatically adapt the :
stepsize and defaults to True.
 `tol_rel_obj`convergence tolerance on the relative norm of the :
objective, defaults to 0.01.
 `eval_elbo`, evaluate ELBO every Nth iteration, defaults to 100 :
 `output_samples` number of posterior samples to draw and save, :
defaults to 1000.
 `adapt_iter` number of iterations to adapt the stepsize if :
adapt_engaged is True and ignored otherwise.
Returns: results : dict
Dictionary containing information related to results.
Examples
>>> from pystan import StanModel >>> m = StanModel(model_code='parameters {real y;} model {y ~ normal(0,1);}') >>> results = m.vb() >>> # results saved on disk in format inspired by CSV >>> print(results['args']['sample_file'])
StanFit4model¶
Each StanFit instance is modelspecific, so the name of the class will be
something like: StanFit4anon_model
. The StanFit4model
instances expose
a number of methods.

class
pystan.
StanFit4model
¶ 
plot
(pars=None)¶ Visualize samples from posterior distributions
Parameters
 pars : sequence of str
 names of parameters
This is currently an alias for the traceplot method.

extract
(pars=None, permuted=True, inc_warmup=False)¶ Extract samples in different forms for different parameters.
Parameters
 pars : sequence of str
 names of parameters (including other quantities)
 permuted : bool
 If True, returned samples are permuted. All chains are merged and warmup samples are discarded.
 inc_warmup : bool
 If True, warmup samples are kept; otherwise they are discarded. If permuted is True, inc_warmup is ignored.
Returns
samples : dict or array If permuted is True, return dictionary with samples for each parameter (or other quantity) named in pars.
If permuted is False, an array is returned. The first dimension of the array is for the iterations; the second for the number of chains; the third for the parameters. Vectors and arrays are expanded to one parameter (a scalar) per cell, with names indicating the third dimension. Parameters are listed in the same order as model_pars and flatnames.

log_prob
(upar, adjust_transform=True, gradient=False)¶ Expose the log_prob of the model to stan_fit so user can call this function.
Parameters
 upar :
 The real parameters on the unconstrained space.
 adjust_transform : bool
 Whether we add the term due to the transform from constrained space to unconstrained space implicitly done in Stan.
Note
In Stan, the parameters need be defined with their supports. For example, for a variance parameter, we must define it on the positive real line. But inside Stan’s sampler, all parameters defined on the constrained space are transformed to unconstrained space, so the log density function need be adjusted (i.e., adding the log of the absolute value of the Jacobian determinant). With the transformation, Stan’s samplers work on the unconstrained space and once a new iteration is drawn, Stan transforms the parameters back to their supports. All the transformation are done inside Stan without interference from the users. However, when using the log density function for a model exposed to Python, we need to be careful. For example, if we are interested in finding the mode of parameters on the constrained space, we then do not need the adjustment. For this reason, there is an argument named adjust_transform for functions log_prob and grad_log_prob.

grad_log_prob
(upars, adjust_transform=True)¶ Expose the grad_log_prob of the model to stan_fit so user can call this function.
Parameters
 upar : array
 The real parameters on the unconstrained space.
 adjust_transform : bool
 Whether we add the term due to the transform from constrained space to unconstrained space implicitly done in Stan.

get_adaptation_info
()¶ Obtain adaptation information for sampler, which now only NUTS2 has.
The results are returned as a list, each element of which is a character string for a chain.

get_logposterior
(inc_warmup=True)¶ Get the logposterior (up to an additive constant) for all chains.
Each element of the returned array is the logposterior for a chain. Optional parameter inc_warmup indicates whether to include the warmup period.

get_sampler_params
(inc_warmup=True)¶ Obtain the parameters used for the sampler such as stepsize and treedepth. The results are returned as a list, each element of which is an OrderedDict a chain. The dictionary has number of elements corresponding to the number of parameters used in the sampler. Optional parameter inc_warmup indicates whether to include the warmup period.

get_posterior_mean
()¶ Get the posterior mean for all parameters
Returns
 means : array of shape (num_parameters, num_chains)
 Order of parameters is given by self.model_pars or self.flatnames if parameters of interest include nonscalar parameters. An additional column for mean lp__ is also included.

unconstrain_pars
(par)¶ Transform parameters from defined support to unconstrained space

get_seed
()¶

get_inits
()¶

get_stancode
()¶
