State space models with linear-Gaussian dynamics

Denote a sequence of observations (y₁, …, y_T) as y_1 : T, and sequence of latent state variables (α₁, …, α_T) as α_1 : T. A general state space model consists of two parts: observation level densities g_t(y_t|α_t) and latent state transition densities μ_t(α_t + 1|α_t). We first focus on the case where the state transitions are linear-Gaussian: α_t + 1 = c_t + T_tα_t + R_tη_t, where c_t is known input vector (often omitted), and T_t and R_t are a system matrices which can depend on unknown parameters. Also, η_t ∼ N(0, I_k) and α₁ ∼ N(a₁, P₁) independently of each other. For observation level density g_t, the bssm package currently supports basic stochastic volatility model and general exponential family state space models.

For exponential family models, the observation equation has a general form

g_t(y_t|d_t + Z_tα_t, x′_tβ, ϕ, u_t), where d_t is a again known input, x_t contains the exogenous covariate values at time t, with β corresponding to the regression coefficients. Parameter ϕ and the known vector u_t are distribution specific and can be omitted in some cases. Currently, following observational level distributions are supported:

• Gaussian distribution: g_t(y_t|Z_tα_t, x′_tβ) = x′_tβ + Z_tα_t + H_tϵ_t with ϵ_t ∼ N(0, 1).

• Poisson distribution: g_t(y_t|Z_tα_t, x′_tβ, u_t) = Poisson(u_texp (x′_tβ + Z_tα_t)), where u_t is the known exposure at time t.

• Binomial distribution: g_t(y_t|Z_tα_t, x′_tβ, u_t) = binomial(u_t, exp (x′_tβ + Z_tα_t)/(1 + exp (x′_tβ + Z_tα_t))), where u_t is the number of trials and exp (x_tβ + Z_tα_t)/(1 + exp (x′_tβ + Z_tα_t)) is the probability of the success.

• Negative binomial distribution: g_t(y_t|Z_tα_t, x′_tβ, ϕ, u_t) = negative binomial(exp (x′_tβ + Z_tα_t), ϕ, u_t), where u_texp (x′_tβ + Z_tα_t) is the expected value and ϕ is the dispersion parameter (u_t is again exposure term).

• Gamma distribution: g_t(y_t|d_t + Z_tα_t, ϕ, u_t) = Gamma(exp (d_t + Z_tα_t), ϕ, u_t), where u_texp (d_t + Z_tα_t) is the expected value, ϕ is the shape parameter, and u_t is a known offset term.

For stochastic volatility model, there are two possible parameterizations available. In general for we have y_t = σexp (α_t/2)ϵ_t,  ϵ_t ∼ N(0, 1), and α_t + 1 = μ + ρ(α_t − μ) + σ_ηη_t, with α₁ ∼ N(μ, σ_η²/(1 − ρ²)). For identifiability purposes we must either choose σ = 1 or μ = 0. Although analytically identical, the parameterization with μ is often preferable in terms of computational efficiency.

Typically some of the model components such as β, T_t or R_t depend on unknown parameter vector θ, so g_t(y_t|α_t) and μ_t(α_t + 1|α_t) depend implicitly on θ. Our goal is to perform Bayesian inference of the joint posterior of α_1 : T and θ.

For multivariate models, these distributions can be combined arbitrarily, except the stochastic volatility model case which is currently handled separately. Also, for fully Gaussian model, the observational level errors can be correlated, i.e. Cov(ϵ_t) = H_tH′_t.

Non-linear models

The general non-linear Gaussian model in the bssm has following form:

$$ y_t = Z(t, \alpha_t, \theta) + H(t, \alpha_t, \theta)\epsilon_t,\\ \alpha_{t+1} = T(t, \alpha_t, \theta) + R(t, \alpha_t, \theta)\eta_t,\\ \alpha_1 \sim N(a_1(\theta), P_1(\theta)), $$ with t = 1, …, n, ϵ_t ∼ N(0, I_p), and η ∼ N(0, I_k). Here vector θ contains the unknown model parameters. Due to their generality and the need to repeated calls within MCMC, functions T(⋅), H(⋅), T(⋅), R(⋅),a₁(⋅), P₁(⋅), as well as functions defining the Jacobians of Z(⋅) and T(⋅) needed by the extended Kalman filter and the prior distribution for θ must be defined by user as a external pointers to user-defined C++ functions. All of these functions can also depend on some known parameters, defined as known_params (vector) and known_tv_params (matrix with n columns) arguments to ssm_nlg function. See the growth model vignette¹ for a template for these functions.

Time-discretised diffusion models

The bssm package also supports models where the state equation is defined as a continuous time diffusion model of form dα_t = μ(α_t, θ)dt + σ(α_t, θ)dB_t,  t ≥ 0, where B_t is a Brownian motion and where μ and σ are scalar-valued functions, with the univariate observation density g(y_k|α_k) defined at integer times k = 1…, n. As these transition densities are generally unavailable for non-linear diffusions, we use Milstein time-discretisation scheme for approximate simulation with bootstrap particle filter. Fine discretisation mesh gives less bias than the coarser one, with increased computational complexity. These models are also defined via C++ snippets, see the SDE vignette for details.

Markov chain Monte Carlo

Given the prior p(θ), the joint posterior of θ and α_1 : T is given as

p(α_1 : T, θ|y_1 : T) ∝ p(θ)p(α_1 : T, y_1 : T|θ) = p(θ)p(y_1 : T|θ)p(α_1 : T|y_1 : T, θ)

where p(y_1 : T|θ) is the marginal likelihood, and p(α_1 : T|y_1 : T, θ) is often referred as a smoothing distribution. However, instead of targeting this joint posterior, it is typically more efficient to target the marginal posterior p(θ|y), and then given the sample {θⁱ}_i = 1ⁿ from this marginal posterior, simulate states α_1 : Tⁱ from the smoothing distribution p(α_1 : T|y_1 : T, θⁱ) for i = 1…, n.

For Gaussian models given the parameters θ, the marginal likelihood p(y_1 : T|θ) can be computed using the well known Kalman filter recursions, and there are several algorithms for simulating the states α_1 : T from the smoothing distribution p(α_1 : T|y_1 : T) (see for example Durbin and Koopman (2012)). Therefore we can straightforwardly apply standard MCMC algorithms. In bssm, we use an adaptive random walk Metropolis algorithm based on RAM (Vihola 2012) where we fix the target acceptance rate beforehand. There RAM algorithm is provided by the ramcmc package (J. Helske 2018).

For non-linear/non-Gaussian models, the marginal likelihood p(y_1 : T|θ) is typically not available in closed form. Thus we need to resort to simulation methods, which leads to pseudo-marginal MCMC algorithm Andrieu and Roberts (2009). bssm also supports more efficient inference algorithms based on (intermediate) approximations, see J. Helske and Vihola (2021) and Vihola, Helske, and Franks (2020).

Model building functions

For linear-Gaussian models, bssm offers functions bsm_lg for basic univariate structural time series models (BSM), ar1 for univariate, possibly noisy AR(1) process, as well as general ssm_ulg and ssm_mlg for arbitrary linear gaussian models. As an example, consider a Gaussian local linear trend model of form

$$ \begin{aligned} y_t &= \mu_t + \epsilon_t,\\ \mu_{t+1} &= \mu_t + \nu_t + \eta_t,\\ \nu_{t+1} &= \nu_t + \xi_t, \end{aligned} $$ with zero-mean Gaussian noise terms ϵ_t, η_t, ξ_t with unknown standard deviations. This model can be built with bsm_lg function as

library("bssm")

## 
## Attaching package: 'bssm'

## The following object is masked from 'package:base':
## 
##     gamma

data("nhtemp", package = "datasets")
prior <- halfnormal(1, 10)
bsm_model <- bsm_lg(y = nhtemp, sd_y = prior, sd_level = prior,
  sd_slope = prior)

Here we use helper function halfnormal which defines half-Normal prior distribution for the standard deviation parameters, with first argument defining the initial value of the parameter, and second defines the scale parameter of the half-Normal distribution. Other prior options are normal and uniform.

For non-Gaussian models, function bsm_ng can be used for constructing an BSM model where the observations are assumed to be distributed according to Poisson, binomial, negative binomial, or Gamma distribution. The syntax is nearly identical as in case of bsm_lg, but we now define also the distribution via argument distribution, and depending on the model, we can also define parameters u and phi. For Poisson and negative binomial models, the known parameter u corresponds to the offset term, whereas in case of binomial model u defines the number of trials. For negative binomial model, argument phi defines the dispersion term, which can be given as a fixed value, or as a prior function. For same observational densities, a model where the state equation follows a first order autoregressive process can be defined using the function ng_ar1. Finally, a stochastic volatility model can be defined using a function svm, and an arbitrary linear-Gaussian state model with Poisson, binomial or negative binomial distributed observations can be defined with ssm_ung and ssm_mng for univariate and multivariate models respectively.

For models where the state equation is no longer linear-Gaussian, we can use our pointer-based C++ interface with the function ssm_nlg. Diffusion models can be defined with the function ssm_sde. For details regarding these types of models, see the corresponding vignettes growth_model and sde_model respectively.

Filtering and smoothing

Filtering refers to estimating the conditional densities of the hidden states at time t, given the observations up to that point. For linear-Gaussian models, these densities can be efficiently computed using the Kalman filter recursions. The bssm has a method kfilter for this task. For models defined with the ssm_mng ,bsm_ng, ar1_ng, and svm functions, kfilter will first construct an approximating Gaussian model for which the Kalman filter is then used. For details of this approximation, see Durbin and Koopman (1997) and Vihola, Helske, and Franks (2020). For non-linear models defined by ssm_nlg it is possible to perform filtering using extended Kalman filter (EKF) with the function ekf, or unscented Kalman filter with the function ukf. It is also possible to use iterated EKF (IEKF) by changing the argument iekf_iter of the ekf function. Compared to EKF, in IEKF the observation equation is linearized iteratively within each time step.

While Kalman filter solves the filtering problem exactly in case of linear-Gaussian models, EKF, UKF, and the filtering based on the approximating Gaussian models produce only approximate, possibly biased filtering estimates for general models. This problem can be solved by the use of particle filters (PF). These sequential Monte Carlo methods are computationally more expensive, but can in principle deal with almost arbitrary state space models. The bssm supports general bootstrap particle filter (BSF) for all model classes of the bssm. For ssm_mng ,bsm_ng, ar1_ng, and svm models we recommend the particle filter called ψ-APF (Vihola, Helske, and Franks 2020) (see also another vignette on CRAN) which makes use of the previously mentioned approximating Gaussian model in order to produce more efficient filter. It is also available for ssm_nlg models but in case of severe non-linearities, it is not necessarily best option.

Compared to filtering problem, in smoothing problems we are interested in the conditional densities of the hidden states at certain time point t given all the observations y₁, …, y_t, …, y_n. Again for linear-Gaussian models we can use so called Kalman smoothing recursions, where as in case of more general models we can rely on approximating methods, or smoothing algorithms based on the output of particle filters. Currently only filter-smoother approach (Kitagawa 1996) for particle smoothing is supported.

Markov chain Monte Carlo

The main purpose of the bssm is to allow efficient MCMC-based inference for various state space models. For this task, a method run_mcmc can be used. Here we define a random walk model with a drift and stochastic seasonal component for UK gas consumption dataset and use 40 000 MCMC iteration where first half is discarded by default as a burn-in. Note that the number of iterations is quite low and in practice we should run the chain longer. Here we use less iterations to speed up the package checks on CRAN.

prior <- halfnormal(0.1, 1)
UKgas_model <- bsm_lg(log10(UKgas), sd_y = prior, sd_level = prior,
  sd_slope = prior, sd_seasonal =  prior)

mcmc_bsm <- run_mcmc(UKgas_model, iter = 4e4, seed = 1)
mcmc_bsm

## 
## Call:
## run_mcmc.lineargaussian(model = UKgas_model, iter = 40000, seed = 1)
## 
## Iterations = 20001:40000
## Thinning interval = 1
## Length of the final jump chain = 4716
## 
## Acceptance rate after the burn-in period:  0.236
## 
## Summary for theta:
## 
##     variable        Mean           SE          SD         2.5%       97.5% ESS
##     sd_level 0.005076792 1.969154e-04 0.003360055 0.0002233676 0.012164506 291
##  sd_seasonal 0.026279113 1.331061e-04 0.003790511 0.0185637669 0.033864873 811
##     sd_slope 0.001169760 2.945858e-05 0.000539790 0.0001344258 0.002394876 336
##         sd_y 0.016280928 2.656162e-04 0.005588283 0.0041307403 0.026326567 443
## 
## Summary for alpha_109:
## 
##    variable time         Mean           SE          SD         2.5%       97.5%
##       level 1987  2.844603981 3.576960e-04 0.016755373  2.811864975  2.87881401
##  seasonal_1 1987  0.268232881 7.340927e-04 0.035012588  0.199319650  0.33673134
##  seasonal_2 1987  0.062504590 3.753102e-04 0.017738847  0.029212802  0.09875666
##  seasonal_3 1987 -0.295387310 3.287016e-04 0.015225214 -0.327559158 -0.26697840
##       slope 1987  0.009664101 8.330244e-05 0.003840359  0.002693921  0.01804641
##   ESS
##  2194
##  2275
##  2234
##  2145
##  2125
## 
## Run time:
##    user  system elapsed 
##   4.639   0.018   4.657

Note that all MCMC algorithms of bssm output also state forecasts for the timepoint n + 1, the summary statistics of this state is also shown in the output above.

Here we use ggplot2 (Wickham 2016) package for the figures, so we transform the MCMC samples to data.frame:

suppressMessages(library("ggplot2"))
d <- as.data.frame(mcmc_bsm, variable = "theta")
ggplot(d, aes(x = value)) + 
  geom_density(adjust = 3, fill = "#92f0a8") + 
  facet_wrap(~ variable, scales = "free") + 
  theme_bw()

suppressMessages(library("dplyr"))
d <- as.data.frame(mcmc_bsm, variable = "states")
level_fit <- d |> 
  filter(variable == "level") |>
  group_by(time) |>
  summarise(consumption = mean(value), 
    lwr = quantile(value, 0.025), 
    upr = quantile(value, 0.975))

ggplot(level_fit, aes(x = time, y = consumption)) + 
  geom_ribbon(aes(ymin = lwr, ymax = upr), 
    fill = "#92f0a8", alpha = 0.25) +
  geom_line(colour = "#92f0a8") +
  geom_line(data = data.frame(
    consumption = log10(UKgas), 
    time = time(UKgas)), 
    colour = "grey30", linetype = "dashed") +
  theme_bw()

Smoothed trend component with 95% intervals.

Acknowledgements

This work has been supported by the Academy of Finland research grants 284513, 312605, 311877, and 331817.