{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# State space modeling: Local Linear Trends" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This notebook describes how to extend the statsmodels statespace classes to create and estimate a custom model. Here we develop a local linear trend model.\n", "\n", "The Local Linear Trend model has the form (see Durbin and Koopman 2012, Chapter 3.2 for all notation and details):\n", "\n", "\n", "\\begin{align}\n", "y_t & = \\mu_t + \\varepsilon_t \\qquad & \\varepsilon_t \\sim\n", " N(0, \\sigma_\\varepsilon^2) \\\\\n", "\\mu_{t+1} & = \\mu_t + \\nu_t + \\xi_t & \\xi_t \\sim N(0, \\sigma_\\xi^2) \\\\\n", "\\nu_{t+1} & = \\nu_t + \\zeta_t & \\zeta_t \\sim N(0, \\sigma_\\zeta^2)\n", "\\end{align}\n", "\n", "\n", "It is easy to see that this can be cast into state space form as:\n", "\n", "\n", "\\begin{align}\n", "y_t & = \\begin{pmatrix} 1 & 0 \\end{pmatrix} \\begin{pmatrix} \\mu_t \\\\ \\nu_t \\end{pmatrix} + \\varepsilon_t \\\\\n", "\\begin{pmatrix} \\mu_{t+1} \\\\ \\nu_{t+1} \\end{pmatrix} & = \\begin{bmatrix} 1 & 1 \\\\ 0 & 1 \\end{bmatrix} \\begin{pmatrix} \\mu_t \\\\ \\nu_t \\end{pmatrix} + \\begin{pmatrix} \\xi_t \\\\ \\zeta_t \\end{pmatrix}\n", "\\end{align}\n", "\n", "\n", "Notice that much of the state space representation is composed of known values; in fact the only parts in which parameters to be estimated appear are in the variance / covariance matrices:\n", "\n", "\n", "\\begin{align}\n", "H_t & = \\begin{bmatrix} \\sigma_\\varepsilon^2 \\end{bmatrix} \\\\\n", "Q_t & = \\begin{bmatrix} \\sigma_\\xi^2 & 0 \\\\ 0 & \\sigma_\\zeta^2 \\end{bmatrix}\n", "\\end{align}\n", "" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "collapsed": false, "execution": { "iopub.execute_input": "2022-06-22T04:38:19.934458Z", "iopub.status.busy": "2022-06-22T04:38:19.934154Z", "iopub.status.idle": "2022-06-22T04:38:21.667427Z", "shell.execute_reply": "2022-06-22T04:38:21.666659Z" }, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [ "%matplotlib inline\n", "\n", "import numpy as np\n", "import pandas as pd\n", "from scipy.stats import norm\n", "import statsmodels.api as sm\n", "import matplotlib.pyplot as plt" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To take advantage of the existing infrastructure, including Kalman filtering and maximum likelihood estimation, we create a new class which extends from statsmodels.tsa.statespace.MLEModel. There are a number of things that must be specified:\n", "\n", "1. **k_states**, **k_posdef**: These two parameters must be provided to the base classes in initialization. The inform the statespace model about the size of, respectively, the state vector, above $\\begin{pmatrix} \\mu_t & \\nu_t \\end{pmatrix}'$, and the state error vector, above $\\begin{pmatrix} \\xi_t & \\zeta_t \\end{pmatrix}'$. Note that the dimension of the endogenous vector does not have to be specified, since it can be inferred from the endog array.\n", "2. **update**: The method update, with argument params, must be specified (it is used when fit() is called to calculate the MLE). It takes the parameters and fills them into the appropriate state space matrices. For example, below, the params vector contains variance parameters $\\begin{pmatrix} \\sigma_\\varepsilon^2 & \\sigma_\\xi^2 & \\sigma_\\zeta^2\\end{pmatrix}$, and the update method must place them in the observation and state covariance matrices. More generally, the parameter vector might be mapped into many different places in all of the statespace matrices.\n", "3. **statespace matrices**: by default, all state space matrices (obs_intercept, design, obs_cov, state_intercept, transition, selection, state_cov) are set to zeros. Values that are fixed (like the ones in the design and transition matrices here) can be set in initialization, whereas values that vary with the parameters should be set in the update method. Note that it is easy to forget to set the selection matrix, which is often just the identity matrix (as it is here), but not setting it will lead to a very different model (one where there is not a stochastic component to the transition equation).\n", "4. **start params**: start parameters must be set, even if it is just a vector of zeros, although often good start parameters can be found from the data. Maximum likelihood estimation by gradient methods (as employed here) can be sensitive to the starting parameters, so it is important to select good ones if possible. Here it does not matter too much (although as variances, they should't be set zero).\n", "5. **initialization**: in addition to defined state space matrices, all state space models must be initialized with the mean and variance for the initial distribution of the state vector. If the distribution is known, initialize_known(initial_state, initial_state_cov) can be called, or if the model is stationary (e.g. an ARMA model), initialize_stationary can be used. Otherwise, initialize_approximate_diffuse is a reasonable generic initialization (exact diffuse initialization is not yet available). Since the local linear trend model is not stationary (it is composed of random walks) and since the distribution is not generally known, we use initialize_approximate_diffuse below.\n", "\n", "The above are the minimum necessary for a successful model. There are also a number of things that do not have to be set, but which may be helpful or important for some applications:\n", "\n", "1. **transform / untransform**: when fit is called, the optimizer in the background will use gradient methods to select the parameters that maximize the likelihood function. By default it uses unbounded optimization, which means that it may select any parameter value. In many cases, that is not the desired behavior; variances, for example, cannot be negative. To get around this, the transform method takes the unconstrained vector of parameters provided by the optimizer and returns a constrained vector of parameters used in likelihood evaluation. untransform provides the reverse operation.\n", "2. **param_names**: this internal method can be used to set names for the estimated parameters so that e.g. the summary provides meaningful names. If not present, parameters are named param0, param1, etc." ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "collapsed": false, "execution": { "iopub.execute_input": "2022-06-22T04:38:21.671881Z", "iopub.status.busy": "2022-06-22T04:38:21.671325Z", "iopub.status.idle": "2022-06-22T04:38:21.680578Z", "shell.execute_reply": "2022-06-22T04:38:21.679969Z" }, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [ "\"\"\"\n", "Univariate Local Linear Trend Model\n", "\"\"\"\n", "class LocalLinearTrend(sm.tsa.statespace.MLEModel):\n", " def __init__(self, endog):\n", " # Model order\n", " k_states = k_posdef = 2\n", "\n", " # Initialize the statespace\n", " super(LocalLinearTrend, self).__init__(\n", " endog, k_states=k_states, k_posdef=k_posdef,\n", " initialization='approximate_diffuse',\n", " loglikelihood_burn=k_states\n", " )\n", "\n", " # Initialize the matrices\n", " self.ssm['design'] = np.array([1, 0])\n", " self.ssm['transition'] = np.array([[1, 1],\n", " [0, 1]])\n", " self.ssm['selection'] = np.eye(k_states)\n", "\n", " # Cache some indices\n", " self._state_cov_idx = ('state_cov',) + np.diag_indices(k_posdef)\n", "\n", " @property\n", " def param_names(self):\n", " return ['sigma2.measurement', 'sigma2.level', 'sigma2.trend']\n", "\n", " @property\n", " def start_params(self):\n", " return [np.std(self.endog)]*3\n", "\n", " def transform_params(self, unconstrained):\n", " return unconstrained**2\n", "\n", " def untransform_params(self, constrained):\n", " return constrained**0.5\n", "\n", " def update(self, params, *args, **kwargs):\n", " params = super(LocalLinearTrend, self).update(params, *args, **kwargs)\n", " \n", " # Observation covariance\n", " self.ssm['obs_cov',0,0] = params[0]\n", "\n", " # State covariance\n", " self.ssm[self._state_cov_idx] = params[1:]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Using this simple model, we can estimate the parameters from a local linear trend model. The following example is from Commandeur and Koopman (2007), section 3.4., modeling motor vehicle fatalities in Finland." ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "collapsed": false, "execution": { "iopub.execute_input": "2022-06-22T04:38:21.684100Z", "iopub.status.busy": "2022-06-22T04:38:21.683809Z", "iopub.status.idle": "2022-06-22T04:38:23.617951Z", "shell.execute_reply": "2022-06-22T04:38:23.617171Z" }, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [ "import requests\n", "from io import BytesIO\n", "from zipfile import ZipFile\n", " \n", "# Download the dataset\n", "ck = requests.get('http://staff.feweb.vu.nl/koopman/projects/ckbook/OxCodeAll.zip').content\n", "zipped = ZipFile(BytesIO(ck))\n", "df = pd.read_table(\n", " BytesIO(zipped.read('OxCodeIntroStateSpaceBook/Chapter_2/NorwayFinland.txt')),\n", " skiprows=1, header=None, sep='\\s+', engine='python',\n", " names=['date','nf', 'ff']\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Since we defined the local linear trend model as extending from MLEModel, the fit() method is immediately available, just as in other statsmodels maximum likelihood classes. Similarly, the returned results class supports many of the same post-estimation results, like the summary method.\n" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "collapsed": false, "execution": { "iopub.execute_input": "2022-06-22T04:38:23.622054Z", "iopub.status.busy": "2022-06-22T04:38:23.621616Z", "iopub.status.idle": "2022-06-22T04:38:23.673614Z", "shell.execute_reply": "2022-06-22T04:38:23.672933Z" }, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " Statespace Model Results \n", "==============================================================================\n", "Dep. Variable: lff No. Observations: 34\n", "Model: LocalLinearTrend Log Likelihood 27.510\n", "Date: Wed, 22 Jun 2022 AIC -49.020\n", "Time: 04:38:23 BIC -44.623\n", "Sample: 01-01-1970 HQIC -47.563\n", " - 01-01-2003 \n", "Covariance Type: opg \n", "======================================================================================\n", " coef std err z P>|z| [0.025 0.975]\n", "--------------------------------------------------------------------------------------\n", "sigma2.measurement 0.0010 0.003 0.346 0.730 -0.005 0.007\n", "sigma2.level 0.0074 0.005 1.564 0.118 -0.002 0.017\n", "sigma2.trend 2.501e-11 0.000 1.67e-07 1.000 -0.000 0.000\n", "===================================================================================\n", "Ljung-Box (L1) (Q): 0.00 Jarque-Bera (JB): 0.68\n", "Prob(Q): 0.95 Prob(JB): 0.71\n", "Heteroskedasticity (H): 0.75 Skew: -0.02\n", "Prob(H) (two-sided): 0.64 Kurtosis: 2.29\n", "===================================================================================\n", "\n", "Warnings:\n", "[1] Covariance matrix calculated using the outer product of gradients (complex-step).\n" ] } ], "source": [ "# Load Dataset\n", "df.index = pd.date_range(start='%d-01-01' % df.date[0], end='%d-01-01' % df.iloc[-1, 0], freq='AS')\n", "\n", "# Log transform\n", "df['lff'] = np.log(df['ff'])\n", "\n", "# Setup the model\n", "mod = LocalLinearTrend(df['lff'])\n", "\n", "# Fit it using MLE (recall that we are fitting the three variance parameters)\n", "res = mod.fit(disp=False)\n", "print(res.summary())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Finally, we can do post-estimation prediction and forecasting. Notice that the end period can be specified as a date." ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "collapsed": false, "execution": { "iopub.execute_input": "2022-06-22T04:38:23.677123Z", "iopub.status.busy": "2022-06-22T04:38:23.676641Z", "iopub.status.idle": "2022-06-22T04:38:23.684156Z", "shell.execute_reply": "2022-06-22T04:38:23.683508Z" }, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [ "# Perform prediction and forecasting\n", "predict = res.get_prediction()\n", "forecast = res.get_forecast('2014')" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "collapsed": false, "execution": { "iopub.execute_input": "2022-06-22T04:38:23.687393Z", "iopub.status.busy": "2022-06-22T04:38:23.686929Z", "iopub.status.idle": "2022-06-22T04:38:24.036233Z", "shell.execute_reply": "2022-06-22T04:38:24.035472Z" }, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "