def az_mu_sigma_plot(stan_fit):
"""
Function to demonstrate pystan theta convergence result through R_hat table, autocorrelation (3 chians), and trace plot
"""
az.plot_trace(stan_fit, var_names=['sigma2', 'mu'], filter_vars="like")
az.plot_autocorr(stan_fit, var_names=['sigma2', "mu"])
az.plot_pair(stan_fit, var_names=['sigma2', "mu"], divergences=True)
def bayes_multiple_detector_I(t, s, n, tracename):
with pm.Model() as abrupt_model:
sigma = pm.Normal('sigma', mu=30, sigma=5)
# sigma = pm.Uniform('sigma', 5, 15)
mu = pm.Uniform("mu1", -30, 30)
tau = pm.DiscreteUniform("tau" + "1", t.min(), t.max())
for i in np.arange(2, n + 2):
_mu = pm.Uniform("mu" + str(i), -100, 0)
mu = T.switch(tau >= t, mu, _mu)
if (i < (n + 1)):
tau = pm.DiscreteUniform("tau" + str(i), tau, t.max())
# add random walk
# sigma_rw = pm.Uniform("sigma_rw", 0, 10)
g_rw = pm.GaussianRandomWalk("g_rw", tau=1, shape=len(s))
s_obs = pm.Normal("s_obs", mu=g_rw + mu, sigma=sigma, observed=s)
# g = pm.model_to_graphviz(abrupt_model)
# g.view()
with abrupt_model:
pm.find_MAP()
trace = pm.sample(5000, tune=1000)
az.plot_trace(trace)
plt.show()
az.plot_autocorr(trace)
plt.show()
az.to_netcdf(trace, getpath('tracepath') + tracename)
pm.summary(trace)
return trace
def az_v_theta_plot(stan_fit):
"""
Function to demonstrate pystan theta convergence result through R_hat table, autocorrelation (3 chians), and trace plot
"""
az.plot_trace(stan_fit, var_names=['v', 'theta'], filter_vars="like")
print(stan_fit.stansummary())
az.plot_autocorr(stan_fit, var_names=["v", 'theta'])
az.plot_pair(stan_fit, var_names=["v", 'theta'], divergences=True)
def az_v_sigma2_plot(stan_fit, var_list=['v', 'sigma2']):
"""
Function to demonstrate pystan v convergence result through R_hat table, autocorrelation (3 chians), and trace plot
"""
# print(az.summary(stan_fit, var_names=["v","sigma2",'W'], filter_vars="like"))
print(az.summary(stan_fit, var_names=var_list + ['W']))
# az.plot_trace(stan_fit, var_names=['v','sigma2'], filter_vars="like")
az.plot_trace(stan_fit, var_names=var_list)
az.plot_autocorr(stan_fit, var_names=var_list)
az.plot_pair(stan_fit, var_names=var_list, divergences=True)
def create_diagnostic_plots(idx,pdf_filename,fit,diag_pars,niter,nchain):
# Converting the Stan FIT object to Arviz InfereceData
samples = fit.extract(permuted=True) # Extracting parameter samples
data = az.from_pystan(fit)
tmp = data.posterior
var_names = list(tmp.data_vars)
# Filtering the list of parameters to plot
unwanted = {'losvd','spec','conv_spec','poly','bestfit','losvd_','losvd_mod','spec_pred','log_likelihood'}
vars_main = [e for e in var_names if e not in unwanted]
# Reading diagnostic parameters
accept_stat, stepsize, treedepth = np.zeros((niter,nchain)), np.zeros((niter,nchain)) , np.zeros((niter,nchain))
n_leapfrog, divergent, energy = np.zeros((niter,nchain)), np.zeros((niter,nchain)) , np.zeros((niter,nchain))
for j in range(nchain):
accept_stat[:,j] = diag_pars[j]['accept_stat__']
stepsize[:,j] = diag_pars[j]['stepsize__']
treedepth[:,j] = diag_pars[j]['treedepth__']
n_leapfrog[:,j] = diag_pars[j]['n_leapfrog__']
divergent[:,j] = diag_pars[j]['divergent__']
energy[:,j] = diag_pars[j]['energy__']
# Creating the plot in multiple PDF papges
pdf_pages = PdfPages(pdf_filename)
print(" - Sampler params")
plot_sampler_params(idx,accept_stat,stepsize,treedepth,n_leapfrog,divergent,energy)
pdf_pages.savefig()
print(" - Chains")
plot_chains(samples,vars_main)
pdf_pages.savefig()
# print(" - Trace plot [Main params]")
# az.plot_trace(data, var_names=vars_main)
# pdf_pages.savefig()
# print(" - Trace plot [LOSVD]")
# az.plot_trace(data, var_names=['losvd'])
# pdf_pages.savefig()
print(" - Pair plot")
az.plot_pair(data, var_names=vars_main, divergences=True, kind='kde', fill_last=False)
pdf_pages.savefig()
print(" - Autocorr plot")
az.plot_autocorr(data, var_names=vars_main)
pdf_pages.savefig()
print(" - Energy plot")
az.plot_energy(data)
pdf_pages.savefig()
pdf_pages.close()
return
def efficient_autocorr(trace, var_names, figstem, max_panel=6):
"""
Wrap the arviz call for correlation to speed things up by splitting into smaller figures bundled as a scrollable PDF.
"""
N = len(var_names)
n = 0
i = 0
while n <= N:
plot_vars = var_names[n : n + max_panel]
az.plot_autocorr(trace, var_names=plot_vars)
plt.savefig(figstem.format(i))
plt.close("all")
n += max_panel
i += 1
def plot_autocorr(trace, title):
"""Generate an autocorr plot with Arviz"""
axs = az.plot_autocorr(trace, max_lag=20)
fig = plt.gcf()
fig.suptitle(title, fontsize=16)
# ax0, ax1 = axs[0,0], axs[0,1]
return axs
def plot_param_diagnostics(mod,
incl_noise_params=False,
incl_trend_params=False,
incl_smooth_params=False,
which='trace',
**kwargs):
"""
Parameters
-----------
mod : orbit model object
which : str, {'density', 'trace', 'pair', 'autocorr', 'posterior', 'forest'}
incl_noise_params : bool
if plot noise parameters; default False
incl_trend_params : bool
if plot trend parameters; default False
incl_smooth_params : bool
if plot smoothing parameters; default False
**kwargs :
other parameters passed to arviz functions
Returns
-------
matplotlib axes object
"""
posterior_samples = get_arviz_plot_dict(
mod,
incl_noise_params=incl_noise_params,
incl_trend_params=incl_trend_params,
incl_smooth_params=incl_smooth_params)
if which == "trace":
axes = az.plot_trace(posterior_samples, **kwargs)
elif which == "density":
axes = az.plot_density(posterior_samples, **kwargs)
elif which == "posterior":
axes = az.plot_posterior(posterior_samples, **kwargs)
elif which == "pair":
axes = az.plot_pair(posterior_samples, **kwargs)
elif which == "autocorr":
axes = az.plot_autocorr(posterior_samples, **kwargs)
elif which == "forest":
axes = az.plot_forest(posterior_samples, **kwargs)
else:
raise Exception(
"please use one of 'trace', 'density', 'posterior', 'pair', 'autocorr', 'forest' for kind."
)
return axes
def mcmc_diagnostic_plots(posterior, sample_stats, it):
az_trace = az.from_dict(posterior=posterior, sample_stats=sample_stats)
"""
# 2 parameters or more for these pair plots
if len(az_trace.posterior.data_vars) > 1:
ax = az.plot_pair(az_trace, kind="hexbin", gridsize=30, marginals=True)
fig = ax.ravel()[0].figure
plt.ylim((5000, 30000))
plt.xlim((1e-10, 1e-7))
fig.savefig(f"./results/pair_plot_it{it}.png")
plt.clf()
ax = az.plot_pair(
az_trace,
kind=["scatter", "kde"],
kde_kwargs={"fill_last": False},
point_estimate="mean",
marginals=True,
)
fig = ax.ravel()[0].figure
fig.savefig(f"./results/point_estimate_plot_it{it}.png")
plt.clf()
"""
ax = az.plot_trace(az_trace, divergences=False)
fig = ax.ravel()[0].figure
fig.savefig(f"./results/trace_plot_it{it}.png")
plt.clf()
ax = az.plot_posterior(az_trace)
fig = ax.ravel()[0].figure
fig.savefig(f"./results/posterior_plot_it{it}.png")
plt.clf()
lag = np.minimum(len(list(posterior.values())[0]), 100)
ax = az.plot_autocorr(az_trace, max_lag=lag)
fig = ax.ravel()[0].figure
fig.savefig(f"./results/autocorr_plot_it{it}.png")
plt.clf()
ax = az.plot_ess(az_trace, kind="evolution")
fig = ax.ravel()[0].figure
fig.savefig(f"./results/ess_evolution_plot_it{it}.png")
plt.clf()
plt.close()
def plot_auto_corr(self, **kwargs):
"""Plot the autocorrelation function of each posterior parameter."""
return az.plot_autocorr(self.data, **kwargs)
os.makedirs(plotdir)
trace = pm.load_trace(directory="chains/close/rv", model=m.model)
# view summary
df = az.summary(trace, var_names=m.all_vars)
print(df)
# write summary to disk
f = open(f"{plotdir}summary.txt", "w")
df.to_string(f)
f.close()
with az.rc_context(rc={"plot.max_subplots": 60}):
# autocorrelation
az.plot_autocorr(trace, var_names=m.sample_vars)
plt.savefig(f"{plotdir}autocorr.png")
# make a traceplot
az.plot_trace(trace, var_names=m.all_vars)
plt.savefig(f"{plotdir}trace.png")
# make a nice corner plot of the variables we care about
samples = pm.trace_to_dataframe(
trace,
varnames=[
"P",
"KAa",
"KAb",
"e",
"gamma",
The following figure shows examples of problematic samples:
<center><img src="../img/pathological_traces.png" width=600></center>
On the first row we see that the MCMC chains has large autocorrelation, you can see the trace (left column) shows long regions of monoticity (the lines parallel to the x-axis). This could be a consequence of a multimodal posterior with barrier between modes of very low probability. Thus the samples has trouble to freely move from mode to mode. Another explanation could be high correlation between parameters, this can also be problematic for some samplers specially Metropolis. In such cases the multimodality could be _apparent_ and not a real feature of our posterior.
On the second row we see two chains that started from two very different position and eventually converge to the same distribution. The first $\approx$ 25 samples could bias our results so we can just remove them (*burn-in*).
ON the last row, we see two chains exploring two different regions of the parameter space. From the trace it seems they are in fact approaching each other at a slow rate and the maybe eventually reach the same stationary distribution.
## Autocorrelation plot
<br>
az.plot_autocorr()
As we discussed in the Numerical Diagnostics section, we can see autocorrelation as a factor that decrease the actual amount of information contained in a sample. So we want to reduce autocorrelation as much as possible.
bad_chains = np.linspace(0, 1, 1000).reshape(2, -1)
az.plot_autocorr(bad_chains)
The autocorrelation plot shows the _degree of autocorrelation_ by default it used a maximum window of 100. The previous figure, corresponding to `bad_chains` show a very high autocorrelation while the next figure corresponding to `good_chains` show a very low autocorrelation.
good_chains = stats.uniform.rvs(0, 1, size=(2, 500))
az.plot_autocorr(good_chains)
## Rank plot
<br>
np.random.seed(0)
with Centered_eight:
trace_centered = pm.sample(1000, chains=4)
print(pm.summary(trace_centered).round(2))
# Effective sample size is << 4*1000, especially for tau
# Also, PyMC3 gives various warnings about not mixing
# Display the total number and percentage of divergent chains
diverging = trace_centered['diverging']
print('Number of Divergent Chains: {}'.format(diverging.nonzero()[0].size))
diverging_pct = diverging.nonzero()[0].size / len(trace_centered) * 100
print('Percentage of Divergent Chains: {:.1f}'.format(diverging_pct))
az.plot_autocorr(trace_centered, var_names=['mu', 'tau'])
az.plot_forest(trace_centered, var_names="theta", credible_interval=0.95)
# Non-Centered model
with pm.Model() as NonCentered_eight:
mu = pm.Normal('mu', mu=0, sigma=10)
tau = pm.HalfCauchy('tau', beta=5)
theta_offset = pm.Normal('theta_offset', mu=0, sigma=1, shape=J)
theta = pm.Deterministic('theta', mu + tau * theta_offset)
#theta = pm.Normal('theta', mu=mu, sigma=tau, shape=J)
obs = pm.Normal('obs', mu=theta, sigma=sigma, observed=y)
np.random.seed(0)
with NonCentered_eight:
def autocorr_plot(self, chain_id, **kwargs):
return az.plot_autocorr(self.chains, var_names=chain_id, **kwargs)
alpha = pm.Uniform('alpha', 0, 5)
log_sigma = pm.Uniform('log_sigma', -10, 10)
mu = alpha
y_obs = pm.Normal('y_obs', mu=mu, sigma=np.exp(log_sigma), observed=d['kcal.per.g'])
pm.find_MAP(model=m6_11, method='BFGS')
with m6_11:
trace = pm.sample(2000, return_inferencedata=True, chains=2)
pm.summary(trace)
az.summary(trace)
#pm.gelman_rubin(trace)
with m6_11:
az.plot_trace(trace)
plt.show()
az.plot_autocorr(trace)
plt.show()
az.plot_density(trace)
plt.show()
az.plot_forest(trace)
plt.show()
# might need to multiply by -2 to compare with McElreath
with m6_11:
print(pm.waic(trace))
print(pm.loo(trace))
#m6_13 = pm.Model()
with pm.Model() as m6_13:
alpha = pm.Uniform('alpha', 0, 5)
az.summary(trace.posterior['intercept'])
pm.traceplot(trace)
plt.show()
az.plot_trace(trace)
az.plot_trace(trace, var_names=['intercept'])
plt.show()
az.plot_trace(trace, var_names=['sigma'])
plt.show()
az.plot_forest(trace, r_hat=True)
plt.show()
az.plot_posterior(trace)
plt.show()
az.plot_energy(trace)
plt.show()
az.plot_autocorr(trace, var_names=["intercept", "sigma"])
plt.show()
# map() by hand
def negPost(x, *args):
y = args[0]
p = -1 * sum(norm.logpdf(y, x[0], x[1]))[0] + norm.logpdf(
x[0], 178, 20) + uniform.logpdf(x[1], 0, 50)
return p
negPost((178, 3), d2)
secondDerivPost = nd.Derivative(negPost, n=2, full_output=True)
modePost1 = minimize(negPost,
for pi in range(len(paraname)):
plt.subplot(3, 1, pi+1)
plt.tight_layout()
[plt.plot(iter_range + 1, ms[iter_range,ci,pi], color=palette[ci]) for ci in range(ms.shape[1])]
plt.title(paraname[pi])
plt.show()
#
for pi in range(len(paraname)):
plt.subplot(3, 1, pi+1)
plt.tight_layout()
[sns.kdeplot(ms[iter_range,ci,pi], color=palette[ci]) for ci in range(ms.shape[1])]
plt.title(paraname[pi])
plt.show()
mcmc_result.plot()
plt.show()
# using arviz instead of bayesplot
#az.plot_density(data=mcmc_result, var_names=['mu']);
az.plot_trace(data=mcmc_result)
plt.show()
az.plot_forest(data=mcmc_result, kind='ridgeplot', combined=True)
plt.show()
az.plot_autocorr(data=mcmc_result)
plt.show()
az.plot_trace(trace_cm, var_names=['a'], divergences='top')
# %%
az.plot_trace(trace_ncm, var_names=['a'])
# %%
az.plot_forest(trace_cm, var_names=['a'], r_hat=True, ess=True)
# %%
summaries = pd.concat([az.summary(trace_cm, var_names=['a']), az.summary(trace_ncm, var_names=['a'])])
summaries.index = ['centered', 'non_centered']
summaries
# %%
az.plot_autocorr(trace_cm, var_names=['a'])
# %%
az.plot_autocorr(trace_ncm, var_names=['a'])
# %%
_, ax = plt.subplots(1, 2, sharey=True, sharex=True, figsize=(10, 5), constrained_layout=True)
for idx, tr in enumerate([trace_cm, trace_ncm]):
az.plot_pair(tr, var_names=['b', 'a'], coords={'b_dim_0':[0]}, kind='scatter',
divergences=True, contour=False, divergences_kwargs={'color':'C1'},
ax=ax[idx])
ax[idx].set_title(['centered', 'non-centered'][idx])
# %%
az.plot_parallel(trace_cm)
"""
Autocorrelation Plot
====================
_thumb: .8, .8
"""
import arviz as az
data = az.load_arviz_data("centered_eight")
ax = az.plot_autocorr(data, var_names="tau", backend="bokeh", show=True)
beta_eff[i] = get_beta_eff(i, beta_start, beta_end, k, 90)
plt.plot(np.arange(0, 180), beta_eff)
plt.xlabel('Time (days)')
plt.ylabel('Beta (effective)')
plt.savefig('../results/plots/beta_over_time.pdf')
plt.clf()
"""
seir.plot_incidence()
plt.plot(np.arange(0,180),daily_cases.newcountconfirmed[20:200],label='observed')
plt.legend()
plt.tight_layout()
plt.savefig('../results/plots/model_fit.pdf')
"""
inference_data = az.from_cmdstan('../results/outputs/*.csv')
az.plot_trace(inference_data)
plt.savefig('../results/plots/model_trace.pdf')
az.plot_joint(inference_data,
var_names=['beta_start', 'beta_end'],
kind='kde',
figsize=(6, 6))
plt.tight_layout()
plt.savefig('../results/plots/model_joint_betas.pdf')
az.plot_posterior(inference_data)
plt.savefig('../results/plots/model_posterior.pdf')
az.plot_autocorr(inference_data, combined=True)
plt.savefig('../results/plots/model_autocorrelation.pdf')
az.plot_rank(inference_data)
plt.savefig('../results/plots/model_rank.pdf')
"""
Autocorrelation Plot
====================
_thumb: .8, .8
"""
import matplotlib.pyplot as plt
import arviz as az
az.style.use("arviz-darkgrid")
data = az.load_arviz_data("centered_eight")
az.plot_autocorr(data, var_names=("tau", "mu"))
plt.show()
np.random.seed(0)
with Centered_eight:
trace_centered = pm.sample(1000, chains=4)
pm.summary(trace_centered).round(2)
# Effective sample size is << 4*1000, especially for tau
# Also, PyMC3 gives various warnings about not mixing
# Display the total number and percentage of divergent chains
diverging = trace_centered['diverging']
print('Number of Divergent Chains: {}'.format(diverging.nonzero()[0].size))
diverging_pct = diverging.nonzero()[0].size / len(trace_centered) * 100
print('Percentage of Divergent Chains: {:.1f}'.format(diverging_pct))
az.plot_autocorr(trace_centered, var_names=['mu_alpha', 'sigma_alpha']);
az.plot_forest(trace_centered, var_names="alpha", credible_interval=0.95);
# Non-Centered model
with pm.Model() as NonCentered_eight:
mu_alpha = pm.Normal('mu_alpha', mu=0, sigma=5)
sigma_alpha = pm.HalfCauchy('sigma_alpha', beta=5)
alpha_offset = pm.Normal('alpha_offset', mu=0, sigma=1, shape=J)
alpha = pm.Deterministic('alpha', mu_alpha + sigma_alpha * alpha_offset)
#alpha = pm.Normal('alpha', mu=mu_alpha, sigma=sigma_alpha, shape=J)
obs = pm.Normal('obs', mu=alpha, sigma=sigma, observed=y)
marginal_kwargs=kde_kwargs,
textsize=20,
figsize=(24, 18),
point_estimate="median",
kind=['scatter', 'kde'])
az.plot_pair(data,
var_names=['b', 'mu'],
marginals=True,
marginal_kwargs=kde_kwargs,
textsize=20,
figsize=(24, 18),
point_estimate="median",
kind=['scatter', 'kde'])
az.plot_autocorr(data, var_names=('kv', 'k0', 'kf', 'k2', 'b', 'mu', 'phif'))
# Load in permuted traces from PyStan run
predictive_df = pd.read_csv('stanwound_fit_predictive_permuted.csv')
stress_mean_predicted_phif_4 = np.empty([0, 3])
stress_mean_predicted_phif_20 = np.empty([0, 3])
stress_mean_predicted_phif_40 = np.empty([0, 3])
stress_mean_predicted_phif_RS = np.empty([0, 3])
stress_predicted_phif_4 = np.empty([0, 3])
stress_predicted_phif_20 = np.empty([0, 3])
stress_predicted_phif_40 = np.empty([0, 3])
stress_predicted_phif_RS = np.empty([0, 3])
von_mises_prob_mean_predicted_phif_4 = np.empty([0, 3])
von_mises_prob_mean_predicted_phif_20 = np.empty([0, 3])
von_mises_prob_mean_predicted_phif_40 = np.empty([0, 3])
von_mises_prob_mean_predicted_phif_RS = np.empty([0, 3])
def conduct_bayesian_norm(xj,
zj,
nj,
mu_init,
beta_init,
draws,
target_accept,
plot_flag=True):
"""
A function to conduct Bayesian updating of fragility models.
(Optional): Produce MCMC-related plots (trace). Default: True
Notes:
Here intensity measure is the wind speed: A normalizing factor (max wind speed) is used to improve
numerical stability.
Prior distributions are designated according to the assumption that the Bayesian analysis will utilize
wind fragility functions from HAZUS (see priors for mu and beta). See De Brujin et al. (2020) for more details.
De Bruijn J. et al. (2020). "Using rapid damage observations from social media for Bayesian updating of hurricane
vulnerability functions: A case study of Hurricane Dorian." Nat.Hazards Earth Syst. Sci. Discuss. [preprint],
https://doi.org/10.5194/nhess-2020-282.
The likelihood function is modeled using a Binomial distribution see Lallemant et al. (2015) for more details.
:param xj: An array or list of observed intensity measure values for the damage measure.
:param zj: An array or list of failure observations (number of failed buildings/components) for the given damage
and intensity measure.
:param nj: An array or list of the total # of buildings for the given damage measure and intensity measure
:param mu_init: The mean value of the prior distribution for the logarithmic mean.
:param beta_init: The mean value of the prior distribution for the logarithmic std. dev.
:param num_samples: (Optional) The number of samples to conduct MCMC.
:param plot_flag: (Optional) Produce the trace plot for the MCMC and updated distributions for parameters.
:return: updated_values: A dictionary with each parameter's updated mean and standard deviation.
"""
# Step 1: Normalize the intensity measure:
norm_analysis = True
if norm_analysis:
norm_factor = max(xj)
xj = xj / norm_factor
mu_init = mu_init / norm_factor
mu_std_dev = 15 / norm_factor
#nj = nj/15
#zj = zj/15
#beta_init = beta_init/norm_factor
#beta_std_dev = 0.03/norm_factor
else:
mu_std_dev = 15
beta_std_dev = 0.03
# Step 2: Build the Bayesian model in PyMC3:
with pm.Model() as model:
# Step 3a: Set up the prior
# Here we assume Normal distributions for both parameters of the fragility
# Note: Parameters for mu are also normalized for compatibility with intensity measure values.
# See De Brujin et al. for more information regarding the initialization of prior distributions.
#mu = pm.Normal('mu', mu_init/norm_factor, 15/norm_factor)
BoundedNormal = pm.Bound(pm.Normal, lower=0.0)
#x = BoundedNormal('x', mu=1.0, sigma=3.0)
theta1 = BoundedNormal('theta1', mu_init, mu_std_dev)
theta2 = BoundedNormal('theta2', beta_init, beta_std_dev)
# Step 3b: Set up the likelihood function:
# The likelihood in this model is represented via a Binomial distribution.
# See Lallemant et al. (2015) for MLE derivation.
# Define fragility function equation:
def normal_cdf(theta1, theta2, xj):
"""Compute the log of the cumulative density function of the normal."""
return 0.5 * (1 + tt.erf(
(tt.log(xj / theta1)) / (theta2 * tt.sqrt(2))))
# Define the likelihood:
like = pm.Binomial('like',
p=normal_cdf(theta1, theta2, xj),
observed=zj,
n=nj)
# Uncomment to do an initial check of parameter values (lookout for like = +/-inf)
#for RV in model.basic_RVs:
# print(RV.name, RV.logp(model.test_point))
# Step 3c: Determine the posterior
# Note: can manually change number of cores if more computational power is available.
trace_idata = pm.sample(draws,
cores=1,
return_inferencedata=True,
random_seed=72,
target_accept=target_accept)
#trace = pm.sample(8000, cores=1, return_inferencedata=True, tune=2000, random_seed=52) #tune=2000
# (Optional): Plotting the trace and updated distributions for parameters:
if plot_flag:
from matplotlib import rcParams
rcParams['font.family'] = "Times New Roman"
rcParams.update({'font.size': 16})
az.plot_trace(trace_idata, chain_prop={'color': ['blue', 'red']})
# Plot the autocorrelation to check convergence:
ax_corr = az.plot_autocorr(trace_idata, combined=True)
ax_corr[0].set_title(r'$\theta_1$')
ax_corr[1].set_title(r'$\theta_2$')
ax_corr[0].set_ylabel('Autocorrelation')
ax_corr[0].set_xlabel('Lag')
ax_corr[1].set_xlabel('Lag')
# Step 4: Generate summary statistics for the MCMC:
print('Summary statistics for the MCMC:')
print(az.summary(
trace_idata)) # Note: can output this DataFrame if needed
df = az.summary(trace_idata, hdi_prob=0.95)
# Step 5: Sample from the posterior and save updated values for mean and std. dev:
ppc = pm.sample_posterior_predictive(
trace_idata, var_names=['theta1', 'theta2', 'like'])
# Re-scale values for logarithmic mean:
if norm_analysis:
df['mean']['theta1'] = df['mean']['theta1'] * norm_factor
df['sd']['theta1'] = df['sd']['theta1'] * norm_factor
ppc['theta1'] = ppc['theta1'] * norm_factor
else:
pass
# Export analysis results:
summary_dict = {}
for row in df.index:
for col in df.columns:
new_key = row + col
if 'hdi' in new_key and 'theta1' in new_key and norm_analysis:
new_val = df[col][row] * norm_factor
else:
new_val = df[col][row]
summary_dict[new_key] = new_val
# Export MCMC details:
mcmc_dict = {'draws': draws, 'target_accept': target_accept}
for key in mcmc_dict:
summary_dict[key] = mcmc_dict[key]
df_summary = pd.DataFrame(summary_dict, index=[0], dtype='object')
# Sample directly from the posterior to create figures:
updated_values = {
'theta1': {
'mean': ppc['theta1'].mean(),
'std dev': np.std(ppc['theta1'])
},
'theta2': {
'mean': ppc['theta2'].mean(),
'std dev': np.std(ppc['theta2'])
}
}
if plot_flag:
# Plot prior and updated distributions for parameters:
# mu
fig, ax = plt.subplots()
ax.hist(ppc['theta1'] / 2.237,
bins=25,
density=True,
alpha=0.4,
color='cornflowerblue',
label='posterior samples')
ax.set_xlim(50 / 2.237, 200 / 2.237)
xmin, xmax = ax.set_xlim()
x = np.linspace(xmin, xmax, 100)
if norm_analysis:
p_prior = norm.pdf(x, mu_init * norm_factor / 2.237,
mu_std_dev * norm_factor / 2.237)
else:
p_prior = norm.pdf(x, mu_init / 2.237, mu_std_dev / 2.237)
p_new = norm.pdf(x, updated_values['theta1']['mean'] / 2.237,
updated_values['theta1']['std dev'] / 2.237)
ax.plot(x, p_prior, 'k', linewidth=2, label='prior')
ax.plot(x,
p_new,
'r',
linewidth=2,
label='updated',
linestyle='dashed')
ax.set_title('Prior and updated distributions for ' +
r'$\theta_1$')
ax.set_xlabel(r'$\theta_1$')
ax.set_ylabel('Probability')
ax.legend()
plt.show()
# beta
fig2, ax2 = plt.subplots()
ax2.hist(ppc['theta2'],
bins=25,
density=True,
alpha=0.4,
color='cornflowerblue',
label='posterior samples')
ax2.set_xlim(0, 0.3)
xmin2, xmax2 = ax2.set_xlim()
x2 = np.linspace(xmin2, xmax2, 100)
p_prior2 = norm.pdf(x2, beta_init, 0.03)
p_new2 = norm.pdf(x2, updated_values['theta2']['mean'],
updated_values['theta2']['std dev'])
ax2.plot(x2, p_prior2, 'k', linewidth=2, label='prior')
ax2.plot(x2,
p_new2,
'r',
linewidth=2,
label='updated',
linestyle='dashed')
ax2.set_title('Prior and updated distributions for ' +
r'$\theta_2$')
ax2.set_xlabel(r'$\theta_2$')
ax2.set_ylabel('Probability')
ax2.legend()
plt.show()
# Create forestplots:
# ax_forest = az.plot_forest(trace_idata.posterior['theta1']*norm_factor/2.237, hdi_prob=0.95, combined=True, var_names=['theta1'])
# ax_forest[0].set_xlim(45, 75)
# plt.show()
# ax_forest2 = az.plot_forest(trace_idata, hdi_prob=0.95, combined=True,
# var_names=['theta2'])
# ax_forest2[0].set_xlim(0, 0.5)
# plt.show()
# Calculate failure probabilities for prior, updated:
im = np.arange(70, 200, 2)
# Mean of simulation-based fragility:
if norm_analysis:
pf_sim = pf(im, mu_init * norm_factor, beta_init)
else:
pf_sim = pf(im, mu_init, beta_init)
# Mean of updated fragility:
pf_mean = pf(im, ppc['theta1'].mean(), ppc['theta2'].mean())
# Calculate entire distribution of pfs using posterior samples:
pf_ppc = []
for i in range(0, len(ppc['theta1'])):
y = pf(im, ppc['theta1'][i], ppc['theta2'][i])
pf_ppc.append(y)
# Plot the credible intervals, mean outcome of prediction, mean of simulation-based:
fig3, ax3 = plt.subplots()
ax3.set_clip_on(False)
ax3.set_ylim(0, 1.2)
ax3.spines['right'].set_visible(False)
ax3.spines['top'].set_visible(False)
az.plot_hdi(im / 2.237,
pf_ppc,
hdi_prob=0.95,
fill_kwargs={
'alpha': 0.1,
'color': 'paleturquoise',
'label': '95% credible interval'
})
ax3.plot(im / 2.237,
pf_mean,
label='mean of prediction',
color='r',
linestyle='dashed')
ax3.plot(im / 2.237,
pf_sim,
label='mean of simulation-based',
color='k')
# Plot the observations:
if norm_analysis:
ax3.scatter(xj * norm_factor / 2.237,
zj / nj,
color='darkviolet',
label='observations',
zorder=5,
s=70)
else:
ax3.scatter(xj / 2.237,
zj / nj,
color='darkviolet',
label='observations',
zorder=5,
s=70)
ax3.set_xlabel('Wind Speed [m/s]')
ax3.set_ylabel('Probability of Failure')
ax3.legend()
plt.show()
return df_summary
# ==> 10 independently drawn, joint samples at `index_points`.
# ==> 10 independently drawn, noisy joint samples at `index_points`
t2 = time.perf_counter()
print()
(observations_.numpy()[0] - X1)
acf = tfp.stats.auto_correlation(
amplitudes, axis=-1, max_lags=None, center=True, normalize=True,
name='auto_correlation'
)
var1 = np.array([amplitudes,
length_scales,
observation_noise_variances])
az.plot_autocorr(var1)
'''
, var_names=("amplitudes",
"length_scales",
"observation_noise_variances"))'''
numElems = len(Y)
sample = samples[0] + mean_fn(observation_index_points[:,0], r.t2bv(10**(observation_index_points[:,1])), a ,b ,c ,d)
idx = np.round(np.linspace(0, len(np.array(sample).reshape(numElems**2)) - 1, numElems)).astype(int)
# Picks equal spaced elements from (longer) prediction array so that its shape of data
mu_test = (np.array(sample).reshape(numElems**2)[idx])
sd_test = (np.array(var).reshape(numElems**2)[idx])
vals = np.sort([mu_test, sd_test], axis=1)
"""
Autocorrelation Plot
====================
_thumb: .8, .8
"""
import arviz as az
az.style.use('arviz-darkgrid')
data = az.load_arviz_data('centered_eight')
az.plot_autocorr(data, var_names=('tau', 'mu'))
def chain_validate_arviz(inferred, variables):
for var in variables:
az.plot_autocorr(inferred, var_names=[var])
