# PyMC linear regression part 3: predicting average height

This is the next post in a series of linear regression posts using PyMC3. This series has been inspired by my reading of Statistical Rethinking. Part 1 was dedicated to setting up the problem and understanding the package’s objects. Part 2 was about interpreting the posterior distribution. In this entry, I’ll be using the posterior distribution to make predictions. Specifically, I’ll make the distinction between predicting average height which has its own uncertainty, and actual height. I’ll cover predictions of average height here.

The first few pieces of code will replicate the previous posts to get us to where we want to be.

import arviz as az
import matplotlib.pyplot as plt
import numpy as np
import os
import pandas as pd
import pymc3 as pm
import scipy.stats as stats
import seaborn as sns

%load_ext nb_black
%config InlineBackend.figure_format = 'retina'
RANDOM_SEED = 8927
np.random.seed(RANDOM_SEED)
az.style.use("arviz-darkgrid")


Here again is the question that motivated the series of posts.

The weights listed below were recorded in the !Kung census, but heights were not recorded for these individuals. Provide predicted heights and 89% compatibility intervals for each of these individuals. That is, fill in the table below, using model-based predictions.

Individual weight expected height 89% interval
1 45
2 40
3 65
4 31
d = pd.read_csv("../data/a_input/Howell1.csv", sep=";", header=0)
d2 = d[d.age >= 18]  # filter to get only adults


# Setting up the variables, producing model  and trace objects

# Get the average weight as part of the model definition
xbar = d2.weight.mean()

with pm.Model() as heights_model:

# Priors are variables a, b, sigma
# using pm.Normal is a way to represent the stochastic relationship the left has to right side of equation
a = pm.Normal("a", mu=178, sd=20)
b = pm.Lognormal("b", mu=0, sd=1)
sigma = pm.Uniform("sigma", 0, 50)

# This is a linear model (not really a prior or likelihood?)
# Data included here (d2.weight, which is observed)
# Mu is deterministic, but a and b are stochastic
mu = a + b * (d2.weight - xbar)

# Likelihood is height variable, which is also observed (data included here, d2.height))
# Height is dependent on deterministic and stochastic variables
height = pm.Normal("height", mu=mu, sd=sigma, observed=d2.height)

# The next lines is doing the fitting and sampling all at once.
# I'll use the return_inferencedata=False flag
# I'll use the progressbar flag to minimize output
trace_m2 = pm.sample(1000, tune=1000, return_inferencedata=False, progressbar=False)

Auto-assigning NUTS sampler...
INFO:pymc3:Auto-assigning NUTS sampler...
Multiprocess sampling (4 chains in 4 jobs)
INFO:pymc3:Multiprocess sampling (4 chains in 4 jobs)
NUTS: [sigma, b, a]
INFO:pymc3:NUTS: [sigma, b, a]
Sampling 4 chains for 1_000 tune and 1_000 draw iterations (4_000 + 4_000 draws total) took 11 seconds.
INFO:pymc3:Sampling 4 chains for 1_000 tune and 1_000 draw iterations (4_000 + 4_000 draws total) took 11 seconds.

trace_m2_df = pm.trace_to_dataframe(trace_m2)


Here again are some summary statistics of the posterior distribution.

az.rcParams["stats.hdi_prob"] = 0.89  # sets default credible interval used by arviz
az.summary(trace_m2, round_to=3, kind="stats")

/Users/blacar/opt/anaconda3/envs/stats_rethinking/lib/python3.8/site-packages/arviz/data/io_pymc3.py:88: 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.
warnings.warn(

mean sd hdi_5.5% hdi_94.5%
a 154.602 0.267 154.152 154.996
b 0.903 0.042 0.834 0.969
sigma 5.106 0.197 4.802 5.430
# Get the covariance matrix.
trace_m2_df.cov().round(3)

a b sigma
a 0.071 -0.000 0.000
b -0.000 0.002 -0.000
sigma 0.000 -0.000 0.039

The correlation matrix can show how changing one parameter affects another.

trace_m2_df.corr()

a b sigma
a 1.000000 -0.004523 0.000751
b -0.004523 1.000000 -0.011835
sigma 0.000751 -0.011835 1.000000

# Making predictions for average height ($\mu_i$)

Now that we have a good grasp of the data, we can make posterior predictions. Functionally, what we are doing is taking into account the probability distributions of each parameter (alpha, beta, sigma) when making the prediction.

However, it was not intuitive to me to see how to carry this out mechanically using pymc. Let’s walk through this step-by-step since there are different ways we can capture uncertainty.

One thing that I had some trouble grasping initially was the distinction in these two equations:

$\text{height}_i$ ~ Normal($\mu_i, \sigma$)
$\mu_i = \alpha + \beta(x_i - \bar{x})$

The first line is actual height, that incorporates the uncertainty of all parameters. The second line is average height. We can make predictions for both. Note that $\sigma$ is not represented but $\alpha$ and $\beta$ are both vectors so $\mu_i$ will also be a vector for a single weight value (or a matrix when looking at all weight values, see below). As stated above, we’ll focus on average height in this post.

In the next few plots, we are only considering plausible mean lines that can be generated with posterior distribution alpha and beta values while ignoring sigma. Here again is the trace_m2 object’s returned parameters (showing only the head of the dataframe). When we are predicting the mean for a given weight, it is helpful to remember that there is uncertainty for the mean itself.

trace_m2_df.head()

a b sigma
0 154.363232 0.878117 5.149980
1 155.100196 0.899341 5.166454
2 154.226905 0.920709 5.049191
3 154.226905 0.920709 5.049191
4 154.614243 0.872827 5.043696

We can generate credibility intervals for the range of weight values using an arviz function. This puts bounds on the plausible mean line. Note how this code omits sigma.

# compute the hpdi for a range of weight values
cred_intervals = np.array(
[
az.hdi(
np.array(trace_m2_df.loc[:, "a"])
+ np.array(trace_m2_df.loc[:, "b"]) * (x - xbar)
)
for x in np.linspace(30, 65)  # This is inputting a range of weight values.
]
)

# Take a look at credibility intervals
cred_intervals[0:5, :]

array([[139.91398663, 142.10746662],
[140.61586835, 142.72290189],
[141.31055931, 143.33144088],
[141.98464947, 143.92085427],
[142.67405724, 144.52814949]])


We can represent uncertainty in two ways in the figure down below. In the left plot, we will use a combination of $\alpha$ and $\beta$ samples to produce a bunch of lines from the posterior distribution. On the right, we are plotting with the credibility interval.

f, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5))

# ax1 plot --------------------------------------------
# Plotting the data as a scatter plot
ax1.scatter(d2["weight"], d2["height"], alpha=0.5)

# Plotting mean lines using the first 50 sampled values for alpha and beta parameters
# note that sigma is not used
for i in range(50):
ax1.plot(
d2["weight"],
trace_m2_df["a"][i] + trace_m2_df["b"][i] * (d2["weight"] - xbar),
color="gray",
linewidth=0.2,
linestyle="dashed",
)

# Plotting the 50th for labeling purposes
ax1.plot(
d2["weight"],
trace_m2_df["a"][i] + trace_m2_df["b"][i] * (d2["weight"] - xbar),
color="gray",
linewidth=0.2,
linestyle="dashed",
label=r"a line for each of 100 randomly $\alpha$ and $\beta$ sampled values",
)

# Plotting the overall mean line
ax1.plot(
d2["weight"],
trace_m2["a"].mean() + trace_m2["b"].mean() * (d2["weight"] - xbar),
label="posterior mean line",
color="orange",
)

ax1.set_xlabel("weight")
ax1.set_ylabel("height")
ax1.legend(fontsize=11)

# ax2 plot --------------------------------------------
# Plotting the data as a scatter plot
ax2.scatter(d2["weight"], d2["height"], alpha=0.5)

ax2.fill_between(
np.linspace(30, 65),
cred_intervals[:, 0],
cred_intervals[:, 1],
alpha=0.4,
color="gray",
label="89% CI",
)

# Plotting the overall mean line
ax2.plot(
d2["weight"],
trace_m2["a"].mean() + trace_m2["b"].mean() * (d2["weight"] - xbar),
label="posterior mean line",
color="orange",
)

ax2.set_xlabel("weight")
ax2.set_ylabel("height")
ax2.legend(fontsize=11) It’s important to remember that the orange line drawn represents the posterior mean line. It is the most plausible line, but it’s helpful to keep in mind that there’s uncertainty and other lines (gray) are plausible (albeit with lower probability).

## Understanding $\mu_i$ uncertainty at a single weight value

It might still be hard to see why we’d have uncertainty around a mean value. Let’s take only one weight, 45 kg. We can use the formula for our line and simply plug in the value of 45 for $x_i$. We will get back a vector of predicted means since $\alpha$ and $\beta$ are vectors. Again, note how $\sigma$ from our posterior distribution is still not used in this equation.

mu_at_45 = trace_m2_df["a"] + trace_m2_df["b"] * (45 - xbar)
mu_at_45

0       154.371587
1       155.108753
2       154.235666
3       154.235666
4       154.622548
...
3995    154.848588
3996    154.247808
3997    154.608258
3998    154.342976
3999    154.589418
Length: 4000, dtype: float64


We can plot the uncertainty around this single weight value.

# Get 89% compatibility interval
az.hdi(np.array(mu_at_45))

array([154.16661059, 155.01021454])

f, ax1 = plt.subplots(1, 1, figsize=(6, 3))

az.plot_kde(mu_at_45, ax=ax1)
ax1.set_title("KDE with arviz")
ax1.set_ylabel("density")
ax1.set_xlabel("mu|weight=45")
ax1.vlines(
az.hdi(np.array(mu_at_45)),
ymin=0,
ymax=1.5,
color="gray",
linestyle="dashed",
linewidth=1,
)

<matplotlib.collections.LineCollection at 0x7fecb04d5460> ## Understanding $\mu_i$ uncertainty for a range weight values

Now let’s take a look at a range of weight values.

This is taken from the repo: “We are doing manually, in the book is done using the link function. In the book on code 4.58 the following operations are performed manually.”

# Input a range of weight values
weight_seq = np.arange(25, 71)

# Given that we have a lot of samples we can use less of them for plotting
# I just decided to use them all
# trace_m_thinned = trace_m2_df[::10]

# This is generating a matrix where the predicted mu values will be kept
# Each weight value will be its own row
mu_pred = np.zeros((len(weight_seq), len(trace_m2_df)))

# Fill out the matrix in this loop
for i, w in enumerate(weight_seq):
mu_pred[i] = trace_m2_df["a"] + trace_m2_df["b"] * (w - d2["weight"].mean())


The line for mu_pred can use further explanation. Unlike the example above where mu was a vector when evaluating at had for a single weight value, we will now return a matrix. (While I didn’t explicitly think to use this, this Stack Overflow link explains how MCMC uses multiple chains.)

df_mu_pred = pd.DataFrame(mu_pred, index=weight_seq)
df_mu_pred.index.name = "weight"

0 1 2 3 4 5 6 7 8 9 ... 3990 3991 3992 3993 3994 3995 3996 3997 3998 3999
weight
25 136.809256 137.121926 135.821484 135.821484 137.166000 135.657218 135.657218 135.657218 137.010733 137.442018 ... 136.315442 136.682549 137.083692 137.219905 135.234508 137.367422 136.002073 136.432719 136.817518 135.816661
26 137.687372 138.021267 136.742193 136.742193 138.038827 136.601131 136.601131 136.601131 137.900697 138.304255 ... 137.221021 137.580689 137.961734 138.091173 136.175118 138.241480 136.914360 137.341496 137.693791 136.755299
27 138.565489 138.920609 137.662903 137.662903 138.911655 137.545044 137.545044 137.545044 138.790662 139.166491 ... 138.126600 138.478828 138.839776 138.962441 137.115727 139.115539 137.826647 138.250273 138.570064 137.693937
28 139.443605 139.819950 138.583612 138.583612 139.784482 138.488957 138.488957 138.488957 139.680627 140.028727 ... 139.032180 139.376967 139.717819 139.833710 138.056337 139.989597 138.738933 139.159050 139.446337 138.632575
29 140.321722 140.719291 139.504321 139.504321 140.657310 139.432870 139.432870 139.432870 140.570591 140.890963 ... 139.937759 140.275107 140.595861 140.704978 138.996946 140.863655 139.651220 140.067827 140.322609 139.571212

5 rows × 4000 columns

f, axes = plt.subplots(2, 3, figsize=(12, 6))

# equally spaced weights weights in the weight range
arb_weights = np.linspace(25, 70, 6)

for arb_weight, ax in zip(arb_weights, axes.flat):
comp_interval = az.hdi(np.array(df_mu_pred.loc[arb_weight]))
legend_label = "CI range: {0:0.2f}".format(np.diff(comp_interval))
az.plot_kde(df_mu_pred.loc[arb_weight], ax=ax)
ax.set_title("mu|weight=%i" % arb_weight + "\n" + legend_label)
# ax.legend()  # cleaner to put as the title
if ax.is_first_col():
ax.set_ylabel("density")
if ax.is_last_row():
ax.set_xlabel("average height") This is another way of looking at the variability for average height. The compatibility interval range (CI range) is showing how bigger the CI is when looking at either end of the weight range. Here is a more intuitive way of showing this, with the data points in blue.

# Plotting the data as a scatter plot
plt.scatter(d2["weight"], d2["height"], alpha=0.5)
plt.plot(weight_seq, mu_pred, "C0.", color="gray", alpha=0.005)
plt.xlabel("weight")
plt.ylabel("height")
plt.title(r"Uncertainty of $\mu_i$, the linear model of the mean")

Text(0.5, 1.0, 'Uncertainty of $\\mu_i$, the linear model of the mean') # Summary

The purpose of this post was to show how to make predictions on average height using pymc. We used our posterior distribution to make many different regression lines. We plotted the uncertainties of average height around individual weights to appreciate this point. One thing that I have stressed is making a distinction between average height versus actual height. The last figure highlights how making predictions on average height would lead to over-confidence in where a new point may lie. In the next post, we will use the posterior distribution to make predictions on actual height.

Appendix: Environment and system parameters

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

Last updated: Sat May 15 2021

Python implementation: CPython
Python version       : 3.8.6
IPython version      : 7.20.0

seaborn   : 0.11.1
pymc3     : 3.11.0
arviz     : 0.11.1
matplotlib: 3.3.4
pandas    : 1.2.1
json      : 2.0.9
scipy     : 1.6.0
numpy     : 1.20.1

Watermark: 2.1.0




Categories:

Updated: