# Diagnosing Biased Inference with Divergences¶

```
[1]:
```

```
from collections import defaultdict
import arviz as az
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import pymc3 as pm
print(f"Runing on PyMC3 v{pm.__version__}")
```

```
Runing on PyMC3 v3.9.0
```

```
[2]:
```

```
%config InlineBackend.figure_format = 'retina'
az.style.use("arviz-darkgrid")
SEED = [20100420, 20134234]
```

This notebook is a PyMC3 port of Michael Betancourt’s post on ms-stan. For detailed explanation of the underlying mechanism please check the original post and Betancourt’s excellent paper.

Bayesian statistics is all about building a model and estimating the parameters in that model. However, a naive or direct parameterization of our probability model can sometimes be ineffective, you can check out Thomas Wiecki’s blog post on the same issue in PyMC3. Suboptimal parameterization often leads to slow sampling, and more problematic, biased MCMC estimators.

More formally, as explained in the original post:

Markov chain Monte Carlo (MCMC) approximates expectations with respect to a given target distribution,

using the states of a Markov chain, \({q{0}, \ldots, q_{N} }\),

These estimators, however, are guaranteed to be accurate only asymptotically as the chain grows to be infinitely long,

To be useful in applied analyses, we need MCMC estimators to converge to the true expectation values sufficiently quickly that they are reasonably accurate before we exhaust our finite computational resources. This fast convergence requires strong ergodicity conditions to hold, in particular geometric ergodicity between a Markov transition and a target distribution. Geometric ergodicity is usually the necessary condition for MCMC estimators to follow a central limit theorem, which ensures not only that they are unbiased even after only a finite number of iterations but also that we can empirically quantify their precision using the MCMC standard error.

Unfortunately, proving geometric ergodicity is infeasible for any nontrivial problem. Instead we must rely on empirical diagnostics that identify obstructions to geometric ergodicity, and hence well-behaved MCMC estimators. For a general Markov transition and target distribution, the best known diagnostic is the split \(\hat{R}\) statistic over an ensemble of Markov chains initialized from diffuse points in parameter space; to do any better we need to exploit the particular structure of a given transition or target distribution.

Hamiltonian Monte Carlo, for example, is especially powerful in this regard as its failures to be geometrically ergodic with respect to any target distribution manifest in distinct behaviors that have been developed into sensitive diagnostics. One of these behaviors is the appearance of divergences that indicate the Hamiltonian Markov chain has encountered regions of high curvature in the target distribution which it cannot adequately explore.

In this notebook we aim to identify divergences and the underlying pathologies in `PyMC3`

.

## The Eight Schools Model¶

The hierarchical model of the Eight Schools dataset (Rubin 1981) as seen in `Stan`

:

where \(n \in \{1, \ldots, 8 \}\) and the \(\{ y_{n}, \sigma_{n} \}\) are given as data.

Inferring the hierarchical hyperparameters, \(\mu\) and \(\sigma\), together with the group-level parameters, \(\theta_{1}, \ldots, \theta_{8}\), allows the model to pool data across the groups and reduce their posterior variance. Unfortunately, the direct *centered* parameterization also squeezes the posterior distribution into a particularly challenging geometry that obstructs geometric ergodicity and hence biases MCMC estimation.

```
[3]:
```

```
# Data of the Eight Schools Model
J = 8
y = np.array([28.0, 8.0, -3.0, 7.0, -1.0, 1.0, 18.0, 12.0])
sigma = np.array([15.0, 10.0, 16.0, 11.0, 9.0, 11.0, 10.0, 18.0])
# tau = 25.
```

## A Centered Eight Schools Implementation¶

`Stan`

model:

```
data {
int<lower=0> J;
real y[J];
real<lower=0> sigma[J];
}
parameters {
real mu;
real<lower=0> tau;
real theta[J];
}
model {
mu ~ normal(0, 5);
tau ~ cauchy(0, 5);
theta ~ normal(mu, tau);
y ~ normal(theta, sigma);
}
```

Similarly, we can easily implement it in `PyMC3`

```
[4]:
```

```
with pm.Model() as Centered_eight:
mu = pm.Normal("mu", mu=0, sigma=5)
tau = pm.HalfCauchy("tau", beta=5)
theta = pm.Normal("theta", mu=mu, sigma=tau, shape=J)
obs = pm.Normal("obs", mu=theta, sigma=sigma, observed=y)
```

Unfortunately, this direct implementation of the model exhibits a pathological geometry that frustrates geometric ergodicity. Even more worrisome, the resulting bias is subtle and may not be obvious upon inspection of the Markov chain alone. To understand this bias, let’s consider first a short Markov chain, commonly used when computational expediency is a motivating factor, and only afterwards a longer Markov chain.

### A Dangerously-Short Markov Chain¶

```
[5]:
```

```
with Centered_eight:
short_trace = pm.sample(600, chains=2, random_seed=SEED)
```

```
Auto-assigning NUTS sampler...
Initializing NUTS using jitter+adapt_diag...
Multiprocess sampling (2 chains in 4 jobs)
NUTS: [theta, tau, mu]
```

```
Sampling 2 chains for 1_000 tune and 600 draw iterations (2_000 + 1_200 draws total) took 7 seconds.
There were 12 divergences after tuning. Increase `target_accept` or reparameterize.
There were 4 divergences after tuning. Increase `target_accept` or reparameterize.
The acceptance probability does not match the target. It is 0.6888589552919814, but should be close to 0.8. Try to increase the number of tuning steps.
The estimated number of effective samples is smaller than 200 for some parameters.
```

In the original post a single chain of 1200 sample is applied. However, since split \(\hat{R}\) is not implemented in `PyMC3`

we fit 2 chains with 600 sample each instead.

The Gelman-Rubin diagnostic \(\hat{R}\) doesn’t indicate any problem (values are all close to 1). You could try re-running the model with a different seed and see if this still holds.

```
[6]:
```

```
pm.summary(short_trace).round(2)
```

```
/dependencies/arviz/arviz/data/io_pymc3.py:89: FutureWarning: Using `from_pymc3` without the model will be deprecated in a future release. Not using the model will return less accurate and less useful results. Make sure you use the model argument or call from_pymc3 within a model context.
FutureWarning,
```

```
[6]:
```

mean | sd | hdi_3% | hdi_97% | mcse_mean | mcse_sd | ess_mean | ess_sd | ess_bulk | ess_tail | r_hat | |
---|---|---|---|---|---|---|---|---|---|---|---|

mu | 4.56 | 3.31 | -0.88 | 11.13 | 0.26 | 0.18 | 166.0 | 166.0 | 168.0 | 455.0 | 1.02 |

theta[0] | 6.61 | 5.54 | -2.74 | 17.36 | 0.34 | 0.24 | 271.0 | 271.0 | 274.0 | 439.0 | 1.02 |

theta[1] | 5.27 | 4.93 | -3.58 | 14.77 | 0.31 | 0.22 | 251.0 | 251.0 | 229.0 | 614.0 | 1.02 |

theta[2] | 4.18 | 5.33 | -6.91 | 13.16 | 0.28 | 0.20 | 357.0 | 357.0 | 318.0 | 550.0 | 1.01 |

theta[3] | 4.85 | 4.97 | -5.22 | 13.66 | 0.28 | 0.20 | 325.0 | 325.0 | 299.0 | 605.0 | 1.01 |

theta[4] | 3.79 | 4.48 | -3.74 | 12.19 | 0.25 | 0.22 | 326.0 | 208.0 | 293.0 | 540.0 | 1.01 |

theta[5] | 4.23 | 4.62 | -4.44 | 12.62 | 0.29 | 0.20 | 256.0 | 256.0 | 250.0 | 342.0 | 1.01 |

theta[6] | 6.56 | 5.11 | -3.29 | 15.98 | 0.31 | 0.22 | 269.0 | 269.0 | 254.0 | 435.0 | 1.02 |

theta[7] | 5.00 | 5.41 | -4.20 | 16.26 | 0.31 | 0.22 | 303.0 | 303.0 | 276.0 | 517.0 | 1.01 |

tau | 4.20 | 2.92 | 1.00 | 9.28 | 0.25 | 0.18 | 137.0 | 137.0 | 86.0 | 86.0 | 1.03 |

Moreover, the trace plots all look fine. Let’s consider, for example, the hierarchical standard deviation \(\tau\), or more specifically, its logarithm, \(log(\tau)\). Because \(\tau\) is constrained to be positive, its logarithm will allow us to better resolve behavior for small values. Indeed the chains seems to be exploring both small and large values reasonably well,

```
[7]:
```

```
# plot the trace of log(tau)
pm.traceplot({"log(tau)": short_trace.get_values(varname="tau_log__", combine=False)});
```

Unfortunately, the resulting estimate for the mean of \(log(\tau)\) is strongly biased away from the true value, here shown in grey.

```
[8]:
```

```
# plot the estimate for the mean of log(τ) cumulating mean
logtau = np.log(short_trace["tau"])
mlogtau = [np.mean(logtau[:i]) for i in np.arange(1, len(logtau))]
plt.figure(figsize=(15, 4))
plt.axhline(0.7657852, lw=2.5, color="gray")
plt.plot(mlogtau, lw=2.5)
plt.ylim(0, 2)
plt.xlabel("Iteration")
plt.ylabel("MCMC mean of log(tau)")
plt.title("MCMC estimation of log(tau)");
```

Hamiltonian Monte Carlo, however, is not so oblivious to these issues as \(\approx\) 3% of the iterations in our lone Markov chain ended with a divergence.

```
[9]:
```

```
# display the total number and percentage of divergent
divergent = short_trace["diverging"]
print("Number of Divergent %d" % divergent.nonzero()[0].size)
divperc = divergent.nonzero()[0].size / len(short_trace) * 100
print("Percentage of Divergent %.1f" % divperc)
```

```
Number of Divergent 16
Percentage of Divergent 2.7
```

Even with a single short chain these divergences are able to identity the bias and advise skepticism of any resulting MCMC estimators.

Additionally, because the divergent transitions, here shown in green, tend to be located near the pathologies we can use them to identify the location of the problematic neighborhoods in parameter space.

```
[10]:
```

```
def pairplot_divergence(trace, ax=None, divergence=True, color="C3", divergence_color="C2"):
theta = trace.get_values(varname="theta", combine=True)[:, 0]
logtau = trace.get_values(varname="tau_log__", combine=True)
if not ax:
_, ax = plt.subplots(1, 1, figsize=(10, 5))
ax.plot(theta, logtau, "o", color=color, alpha=0.5)
if divergence:
divergent = trace["diverging"]
ax.plot(theta[divergent], logtau[divergent], "o", color=divergence_color)
ax.set_xlabel("theta[0]")
ax.set_ylabel("log(tau)")
ax.set_title("scatter plot between log(tau) and theta[0]")
return ax
pairplot_divergence(short_trace);
```

It is important to point out that the pathological samples from the trace are not necessarily concentrated at the funnel: when a divergence is encountered, the subtree being constructed is rejected and the transition samples uniformly from the existing discrete trajectory. Consequently, divergent samples will not be located exactly in the region of high curvature.

In `pymc3`

, we recently implemented a warning system that also saves the information of *where* the divergence occurs, and hence you can visualize them directly. To be more precise, what we include as the divergence point in the warning is the point where that problematic leapfrog step started. Some could also be because the divergence happens in one of the leapfrog step (which strictly speaking is not a point). But nonetheless, visualizing these should give a closer proximate where the funnel
is.

Notices that only the first 100 divergences are stored, so that we don’t eat all memory.

```
[11]:
```

```
divergent_point = defaultdict(list)
chain_warn = short_trace.report._chain_warnings
for i in range(len(chain_warn)):
for warning_ in chain_warn[i]:
if warning_.step is not None and warning_.extra is not None:
for RV in Centered_eight.free_RVs:
para_name = RV.name
divergent_point[para_name].append(warning_.extra[para_name])
for RV in Centered_eight.free_RVs:
para_name = RV.name
divergent_point[para_name] = np.asarray(divergent_point[para_name])
ii = 5
tau_log_d = divergent_point["tau_log__"]
theta0_d = divergent_point["theta"][:, ii]
Ndiv_recorded = len(tau_log_d)
```

```
[12]:
```

```
_, ax = plt.subplots(1, 2, figsize=(15, 6), sharex=True, sharey=True)
pairplot_divergence(short_trace, ax=ax[0], color="C7", divergence_color="C2")
plt.title("scatter plot between log(tau) and theta[0]")
pairplot_divergence(short_trace, ax=ax[1], color="C7", divergence_color="C2")
theta_trace = short_trace["theta"]
theta0 = theta_trace[:, 0]
ax[1].plot(
[theta0[divergent == 1][:Ndiv_recorded], theta0_d],
[logtau[divergent == 1][:Ndiv_recorded], tau_log_d],
"k-",
alpha=0.5,
)
ax[1].scatter(
theta0_d, tau_log_d, color="C3", label="Location of Energy error (start location of leapfrog)"
)
plt.title("scatter plot between log(tau) and theta[0]")
plt.legend();
```

There are many other ways to explore and visualize the pathological region in the parameter space. For example, we can reproduce Figure 5b in Visualization in Bayesian workflow

```
[13]:
```

```
tracedf = pm.trace_to_dataframe(short_trace)
plotorder = [
"mu",
"tau",
"theta__0",
"theta__1",
"theta__2",
"theta__3",
"theta__4",
"theta__5",
"theta__6",
"theta__7",
]
tracedf = tracedf[plotorder]
_, ax = plt.subplots(1, 2, figsize=(15, 4), sharex=True, sharey=True)
ax[0].plot(tracedf.values[divergent == 0].T, color="k", alpha=0.025)
ax[0].plot(tracedf.values[divergent == 1].T, color="C2", lw=0.5)
ax[1].plot(tracedf.values[divergent == 0].T, color="k", alpha=0.025)
ax[1].plot(tracedf.values[divergent == 1].T, color="C2", lw=0.5)
divsp = np.hstack(
[
divergent_point["mu"][:, None],
np.exp(divergent_point["tau_log__"])[:, None],
divergent_point["theta"],
]
)
ax[1].plot(divsp.T, "C3", lw=0.5)
plt.ylim([-20, 40])
plt.xticks(range(10), plotorder)
plt.tight_layout();
```

```
[14]:
```

```
# A small wrapper function for displaying the MCMC sampler diagnostics as above
def report_trace(trace):
# plot the trace of log(tau)
pm.traceplot({"log(tau)": trace.get_values(varname="tau_log__", combine=False)})
# plot the estimate for the mean of log(τ) cumulating mean
logtau = np.log(trace["tau"])
mlogtau = [np.mean(logtau[:i]) for i in np.arange(1, len(logtau))]
plt.figure(figsize=(15, 4))
plt.axhline(0.7657852, lw=2.5, color="gray")
plt.plot(mlogtau, lw=2.5)
plt.ylim(0, 2)
plt.xlabel("Iteration")
plt.ylabel("MCMC mean of log(tau)")
plt.title("MCMC estimation of log(tau)")
plt.show()
# display the total number and percentage of divergent
divergent = trace["diverging"]
print("Number of Divergent %d" % divergent.nonzero()[0].size)
divperc = divergent.nonzero()[0].size / len(trace) * 100
print("Percentage of Divergent %.1f" % divperc)
# scatter plot between log(tau) and theta[0]
# for the identifcation of the problematic neighborhoods in parameter space
pairplot_divergence(trace);
```

### A Safer, Longer Markov Chain¶

Given the potential insensitivity of split \(\hat{R}\) on single short chains, `Stan`

recommend always running multiple chains as long as possible to have the best chance to observe any obstructions to geometric ergodicity. Because it is not always possible to run long chains for complex models, however, divergences are an incredibly powerful diagnostic for biased MCMC estimation.

```
[15]:
```

```
with Centered_eight:
longer_trace = pm.sample(4000, chains=2, tune=1000, random_seed=SEED)
```

```
Auto-assigning NUTS sampler...
Initializing NUTS using jitter+adapt_diag...
Multiprocess sampling (2 chains in 4 jobs)
NUTS: [theta, tau, mu]
```

```
Sampling 2 chains for 1_000 tune and 4_000 draw iterations (2_000 + 8_000 draws total) took 20 seconds.
There were 60 divergences after tuning. Increase `target_accept` or reparameterize.
There were 32 divergences after tuning. Increase `target_accept` or reparameterize.
The acceptance probability does not match the target. It is 0.6820146554333005, but should be close to 0.8. Try to increase the number of tuning steps.
The number of effective samples is smaller than 10% for some parameters.
```

```
[16]:
```

```
report_trace(longer_trace)
```

```
Number of Divergent 92
Percentage of Divergent 2.3
```

```
[17]:
```

```
pm.summary(longer_trace).round(2)
```

```
/dependencies/arviz/arviz/data/io_pymc3.py:89: FutureWarning: Using `from_pymc3` without the model will be deprecated in a future release. Not using the model will return less accurate and less useful results. Make sure you use the model argument or call from_pymc3 within a model context.
FutureWarning,
```

```
[17]:
```

mean | sd | hdi_3% | hdi_97% | mcse_mean | mcse_sd | ess_mean | ess_sd | ess_bulk | ess_tail | r_hat | |
---|---|---|---|---|---|---|---|---|---|---|---|

mu | 4.33 | 3.34 | -1.84 | 10.76 | 0.10 | 0.07 | 1014.0 | 1014.0 | 1020.0 | 1974.0 | 1.00 |

theta[0] | 6.62 | 5.98 | -3.85 | 18.47 | 0.16 | 0.11 | 1471.0 | 1471.0 | 1313.0 | 2971.0 | 1.00 |

theta[1] | 4.96 | 5.00 | -4.21 | 14.50 | 0.12 | 0.08 | 1828.0 | 1828.0 | 1739.0 | 3746.0 | 1.00 |

theta[2] | 3.76 | 5.62 | -7.10 | 14.28 | 0.12 | 0.09 | 2289.0 | 2122.0 | 1992.0 | 2992.0 | 1.00 |

theta[3] | 4.84 | 5.20 | -5.23 | 14.43 | 0.12 | 0.09 | 1779.0 | 1779.0 | 1635.0 | 3605.0 | 1.00 |

theta[4] | 3.34 | 4.80 | -6.09 | 11.88 | 0.12 | 0.08 | 1751.0 | 1751.0 | 1659.0 | 3864.0 | 1.00 |

theta[5] | 3.90 | 5.05 | -5.94 | 13.43 | 0.12 | 0.08 | 1747.0 | 1747.0 | 1657.0 | 2996.0 | 1.00 |

theta[6] | 6.69 | 5.30 | -3.30 | 16.76 | 0.14 | 0.10 | 1375.0 | 1375.0 | 1304.0 | 2940.0 | 1.00 |

theta[7] | 5.00 | 5.64 | -5.92 | 15.29 | 0.12 | 0.08 | 2295.0 | 2283.0 | 2020.0 | 3454.0 | 1.00 |

tau | 4.44 | 3.09 | 0.78 | 9.85 | 0.12 | 0.09 | 634.0 | 634.0 | 359.0 | 219.0 | 1.02 |

Similar to the result in `Stan`

, \(\hat{R}\) does not indicate any serious issues. However, the effective sample size per iteration has drastically fallen, indicating that we are exploring less efficiently the longer we run. This odd behavior is a clear sign that something problematic is afoot. As shown in the trace plot, the chain occasionally “sticks” as it approaches small values of \(\tau\), exactly where we saw the divergences concentrating. This is a clear indication of the
underlying pathologies. These sticky intervals induce severe oscillations in the MCMC estimators early on, until they seem to finally settle into biased values.

In fact the sticky intervals are the Markov chain trying to correct the biased exploration. If we ran the chain even longer then it would eventually get stuck again and drag the MCMC estimator down towards the true value. Given an infinite number of iterations this delicate balance asymptotes to the true expectation as we’d expect given the consistency guarantee of MCMC. Stopping after any finite number of iterations, however, destroys this balance and leaves us with a significant bias.

More details can be found in Betancourt’s recent paper.

## Mitigating Divergences by Adjusting PyMC3’s Adaptation Routine¶

Divergences in Hamiltonian Monte Carlo arise when the Hamiltonian transition encounters regions of extremely large curvature, such as the opening of the hierarchical funnel. Unable to accurate resolve these regions, the transition malfunctions and flies off towards infinity. With the transitions unable to completely explore these regions of extreme curvature, we lose geometric ergodicity and our MCMC estimators become biased.

Algorithm implemented in `Stan`

uses a heuristic to quickly identify these misbehaving trajectories, and hence label divergences, without having to wait for them to run all the way to infinity. This heuristic can be a bit aggressive, however, and sometimes label transitions as divergent even when we have not lost geometric ergodicity.

To resolve this potential ambiguity we can adjust the step size, \(\epsilon\), of the Hamiltonian transition. The smaller the step size the more accurate the trajectory and the less likely it will be mislabeled as a divergence. In other words, if we have geometric ergodicity between the Hamiltonian transition and the target distribution then decreasing the step size will reduce and then ultimately remove the divergences entirely. If we do not have geometric ergodicity, however, then decreasing the step size will not completely remove the divergences.

Like `Stan`

, the step size in `PyMC3`

is tuned automatically during warm up, but we can coerce smaller step sizes by tweaking the configuration of `PyMC3`

’s adaptation routine. In particular, we can increase the `target_accept`

parameter from its default value of 0.8 closer to its maximum value of 1.

### Adjusting Adaptation Routine¶

```
[18]:
```

```
with Centered_eight:
fit_cp85 = pm.sample(5000, chains=2, tune=2000, target_accept=0.85)
```

```
Auto-assigning NUTS sampler...
Initializing NUTS using jitter+adapt_diag...
Multiprocess sampling (2 chains in 4 jobs)
NUTS: [theta, tau, mu]
```

```
Sampling 2 chains for 2_000 tune and 5_000 draw iterations (4_000 + 10_000 draws total) took 28 seconds.
There were 262 divergences after tuning. Increase `target_accept` or reparameterize.
The acceptance probability does not match the target. It is 0.5895121610208105, but should be close to 0.85. Try to increase the number of tuning steps.
There were 737 divergences after tuning. Increase `target_accept` or reparameterize.
The acceptance probability does not match the target. It is 0.600219643701489, but should be close to 0.85. Try to increase the number of tuning steps.
The rhat statistic is larger than 1.05 for some parameters. This indicates slight problems during sampling.
The estimated number of effective samples is smaller than 200 for some parameters.
```

```
[19]:
```

```
with Centered_eight:
fit_cp90 = pm.sample(5000, chains=2, tune=2000, target_accept=0.90)
```

```
Auto-assigning NUTS sampler...
Initializing NUTS using jitter+adapt_diag...
Multiprocess sampling (2 chains in 4 jobs)
NUTS: [theta, tau, mu]
```

```
Sampling 2 chains for 2_000 tune and 5_000 draw iterations (4_000 + 10_000 draws total) took 37 seconds.
There were 77 divergences after tuning. Increase `target_accept` or reparameterize.
There were 459 divergences after tuning. Increase `target_accept` or reparameterize.
The acceptance probability does not match the target. It is 0.6195936824761532, but should be close to 0.9. Try to increase the number of tuning steps.
The rhat statistic is larger than 1.05 for some parameters. This indicates slight problems during sampling.
The estimated number of effective samples is smaller than 200 for some parameters.
```

```
[20]:
```

```
with Centered_eight:
fit_cp95 = pm.sample(5000, chains=2, tune=2000, target_accept=0.95)
```

```
Auto-assigning NUTS sampler...
Initializing NUTS using jitter+adapt_diag...
Multiprocess sampling (2 chains in 4 jobs)
NUTS: [theta, tau, mu]
```

```
Sampling 2 chains for 2_000 tune and 5_000 draw iterations (4_000 + 10_000 draws total) took 54 seconds.
There were 34 divergences after tuning. Increase `target_accept` or reparameterize.
There were 761 divergences after tuning. Increase `target_accept` or reparameterize.
The acceptance probability does not match the target. It is 0.7044998264610822, but should be close to 0.95. Try to increase the number of tuning steps.
The rhat statistic is larger than 1.05 for some parameters. This indicates slight problems during sampling.
The estimated number of effective samples is smaller than 200 for some parameters.
```

```
[21]:
```

```
with Centered_eight:
fit_cp99 = pm.sample(5000, chains=2, tune=2000, target_accept=0.99)
```

```
Auto-assigning NUTS sampler...
Initializing NUTS using jitter+adapt_diag...
Multiprocess sampling (2 chains in 4 jobs)
NUTS: [theta, tau, mu]
```

```
Sampling 2 chains for 2_000 tune and 5_000 draw iterations (4_000 + 10_000 draws total) took 197 seconds.
There were 14 divergences after tuning. Increase `target_accept` or reparameterize.
There were 84 divergences after tuning. Increase `target_accept` or reparameterize.
The acceptance probability does not match the target. It is 0.9447335832730234, but should be close to 0.99. Try to increase the number of tuning steps.
The number of effective samples is smaller than 10% for some parameters.
```

```
[22]:
```

```
df = pd.DataFrame(
[
longer_trace["step_size"].mean(),
fit_cp85["step_size"].mean(),
fit_cp90["step_size"].mean(),
fit_cp95["step_size"].mean(),
fit_cp99["step_size"].mean(),
],
columns=["Step_size"],
)
df["Divergent"] = pd.Series(
[
longer_trace["diverging"].sum(),
fit_cp85["diverging"].sum(),
fit_cp90["diverging"].sum(),
fit_cp95["diverging"].sum(),
fit_cp99["diverging"].sum(),
]
)
df["delta_target"] = pd.Series([".80", ".85", ".90", ".95", ".99"])
df
```

```
[22]:
```

Step_size | Divergent | delta_target | |
---|---|---|---|

0 | 0.302629 | 92 | .80 |

1 | 0.247224 | 999 | .85 |

2 | 0.225910 | 536 | .90 |

3 | 0.157191 | 795 | .95 |

4 | 0.056156 | 98 | .99 |

Here, the number of divergent transitions dropped dramatically when delta was increased to 0.99.

This behavior also has a nice geometric intuition. The more we decrease the step size the more the Hamiltonian Markov chain can explore the neck of the funnel. Consequently, the marginal posterior distribution for \(log (\tau)\) stretches further and further towards negative values with the decreasing step size.

Since in `PyMC3`

after tuning we have a smaller step size than `Stan`

, the geometery is better explored.

However, the Hamiltonian transition is still not geometrically ergodic with respect to the centered implementation of the Eight Schools model. Indeed, this is expected given the observed bias.

```
[23]:
```

```
_, ax = plt.subplots(1, 1, figsize=(10, 6))
pairplot_divergence(fit_cp99, ax=ax, color="C3", divergence=False)
pairplot_divergence(longer_trace, ax=ax, color="C1", divergence=False)
ax.legend(["Centered, delta=0.99", "Centered, delta=0.85"]);
```

```
[24]:
```

```
logtau0 = longer_trace["tau_log__"]
logtau2 = np.log(fit_cp90["tau"])
logtau1 = fit_cp99["tau_log__"]
plt.figure(figsize=(15, 4))
plt.axhline(0.7657852, lw=2.5, color="gray")
mlogtau0 = [np.mean(logtau0[:i]) for i in np.arange(1, len(logtau0))]
plt.plot(mlogtau0, label="Centered, delta=0.85", lw=2.5)
mlogtau2 = [np.mean(logtau2[:i]) for i in np.arange(1, len(logtau2))]
plt.plot(mlogtau2, label="Centered, delta=0.90", lw=2.5)
mlogtau1 = [np.mean(logtau1[:i]) for i in np.arange(1, len(logtau1))]
plt.plot(mlogtau1, label="Centered, delta=0.99", lw=2.5)
plt.ylim(0, 2)
plt.xlabel("Iteration")
plt.ylabel("MCMC mean of log(tau)")
plt.title("MCMC estimation of log(tau)")
plt.legend();
```

## A Non-Centered Eight Schools Implementation¶

Although reducing the step size improves exploration, ultimately it only reveals the true extent the pathology in the centered implementation. Fortunately, there is another way to implement hierarchical models that does not suffer from the same pathologies.

In a non-centered parameterization we do not try to fit the group-level parameters directly, rather we fit a latent Gaussian variable from which we can recover the group-level parameters with a scaling and a translation.

Stan model:

```
data {
int<lower=0> J;
real y[J];
real<lower=0> sigma[J];
}
parameters {
real mu;
real<lower=0> tau;
real theta_tilde[J];
}
transformed parameters {
real theta[J];
for (j in 1:J)
theta[j] = mu + tau * theta_tilde[j];
}
model {
mu ~ normal(0, 5);
tau ~ cauchy(0, 5);
theta_tilde ~ normal(0, 1);
y ~ normal(theta, sigma);
}
```

```
[25]:
```

```
with pm.Model() as NonCentered_eight:
mu = pm.Normal("mu", mu=0, sigma=5)
tau = pm.HalfCauchy("tau", beta=5)
theta_tilde = pm.Normal("theta_t", mu=0, sigma=1, shape=J)
theta = pm.Deterministic("theta", mu + tau * theta_tilde)
obs = pm.Normal("obs", mu=theta, sigma=sigma, observed=y)
```

```
[26]:
```

```
with NonCentered_eight:
fit_ncp80 = pm.sample(5000, chains=2, tune=1000, random_seed=SEED, target_accept=0.80)
```

```
Auto-assigning NUTS sampler...
Initializing NUTS using jitter+adapt_diag...
Multiprocess sampling (2 chains in 4 jobs)
NUTS: [theta_t, tau, mu]
```

```
Sampling 2 chains for 1_000 tune and 5_000 draw iterations (2_000 + 10_000 draws total) took 22 seconds.
There were 25 divergences after tuning. Increase `target_accept` or reparameterize.
There were 31 divergences after tuning. Increase `target_accept` or reparameterize.
```

```
[27]:
```

```
pm.summary(fit_ncp80).round(2)
```

```
/dependencies/arviz/arviz/data/io_pymc3.py:89: FutureWarning: Using `from_pymc3` without the model will be deprecated in a future release. Not using the model will return less accurate and less useful results. Make sure you use the model argument or call from_pymc3 within a model context.
FutureWarning,
```

```
[27]:
```

mean | sd | hdi_3% | hdi_97% | mcse_mean | mcse_sd | ess_mean | ess_sd | ess_bulk | ess_tail | r_hat | |
---|---|---|---|---|---|---|---|---|---|---|---|

mu | 4.38 | 3.31 | -1.78 | 10.43 | 0.04 | 0.03 | 8525.0 | 7794.0 | 8517.0 | 5785.0 | 1.0 |

theta_t[0] | 0.30 | 1.00 | -1.65 | 2.07 | 0.01 | 0.01 | 8053.0 | 4467.0 | 8042.0 | 5835.0 | 1.0 |

theta_t[1] | 0.09 | 0.94 | -1.65 | 1.91 | 0.01 | 0.01 | 9640.0 | 3889.0 | 9675.0 | 6130.0 | 1.0 |

theta_t[2] | -0.07 | 0.97 | -1.90 | 1.77 | 0.01 | 0.01 | 8720.0 | 3934.0 | 8734.0 | 6197.0 | 1.0 |

theta_t[3] | 0.04 | 0.94 | -1.75 | 1.77 | 0.01 | 0.01 | 9677.0 | 4322.0 | 9678.0 | 6704.0 | 1.0 |

theta_t[4] | -0.17 | 0.93 | -1.93 | 1.56 | 0.01 | 0.01 | 11378.0 | 4095.0 | 11383.0 | 6588.0 | 1.0 |

theta_t[5] | -0.06 | 0.95 | -1.72 | 1.84 | 0.01 | 0.01 | 10628.0 | 4231.0 | 10620.0 | 6818.0 | 1.0 |

theta_t[6] | 0.36 | 0.98 | -1.40 | 2.26 | 0.01 | 0.01 | 8929.0 | 4489.0 | 8886.0 | 5995.0 | 1.0 |

theta_t[7] | 0.09 | 0.98 | -1.77 | 1.87 | 0.01 | 0.01 | 9791.0 | 3945.0 | 9782.0 | 5589.0 | 1.0 |

tau | 3.61 | 3.24 | 0.00 | 9.41 | 0.05 | 0.03 | 5084.0 | 4791.0 | 5036.0 | 4473.0 | 1.0 |

theta[0] | 6.15 | 5.54 | -3.45 | 17.10 | 0.07 | 0.06 | 7142.0 | 5074.0 | 8077.0 | 5274.0 | 1.0 |

theta[1] | 4.89 | 4.68 | -3.33 | 14.27 | 0.05 | 0.04 | 8882.0 | 6454.0 | 9199.0 | 6973.0 | 1.0 |

theta[2] | 3.96 | 5.33 | -6.62 | 13.78 | 0.06 | 0.05 | 7749.0 | 6200.0 | 8362.0 | 5759.0 | 1.0 |

theta[3] | 4.70 | 4.80 | -4.31 | 13.84 | 0.05 | 0.04 | 9283.0 | 7856.0 | 9580.0 | 6361.0 | 1.0 |

theta[4] | 3.57 | 4.58 | -5.14 | 12.20 | 0.05 | 0.04 | 8748.0 | 7175.0 | 8995.0 | 6980.0 | 1.0 |

theta[5] | 4.01 | 4.79 | -4.94 | 13.31 | 0.05 | 0.04 | 8648.0 | 7355.0 | 9140.0 | 6281.0 | 1.0 |

theta[6] | 6.31 | 5.19 | -2.81 | 16.38 | 0.06 | 0.05 | 8090.0 | 6274.0 | 8775.0 | 6288.0 | 1.0 |

theta[7] | 4.87 | 5.32 | -4.81 | 15.46 | 0.06 | 0.05 | 7954.0 | 6343.0 | 8264.0 | 6232.0 | 1.0 |

As shown above, the effective sample size per iteration has drastically improved, and the trace plots no longer show any “stickyness”. However, we do still see the rare divergence. These infrequent divergences do not seem concentrate anywhere in parameter space, which is indicative of the divergences being false positives.

```
[28]:
```

```
report_trace(fit_ncp80)
```

```
Number of Divergent 56
Percentage of Divergent 1.1
```

As expected of false positives, we can remove the divergences entirely by decreasing the step size,

```
[29]:
```

```
with NonCentered_eight:
fit_ncp90 = pm.sample(5000, chains=2, tune=1000, random_seed=SEED, target_accept=0.90)
# display the total number and percentage of divergent
divergent = fit_ncp90["diverging"]
print("Number of Divergent %d" % divergent.nonzero()[0].size)
```

```
Auto-assigning NUTS sampler...
Initializing NUTS using jitter+adapt_diag...
Multiprocess sampling (2 chains in 4 jobs)
NUTS: [theta_t, tau, mu]
```

```
Sampling 2 chains for 1_000 tune and 5_000 draw iterations (2_000 + 10_000 draws total) took 23 seconds.
There was 1 divergence after tuning. Increase `target_accept` or reparameterize.
```

```
Number of Divergent 1
```

The more agreeable geometry of the non-centered implementation allows the Markov chain to explore deep into the neck of the funnel, capturing even the smallest values of \(\tau\) that are consistent with the measurements. Consequently, MCMC estimators from the non-centered chain rapidly converge towards their true expectation values.

```
[30]:
```

```
_, ax = plt.subplots(1, 1, figsize=(10, 6))
pairplot_divergence(fit_ncp80, ax=ax, color="C0", divergence=False)
pairplot_divergence(fit_cp99, ax=ax, color="C3", divergence=False)
pairplot_divergence(fit_cp90, ax=ax, color="C1", divergence=False)
ax.legend(["Non-Centered, delta=0.80", "Centered, delta=0.99", "Centered, delta=0.90"]);
```

```
[31]:
```

```
logtaun = fit_ncp80["tau_log__"]
plt.figure(figsize=(15, 4))
plt.axhline(0.7657852, lw=2.5, color="gray")
mlogtaun = [np.mean(logtaun[:i]) for i in np.arange(1, len(logtaun))]
plt.plot(mlogtaun, color="C0", lw=2.5, label="Non-Centered, delta=0.80")
mlogtau1 = [np.mean(logtau1[:i]) for i in np.arange(1, len(logtau1))]
plt.plot(mlogtau1, color="C3", lw=2.5, label="Centered, delta=0.99")
mlogtau0 = [np.mean(logtau0[:i]) for i in np.arange(1, len(logtau0))]
plt.plot(mlogtau0, color="C1", lw=2.5, label="Centered, delta=0.90")
plt.ylim(0, 2)
plt.xlabel("Iteration")
plt.ylabel("MCMC mean of log(tau)")
plt.title("MCMC estimation of log(tau)")
plt.legend();
```

```
[32]:
```

```
%load_ext watermark
%watermark -n -u -v -iv -w
```

```
pandas 1.0.4
pymc3 3.9.0
arviz 0.8.3
numpy 1.18.5
last updated: Mon Jun 15 2020
CPython 3.7.7
IPython 7.15.0
watermark 2.0.2
```