def make_plot(trace):
plot_training_data()
# plot logistic curve
theta = trace['θ'].mean(axis=0)
idx = np.argsort(x_c)
plt.plot(x_c[idx], theta[idx], color='C2', lw=3)
az.plot_hpd(x_c, trace['θ'], color='C2')
# plot decision boundary
plt.vlines(trace['bd'].mean(), 0, 1, color='k')
bd_hpd = az.hpd(trace['bd'])
plt.fill_betweenx([0, 1], bd_hpd[0], bd_hpd[1], color='k', alpha=0.5)
def plot_polynomial_regressions(d1,
trace_1,
xcol,
ycol,
degree=1,
credible_interval=.95,
plot_name='hpd',
ax=None):
yval = d1[ycol].values
# Polynomial features
polynomial_features = PolynomialFeatures(degree=degree, include_bias=False)
xval = polynomial_features.fit_transform(d1[xcol].values.reshape(-1, 1))
if plot_name == 'hpd':
if ax == None:
fig, ax = plt.subplots(figsize=(6, 6))
mu_mean = trace_1['mu']
ax.scatter(xval[:, 0], yval)
sorted_xval = np.argsort(xval[:, 0])
ax.plot(xval[sorted_xval, 0], mu_mean.mean(0)[sorted_xval], 'C1')
xseq = np.linspace(np.min(xval[:, 0]), np.max(xval[:, 0]), 50)
xplot = polynomial_features.fit_transform(xseq.reshape(-1, 1)).T
mu_pred = trace_1['a'].reshape(-1, 1) + np.dot(trace_1['b'], xplot)
ax.plot(xseq, mu_pred.mean(0), 'k.')
az.plot_hpd(xseq,
mu_pred,
fill_kwargs={'alpha': 0},
plot_kwargs={
'alpha': 1,
'color': 'k',
'ls': '--'
},
ax=ax,
credible_interval=credible_interval)
ax.set_xlabel(xcol)
ax.set_ylabel(ycol)
ax.set_title('Polynomial fit with degree=%d' % degree)
# get the mean of the parameters
alpha_m = trace["alpha"].mean()
beta_m = trace["beta"].mean()
# take some draws from the posterior of parameters
draws = range(0,len(trace["alpha"]),10)
ax.plot(x,trace["alpha"][draws] + trace["beta"][draws] * x[:,np.newaxis], c = "gray", alpha = 0.5)
ax.plot(x, alpha_m + beta_m * x, c = "k",label=f'y = {alpha_m:.2f} + {beta_m:.2f} * x')
ax.set_xlabel("x")
ax.set_ylabel("y",rotation = 0)
plt.legend()
plt.show()
# plot 2
fig, ax = plt.subplots(figsize = (8,4))
ax.scatter(x,y)
ax.plot(x, alpha_m + beta_m * x, c = "k",label=f'y = {alpha_m:.2f} + {beta_m:.2f} * x')
az.plot_hpd(x,trace["mu"],credible_interval = 0.98,color = "k")
ax.set_xlabel("x")
ax.set_ylabel("y",rotation = 0)
plt.legend()
plt.show()
# plot 3
# get the y from the posterior distribution
ppc = pm.sample_posterior_predictive(trace,samples = 2000,model = linear_model)
plt.figure()
plt.plot(x,y,"b.")
plt.plot(x,alpha_m + beta_m * x,c = "k",label=f'y = {alpha_m:.2f} + {beta_m:.2f} * x')
az.plot_hpd(x,ppc["obs"],credible_interval = 0.5, color = "gray")
az.plot_hpd(x,ppc["obs"],color = "gray")
plt.xlabel("x")
plt.ylabel("y")
plt.show()
"""
Plot HPD
====================
_thumb: .8, .8
"""
import matplotlib.pyplot as plt
import numpy as np
import arviz as az
az.style.use('arviz-darkgrid')
x_data = np.random.normal(0, 1, 100)
y_data = 2 + x_data * 0.5
y_data_rep = np.random.normal(y_data, 0.5, (200, 100))
plt.plot(x_data, y_data, 'C6')
az.plot_hpd(x_data, y_data_rep, color='k', plot_kwargs={'ls': '--'})
m_5_1_trace["bA"].shape
# %%
age_std_seq = np.linspace(-3, 3.2, 30)
m_5_1_trace = m_5_1_trace[::10]
mu_pred = np.zeros((len(age_std_seq), len(m_5_1_trace) * m_5_1_trace.nchains))
for i, age_std in enumerate(age_std_seq):
mu_pred[i] = m_5_1_trace["a"] + m_5_1_trace["bA"] * age_std
# %%
mu_mean = mu_pred.mean(axis=1)
plt.plot(age_std_seq, mu_mean)
ax = az.plot_hpd(age_std_seq, mu_pred.T)
ax.set_xlabel("Median age marriage")
ax.set_ylabel("Divorce rate")
# %%
with pm.Model() as m_5_2:
a = pm.Normal("a", 0, 0.2)
bM = pm.Normal("bM", 0, 0.5)
sigma = pm.Exponential("sigma", 1)
mu = pm.Deterministic("mu", a + bM * data["Marriage_std"])
divorce_rate_std = pm.Normal("divorce_rate_std",
mu=mu,
sigma=sigma,
observed=data["Divorce_std"].values)
prior_samples = pm.sample_prior_predictive()
with model_rlg:
log.info("The summary on the trace is as follows: %s",
az.summary(trace, var_names=["alpha", "beta", "db", "pie"]))
az.plot_trace(trace, var_names=["alpha", "beta", "db", "pie"])
# ------------------- plots ------------------------------------------- #
# get the mean of theta
theta_mean = trace["theta"].mean(0)
# get idx
idx = np.argsort(x_c)
# plot the predicted p of the data
plt.figure()
plt.plot(x_c[idx], theta_mean[idx], color="C2", lw=3)
# set a vertical line at the mean of the decision boundary
plt.vlines(trace["db"].mean(), 0, 1, color="k")
# get the hpd of db
db_hpd = az.hpd(trace["db"])
plt.fill_betweenx([0, 1], db_hpd[0], db_hpd[1], color="k", alpha=0.5)
plt.scatter(x_c,
np.random.normal(y_0, 0.02),
marker='.',
color=[f'C{x}' for x in y_0])
az.plot_hpd(x_c, trace["theta"], color="C2")
plt.xlabel("petal length")
plt.ylabel("theta", rotation=0)
locs, _ = plt.xticks()
plt.xticks(locs, np.round(locs + x_0.mean(), 1))
plt.show()
plt.plot(x, alpha_m + beta_m * x, c='k',
label=f'y = {alpha_m:.2f} + {beta_m:.2f} * x')
plt.xlabel('x')
plt.ylabel('y', rotation=0)
plt.legend()
plt.savefig('B11197_03_05.png', dpi=300)
# In[9]:
plt.plot(x, alpha_m + beta_m * x, c='k',
label=f'y = {alpha_m:.2f} + {beta_m:.2f} * x')
sig = az.plot_hpd(x, trace_g['μ'], credible_interval=0.98, color='k')
plt.xlabel('x')
plt.ylabel('y', rotation=0)
plt.legend()
plt.savefig('B11197_03_06.png', dpi=300)
# In[10]:
ppc = pm.sample_posterior_predictive(trace_g, samples=2000, model=model_g)
# In[11]:
# get the theta and db
theta = pm.Deterministic("theta",
pm.math.sigmoid(alpha + pm.math.dot(x_0, beta)))
db = pm.Deterministic("db",
-alpha / beta[1] - beta[0] / beta[1] * x_0[:, 0])
# specify a likelihood
y_obs = pm.Bernoulli("y_obs", p=theta, observed=y_0)
# inference step
trace = pm.sample(1500, tune=1000)
# --------------------- analyse the posterior -------------------------- #
with log_model:
log.info("the summary of the trace is: %s",
az.summary(trace, var_names=["alpha", "beta"]))
# ---------------------- plot the data with the decision boundary ------------- #
# initialize a figure
plt.figure(figsize=(12, 5))
# get the index to order the independent variable
idx = np.argsort(x_0[:, 0])
# get the mean of the decision boundary to plot
db = trace["db"].mean(0)[idx]
# scatter the true data
plt.scatter(x_0[:, 0], x_0[:, 1], c=[f'C{x}' for x in y_0])
# plot the decision boundary
plt.plot(x_0[:, 0][idx], db, c="k")
# get the hpd
az.plot_hpd(x_0[:, 0], trace["db"], color="k")
plt.show()
# %%
mass_shared.set_value(np.log(mass))
neocortex_shared.set_value(neocortex)
post_pred = pm.sample_posterior_predictive(trace_m6_14, samples=10000, model=m6_14)
# %%
milk_ensemble = pm.sample_posterior_predictive_w(
traces, 10000, models, weights=compare_df.weight.sort_index(ascending=True)
)
# %%
plt.figure(figsize=(8, 6))
plt.plot(neocortex, post_pred["kcal"].mean(0), ls="--", color="k")
az.plot_hpd(
neocortex,
post_pred["kcal"],
fill_kwargs={"alpha": 0},
plot_kwargs={"alpha": 1, "color": "k", "ls": "--"},
)
plt.plot(neocortex, milk_ensemble["kcal"].mean(0), color="C1")
az.plot_hpd(neocortex, milk_ensemble["kcal"])
plt.scatter(d["neocortex"], d["kcal.per.g"], facecolor="None", edgecolors="C0")
plt.ylim(0.3, 1)
plt.xlabel("neocortex")
plt.ylabel("kcal.per.g")
bd = pm.Deterministic('bd', -α / β) # decision boundary
yl = pm.Bernoulli('yl', p=θ, observed=y_0)
trace_0 = pm.sample(1000)
varnames = ['α', 'β', 'bd']
az.summary(trace_0, varnames)
theta = trace_0['θ'].mean(axis=0)
idx = np.argsort(x_c)
plt.figure()
# plot logistic curve
plt.plot(x_c[idx], theta[idx], color='C2', lw=3)
az.plot_hpd(x_c, trace_0['θ'], color='C2')
# plot decision boundary
plt.vlines(trace_0['bd'].mean(), 0, 1, color='k')
bd_hpd = az.hpd(trace_0['bd'])
plt.fill_betweenx([0, 1], bd_hpd[0], bd_hpd[1], color='k', alpha=0.5)
# plot jittered data
plt.scatter(x_c,
np.random.normal(y_0, 0.02),
marker='.',
color=[f'C{x}' for x in y_0])
plt.xlabel(x_n)
plt.ylabel('p(y=1)', rotation=0)
# use original scale for xticks
with pm.Model() as model_simple:
α = pm.Normal('α', mu=0, sd=10)
β = pm.Normal('β', mu=0, sd=10)
μ = α + pm.math.dot(x_c, β)
θ = pm.Deterministic('θ', pm.math.sigmoid(μ))
bd = pm.Deterministic('bd', -α/β)
y_1 = pm.Bernoulli('y_1', p=θ, observed=y_simple)
trace_simple = pm.sample(1000, tune=1000)
#%% this is slow convergence
theta = trace_simple['θ'].mean(axis=0)
idx = np.argsort(x_c)
plt.plot(x_c[idx], theta[idx], color='C2', lw=3)
plt.vlines(trace_simple['bd'].mean(), 0, 1, color='k')
bd_hpd = az.hpd(trace_simple['bd'])
plt.fill_betweenx([0, 1], bd_hpd[0], bd_hpd[1], color='k', alpha=0.5)
plt.scatter(x_c, np.random.normal(y_simple, 0.02),
marker='.', color=[f'C{x}' for x in y_simple])
az.plot_hpd(x_c, trace_simple['θ'], color='C2')
plt.xlabel(x_n)
plt.ylabel('θ', rotation=0)
locs, _ = plt.xticks()
plt.xticks(locs, np.round(locs + x_0.mean(), 1));
#%%
data['age'] = data['age'] / 10
data['age2'] = np.square(data['age'])
with pm.Model() as logistic_model:
pm.glm.GLM.from_formula('outcome ~ age + age2 + job + marital + education + default + housing + loan + contact + month + day_of_week + duration + campaign + pdays + previous + euribor3m', data, family = pm.glm.families.Binomial())
trace = pm.sample(500, tune = 500, init = 'adapt_diag')
az.plot_trace(trace);
loo_list = pm.loo(trace_m5, model=m5, pointwise=True)
pl.plot(waic_list.WAIC_i, marker='.', ls='', color='k');
pl.plot(loo_list.LOO_i, marker='s', ls='', markeredgecolor='r');
dfinal.head()
# Plotting the interaction
% matplotlib inline
_, axs = pl.subplots(ncols=2, figsize=(8,4))
ttls = ['Non-African', 'African']
df_m5 = pm.trace_to_dataframe(trace_m5)
for i, (axi, ttl) in enumerate(zip(axs, ttls)):
axs[i].scatter(dfinal[dfinal.cont_africa==i].rugged_s, dfinal[dfinal.cont_africa==i].log_gdp_s)
m5_μ = link(df_m5.filter(regex=f'{i}', axis=1), x)
m5_μ_mean = m5_μ.mean(axis=0)
m5_ci = pm.hpd(m5_μ, alpha=0.03)
axs[i].plot(rugged_seq, m5_μ_mean, lw=1.5, color='k')
axs[i].set_title(f'{ttl} nations')
axs[i].set_xlabel('ruggedness (standardized)')
axs[i].set_ylabel('log GDP (as prop. of mean)')
#axs[i].fill_between(rugged_seq.flatten(), y1=m5_ci[:, 0], y2=m5_ci[:, 1], alpha=0.5)
az.plot_hpd(rugged_seq, m5_μ, credible_interval=0.97, ax=axs[i], smooth=True)
rugged_seq.shape
df_m5_A0 = pm.trace_to_dataframe(trace_m5).filter(regex='0', axis=1)
m5_μ = link(df_m5_A0, x)
pm.hpd(m5_μ, alpha=0.03).shape
cond = d.condition.unique()
prosoc_l = d.prosoc_left.unique()
for i in range(len(rt)):
tmp = []
if rt[i].size < 2:
continue
for cp in cond:
for pl in prosoc_l:
tmp.append(
np.mean(rt[i][(d.prosoc_left == pl) & d.chose_prosoc == cp]))
pred_mean[i] = tmp
ticks = range(4)
mp = pred_mean.mean(0)
az.plot_hpd(ticks, pred_mean, color="k", smooth=False)
plt.plot(mp, color="k")
plt.xticks(ticks, ("0/0", "1/0", "0/1", "1/1"))
chimps = (d.groupby(["actor", "prosoc_left", "condition"
]).agg("mean")["pulled_left"].values.reshape(7, -1))
for i in range(7):
plt.plot(chimps[i], "C0")
plt.ylim(0, 1.1)
# %%
with pm.Model() as model_10_4:
a = pm.Normal("alpha", 0, 10, shape=len(d.actor.unique()))
bp = pm.Normal("bp", 0, 10)
bpC = pm.Normal("bpC", 0, 10)
p = pm.math.invlogit(a[d.actor.values] +
_, ax = plt.subplots(1, 2, figsize=(12, 6))
ax[0].scatter(islands.lon2, islands.lat, psize, zorder=3)
ax[1].scatter(islands.logpop, islands.total_tools, psize, zorder=3)
for i, itext in enumerate(culture_labels):
ax[0].text(islands.lon2[i] + 1, islands.lat[i] + 1, itext)
ax[1].text(islands.logpop[i] + .1, islands.total_tools[i] - 2.5, itext)
ax[1].plot(log_pop_seq, np.median(lambda_post, axis=0), 'k--')
az.plot_hpd(log_pop_seq,
lambda_post,
fill_kwargs={'alpha': 0},
plot_kwargs={
'color': 'k',
'ls': '--',
'alpha': 1
})
for i in range(10):
for j in np.arange(i + 1, 10):
ax[0].plot((islands.lon2[i], islands.lon2[j]),
(islands.lat[i], islands.lat[j]),
'C1-',
alpha=ρ.iloc[i, j]**2,
lw=4)
ax[1].plot((islands.logpop[i], islands.logpop[j]),
(islands.total_tools[i], islands.total_tools[j]),
'C1-',
alpha=ρ.iloc[i, j]**2,
"""
Plot HPD
========
_thumb: .8, .8
"""
import bokeh.plotting as bkp
import numpy as np
import arviz as az
x_data = np.random.normal(0, 1, 100)
y_data = 2 + x_data * 0.5
y_data_rep = np.random.normal(y_data, 0.5, (200, 100))
x_data_sorted = np.sort(x_data)
ax = az.plot_hpd(x_data, y_data_rep, color="red", backend="bokeh", show=False)
ax.line(x_data_sorted,
2 + x_data_sorted * 0.5,
line_color="black",
line_width=3)
if az.rcParams["plot.bokeh.show"]:
bkp.show(ax)
f_pred = gp.conditional('f_pred', X_new)
pred_samples = pm.sample_posterior_predictive(
trace_iris, vars=[f_pred], samples=1000)
# Plot results
_, ax = plt.subplots(figsize=(10, 6))
fp = logistic(pred_samples['f_pred'])
fp_mean = np.mean(fp, 0)
ax.plot(X_new[:, 0], fp_mean)
# plot the data (with some jitter) and the true latent function
ax.scatter(x_1, np.random.normal(y, 0.02),
marker='.', color=[f'C{x}' for x in y])
az.plot_hpd(X_new[:, 0], fp, color='C2')
db = np.array([find_midpoint(f, X_new[:, 0], 0.5) for f in fp])
db_mean = db.mean()
db_hpd = az.hpd(db)
ax.vlines(db_mean, 0, 1, color='k')
ax.fill_betweenx([0, 1], db_hpd[0], db_hpd[1], color='k', alpha=0.5)
ax.set_xlabel('sepal_length')
ax.set_ylabel('θ', rotation=0)
plt.savefig('../figures/gp_classify_iris1.pdf', dpi=300)
# Change kernel to be sum of SE and linear, to improve tail behavior
with pm.Model() as model_iris2:
#ℓ = pm.HalfCauchy("ℓ", 1)
ℓ = pm.Gamma('ℓ', 2, 0.5)
label = f'y={alpha_m:.2f} + {beta_m:.2f}*x')
plt.xlabel('x', fontsize=15)
plt.ylabel('y', rotation=0, fontsize=15)
plt.legend(fontsize=15)
plt.xticks(fontsize=15)
plt.yticks(fontsize=15)
plt.show()
# In[7]:
plt.plot(x, alpha_m + beta_m * x, c = 'k',
label = f'y={alpha_m:.2f} + {beta_m:.2f}*x')
sig = az.plot_hpd(x, trace_g['μ'], credible_interval=0.98, color='0.5', plot_kwargs={'alpha':0.1})
plt.xlabel('x', fontsize=15)
plt.ylabel('y', rotation=0, fontsize=15)
plt.legend(fontsize=15)
plt.xticks(fontsize=15)
plt.yticks(fontsize=15)
plt.show()
# Another option is to plot the HPD of the posterior predictive.
# In[8]:
ppc = pm.sample_posterior_predictive(trace_g, samples=2000, model=model_g)
for cp in cond:
for pl in prosoc_l:
tmp.append(
np.mean(
rt[i][
(d.prosoc_left[sel_actor].values == pl)
& (d.condition[sel_actor].values == cp)
]
)
)
pred_mean[i] = tmp
mp = pred_mean.mean(0)
_, ax = plt.subplots(1, 1, figsize=(5, 5))
az.plot_hpd(range(4), pred_mean, credible_interval=0.89, color="k")
ax.plot(mp, color="k")
chimps = (
d.groupby(["actor", "prosoc_left", "condition"])
.agg("mean")["pulled_left"]
.values.reshape(7, -1)
)
ax.plot(chimps[chimp], "C0")
ax.set_ylim(0, 1.1)
ax.set_xlabel("prosoc_left/condition")
ax.set_ylabel("proportion pulled left")
plt.xticks(range(4), ("0/0", "1/0", "0/1", "1/1"))
# %%
h = pm.Normal('h', mu=mu, sigma=sigma, observed=kcal_per_g)
trace_neocortex_mass = pm.sample(cores=2)
#%%
# Plots
az.plot_forest([trace_neocortex_mass, trace_log_mass, trace_neocortex],
model_names=['both_br_bl', 'only_br', 'only_bl'],
var_names=['bl', 'br'])
#%%
fig, ax = plt.subplots(nrows=2, ncols=2, figsize=(10, 10))
mu_mean = trace_neocortex['mu']
ax[0, 0].scatter(neocortex_perc, kcal_per_g)
ax[0, 0].plot(neocortex_perc, mu_mean.mean(0), 'C1')
az.plot_hpd(neocortex_perc, mu_mean, ax=ax[0, 0])
mu_mean = trace_log_mass['mu']
ax[0, 1].scatter(log_mass, kcal_per_g)
ax[0, 1].plot(log_mass, mu_mean.mean(0), 'C1')
az.plot_hpd(log_mass, mu_mean, ax=ax[0, 1])
seq = np.linspace(55, 76, 50)
mu_pred = trace_neocortex_mass['a'] + trace_neocortex_mass[
'bl'] * seq[:, None] + trace_neocortex_mass['br'] * log_mass.mean()
ax[1, 0].plot(seq, mu_pred.mean(1), 'k')
az.plot_hpd(seq,
mu_pred.T,
fill_kwargs={'alpha': 0},
plot_kwargs={
'alpha': 1,
β = pm.Normal('β', mu=0, sd=2, shape=len(x_n))
μ = α + pm.math.dot(x_1, β)
θ = pm.Deterministic('θ', 1 / (1 + pm.math.exp(-μ)))
bd = pm.Deterministic('bd', -α / β[1] - β[0] / β[1] * x_1[:, 0])
yl = pm.Bernoulli('yl', p=θ, observed=y_1)
trace_1 = pm.sample(2000)
varnames = ['α', 'β']
#az.plot_forest(trace_1, var_names=varnames);
idx = np.argsort(x_1[:, 0])
bd = trace_1['bd'].mean(0)[idx]
plt.figure()
plt.scatter(x_1[:, 0], x_1[:, 1], c=[f'C{x}' for x in y_1])
plt.plot(x_1[:, 0][idx], bd, color='k')
az.plot_hpd(x_1[:, 0], trace_1['bd'], color='k')
plt.xlabel(x_n[0])
plt.ylabel(x_n[1])
plt.tight_layout()
if unbalanced:
plt.savefig('../figures/logreg_iris_bayes_2d_unbalanced.pdf', dpi=300)
else:
plt.savefig('../figures/logreg_iris_bayes_2d.pdf', dpi=300)
alpha=0.5)
plt.plot(x,
alpha_m + beta_m * x,
c='k',
label=f'y = {alpha_m:.2f} + {beta_m:.2f} * x')
plt.xlabel('x')
plt.ylabel('y', rotation=0)
# v2 - plotting hpd
plt.plot(x,
alpha_m + beta_m * x,
c='k',
label=f'y = {alpha_m:.2f} + {beta_m:.2f} * x')
sig = az.plot_hpd(x, trace_g['mu'], credible_interval=0.98, color='k')
plt.xlabel('x')
plt.ylabel('y', rotation=0)
plt.legend()
# v3 - plotting interval for future data
ppc = pm.sample_posterior_predictive(trace_g, samples=2000, model=model_g)
# way to get r2
az.r2_score(y, ppc['y_pred'])
# In[11]:
plt.plot(x, y, 'b.')
plt.plot(x,
az.summary(trace_0, varnames)
# In[10]:
theta = trace_0['theta'].mean(axis=0)
idx = np.argsort(x_c)
plt.plot(x_c[idx], theta[idx], color='C2', lw=3)
plt.vlines(trace_0['bd'].mean(), 0, 1, color='k')
bd_hpd = az.hpd(trace_0['bd'])
plt.fill_betweenx([0, 1], bd_hpd[0], bd_hpd[1], color='k', alpha=0.5)
plt.scatter(x_c,
np.random.normal(y_0, 0.02),
marker='.',
color=[f'C{x}' for x in y_0])
az.plot_hpd(x_c, trace_0['theta'], color='C2')
plt.xlabel(x_n)
plt.ylabel('theta', rotation=0)
# use original scale for xticks
locs, _ = plt.xticks()
plt.xticks(locs, np.round(locs + x_0.mean(), 1))
plt.savefig('B11197_04_04.png', dpi=300)
# # Multiple logistic regression
# In[11]:
df = iris.query("species == ('setosa', 'versicolor')")
y_1 = pd.Categorical(df['species']).codes
x_n = ['sepal_length', 'sepal_width']
"""
Plot HPD
========
_thumb: .8, .8
"""
import matplotlib.pyplot as plt
import numpy as np
import arviz as az
az.style.use("arviz-darkgrid")
x_data = np.random.normal(0, 1, 100)
y_data = 2 + x_data * 0.5
y_data_rep = np.random.normal(y_data, 0.5, (200, 100))
plt.plot(x_data, y_data, "C6")
az.plot_hpd(x_data, y_data_rep, color="k", plot_kwargs={"ls": "--"})
plt.show()
Nsamp, Nbin = 1000, 30
log_pop_seq = np.linspace(6, 14, Nbin)
a_post = trace_13_7.get_values(varname="a", combine=True)[:, None]
bp_post = trace_13_7.get_values(varname="bp", combine=True)[:, None]
lambda_post = np.exp(a_post + bp_post * log_pop_seq)
_, axes = plt.subplots(1, 1, figsize=(5, 5))
cred_interval = 0.8
# display posterior predictions
axes.plot(log_pop_seq, np.median(lambda_post, axis=0), "--", color="k")
az.plot_hpd(
log_pop_seq,
lambda_post,
credible_interval=cred_interval,
color="k",
fill_kwargs={"alpha": cred_interval * 0.5},
)
# plot raw data and labels
axes.scatter(dk["logpop"], dk["total_tools"], psize)
labels = dk["culture"].values
for i, itext in enumerate(labels):
axes.text(dk["logpop"][i] + 0.1, dk["total_tools"][i] - 2.5, itext)
# overlay correlations
for i in range(10):
for j in np.arange(i + 1, 10):
axes.plot(
[dk["logpop"][i], dk["logpop"][j]],
# plot the non robust linear regression
plt.plot(x,
alpha_c + beta_c * x,
c="k",
label="Non-robust regression",
alpha=0.5)
# plot the data
plt.plot(x, y, 'C0o')
# get the mean of the intercept from the posterior
alpha_m = trace["alpha"].mean()
# get the mean of the coefficient from the posterior
beta_m = trace["beta"].mean()
# plot the robust linear regression
plt.plot(x, alpha_m + beta_m * x, c="k", label="Robust linear regression")
# plot the variety of predicted results
az.plot_hpd(x, ppc["obs"])
# set the last details of the graph
plt.xlabel("x")
plt.ylabel("y", rotation=0)
#plt.legend(loc=2)
plt.tight_layout()
plt.show()
# ----------------- analyse the posterior -------------------- #
with model_t:
az.plot_trace(trace, var_names=["alpha", "beta", "sigma", "vu"])
# get the summary
log.info("the trace summary is: %s", az.summary(trace))
# let's also run a posterior predictive check
ppc = pm.sample_posterior_predictive(trace, samples=2000)
