{
 "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": "2026-07-29T17:32:58.060268Z",
     "iopub.status.busy": "2026-07-29T17:32:58.060032Z",
     "iopub.status.idle": "2026-07-29T17:33:04.355035Z",
     "shell.execute_reply": "2026-07-29T17:33:04.354223Z"
    },
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "import statsmodels.api as sm"
   ]
  },
  {
   "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": "2026-07-29T17:33:04.364951Z",
     "iopub.status.busy": "2026-07-29T17:33:04.364528Z",
     "iopub.status.idle": "2026-07-29T17:33:04.388019Z",
     "shell.execute_reply": "2026-07-29T17:33:04.387107Z"
    },
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "Univariate Local Linear Trend Model\n",
    "\"\"\"\n",
    "\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().__init__(\n",
    "            endog,\n",
    "            k_states=k_states,\n",
    "            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], [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().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": "2026-07-29T17:33:04.397490Z",
     "iopub.status.busy": "2026-07-29T17:33:04.397226Z",
     "iopub.status.idle": "2026-07-29T17:33:04.621065Z",
     "shell.execute_reply": "2026-07-29T17:33:04.620078Z"
    },
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# Download the dataset\n",
    "df = pd.read_table(\n",
    "    \"https://raw.githubusercontent.com/statsmodels/smdatasets/refs/heads/main/data/statespace-local-linear-trend/NorwayFinland.txt\",\n",
    "    skiprows=1,\n",
    "    header=None,\n",
    "    sep=r\"\\s+\",\n",
    "    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": "2026-07-29T17:33:04.624764Z",
     "iopub.status.busy": "2026-07-29T17:33:04.624530Z",
     "iopub.status.idle": "2026-07-29T17:33:04.892563Z",
     "shell.execute_reply": "2026-07-29T17:33:04.887089Z"
    },
    "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, 29 Jul 2026   AIC                            -49.020\n",
      "Time:                        17:33:04   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.42e-11      0.000   1.61e-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(\n",
    "    start=f\"{df.date[0]}-01-01\", end=f\"{df.iloc[-1, 0]}-01-01\", freq=\"YS\"\n",
    ")\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": "2026-07-29T17:33:04.897040Z",
     "iopub.status.busy": "2026-07-29T17:33:04.896815Z",
     "iopub.status.idle": "2026-07-29T17:33:04.904792Z",
     "shell.execute_reply": "2026-07-29T17:33:04.904035Z"
    },
    "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": "2026-07-29T17:33:04.909860Z",
     "iopub.status.busy": "2026-07-29T17:33:04.909496Z",
     "iopub.status.idle": "2026-07-29T17:33:06.089476Z",
     "shell.execute_reply": "2026-07-29T17:33:06.088792Z"
    },
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(figsize=(10, 4))\n",
    "\n",
    "# Plot the results\n",
    "df[\"lff\"].plot(ax=ax, style=\"k.\", label=\"Observations\")\n",
    "predict.predicted_mean.plot(ax=ax, label=\"One-step-ahead Prediction\")\n",
    "predict_ci = predict.conf_int(alpha=0.05)\n",
    "predict_index = np.arange(len(predict_ci))\n",
    "ax.fill_between(\n",
    "    predict_index[2:], predict_ci.iloc[2:, 0], predict_ci.iloc[2:, 1], alpha=0.1\n",
    ")\n",
    "\n",
    "forecast.predicted_mean.plot(ax=ax, style=\"r\", label=\"Forecast\")\n",
    "forecast_ci = forecast.conf_int()\n",
    "forecast_index = np.arange(len(predict_ci), len(predict_ci) + len(forecast_ci))\n",
    "ax.fill_between(\n",
    "    forecast_index, forecast_ci.iloc[:, 0], forecast_ci.iloc[:, 1], alpha=0.1\n",
    ")\n",
    "\n",
    "# Cleanup the image\n",
    "ax.set_ylim((4, 8))\n",
    "legend = ax.legend(loc=\"lower left\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### References\n",
    "\n",
    "    Commandeur, Jacques J. F., and Siem Jan Koopman. 2007.\n",
    "    An Introduction to State Space Time Series Analysis.\n",
    "    Oxford ; New York: Oxford University Press.\n",
    "\n",
    "    Durbin, James, and Siem Jan Koopman. 2012.\n",
    "    Time Series Analysis by State Space Methods: Second Edition.\n",
    "    Oxford University Press."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.14.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}