# Really basic Stan

Ever since I got a primer on Bayesian statistics from Aaron McNeil in my Analysis of Biological Data course at Dalhousie, I’ve been Bayesian-curious. As an avid R user, the way to do Bayesian statistics (as far as I can tell) is Stan, “a state-of-the-art platform for statistical modeling and high-performance statistical computation”. Other packages like brms build on Stan for most use-cases; an excellent guide to doing statistics using brms is available as the online book Statistical Rethinking with brms, ggplot2, and the tidyverse.

Using brms is less intuitive (for me) with more complex models. My use-case is physically-based age-depth models, but there comes a point where writing Stan code is more expressive than the equivalent brms code, and because Bayesian stats can be complicated to explain to people, expressiveness is key! The rest of this post is the result of my adventures learning how to write Stan code. I’ll be using the tidyverse and rstan for the rest of the post.

library(tidyverse)
library(rstan)

## A Bayesian linear model

(based on the tutorial in the excellent Stan documentation)

Most of us have been using linear models ever since we learned how to insert a “best fit” line in Excel, which prints a nice equation in the form y = m * x + b. Because every point has some error (not every point is along the best-fit line), the model is actually more like y = m * x + b + error, and indeed, the assumptions that underly frequentist hypothesis testing for linear models assume that the residuals are normally distributed (mean of 0 with a standard deviation). I normally don’t use fake data in posts, but here it’s useful so that we see if the model is giving us the correct values.

actual_slope <- 4.5
actual_intercept <- 12
actual_se <- 20

set.seed(2847)
linear_data <- tibble(
x = 0:99,
y = actual_slope * x + actual_intercept +
rnorm(100, mean = 0, sd = actual_se)
)

ggplot(linear_data, aes(x, y)) +
geom_abline(
slope = actual_slope,
intercept = actual_intercept,
lty = 2, alpha = 0.7
) +
geom_point()

Of course, the “normal” way to fit the model (estimate m and b) is using lm():

lm_fit <- lm(y ~ x, data = linear_data)
summary(lm_fit)
##
## Call:
## lm(formula = y ~ x, data = linear_data)
##
## Residuals:
##     Min      1Q  Median      3Q     Max
## -59.845 -16.378   2.149  15.298  43.582
##
## Coefficients:
##             Estimate Std. Error t value Pr(>|t|)
## (Intercept) 10.92106    4.16778    2.62   0.0102 *
## x            4.49005    0.07273   61.73   <2e-16 ***
## ---
## Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
##
## Residual standard error: 21 on 98 degrees of freedom
## Multiple R-squared:  0.9749,	Adjusted R-squared:  0.9747
## F-statistic:  3811 on 1 and 98 DF,  p-value: < 2.2e-16

Using Stan, there are more steps. First, we have to define the model. I usually do this in a character vector, but you can also define it in an RMarkdown chunk or a .stan file, where you’ll get better RStudio syntax highlighting and autocompletion.

stan_model_def <- "
data {
int n;
vector[n] x;
vector[n] y;
}

parameters {
real slope;
real intercept;
real standardError;
}

model {
y ~ normal(slope * x + intercept, standardError);
}
"

stan_fit <- stan(
model_code = stan_model_def,
data = list(
n = nrow(linear_data),
x = linear_data\$x,
y = linear_data\$y
)
)
stan_fit
## Inference for Stan model: f7e762c95082ee6612f2bddb48340f4c.
## 4 chains, each with iter=2000; warmup=1000; thin=1;
## post-warmup draws per chain=1000, total post-warmup draws=4000.
##
##                  mean se_mean   sd    2.5%     25%     50%     75%   97.5%
## slope            4.49    0.00 0.07    4.35    4.44    4.49    4.54    4.63
## intercept       10.83    0.10 4.17    2.61    8.05   10.85   13.67   19.02
## standardError   21.24    0.03 1.51   18.50   20.17   21.17   22.18   24.46
## lp__          -354.94    0.03 1.19 -358.04 -355.52 -354.63 -354.05 -353.53
##               n_eff Rhat
## slope          1587    1
## intercept      1599    1
## standardError  2179    1
## lp__           1571    1
##
## Samples were drawn using NUTS(diag_e) at Sun Dec 15 20:41:50 2019.
## For each parameter, n_eff is a crude measure of effective sample size,
## and Rhat is the potential scale reduction factor on split chains (at
## convergence, Rhat=1).

(For the rest of this post I’m only going to show the Stan code for clarity, but you should also know that rstan::extract(stan_fit) and rstan::stan_plot(stan_fit) are useful ways to extract information from the stan_fit object.)

The Stan model didn’t get any mean estimates for the parameters were closer to the “true” values than the lm() version, but it does a way better job at assessing error: the “true” values are all between the 25% and 75% quantiles for the estimated parameters. The lm() version doesn’t give any of this information (nor can it). All models are wrong, but at least the Stan model has an idea how wrong it actually is.

The above model doesn’t actually incorporate the most important feature of Bayesian statistics, which is the incorporation of prior knowledge. This is more important with more non-linear relationships, which need some guidance to converge on a solution. These get defined as distributions for the parameters you are trying to estimate. To specify that the slope should be “somewhere around 5”, for example, you could suggest that slope ~ normal(5, 3) (normally distributed with a mean of 5 and a standard deviation of 3). In Stan, these are added in the model block like so:

data {
int n;
vector[n] x;
vector[n] y;
}

parameters {
real slope;
real intercept;
real standardError;
}

model {
intercept ~ normal(10, 5);
slope ~ normal(5, 3);

y ~ normal(slope * x + intercept, standardError);
}
## Inference for Stan model: eddebbf1e1c595e093b7f8cc31ff1391.
## 4 chains, each with iter=2000; warmup=1000; thin=1;
## post-warmup draws per chain=1000, total post-warmup draws=4000.
##
##                  mean se_mean   sd    2.5%     25%     50%     75%   97.5%
## slope            4.50    0.00 0.06    4.38    4.46    4.50    4.54    4.62
## intercept       10.40    0.07 3.20    4.03    8.30   10.49   12.52   16.44
## standardError   21.28    0.03 1.50   18.58   20.24   21.18   22.22   24.53
## lp__          -354.94    0.03 1.19 -358.09 -355.50 -354.64 -354.06 -353.55
##               n_eff Rhat
## slope          2137    1
## intercept      2116    1
## standardError  2537    1
## lp__           1625    1
##
## Samples were drawn using NUTS(diag_e) at Sun Dec 15 20:42:31 2019.
## For each parameter, n_eff is a crude measure of effective sample size,
## and Rhat is the potential scale reduction factor on split chains (at
## convergence, Rhat=1).

And, magically, Stan gets the slope bang on at 4.5 (the intercept isn’t quite as good, but it’s still well within the error bounds).

## Really basic Stan

Stan models get defined in 3 main parts: data, parameters, and model. I like to think of Stan models as R functions that might look something like this:

my_stan_model <- function(data) {
parameter_values <- sample_priors(parameters)

for (i in many_iterations) {
log_probability <- evaluate(model, at = parameter_values, using = data)
if (is_good_enough(log_probability)) {
keep(parameter_values)
}

parameter_values <- update_parameter_values(parameter_values)
}

return(best(parameter_values))
}

Not being a statistician, I imagine I’m missing a lot of nuances here, but in the words of Greg Wilson, “never hesitate to sacrifice the truth for clarity”.

### Data

Let’s start with the data, or where we define the inputs. For the linear model, the inputs were x and y, and because Stan needs to know the length of any of its inputs before they’re declared, we also need the input of n, or the number of points.

data {
int n;
vector[n] x;
vector[n] y;
}

You should include anything in data that you can compute in advance, or that you are going to change from model to model. In our case, this includes information about the prior distribution of slope and intercept (I hard-coded this in the example above, but it will be different when x and y change, so it shouldn’t be hard-coded).

data {
int n;
vector[n] x;
vector[n] y;
real slopeEstimate;
real slopeEstimateSigma;
real interceptEstimate;
real interceptEstimateSigma;
}

The only thing missing are constraints. Stan lets you specify bounds for the input data, which helps track down errors considerably (also nicely communicates what you intended each variable to represent). You can specify this in angled brackets after the variable type.

data {
int<lower=0> n;
vector[n] x;
vector[n] y;
real slopeEstimate;
real<lower=0> slopeEstimateSigma;
real interceptEstimate;
real<lower=0> interceptEstimateSigma;
}

Make sure to put a semi-colon after each line!

### Parameters

If the data are the things that you do know, parameters are the things that you don’t know. They get defined in the same way as the data. For the linear model, we don’t know the slope, the intercept, or the standard error of the residuals. Just like the data, they can have constraints as well (and need semi-colons after each line).

parameters {
real slope;
real intercept;
real<lower=0> standardError;
}

### Model

The model is where the magic happens! I think of this as a place where you can write things that are true, including prior probabilities and the relationships model itself.

model {
intercept ~ normal(interceptEstimate, interceptEstimateSigma);
slope ~ normal(slopeEstimate, slopeEstimateSigma);

y ~ normal(slope * x + intercept, standardError);
}

### Putting it all together

data {
int<lower=0> n;
vector[n] x;
vector[n] y;
real slopeEstimate;
real<lower=0> slopeEstimateSigma;
real interceptEstimate;
real<lower=0> interceptEstimateSigma;
}

parameters {
real slope;
real intercept;
real<lower=0> standardError;
}

model {
intercept ~ normal(interceptEstimate, interceptEstimateSigma);
slope ~ normal(slopeEstimate, slopeEstimateSigma);

y ~ normal(slope * x + intercept, standardError);
}

Because we’ve added new data definitions, we need to add these to the data that we pass to stan().

stan_fit <- stan(
...,
data = list(
n = nrow(linear_data),
x = linear_data\$x,
y = linear_data\$y,
slopeEstimate = 5,
slopeEstimateSigma = 3,
interceptEstimate = 10,
interceptEstimateSigma = 3
)
)

stan_fit
## Inference for Stan model: 4211910eaaac919092a7429e0e3d982b.
## 4 chains, each with iter=2000; warmup=1000; thin=1;
## post-warmup draws per chain=1000, total post-warmup draws=4000.
##
##                  mean se_mean   sd    2.5%     25%     50%     75%   97.5%
## slope            4.50    0.00 0.05    4.39    4.46    4.50    4.53    4.60
## intercept       10.31    0.06 2.42    5.47    8.69   10.38   11.97   15.07
## standardError   21.21    0.03 1.50   18.49   20.17   21.14   22.22   24.28
## lp__          -351.91    0.03 1.22 -355.13 -352.46 -351.61 -351.02 -350.52
##               n_eff Rhat
## slope          1940    1
## intercept      1916    1
## standardError  2560    1
## lp__           1831    1
##
## Samples were drawn using NUTS(diag_e) at Sun Dec 15 20:43:08 2019.
## For each parameter, n_eff is a crude measure of effective sample size,
## and Rhat is the potential scale reduction factor on split chains (at
## convergence, Rhat=1).

## A more complex example

Bayesian linear models are well-handled in the R universe (the above example could be condensed to brms::brm(y ~ x, data = linear_data)), but more complex or discipline-specific models probably don’t have a well-summarised equivalent.

As an example, I’ll use radiometric dating. You might remember that radioactive elements decay exponentially, and can be modeled by the formula

amount <- function(t) initialAmount * exp(-decayConstant * t)

I deal in recent lake sediments, whose ages are usually estimated using measurements of ^210^Pb (which is radioactive). Usually we use a more complex model, but the earliest model (the CIC model) modeled the age of each slice in exactly this way, with the slight complication that there’s some residual (background) ^210^Pb hanging around in all samples. We can model a fake core that uses exactly this principle using the pb210 package.

known_background <- 15
known_background_error <- 5

# remotes::install_github("paleolimbot/pb210")
library(pb210)
fake_core <- pb210_simulate_accumulation() %>%
pb210_simulate_core(rep(1, 20)) %>%
mutate(
activity = activity +
rnorm(20, mean = known_background, sd = known_background_error)
) %>%
pb210_simulate_counting(count_time = lubridate::dhours(12)) %>%
select(depth, age, activity_estimate, activity_se)

fake_core
## # A tibble: 20 x 4
##    depth    age activity_estimate activity_se
##    <dbl>  <dbl>             <dbl>       <dbl>
##  1   0.5   5.04             583.        5.19
##  2   1.5  15.2              416.        4.39
##  3   2.5  25.5              330.        3.91
##  4   3.5  35.9              232.        3.28
##  5   4.5  46.6              167.        2.78
##  6   5.5  57.4              124.        2.40
##  7   6.5  68.4               76.6       1.88
##  8   7.5  79.6               67.5       1.77
##  9   8.5  91.1               55.6       1.60
## 10   9.5 103.                43.1       1.41
## 11  10.5 115.                32.7       1.23
## 12  11.5 127.                26.6       1.11
## 13  12.5 139.                32.5       1.23
## 14  13.5 152.                27.0       1.12
## 15  14.5 165.                19.3       0.945
## 16  15.5 178.                13.2       0.783
## 17  16.5 192.                18.8       0.934
## 18  17.5 206.                13.7       0.797
## 19  18.5 221.                19.3       0.944
## 20  19.5 236.                12.9       0.772

The Stan model for this is a bit more complicated, because we’re trying to estimate more parameters (notably, the age of each slice). The model does very poorly if we don’t give it some idea of what the ages of each slice are, and it turns out we really do know some things about how fast sediment could possibly accumulate, so it’s not unrealistic to include it in the model. Something else I do here is loop within the model bit…I think it’s possible to use vectorized notation (like for the linear model), but I think it’s good to illustrate that you can loop here to capture more complex “truths”.

data {
int<lower=0> nSamples;
real<lower=0> decayConstant;
vector<lower=0>[nSamples] activity;
vector<lower=0>[nSamples] sigmaActivity;
vector<lower=0>[nSamples] ageEstimate;
vector<lower=0>[nSamples] ageEstimateSigma;
real backgroundActivityEstimate;
real<lower=0> backgroundActivitySigma;
}

parameters {
vector<lower=0>[nSamples] age;
real<lower=0> initialActivity;
real backgroundActivity;
}

model {
initialActivity ~ normal(activity[1], sigmaActivity[1]);
backgroundActivity ~ normal(backgroundActivityEstimate, backgroundActivitySigma);

for (i in 1:nSamples)  {
activity[i] ~ normal(
backgroundActivity + initialActivity * exp(-decayConstant * age[i]),
sigmaActivity[i]
);
age[i] ~ normal(ageEstimate[i], ageEstimateSigma[i]);
}
}
stan_fit
## Inference for Stan model: 9fcf7bf39a29564f039893a762baffeb.
## 4 chains, each with iter=5000; warmup=2500; thin=1;
## post-warmup draws per chain=2500, total post-warmup draws=10000.
##
##                      mean se_mean     sd   2.5%    25%    50%    75%
## age[1]               0.79    0.01   0.38   0.11   0.51   0.77   1.04
## age[2]              11.87    0.01   0.45  11.00  11.56  11.87  12.16
## age[3]              19.53    0.01   0.48  18.59  19.21  19.52  19.84
## age[4]              31.38    0.01   0.56  30.29  31.01  31.38  31.76
## age[5]              42.71    0.01   0.64  41.48  42.27  42.70  43.14
## age[6]              53.17    0.01   0.76  51.72  52.66  53.17  53.68
## age[7]              71.18    0.01   1.04  69.20  70.47  71.16  71.87
## age[8]              76.21    0.01   1.12  74.02  75.46  76.20  76.94
## age[9]              84.13    0.01   1.30  81.64  83.24  84.10  85.00
## age[10]             95.46    0.02   1.63  92.33  94.37  95.44  96.53
## age[11]            109.31    0.02   2.21 105.13 107.80 109.27 110.75
## age[12]            121.52    0.03   2.97 116.13 119.47 121.40 123.45
## age[13]            109.72    0.03   2.25 105.50 108.18 109.64 111.16
## age[14]            120.52    0.03   2.92 115.21 118.48 120.40 122.44
## age[15]            148.36    0.08   6.42 137.60 144.01 147.70 152.00
## age[16]            449.97    1.96 186.79 209.45 304.70 410.52 559.66
## age[17]            151.12    0.08   6.91 139.43 146.32 150.45 155.21
## age[18]            466.85    2.23 215.08 197.18 294.30 420.82 593.89
## age[19]            148.65    0.08   6.39 137.99 144.14 148.02 152.42
## age[20]            537.06    2.23 239.28 223.40 348.22 489.76 677.58
## initialActivity    582.99    0.08   4.99 573.55 579.55 582.90 586.38
## backgroundActivity  13.36    0.01   0.49  12.37  13.05  13.37  13.69
## lp__                80.50    0.05   3.30  73.10  78.50  80.83  82.85
##                      97.5% n_eff Rhat
## age[1]                1.57  4930    1
## age[2]               12.74  5669    1
## age[3]               20.48  6014    1
## age[4]               32.48  7262    1
## age[5]               43.97  7224    1
## age[6]               54.69  8111    1
## age[7]               73.26  9427    1
## age[8]               78.46  8081    1
## age[9]               86.73  9227    1
## age[10]              98.76  9172    1
## age[11]             113.91  8563    1
## age[12]             127.65  8278    1
## age[13]             114.36  7620    1
## age[14]             126.50  7974    1
## age[15]             162.68  7273    1
## age[16]             902.13  9125    1
## age[17]             166.61  6720    1
## age[18]             978.21  9276    1
## age[19]             162.94  6331    1
## age[20]            1106.82 11475    1
## initialActivity     592.86  3891    1
## backgroundActivity   14.27  3799    1
## lp__                 85.94  3768    1
##
## Samples were drawn using NUTS(diag_e) at Sun Dec 15 20:43:48 2019.
## For each parameter, n_eff is a crude measure of effective sample size,
## and Rhat is the potential scale reduction factor on split chains (at
## convergence, Rhat=1).

Lo and behold, we get estimates! I used age priors of 10 years per slice (with a sd of age times 2…fairly uninformative but realistic). The model does poorly in the lower sediment intervals, but correctly has high error there as well. I think it’s amazing that it estimated the background so well! To do better, it would probably have to incorporate the background error somehow, but that is a battle for another day.