Summarising

StatsBase.summarystats(
    chain::FlexiChain{TKey};
    split_varnames::Bool=true,
    warn::Bool=true,
) where {TKey}

Compute a standard set of summary statistics for each key in the chain. The statistics include:

• mean (using Statistics.mean)
• standard deviation (Statistics.std)
• Monte Carlo standard error (MCMCDiagnosticTools.mcse)
• bulk effective sample size (MCMCDiagnosticTools.ess)
• tail effective sample size
• R-hat diagnostic (MCMCDiagnosticTools.rhat)
• 5th, 50th (median), and 95th percentiles (Statistics.quantile)

The split_varnames keyword argument, if true, will first split up variables in the chain such that each key corresponds to a single scalar value. The splitting is only supported for chains with TKey<:VarName or TKey==Symbol; for other key types, this will be a no-op as long as the data already contain scalar values for every key, but will error if the data contain non-scalar values.

If any of the statistics cannot be computed for a key, a missing value is returned. If none of the statistics can be computed for a key, that key will be dropped from the resulting FlexiSummary, and a warning issued. The warning can be suppressed by setting warn=false.

Statistics.mean(
    chain::FlexiChain{TKey};
    dims::Symbol=:both,
    warn::Bool=true,
    split_varnames::Bool=true,
    kwargs...
) where {TKey}

Calculate the mean across all iterations and chains for each key in the chain. If the statistic cannot be computed for a key, that key is skipped and a warning is issued (which can be suppressed by setting warn=false).

The dims keyword argument specifies which dimensions to collapse. The default value of :both collapses both the iteration and chain dimensions. Other valid values are :iter or :chain, which respectively collapse only the iteration or chain dimension.

The split_varnames keyword argument, if true, will first split up variables in the chain such that each key corresponds to a single scalar value. This is only supported for chains with TKey<:VarName or TKey==Symbol; for other key types this will be a no-op as long as the data already contain scalar values for every key, but will error if the data contain non-scalar values.

Other keyword arguments are forwarded to Statistics.mean; please see its documentation for details of supported keyword arguments.

Statistics.median(
    chain::FlexiChain{TKey};
    dims::Symbol=:both,
    warn::Bool=true,
    split_varnames::Bool=true,
    kwargs...
) where {TKey}

Calculate the median across all iterations and chains for each key in the chain. If the statistic cannot be computed for a key, that key is skipped and a warning is issued (which can be suppressed by setting warn=false).

The dims keyword argument specifies which dimensions to collapse. The default value of :both collapses both the iteration and chain dimensions. Other valid values are :iter or :chain, which respectively collapse only the iteration or chain dimension.

The split_varnames keyword argument, if true, will first split up variables in the chain such that each key corresponds to a single scalar value. This is only supported for chains with TKey<:VarName or TKey==Symbol; for other key types this will be a no-op as long as the data already contain scalar values for every key, but will error if the data contain non-scalar values.

Other keyword arguments are forwarded to Statistics.median; please see its documentation for details of supported keyword arguments.

Statistics.std(
    chain::FlexiChain{TKey};
    dims::Symbol=:both,
    warn::Bool=true,
    split_varnames::Bool=true,
    kwargs...
) where {TKey}

Calculate the standard deviation across all iterations and chains for each key in the chain. If the statistic cannot be computed for a key, that key is skipped and a warning is issued (which can be suppressed by setting warn=false).

The dims keyword argument specifies which dimensions to collapse. The default value of :both collapses both the iteration and chain dimensions. Other valid values are :iter or :chain, which respectively collapse only the iteration or chain dimension.

The split_varnames keyword argument, if true, will first split up variables in the chain such that each key corresponds to a single scalar value. This is only supported for chains with TKey<:VarName or TKey==Symbol; for other key types this will be a no-op as long as the data already contain scalar values for every key, but will error if the data contain non-scalar values.

Other keyword arguments are forwarded to Statistics.std; please see its documentation for details of supported keyword arguments.

Statistics.var(
    chain::FlexiChain{TKey};
    dims::Symbol=:both,
    warn::Bool=true,
    split_varnames::Bool=true,
    kwargs...
) where {TKey}

Calculate the variance across all iterations and chains for each key in the chain. If the statistic cannot be computed for a key, that key is skipped and a warning is issued (which can be suppressed by setting warn=false).

The dims keyword argument specifies which dimensions to collapse. The default value of :both collapses both the iteration and chain dimensions. Other valid values are :iter or :chain, which respectively collapse only the iteration or chain dimension.

The split_varnames keyword argument, if true, will first split up variables in the chain such that each key corresponds to a single scalar value. This is only supported for chains with TKey<:VarName or TKey==Symbol; for other key types this will be a no-op as long as the data already contain scalar values for every key, but will error if the data contain non-scalar values.

Other keyword arguments are forwarded to Statistics.var; please see its documentation for details of supported keyword arguments.

Statistics.quantile(
    chain::FlexiChain{TKey},
    p;
    dims::Symbol=:both,
    warn::Bool=true,
    split_varnames::Bool=true,
    kwargs...
) where {TKey}

Calculate the quantile across all iterations and chains for each key in the chain. If it cannot be computed for a key, that key is skipped and a warning is issued (which can be suppressed by setting warn=false).

The dims keyword argument specifies which dimensions to collapse.

• :iter: collapse the iteration dimension only
• :chain: collapse the chain dimension only
• :both: collapse both the iteration and chain dimensions (default)

The argument p specifies the quantile to compute, and is forwarded to Statistics.quantile, along with any other keyword arguments.

Base.minimum(
    chain::FlexiChain{TKey};
    dims::Symbol=:both,
    warn::Bool=true,
    split_varnames::Bool=true,
    kwargs...
) where {TKey}

Calculate the minimum across all iterations and chains for each key in the chain. If the statistic cannot be computed for a key, that key is skipped and a warning is issued (which can be suppressed by setting warn=false).

The dims keyword argument specifies which dimensions to collapse. The default value of :both collapses both the iteration and chain dimensions. Other valid values are :iter or :chain, which respectively collapse only the iteration or chain dimension.

The split_varnames keyword argument, if true, will first split up variables in the chain such that each key corresponds to a single scalar value. This is only supported for chains with TKey<:VarName or TKey==Symbol; for other key types this will be a no-op as long as the data already contain scalar values for every key, but will error if the data contain non-scalar values.

Other keyword arguments are forwarded to Base.minimum; please see its documentation for details of supported keyword arguments.

Base.maximum(
    chain::FlexiChain{TKey};
    dims::Symbol=:both,
    warn::Bool=true,
    split_varnames::Bool=true,
    kwargs...
) where {TKey}

Calculate the maximum across all iterations and chains for each key in the chain. If the statistic cannot be computed for a key, that key is skipped and a warning is issued (which can be suppressed by setting warn=false).

The dims keyword argument specifies which dimensions to collapse. The default value of :both collapses both the iteration and chain dimensions. Other valid values are :iter or :chain, which respectively collapse only the iteration or chain dimension.

The split_varnames keyword argument, if true, will first split up variables in the chain such that each key corresponds to a single scalar value. This is only supported for chains with TKey<:VarName or TKey==Symbol; for other key types this will be a no-op as long as the data already contain scalar values for every key, but will error if the data contain non-scalar values.

Other keyword arguments are forwarded to Base.maximum; please see its documentation for details of supported keyword arguments.

Base.sum(
    chain::FlexiChain{TKey};
    dims::Symbol=:both,
    warn::Bool=true,
    split_varnames::Bool=true,
    kwargs...
) where {TKey}

Calculate the sum across all iterations and chains for each key in the chain. If the statistic cannot be computed for a key, that key is skipped and a warning is issued (which can be suppressed by setting warn=false).

The dims keyword argument specifies which dimensions to collapse. The default value of :both collapses both the iteration and chain dimensions. Other valid values are :iter or :chain, which respectively collapse only the iteration or chain dimension.

The split_varnames keyword argument, if true, will first split up variables in the chain such that each key corresponds to a single scalar value. This is only supported for chains with TKey<:VarName or TKey==Symbol; for other key types this will be a no-op as long as the data already contain scalar values for every key, but will error if the data contain non-scalar values.

Other keyword arguments are forwarded to Base.sum; please see its documentation for details of supported keyword arguments.

Base.prod(
    chain::FlexiChain{TKey};
    dims::Symbol=:both,
    warn::Bool=true,
    split_varnames::Bool=true,
    kwargs...
) where {TKey}

Calculate the product across all iterations and chains for each key in the chain. If the statistic cannot be computed for a key, that key is skipped and a warning is issued (which can be suppressed by setting warn=false).

The dims keyword argument specifies which dimensions to collapse. The default value of :both collapses both the iteration and chain dimensions. Other valid values are :iter or :chain, which respectively collapse only the iteration or chain dimension.

The split_varnames keyword argument, if true, will first split up variables in the chain such that each key corresponds to a single scalar value. This is only supported for chains with TKey<:VarName or TKey==Symbol; for other key types this will be a no-op as long as the data already contain scalar values for every key, but will error if the data contain non-scalar values.

Other keyword arguments are forwarded to Base.prod; please see its documentation for details of supported keyword arguments.

MCMCDiagnosticTools.ess(
    chain::FlexiChain{TKey};
    dims::Symbol=:both,
    warn::Bool=true,
    split_varnames::Bool=true,
    kwargs...
) where {TKey}

Calculate the effective sample size across all iterations and chains for each key in the chain. If the statistic cannot be computed for a key, that key is skipped and a warning is issued (which can be suppressed by setting warn=false).

The dims keyword argument specifies which dimensions to collapse. The default value of :both collapses both the iteration and chain dimensions. Other valid values are :iter or :chain, which respectively collapse only the iteration or chain dimension.

The split_varnames keyword argument, if true, will first split up variables in the chain such that each key corresponds to a single scalar value. This is only supported for chains with TKey<:VarName or TKey==Symbol; for other key types this will be a no-op as long as the data already contain scalar values for every key, but will error if the data contain non-scalar values.

Other keyword arguments are forwarded to MCMCDiagnosticTools.ess; please see its documentation for details of supported keyword arguments.

MCMCDiagnosticTools.rhat(
    chain::FlexiChain{TKey};
    dims::Symbol=:both,
    warn::Bool=true,
    split_varnames::Bool=true,
    kwargs...
) where {TKey}

Calculate the R-hat diagnostic across all iterations and chains for each key in the chain. If the statistic cannot be computed for a key, that key is skipped and a warning is issued (which can be suppressed by setting warn=false).

The dims keyword argument specifies which dimensions to collapse. The default value of :both collapses both the iteration and chain dimensions. Other valid values are :iter or :chain, which respectively collapse only the iteration or chain dimension.

The split_varnames keyword argument, if true, will first split up variables in the chain such that each key corresponds to a single scalar value. This is only supported for chains with TKey<:VarName or TKey==Symbol; for other key types this will be a no-op as long as the data already contain scalar values for every key, but will error if the data contain non-scalar values.

Other keyword arguments are forwarded to MCMCDiagnosticTools.rhat; please see its documentation for details of supported keyword arguments.

MCMCDiagnosticTools.mcse(
    chain::FlexiChain{TKey};
    dims::Symbol=:both,
    warn::Bool=true,
    split_varnames::Bool=true,
    kwargs...
) where {TKey}

Calculate the Monte Carlo standard error across all iterations and chains for each key in the chain. If the statistic cannot be computed for a key, that key is skipped and a warning is issued (which can be suppressed by setting warn=false).

The dims keyword argument specifies which dimensions to collapse. The default value of :both collapses both the iteration and chain dimensions. Other valid values are :iter or :chain, which respectively collapse only the iteration or chain dimension.

The split_varnames keyword argument, if true, will first split up variables in the chain such that each key corresponds to a single scalar value. This is only supported for chains with TKey<:VarName or TKey==Symbol; for other key types this will be a no-op as long as the data already contain scalar values for every key, but will error if the data contain non-scalar values.

Other keyword arguments are forwarded to MCMCDiagnosticTools.mcse; please see its documentation for details of supported keyword arguments.

StatsBase.mad(
    chain::FlexiChain{TKey};
    dims::Symbol=:both,
    warn::Bool=true,
    split_varnames::Bool=true,
    kwargs...
) where {TKey}

Calculate the median absolute deviation across all iterations and chains for each key in the chain. If the statistic cannot be computed for a key, that key is skipped and a warning is issued (which can be suppressed by setting warn=false).

The dims keyword argument specifies which dimensions to collapse. The default value of :both collapses both the iteration and chain dimensions. Other valid values are :iter or :chain, which respectively collapse only the iteration or chain dimension.

The split_varnames keyword argument, if true, will first split up variables in the chain such that each key corresponds to a single scalar value. This is only supported for chains with TKey<:VarName or TKey==Symbol; for other key types this will be a no-op as long as the data already contain scalar values for every key, but will error if the data contain non-scalar values.

Other keyword arguments are forwarded to StatsBase.mad; please see its documentation for details of supported keyword arguments.

StatsBase.geomean(
    chain::FlexiChain{TKey};
    dims::Symbol=:both,
    warn::Bool=true,
    split_varnames::Bool=true,
    kwargs...
) where {TKey}

Calculate the geometric mean across all iterations and chains for each key in the chain. If the statistic cannot be computed for a key, that key is skipped and a warning is issued (which can be suppressed by setting warn=false).

The dims keyword argument specifies which dimensions to collapse. The default value of :both collapses both the iteration and chain dimensions. Other valid values are :iter or :chain, which respectively collapse only the iteration or chain dimension.

The split_varnames keyword argument, if true, will first split up variables in the chain such that each key corresponds to a single scalar value. This is only supported for chains with TKey<:VarName or TKey==Symbol; for other key types this will be a no-op as long as the data already contain scalar values for every key, but will error if the data contain non-scalar values.

Other keyword arguments are forwarded to StatsBase.geomean; please see its documentation for details of supported keyword arguments.

StatsBase.harmmean(
    chain::FlexiChain{TKey};
    dims::Symbol=:both,
    warn::Bool=true,
    split_varnames::Bool=true,
    kwargs...
) where {TKey}

Calculate the harmonic mean across all iterations and chains for each key in the chain. If the statistic cannot be computed for a key, that key is skipped and a warning is issued (which can be suppressed by setting warn=false).

The dims keyword argument specifies which dimensions to collapse. The default value of :both collapses both the iteration and chain dimensions. Other valid values are :iter or :chain, which respectively collapse only the iteration or chain dimension.

The split_varnames keyword argument, if true, will first split up variables in the chain such that each key corresponds to a single scalar value. This is only supported for chains with TKey<:VarName or TKey==Symbol; for other key types this will be a no-op as long as the data already contain scalar values for every key, but will error if the data contain non-scalar values.

Other keyword arguments are forwarded to StatsBase.harmmean; please see its documentation for details of supported keyword arguments.

StatsBase.iqr(
    chain::FlexiChain{TKey};
    dims::Symbol=:both,
    warn::Bool=true,
    split_varnames::Bool=true,
    kwargs...
) where {TKey}

Calculate the interquartile range across all iterations and chains for each key in the chain. If the statistic cannot be computed for a key, that key is skipped and a warning is issued (which can be suppressed by setting warn=false).

The dims keyword argument specifies which dimensions to collapse. The default value of :both collapses both the iteration and chain dimensions. Other valid values are :iter or :chain, which respectively collapse only the iteration or chain dimension.

The split_varnames keyword argument, if true, will first split up variables in the chain such that each key corresponds to a single scalar value. This is only supported for chains with TKey<:VarName or TKey==Symbol; for other key types this will be a no-op as long as the data already contain scalar values for every key, but will error if the data contain non-scalar values.

Other keyword arguments are forwarded to StatsBase.iqr; please see its documentation for details of supported keyword arguments.

StatsBase.autocor(
    chain::FlexiChain{TKey};
    lags::AbstractVector{<:Integer}=[1, 5, 10, 50],
    demean::Bool=true,
    dims::Symbol=:both,
    warn::Bool=true,
    split_varnames::Bool=true,
) where {TKey}

Calculate the autocorrelation of each key in the chain at each of the given lags.

The result is a FlexiSummary with one statistic per lag, named :lag1, :lag5, and so on. Autocorrelation is always computed within each chain separately, since consecutive samples from different chains are unrelated. The dims keyword argument controls how the per-chain results are combined:

• :both (the default): the per-chain autocorrelations are averaged, giving a single value per key and lag.
• :iter: the autocorrelation is reported separately for each chain.
• :chain is not supported, since autocorrelation across chains at a single iteration is not meaningful.

If a lag is greater than or equal to the number of iterations, the autocorrelation at that lag cannot be computed and is reported as missing. If the autocorrelation cannot be computed for a key at any lag (for example because the key is not real-valued), that key is skipped and a warning is issued (which can be suppressed by setting warn=false).

The demean keyword argument is forwarded to StatsBase.autocor; if true, the mean of each chain is subtracted before computing the autocorrelation.

The split_varnames keyword argument, if true, will first split up variables in the chain such that each key corresponds to a single scalar value. This is only supported for chains with TKey<:VarName or TKey==Symbol; for other key types this will be a no-op as long as the data already contain scalar values for every key, but will error if the data contain non-scalar values.

Statistics.cor(
    chain::FlexiChain{TKey};
    dims::Symbol=:both,
    warn::Bool=true,
    split_varnames::Bool=true,
) where {TKey}

Calculate the Pearson correlation matrix between all parameters in the chain.

Unlike the other summary functions, this does not return a FlexiSummary, since the result is a matrix over pairs of parameters rather than a value for each parameter. Instead, it returns a DimensionalData.DimArray:

• With dims=:both (the default), samples from all chains are pooled together, and the result has dimensions (:param, :param).
• With dims=:iter, a separate correlation matrix is computed for each chain, and the result has dimensions (:chain, :param, :param).
• dims=:chain is not supported, since correlations across chains at a single iteration are not meaningful.

Both :param dimensions are indexed by the parameter keys, so the correlation between parameters x and y can be obtained with c[At(x), At(y)].

Only parameters (not extras) are included. The split_varnames keyword argument, if true, will first split up array-valued parameters such that each key corresponds to a single scalar value. Parameters whose values are not Real are skipped with a warning (which can be suppressed by setting warn=false).

changerate(
    chain::FlexiChain;
    dims::Symbol=:both,
    warn::Bool=true,
    split_varnames::Bool=true,
)

Calculate the number of adjacent values that differ for each key in the chain, divided by the number of transitions, i.e., niters - 1.

Change rates are always computed within each chain separately, since consecutive samples from different chains are unrelated.

The dims keyword argument controls how the per-chain results are combined:

• :both (the default): the per-chain change rates are averaged, giving a single value per key.
• :iter: the change rate is reported separately for each chain.
• :chain is not supported, since a change rate across chains at a single iteration is not meaningful.

FlexiChains.collapse(
    chain::FlexiChain,
    funcs::AbstractVector;
    dims::Symbol=:both,
    warn::Bool=true,
    split_varnames::Bool=true,
    drop_stat_dim::Bool=false,
)

Low-level function to collapse one or both dimensions of a FlexiChain by applying a list of summary statistics.

The funcs argument must be a vector of FlexiChains.CollapseFunctions. The name of each statistic in the result is taken from the CollapseFunction.

The dims keyword argument specifies which dimensions to collapse. By default, dims is :both, which collapses both the iteration and chain dimensions. Other valid values are :iter or :chain, which respectively collapse only the iteration or chain dimension.

A CollapseFunction specifies how to compute a statistic for each of the three possible values of dims. Ordinary functions can be converted to CollapseFunctions using one of the following shortcuts:

• FlexiChains.CollapseFunctionVec for functions that map a vector to a single value, such as Statistics.mean;
• FlexiChains.CollapseFunctionDiagnostic for MCMC diagnostics, such as MCMCDiagnosticTools.rhat.

using FlexiChains: collapse, CollapseFunctionVecusing Statistics: mean, stdcollapse(chn, [CollapseFunctionVec(mean), CollapseFunctionVec(std)]; dims=:both)collapse(chn, [CollapseFunctionVec(mean), CollapseFunctionVec(std)]; dims=:iter)

Positional and keyword arguments passed to the shortcut constructors are forwarded to the underlying function.

Sometimes the inferred statistic name is not what you want (for example, if you calculate several quantiles). In this case, you can pass a Symbol as the first argument to be used as the name, as illustrated by :q5 and :q95 below.

collapse(chn, [    CollapseFunctionVec(mean),    CollapseFunctionVec(std),    CollapseFunctionVec(:q5, quantile, 0.05),    CollapseFunctionVec(:q95, quantile, 0.95),])

If a statistic function errors when applied to a key, the value for that statistic is missing. If all statistic functions error for a key, that key is skipped and a warning is issued. The warning can be suppressed by setting warn=false.

If any CollapseFunction does not support the requested dims (i.e., the corresponding field is nothing), an ArgumentError is thrown. If a CollapseFunction returns an output of the wrong size, a DimensionMismatch is thrown.

The split_varnames keyword argument, if true, will first split up variables in the chain such that each key corresponds to a single scalar value.

If the drop_stat_dim keyword argument is true and only one function is provided in funcs, then the resulting FlexiSummary will have the stat dimension dropped. This allows for easier indexing into the result when only one statistic is computed. It is an error to set drop_stat_dim=true when more than one function is provided.

FlexiChains.CollapseFunction(name::Symbol, over_chain_iter, over_chain, over_iter)
FlexiChains.CollapseFunction(over_chain_iter, over_chain, over_iter)

A summary statistic that can be passed to FlexiChains.collapse. It bundles together three functions, one for each way that the (iter, chain) dimensions of a FlexiChain can be collapsed. Each function receives the full (iter, chain) matrix of samples for a single key, and must return:

• over_chain_iter: a single summary value (used for dims=:both);
• over_chain: one value per iteration, i.e. a vector of length niters or an (niters, 1) matrix (used for dims=:chain);
• over_iter: one value per chain, i.e. a vector of length nchains or a (1, nchains) matrix (used for dims=:iter).

Any of these may be nothing, which indicates that the statistic cannot be computed when collapsing over those dimensions. In that case, collapse throws an ArgumentError if the corresponding dims is requested.

name is the name of the statistic in the resulting FlexiSummary. If it is not provided, it is obtained from the first function which is not nothing (so at least one of them must not be nothing).

For example, the mean can be expressed as

using Statistics: meanCollapseFunction(mean, m -> mean(m; dims=2), m -> mean(m; dims=1))

Most of the time, you will not need to construct this directly, and can instead use one of the following shortcuts:

• FlexiChains.CollapseFunctionVec, for functions which map a vector to a single value (e.g. mean, quantile);
• FlexiChains.CollapseFunctionDiagnostic, for MCMC diagnostics which need to know which chain each sample came from (e.g. rhat, ess).

FlexiChains.CollapseFunctionVec([name::Symbol,] f, args...; kwargs...)

Construct a FlexiChains.CollapseFunction from a function f which maps a vector to a single value, like Statistics.mean or Statistics.quantile. When collapsing over both dimensions, f is applied to all samples stacked together into a single vector; otherwise it is applied to each row (dims=:chain) or column (dims=:iter) of the (iter, chain) matrix. This is equivalent to

CollapseFunction(    name,    m -> f(vec(m), args...; kwargs...),    m -> map(r -> f(r, args...; kwargs...), eachrow(m)),    m -> map(c -> f(c, args...; kwargs...), eachcol(m)),)

where name defaults to Symbol(f).

Note that this discards the information about which chain each sample came from when collapsing over both dimensions. For MCMC diagnostics, which depend on this information, use FlexiChains.CollapseFunctionDiagnostic instead.

FlexiChains.CollapseFunctionDiagnostic([name::Symbol,] f, args...; kwargs...)

Construct a FlexiChains.CollapseFunction from an MCMC diagnostic function f, such as MCMCDiagnosticTools.rhat or MCMCDiagnosticTools.ess, which takes an (iter, chain) matrix of samples and returns a single value.

• When collapsing over both dimensions, f is applied to the full (iter, chain) matrix, so that it can make use of the chain structure.
• When collapsing over iterations only (dims=:iter), f is applied to each chain separately.
• Collapsing over chains only (dims=:chain) is not supported, since a diagnostic computed across chains at a single iteration is not meaningful.

This is equivalent to

CollapseFunction(    name,    m -> f(m, args...; kwargs...),    nothing,    m -> map(c -> f(c, args...; kwargs...), eachcol(m)),)

where name defaults to Symbol(f).

Base.merge(
    s1::FlexiSummary{TKey1},
    s2::FlexiSummary{TKey2},
) where {TKey1,TKey2}

Merge two FlexiSummarys along both the key and statistic dimensions.

The two summaries must have the same iteration and chain indices.

The merged result contains the union of keys and the union of stat names from both summaries. For each (key, stat) pair, the value from s2 takes priority over s1. Pairs that exist in neither summary are filled with missing.

If the key types are different, the resulting FlexiSummary will have a promoted key type, and a warning will be issued.

MCMCDiagnosticTools.gelmandiag(
    chain::FlexiChain{TKey};
    warn::Bool=true,
    kwargs...
) where {TKey}

Compute the Gelman–Rubin–Brooks diagnostic (Potential Scale Reduction Factor, PSRF) for each parameter in the chain.

Returns a FlexiSummary with two statistics per parameter: :psrf (the point estimate) and :psrfci (the upper confidence limit).

The FlexiChain must contain at least 2 chains. Array-valued parameters are automatically split into their constituent scalars. Non-Real-valued keys are skipped with a warning (which can be suppressed via warn=false).

Other keyword arguments are forwarded to MCMCDiagnosticTools.gelmandiag.

MCMCDiagnosticTools.gelmandiag_multivariate(
    chain::FlexiChain{TKey};
    warn::Bool=true,
    kwargs...
) where {TKey}

Compute the multivariate Gelman–Rubin–Brooks diagnostic for the chain. This requires at least 2 parameters and at least 2 chains.

Returns a NamedTuple with two fields:

• summary: a FlexiSummary with :psrf and :psrfci statistics (same as what gelmandiag returns)
• psrf_multivariate: the multivariate potential scale reduction factor (Float64)

Array-valued parameters are automatically split into their constituent scalars. Non-Real-valued keys are skipped with a warning (which can be suppressed via warn=false).

Other keyword arguments are forwarded to MCMCDiagnosticTools.gelmandiag_multivariate.

MCMCDiagnosticTools.discretediag(
    chain::FlexiChain{TKey};
    warn::Bool=true,
    kwargs...
) where {TKey}

Compute the discrete diagnostic for each parameter in the chain. This diagnostic is designed for discrete (categorical) MCMC samples.

Returns a NamedTuple with two fields:

• between: a FlexiSummary with between-chain diagnostics (:stat, :df, :pvalue) per parameter
• within: a FlexiSummary with within-chain diagnostics (:stat, :df, :pvalue) per parameter and per chain

The FlexiChain must contain at least 2 chains. Array-valued parameters are automatically split into their constituent scalars. Non-Integer-valued keys are skipped with a warning (which can be suppressed via warn=false).

Other keyword arguments are forwarded to MCMCDiagnosticTools.discretediag.

MCMCDiagnosticTools.bfmi(
    chain::FlexiChain,
    energy_key
)

Calculate the Bayesian fraction of missing information (BFMI) from the given chain, using the specified energy_key to identify the key in the chain that corresponds to the Hamiltonian energy. Returns a DimVector of BFMI values, one per chain (note that even if there is only one chain, the result will still be a vector of length 1).

For chains sampled with Turing.jl's HMC/NUTS, the energy key is :hamiltonian_energy.

MCMCDiagnosticTools.rstar(
    [rng::Random.AbstractRNG,]
    classifier::MLJModelInterface.Supervised,
    chain::FlexiChain;
    warn::Bool=true,
    kwargs...
)

Compute the $R^*$ convergence diagnostic of the chain using the given MLJ classifier. Returns a distribution of $R^*$ values for probabilistic classifiers, or a single value for deterministic ones; values close to 1 indicate convergence.

All Real-valued parameters are used; array-valued parameters are automatically split into their constituent scalars. Non-Real-valued keys are skipped with a warning (which can be suppressed via warn=false).

Other keyword arguments are forwarded to MCMCDiagnosticTools.rstar.

using MLJDecisionTreeInterfacerstar(DecisionTreeClassifier(), chain)