{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Exponential Smoothing and Innovation State Space Model (ISSM)\n", "\n", "In this notebook we will illustrate the implementation of filtering in innovation state space model (ISSM, for short) using MXNet. Let us first briefy reivew the basic concepts.\n", "\n", "\n", "Time series forecasting is a central problem occuring in many applications from optimal inventory management, staff scheduling to topology planning. \n", "Given a sequence of measurements $z_1, \\ldots, z_T$ observed over time, the problem here is to predict future values of the time series $z_{T+1}, \\ldots, z_{T+\\tau}$, where $\\tau$ is referred as the time horizon.\n", "\n", "Exponential smoothing (ETS, which stands for *Error, Trend, and Seasonality*) is a family of very successful forecasting methods which are based on the key property that forecasts are weighted combinations of past observations ([Hyndman et. al, 2008](http://www.exponentialsmoothing.net/home)).\n", "\n", "For example, in simple exponential smoothing, the foreacast $\\hat{z}_{T+1}$ for time step $T+1$ is written as ([Hyndman, Athanasopoulos, 2012](https://www.otexts.org/fpp/7/1))\n", "\n", "$$\\hat{z}_{T+1} = \\hat{z}_T + \\alpha (z_T - \\hat{z}_T) = \\alpha\\cdot z_T + (1 - \\alpha)\\cdot \\hat{z}_T,$$\n", "\n", "In words, the next step forecast is a convex combination of the most recent obseravtion and forecast. Expanding the above equation, it is clear that the forecast is given by the exponentially weighted average of past observations, \n", "\n", "$$\\hat{z}_{T+1} = \\alpha z_T + \\alpha(1-\\alpha) z_{T-1} + \\alpha(1-\\alpha)^2 z_{T-2}+ \\cdots.$$\n", "\n", "Here $\\alpha > 0$ is a smoothing parameter that controls the weight given to each observation.\n", "Note that the recent observations are given more weight than the older observations.\n", "In fact the weight given to the past observation descreases exponentially as it gets older and hence the name **exponential smoothing**.\n", "\n", "General exponential smoothing methods consider the extensions of simple ETS to include time series patterns such as (linear) trend, various periodic seasonal effects. All ETS methods falls under the category of forecasting methods as the predictions are point forecasts (a single value is predicted for each future time step). \n", "On the other hand a statistical model describes the underlying data generation process and has an advantage that it can produce an entire probability distribuiton for each of the future time steps.\n", "Innovation state space model (ISSM) is an example of such models with considerable flexibility in respresnting commonly occurring time series patterns and underlie the exponential smoothing methods.\n", "\n", "The idea behind ISSMs is to maintain a latent state vector $l_{t}$ with recent information about level, trend, and seasonality factors.\n", "The state vector $l_t$ evolves over time adding small *innvoation* (i.e., the Gaussian noise) at each time step. \n", "The observations are then a linear combination of the components of the current state.\n", "\n", "Mathematically, ISSM is specified by two equations\n", "\n", "* The state transition equation is given by \n", "\n", "$$l_{t} = F_t l_{t-1} + g_{t}\\epsilon_t,\\quad \\epsilon_t\\sim \\mathcal{N}(0,1).$$\n", "\n", "Note that the innovation strength is controlled by $g_t$, i.e., $g_t\\epsilon_t \\sim \\mathcal{N}(0, g_t^2)$.\n", "\n", "* The observation equation is given by\n", "\n", "$$z_t = a_{t}^{\\top}l_{t-1} + b_t + \\nu_t, \\quad \\nu_t \\sim \\mathcal{N}(0, \\sigma_t^2)$$\n", "\n", "Note that here we allow for an additional term $b_t$ which can model any determinstic component (exogenous variables).\n", "\n", "This describes a fairy generic model allowing the user to encode specific time series patterns using the coefficients $F$, $a_t$ and thus are problem dependent. The innovation vector $g_t$ comes in terms of parameters to be learned (the innovation strengths). Moreover, the initial state $l_0$ has to be specified. \n", "We do so by specifying a Gaussian prior distribution $P(l_0)$, whose parameters (means, standard deviation) are learned from data as well.\n", "\n", "The parameters of the ISSM are typically learned using the maximum likelihood principle. \n", "This requires the computation of the log-likelihood of the given observations i.e., computing the probability of the data under the model, $P(z_1, \\ldots, z_T)$. Fortunately, in the previous notebook, we have learned how to compute the log-likelihood as a byproduct of LDS filtering problem. \n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Filtering\n", "\n", "We remark that ISSM is a special case of linear dynamical system except that the coefficients are allowed to change over time. The filtering equations for ISSM can readily be obtained from the general derivation described in LDS.\n", "\n", "\n", "Note the change in the notation in the following equations for filtered mean ($\\mu_t$) and filtered variance ($S_t$) because of the conflict of notation for the ISSM coefficient $F$. Also note that the deterministic part $b_t$ needs to be subtracted from the observations $[z_t]$. \n", "\n", "$$\\mu_h = F_t \\mu_{t-1} \\quad \\quad \\quad \\mu_v = a_t^{\\top}\\mu_h$$\n", "\n", "$$\\Sigma_{hh} = F_t S_{t-1}F_t^T + g_t g_t^T \\quad \\quad \\quad \\sigma^2_{v} = a_t^T\\Sigma_{hh}a_t + \\sigma_t^2$$\n", "\n", "$$K_t = \\frac{1} {\\sigma^2_{v}} \\Sigma_{hh}a_t$$\n", "\n", "$$\\mu_t = \\mu_h + K(z_t - b_t -\\mu_v) \\quad \\quad \\quad S_t = (I - K_t a_t^T)\\Sigma_{hh}(I-K_t a_t^T)^T + \\sigma^2_t K_tK_t^T$$\n", "\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "collapsed": true }, "outputs": [], "source": [ "import mxnet as mx\n", "from mxnet.ndarray import linalg_gemm2 as gemm2\n", "import mxnet.ndarray as nd" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## ISSM Filtering Function" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "collapsed": true }, "outputs": [], "source": [ "def ISSM_filter(z, b, F, a, g, sigma, m_prior, S_prior): \n", " \n", " H = F.shape[0] # dim of latent state\n", " T = z.shape[0] # num of observations\n", " \n", " eye_h = nd.array(np.eye(H)) \n", "\n", " mu_seq = []\n", " S_seq = []\n", " log_p_seq = []\n", " \n", " for t in range(T):\n", " \n", " if t == 0:\n", " # At the first time step, use the prior\n", " mu_h = m_prior\n", " S_hh = S_prior\n", " else:\n", " # Otherwise compute using update eqns.\n", " F_t = F[:, :, t] \n", " g_t = g[:, t].reshape((H,1)) \n", " \n", " mu_h = gemm2(F_t, mu_t)\n", " S_hh = gemm2(F_t, gemm2(S_t, F_t, transpose_b=1)) + \\\n", " gemm2(g_t, g_t, transpose_b=1)\n", "\n", " a_t = a[:, t].reshape((H,1))\n", " mu_v = gemm2(mu_h, a_t, transpose_a=1)\n", "\n", " # Compute the Kalman gain (vector)\n", " S_hh_x_a_t = gemm2(S_hh, a_t)\n", " \n", " sigma_t = sigma[t]\n", " S_vv = gemm2(a_t, S_hh_x_a_t, transpose_a=1) + nd.square(sigma_t)\n", " kalman_gain = nd.broadcast_div(S_hh_x_a_t, S_vv)\n", "\n", " # Compute the error (delta)\n", " delta = z[t] - b[t] - mu_v\n", "\n", " # Filtered estimates\n", " mu_t = mu_h + gemm2(kalman_gain, delta)\n", "\n", " # Joseph's symmetrized update for covariance:\n", " ImKa = nd.broadcast_sub(eye_h, gemm2(kalman_gain, a_t, transpose_b=1))\n", " S_t = gemm2(gemm2(ImKa, S_hh), ImKa, transpose_b=1) + \\\n", " nd.broadcast_mul(gemm2(kalman_gain, kalman_gain, transpose_b=1), nd.square(sigma_t))\n", " \n", " # likelihood term\n", " log_p = (-0.5 * (delta * delta / S_vv\n", " + np.log(2.0 * np.pi)\n", " + nd.log(S_vv))\n", " )\n", "\n", " mu_seq.append(mu_t)\n", " S_seq.append(S_t)\n", " log_p_seq.append(log_p)\n", "\n", "\n", " return mu_seq, S_seq, log_p_seq" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Data\n", "\n", "We will use the [10 year US Government Bond Yields dataset](https://datahub.io/core/bond-yields-us-10y) to illustrate two specific instances of ISSM models." ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "collapsed": true }, "outputs": [], "source": [ "import pandas as pd\n", "import numpy as np\n", "%matplotlib inline\n", "import matplotlib.pyplot as plt\n", "plt.rcParams[\"figure.figsize\"] = (12, 5)" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "collapsed": true }, "outputs": [], "source": [ "df = pd.read_csv(\"https://datahub.io/core/bond-yields-us-10y/r/monthly.csv\", header=0)" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "collapsed": true }, "outputs": [], "source": [ "df.set_index(\"Date\")\n", "\n", "# get the time series \n", "ts = df.values[:,1]\n", "\n", "# Let us normalize the time series\n", "ts = np.array((ts - np.mean(ts)) / np.std(ts), dtype=np.double)" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "scrolled": false }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "