diff --git a/notebooks/multivariate_ssm.ipynb b/notebooks/multivariate_ssm.ipynb new file mode 100644 index 000000000..dc86c5879 --- /dev/null +++ b/notebooks/multivariate_ssm.ipynb @@ -0,0 +1,1350 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "a5b7dcb3", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "from pymc_extras.statespace.models import structural as st\n", + "\n", + "import pymc as pm\n", + "import arviz as az\n", + "import pytensor.tensor as pt\n", + "\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "f8bfe995", + "metadata": {}, + "outputs": [], + "source": [ + "rng = np.random" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "a96a731b", + "metadata": {}, + "outputs": [], + "source": [ + "def simulate_local_level_with_exog(\n", + " n_endog: int = 1,\n", + " time_steps: int = 100,\n", + " mu0: float = 0.0,\n", + " sigma_eta: float = 1.0,\n", + " sigma_eps: float = 0.5,\n", + " beta1: float = 2.0,\n", + " beta2: float = -1.5,\n", + " seed: int | None = None,\n", + "):\n", + " \"\"\"\n", + " Simulates a local level model with exogenous variables.\n", + "\n", + " Parameters\n", + " ----------\n", + " n_endog: int\n", + " The number of series to simulate\n", + " time_steps: int\n", + " The length of the time-series to simulate\n", + " mu0: float\n", + " The initial state\n", + " sigma_eta: float\n", + " The level innovations standard deviation\n", + " sigma_eps: float\n", + " The observations standard deviation\n", + " beta1: float\n", + " The weight of the binary exogenous variable\n", + " beta2: float\n", + " The weight of the continuous exogenous variable\n", + " seed: int\n", + " Random generator seed for reproducibility\n", + "\n", + " Returns\n", + " -------\n", + " ys: dict[str, float]\n", + " n_endog number of observations\n", + " mu: float\n", + " latent state\n", + " x1: int\n", + " binary exogenous observations\n", + " x2: float\n", + " continuous exogenous observations\n", + " \"\"\"\n", + " if seed is not None:\n", + " np.random.seed(seed)\n", + "\n", + " # init state and observation vectors\n", + " mu = np.zeros(time_steps)\n", + " y = np.zeros(time_steps)\n", + "\n", + " # initial state\n", + " mu[0] = mu0\n", + "\n", + " # simulate exogenous variables\n", + " # binary variable\n", + " x1 = np.random.binomial(1, 0.2, size=time_steps)\n", + "\n", + " # continous variable\n", + " x2 = np.random.normal(0, 1, size=time_steps)\n", + "\n", + " # simulate latent state (local level)\n", + " for t in range(1, time_steps):\n", + " mu[t] = mu[t - 1] + np.random.normal(0, sigma_eta)\n", + "\n", + " # simulate observations\n", + " ys = {\n", + " f\"y{i+1}\": mu + beta1 * x1 + beta2 * x2 + np.random.normal(0, sigma_eps, size=time_steps)\n", + " for i in range(n_endog)\n", + " }\n", + "\n", + " return ys, mu, x1, x2" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "a4130131", + "metadata": {}, + "outputs": [], + "source": [ + "# Simulate\n", + "T = 100\n", + "true_sigma_eta = 0.3\n", + "true_sigma_eps = 0.6\n", + "true_beta1 = 3.0\n", + "true_beta2 = -1.0\n", + "ys, mu, x1, x2 = simulate_local_level_with_exog(\n", + " n_endog=3,\n", + " time_steps=T,\n", + " mu0=0,\n", + " sigma_eta=true_sigma_eta,\n", + " sigma_eps=true_sigma_eps,\n", + " beta1=true_beta1,\n", + " beta2=true_beta2,\n", + " seed=42,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "5e9acbb8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "y = ys[\"y1\"]\n", + "\n", + "# Plot\n", + "plt.figure(figsize=(12, 6))\n", + "for k, vy in ys.items():\n", + " plt.plot(vy, label=f\"Observed ${k}_t$\", alpha=0.6)\n", + "plt.plot(mu, label=\"Latent level $\\\\mu_t$\", linewidth=2)\n", + "plt.plot(x1 * 5, label=\"Binary Exog $x^{(1)}_t$\", linestyle=\"--\") # need to blow up to see it\n", + "plt.plot(x2, label=\"Continuous Exog $x^{(2)}_t$\", linestyle=\":\")\n", + "plt.legend()\n", + "plt.title(\"Local Level Model with Exogenous Variables\")\n", + "plt.xlabel(\"Time\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "f23bb2ed", + "metadata": {}, + "source": [ + "# Quick and dirty test" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "d51ff06e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
                                  Model Requirements                                   \n",
+       "                                                                                       \n",
+       "  Variable        Shape       Constraints                                  Dimensions  \n",
+       " ───────────────────────────────────────────────────────────────────────────────────── \n",
+       "  initial_trend   (3, 1)                               ('trend_endog', 'trend_state')  \n",
+       "  sigma_trend     (3, 1)      Positive                 ('trend_endog', 'trend_shock')  \n",
+       "  beta_exog       (3, 2)                                 ('exog_endog', 'exog_state')  \n",
+       "  P0              (9, 9)      Positive semi-definite           ('state', 'state_aux')  \n",
+       "                                                                                       \n",
+       "  data_exog       (None, 2)   pm.Data                          ('time', 'exog_state')  \n",
+       "                                                                                       \n",
+       "These parameters should be assigned priors inside a PyMC model block before calling the\n",
+       "                            build_statespace_graph method.                             \n",
+       "
\n" + ], + "text/plain": [ + "\u001b[3m Model Requirements \u001b[0m\n", + " \n", + " \u001b[1m \u001b[0m\u001b[1mVariable \u001b[0m\u001b[1m \u001b[0m \u001b[1m \u001b[0m\u001b[1mShape \u001b[0m\u001b[1m \u001b[0m \u001b[1m \u001b[0m\u001b[1mConstraints \u001b[0m\u001b[1m \u001b[0m \u001b[1m \u001b[0m\u001b[1m Dimensions\u001b[0m\u001b[1m \u001b[0m \n", + " ───────────────────────────────────────────────────────────────────────────────────── \n", + " initial_trend \u001b[1m(\u001b[0m\u001b[1;36m3\u001b[0m, \u001b[1;36m1\u001b[0m\u001b[1m)\u001b[0m \u001b[1m(\u001b[0m\u001b[32m'trend_endog'\u001b[0m, \u001b[32m'trend_state'\u001b[0m\u001b[1m)\u001b[0m \n", + " sigma_trend \u001b[1m(\u001b[0m\u001b[1;36m3\u001b[0m, \u001b[1;36m1\u001b[0m\u001b[1m)\u001b[0m Positive \u001b[1m(\u001b[0m\u001b[32m'trend_endog'\u001b[0m, \u001b[32m'trend_shock'\u001b[0m\u001b[1m)\u001b[0m \n", + " beta_exog \u001b[1m(\u001b[0m\u001b[1;36m3\u001b[0m, \u001b[1;36m2\u001b[0m\u001b[1m)\u001b[0m \u001b[1m(\u001b[0m\u001b[32m'exog_endog'\u001b[0m, \u001b[32m'exog_state'\u001b[0m\u001b[1m)\u001b[0m \n", + " P0 \u001b[1m(\u001b[0m\u001b[1;36m9\u001b[0m, \u001b[1;36m9\u001b[0m\u001b[1m)\u001b[0m Positive semi-definite \u001b[1m(\u001b[0m\u001b[32m'state'\u001b[0m, \u001b[32m'state_aux'\u001b[0m\u001b[1m)\u001b[0m \n", + " \n", + " data_exog \u001b[1m(\u001b[0m\u001b[3;35mNone\u001b[0m, \u001b[1;36m2\u001b[0m\u001b[1m)\u001b[0m pm.Data \u001b[1m(\u001b[0m\u001b[32m'time'\u001b[0m, \u001b[32m'exog_state'\u001b[0m\u001b[1m)\u001b[0m \n", + " \n", + "\u001b[2;3mThese parameters should be assigned priors inside a PyMC model block before calling the\u001b[0m\n", + "\u001b[2;3m build_statespace_graph method. \u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "level_trend = st.LevelTrendComponent(\n", + " order=1, innovations_order=[1], name=\"level_trend\", observed_state_names=[\"y1\", \"y2\", \"y3\"]\n", + ")\n", + "\n", + "exog = st.RegressionComponent(\n", + " name=\"exog\",\n", + " k_exog=2,\n", + " innovations=False,\n", + " state_names=[\"x1\", \"x2\"],\n", + " observed_state_names=[\"y1\", \"y2\", \"y3\"],\n", + ")\n", + "\n", + "ss_mod = (level_trend + exog).build(mode=\"JAX\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "eec30de3", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/dekermanjian/Desktop/Open_Source_Contributions/pymc-extras/pymc_extras/statespace/utils/data_tools.py:74: UserWarning: No time index found on the supplied data. A simple range index will be automatically generated.\n", + " warnings.warn(NO_TIME_INDEX_WARNING)\n" + ] + } + ], + "source": [ + "with pm.Model(coords=ss_mod.coords) as level_trend_exog_model:\n", + " # Data container\n", + " data_exog = pm.Data(\"data_exog\", np.vstack((x1, x2)).T, dims=(\"time\", \"exog_state\"))\n", + "\n", + " # Initial process covariance matrix\n", + " P0_diag = pm.Gamma(\"P0_diag\", alpha=2, beta=4, dims=\"state\")\n", + " P0 = pm.Deterministic(\"P0\", pt.diag(P0_diag), dims=(\"state\", \"state_aux\"))\n", + "\n", + " # Initial local level trend\n", + " initial_trend = pm.Normal(\"initial_trend\", mu=0, sigma=1, dims=(\"trend_endog\", \"trend_state\"))\n", + "\n", + " # Local level innovations sigma\n", + " sigma_trend = pm.HalfNormal(\"sigma_trend\", 1, dims=(\"trend_endog\", \"trend_shock\"))\n", + "\n", + " # exogenous variable parameter priors\n", + " beta_exog = pm.Normal(\"beta_exog\", 0, 5, dims=(\"exog_endog\", \"exog_state\"))\n", + "\n", + " ss_mod.build_statespace_graph(np.vstack((ys[\"y1\"], ys[\"y2\"], ys[\"y3\"])).T)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "05830b2b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + "

Sampler Progress

\n", + "

Total Chains: 4

\n", + "

Active Chains: 0

\n", + "

\n", + " Finished Chains:\n", + " 4\n", + "

\n", + "

Sampling for 43 seconds

\n", + "

\n", + " Estimated Time to Completion:\n", + " now\n", + "

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ProgressDrawsDivergencesStep SizeGradients/Draw
\n", + " \n", + " \n", + " 200040.527
\n", + " \n", + " \n", + " 200050.517
\n", + " \n", + " \n", + " 200060.557
\n", + " \n", + " \n", + " 2000130.537
\n", + "
\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "with level_trend_exog_model:\n", + " idata = pm.sample(\n", + " nuts_sampler=\"nutpie\", nuts_sampler_kwargs={\"backend\": \"JAX\", \"gradient_backend\": \"JAX\"}\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "466fb92a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
meansdhdi_3%hdi_97%mcse_meanmcse_sdess_bulkess_tailr_hat
beta_exog[y1, x1]2.9470.7081.6034.3240.0120.0153842.02349.01.0
beta_exog[y1, x2]-0.9840.711-2.4430.3350.0120.0153976.02520.01.0
beta_exog[y2, x1]2.9840.7321.5804.4410.0140.0162873.01903.01.0
beta_exog[y2, x2]-1.0400.719-2.2410.5190.0130.0163148.02390.01.0
beta_exog[y3, x1]2.7760.7111.4234.2040.0130.0153406.02475.01.0
beta_exog[y3, x2]-0.9460.691-2.2540.3860.0130.0173252.02249.01.0
sigma_trend[y1, level]0.7550.0550.6540.8580.0010.0016764.03005.01.0
sigma_trend[y2, level]0.9260.0670.7991.0510.0010.0016923.02801.01.0
sigma_trend[y3, level]0.8480.0630.7380.9750.0010.0016697.02873.01.0
\n", + "
" + ], + "text/plain": [ + " mean sd hdi_3% hdi_97% mcse_mean mcse_sd \\\n", + "beta_exog[y1, x1] 2.947 0.708 1.603 4.324 0.012 0.015 \n", + "beta_exog[y1, x2] -0.984 0.711 -2.443 0.335 0.012 0.015 \n", + "beta_exog[y2, x1] 2.984 0.732 1.580 4.441 0.014 0.016 \n", + "beta_exog[y2, x2] -1.040 0.719 -2.241 0.519 0.013 0.016 \n", + "beta_exog[y3, x1] 2.776 0.711 1.423 4.204 0.013 0.015 \n", + "beta_exog[y3, x2] -0.946 0.691 -2.254 0.386 0.013 0.017 \n", + "sigma_trend[y1, level] 0.755 0.055 0.654 0.858 0.001 0.001 \n", + "sigma_trend[y2, level] 0.926 0.067 0.799 1.051 0.001 0.001 \n", + "sigma_trend[y3, level] 0.848 0.063 0.738 0.975 0.001 0.001 \n", + "\n", + " ess_bulk ess_tail r_hat \n", + "beta_exog[y1, x1] 3842.0 2349.0 1.0 \n", + "beta_exog[y1, x2] 3976.0 2520.0 1.0 \n", + "beta_exog[y2, x1] 2873.0 1903.0 1.0 \n", + "beta_exog[y2, x2] 3148.0 2390.0 1.0 \n", + "beta_exog[y3, x1] 3406.0 2475.0 1.0 \n", + "beta_exog[y3, x2] 3252.0 2249.0 1.0 \n", + "sigma_trend[y1, level] 6764.0 3005.0 1.0 \n", + "sigma_trend[y2, level] 6923.0 2801.0 1.0 \n", + "sigma_trend[y3, level] 6697.0 2873.0 1.0 " + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "az.summary(idata, var_names=[\"beta_exog\", \"sigma_trend\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "3684616b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "az.plot_posterior(\n", + " idata,\n", + " var_names=\"beta_exog\",\n", + " ref_val={\n", + " \"beta_exog\": [\n", + " {\"exog_endog\": \"y1\", \"exog_state\": \"x1\", \"ref_val\": true_beta1},\n", + " {\"exog_endog\": \"y1\", \"exog_state\": \"x2\", \"ref_val\": true_beta2},\n", + " ]\n", + " },\n", + ");" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "7dc5d11b", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "No start date provided. Using the last date in the data index. To silence this warning, explicitly pass a start date or set verbose = False\n", + "/Users/dekermanjian/Desktop/Open_Source_Contributions/pymc-extras/pymc_extras/statespace/utils/data_tools.py:74: UserWarning: No time index found on the supplied data. A simple range index will be automatically generated.\n", + " warnings.warn(NO_TIME_INDEX_WARNING)\n", + "/opt/miniconda3/envs/pymc-extras-test/lib/python3.12/site-packages/pytensor/link/jax/linker.py:32: UserWarning: The RandomType SharedVariables [RNG()] will not be used in the compiled JAX graph. Instead a copy will be used.\n", + " warnings.warn(\n", + "Sampling: [forecast_combined]\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "fe28f382d9e04444ac804b184abdd524", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Output()" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 4MB\n",
+       "Dimensions:            (chain: 4, draw: 1000, time: 10, state: 9,\n",
+       "                        observed_state: 3)\n",
+       "Coordinates:\n",
+       "  * chain              (chain) int64 32B 0 1 2 3\n",
+       "  * draw               (draw) int64 8kB 0 1 2 3 4 5 ... 994 995 996 997 998 999\n",
+       "  * time               (time) int64 80B 100 101 102 103 104 105 106 107 108 109\n",
+       "  * state              (state) <U9 324B 'level[y1]' 'level[y2]' ... 'x2[y3]'\n",
+       "  * observed_state     (observed_state) <U2 24B 'y1' 'y2' 'y3'\n",
+       "Data variables:\n",
+       "    forecast_latent    (chain, draw, time, state) float64 3MB 2.679 ... -1.022\n",
+       "    forecast_observed  (chain, draw, time, observed_state) float64 960kB 1.81...\n",
+       "Attributes:\n",
+       "    created_at:                 2025-07-05T14:42:22.808692+00:00\n",
+       "    arviz_version:              0.21.0\n",
+       "    inference_library:          pymc\n",
+       "    inference_library_version:  5.23.0
" + ], + "text/plain": [ + " Size: 4MB\n", + "Dimensions: (chain: 4, draw: 1000, time: 10, state: 9,\n", + " observed_state: 3)\n", + "Coordinates:\n", + " * chain (chain) int64 32B 0 1 2 3\n", + " * draw (draw) int64 8kB 0 1 2 3 4 5 ... 994 995 996 997 998 999\n", + " * time (time) int64 80B 100 101 102 103 104 105 106 107 108 109\n", + " * state (state) 0 - - P0 = self.make_and_register_variable("P0", shape=(self.k_states, self.k_states)) - self.ssm["initial_state_cov"] = P0 - - @staticmethod - def _add_inital_state_cov_to_properties(param_names, param_dims, param_info, k_states): - param_names += ["P0"] - param_dims["P0"] = (ALL_STATE_DIM, ALL_STATE_AUX_DIM) - param_info["P0"] = { - "shape": (k_states, k_states), - "constraints": "Positive semi-definite", - "dims": param_dims["P0"], - } - - return param_names, param_dims, param_info - - @property - def param_names(self): - return self._param_names - - @property - def data_names(self) -> list[str]: - return self._data_names - - @property - def state_names(self): - return self._state_names - - @property - def observed_states(self): - return [self._name] - - @property - def shock_names(self): - return self._shock_names - - @property - def param_dims(self): - return self._param_dims - - @property - def coords(self) -> dict[str, Sequence]: - return self._coords - - @property - def param_info(self) -> dict[str, dict[str, Any]]: - return self._param_info - - @property - def data_info(self) -> dict[str, dict[str, Any]]: - return self._data_info - - def make_symbolic_graph(self) -> None: - """ - Assign placeholder pytensor variables among statespace matrices in positions where PyMC variables will go. - - Notes - ----- - This assignment is handled by the components, so this function is implemented only to avoid the - NotImplementedError raised by the base class. - """ - - pass - - def _state_slices_from_info(self): - info = self._component_info.copy() - comp_states = np.cumsum([0] + [info["k_states"] for info in info.values()]) - state_slices = [slice(i, j) for i, j in pairwise(comp_states)] - - return state_slices - - def _hidden_states_from_data(self, data): - state_slices = self._state_slices_from_info() - info = self._component_info - names = info.keys() - result = [] - - for i, (name, s) in enumerate(zip(names, state_slices)): - obs_idx = info[name]["obs_state_idx"] - if obs_idx is None: - continue - - X = data[..., s] - if info[name]["combine_hidden_states"]: - sum_idx = np.flatnonzero(obs_idx) - result.append(X[..., sum_idx].sum(axis=-1)[..., None]) - else: - comp_names = self.state_names[s] - for j, state_name in enumerate(comp_names): - result.append(X[..., j, None]) - - return np.concatenate(result, axis=-1) - - def _get_subcomponent_names(self): - state_slices = self._state_slices_from_info() - info = self._component_info - names = info.keys() - result = [] - - for i, (name, s) in enumerate(zip(names, state_slices)): - if info[name]["combine_hidden_states"]: - result.append(name) - else: - comp_names = self.state_names[s] - result.extend([f"{name}[{comp_name}]" for comp_name in comp_names]) - return result - - def extract_components_from_idata(self, idata: xr.Dataset) -> xr.Dataset: - r""" - Extract interpretable hidden states from an InferenceData returned by a PyMCStateSpace sampling method - - Parameters - ---------- - idata: Dataset - A Dataset object, returned by a PyMCStateSpace sampling method - - Returns - ------- - idata: Dataset - An Dataset object with hidden states transformed to represent only the "interpretable" subcomponents - of the structural model. - - Notes - ----- - In general, a structural statespace model can be represented as: - - .. math:: - y_t = \mu_t + \nu_t + \cdots + \gamma_t + c_t + \xi_t + \epsilon_t \tag{1} - - Where: - - - :math:`\mu_t` is the level of the data at time t - - :math:`\nu_t` is the slope of the data at time t - - :math:`\cdots` are higher time derivatives of the position (acceleration, jerk, etc) at time t - - :math:`\gamma_t` is the seasonal component at time t - - :math:`c_t` is the cycle component at time t - - :math:`\xi_t` is the autoregressive error at time t - - :math:`\varepsilon_t` is the measurement error at time t - - In state space form, some or all of these components are represented as linear combinations of other - subcomponents, making interpretation of the outputs of the outputs difficult. The purpose of this function is - to take the expended statespace representation and return a "reduced form" of only the components shown in - equation (1). - """ - - def _extract_and_transform_variable(idata, new_state_names): - *_, time_dim, state_dim = idata.dims - state_func = ft.partial(self._hidden_states_from_data) - new_idata = xr.apply_ufunc( - state_func, - idata, - input_core_dims=[[time_dim, state_dim]], - output_core_dims=[[time_dim, state_dim]], - exclude_dims={state_dim}, - ) - new_idata.coords.update({state_dim: new_state_names}) - return new_idata - - var_names = list(idata.data_vars.keys()) - is_latent = [idata[name].shape[-1] == self.k_states for name in var_names] - new_state_names = self._get_subcomponent_names() - - latent_names = [name for latent, name in zip(is_latent, var_names) if latent] - dropped_vars = set(var_names) - set(latent_names) - if len(dropped_vars) > 0: - _log.warning( - f'Variables {", ".join(dropped_vars)} do not contain all hidden states (their last dimension ' - f"is not {self.k_states}). They will not be present in the modified idata." - ) - if len(dropped_vars) == len(var_names): - raise ValueError( - "Provided idata had no variables with all hidden states; cannot extract components." - ) - - idata_new = xr.Dataset( - { - name: _extract_and_transform_variable(idata[name], new_state_names) - for name in latent_names - } - ) - return idata_new - - -class Component(ABC): - r""" - Base class for a component of a structural timeseries model. - - This base class contains a subset of the class attributes of the PyMCStateSpace class, and none of the class - methods. The purpose of a component is to allow the partial definition of a structural model. Components are - assembled into a full model by the StructuralTimeSeries class. - - Parameters - ---------- - name: str - The name of the component - k_endog: int - Number of endogenous variables being modeled. Currently, must be one because structural models only support - univariate data. - k_states: int - Number of hidden states in the component model - k_posdef: int - Rank of the state covariance matrix, or the number of sources of innovations in the component model - measurement_error: bool - Whether the observation associated with the component has measurement error. Default is False. - combine_hidden_states: bool - Flag for the ``extract_hidden_states_from_data`` method. When ``True``, hidden states from the component model - are extracted as ``hidden_states[:, np.flatnonzero(Z)]``. Should be True in models where hidden states - individually have no interpretation, such as seasonal or autoregressive components. - """ - - def __init__( - self, - name, - k_endog, - k_states, - k_posdef, - state_names=None, - data_names=None, - shock_names=None, - param_names=None, - exog_names=None, - representation: PytensorRepresentation | None = None, - measurement_error=False, - combine_hidden_states=True, - component_from_sum=False, - obs_state_idxs=None, - ): - self.name = name - self.k_endog = k_endog - self.k_states = k_states - self.k_posdef = k_posdef - self.measurement_error = measurement_error - - self.state_names = state_names if state_names is not None else [] - self.data_names = data_names if data_names is not None else [] - self.shock_names = shock_names if shock_names is not None else [] - self.param_names = param_names if param_names is not None else [] - self.exog_names = exog_names if exog_names is not None else [] - - self.needs_exog_data = len(self.exog_names) > 0 - self.coords = {} - self.param_dims = {} - - self.param_info = {} - self.data_info = {} - - self.param_counts = {} - - if representation is None: - self.ssm = PytensorRepresentation(k_endog=k_endog, k_states=k_states, k_posdef=k_posdef) - else: - self.ssm = representation - - self._name_to_variable = {} - self._name_to_data = {} - - if not component_from_sum: - self.populate_component_properties() - self.make_symbolic_graph() - - self._component_info = { - self.name: { - "k_states": self.k_states, - "k_enodg": self.k_endog, - "k_posdef": self.k_posdef, - "combine_hidden_states": combine_hidden_states, - "obs_state_idx": obs_state_idxs, - } - } - - def make_and_register_variable(self, name, shape, dtype=floatX) -> Variable: - r""" - Helper function to create a pytensor symbolic variable and register it in the _name_to_variable dictionary - - Parameters - ---------- - name : str - The name of the placeholder variable. Must be the name of a model parameter. - shape : int or tuple of int - Shape of the parameter - dtype : str, default pytensor.config.floatX - dtype of the parameter - - Notes - ----- - Symbolic pytensor variables are used in the ``make_symbolic_graph`` method as placeholders for PyMC random - variables. The change is made in the ``_insert_random_variables`` method via ``pytensor.graph_replace``. To - make the change, a dictionary mapping pytensor variables to PyMC random variables needs to be constructed. - - The purpose of this method is to: - 1. Create the placeholder symbolic variables - 2. Register the placeholder variable in the ``_name_to_variable`` dictionary - - The shape provided here will define the shape of the prior that will need to be provided by the user. - - An error is raised if the provided name has already been registered, or if the name is not present in the - ``param_names`` property. - """ - if name not in self.param_names: - raise ValueError( - f"{name} is not a model parameter. All placeholder variables should correspond to model " - f"parameters." - ) - - if name in self._name_to_variable.keys(): - raise ValueError( - f"{name} is already a registered placeholder variable with shape " - f"{self._name_to_variable[name].type.shape}" - ) - - placeholder = pt.tensor(name, shape=shape, dtype=dtype) - self._name_to_variable[name] = placeholder - return placeholder - - def make_and_register_data(self, name, shape, dtype=floatX) -> Variable: - r""" - Helper function to create a pytensor symbolic variable and register it in the _name_to_data dictionary - - Parameters - ---------- - name : str - The name of the placeholder data. Must be the name of an expected data variable. - shape : int or tuple of int - Shape of the parameter - dtype : str, default pytensor.config.floatX - dtype of the parameter - - Notes - ----- - See docstring for make_and_register_variable for more details. This function is similar, but handles data - inputs instead of model parameters. - - An error is raised if the provided name has already been registered, or if the name is not present in the - ``data_names`` property. - """ - if name not in self.data_names: - raise ValueError( - f"{name} is not a model parameter. All placeholder variables should correspond to model " - f"parameters." - ) - - if name in self._name_to_data.keys(): - raise ValueError( - f"{name} is already a registered placeholder variable with shape " - f"{self._name_to_data[name].type.shape}" - ) - - placeholder = pt.tensor(name, shape=shape, dtype=dtype) - self._name_to_data[name] = placeholder - return placeholder - - def make_symbolic_graph(self) -> None: - raise NotImplementedError - - def populate_component_properties(self): - raise NotImplementedError - - def _get_combined_shapes(self, other): - k_states = self.k_states + other.k_states - k_posdef = self.k_posdef + other.k_posdef - if self.k_endog != other.k_endog: - raise NotImplementedError( - "Merging elements with different numbers of observed states is not supported.>" - ) - k_endog = self.k_endog - - return k_states, k_posdef, k_endog - - def _combine_statespace_representations(self, other): - def make_slice(name, x, o_x): - ndim = max(x.ndim, o_x.ndim) - return (name,) + (slice(None, None, None),) * ndim - - k_states, k_posdef, k_endog = self._get_combined_shapes(other) - - self_matrices = [self.ssm[name] for name in LONG_MATRIX_NAMES] - other_matrices = [other.ssm[name] for name in LONG_MATRIX_NAMES] - - x0, P0, c, d, T, Z, R, H, Q = ( - self.ssm[make_slice(name, x, o_x)] - for name, x, o_x in zip(LONG_MATRIX_NAMES, self_matrices, other_matrices) - ) - o_x0, o_P0, o_c, o_d, o_T, o_Z, o_R, o_H, o_Q = ( - other.ssm[make_slice(name, x, o_x)] - for name, x, o_x in zip(LONG_MATRIX_NAMES, self_matrices, other_matrices) - ) - - initial_state = pt.concatenate(conform_time_varying_and_time_invariant_matrices(x0, o_x0)) - initial_state.name = x0.name - - initial_state_cov = pt.linalg.block_diag(P0, o_P0) - initial_state_cov.name = P0.name - - state_intercept = pt.concatenate(conform_time_varying_and_time_invariant_matrices(c, o_c)) - state_intercept.name = c.name - - obs_intercept = d + o_d - obs_intercept.name = d.name - - transition = pt.linalg.block_diag(T, o_T) - transition.name = T.name - - design = pt.concatenate(conform_time_varying_and_time_invariant_matrices(Z, o_Z), axis=-1) - design.name = Z.name - - selection = pt.linalg.block_diag(R, o_R) - selection.name = R.name - - obs_cov = H + o_H - obs_cov.name = H.name - - state_cov = pt.linalg.block_diag(Q, o_Q) - state_cov.name = Q.name - - new_ssm = PytensorRepresentation( - k_endog=k_endog, - k_states=k_states, - k_posdef=k_posdef, - initial_state=initial_state, - initial_state_cov=initial_state_cov, - state_intercept=state_intercept, - obs_intercept=obs_intercept, - transition=transition, - design=design, - selection=selection, - obs_cov=obs_cov, - state_cov=state_cov, - ) - - return new_ssm - - def _combine_property(self, other, name): - self_prop = getattr(self, name) - if isinstance(self_prop, list): - return self_prop + getattr(other, name) - elif isinstance(self_prop, dict): - new_prop = self_prop.copy() - new_prop.update(getattr(other, name)) - return new_prop - - def _combine_component_info(self, other): - combined_info = {} - for key, value in self._component_info.items(): - if not key.startswith("StateSpace"): - if key in combined_info.keys(): - raise ValueError(f"Found duplicate component named {key}") - combined_info[key] = value - - for key, value in other._component_info.items(): - if not key.startswith("StateSpace"): - if key in combined_info.keys(): - raise ValueError(f"Found duplicate component named {key}") - combined_info[key] = value - - return combined_info - - def _make_combined_name(self): - components = self._component_info.keys() - name = f'StateSpace[{", ".join(components)}]' - return name - - def __add__(self, other): - state_names = self._combine_property(other, "state_names") - data_names = self._combine_property(other, "data_names") - param_names = self._combine_property(other, "param_names") - shock_names = self._combine_property(other, "shock_names") - param_info = self._combine_property(other, "param_info") - data_info = self._combine_property(other, "data_info") - param_dims = self._combine_property(other, "param_dims") - coords = self._combine_property(other, "coords") - exog_names = self._combine_property(other, "exog_names") - - _name_to_variable = self._combine_property(other, "_name_to_variable") - _name_to_data = self._combine_property(other, "_name_to_data") - - measurement_error = any([self.measurement_error, other.measurement_error]) - - k_states, k_posdef, k_endog = self._get_combined_shapes(other) - ssm = self._combine_statespace_representations(other) - - new_comp = Component( - name="", - k_endog=1, - k_states=k_states, - k_posdef=k_posdef, - measurement_error=measurement_error, - representation=ssm, - component_from_sum=True, - ) - new_comp._component_info = self._combine_component_info(other) - new_comp.name = new_comp._make_combined_name() - - names_and_props = [ - ("state_names", state_names), - ("data_names", data_names), - ("param_names", param_names), - ("shock_names", shock_names), - ("param_dims", param_dims), - ("coords", coords), - ("param_dims", param_dims), - ("param_info", param_info), - ("data_info", data_info), - ("exog_names", exog_names), - ("_name_to_variable", _name_to_variable), - ("_name_to_data", _name_to_data), - ] - - for prop, value in names_and_props: - setattr(new_comp, prop, value) - - return new_comp - - def build( - self, name=None, filter_type="standard", verbose=True, mode: str | Mode | None = None - ): - """ - Build a StructuralTimeSeries statespace model from the current component(s) - - Parameters - ---------- - name: str, optional - Name of the exogenous data being modeled. Default is "data" - - filter_type : str, optional - The type of Kalman filter to use. Valid options are "standard", "univariate", "single", "cholesky", and - "steady_state". For more information, see the docs for each filter. Default is "standard". - - verbose : bool, optional - If True, displays information about the initialized model. Defaults to True. - - mode: str or Mode, optional - Pytensor compile mode, used in auxiliary sampling methods such as ``sample_conditional_posterior`` and - ``forecast``. The mode does **not** effect calls to ``pm.sample``. - - Regardless of whether a mode is specified, it can always be overwritten via the ``compile_kwargs`` argument - to all sampling methods. - - Returns - ------- - PyMCStateSpace - An initialized instance of a PyMCStateSpace, constructed using the system matrices contained in the - components. - """ - - return StructuralTimeSeries( - self.ssm, - name=name, - state_names=self.state_names, - data_names=self.data_names, - shock_names=self.shock_names, - param_names=self.param_names, - param_dims=self.param_dims, - coords=self.coords, - param_info=self.param_info, - data_info=self.data_info, - component_info=self._component_info, - measurement_error=self.measurement_error, - exog_names=self.exog_names, - name_to_variable=self._name_to_variable, - name_to_data=self._name_to_data, - filter_type=filter_type, - verbose=verbose, - mode=mode, - ) - - -class LevelTrendComponent(Component): - r""" - Level and trend component of a structural time series model - - Parameters - ---------- - __________ - order : int - - Number of time derivatives of the trend to include in the model. For example, when order=3, the trend will - be of the form ``y = a + b * t + c * t ** 2``, where the coefficients ``a, b, c`` come from the initial - state values. - - innovations_order : int or sequence of int, optional - - The number of stochastic innovations to include in the model. By default, ``innovations_order = order`` - - Notes - ----- - This class implements the level and trend components of the general structural time series model. In the most - general form, the level and trend is described by a system of two time-varying equations. - - .. math:: - \begin{align} - \mu_{t+1} &= \mu_t + \nu_t + \zeta_t \\ - \nu_{t+1} &= \nu_t + \xi_t - \zeta_t &\sim N(0, \sigma_\zeta) \\ - \xi_t &\sim N(0, \sigma_\xi) - \end{align} - - Where :math:`\mu_{t+1}` is the mean of the timeseries at time t, and :math:`\nu_t` is the drift or the slope of - the process. When both innovations :math:`\zeta_t` and :math:`\xi_t` are included in the model, it is known as a - *local linear trend* model. This system of two equations, corresponding to ``order=2``, can be expanded or - contracted by adding or removing equations. ``order=3`` would add an acceleration term to the sytsem: - - .. math:: - \begin{align} - \mu_{t+1} &= \mu_t + \nu_t + \zeta_t \\ - \nu_{t+1} &= \nu_t + \eta_t + \xi_t \\ - \eta_{t+1} &= \eta_{t-1} + \omega_t \\ - \zeta_t &\sim N(0, \sigma_\zeta) \\ - \xi_t &\sim N(0, \sigma_\xi) \\ - \omega_t &\sim N(0, \sigma_\omega) - \end{align} - - After setting all innovation terms to zero and defining initial states :math:`\mu_0, \nu_0, \eta_0`, these equations - can be collapsed to: - - .. math:: - \mu_t = \mu_0 + \nu_0 \cdot t + \eta_0 \cdot t^2 - - Which clarifies how the order and initial states influence the model. In particular, the initial states are the - coefficients on the intercept, slope, acceleration, and so on. - - In this light, allowing for innovations can be understood as allowing these coefficients to vary over time. Each - component can be individually selected for time variation by passing a list to the ``innovations_order`` argument. - For example, a constant intercept with time varying trend and acceleration is specified as ``order=3, - innovations_order=[0, 1, 1]``. - - By choosing the ``order`` and ``innovations_order``, a large variety of models can be obtained. Notable - models include: - - * Constant intercept, ``order=1, innovations_order=0`` - - .. math:: - \mu_t = \mu - - * Constant linear slope, ``order=2, innovations_order=0`` - - .. math:: - \mu_t = \mu_{t-1} + \nu - - * Gaussian Random Walk, ``order=1, innovations_order=1`` - - .. math:: - \mu_t = \mu_{t-1} + \zeta_t - - * Gaussian Random Walk with Drift, ``order=2, innovations_order=1`` - - .. math:: - \mu_t = \mu_{t-1} + \nu + \zeta_t - - * Smooth Trend, ``order=2, innovations_order=[0, 1]`` - - .. math:: - \begin{align} - \mu_t &= \mu_{t-1} + \nu_{t-1} \\ - \nu_t &= \nu_{t-1} + \xi_t - \end{align} - - * Local Level, ``order=2, innovations_order=2`` - - [1] notes that the smooth trend model produces more gradually changing slopes than the full local linear trend - model, and is equivalent to an "integrated trend model". - - References - ---------- - .. [1] Durbin, James, and Siem Jan Koopman. 2012. - Time Series Analysis by State Space Methods: Second Edition. - Oxford University Press. - - """ - - def __init__( - self, - order: int | list[int] = 2, - innovations_order: int | list[int] | None = None, - name: str = "LevelTrend", - ): - if innovations_order is None: - innovations_order = order - - self._order_mask = order_to_mask(order) - max_state = np.flatnonzero(self._order_mask)[-1].item() + 1 - - # If the user passes excess zeros, raise an error. The alternative is to prune them, but this would cause - # the shape of the state to be different to what the user expects. - if len(self._order_mask) > max_state: - raise ValueError( - f"order={order} is invalid. The highest derivative should not be set to zero. If you want a " - f"lower order model, explicitly omit the zeros." - ) - k_states = max_state - - if isinstance(innovations_order, int): - n = innovations_order - innovations_order = order_to_mask(k_states) - if n > 0: - innovations_order[n:] = False - else: - innovations_order[:] = False - else: - innovations_order = order_to_mask(innovations_order) - - self.innovations_order = innovations_order[:max_state] - k_posdef = int(sum(innovations_order)) - - super().__init__( - name, - k_endog=1, - k_states=k_states, - k_posdef=k_posdef, - measurement_error=False, - combine_hidden_states=False, - obs_state_idxs=np.array([1.0] + [0.0] * (k_states - 1)), - ) - - def populate_component_properties(self): - name_slice = POSITION_DERIVATIVE_NAMES[: self.k_states] - self.param_names = ["initial_trend"] - self.state_names = [name for name, mask in zip(name_slice, self._order_mask) if mask] - self.param_dims = {"initial_trend": ("trend_state",)} - self.coords = {"trend_state": self.state_names} - self.param_info = {"initial_trend": {"shape": (self.k_states,), "constraints": None}} - - if self.k_posdef > 0: - self.param_names += ["sigma_trend"] - self.shock_names = [ - name for name, mask in zip(name_slice, self.innovations_order) if mask - ] - self.param_dims["sigma_trend"] = ("trend_shock",) - self.coords["trend_shock"] = self.shock_names - self.param_info["sigma_trend"] = {"shape": (self.k_posdef,), "constraints": "Positive"} - - for name in self.param_names: - self.param_info[name]["dims"] = self.param_dims[name] - - def make_symbolic_graph(self) -> None: - initial_trend = self.make_and_register_variable("initial_trend", shape=(self.k_states,)) - self.ssm["initial_state", :] = initial_trend - triu_idx = np.triu_indices(self.k_states) - self.ssm[np.s_["transition", triu_idx[0], triu_idx[1]]] = 1 - - R = np.eye(self.k_states) - R = R[:, self.innovations_order] - self.ssm["selection", :, :] = R - - self.ssm["design", 0, :] = np.array([1.0] + [0.0] * (self.k_states - 1)) - - if self.k_posdef > 0: - sigma_trend = self.make_and_register_variable("sigma_trend", shape=(self.k_posdef,)) - diag_idx = np.diag_indices(self.k_posdef) - idx = np.s_["state_cov", diag_idx[0], diag_idx[1]] - self.ssm[idx] = sigma_trend**2 - - -class MeasurementError(Component): - r""" - Measurement error term for a structural timeseries model - - Parameters - ---------- - name: str, optional - - Name of the observed data. Default is "obs". - - Notes - ----- - This component should only be used in combination with other components, because it has no states. It's only use - is to add a variance parameter to the model, associated with the observation noise matrix H. - - Examples - -------- - Create and estimate a deterministic linear trend with measurement error - - .. code:: python - - from pymc_extras.statespace import structural as st - import pymc as pm - import pytensor.tensor as pt - - trend = st.LevelTrendComponent(order=2, innovations_order=0) - error = st.MeasurementError() - ss_mod = (trend + error).build() - - with pm.Model(coords=ss_mod.coords) as model: - P0 = pm.Deterministic('P0', pt.eye(ss_mod.k_states) * 10, dims=ss_mod.param_dims['P0']) - intitial_trend = pm.Normal('initial_trend', sigma=10, dims=ss_mod.param_dims['initial_trend']) - sigma_obs = pm.Exponential('sigma_obs', 1, dims=ss_mod.param_dims['sigma_obs']) - - ss_mod.build_statespace_graph(data) - idata = pm.sample(nuts_sampler='numpyro') - """ - - def __init__(self, name: str = "MeasurementError"): - k_endog = 1 - k_states = 0 - k_posdef = 0 - - super().__init__( - name, k_endog, k_states, k_posdef, measurement_error=True, combine_hidden_states=False - ) - - def populate_component_properties(self): - self.param_names = [f"sigma_{self.name}"] - self.param_dims = {} - self.param_info = { - f"sigma_{self.name}": { - "shape": (), - "constraints": "Positive", - "dims": None, - } - } - - def make_symbolic_graph(self) -> None: - sigma_shape = () - error_sigma = self.make_and_register_variable(f"sigma_{self.name}", shape=sigma_shape) - diag_idx = np.diag_indices(self.k_endog) - idx = np.s_["obs_cov", diag_idx[0], diag_idx[1]] - self.ssm[idx] = error_sigma**2 - - -class AutoregressiveComponent(Component): - r""" - Autoregressive timeseries component - - Parameters - ---------- - order: int or sequence of int - - If int, the number of lags to include in the model. - If a sequence, an array-like of zeros and ones indicating which lags to include in the model. - - Notes - ----- - An autoregressive component can be thought of as a way o introducing serially correlated errors into the model. - The process is modeled: - - .. math:: - x_t = \sum_{i=1}^p \rho_i x_{t-i} - - Where ``p``, the number of autoregressive terms to model, is the order of the process. By default, all lags up to - ``p`` are included in the model. To disable lags, pass a list of zeros and ones to the ``order`` argumnet. For - example, ``order=[1, 1, 0, 1]`` would become: - - .. math:: - x_t = \rho_1 x_{t-1} + \rho_2 x_{t-1} + \rho_4 x_{t-1} - - The coefficient :math:`\rho_3` has been constrained to zero. - - .. warning:: This class is meant to be used as a component in a structural time series model. For modeling of - stationary processes with ARIMA, use ``statespace.BayesianSARIMA``. - - Examples - -------- - Model a timeseries as an AR(2) process with non-zero mean: - - .. code:: python - - from pymc_extras.statespace import structural as st - import pymc as pm - import pytensor.tensor as pt - - trend = st.LevelTrendComponent(order=1, innovations_order=0) - ar = st.AutoregressiveComponent(2) - ss_mod = (trend + ar).build() - - with pm.Model(coords=ss_mod.coords) as model: - P0 = pm.Deterministic('P0', pt.eye(ss_mod.k_states) * 10, dims=ss_mod.param_dims['P0']) - intitial_trend = pm.Normal('initial_trend', sigma=10, dims=ss_mod.param_dims['initial_trend']) - ar_params = pm.Normal('ar_params', dims=ss_mod.param_dims['ar_params']) - sigma_ar = pm.Exponential('sigma_ar', 1, dims=ss_mod.param_dims['sigma_ar']) - - ss_mod.build_statespace_graph(data) - idata = pm.sample(nuts_sampler='numpyro') - - """ - - def __init__(self, order: int = 1, name: str = "AutoRegressive"): - order = order_to_mask(order) - ar_lags = np.flatnonzero(order).ravel().astype(int) + 1 - k_states = len(order) - - self.order = order - self.ar_lags = ar_lags - - super().__init__( - name=name, - k_endog=1, - k_states=k_states, - k_posdef=1, - measurement_error=True, - combine_hidden_states=True, - obs_state_idxs=np.r_[[1.0], np.zeros(k_states - 1)], - ) - - def populate_component_properties(self): - self.state_names = [f"L{i + 1}.data" for i in range(self.k_states)] - self.shock_names = [f"{self.name}_innovation"] - self.param_names = ["ar_params", "sigma_ar"] - self.param_dims = {"ar_params": (AR_PARAM_DIM,)} - self.coords = {AR_PARAM_DIM: self.ar_lags.tolist()} - - self.param_info = { - "ar_params": { - "shape": (self.k_states,), - "constraints": None, - "dims": (AR_PARAM_DIM,), - }, - "sigma_ar": {"shape": (), "constraints": "Positive", "dims": None}, - } - - def make_symbolic_graph(self) -> None: - k_nonzero = int(sum(self.order)) - ar_params = self.make_and_register_variable("ar_params", shape=(k_nonzero,)) - sigma_ar = self.make_and_register_variable("sigma_ar", shape=()) - - T = np.eye(self.k_states, k=-1) - self.ssm["transition", :, :] = T - self.ssm["selection", 0, 0] = 1 - self.ssm["design", 0, 0] = 1 - - ar_idx = ("transition", np.zeros(k_nonzero, dtype="int"), np.nonzero(self.order)[0]) - self.ssm[ar_idx] = ar_params - - cov_idx = ("state_cov", *np.diag_indices(1)) - self.ssm[cov_idx] = sigma_ar**2 - - -class TimeSeasonality(Component): - r""" - Seasonal component, modeled in the time domain - - Parameters - ---------- - season_length: int - The number of periods in a single seasonal cycle, e.g. 12 for monthly data with annual seasonal pattern, 7 for - daily data with weekly seasonal pattern, etc. - - innovations: bool, default True - Whether to include stochastic innovations in the strength of the seasonal effect - - name: str, default None - A name for this seasonal component. Used to label dimensions and coordinates. Useful when multiple seasonal - components are included in the same model. Default is ``f"Seasonal[s={season_length}]"`` - - state_names: list of str, default None - List of strings for seasonal effect labels. If provided, it must be of length ``season_length``. An example - would be ``state_names = ['Mon', 'Tue', 'Wed', 'Thur', 'Fri', 'Sat', 'Sun']`` when data is daily with a weekly - seasonal pattern (``season_length = 7``). - - If None, states will be numbered ``[State_0, ..., State_s]`` - - remove_first_state: bool, default True - If True, the first state will be removed from the model. This is done because there are only n-1 degrees of - freedom in the seasonal component, and one state is not identified. If False, the first state will be - included in the model, but it will not be identified -- you will need to handle this in the priors (e.g. with - ZeroSumNormal). - - Notes - ----- - A seasonal effect is any pattern that repeats every fixed interval. Although there are many possible ways to - model seasonal effects, the implementation used here is the one described by [1] as the "canonical" time domain - representation. The seasonal component can be expressed: - - .. math:: - \gamma_t = -\sum_{i=1}^{s-1} \gamma_{t-i} + \omega_t, \quad \omega_t \sim N(0, \sigma_\gamma) - - Where :math:`s` is the ``seasonal_length`` parameter and :math:`\omega_t` is the (optional) stochastic innovation. - To give interpretation to the :math:`\gamma` terms, it is helpful to work through the algebra for a simple - example. Let :math:`s=4`, and omit the shock term. Define initial conditions :math:`\gamma_0, \gamma_{-1}, - \gamma_{-2}`. The value of the seasonal component for the first 5 timesteps will be: - - .. math:: - \begin{align} - \gamma_1 &= -\gamma_0 - \gamma_{-1} - \gamma_{-2} \\ - \gamma_2 &= -\gamma_1 - \gamma_0 - \gamma_{-1} \\ - &= -(-\gamma_0 - \gamma_{-1} - \gamma_{-2}) - \gamma_0 - \gamma_{-1} \\ - &= (\gamma_0 - \gamma_0 )+ (\gamma_{-1} - \gamma_{-1}) + \gamma_{-2} \\ - &= \gamma_{-2} \\ - \gamma_3 &= -\gamma_2 - \gamma_1 - \gamma_0 \\ - &= -\gamma_{-2} - (-\gamma_0 - \gamma_{-1} - \gamma_{-2}) - \gamma_0 \\ - &= (\gamma_{-2} - \gamma_{-2}) + \gamma_{-1} + (\gamma_0 - \gamma_0) \\ - &= \gamma_{-1} \\ - \gamma_4 &= -\gamma_3 - \gamma_2 - \gamma_1 \\ - &= -\gamma_{-1} - \gamma_{-2} -(-\gamma_0 - \gamma_{-1} - \gamma_{-2}) \\ - &= (\gamma_{-2} - \gamma_{-2}) + (\gamma_{-1} - \gamma_{-1}) + \gamma_0 \\ - &= \gamma_0 \\ - \gamma_5 &= -\gamma_4 - \gamma_3 - \gamma_2 \\ - &= -\gamma_0 - \gamma_{-1} - \gamma_{-2} \\ - &= \gamma_1 - \end{align} - - This exercise shows that, given a list ``initial_conditions`` of length ``s-1``, the effects of this model will be: - - - Period 1: ``-sum(initial_conditions)`` - - Period 2: ``initial_conditions[-1]`` - - Period 3: ``initial_conditions[-2]`` - - ... - - Period s: ``initial_conditions[0]`` - - Period s+1: ``-sum(initial_condition)`` - - And so on. So for interpretation, the ``season_length - 1`` initial states are, when reversed, the coefficients - associated with ``state_names[1:]``. - - .. warning:: - Although the ``state_names`` argument expects a list of length ``season_length``, only ``state_names[1:]`` - will be saved as model dimensions, since the 1st coefficient is not identified (it is defined as - :math:`-\sum_{i=1}^{s} \gamma_{t-i}`). - - Examples - -------- - Estimate monthly with a model with a gaussian random walk trend and monthly seasonality: - - .. code:: python - - from pymc_extras.statespace import structural as st - import pymc as pm - import pytensor.tensor as pt - import pandas as pd - - # Get month names - state_names = pd.date_range('1900-01-01', '1900-12-31', freq='MS').month_name().tolist() - - # Build the structural model - grw = st.LevelTrendComponent(order=1, innovations_order=1) - annual_season = st.TimeSeasonality(season_length=12, name='annual', state_names=state_names, innovations=False) - ss_mod = (grw + annual_season).build() - - # Estimate with PyMC - with pm.Model(coords=ss_mod.coords) as model: - P0 = pm.Deterministic('P0', pt.eye(ss_mod.k_states) * 10, dims=ss_mod.param_dims['P0']) - intitial_trend = pm.Deterministic('initial_trend', pt.zeros(1), dims=ss_mod.param_dims['initial_trend']) - annual_coefs = pm.Normal('annual_coefs', sigma=1e-2, dims=ss_mod.param_dims['annual_coefs']) - trend_sigmas = pm.HalfNormal('trend_sigmas', sigma=1e-6, dims=ss_mod.param_dims['trend_sigmas']) - ss_mod.build_statespace_graph(data) - idata = pm.sample(nuts_sampler='numpyro') - - References - ---------- - .. [1] Durbin, James, and Siem Jan Koopman. 2012. - Time Series Analysis by State Space Methods: Second Edition. - Oxford University Press. - """ - - def __init__( - self, - season_length: int, - innovations: bool = True, - name: str | None = None, - state_names: list | None = None, - remove_first_state: bool = True, - ): - if name is None: - name = f"Seasonal[s={season_length}]" - if state_names is None: - state_names = [f"{name}_{i}" for i in range(season_length)] - else: - if len(state_names) != season_length: - raise ValueError( - f"state_names must be a list of length season_length, got {len(state_names)}" - ) - state_names = state_names.copy() - self.innovations = innovations - self.remove_first_state = remove_first_state - - if self.remove_first_state: - # In traditional models, the first state isn't identified, so we can help out the user by automatically - # discarding it. - # TODO: Can this be stashed and reconstructed automatically somehow? - state_names.pop(0) - - k_states = season_length - int(self.remove_first_state) - - super().__init__( - name=name, - k_endog=1, - k_states=k_states, - k_posdef=int(innovations), - state_names=state_names, - measurement_error=False, - combine_hidden_states=True, - obs_state_idxs=np.r_[[1.0], np.zeros(k_states - 1)], - ) - - def populate_component_properties(self): - self.param_names = [f"{self.name}_coefs"] - self.param_info = { - f"{self.name}_coefs": { - "shape": (self.k_states,), - "constraints": None, - "dims": (f"{self.name}_state",), - } - } - self.param_dims = {f"{self.name}_coefs": (f"{self.name}_state",)} - self.coords = {f"{self.name}_state": self.state_names} - - if self.innovations: - self.param_names += [f"sigma_{self.name}"] - self.param_info[f"sigma_{self.name}"] = { - "shape": (), - "constraints": "Positive", - "dims": None, - } - self.shock_names = [f"{self.name}"] - - def make_symbolic_graph(self) -> None: - if self.remove_first_state: - # In this case, parameters are normalized to sum to zero, so the current state is the negative sum of - # all previous states. - T = np.eye(self.k_states, k=-1) - T[0, :] = -1 - else: - # In this case we assume the user to be responsible for ensuring the states sum to zero, so T is just a - # circulant matrix that cycles between the states. - T = np.eye(self.k_states, k=1) - T[-1, 0] = 1 - - self.ssm["transition", :, :] = T - self.ssm["design", 0, 0] = 1 - - initial_states = self.make_and_register_variable( - f"{self.name}_coefs", shape=(self.k_states,) - ) - self.ssm["initial_state", np.arange(self.k_states, dtype=int)] = initial_states - - if self.innovations: - self.ssm["selection", 0, 0] = 1 - season_sigma = self.make_and_register_variable(f"sigma_{self.name}", shape=()) - cov_idx = ("state_cov", *np.diag_indices(1)) - self.ssm[cov_idx] = season_sigma**2 - - -class FrequencySeasonality(Component): - r""" - Seasonal component, modeled in the frequency domain - - Parameters - ---------- - season_length: float - The number of periods in a single seasonal cycle, e.g. 12 for monthly data with annual seasonal pattern, 7 for - daily data with weekly seasonal pattern, etc. Non-integer seasonal_length is also permitted, for example - 365.2422 days in a (solar) year. - - n: int - Number of fourier features to include in the seasonal component. Default is ``season_length // 2``, which - is the maximum possible. A smaller number can be used for a more wave-like seasonal pattern. - - name: str, default None - A name for this seasonal component. Used to label dimensions and coordinates. Useful when multiple seasonal - components are included in the same model. Default is ``f"Seasonal[s={season_length}, n={n}]"`` - - innovations: bool, default True - Whether to include stochastic innovations in the strength of the seasonal effect - - Notes - ----- - A seasonal effect is any pattern that repeats every fixed interval. Although there are many possible ways to - model seasonal effects, the implementation used here is the one described by [1] as the "canonical" frequency domain - representation. The seasonal component can be expressed: - - .. math:: - \begin{align} - \gamma_t &= \sum_{j=1}^{2n} \gamma_{j,t} \\ - \gamma_{j, t+1} &= \gamma_{j,t} \cos \lambda_j + \gamma_{j,t}^\star \sin \lambda_j + \omega_{j, t} \\ - \gamma_{j, t}^\star &= -\gamma_{j,t} \sin \lambda_j + \gamma_{j,t}^\star \cos \lambda_j + \omega_{j,t}^\star - \lambda_j &= \frac{2\pi j}{s} - \end{align} - - Where :math:`s` is the ``seasonal_length``. - - Unlike a ``TimeSeasonality`` component, a ``FrequencySeasonality`` component does not require integer season - length. In addition, for long seasonal periods, it is possible to obtain a more compact state space representation - by choosing ``n << s // 2``. Using ``TimeSeasonality``, an annual seasonal pattern in daily data requires 364 - states, whereas ``FrequencySeasonality`` always requires ``2 * n`` states, regardless of the ``seasonal_length``. - The price of this compactness is less representational power. At ``n = 1``, the seasonal pattern will be a pure - sine wave. At ``n = s // 2``, any arbitrary pattern can be represented. - - One cost of the added flexibility of ``FrequencySeasonality`` is reduced interpretability. States of this model are - coefficients :math:`\gamma_1, \gamma^\star_1, \gamma_2, \gamma_2^\star ..., \gamma_n, \gamma^\star_n` associated - with different frequencies in the fourier representation of the seasonal pattern. As a result, it is not possible - to isolate and identify a "Monday" effect, for instance. - """ - - def __init__(self, season_length, n=None, name=None, innovations=True): - if n is None: - n = int(season_length // 2) - if name is None: - name = f"Frequency[s={season_length}, n={n}]" - - k_states = n * 2 - self.n = n - self.season_length = season_length - self.innovations = innovations - - # If the model is completely saturated (n = s // 2), the last state will not be identified, so it shouldn't - # get a parameter assigned to it and should just be fixed to zero. - # Test this way (rather than n == s // 2) to catch cases when n is non-integer. - self.last_state_not_identified = self.season_length / self.n == 2.0 - self.n_coefs = k_states - int(self.last_state_not_identified) - - obs_state_idx = np.zeros(k_states) - obs_state_idx[slice(0, k_states, 2)] = 1 - - super().__init__( - name=name, - k_endog=1, - k_states=k_states, - k_posdef=k_states * int(self.innovations), - measurement_error=False, - combine_hidden_states=True, - obs_state_idxs=obs_state_idx, - ) - - def make_symbolic_graph(self) -> None: - self.ssm["design", 0, slice(0, self.k_states, 2)] = 1 - - init_state = self.make_and_register_variable(f"{self.name}", shape=(self.n_coefs,)) - - init_state_idx = np.arange(self.n_coefs, dtype=int) - self.ssm["initial_state", init_state_idx] = init_state - - T_mats = [_frequency_transition_block(self.season_length, j + 1) for j in range(self.n)] - T = pt.linalg.block_diag(*T_mats) - self.ssm["transition", :, :] = T - - if self.innovations: - sigma_season = self.make_and_register_variable(f"sigma_{self.name}", shape=()) - self.ssm["state_cov", :, :] = pt.eye(self.k_posdef) * sigma_season**2 - self.ssm["selection", :, :] = np.eye(self.k_states) - - def populate_component_properties(self): - self.state_names = [f"{self.name}_{f}_{i}" for i in range(self.n) for f in ["Cos", "Sin"]] - self.param_names = [f"{self.name}"] - - self.param_dims = {self.name: (f"{self.name}_state",)} - self.param_info = { - f"{self.name}": { - "shape": (self.k_states - int(self.last_state_not_identified),), - "constraints": None, - "dims": (f"{self.name}_state",), - } - } - - init_state_idx = np.arange(self.k_states, dtype=int) - if self.last_state_not_identified: - init_state_idx = init_state_idx[:-1] - self.coords = {f"{self.name}_state": [self.state_names[i] for i in init_state_idx]} - - if self.innovations: - self.shock_names = self.state_names.copy() - self.param_names += [f"sigma_{self.name}"] - self.param_info[f"sigma_{self.name}"] = { - "shape": (), - "constraints": "Positive", - "dims": None, - } - - -class CycleComponent(Component): - r""" - A component for modeling longer-term cyclical effects - - Parameters - ---------- - name: str - Name of the component. Used in generated coordinates and state names. If None, a descriptive name will be - used. - - cycle_length: int, optional - The length of the cycle, in the calendar units of your data. For example, if your data is monthly, and you - want to model a 12-month cycle, use ``cycle_length=12``. You cannot specify both ``cycle_length`` and - ``estimate_cycle_length``. - - estimate_cycle_length: bool, default False - Whether to estimate the cycle length. If True, an additional parameter, ``cycle_length`` will be added to the - model. You cannot specify both ``cycle_length`` and ``estimate_cycle_length``. - - dampen: bool, default False - Whether to dampen the cycle by multiplying by a dampening factor :math:`\rho` at every timestep. If true, - an additional parameter, ``dampening_factor`` will be added to the model. - - innovations: bool, default True - Whether to include stochastic innovations in the strength of the seasonal effect. If True, an additional - parameter, ``sigma_{name}`` will be added to the model. - - Notes - ----- - The cycle component is very similar in implementation to the frequency domain seasonal component, expect that it - is restricted to n=1. The cycle component can be expressed: - - .. math:: - \begin{align} - \gamma_t &= \rho \gamma_{t-1} \cos \lambda + \rho \gamma_{t-1}^\star \sin \lambda + \omega_{t} \\ - \gamma_{t}^\star &= -\rho \gamma_{t-1} \sin \lambda + \rho \gamma_{t-1}^\star \cos \lambda + \omega_{t}^\star \\ - \lambda &= \frac{2\pi}{s} - \end{align} - - Where :math:`s` is the ``cycle_length``. [1] recommend that this component be used for longer term cyclical - effects, such as business cycles, and that the seasonal component be used for shorter term effects, such as - weekly or monthly seasonality. - - Unlike a FrequencySeasonality component, the length of a CycleComponent can be estimated. - - Examples - -------- - Estimate a business cycle with length between 6 and 12 years: - - .. code:: python - - from pymc_extras.statespace import structural as st - import pymc as pm - import pytensor.tensor as pt - import pandas as pd - import numpy as np - - data = np.random.normal(size=(100, 1)) - - # Build the structural model - grw = st.LevelTrendComponent(order=1, innovations_order=1) - cycle = st.CycleComponent('business_cycle', estimate_cycle_length=True, dampen=False) - ss_mod = (grw + cycle).build() - - # Estimate with PyMC - with pm.Model(coords=ss_mod.coords) as model: - P0 = pm.Deterministic('P0', pt.eye(ss_mod.k_states), dims=ss_mod.param_dims['P0']) - intitial_trend = pm.Normal('initial_trend', dims=ss_mod.param_dims['initial_trend']) - sigma_trend = pm.HalfNormal('sigma_trend', dims=ss_mod.param_dims['sigma_trend']) - - cycle_strength = pm.Normal('business_cycle') - cycle_length = pm.Uniform('business_cycle_length', lower=6, upper=12) - - sigma_cycle = pm.HalfNormal('sigma_business_cycle', sigma=1) - ss_mod.build_statespace_graph(data) - - idata = pm.sample(nuts_sampler='numpyro') - - References - ---------- - .. [1] Durbin, James, and Siem Jan Koopman. 2012. - Time Series Analysis by State Space Methods: Second Edition. - Oxford University Press. - """ - - def __init__( - self, - name: str | None = None, - cycle_length: int | None = None, - estimate_cycle_length: bool = False, - dampen: bool = False, - innovations: bool = True, - ): - if cycle_length is None and not estimate_cycle_length: - raise ValueError("Must specify cycle_length if estimate_cycle_length is False") - if cycle_length is not None and estimate_cycle_length: - raise ValueError("Cannot specify cycle_length if estimate_cycle_length is True") - if name is None: - cycle = int(cycle_length) if cycle_length is not None else "Estimate" - name = f"Cycle[s={cycle}, dampen={dampen}, innovations={innovations}]" - - self.estimate_cycle_length = estimate_cycle_length - self.cycle_length = cycle_length - self.innovations = innovations - self.dampen = dampen - self.n_coefs = 1 - - k_states = 2 - k_endog = 1 - k_posdef = 2 - - obs_state_idx = np.zeros(k_states) - obs_state_idx[slice(0, k_states, 2)] = 1 - - super().__init__( - name=name, - k_endog=k_endog, - k_states=k_states, - k_posdef=k_posdef, - measurement_error=False, - combine_hidden_states=True, - obs_state_idxs=obs_state_idx, - ) - - def make_symbolic_graph(self) -> None: - self.ssm["design", 0, slice(0, self.k_states, 2)] = 1 - self.ssm["selection", :, :] = np.eye(self.k_states) - self.param_dims = {self.name: (f"{self.name}_state",)} - self.coords = {f"{self.name}_state": self.state_names} - - init_state = self.make_and_register_variable(f"{self.name}", shape=(self.k_states,)) - - self.ssm["initial_state", :] = init_state - - if self.estimate_cycle_length: - lamb = self.make_and_register_variable(f"{self.name}_length", shape=()) - else: - lamb = self.cycle_length - - if self.dampen: - rho = self.make_and_register_variable(f"{self.name}_dampening_factor", shape=()) - else: - rho = 1 - - T = rho * _frequency_transition_block(lamb, j=1) - self.ssm["transition", :, :] = T - - if self.innovations: - sigma_cycle = self.make_and_register_variable(f"sigma_{self.name}", shape=()) - self.ssm["state_cov", :, :] = pt.eye(self.k_posdef) * sigma_cycle**2 - - def populate_component_properties(self): - self.state_names = [f"{self.name}_{f}" for f in ["Cos", "Sin"]] - self.param_names = [f"{self.name}"] - - self.param_info = { - f"{self.name}": { - "shape": (2,), - "constraints": None, - "dims": (f"{self.name}_state",), - } - } - - if self.estimate_cycle_length: - self.param_names += [f"{self.name}_length"] - self.param_info[f"{self.name}_length"] = { - "shape": (), - "constraints": "Positive, non-zero", - "dims": None, - } - - if self.dampen: - self.param_names += [f"{self.name}_dampening_factor"] - self.param_info[f"{self.name}_dampening_factor"] = { - "shape": (), - "constraints": "0 < x ≤ 1", - "dims": None, - } - - if self.innovations: - self.param_names += [f"sigma_{self.name}"] - self.param_info[f"sigma_{self.name}"] = { - "shape": (), - "constraints": "Positive", - "dims": None, - } - self.shock_names = self.state_names.copy() - - -class RegressionComponent(Component): - def __init__( - self, - k_exog: int | None = None, - name: str | None = "Exogenous", - state_names: list[str] | None = None, - innovations=False, - ): - self.innovations = innovations - k_exog = self._handle_input_data(k_exog, state_names, name) - - k_states = k_exog - k_endog = 1 - k_posdef = k_exog - - super().__init__( - name=name, - k_endog=k_endog, - k_states=k_states, - k_posdef=k_posdef, - state_names=self.state_names, - measurement_error=False, - combine_hidden_states=False, - exog_names=[f"data_{name}"], - obs_state_idxs=np.ones(k_states), - ) - - @staticmethod - def _get_state_names(k_exog: int | None, state_names: list[str] | None, name: str): - if k_exog is None and state_names is None: - raise ValueError("Must specify at least one of k_exog or state_names") - if state_names is not None and k_exog is not None: - if len(state_names) != k_exog: - raise ValueError(f"Expected {k_exog} state names, found {len(state_names)}") - elif k_exog is None: - k_exog = len(state_names) - else: - state_names = [f"{name}_{i + 1}" for i in range(k_exog)] - - return k_exog, state_names - - def _handle_input_data(self, k_exog: int, state_names: list[str] | None, name) -> int: - k_exog, state_names = self._get_state_names(k_exog, state_names, name) - self.state_names = state_names - - return k_exog - - def make_symbolic_graph(self) -> None: - betas = self.make_and_register_variable(f"beta_{self.name}", shape=(self.k_states,)) - regression_data = self.make_and_register_data( - f"data_{self.name}", shape=(None, self.k_states) - ) - - self.ssm["initial_state", :] = betas - self.ssm["transition", :, :] = np.eye(self.k_states) - self.ssm["selection", :, :] = np.eye(self.k_states) - self.ssm["design"] = pt.expand_dims(regression_data, 1) - - if self.innovations: - sigma_beta = self.make_and_register_variable( - f"sigma_beta_{self.name}", (self.k_states,) - ) - row_idx, col_idx = np.diag_indices(self.k_states) - self.ssm["state_cov", row_idx, col_idx] = sigma_beta**2 - - def populate_component_properties(self) -> None: - self.shock_names = self.state_names - - self.param_names = [f"beta_{self.name}"] - self.data_names = [f"data_{self.name}"] - self.param_dims = { - f"beta_{self.name}": ("exog_state",), - } - - self.param_info = { - f"beta_{self.name}": { - "shape": (self.k_states,), - "constraints": None, - "dims": ("exog_state",), - }, - } - - self.data_info = { - f"data_{self.name}": { - "shape": (None, self.k_states), - "dims": (TIME_DIM, "exog_state"), - }, - } - self.coords = {"exog_state": self.state_names} - - if self.innovations: - self.param_names += [f"sigma_beta_{self.name}"] - self.param_dims[f"sigma_beta_{self.name}"] = "exog_state" - self.param_info[f"sigma_beta_{self.name}"] = { - "shape": (), - "constraints": "Positive", - "dims": ("exog_state",), - } diff --git a/pymc_extras/statespace/models/structural/__init__.py b/pymc_extras/statespace/models/structural/__init__.py new file mode 100644 index 000000000..57cb6d7ac --- /dev/null +++ b/pymc_extras/statespace/models/structural/__init__.py @@ -0,0 +1,21 @@ +from pymc_extras.statespace.models.structural.components.autoregressive import ( + AutoregressiveComponent, +) +from pymc_extras.statespace.models.structural.components.cycle import CycleComponent +from pymc_extras.statespace.models.structural.components.level_trend import LevelTrendComponent +from pymc_extras.statespace.models.structural.components.measurement_error import MeasurementError +from pymc_extras.statespace.models.structural.components.regression import RegressionComponent +from pymc_extras.statespace.models.structural.components.seasonality import ( + FrequencySeasonality, + TimeSeasonality, +) + +__all__ = [ + "LevelTrendComponent", + "MeasurementError", + "AutoregressiveComponent", + "TimeSeasonality", + "FrequencySeasonality", + "RegressionComponent", + "CycleComponent", +] diff --git a/pymc_extras/statespace/models/structural/components/__init__.py b/pymc_extras/statespace/models/structural/components/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/pymc_extras/statespace/models/structural/components/autoregressive.py b/pymc_extras/statespace/models/structural/components/autoregressive.py new file mode 100644 index 000000000..0a3dd0586 --- /dev/null +++ b/pymc_extras/statespace/models/structural/components/autoregressive.py @@ -0,0 +1,182 @@ +import numpy as np +import pytensor.tensor as pt + +from pymc_extras.statespace.models.structural.core import Component +from pymc_extras.statespace.models.structural.utils import order_to_mask +from pymc_extras.statespace.utils.constants import AR_PARAM_DIM + + +class AutoregressiveComponent(Component): + r""" + Autoregressive timeseries component + + Parameters + ---------- + order: int or sequence of int + + If int, the number of lags to include in the model. + If a sequence, an array-like of zeros and ones indicating which lags to include in the model. + + Notes + ----- + An autoregressive component can be thought of as a way o introducing serially correlated errors into the model. + The process is modeled: + + .. math:: + x_t = \sum_{i=1}^p \rho_i x_{t-i} + + Where ``p``, the number of autoregressive terms to model, is the order of the process. By default, all lags up to + ``p`` are included in the model. To disable lags, pass a list of zeros and ones to the ``order`` argumnet. For + example, ``order=[1, 1, 0, 1]`` would become: + + .. math:: + x_t = \rho_1 x_{t-1} + \rho_2 x_{t-1} + \rho_4 x_{t-1} + + The coefficient :math:`\rho_3` has been constrained to zero. + + .. warning:: This class is meant to be used as a component in a structural time series model. For modeling of + stationary processes with ARIMA, use ``statespace.BayesianSARIMA``. + + Examples + -------- + Model a timeseries as an AR(2) process with non-zero mean: + + .. code:: python + + from pymc_extras.statespace import structural as st + import pymc as pm + import pytensor.tensor as pt + + trend = st.LevelTrendComponent(order=1, innovations_order=0) + ar = st.AutoregressiveComponent(2) + ss_mod = (trend + ar).build() + + with pm.Model(coords=ss_mod.coords) as model: + P0 = pm.Deterministic('P0', pt.eye(ss_mod.k_states) * 10, dims=ss_mod.param_dims['P0']) + intitial_trend = pm.Normal('initial_trend', sigma=10, dims=ss_mod.param_dims['initial_trend']) + ar_params = pm.Normal('ar_params', dims=ss_mod.param_dims['ar_params']) + sigma_ar = pm.Exponential('sigma_ar', 1, dims=ss_mod.param_dims['sigma_ar']) + + ss_mod.build_statespace_graph(data) + idata = pm.sample(nuts_sampler='numpyro') + + """ + + def __init__( + self, + order: int = 1, + name: str = "auto_regressive", + observed_state_names: list[str] | None = None, + ): + if observed_state_names is None: + observed_state_names = ["data"] + + k_posdef = k_endog = len(observed_state_names) + + order = order_to_mask(order) + ar_lags = np.flatnonzero(order).ravel().astype(int) + 1 + k_states = len(order) + + self.order = order + self.ar_lags = ar_lags + + super().__init__( + name=name, + k_endog=k_endog, + k_states=k_states * k_endog, + k_posdef=k_posdef, + measurement_error=True, + combine_hidden_states=True, + observed_state_names=observed_state_names, + obs_state_idxs=np.tile(np.r_[[1.0], np.zeros(k_states - 1)], k_endog), + ) + + def populate_component_properties(self): + k_states = self.k_states // self.k_endog + + self.state_names = [ + f"L{i + 1}[{state_name}]" + for state_name in self.observed_state_names + for i in range(k_states) + ] + + self.shock_names = [f"{self.name}[{obs_name}]" for obs_name in self.observed_state_names] + self.param_names = [f"{self.name}_params", f"{self.name}_sigma"] + self.param_dims = {f"{self.name}_params": (f"{self.name}_lag",)} + self.coords = {f"{self.name}_lag": self.ar_lags.tolist()} + + if self.k_endog > 1: + self.param_dims[f"{self.name}_params"] = ( + f"{self.name}_endog", + AR_PARAM_DIM, + ) + self.param_dims[f"{self.name}_sigma"] = (f"{self.name}_endog",) + + self.coords[f"{self.name}_endog"] = self.observed_state_names + + self.param_info = { + f"{self.name}_params": { + "shape": (self.k_states,) if self.k_endog == 1 else (self.k_endog, self.k_states), + "constraints": None, + "dims": (AR_PARAM_DIM,) + if self.k_endog == 1 + else ( + f"{self.name}_endog", + AR_PARAM_DIM, + ), + }, + f"{self.name}_sigma": { + "shape": () if self.k_endog == 1 else (self.k_endog,), + "constraints": "Positive", + "dims": None if self.k_endog == 1 else (f"{self.name}_endog",), + }, + } + + def make_symbolic_graph(self) -> None: + k_endog = self.k_endog + k_states = self.k_states // k_endog + k_posdef = self.k_posdef + + k_nonzero = int(sum(self.order)) + ar_params = self.make_and_register_variable( + f"{self.name}_params", shape=(k_nonzero,) if k_endog == 1 else (k_endog, k_nonzero) + ) + sigma_ar = self.make_and_register_variable( + f"{self.name}_sigma", shape=() if k_endog == 1 else (k_endog,) + ) + + if k_endog == 1: + T = pt.eye(k_states, k=-1) + ar_idx = (np.zeros(k_nonzero, dtype="int"), np.nonzero(self.order)[0]) + T = T[ar_idx].set(ar_params) + + else: + transition_matrices = [] + + for i in range(k_endog): + T = pt.eye(k_states, k=-1) + ar_idx = (np.zeros(k_nonzero, dtype="int"), np.nonzero(self.order)[0]) + T = T[ar_idx].set(ar_params[i]) + transition_matrices.append(T) + T = pt.specify_shape( + pt.linalg.block_diag(*transition_matrices), (self.k_states, self.k_states) + ) + + self.ssm["transition", :, :] = T + + R = np.eye(k_states) + R_mask = np.full((k_states), False) + R_mask[0] = True + R = R[:, R_mask] + + self.ssm["selection", :, :] = pt.specify_shape( + pt.linalg.block_diag(*[R for _ in range(k_endog)]), (self.k_states, self.k_posdef) + ) + + Z = pt.zeros((1, k_states))[0, 0].set(1.0) + self.ssm["design", :, :] = pt.specify_shape( + pt.linalg.block_diag(*[Z for _ in range(k_endog)]), (self.k_endog, self.k_states) + ) + + cov_idx = ("state_cov", *np.diag_indices(k_posdef)) + self.ssm[cov_idx] = sigma_ar**2 diff --git a/pymc_extras/statespace/models/structural/components/cycle.py b/pymc_extras/statespace/models/structural/components/cycle.py new file mode 100644 index 000000000..1636c51b1 --- /dev/null +++ b/pymc_extras/statespace/models/structural/components/cycle.py @@ -0,0 +1,307 @@ +import numpy as np + +from pytensor import tensor as pt +from pytensor.tensor.slinalg import block_diag +from scipy import linalg + +from pymc_extras.statespace.models.structural.core import Component +from pymc_extras.statespace.models.structural.utils import _frequency_transition_block + + +class CycleComponent(Component): + r""" + A component for modeling longer-term cyclical effects + + Supports both univariate and multivariate time series. For multivariate time series, + each endogenous variable gets its own independent cycle component with separate + cosine/sine states and optional variable-specific innovation variances. + + Parameters + ---------- + name: str + Name of the component. Used in generated coordinates and state names. If None, a descriptive name will be + used. + + cycle_length: int, optional + The length of the cycle, in the calendar units of your data. For example, if your data is monthly, and you + want to model a 12-month cycle, use ``cycle_length=12``. You cannot specify both ``cycle_length`` and + ``estimate_cycle_length``. + + estimate_cycle_length: bool, default False + Whether to estimate the cycle length. If True, an additional parameter, ``cycle_length`` will be added to the + model. You cannot specify both ``cycle_length`` and ``estimate_cycle_length``. + + dampen: bool, default False + Whether to dampen the cycle by multiplying by a dampening factor :math:`\rho` at every timestep. If true, + an additional parameter, ``dampening_factor`` will be added to the model. + + innovations: bool, default True + Whether to include stochastic innovations in the strength of the seasonal effect. If True, an additional + parameter, ``sigma_{name}`` will be added to the model. + For multivariate time series, this is a vector (variable-specific innovation variances). + + observed_state_names: list[str], optional + Names of the observed state variables. For univariate time series, defaults to ``["data"]``. + For multivariate time series, specify a list of names for each endogenous variable. + + Notes + ----- + The cycle component is very similar in implementation to the frequency domain seasonal component, expect that it + is restricted to n=1. The cycle component can be expressed: + + .. math:: + \begin{align} + \gamma_t &= \rho \gamma_{t-1} \cos \lambda + \rho \gamma_{t-1}^\star \sin \lambda + \omega_{t} \\ + \gamma_{t}^\star &= -\rho \gamma_{t-1} \sin \lambda + \rho \gamma_{t-1}^\star \cos \lambda + \omega_{t}^\star \\ + \lambda &= \frac{2\pi}{s} + \end{align} + + Where :math:`s` is the ``cycle_length``. [1] recommend that this component be used for longer term cyclical + effects, such as business cycles, and that the seasonal component be used for shorter term effects, such as + weekly or monthly seasonality. + + Unlike a FrequencySeasonality component, the length of a CycleComponent can be estimated. + + **Multivariate Support:** + For multivariate time series with k endogenous variables, the component creates: + - 2k states (cosine and sine components for each variable) + - Block diagonal transition and selection matrices + - Variable-specific innovation variances (optional) + - Proper parameter shapes: (k, 2) for initial states, (k,) for innovation variances + + Examples + -------- + **Univariate Example:** + Estimate a business cycle with length between 6 and 12 years: + + .. code:: python + + from pymc_extras.statespace import structural as st + import pymc as pm + import pytensor.tensor as pt + import pandas as pd + import numpy as np + + data = np.random.normal(size=(100, 1)) + + # Build the structural model + grw = st.LevelTrendComponent(order=1, innovations_order=1) + cycle = st.CycleComponent('business_cycle', estimate_cycle_length=True, dampen=False) + ss_mod = (grw + cycle).build() + + # Estimate with PyMC + with pm.Model(coords=ss_mod.coords) as model: + P0 = pm.Deterministic('P0', pt.eye(ss_mod.k_states), dims=ss_mod.param_dims['P0']) + intitial_trend = pm.Normal('initial_trend', dims=ss_mod.param_dims['initial_trend']) + sigma_trend = pm.HalfNormal('sigma_trend', dims=ss_mod.param_dims['sigma_trend']) + + cycle_strength = pm.Normal("business_cycle", dims=ss_mod.param_dims["business_cycle"]) + cycle_length = pm.Uniform('business_cycle_length', lower=6, upper=12) + sigma_cycle = pm.HalfNormal('sigma_business_cycle', sigma=1) + + ss_mod.build_statespace_graph(data) + idata = pm.sample() + + **Multivariate Example:** + Model cycles for multiple economic indicators with variable-specific innovation variances: + + .. code:: python + + # Multivariate cycle component + cycle = st.CycleComponent( + name='business_cycle', + cycle_length=12, + estimate_cycle_length=False, + innovations=True, + dampen=True, + observed_state_names=['gdp', 'unemployment', 'inflation'] + ) + + # Build the model + ss_mod = cycle.build() + + # In PyMC model: + with pm.Model(coords=ss_mod.coords) as model: + P0 = pm.Deterministic("P0", pt.eye(ss_mod.k_states), dims=ss_mod.param_dims["P0"]) + # Initial states: shape (3, 2) for 3 variables, 2 states each + cycle_init = pm.Normal('business_cycle', dims=ss_mod.param_dims["business_cycle"]) + + # Dampening factor: scalar (shared across variables) + dampening = pm.Beta("business_cycle_dampening_factor", 2, 2) + + # Innovation variances: shape (3,) for variable-specific variances + sigma_cycle = pm.HalfNormal( + "sigma_business_cycle", dims=ss_mod.param_dims["sigma_business_cycle"] + ) + + ss_mod.build_statespace_graph(data) + idata = pm.sample() + + References + ---------- + .. [1] Durbin, James, and Siem Jan Koopman. 2012. + Time Series Analysis by State Space Methods: Second Edition. + Oxford University Press. + """ + + def __init__( + self, + name: str | None = None, + cycle_length: int | None = None, + estimate_cycle_length: bool = False, + dampen: bool = False, + innovations: bool = True, + observed_state_names: list[str] | None = None, + ): + if observed_state_names is None: + observed_state_names = ["data"] + + if cycle_length is None and not estimate_cycle_length: + raise ValueError("Must specify cycle_length if estimate_cycle_length is False") + if cycle_length is not None and estimate_cycle_length: + raise ValueError("Cannot specify cycle_length if estimate_cycle_length is True") + if name is None: + cycle = int(cycle_length) if cycle_length is not None else "Estimate" + name = f"Cycle[s={cycle}, dampen={dampen}, innovations={innovations}]" + + self.estimate_cycle_length = estimate_cycle_length + self.cycle_length = cycle_length + self.innovations = innovations + self.dampen = dampen + self.n_coefs = 1 + + k_endog = len(observed_state_names) + + k_states = 2 * k_endog + k_posdef = 2 * k_endog + + obs_state_idx = np.zeros(k_states) + obs_state_idx[slice(0, k_states, 2)] = 1 + + super().__init__( + name=name, + k_endog=k_endog, + k_states=k_states, + k_posdef=k_posdef, + measurement_error=False, + combine_hidden_states=True, + obs_state_idxs=obs_state_idx, + observed_state_names=observed_state_names, + ) + + def make_symbolic_graph(self) -> None: + if self.k_endog == 1: + self.ssm["design", 0, slice(0, self.k_states, 2)] = 1 + self.ssm["selection", :, :] = np.eye(self.k_states) + init_state = self.make_and_register_variable(f"{self.name}", shape=(self.k_states,)) + + else: + Z = np.array([1.0, 0.0]).reshape((1, -1)) + design_matrix = linalg.block_diag(*[Z for _ in range(self.k_endog)]) + self.ssm["design", :, :] = pt.as_tensor_variable(design_matrix) + + R = np.eye(2) # 2x2 identity for each cycle component + selection_matrix = linalg.block_diag(*[R for _ in range(self.k_endog)]) + self.ssm["selection", :, :] = pt.as_tensor_variable(selection_matrix) + + init_state = self.make_and_register_variable(f"{self.name}", shape=(self.k_endog, 2)) + + self.ssm["initial_state", :] = init_state.ravel() + + if self.estimate_cycle_length: + lamb = self.make_and_register_variable(f"{self.name}_length", shape=()) + else: + lamb = self.cycle_length + + if self.dampen: + rho = self.make_and_register_variable(f"{self.name}_dampening_factor", shape=()) + else: + rho = 1 + + T = rho * _frequency_transition_block(lamb, j=1) + if self.k_endog == 1: + self.ssm["transition", :, :] = T + else: + transition = block_diag(*[T for _ in range(self.k_endog)]) + self.ssm["transition"] = pt.specify_shape(transition, (self.k_states, self.k_states)) + + if self.innovations: + if self.k_endog == 1: + sigma_cycle = self.make_and_register_variable(f"sigma_{self.name}", shape=()) + self.ssm["state_cov", :, :] = pt.eye(self.k_posdef) * sigma_cycle**2 + else: + sigma_cycle = self.make_and_register_variable( + f"sigma_{self.name}", shape=(self.k_endog,) + ) + state_cov = block_diag( + *[pt.eye(2) * sigma_cycle[i] ** 2 for i in range(self.k_endog)] + ) + self.ssm["state_cov"] = pt.specify_shape(state_cov, (self.k_states, self.k_states)) + + def populate_component_properties(self): + if self.k_endog == 1: + self.state_names = [f"{self.name}_{f}" for f in ["Cos", "Sin"]] + else: + # For multivariate cycles, create state names for each observed state + self.state_names = [] + for var_name in self.observed_state_names: + self.state_names.extend([f"{self.name}_{var_name}_{f}" for f in ["Cos", "Sin"]]) + + self.param_names = [f"{self.name}"] + + if self.k_endog == 1: + self.param_dims = {self.name: (f"{self.name}_state",)} + self.coords = {f"{self.name}_state": self.state_names} + self.param_info = { + f"{self.name}": { + "shape": (2,), + "constraints": None, + "dims": (f"{self.name}_state",), + } + } + else: + self.param_dims = {self.name: (f"{self.name}_endog", f"{self.name}_state")} + self.coords = { + f"{self.name}_state": [f"{self.name}_Cos", f"{self.name}_Sin"], + f"{self.name}_endog": self.observed_state_names, + } + self.param_info = { + f"{self.name}": { + "shape": (self.k_endog, 2), + "constraints": None, + "dims": (f"{self.name}_endog", f"{self.name}_state"), + } + } + + if self.estimate_cycle_length: + self.param_names += [f"{self.name}_length"] + self.param_info[f"{self.name}_length"] = { + "shape": (), + "constraints": "Positive, non-zero", + "dims": None, + } + + if self.dampen: + self.param_names += [f"{self.name}_dampening_factor"] + self.param_info[f"{self.name}_dampening_factor"] = { + "shape": (), + "constraints": "0 < x ≤ 1", + "dims": None, + } + + if self.innovations: + self.param_names += [f"sigma_{self.name}"] + if self.k_endog == 1: + self.param_info[f"sigma_{self.name}"] = { + "shape": (), + "constraints": "Positive", + "dims": None, + } + else: + self.param_dims[f"sigma_{self.name}"] = (f"{self.name}_endog",) + self.param_info[f"sigma_{self.name}"] = { + "shape": (self.k_endog,), + "constraints": "Positive", + "dims": (f"{self.name}_endog",), + } + self.shock_names = self.state_names.copy() diff --git a/pymc_extras/statespace/models/structural/components/level_trend.py b/pymc_extras/statespace/models/structural/components/level_trend.py new file mode 100644 index 000000000..4a8418543 --- /dev/null +++ b/pymc_extras/statespace/models/structural/components/level_trend.py @@ -0,0 +1,250 @@ +import numpy as np +import pytensor.tensor as pt + +from pymc_extras.statespace.models.structural.core import Component +from pymc_extras.statespace.models.structural.utils import order_to_mask +from pymc_extras.statespace.utils.constants import POSITION_DERIVATIVE_NAMES + + +class LevelTrendComponent(Component): + r""" + Level and trend component of a structural time series model + + Parameters + ---------- + order : int + + Number of time derivatives of the trend to include in the model. For example, when order=3, the trend will + be of the form ``y = a + b * t + c * t ** 2``, where the coefficients ``a, b, c`` come from the initial + state values. + + innovations_order : int or sequence of int, optional + + The number of stochastic innovations to include in the model. By default, ``innovations_order = order`` + + Notes + ----- + This class implements the level and trend components of the general structural time series model. In the most + general form, the level and trend is described by a system of two time-varying equations. + + .. math:: + \begin{align} + \mu_{t+1} &= \mu_t + \nu_t + \zeta_t \\ + \nu_{t+1} &= \nu_t + \xi_t + \zeta_t &\sim N(0, \sigma_\zeta) \\ + \xi_t &\sim N(0, \sigma_\xi) + \end{align} + + Where :math:`\mu_{t+1}` is the mean of the timeseries at time t, and :math:`\nu_t` is the drift or the slope of + the process. When both innovations :math:`\zeta_t` and :math:`\xi_t` are included in the model, it is known as a + *local linear trend* model. This system of two equations, corresponding to ``order=2``, can be expanded or + contracted by adding or removing equations. ``order=3`` would add an acceleration term to the sytsem: + + .. math:: + \begin{align} + \mu_{t+1} &= \mu_t + \nu_t + \zeta_t \\ + \nu_{t+1} &= \nu_t + \eta_t + \xi_t \\ + \eta_{t+1} &= \eta_{t-1} + \omega_t \\ + \zeta_t &\sim N(0, \sigma_\zeta) \\ + \xi_t &\sim N(0, \sigma_\xi) \\ + \omega_t &\sim N(0, \sigma_\omega) + \end{align} + + After setting all innovation terms to zero and defining initial states :math:`\mu_0, \nu_0, \eta_0`, these equations + can be collapsed to: + + .. math:: + \mu_t = \mu_0 + \nu_0 \cdot t + \eta_0 \cdot t^2 + + Which clarifies how the order and initial states influence the model. In particular, the initial states are the + coefficients on the intercept, slope, acceleration, and so on. + + In this light, allowing for innovations can be understood as allowing these coefficients to vary over time. Each + component can be individually selected for time variation by passing a list to the ``innovations_order`` argument. + For example, a constant intercept with time varying trend and acceleration is specified as ``order=3, + innovations_order=[0, 1, 1]``. + + By choosing the ``order`` and ``innovations_order``, a large variety of models can be obtained. Notable + models include: + + * Constant intercept, ``order=1, innovations_order=0`` + + .. math:: + \mu_t = \mu + + * Constant linear slope, ``order=2, innovations_order=0`` + + .. math:: + \mu_t = \mu_{t-1} + \nu + + * Gaussian Random Walk, ``order=1, innovations_order=1`` + + .. math:: + \mu_t = \mu_{t-1} + \zeta_t + + * Gaussian Random Walk with Drift, ``order=2, innovations_order=1`` + + .. math:: + \mu_t = \mu_{t-1} + \nu + \zeta_t + + * Smooth Trend, ``order=2, innovations_order=[0, 1]`` + + .. math:: + \begin{align} + \mu_t &= \mu_{t-1} + \nu_{t-1} \\ + \nu_t &= \nu_{t-1} + \xi_t + \end{align} + + * Local Level, ``order=2, innovations_order=2`` + + [1] notes that the smooth trend model produces more gradually changing slopes than the full local linear trend + model, and is equivalent to an "integrated trend model". + + References + ---------- + .. [1] Durbin, James, and Siem Jan Koopman. 2012. + Time Series Analysis by State Space Methods: Second Edition. + Oxford University Press. + + """ + + def __init__( + self, + order: int | list[int] = 2, + innovations_order: int | list[int] | None = None, + name: str = "level_trend", + observed_state_names: list[str] | None = None, + ): + if innovations_order is None: + innovations_order = order + + if observed_state_names is None: + observed_state_names = ["data"] + k_endog = len(observed_state_names) + + self._order_mask = order_to_mask(order) + max_state = np.flatnonzero(self._order_mask)[-1].item() + 1 + + # If the user passes excess zeros, raise an error. The alternative is to prune them, but this would cause + # the shape of the state to be different to what the user expects. + if len(self._order_mask) > max_state: + raise ValueError( + f"order={order} is invalid. The highest derivative should not be set to zero. If you want a " + f"lower order model, explicitly omit the zeros." + ) + k_states = max_state + + if isinstance(innovations_order, int): + n = innovations_order + innovations_order = order_to_mask(k_states) + if n > 0: + innovations_order[n:] = False + else: + innovations_order[:] = False + else: + innovations_order = order_to_mask(innovations_order) + + self.innovations_order = innovations_order[:max_state] + k_posdef = int(sum(innovations_order)) + + super().__init__( + name, + k_endog=k_endog, + k_states=k_states * k_endog, + k_posdef=k_posdef * k_endog, + observed_state_names=observed_state_names, + measurement_error=False, + combine_hidden_states=False, + obs_state_idxs=np.tile(np.array([1.0] + [0.0] * (k_states - 1)), k_endog), + ) + + def populate_component_properties(self): + k_endog = self.k_endog + k_states = self.k_states // k_endog + k_posdef = self.k_posdef // k_endog + + name_slice = POSITION_DERIVATIVE_NAMES[:k_states] + self.param_names = [f"{self.name}_initial"] + base_names = [name for name, mask in zip(name_slice, self._order_mask) if mask] + self.state_names = [ + f"{name}[{obs_name}]" for obs_name in self.observed_state_names for name in base_names + ] + self.param_dims = {f"{self.name}_initial": (f"{self.name}_state",)} + self.coords = {f"{self.name}_state": base_names} + + if k_endog > 1: + self.param_dims[f"{self.name}_state"] = ( + f"{self.name}_endog", + f"{self.name}_state", + ) + self.param_dims = {f"{self.name}_initial": (f"{self.name}_endog", f"{self.name}_state")} + self.coords[f"{self.name}_endog"] = self.observed_state_names + + shape = (k_endog, k_states) if k_endog > 1 else (k_states,) + self.param_info = {f"{self.name}_initial": {"shape": shape, "constraints": None}} + + if self.k_posdef > 0: + self.param_names += [f"{self.name}_sigma"] + + shock_base_names = [ + name for name, mask in zip(name_slice, self.innovations_order) if mask + ] + self.shock_names = [ + f"{name}[{obs_name}]" + for obs_name in self.observed_state_names + for name in shock_base_names + ] + + self.param_dims[f"{self.name}_sigma"] = ( + (f"{self.name}_shock",) + if k_endog == 1 + else (f"{self.name}_endog", f"{self.name}_shock") + ) + self.coords[f"{self.name}_shock"] = self.shock_names + self.param_info[f"{self.name}_sigma"] = { + "shape": (k_posdef,) if k_endog == 1 else (k_endog, k_posdef), + "constraints": "Positive", + } + + for name in self.param_names: + self.param_info[name]["dims"] = self.param_dims[name] + + def make_symbolic_graph(self) -> None: + k_endog = self.k_endog + k_states = self.k_states // k_endog + k_posdef = self.k_posdef // k_endog + + initial_trend = self.make_and_register_variable( + f"{self.name}_initial", + shape=(k_states,) if k_endog == 1 else (k_endog, k_states), + ) + self.ssm["initial_state", :] = initial_trend.ravel() + + triu_idx = pt.triu_indices(k_states) + T = pt.zeros((k_states, k_states))[triu_idx[0], triu_idx[1]].set(1) + + self.ssm["transition", :, :] = pt.specify_shape( + pt.linalg.block_diag(*[T for _ in range(k_endog)]), (self.k_states, self.k_states) + ) + + R = np.eye(k_states) + R = R[:, self.innovations_order] + + self.ssm["selection", :, :] = pt.specify_shape( + pt.linalg.block_diag(*[R for _ in range(k_endog)]), (self.k_states, self.k_posdef) + ) + + Z = np.array([1.0] + [0.0] * (k_states - 1)).reshape((1, -1)) + + self.ssm["design", :, :] = pt.specify_shape( + pt.linalg.block_diag(*[Z for _ in range(k_endog)]), (self.k_endog, self.k_states) + ) + + if k_posdef > 0: + sigma_trend = self.make_and_register_variable( + f"{self.name}_sigma", + shape=(k_posdef,) if k_endog == 1 else (k_endog, k_posdef), + ) + diag_idx = np.diag_indices(k_posdef * k_endog) + idx = np.s_["state_cov", diag_idx[0], diag_idx[1]] + self.ssm[idx] = (sigma_trend**2).ravel() diff --git a/pymc_extras/statespace/models/structural/components/measurement_error.py b/pymc_extras/statespace/models/structural/components/measurement_error.py new file mode 100644 index 000000000..b62c8fce2 --- /dev/null +++ b/pymc_extras/statespace/models/structural/components/measurement_error.py @@ -0,0 +1,86 @@ +import numpy as np + +from pymc_extras.statespace.models.structural.core import Component + + +class MeasurementError(Component): + r""" + Measurement error term for a structural timeseries model + + Parameters + ---------- + name: str, optional + + Name of the observed data. Default is "obs". + + Notes + ----- + This component should only be used in combination with other components, because it has no states. It's only use + is to add a variance parameter to the model, associated with the observation noise matrix H. + + Examples + -------- + Create and estimate a deterministic linear trend with measurement error + + .. code:: python + + from pymc_extras.statespace import structural as st + import pymc as pm + import pytensor.tensor as pt + + trend = st.LevelTrendComponent(order=2, innovations_order=0) + error = st.MeasurementError() + ss_mod = (trend + error).build() + + with pm.Model(coords=ss_mod.coords) as model: + P0 = pm.Deterministic('P0', pt.eye(ss_mod.k_states) * 10, dims=ss_mod.param_dims['P0']) + intitial_trend = pm.Normal('initial_trend', sigma=10, dims=ss_mod.param_dims['initial_trend']) + sigma_obs = pm.Exponential('sigma_obs', 1, dims=ss_mod.param_dims['sigma_obs']) + + ss_mod.build_statespace_graph(data) + idata = pm.sample(nuts_sampler='numpyro') + """ + + def __init__( + self, name: str = "MeasurementError", observed_state_names: list[str] | None = None + ): + if observed_state_names is None: + observed_state_names = ["data"] + + k_endog = len(observed_state_names) + k_states = 0 + k_posdef = 0 + + super().__init__( + name, + k_endog, + k_states, + k_posdef, + measurement_error=True, + combine_hidden_states=False, + observed_state_names=observed_state_names, + ) + + def populate_component_properties(self): + self.param_names = [f"sigma_{self.name}"] + self.param_dims = {} + self.coords = {} + + if self.k_endog > 1: + self.param_dims[f"sigma_{self.name}"] = (f"endog_{self.name}",) + self.coords[f"endog_{self.name}"] = self.observed_state_names + + self.param_info = { + f"sigma_{self.name}": { + "shape": (self.k_endog,) if self.k_endog > 1 else (), + "constraints": "Positive", + "dims": (f"endog_{self.name}",) if self.k_endog > 1 else None, + } + } + + def make_symbolic_graph(self) -> None: + sigma_shape = () if self.k_endog == 1 else (self.k_endog,) + error_sigma = self.make_and_register_variable(f"sigma_{self.name}", shape=sigma_shape) + diag_idx = np.diag_indices(self.k_endog) + idx = np.s_["obs_cov", diag_idx[0], diag_idx[1]] + self.ssm[idx] = error_sigma**2 diff --git a/pymc_extras/statespace/models/structural/components/regression.py b/pymc_extras/statespace/models/structural/components/regression.py new file mode 100644 index 000000000..dd17da1fb --- /dev/null +++ b/pymc_extras/statespace/models/structural/components/regression.py @@ -0,0 +1,133 @@ +import numpy as np + +from pytensor import tensor as pt + +from pymc_extras.statespace.models.structural.core import Component +from pymc_extras.statespace.utils.constants import TIME_DIM + + +class RegressionComponent(Component): + def __init__( + self, + k_exog: int | None = None, + name: str | None = "regression", + state_names: list[str] | None = None, + observed_state_names: list[str] | None = None, + innovations=False, + ): + if observed_state_names is None: + observed_state_names = ["data"] + + self.innovations = innovations + k_exog = self._handle_input_data(k_exog, state_names, name) + + k_states = k_exog + k_endog = len(observed_state_names) + k_posdef = k_exog + + super().__init__( + name=name, + k_endog=k_endog, + k_states=k_states * k_endog, + k_posdef=k_posdef * k_endog, + state_names=self.state_names, + observed_state_names=observed_state_names, + measurement_error=False, + combine_hidden_states=False, + exog_names=[f"data_{name}"], + obs_state_idxs=np.ones(k_states), + ) + + @staticmethod + def _get_state_names(k_exog: int | None, state_names: list[str] | None, name: str): + if k_exog is None and state_names is None: + raise ValueError("Must specify at least one of k_exog or state_names") + if state_names is not None and k_exog is not None: + if len(state_names) != k_exog: + raise ValueError(f"Expected {k_exog} state names, found {len(state_names)}") + elif k_exog is None: + k_exog = len(state_names) + else: + state_names = [f"{name}_{i + 1}" for i in range(k_exog)] + + return k_exog, state_names + + def _handle_input_data(self, k_exog: int, state_names: list[str] | None, name) -> int: + k_exog, state_names = self._get_state_names(k_exog, state_names, name) + self.state_names = state_names + + return k_exog + + def make_symbolic_graph(self) -> None: + k_endog = self.k_endog + k_states = self.k_states // k_endog + + betas = self.make_and_register_variable( + f"beta_{self.name}", shape=(k_endog, k_states) if k_endog > 1 else (k_states,) + ) + regression_data = self.make_and_register_data(f"data_{self.name}", shape=(None, k_states)) + + self.ssm["initial_state", :] = betas.ravel() + self.ssm["transition", :, :] = pt.eye(self.k_states) + self.ssm["selection", :, :] = pt.eye(self.k_states) + + Z = pt.linalg.block_diag(*[pt.expand_dims(regression_data, 1) for _ in range(k_endog)]) + self.ssm["design"] = pt.specify_shape( + Z, (None, k_endog, regression_data.type.shape[1] * k_endog) + ) + + if self.innovations: + sigma_beta = self.make_and_register_variable( + f"sigma_beta_{self.name}", (k_states,) if k_endog == 1 else (k_endog, k_states) + ) + row_idx, col_idx = np.diag_indices(self.k_states) + self.ssm["state_cov", row_idx, col_idx] = sigma_beta.ravel() ** 2 + + def populate_component_properties(self) -> None: + k_endog = self.k_endog + k_states = self.k_states // k_endog + + self.shock_names = self.state_names + + self.param_names = [f"beta_{self.name}"] + self.data_names = [f"data_{self.name}"] + self.param_dims = { + f"beta_{self.name}": (f"{self.name}_endog", f"{self.name}_state"), + } + + base_names = self.state_names + self.state_names = [ + f"{name}[{obs_name}]" for obs_name in self.observed_state_names for name in base_names + ] + + self.param_info = { + f"beta_{self.name}": { + "shape": (k_endog, k_states) if k_endog > 1 else (k_states,), + "constraints": None, + "dims": (f"{self.name}_endog", f"{self.name}_state") + if k_endog > 1 + else (f"{self.name}_state",), + }, + } + + self.data_info = { + f"data_{self.name}": { + "shape": (None, k_states), + "dims": (TIME_DIM, "exog_state"), + }, + } + self.coords = { + f"{self.name}_state": self.state_names, + f"{self.name}_endog": self.observed_state_names, + } + + if self.innovations: + self.param_names += [f"sigma_beta_{self.name}"] + self.param_dims[f"sigma_beta_{self.name}"] = f"{self.name}_state" + self.param_info[f"sigma_beta_{self.name}"] = { + "shape": (), + "constraints": "Positive", + "dims": (f"{self.name}_state",) + if k_endog == 1 + else (f"{self.name}_endog", f"{self.name}_state"), + } diff --git a/pymc_extras/statespace/models/structural/components/seasonality.py b/pymc_extras/statespace/models/structural/components/seasonality.py new file mode 100644 index 000000000..6ab0ee9c4 --- /dev/null +++ b/pymc_extras/statespace/models/structural/components/seasonality.py @@ -0,0 +1,417 @@ +import numpy as np + +from pytensor import tensor as pt + +from pymc_extras.statespace.models.structural.core import Component +from pymc_extras.statespace.models.structural.utils import _frequency_transition_block + + +class TimeSeasonality(Component): + r""" + Seasonal component, modeled in the time domain + + Parameters + ---------- + season_length: int + The number of periods in a single seasonal cycle, e.g. 12 for monthly data with annual seasonal pattern, 7 for + daily data with weekly seasonal pattern, etc. + + innovations: bool, default True + Whether to include stochastic innovations in the strength of the seasonal effect + + name: str, default None + A name for this seasonal component. Used to label dimensions and coordinates. Useful when multiple seasonal + components are included in the same model. Default is ``f"Seasonal[s={season_length}]"`` + + state_names: list of str, default None + List of strings for seasonal effect labels. If provided, it must be of length ``season_length``. An example + would be ``state_names = ['Mon', 'Tue', 'Wed', 'Thur', 'Fri', 'Sat', 'Sun']`` when data is daily with a weekly + seasonal pattern (``season_length = 7``). + + If None, states will be numbered ``[State_0, ..., State_s]`` + + remove_first_state: bool, default True + If True, the first state will be removed from the model. This is done because there are only n-1 degrees of + freedom in the seasonal component, and one state is not identified. If False, the first state will be + included in the model, but it will not be identified -- you will need to handle this in the priors (e.g. with + ZeroSumNormal). + + Notes + ----- + A seasonal effect is any pattern that repeats every fixed interval. Although there are many possible ways to + model seasonal effects, the implementation used here is the one described by [1] as the "canonical" time domain + representation. The seasonal component can be expressed: + + .. math:: + \gamma_t = -\sum_{i=1}^{s-1} \gamma_{t-i} + \omega_t, \quad \omega_t \sim N(0, \sigma_\gamma) + + Where :math:`s` is the ``seasonal_length`` parameter and :math:`\omega_t` is the (optional) stochastic innovation. + To give interpretation to the :math:`\gamma` terms, it is helpful to work through the algebra for a simple + example. Let :math:`s=4`, and omit the shock term. Define initial conditions :math:`\gamma_0, \gamma_{-1}, + \gamma_{-2}`. The value of the seasonal component for the first 5 timesteps will be: + + .. math:: + \begin{align} + \gamma_1 &= -\gamma_0 - \gamma_{-1} - \gamma_{-2} \\ + \gamma_2 &= -\gamma_1 - \gamma_0 - \gamma_{-1} \\ + &= -(-\gamma_0 - \gamma_{-1} - \gamma_{-2}) - \gamma_0 - \gamma_{-1} \\ + &= (\gamma_0 - \gamma_0 )+ (\gamma_{-1} - \gamma_{-1}) + \gamma_{-2} \\ + &= \gamma_{-2} \\ + \gamma_3 &= -\gamma_2 - \gamma_1 - \gamma_0 \\ + &= -\gamma_{-2} - (-\gamma_0 - \gamma_{-1} - \gamma_{-2}) - \gamma_0 \\ + &= (\gamma_{-2} - \gamma_{-2}) + \gamma_{-1} + (\gamma_0 - \gamma_0) \\ + &= \gamma_{-1} \\ + \gamma_4 &= -\gamma_3 - \gamma_2 - \gamma_1 \\ + &= -\gamma_{-1} - \gamma_{-2} -(-\gamma_0 - \gamma_{-1} - \gamma_{-2}) \\ + &= (\gamma_{-2} - \gamma_{-2}) + (\gamma_{-1} - \gamma_{-1}) + \gamma_0 \\ + &= \gamma_0 \\ + \gamma_5 &= -\gamma_4 - \gamma_3 - \gamma_2 \\ + &= -\gamma_0 - \gamma_{-1} - \gamma_{-2} \\ + &= \gamma_1 + \end{align} + + This exercise shows that, given a list ``initial_conditions`` of length ``s-1``, the effects of this model will be: + + - Period 1: ``-sum(initial_conditions)`` + - Period 2: ``initial_conditions[-1]`` + - Period 3: ``initial_conditions[-2]`` + - ... + - Period s: ``initial_conditions[0]`` + - Period s+1: ``-sum(initial_condition)`` + + And so on. So for interpretation, the ``season_length - 1`` initial states are, when reversed, the coefficients + associated with ``state_names[1:]``. + + .. warning:: + Although the ``state_names`` argument expects a list of length ``season_length``, only ``state_names[1:]`` + will be saved as model dimensions, since the 1st coefficient is not identified (it is defined as + :math:`-\sum_{i=1}^{s} \gamma_{t-i}`). + + Examples + -------- + Estimate monthly with a model with a gaussian random walk trend and monthly seasonality: + + .. code:: python + + from pymc_extras.statespace import structural as st + import pymc as pm + import pytensor.tensor as pt + import pandas as pd + + # Get month names + state_names = pd.date_range('1900-01-01', '1900-12-31', freq='MS').month_name().tolist() + + # Build the structural model + grw = st.LevelTrendComponent(order=1, innovations_order=1) + annual_season = st.TimeSeasonality(season_length=12, name='annual', state_names=state_names, innovations=False) + ss_mod = (grw + annual_season).build() + + # Estimate with PyMC + with pm.Model(coords=ss_mod.coords) as model: + P0 = pm.Deterministic('P0', pt.eye(ss_mod.k_states) * 10, dims=ss_mod.param_dims['P0']) + intitial_trend = pm.Deterministic('initial_trend', pt.zeros(1), dims=ss_mod.param_dims['initial_trend']) + annual_coefs = pm.Normal('annual_coefs', sigma=1e-2, dims=ss_mod.param_dims['annual_coefs']) + trend_sigmas = pm.HalfNormal('trend_sigmas', sigma=1e-6, dims=ss_mod.param_dims['trend_sigmas']) + ss_mod.build_statespace_graph(data) + idata = pm.sample(nuts_sampler='numpyro') + + References + ---------- + .. [1] Durbin, James, and Siem Jan Koopman. 2012. + Time Series Analysis by State Space Methods: Second Edition. + Oxford University Press. + """ + + def __init__( + self, + season_length: int, + innovations: bool = True, + name: str | None = None, + state_names: list | None = None, + remove_first_state: bool = True, + observed_state_names: list[str] | None = None, + ): + if observed_state_names is None: + observed_state_names = ["data"] + + if name is None: + name = f"Seasonal[s={season_length}]" + if state_names is None: + state_names = [f"{name}_{i}" for i in range(season_length)] + else: + if len(state_names) != season_length: + raise ValueError( + f"state_names must be a list of length season_length, got {len(state_names)}" + ) + state_names = state_names.copy() + + self.innovations = innovations + self.remove_first_state = remove_first_state + + if self.remove_first_state: + # In traditional models, the first state isn't identified, so we can help out the user by automatically + # discarding it. + # TODO: Can this be stashed and reconstructed automatically somehow? + state_names.pop(0) + + self.provided_state_names = state_names + + k_states = season_length - int(self.remove_first_state) + k_endog = len(observed_state_names) + k_posdef = int(innovations) + + super().__init__( + name=name, + k_endog=k_endog, + k_states=k_states * k_endog, + k_posdef=k_posdef * k_endog, + observed_state_names=observed_state_names, + measurement_error=False, + combine_hidden_states=True, + obs_state_idxs=np.tile(np.array([1.0] + [0.0] * (k_states - 1)), k_endog), + ) + + def populate_component_properties(self): + k_states = self.k_states // self.k_endog + k_endog = self.k_endog + + self.state_names = [ + f"{state_name}[{endog_name}]" + for endog_name in self.observed_state_names + for state_name in self.provided_state_names + ] + self.param_names = [f"{self.name}_coefs"] + + self.param_info = { + f"{self.name}_coefs": { + "shape": (k_states,) if k_endog == 1 else (k_endog, k_states), + "constraints": None, + "dims": (f"{self.name}_state",) + if k_endog == 1 + else (f"{self.name}_endog", f"{self.name}_state"), + } + } + self.param_dims = {f"{self.name}_coefs": (f"{self.name}_state",)} + self.coords = {f"{self.name}_state": self.state_names} + + if self.innovations: + self.param_names += [f"sigma_{self.name}"] + self.param_info[f"sigma_{self.name}"] = { + "shape": (), + "constraints": "Positive", + "dims": None, + } + self.shock_names = [f"{self.name}[{name}]" for name in self.observed_state_names] + + def make_symbolic_graph(self) -> None: + k_states = self.k_states // self.k_endog + k_posdef = self.k_posdef // self.k_endog + k_endog = self.k_endog + + if self.remove_first_state: + # In this case, parameters are normalized to sum to zero, so the current state is the negative sum of + # all previous states. + T = np.eye(k_states, k=-1) + T[0, :] = -1 + else: + # In this case we assume the user to be responsible for ensuring the states sum to zero, so T is just a + # circulant matrix that cycles between the states. + T = np.eye(k_states, k=1) + T[-1, 0] = 1 + + self.ssm["transition", :, :] = pt.linalg.block_diag(*[T for _ in range(k_endog)]) + + Z = pt.zeros((1, k_states))[0, 0].set(1) + self.ssm["design", :, :] = pt.linalg.block_diag(*[Z for _ in range(k_endog)]) + + initial_states = self.make_and_register_variable( + f"{self.name}_coefs", shape=(k_states,) if k_endog == 1 else (k_endog, k_states) + ) + self.ssm["initial_state", :] = initial_states.ravel() + + if self.innovations: + R = pt.zeros((k_states, k_posdef))[0, 0].set(1.0) + self.ssm["selection", :, :] = pt.join(0, *[R for _ in range(k_endog)]) + season_sigma = self.make_and_register_variable( + f"sigma_{self.name}", shape=() if k_endog == 1 else (k_endog,) + ) + cov_idx = ("state_cov", *np.diag_indices(k_posdef * k_endog)) + self.ssm[cov_idx] = season_sigma**2 + + +class FrequencySeasonality(Component): + r""" + Seasonal component, modeled in the frequency domain + + Parameters + ---------- + season_length: float + The number of periods in a single seasonal cycle, e.g. 12 for monthly data with annual seasonal pattern, 7 for + daily data with weekly seasonal pattern, etc. Non-integer seasonal_length is also permitted, for example + 365.2422 days in a (solar) year. + + n: int + Number of fourier features to include in the seasonal component. Default is ``season_length // 2``, which + is the maximum possible. A smaller number can be used for a more wave-like seasonal pattern. + + name: str, default None + A name for this seasonal component. Used to label dimensions and coordinates. Useful when multiple seasonal + components are included in the same model. Default is ``f"Seasonal[s={season_length}, n={n}]"`` + + innovations: bool, default True + Whether to include stochastic innovations in the strength of the seasonal effect + + Notes + ----- + A seasonal effect is any pattern that repeats every fixed interval. Although there are many possible ways to + model seasonal effects, the implementation used here is the one described by [1] as the "canonical" frequency domain + representation. The seasonal component can be expressed: + + .. math:: + \begin{align} + \gamma_t &= \sum_{j=1}^{2n} \gamma_{j,t} \\ + \gamma_{j, t+1} &= \gamma_{j,t} \cos \lambda_j + \gamma_{j,t}^\star \sin \lambda_j + \omega_{j, t} \\ + \gamma_{j, t}^\star &= -\gamma_{j,t} \sin \lambda_j + \gamma_{j,t}^\star \cos \lambda_j + \omega_{j,t}^\star + \lambda_j &= \frac{2\pi j}{s} + \end{align} + + Where :math:`s` is the ``seasonal_length``. + + Unlike a ``TimeSeasonality`` component, a ``FrequencySeasonality`` component does not require integer season + length. In addition, for long seasonal periods, it is possible to obtain a more compact state space representation + by choosing ``n << s // 2``. Using ``TimeSeasonality``, an annual seasonal pattern in daily data requires 364 + states, whereas ``FrequencySeasonality`` always requires ``2 * n`` states, regardless of the ``seasonal_length``. + The price of this compactness is less representational power. At ``n = 1``, the seasonal pattern will be a pure + sine wave. At ``n = s // 2``, any arbitrary pattern can be represented. + + One cost of the added flexibility of ``FrequencySeasonality`` is reduced interpretability. States of this model are + coefficients :math:`\gamma_1, \gamma^\star_1, \gamma_2, \gamma_2^\star ..., \gamma_n, \gamma^\star_n` associated + with different frequencies in the fourier representation of the seasonal pattern. As a result, it is not possible + to isolate and identify a "Monday" effect, for instance. + """ + + def __init__( + self, + season_length, + n=None, + name=None, + innovations=True, + observed_state_names: list[str] | None = None, + ): + if observed_state_names is None: + observed_state_names = ["data"] + + k_endog = len(observed_state_names) + + if n is None: + n = int(season_length / 2) + if name is None: + name = f"Frequency[s={season_length}, n={n}]" + + k_states = n * 2 + self.n = n + self.season_length = season_length + self.innovations = innovations + + # If the model is completely saturated (n = s // 2), the last state will not be identified, so it shouldn't + # get a parameter assigned to it and should just be fixed to zero. + # Test this way (rather than n == s // 2) to catch cases when n is non-integer. + self.last_state_not_identified = self.season_length / self.n == 2.0 + self.n_coefs = k_states - int(self.last_state_not_identified) + + obs_state_idx = np.zeros(k_states) + obs_state_idx[slice(0, k_states, 2)] = 1 + obs_state_idx = np.tile(obs_state_idx, k_endog) + + super().__init__( + name=name, + k_endog=k_endog, + k_states=k_states * k_endog, + k_posdef=k_states * int(self.innovations) * k_endog, + observed_state_names=observed_state_names, + measurement_error=False, + combine_hidden_states=True, + obs_state_idxs=obs_state_idx, + ) + + def make_symbolic_graph(self) -> None: + k_endog = self.k_endog + k_states = self.k_states // k_endog + k_posdef = self.k_posdef // k_endog + n_coefs = self.n_coefs + + Z = pt.zeros((1, k_states))[0, slice(0, k_states, 2)].set(1.0) + + self.ssm["design", :, :] = pt.linalg.block_diag(*[Z for _ in range(k_endog)]) + + init_state = self.make_and_register_variable( + f"{self.name}", shape=(n_coefs,) if k_endog == 1 else (k_endog, n_coefs) + ) + + init_state_idx = np.concatenate( + [ + np.arange(k_states * i, (i + 1) * k_states, dtype=int)[:n_coefs] + for i in range(k_endog) + ], + axis=0, + ) + + self.ssm["initial_state", init_state_idx] = init_state.ravel() + + T_mats = [_frequency_transition_block(self.season_length, j + 1) for j in range(self.n)] + T = pt.linalg.block_diag(*T_mats) + self.ssm["transition", :, :] = pt.linalg.block_diag(*[T for _ in range(k_endog)]) + + if self.innovations: + sigma_season = self.make_and_register_variable( + f"sigma_{self.name}", shape=() if k_endog == 1 else (k_endog,) + ) + self.ssm["selection", :, :] = pt.eye(self.k_states) + self.ssm["state_cov", :, :] = pt.eye(self.k_posdef) * pt.repeat( + sigma_season**2, k_posdef + ) + + def populate_component_properties(self): + k_endog = self.k_endog + n_coefs = self.n_coefs + k_states = self.k_states // k_endog + + self.state_names = [ + f"{self.name}_{f}_{i}[{obs_state_name}]" + for obs_state_name in self.observed_state_names + for i in range(self.n) + for f in ["Cos", "Sin"] + ] + self.param_names = [f"{self.name}"] + + self.param_dims = {self.name: (f"{self.name}_state",)} + self.param_info = { + f"{self.name}": { + "shape": (n_coefs,) if k_endog == 1 else (k_endog, n_coefs), + "constraints": None, + "dims": (f"{self.name}_state",) + if k_endog == 1 + else (f"{self.name}_endog", f"{self.name}_state"), + } + } + + # Regardless of whether the fourier basis are saturated, there will always be one symbolic state per basis. + # That's why the self.states is just a simple loop over everything. But when saturated, one of those states + # doesn't have an associated **parameter**, so the coords need to be adjusted to reflect this. + init_state_idx = np.concatenate( + [ + np.arange(k_states * i, (i + 1) * k_states, dtype=int)[:n_coefs] + for i in range(k_endog) + ], + axis=0, + ) + self.coords = {f"{self.name}_state": [self.state_names[i] for i in init_state_idx]} + + if self.innovations: + self.shock_names = self.state_names.copy() + self.param_names += [f"sigma_{self.name}"] + self.param_info[f"sigma_{self.name}"] = { + "shape": () if k_endog == 1 else (k_endog, n_coefs), + "constraints": "Positive", + "dims": None if k_endog == 1 else (f"{self.name}_endog",), + } diff --git a/pymc_extras/statespace/models/structural/core.py b/pymc_extras/statespace/models/structural/core.py new file mode 100644 index 000000000..418f57123 --- /dev/null +++ b/pymc_extras/statespace/models/structural/core.py @@ -0,0 +1,739 @@ +import functools as ft +import logging + +from collections.abc import Sequence +from itertools import pairwise +from typing import Any + +import numpy as np +import xarray as xr + +from pytensor import Mode, Variable, config +from pytensor import tensor as pt + +from pymc_extras.statespace.core import PyMCStateSpace, PytensorRepresentation +from pymc_extras.statespace.models.utilities import ( + add_tensors_by_dim_labels, + conform_time_varying_and_time_invariant_matrices, + join_tensors_by_dim_labels, + make_default_coords, +) +from pymc_extras.statespace.utils.constants import ( + ALL_STATE_AUX_DIM, + ALL_STATE_DIM, + LONG_MATRIX_NAMES, +) + +_log = logging.getLogger(__name__) +floatX = config.floatX + + +class StructuralTimeSeries(PyMCStateSpace): + r""" + Structural Time Series Model + + The structural time series model, named by [1] and presented in statespace form in [2], is a framework for + decomposing a univariate time series into level, trend, seasonal, and cycle components. It also admits the + possibility of exogenous regressors. Unlike the SARIMAX framework, the time series is not assumed to be stationary. + + Notes + ----- + + .. math:: + + y_t = \mu_t + \gamma_t + c_t + \varepsilon_t + + """ + + def __init__( + self, + ssm: PytensorRepresentation, + name: str, + state_names: list[str], + observed_state_names: list[str], + data_names: list[str], + shock_names: list[str], + param_names: list[str], + exog_names: list[str], + param_dims: dict[str, tuple[int]], + coords: dict[str, Sequence], + param_info: dict[str, dict[str, Any]], + data_info: dict[str, dict[str, Any]], + component_info: dict[str, dict[str, Any]], + measurement_error: bool, + name_to_variable: dict[str, Variable], + name_to_data: dict[str, Variable] | None = None, + verbose: bool = True, + filter_type: str = "standard", + mode: str | Mode | None = None, + ): + name = "StructuralTimeSeries" if name is None else name + + self._name = name + self._observed_state_names = observed_state_names + + k_states, k_posdef, k_endog = ssm.k_states, ssm.k_posdef, ssm.k_endog + param_names, param_dims, param_info = self._add_inital_state_cov_to_properties( + param_names, param_dims, param_info, k_states + ) + + self._state_names = self._strip_data_names_if_unambiguous(state_names, k_endog) + self._data_names = self._strip_data_names_if_unambiguous(data_names, k_endog) + self._shock_names = self._strip_data_names_if_unambiguous(shock_names, k_endog) + self._param_names = self._strip_data_names_if_unambiguous(param_names, k_endog) + self._param_dims = param_dims + + default_coords = make_default_coords(self) + coords.update(default_coords) + + self._coords = { + k: self._strip_data_names_if_unambiguous(v, k_endog) for k, v in coords.items() + } + self._param_info = param_info.copy() + self._data_info = data_info.copy() + self.measurement_error = measurement_error + + super().__init__( + k_endog, + k_states, + max(1, k_posdef), + filter_type=filter_type, + verbose=verbose, + measurement_error=measurement_error, + mode=mode, + ) + self.ssm = ssm.copy() + + if k_posdef == 0: + # If there is no randomness in the model, add dummy matrices to the representation to avoid errors + # when we go to construct random variables from the matrices + self.ssm.k_posdef = self.k_posdef + self.ssm.shapes["state_cov"] = (1, 1, 1) + self.ssm["state_cov"] = pt.zeros((1, 1, 1)) + + self.ssm.shapes["selection"] = (1, self.k_states, 1) + self.ssm["selection"] = pt.zeros((1, self.k_states, 1)) + + self._component_info = component_info.copy() + + self._name_to_variable = name_to_variable.copy() + self._name_to_data = name_to_data.copy() + + self._exog_names = exog_names.copy() + self._needs_exog_data = len(exog_names) > 0 + + P0 = self.make_and_register_variable("P0", shape=(self.k_states, self.k_states)) + self.ssm["initial_state_cov"] = P0 + + def _strip_data_names_if_unambiguous(self, names: list[str], k_endog: int): + """ + State names from components should always be of the form name[data_name], in the case that the component is + associated with multiple observed states. Not doing so leads to ambiguity -- we might have two level states, + but which goes to which observed component? So we set `level[data_1]` and `level[data_2]`. + + In cases where there is only one observed state (when k_endog == 1), we can strip the data part and just use + the state name. This is a bit cleaner. + """ + if k_endog == 1: + [data_name] = self.observed_states + return [ + name.replace(f"[{data_name}]", "") if isinstance(name, str) else name + for name in names + ] + + else: + return names + + @staticmethod + def _add_inital_state_cov_to_properties(param_names, param_dims, param_info, k_states): + param_names += ["P0"] + param_dims["P0"] = (ALL_STATE_DIM, ALL_STATE_AUX_DIM) + param_info["P0"] = { + "shape": (k_states, k_states), + "constraints": "Positive semi-definite", + "dims": param_dims["P0"], + } + + return param_names, param_dims, param_info + + @property + def param_names(self): + return self._param_names + + @property + def data_names(self) -> list[str]: + return self._data_names + + @property + def state_names(self): + return self._state_names + + @property + def observed_states(self): + return self._observed_state_names + + @property + def shock_names(self): + return self._shock_names + + @property + def param_dims(self): + return self._param_dims + + @property + def coords(self) -> dict[str, Sequence]: + return self._coords + + @property + def param_info(self) -> dict[str, dict[str, Any]]: + return self._param_info + + @property + def data_info(self) -> dict[str, dict[str, Any]]: + return self._data_info + + def make_symbolic_graph(self) -> None: + """ + Assign placeholder pytensor variables among statespace matrices in positions where PyMC variables will go. + + Notes + ----- + This assignment is handled by the components, so this function is implemented only to avoid the + NotImplementedError raised by the base class. + """ + + pass + + def _state_slices_from_info(self): + info = self._component_info.copy() + comp_states = np.cumsum([0] + [info["k_states"] for info in info.values()]) + state_slices = [slice(i, j) for i, j in pairwise(comp_states)] + + return state_slices + + def _hidden_states_from_data(self, data): + state_slices = self._state_slices_from_info() + info = self._component_info + names = info.keys() + result = [] + + for i, (name, s) in enumerate(zip(names, state_slices)): + obs_idx = info[name]["obs_state_idx"] + if obs_idx is None: + continue + + X = data[..., s] + if info[name]["combine_hidden_states"]: + sum_idx = np.flatnonzero(obs_idx) + result.append(X[..., sum_idx].sum(axis=-1)[..., None]) + else: + comp_names = self.state_names[s] + for j, state_name in enumerate(comp_names): + result.append(X[..., j, None]) + + return np.concatenate(result, axis=-1) + + def _get_subcomponent_names(self): + state_slices = self._state_slices_from_info() + info = self._component_info + names = info.keys() + result = [] + + for i, (name, s) in enumerate(zip(names, state_slices)): + if info[name]["combine_hidden_states"]: + result.append(name) + else: + comp_names = self.state_names[s] + result.extend([f"{name}[{comp_name}]" for comp_name in comp_names]) + return result + + def extract_components_from_idata(self, idata: xr.Dataset) -> xr.Dataset: + r""" + Extract interpretable hidden states from an InferenceData returned by a PyMCStateSpace sampling method + + Parameters + ---------- + idata: Dataset + A Dataset object, returned by a PyMCStateSpace sampling method + + Returns + ------- + idata: Dataset + An Dataset object with hidden states transformed to represent only the "interpretable" subcomponents + of the structural model. + + Notes + ----- + In general, a structural statespace model can be represented as: + + .. math:: + y_t = \mu_t + \nu_t + \cdots + \gamma_t + c_t + \xi_t + \epsilon_t \tag{1} + + Where: + + - :math:`\mu_t` is the level of the data at time t + - :math:`\nu_t` is the slope of the data at time t + - :math:`\cdots` are higher time derivatives of the position (acceleration, jerk, etc) at time t + - :math:`\gamma_t` is the seasonal component at time t + - :math:`c_t` is the cycle component at time t + - :math:`\xi_t` is the autoregressive error at time t + - :math:`\varepsilon_t` is the measurement error at time t + + In state space form, some or all of these components are represented as linear combinations of other + subcomponents, making interpretation of the outputs of the outputs difficult. The purpose of this function is + to take the expended statespace representation and return a "reduced form" of only the components shown in + equation (1). + """ + + def _extract_and_transform_variable(idata, new_state_names): + *_, time_dim, state_dim = idata.dims + state_func = ft.partial(self._hidden_states_from_data) + new_idata = xr.apply_ufunc( + state_func, + idata, + input_core_dims=[[time_dim, state_dim]], + output_core_dims=[[time_dim, state_dim]], + exclude_dims={state_dim}, + ) + new_idata.coords.update({state_dim: new_state_names}) + return new_idata + + var_names = list(idata.data_vars.keys()) + is_latent = [idata[name].shape[-1] == self.k_states for name in var_names] + new_state_names = self._get_subcomponent_names() + + latent_names = [name for latent, name in zip(is_latent, var_names) if latent] + dropped_vars = set(var_names) - set(latent_names) + if len(dropped_vars) > 0: + _log.warning( + f'Variables {", ".join(dropped_vars)} do not contain all hidden states (their last dimension ' + f"is not {self.k_states}). They will not be present in the modified idata." + ) + if len(dropped_vars) == len(var_names): + raise ValueError( + "Provided idata had no variables with all hidden states; cannot extract components." + ) + + idata_new = xr.Dataset( + { + name: _extract_and_transform_variable(idata[name], new_state_names) + for name in latent_names + } + ) + return idata_new + + +class Component: + r""" + Base class for a component of a structural timeseries model. + + This base class contains a subset of the class attributes of the PyMCStateSpace class, and none of the class + methods. The purpose of a component is to allow the partial definition of a structural model. Components are + assembled into a full model by the StructuralTimeSeries class. + + Parameters + ---------- + name: str + The name of the component + k_endog: int + Number of endogenous variables being modeled. + k_states: int + Number of hidden states in the component model + k_posdef: int + Rank of the state covariance matrix, or the number of sources of innovations in the component model + observed_state_names: str or list or str, optional + Names of the observed states associated with this component. Must have the same length as k_endog. If not + provided, generic names are generated: ``observed_state_1, observed_state_2, ..., observed_state_k_endog``. + measurement_error: bool + Whether the observation associated with the component has measurement error. Default is False. + combine_hidden_states: bool + Flag for the ``extract_hidden_states_from_data`` method. When ``True``, hidden states from the component model + are extracted as ``hidden_states[:, np.flatnonzero(Z)]``. Should be True in models where hidden states + individually have no interpretation, such as seasonal or autoregressive components. + """ + + def __init__( + self, + name, + k_endog, + k_states, + k_posdef, + state_names=None, + observed_state_names=None, + data_names=None, + shock_names=None, + param_names=None, + exog_names=None, + representation: PytensorRepresentation | None = None, + measurement_error=False, + combine_hidden_states=True, + component_from_sum=False, + obs_state_idxs=None, + ): + self.name = name + self.k_endog = k_endog + self.k_states = k_states + self.k_posdef = k_posdef + self.measurement_error = measurement_error + + self.state_names = state_names if state_names is not None else [] + self.observed_state_names = observed_state_names if observed_state_names is not None else [] + self.data_names = data_names if data_names is not None else [] + self.shock_names = shock_names if shock_names is not None else [] + self.param_names = param_names if param_names is not None else [] + self.exog_names = exog_names if exog_names is not None else [] + + self.needs_exog_data = len(self.exog_names) > 0 + self.coords = {} + self.param_dims = {} + + self.param_info = {} + self.data_info = {} + + self.param_counts = {} + + if representation is None: + self.ssm = PytensorRepresentation(k_endog=k_endog, k_states=k_states, k_posdef=k_posdef) + else: + self.ssm = representation + + self._name_to_variable = {} + self._name_to_data = {} + + if not component_from_sum: + self.populate_component_properties() + self.make_symbolic_graph() + + self._component_info = { + self.name: { + "k_states": self.k_states, + "k_enodg": self.k_endog, + "k_posdef": self.k_posdef, + "observed_state_names": self.observed_state_names, + "combine_hidden_states": combine_hidden_states, + "obs_state_idx": obs_state_idxs, + } + } + + def make_and_register_variable(self, name, shape, dtype=floatX) -> Variable: + r""" + Helper function to create a pytensor symbolic variable and register it in the _name_to_variable dictionary + + Parameters + ---------- + name : str + The name of the placeholder variable. Must be the name of a model parameter. + shape : int or tuple of int + Shape of the parameter + dtype : str, default pytensor.config.floatX + dtype of the parameter + + Notes + ----- + Symbolic pytensor variables are used in the ``make_symbolic_graph`` method as placeholders for PyMC random + variables. The change is made in the ``_insert_random_variables`` method via ``pytensor.graph_replace``. To + make the change, a dictionary mapping pytensor variables to PyMC random variables needs to be constructed. + + The purpose of this method is to: + 1. Create the placeholder symbolic variables + 2. Register the placeholder variable in the ``_name_to_variable`` dictionary + + The shape provided here will define the shape of the prior that will need to be provided by the user. + + An error is raised if the provided name has already been registered, or if the name is not present in the + ``param_names`` property. + """ + if name not in self.param_names: + raise ValueError( + f"{name} is not a model parameter. All placeholder variables should correspond to model " + f"parameters." + ) + + if name in self._name_to_variable.keys(): + raise ValueError( + f"{name} is already a registered placeholder variable with shape " + f"{self._name_to_variable[name].type.shape}" + ) + + placeholder = pt.tensor(name, shape=shape, dtype=dtype) + self._name_to_variable[name] = placeholder + return placeholder + + def make_and_register_data(self, name, shape, dtype=floatX) -> Variable: + r""" + Helper function to create a pytensor symbolic variable and register it in the _name_to_data dictionary + + Parameters + ---------- + name : str + The name of the placeholder data. Must be the name of an expected data variable. + shape : int or tuple of int + Shape of the parameter + dtype : str, default pytensor.config.floatX + dtype of the parameter + + Notes + ----- + See docstring for make_and_register_variable for more details. This function is similar, but handles data + inputs instead of model parameters. + + An error is raised if the provided name has already been registered, or if the name is not present in the + ``data_names`` property. + """ + if name not in self.data_names: + raise ValueError( + f"{name} is not a model parameter. All placeholder variables should correspond to model " + f"parameters." + ) + + if name in self._name_to_data.keys(): + raise ValueError( + f"{name} is already a registered placeholder variable with shape " + f"{self._name_to_data[name].type.shape}" + ) + + placeholder = pt.tensor(name, shape=shape, dtype=dtype) + self._name_to_data[name] = placeholder + return placeholder + + def make_symbolic_graph(self) -> None: + raise NotImplementedError + + def populate_component_properties(self): + raise NotImplementedError + + def _get_combined_shapes(self, other): + k_states = self.k_states + other.k_states + k_posdef = self.k_posdef + other.k_posdef + + # To count endog states, we have to count unique names between the two components. + combined_states = self._combine_property( + other, "observed_state_names", allow_duplicates=False + ) + k_endog = len(combined_states) + + return k_states, k_posdef, k_endog + + def _combine_statespace_representations(self, other): + def make_slice(name, x, o_x): + ndim = max(x.ndim, o_x.ndim) + return (name,) + (slice(None, None, None),) * ndim + + k_states, k_posdef, k_endog = self._get_combined_shapes(other) + + self_matrices = [self.ssm[name] for name in LONG_MATRIX_NAMES] + other_matrices = [other.ssm[name] for name in LONG_MATRIX_NAMES] + + self_observed_states = self.observed_state_names + other_observed_states = other.observed_state_names + + x0, P0, c, d, T, Z, R, H, Q = ( + self.ssm[make_slice(name, x, o_x)] + for name, x, o_x in zip(LONG_MATRIX_NAMES, self_matrices, other_matrices) + ) + o_x0, o_P0, o_c, o_d, o_T, o_Z, o_R, o_H, o_Q = ( + other.ssm[make_slice(name, x, o_x)] + for name, x, o_x in zip(LONG_MATRIX_NAMES, self_matrices, other_matrices) + ) + + initial_state = pt.concatenate(conform_time_varying_and_time_invariant_matrices(x0, o_x0)) + initial_state.name = x0.name + + initial_state_cov = pt.linalg.block_diag(P0, o_P0) + initial_state_cov.name = P0.name + + state_intercept = pt.concatenate(conform_time_varying_and_time_invariant_matrices(c, o_c)) + state_intercept.name = c.name + + obs_intercept = add_tensors_by_dim_labels( + d, o_d, labels=self_observed_states, other_labels=other_observed_states, labeled_axis=-1 + ) + obs_intercept.name = d.name + + transition = pt.linalg.block_diag(T, o_T) + transition.name = T.name + + design = join_tensors_by_dim_labels( + *conform_time_varying_and_time_invariant_matrices(Z, o_Z), + labels=self_observed_states, + other_labels=other_observed_states, + labeled_axis=-2, + join_axis=-1, + ) + design.name = Z.name + + selection = pt.linalg.block_diag(R, o_R) + selection.name = R.name + + obs_cov = add_tensors_by_dim_labels( + H, + o_H, + labels=self_observed_states, + other_labels=other_observed_states, + labeled_axis=(-1, -2), + ) + obs_cov.name = H.name + + state_cov = pt.linalg.block_diag(Q, o_Q) + state_cov.name = Q.name + + new_ssm = PytensorRepresentation( + k_endog=k_endog, + k_states=k_states, + k_posdef=k_posdef, + initial_state=initial_state, + initial_state_cov=initial_state_cov, + state_intercept=state_intercept, + obs_intercept=obs_intercept, + transition=transition, + design=design, + selection=selection, + obs_cov=obs_cov, + state_cov=state_cov, + ) + + return new_ssm + + def _combine_property(self, other, name, allow_duplicates=True): + self_prop = getattr(self, name) + if isinstance(self_prop, list) and allow_duplicates: + return self_prop + getattr(other, name) + elif isinstance(self_prop, list) and not allow_duplicates: + return self_prop + [x for x in getattr(other, name) if x not in self_prop] + elif isinstance(self_prop, dict): + new_prop = self_prop.copy() + new_prop.update(getattr(other, name)) + return new_prop + + def _combine_component_info(self, other): + combined_info = {} + for key, value in self._component_info.items(): + if not key.startswith("StateSpace"): + if key in combined_info.keys(): + raise ValueError(f"Found duplicate component named {key}") + combined_info[key] = value + + for key, value in other._component_info.items(): + if not key.startswith("StateSpace"): + if key in combined_info.keys(): + raise ValueError(f"Found duplicate component named {key}") + combined_info[key] = value + + return combined_info + + def _make_combined_name(self): + components = self._component_info.keys() + name = f'StateSpace[{", ".join(components)}]' + return name + + def __add__(self, other): + state_names = self._combine_property(other, "state_names") + data_names = self._combine_property(other, "data_names") + observed_state_names = self._combine_property( + other, "observed_state_names", allow_duplicates=False + ) + + param_names = self._combine_property(other, "param_names") + shock_names = self._combine_property(other, "shock_names") + param_info = self._combine_property(other, "param_info") + data_info = self._combine_property(other, "data_info") + param_dims = self._combine_property(other, "param_dims") + coords = self._combine_property(other, "coords") + exog_names = self._combine_property(other, "exog_names") + + _name_to_variable = self._combine_property(other, "_name_to_variable") + _name_to_data = self._combine_property(other, "_name_to_data") + + measurement_error = any([self.measurement_error, other.measurement_error]) + + k_states, k_posdef, k_endog = self._get_combined_shapes(other) + + ssm = self._combine_statespace_representations(other) + + new_comp = Component( + name="", + k_endog=k_endog, + k_states=k_states, + k_posdef=k_posdef, + observed_state_names=observed_state_names, + measurement_error=measurement_error, + representation=ssm, + component_from_sum=True, + ) + new_comp._component_info = self._combine_component_info(other) + new_comp.name = new_comp._make_combined_name() + + names_and_props = [ + ("state_names", state_names), + ("observed_state_names", observed_state_names), + ("data_names", data_names), + ("param_names", param_names), + ("shock_names", shock_names), + ("param_dims", param_dims), + ("coords", coords), + ("param_dims", param_dims), + ("param_info", param_info), + ("data_info", data_info), + ("exog_names", exog_names), + ("_name_to_variable", _name_to_variable), + ("_name_to_data", _name_to_data), + ] + + for prop, value in names_and_props: + setattr(new_comp, prop, value) + + return new_comp + + def build( + self, name=None, filter_type="standard", verbose=True, mode: str | Mode | None = None + ): + """ + Build a StructuralTimeSeries statespace model from the current component(s) + + Parameters + ---------- + name: str, optional + Name of the exogenous data being modeled. Default is "data" + + filter_type : str, optional + The type of Kalman filter to use. Valid options are "standard", "univariate", "single", "cholesky", and + "steady_state". For more information, see the docs for each filter. Default is "standard". + + verbose : bool, optional + If True, displays information about the initialized model. Defaults to True. + + mode: str or Mode, optional + Pytensor compile mode, used in auxiliary sampling methods such as ``sample_conditional_posterior`` and + ``forecast``. The mode does **not** effect calls to ``pm.sample``. + + Regardless of whether a mode is specified, it can always be overwritten via the ``compile_kwargs`` argument + to all sampling methods. + + Returns + ------- + PyMCStateSpace + An initialized instance of a PyMCStateSpace, constructed using the system matrices contained in the + components. + """ + + return StructuralTimeSeries( + self.ssm, + name=name, + state_names=self.state_names, + observed_state_names=self.observed_state_names, + data_names=self.data_names, + shock_names=self.shock_names, + param_names=self.param_names, + param_dims=self.param_dims, + coords=self.coords, + param_info=self.param_info, + data_info=self.data_info, + component_info=self._component_info, + measurement_error=self.measurement_error, + exog_names=self.exog_names, + name_to_variable=self._name_to_variable, + name_to_data=self._name_to_data, + filter_type=filter_type, + verbose=verbose, + mode=mode, + ) diff --git a/pymc_extras/statespace/models/structural/utils.py b/pymc_extras/statespace/models/structural/utils.py new file mode 100644 index 000000000..d75252225 --- /dev/null +++ b/pymc_extras/statespace/models/structural/utils.py @@ -0,0 +1,16 @@ +import numpy as np + +from pytensor import tensor as pt + + +def order_to_mask(order): + if isinstance(order, int): + return np.ones(order).astype(bool) + else: + return np.array(order).astype(bool) + + +def _frequency_transition_block(s, j): + lam = 2 * np.pi * j / s + + return pt.stack([[pt.cos(lam), pt.sin(lam)], [-pt.sin(lam), pt.cos(lam)]]) diff --git a/pymc_extras/statespace/models/utilities.py b/pymc_extras/statespace/models/utilities.py index 6bc22370b..b91d1cddb 100644 --- a/pymc_extras/statespace/models/utilities.py +++ b/pymc_extras/statespace/models/utilities.py @@ -1,6 +1,10 @@ +from typing import cast as type_cast + import numpy as np import pytensor.tensor as pt +from pytensor.tensor import TensorVariable + from pymc_extras.statespace.utils.constants import ( ALL_STATE_AUX_DIM, ALL_STATE_DIM, @@ -374,6 +378,278 @@ def conform_time_varying_and_time_invariant_matrices(A, B): return A, B +def normalize_axis(x, axis): + """ + Convert negative axis values to positive axis values + """ + if isinstance(axis, tuple): + return tuple([normalize_axis(x, i) for i in axis]) + if axis < 0: + axis = x.ndim + axis + return axis + + +def reorder_from_labels( + x: TensorVariable, + labels: list[str], + ordered_labels: list[str], + labeled_axis: int | tuple[int, int], +) -> TensorVariable: + """ + Reorder an input tensor along request axis/axes based on lists of string labels + + Parameters + ---------- + x: TensorVariable + Input tensor + labels: list of str + Labels associated with values of the input tensor ``x``, along the ``labeled_axis``. At runtime, should have + ``x.shape[labeled_axis] == len(labels)`` + ordered_labels: list of str + Target ordering according to which ``x`` will be reordered. + labeled_axis: int or tuple of int + Axis along which ``x`` will be labeled. If a tuple, each axis will be assumed to have identical labels, and + and reorganization will be done on all requested axes together (NOT fancy indexing!) + + Returns + ------- + x_sorted: TensorVariable + Output tensor sorted along ``labeled_axis`` according to ``ordered_labels`` + """ + n_out = len(ordered_labels) + label_to_index = {label: index for index, label in enumerate(ordered_labels)} + + missing_labels = [label for label in ordered_labels if label not in labels] + indices = np.argsort([label_to_index[label] for label in [*labels, *missing_labels]]) + + if isinstance(labeled_axis, int): + labeled_axis = (labeled_axis,) + + if indices.tolist() != list(range(n_out)): + for axis in labeled_axis: + idx = np.s_[tuple([slice(None, None) if i != axis else indices for i in range(x.ndim)])] + x = x[idx] + + return x + + +def pad_and_reorder( + x: TensorVariable, labels: list[str], ordered_labels: list[str], labeled_axis: int +) -> TensorVariable: + """ + Pad input tensor ``x`` along the `labeled_axis` to match the length of ``ordered_labels``, then reorder the + padded dimension to match the ordering in ``ordered_labels``. + + Parameters + ---------- + x: TensorVariable + Input tensor + labels: list of str + String labels associated with the `x` tensor at the ``labeled_axis`` dimension. At runtime, should have + ``x.shape[labeled_axis] == len(labels)``. ``labels`` should be a subset of ``ordered_labels``. + ordered_labels: list of str + Target ordering according to which ``x`` will be reordered. + labeled_axis: int + Axis along which ``x`` will be labeled. + + Returns + ------- + x_padded: TensorVariable + Output tensor padded along ``labeled_axis`` according to ``ordered_labels``, then reordered. + + """ + n_out = len(ordered_labels) + n_missing = n_out - len(labels) + + if n_missing > 0: + zeros = pt.zeros( + tuple([x.shape[i] if i != labeled_axis else n_missing for i in range(x.ndim)]) + ) + x_padded = pt.concatenate([x, zeros], axis=labeled_axis) + else: + x_padded = x + + return reorder_from_labels(x_padded, labels, ordered_labels, labeled_axis) + + +def ndim_pad_and_reorder( + x: TensorVariable, + labels: list[str], + ordered_labels: list[str], + labeled_axis: int | tuple[int, int], +) -> TensorVariable: + """ + Pad input tensor ``x`` along the `labeled_axis` to match the length of ``ordered_labels``, then reorder the + padded dimension to match the ordering in ``ordered_labels``. + + Unlike ``pad_and_reorder``, this function allows padding and reordering to be done simultaneously on multiple + axes. In this case, reordering is done jointly on all axes -- it does *not* use fancy indexing. + + Parameters + ---------- + x: TensorVariable + Input tensor + labels: list of str + Labels associated with values of the input tensor ``x``, along the ``labeled_axis``. At runtime, should have + ``x.shape[labeled_axis] == len(labels)``. If ``labeled_axis`` is a tuple, all axes are assumed to have the + same labels. + ordered_labels: list of str + Target ordering according to which ``x`` will be reordered. ``labels`` should be a subset of ``ordered_labels``. + labeled_axis: int or tuple of int + Axis along which ``x`` will be labeled. If a tuple, each axis will be assumed to have identical labels, and + and reorganization will be done on all requested axes together (NOT fancy indexing!) + + Returns + ------- + x_sorted: TensorVariable + Output tensor. Each ``labeled_axis`` is padded to the length of ``ordered_labels``, then reordered. + """ + n_missing = len(ordered_labels) - len(labels) + + if isinstance(labeled_axis, int): + labeled_axis = (labeled_axis,) + + if n_missing > 0: + pad_size = [(0, 0) if i not in labeled_axis else (0, n_missing) for i in range(x.ndim)] + x = pt.pad(x, pad_size, mode="constant", constant_values=0) + + return reorder_from_labels(x, labels, ordered_labels, labeled_axis) + + +def add_tensors_by_dim_labels( + tensor: TensorVariable, + other_tensor: TensorVariable, + labels: list[str], + other_labels: list[str], + labeled_axis: int | tuple[int, int] = -1, +) -> TensorVariable: + """ + Add two tensors based on labels associated with one dimension. + + When combining statespace matrices associated with structural components with potentially different states, it is + important to make sure that duplicated states are handled correctly. For bias vectors and covariance matrices, + duplicated states should be summed. + + When a state appears in one component but not another, that state should be treated as an implicit zero in the + components where the state does not appear. This amounts to padding the relevant matrices with zeros before + performing the addition. + + When labeled_axis is a tuple, each provided label is assumed to be identically labeled in each input tensor. This + is the case, for example, when working with a covariance matrix. In this case, padding and alignment will be + done on each indicated index. + + Parameters + ---------- + tensor: TensorVariable + A statespace matrix to be summed with ``other_tensor``. + other_tensor: TensorVariable + A statespace matrix to be summed with ``tensor``. + labels: list of str + Dimension labels associated with ``tensor``, on the ``labeled_axis`` dimension. + other_labels: list of str + Dimension labels associated with ``other_tensor``, on the ``labeled_axis`` dimension. + labeled_axis: int or tuple of int + Dimension that is labeled by ``labels`` and ``other_labels``. ``tensor.shape[labeled_axis]`` must have the + shape of ``len(labels)`` at runtime. + + Returns + ------- + result: TensorVariable + Result of addition of ``tensor`` and ``other_tensor``, along the ``labeled_axis`` dimension. The ordering of + the output will be ``labels + [label for label in other_labels if label not in labels]``. That is, ``labels`` + come first, followed by any new labels introduced by ``other_labels``. + + """ + labeled_axis = normalize_axis(tensor, labeled_axis) + new_labels = [label for label in other_labels if label not in labels] + combined_labels = type_cast(list[str], [*labels, *new_labels]) + + # If there is no overlap at all, directly concatenate the two matrices -- there's no need to worry about the order + # of things, or padding. This is equivalent to padding both out with zeros then adding them. + if combined_labels == [*labels, *other_labels]: + if isinstance(labeled_axis, int): + return pt.concatenate([tensor, other_tensor], axis=labeled_axis) + else: + # In the case where we want to align multiple dimensions, use block_diag to accomplish padding on the last + # two dimensions + dims = [*[i for i in range(tensor.ndim) if i not in labeled_axis], *labeled_axis] + return pt.linalg.block_diag( + type_cast(TensorVariable, tensor.transpose(*dims)), + type_cast(TensorVariable, other_tensor.transpose(*dims)), + ) + # Otherwise, there are two possibilities. If all labels are the same, we might need to re-order one or both to get + # them to agree. If *some* labels are the same, we will need to pad first, then potentially re-order. In any case, + # the final step is just to add the padded and re-ordered tensors. + fn = pad_and_reorder if isinstance(labeled_axis, int) else ndim_pad_and_reorder + + padded_tensor = fn( + tensor, + labels=type_cast(list[str], labels), + ordered_labels=combined_labels, + labeled_axis=labeled_axis, + ) + padded_tensor.name = tensor.name + + padded_other_tensor = fn( + other_tensor, + labels=type_cast(list[str], other_labels), + ordered_labels=combined_labels, + labeled_axis=labeled_axis, + ) + + padded_other_tensor.name = other_tensor.name + + return padded_tensor + padded_other_tensor + + +def join_tensors_by_dim_labels( + tensor: TensorVariable, + other_tensor: TensorVariable, + labels: list[str], + other_labels: list[str], + labeled_axis: int = -1, + join_axis: int = -1, + block_diag_join: bool = False, +) -> TensorVariable: + labeled_axis = normalize_axis(tensor, labeled_axis) + new_labels = [label for label in other_labels if label not in labels] + combined_labels = [*labels, *new_labels] + + # Check for no overlap first. In this case, do a block_diagonal join, which implicitly results in padding zeros + # everywhere they are needed -- no other sorting or padding necessary + if combined_labels == [*labels, *other_labels]: + res = pt.linalg.block_diag(tensor, other_tensor) + new_shape = [ + shape_1 + shape_2 if (shape_1 is not None and shape_2 is not None) else None + for shape_1, shape_2 in zip(tensor.type.shape, other_tensor.type.shape) + ] + return pt.specify_shape(res, new_shape) + + # Otherwise there is either total overlap or partial overlap. Let the padding and reordering function figure it out. + tensor = ndim_pad_and_reorder(tensor, labels, combined_labels, labeled_axis) + other_tensor = ndim_pad_and_reorder(other_tensor, other_labels, combined_labels, labeled_axis) + + if block_diag_join: + new_shape = [ + shape_1 + shape_2 if (shape_1 is not None and shape_2 is not None) else None + for shape_1, shape_2 in zip(tensor.type.shape, other_tensor.type.shape) + ] + res = pt.linalg.block_diag(tensor, other_tensor) + else: + new_shape = [] + join_axis_norm = normalize_axis(tensor, join_axis) + for i, (shape_1, shape_2) in enumerate(zip(tensor.type.shape, other_tensor.type.shape)): + if i == join_axis_norm: + new_shape.append( + shape_1 + shape_2 if (shape_1 is not None and shape_2 is not None) else None + ) + else: + new_shape.append(shape_1 if shape_1 is not None else shape_2) + res = pt.concatenate([tensor, other_tensor], axis=join_axis) + + return pt.specify_shape(res, new_shape) + + def get_exog_dims_from_idata(exog_name, idata): if exog_name in idata.posterior.data_vars: exog_dims = idata.posterior[exog_name].dims[2:] diff --git a/tests/statespace/core/test_statespace.py b/tests/statespace/core/test_statespace.py index bfcd114ae..3c7ab1daf 100644 --- a/tests/statespace/core/test_statespace.py +++ b/tests/statespace/core/test_statespace.py @@ -167,7 +167,9 @@ def exog_pymc_mod(exog_ss_mod, exog_data): P0_diag = pm.Gamma("P0_diag", alpha=2, beta=4, dims=["state"]) P0 = pm.Deterministic("P0", pt.diag(P0_diag), dims=["state", "state_aux"]) - initial_trend = pm.Normal("initial_trend", mu=[0], sigma=[0.005], dims=["trend_state"]) + initial_trend = pm.Normal( + "level_trend_initial", mu=[0], sigma=[0.005], dims=["level_trend_state"] + ) data_exog = pm.Data( "data_exog", exog_data["x1"].values[:, None], dims=["time", "exog_state"] @@ -184,12 +186,12 @@ def pymc_mod_no_exog(ss_mod_no_exog, rng): y = pd.DataFrame(rng.normal(size=(100, 1)).astype(floatX), columns=["y"]) with pm.Model(coords=ss_mod_no_exog.coords) as m: - initial_trend = pm.Normal("initial_trend", dims=["trend_state"]) + initial_trend = pm.Normal("level_trend_initial", dims=["level_trend_state"]) P0_sigma = pm.Exponential("P0_sigma", 1) P0 = pm.Deterministic( "P0", pt.eye(ss_mod_no_exog.k_states) * P0_sigma, dims=["state", "state_aux"] ) - sigma_trend = pm.Exponential("sigma_trend", 1, dims=["trend_shock"]) + sigma_trend = pm.Exponential("level_trend_sigma", 1, dims=["level_trend_shock"]) ss_mod_no_exog.build_statespace_graph(y) return m @@ -204,12 +206,12 @@ def pymc_mod_no_exog_dt(ss_mod_no_exog_dt, rng): ) with pm.Model(coords=ss_mod_no_exog_dt.coords) as m: - initial_trend = pm.Normal("initial_trend", dims=["trend_state"]) + initial_trend = pm.Normal("level_trend_initial", dims=["level_trend_state"]) P0_sigma = pm.Exponential("P0_sigma", 1) P0 = pm.Deterministic( "P0", pt.eye(ss_mod_no_exog_dt.k_states) * P0_sigma, dims=["state", "state_aux"] ) - sigma_trend = pm.Exponential("sigma_trend", 1, dims=["trend_shock"]) + sigma_trend = pm.Exponential("level_trend_sigma", 1, dims=["level_trend_shock"]) ss_mod_no_exog_dt.build_statespace_graph(y) return m @@ -313,7 +315,7 @@ def test_build_statespace_graph_warns_if_data_has_nans(): ss_mod = st.LevelTrendComponent(order=1, innovations_order=0).build(verbose=False) with pm.Model() as pymc_mod: - initial_trend = pm.Normal("initial_trend", shape=(1,)) + initial_trend = pm.Normal("level_trend_initial", shape=(1,)) P0 = pm.Deterministic("P0", pt.eye(1, dtype=floatX)) with pytest.warns(pm.ImputationWarning): ss_mod.build_statespace_graph( @@ -326,7 +328,7 @@ def test_build_statespace_graph_raises_if_data_has_missing_fill(): ss_mod = st.LevelTrendComponent(order=1, innovations_order=0).build(verbose=False) with pm.Model() as pymc_mod: - initial_trend = pm.Normal("initial_trend", shape=(1,)) + initial_trend = pm.Normal("level_trend_initial", shape=(1,)) P0 = pm.Deterministic("P0", pt.eye(1, dtype=floatX)) with pytest.raises(ValueError, match="Provided data contains the value 1.0"): data = np.ones((10, 1), dtype=floatX) @@ -882,7 +884,7 @@ def test_forecast_with_exog_data(rng, exog_ss_mod, idata_exog, start): ) components = exog_ss_mod.extract_components_from_idata(forecast_idata) - level = components.forecast_latent.sel(state="LevelTrend[level]") + level = components.forecast_latent.sel(state="level_trend[level]") betas = components.forecast_latent.sel(state=["exog[x1]"]) scenario.index.name = "time" diff --git a/tests/statespace/filters/test_distributions.py b/tests/statespace/filters/test_distributions.py index 1958d0bf0..383257196 100644 --- a/tests/statespace/filters/test_distributions.py +++ b/tests/statespace/filters/test_distributions.py @@ -52,8 +52,8 @@ def pymc_model(data): data = pm.Data("data", data.values) P0_diag = pm.Exponential("P0_diag", 1, shape=(2,)) P0 = pm.Deterministic("P0", pt.diag(P0_diag)) - initial_trend = pm.Normal("initial_trend", shape=(2,)) - sigma_trend = pm.Exponential("sigma_trend", 1, shape=(2,)) + initial_trend = pm.Normal("level_trend_initial", shape=(2,)) + sigma_trend = pm.Exponential("level_trend_sigma", 1, shape=(2,)) return mod @@ -69,8 +69,8 @@ def pymc_model_2(data): with pm.Model(coords=coords) as mod: P0_diag = pm.Exponential("P0_diag", 1, shape=(2,)) P0 = pm.Deterministic("P0", pt.diag(P0_diag)) - initial_trend = pm.Normal("initial_trend", shape=(2,)) - sigma_trend = pm.Exponential("sigma_trend", 1, shape=(2,)) + initial_trend = pm.Normal("level_trend_initial", shape=(2,)) + sigma_trend = pm.Exponential("level_trend_sigma", 1, shape=(2,)) sigma_me = pm.Exponential("sigma_error", 1) return mod @@ -207,8 +207,8 @@ def test_lgss_with_time_varying_inputs(output_name, rng): exog_data = pm.Data("data_exog", X) P0_diag = pm.Exponential("P0_diag", 1, shape=(mod.k_states,)) P0 = pm.Deterministic("P0", pt.diag(P0_diag)) - initial_trend = pm.Normal("initial_trend", shape=(2,)) - sigma_trend = pm.Exponential("sigma_trend", 1, shape=(2,)) + initial_trend = pm.Normal("level_trend_initial", shape=(2,)) + sigma_trend = pm.Exponential("level_trend_sigma", 1, shape=(2,)) beta_exog = pm.Normal("beta_exog", shape=(3,)) mod._insert_random_variables() diff --git a/tests/statespace/models/structural/__init__.py b/tests/statespace/models/structural/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/tests/statespace/models/structural/components/__init__.py b/tests/statespace/models/structural/components/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/tests/statespace/models/structural/components/test_autoregressive.py b/tests/statespace/models/structural/components/test_autoregressive.py new file mode 100644 index 000000000..71a181925 --- /dev/null +++ b/tests/statespace/models/structural/components/test_autoregressive.py @@ -0,0 +1,132 @@ +import numpy as np +import pytensor +import pytest + +from numpy.testing import assert_allclose +from pytensor import config +from pytensor.graph.basic import explicit_graph_inputs + +from pymc_extras.statespace.models import structural as st +from tests.statespace.models.structural.conftest import _assert_basic_coords_correct +from tests.statespace.test_utilities import simulate_from_numpy_model + + +@pytest.mark.parametrize("order", [1, 2, [1, 0, 1]], ids=["AR1", "AR2", "AR(1,0,1)"]) +def test_autoregressive_model(order, rng): + ar = st.AutoregressiveComponent(order=order).build(verbose=False) + + # Check coords + _assert_basic_coords_correct(ar) + + lags = np.arange(len(order) if isinstance(order, list) else order, dtype="int") + 1 + if isinstance(order, list): + lags = lags[np.flatnonzero(order)] + assert_allclose(ar.coords["auto_regressive_lag"], lags) + + +def test_autoregressive_multiple_observed_build(rng): + ar = st.AutoregressiveComponent(order=3, observed_state_names=["data_1", "data_2"]) + mod = ar.build(verbose=False) + + assert mod.k_endog == 2 + assert mod.k_states == 6 + assert mod.k_posdef == 2 + + assert mod.state_names == [ + "L1[data_1]", + "L2[data_1]", + "L3[data_1]", + "L1[data_2]", + "L2[data_2]", + "L3[data_2]", + ] + + assert mod.shock_names == ["auto_regressive[data_1]", "auto_regressive[data_2]"] + + params = { + "auto_regressive_params": np.full( + ( + 2, + sum(ar.order), + ), + 0.5, + dtype=config.floatX, + ), + "auto_regressive_sigma": np.array([0.05, 0.12]), + } + _, _, _, _, T, Z, R, _, Q = mod._unpack_statespace_with_placeholders() + input_vars = explicit_graph_inputs([T, Z, R, Q]) + fn = pytensor.function( + inputs=list(input_vars), + outputs=[T, Z, R, Q], + mode="FAST_COMPILE", + ) + + T, Z, R, Q = fn(**params) + + np.testing.assert_allclose( + T, + np.array( + [ + [0.5, 0.5, 0.5, 0.0, 0.0, 0.0], + [1.0, 0.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 1.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 0.5, 0.5, 0.5], + [0.0, 0.0, 0.0, 1.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 1.0, 0.0], + ] + ), + ) + + np.testing.assert_allclose( + Z, np.array([[1.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 1.0, 0.0, 0.0]]) + ) + + np.testing.assert_allclose( + R, np.array([[1.0, 0.0], [0.0, 0.0], [0.0, 0.0], [0.0, 1.0], [0.0, 0.0], [0.0, 0.0]]) + ) + + np.testing.assert_allclose(Q, np.diag([0.05**2, 0.12**2])) + + +def test_autoregressive_multiple_observed_data(rng): + ar = st.AutoregressiveComponent(order=1, observed_state_names=["data_1", "data_2", "data_3"]) + mod = ar.build(verbose=False) + + params = { + "auto_regressive_params": np.array([0.9, 0.8, 0.5]).reshape((3, 1)), + "auto_regressive_sigma": np.array([0.05, 0.12, 0.22]), + "initial_state_cov": np.eye(3), + } + + # Recover the AR(1) coefficients from the simulated data via OLS + x, y = simulate_from_numpy_model(mod, rng, params, steps=2000) + for i in range(3): + ols_coefs = np.polyfit(y[:-1, i], y[1:, i], 1) + np.testing.assert_allclose(ols_coefs[0], params["auto_regressive_params"][i, 0], atol=1e-1) + + +def test_add_autoregressive_different_observed(): + mod_1 = st.AutoregressiveComponent(order=1, name="ar1", observed_state_names=["data_1"]) + mod_2 = st.AutoregressiveComponent(name="ar6", order=6, observed_state_names=["data_2"]) + + mod = (mod_1 + mod_2).build(verbose=False) + + print(mod.coords) + + assert mod.k_endog == 2 + assert mod.k_states == 7 + assert mod.k_posdef == 2 + assert mod.state_names == [ + "L1[data_1]", + "L1[data_2]", + "L2[data_2]", + "L3[data_2]", + "L4[data_2]", + "L5[data_2]", + "L6[data_2]", + ] + + assert mod.shock_names == ["ar1[data_1]", "ar6[data_2]"] + assert mod.coords["ar1_lag"] == [1] + assert mod.coords["ar6_lag"] == [1, 2, 3, 4, 5, 6] diff --git a/tests/statespace/models/structural/components/test_cycle.py b/tests/statespace/models/structural/components/test_cycle.py new file mode 100644 index 000000000..987cbf914 --- /dev/null +++ b/tests/statespace/models/structural/components/test_cycle.py @@ -0,0 +1,140 @@ +import numpy as np + +from numpy.testing import assert_allclose +from pytensor import config + +from pymc_extras.statespace.models import structural as st +from tests.statespace.models.structural.conftest import _assert_basic_coords_correct +from tests.statespace.test_utilities import assert_pattern_repeats, simulate_from_numpy_model + +ATOL = 1e-8 if config.floatX.endswith("64") else 1e-4 +RTOL = 0 if config.floatX.endswith("64") else 1e-6 + + +cycle_test_vals = zip([None, None, 3, 5, 10], [False, True, True, False, False]) + + +def test_cycle_component_deterministic(rng): + cycle = st.CycleComponent( + name="cycle", cycle_length=12, estimate_cycle_length=False, innovations=False + ) + params = {"cycle": np.array([1.0, 1.0], dtype=config.floatX)} + x, y = simulate_from_numpy_model(cycle, rng, params, steps=12 * 12) + + assert_pattern_repeats(y, 12, atol=ATOL, rtol=RTOL) + + +def test_cycle_component_with_dampening(rng): + cycle = st.CycleComponent( + name="cycle", cycle_length=12, estimate_cycle_length=False, innovations=False, dampen=True + ) + params = {"cycle": np.array([10.0, 10.0], dtype=config.floatX), "cycle_dampening_factor": 0.75} + x, y = simulate_from_numpy_model(cycle, rng, params, steps=100) + + # Check that the cycle dampens to zero over time + assert_allclose(y[-1], 0.0, atol=ATOL, rtol=RTOL) + + +def test_cycle_component_with_innovations_and_cycle_length(rng): + cycle = st.CycleComponent( + name="cycle", estimate_cycle_length=True, innovations=True, dampen=True + ) + params = { + "cycle": np.array([1.0, 1.0], dtype=config.floatX), + "cycle_length": 12.0, + "cycle_dampening_factor": 0.95, + "sigma_cycle": 1.0, + } + x, y = simulate_from_numpy_model(cycle, rng, params) + + cycle.build(verbose=False) + _assert_basic_coords_correct(cycle) + + +def test_cycle_multivariate_deterministic(rng): + """Test multivariate cycle component with deterministic cycles.""" + cycle = st.CycleComponent( + name="cycle", + cycle_length=12, + estimate_cycle_length=False, + innovations=False, + observed_state_names=["data_1", "data_2", "data_3"], + ) + params = {"cycle": np.array([[1.0, 1.0], [2.0, 2.0], [3.0, 3.0]], dtype=config.floatX)} + x, y = simulate_from_numpy_model(cycle, rng, params, steps=12 * 12) + + # Check that each variable has a cyclical pattern with the expected period + for i in range(3): + assert_pattern_repeats(y[:, i], 12, atol=ATOL, rtol=RTOL) + + # Check that the cycles have different amplitudes (different initial states) + assert np.std(y[:, 0]) > 0 + assert np.std(y[:, 1]) > 0 + assert np.std(y[:, 2]) > 0 + # The second and third variables should have larger amplitudes due to larger initial states + assert np.std(y[:, 1]) > np.std(y[:, 0]) + assert np.std(y[:, 2]) > np.std(y[:, 0]) + + +def test_cycle_multivariate_with_dampening(rng): + """Test multivariate cycle component with dampening.""" + cycle = st.CycleComponent( + name="cycle", + cycle_length=12, + estimate_cycle_length=False, + innovations=False, + dampen=True, + observed_state_names=["data_1", "data_2", "data_3"], + ) + params = { + "cycle": np.array([[10.0, 10.0], [20.0, 20.0], [30.0, 30.0]], dtype=config.floatX), + "cycle_dampening_factor": 0.75, + } + x, y = simulate_from_numpy_model(cycle, rng, params, steps=100) + + # Check that all cycles dampen to zero over time + for i in range(3): + assert_allclose(y[-1, i], 0.0, atol=ATOL, rtol=RTOL) + + # Check that the dampening pattern is consistent across variables + # The variables should dampen at the same rate but with different initial amplitudes + for i in range(1, 3): + # The ratio of final to initial values should be similar across variables + ratio_0 = abs(y[-1, 0] / y[0, 0]) if y[0, 0] != 0 else 0 + ratio_i = abs(y[-1, i] / y[0, i]) if y[0, i] != 0 else 0 + assert_allclose(ratio_0, ratio_i, atol=1e-2, rtol=1e-2) + + +def test_cycle_multivariate_with_innovations_and_cycle_length(rng): + """Test multivariate cycle component with innovations and estimated cycle length.""" + cycle = st.CycleComponent( + name="cycle", + estimate_cycle_length=True, + innovations=True, + dampen=True, + observed_state_names=["data_1", "data_2", "data_3"], + ) + params = { + "cycle": np.array([[1.0, 1.0], [2.0, 2.0], [3.0, 3.0]], dtype=config.floatX), + "cycle_length": 12.0, + "cycle_dampening_factor": 0.95, + "sigma_cycle": np.array([0.5, 1.0, 1.5]), # Different innovation variances per variable + } + x, y = simulate_from_numpy_model(cycle, rng, params) + + cycle.build(verbose=False) + _assert_basic_coords_correct(cycle) + + assert cycle.coords["cycle_state"] == ["cycle_Cos", "cycle_Sin"] + assert cycle.coords["cycle_endog"] == ["data_1", "data_2", "data_3"] + + assert cycle.k_endog == 3 + assert cycle.k_states == 6 # 2 states per variable + assert cycle.k_posdef == 6 # 2 innovations per variable + + # Check that the data has the expected shape + assert y.shape[1] == 3 # 3 variables + + # Check that each variable shows some variation (due to innovations) + for i in range(3): + assert np.std(y[:, i]) > 0 diff --git a/tests/statespace/models/structural/components/test_level_trend.py b/tests/statespace/models/structural/components/test_level_trend.py new file mode 100644 index 000000000..c8a9c419a --- /dev/null +++ b/tests/statespace/models/structural/components/test_level_trend.py @@ -0,0 +1,158 @@ +import numpy as np +import pytensor + +from numpy.testing import assert_allclose +from pytensor import config + +from pymc_extras.statespace.models import structural as st +from tests.statespace.models.structural.conftest import _assert_basic_coords_correct +from tests.statespace.test_utilities import simulate_from_numpy_model + +ATOL = 1e-8 if config.floatX.endswith("64") else 1e-4 +RTOL = 0 if config.floatX.endswith("64") else 1e-6 + + +def test_level_trend_model(rng): + mod = st.LevelTrendComponent(order=2, innovations_order=0) + params = {"level_trend_initial": [0.0, 1.0]} + x, y = simulate_from_numpy_model(mod, rng, params) + + assert_allclose(np.diff(y), 1, atol=ATOL, rtol=RTOL) + + # Check coords + mod = mod.build(verbose=False) + _assert_basic_coords_correct(mod) + assert mod.coords["level_trend_state"] == ["level", "trend"] + + +def test_level_trend_multiple_observed_construction(): + mod = st.LevelTrendComponent( + order=2, innovations_order=1, observed_state_names=["data_1", "data_2", "data_3"] + ) + mod = mod.build(verbose=False) + assert mod.k_endog == 3 + assert mod.k_states == 6 + assert mod.k_posdef == 3 + + assert mod.coords["level_trend_state"] == ["level", "trend"] + assert mod.coords["level_trend_endog"] == ["data_1", "data_2", "data_3"] + + assert mod.state_names == [ + "level[data_1]", + "trend[data_1]", + "level[data_2]", + "trend[data_2]", + "level[data_3]", + "trend[data_3]", + ] + assert mod.shock_names == ["level[data_1]", "level[data_2]", "level[data_3]"] + + Z, T, R = pytensor.function( + [], [mod.ssm["design"], mod.ssm["transition"], mod.ssm["selection"]], mode="FAST_COMPILE" + )() + + np.testing.assert_allclose( + Z, + np.array( + [ + [1.0, 0.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 1.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 1.0, 0.0], + ] + ), + ) + + np.testing.assert_allclose( + T, + np.array( + [ + [1.0, 1.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 1.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 1.0, 1.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 1.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 1.0, 1.0], + [0.0, 0.0, 0.0, 0.0, 0.0, 1.0], + ] + ), + ) + + np.testing.assert_allclose( + R, + np.array( + [ + [1.0, 0.0, 0.0], + [0.0, 0.0, 0.0], + [0.0, 1.0, 0.0], + [0.0, 0.0, 0.0], + [0.0, 0.0, 1.0], + [0.0, 0.0, 0.0], + ] + ), + ) + + +def test_level_trend_multiple_observed(rng): + mod = st.LevelTrendComponent( + order=2, innovations_order=0, observed_state_names=["data_1", "data_2", "data_3"] + ) + params = {"level_trend_initial": np.array([[0.0, 1.0], [0.0, 2.0], [0.0, 3.0]])} + + x, y = simulate_from_numpy_model(mod, rng, params) + assert (np.diff(y, axis=0) == np.array([[1.0, 2.0, 3.0]])).all().all() + assert (np.diff(x, axis=0) == np.array([[1.0, 0.0, 2.0, 0.0, 3.0, 0.0]])).all().all() + + +def test_add_level_trend_with_different_observed(): + mod_1 = st.LevelTrendComponent( + name="ll", order=2, innovations_order=[0, 1], observed_state_names=["data_1"] + ) + mod_2 = st.LevelTrendComponent( + name="grw", order=1, innovations_order=[1], observed_state_names=["data_2"] + ) + + mod = (mod_1 + mod_2).build(verbose=False) + assert mod.k_endog == 2 + assert mod.k_states == 3 + assert mod.k_posdef == 2 + + assert mod.coords["ll_state"] == ["level", "trend"] + assert mod.coords["grw_state"] == ["level"] + + assert mod.state_names == ["level[data_1]", "trend[data_1]", "level[data_2]"] + assert mod.shock_names == ["trend[data_1]", "level[data_2]"] + + Z, T, R = pytensor.function( + [], [mod.ssm["design"], mod.ssm["transition"], mod.ssm["selection"]], mode="FAST_COMPILE" + )() + + np.testing.assert_allclose( + Z, + np.array( + [ + [1.0, 0.0, 0.0], + [0.0, 0.0, 1.0], + ] + ), + ) + + np.testing.assert_allclose( + T, + np.array( + [ + [1.0, 1.0, 0.0], + [0.0, 1.0, 0.0], + [0.0, 0.0, 1.0], + ] + ), + ) + + np.testing.assert_allclose( + R, + np.array( + [ + [0.0, 0.0], + [1.0, 0.0], + [0.0, 1.0], + ] + ), + ) diff --git a/tests/statespace/models/structural/components/test_measurement_error.py b/tests/statespace/models/structural/components/test_measurement_error.py new file mode 100644 index 000000000..ba6a654f9 --- /dev/null +++ b/tests/statespace/models/structural/components/test_measurement_error.py @@ -0,0 +1,32 @@ +import numpy as np + +from pymc_extras.statespace.models import structural as st +from tests.statespace.models.structural.conftest import _assert_basic_coords_correct + + +def test_measurement_error(rng): + mod = st.MeasurementError("obs") + st.LevelTrendComponent(order=2) + mod = mod.build(verbose=False) + + _assert_basic_coords_correct(mod) + assert "sigma_obs" in mod.param_names + + +def test_measurement_error_multiple_observed(): + mod = st.MeasurementError("obs", observed_state_names=["data_1", "data_2"]) + assert mod.k_endog == 2 + assert mod.coords["endog_obs"] == ["data_1", "data_2"] + assert mod.param_dims["sigma_obs"] == ("endog_obs",) + + +def test_build_with_measurement_error_subset(): + ll = st.LevelTrendComponent(order=2, observed_state_names=["data_1", "data_2", "data_3"]) + me = st.MeasurementError("obs", observed_state_names=["data_1", "data_3"]) + mod = (ll + me).build() + + H = mod.ssm["obs_cov"] + assert H.type.shape == (3, 3) + np.testing.assert_allclose( + H.eval({"sigma_obs": [1.0, 3.0]}), + np.array([[1.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 9.0]]), + ) diff --git a/tests/statespace/models/structural/components/test_regression.py b/tests/statespace/models/structural/components/test_regression.py new file mode 100644 index 000000000..8bea66647 --- /dev/null +++ b/tests/statespace/models/structural/components/test_regression.py @@ -0,0 +1,137 @@ +import numpy as np +import pandas as pd +import pymc as pm + +from numpy.testing import assert_allclose +from pytensor import config +from pytensor import tensor as pt +from pytensor.graph.basic import explicit_graph_inputs + +from pymc_extras.statespace.models import structural as st +from tests.statespace.models.structural.conftest import _assert_basic_coords_correct +from tests.statespace.test_utilities import simulate_from_numpy_model + +ATOL = 1e-8 if config.floatX.endswith("64") else 1e-4 +RTOL = 0 if config.floatX.endswith("64") else 1e-6 + + +def test_exogenous_component(rng): + data = rng.normal(size=(100, 2)).astype(config.floatX) + mod = st.RegressionComponent(state_names=["feature_1", "feature_2"], name="exog") + + params = {"beta_exog": np.array([1.0, 2.0], dtype=config.floatX)} + exog_data = {"data_exog": data} + x, y = simulate_from_numpy_model(mod, rng, params, exog_data) + + # Check that the generated data is just a linear regression + assert_allclose(y, data @ params["beta_exog"], atol=ATOL, rtol=RTOL) + + mod = mod.build(verbose=False) + _assert_basic_coords_correct(mod) + assert mod.coords["exog_state"] == ["feature_1", "feature_2"] + + +def test_adding_exogenous_component(rng): + data = rng.normal(size=(100, 2)).astype(config.floatX) + reg = st.RegressionComponent(state_names=["a", "b"], name="exog") + ll = st.LevelTrendComponent(name="level") + + seasonal = st.FrequencySeasonality(name="annual", season_length=12, n=4) + mod = reg + ll + seasonal + + assert mod.ssm["design"].eval({"data_exog": data}).shape == (100, 1, 2 + 2 + 8) + assert_allclose(mod.ssm["design", 5, 0, :2].eval({"data_exog": data}), data[5]) + + +def test_regression_with_multiple_observed_states(rng): + from scipy.linalg import block_diag + + data = rng.normal(size=(100, 2)).astype(config.floatX) + mod = st.RegressionComponent( + state_names=["feature_1", "feature_2"], + name="exog", + observed_state_names=["data_1", "data_2"], + ) + + params = {"beta_exog": np.array([[1.0, 2.0], [3.0, 4.0]], dtype=config.floatX)} + exog_data = {"data_exog": data} + x, y = simulate_from_numpy_model(mod, rng, params, exog_data) + + assert x.shape == (100, 4) # 2 features, 2 states + assert y.shape == (100, 2) + + # Check that the generated data are two independent linear regressions + assert_allclose(y[:, 0], data @ params["beta_exog"][0], atol=ATOL, rtol=RTOL) + assert_allclose(y[:, 1], data @ params["beta_exog"][1], atol=ATOL, rtol=RTOL) + + mod = mod.build(verbose=False) + assert mod.coords["exog_state"] == [ + "feature_1[data_1]", + "feature_2[data_1]", + "feature_1[data_2]", + "feature_2[data_2]", + ] + + Z = mod.ssm["design"].eval({"data_exog": data}) + vec_block_diag = np.vectorize(block_diag, signature="(n,m),(o,p)->(q,r)") + assert Z.shape == (100, 2, 4) + assert np.allclose(Z, vec_block_diag(data[:, None, :], data[:, None, :])) + + +def test_add_regression_components_with_multiple_observed_states(rng): + from scipy.linalg import block_diag + + data_1 = rng.normal(size=(100, 2)).astype(config.floatX) + data_2 = rng.normal(size=(100, 1)).astype(config.floatX) + + reg1 = st.RegressionComponent( + state_names=["a", "b"], name="exog1", observed_state_names=["data_1", "data_2"] + ) + reg2 = st.RegressionComponent(state_names=["c"], name="exog2", observed_state_names=["data_3"]) + + mod = (reg1 + reg2).build(verbose=False) + assert mod.coords["exog1_state"] == ["a[data_1]", "b[data_1]", "a[data_2]", "b[data_2]"] + assert mod.coords["exog2_state"] == ["c[data_3]"] + + Z = mod.ssm["design"].eval({"data_exog1": data_1, "data_exog2": data_2}) + vec_block_diag = np.vectorize(block_diag, signature="(n,m),(o,p)->(q,r)") + assert Z.shape == (100, 3, 5) + assert np.allclose( + Z, + vec_block_diag(vec_block_diag(data_1[:, None, :], data_1[:, None, :]), data_2[:, None, :]), + ) + + x0 = mod.ssm["initial_state"].eval( + { + "beta_exog1": np.array([[1.0, 2.0], [3.0, 4.0]], dtype=config.floatX), + "beta_exog2": np.array([5.0], dtype=config.floatX), + } + ) + np.testing.assert_allclose(x0, np.array([1.0, 2.0, 3.0, 4.0, 5.0], dtype=config.floatX)) + + +def test_filter_scans_time_varying_design_matrix(rng): + time_idx = pd.date_range(start="2000-01-01", freq="D", periods=100) + data = pd.DataFrame(rng.normal(size=(100, 2)), columns=["a", "b"], index=time_idx) + + y = pd.DataFrame(rng.normal(size=(100, 1)), columns=["data"], index=time_idx) + + reg = st.RegressionComponent(state_names=["a", "b"], name="exog") + mod = reg.build(verbose=False) + + with pm.Model(coords=mod.coords) as m: + data_exog = pm.Data("data_exog", data.values) + + x0 = pm.Normal("x0", dims=["state"]) + P0 = pm.Deterministic("P0", pt.eye(mod.k_states), dims=["state", "state_aux"]) + beta_exog = pm.Normal("beta_exog", dims=["exog_state"]) + + mod.build_statespace_graph(y) + x0, P0, c, d, T, Z, R, H, Q = mod.unpack_statespace() + pm.Deterministic("Z", Z) + + prior = pm.sample_prior_predictive(draws=10) + + prior_Z = prior.prior.Z.values + assert prior_Z.shape == (1, 10, 100, 1, 2) + assert_allclose(prior_Z[0, :, :, 0, :], data.values[None].repeat(10, axis=0)) diff --git a/tests/statespace/models/structural/components/test_seasonality.py b/tests/statespace/models/structural/components/test_seasonality.py new file mode 100644 index 000000000..ebe8d0e6e --- /dev/null +++ b/tests/statespace/models/structural/components/test_seasonality.py @@ -0,0 +1,439 @@ +import numpy as np +import pytensor +import pytest + +from pytensor import config +from pytensor.graph.basic import explicit_graph_inputs + +from pymc_extras.statespace.models import structural as st +from tests.statespace.models.structural.conftest import _assert_basic_coords_correct +from tests.statespace.test_utilities import assert_pattern_repeats, simulate_from_numpy_model + +ATOL = 1e-8 if config.floatX.endswith("64") else 1e-4 +RTOL = 0 if config.floatX.endswith("64") else 1e-6 + + +@pytest.mark.parametrize("s", [10, 25, 50]) +@pytest.mark.parametrize("innovations", [True, False]) +@pytest.mark.parametrize("remove_first_state", [True, False]) +@pytest.mark.filterwarnings( + "ignore:divide by zero encountered in matmul:RuntimeWarning", + "ignore:overflow encountered in matmul:RuntimeWarning", + "ignore:invalid value encountered in matmul:RuntimeWarning", +) +def test_time_seasonality(s, innovations, remove_first_state, rng): + def random_word(rng): + return "".join(rng.choice(list("abcdefghijklmnopqrstuvwxyz")) for _ in range(5)) + + state_names = [random_word(rng) for _ in range(s)] + mod = st.TimeSeasonality( + season_length=s, + innovations=innovations, + name="season", + state_names=state_names, + remove_first_state=remove_first_state, + ) + x0 = np.zeros(mod.k_states, dtype=config.floatX) + x0[0] = 1 + + params = {"season_coefs": x0} + if innovations: + params["sigma_season"] = 0.0 + + x, y = simulate_from_numpy_model(mod, rng, params) + y = y.ravel() + if not innovations: + assert_pattern_repeats(y, s, atol=ATOL, rtol=RTOL) + + # Check coords + mod = mod.build(verbose=False) + _assert_basic_coords_correct(mod) + test_slice = slice(1, None) if remove_first_state else slice(None) + assert mod.coords["season_state"] == state_names[test_slice] + + +@pytest.mark.parametrize( + "remove_first_state", [True, False], ids=["remove_first_state", "keep_first_state"] +) +def test_time_seasonality_multiple_observed(rng, remove_first_state): + s = 3 + state_names = [f"state_{i}" for i in range(s)] + mod = st.TimeSeasonality( + season_length=s, + innovations=True, + name="season", + state_names=state_names, + observed_state_names=["data_1", "data_2"], + remove_first_state=remove_first_state, + ) + x0 = np.zeros((mod.k_endog, mod.k_states // mod.k_endog), dtype=config.floatX) + + expected_states = [ + f"state_{i}[data_{j}]" for j in range(1, 3) for i in range(int(remove_first_state), s) + ] + assert mod.state_names == expected_states + assert mod.shock_names == ["season[data_1]", "season[data_2]"] + + x0[0, 0] = 1 + x0[1, 0] = 2.0 + + params = {"season_coefs": x0, "sigma_season": np.array([0.0, 0.0], dtype=config.floatX)} + + x, y = simulate_from_numpy_model(mod, rng, params, steps=123) + assert_pattern_repeats(y[:, 0], s, atol=ATOL, rtol=RTOL) + assert_pattern_repeats(y[:, 1], s, atol=ATOL, rtol=RTOL) + + mod = mod.build(verbose=False) + x0, *_, T, Z, R, _, Q = mod._unpack_statespace_with_placeholders() + + input_vars = explicit_graph_inputs([x0, T, Z, R, Q]) + + fn = pytensor.function( + inputs=list(input_vars), + outputs=[x0, T, Z, R, Q], + mode="FAST_COMPILE", + ) + + params["sigma_season"] = np.array([0.1, 0.8], dtype=config.floatX) + x0, T, Z, R, Q = fn(**params) + + if remove_first_state: + expected_x0 = np.array([1.0, 0.0, 2.0, 0.0]) + + expected_T = np.array( + [ + [-1.0, -1.0, 0.0, 0.0], + [1.0, 0.0, 0.0, 0.0], + [0.0, 0.0, -1.0, -1.0], + [0.0, 0.0, 1.0, 0.0], + ] + ) + expected_R = np.array([[1.0, 1.0], [0.0, 0.0], [1.0, 1.0], [0.0, 0.0]]) + expected_Z = np.array([[1.0, 0.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0]]) + + else: + expected_x0 = np.array([1.0, 0.0, 0.0, 2.0, 0.0, 0.0]) + expected_T = np.array( + [ + [0.0, 1.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 1.0, 0.0, 0.0, 0.0], + [1.0, 0.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 1.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 0.0, 1.0], + [0.0, 0.0, 0.0, 1.0, 0.0, 0.0], + ] + ) + expected_R = np.array( + [[1.0, 1.0], [0.0, 0.0], [0.0, 0.0], [1.0, 1.0], [0.0, 0.0], [0.0, 0.0]] + ) + expected_Z = np.array([[1.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 1.0, 0.0, 0.0]]) + + expected_Q = np.array([[0.1**2, 0.0], [0.0, 0.8**2]]) + + for matrix, expected in zip( + [x0, T, Z, R, Q], + [expected_x0, expected_T, expected_Z, expected_R, expected_Q], + ): + np.testing.assert_allclose(matrix, expected) + + +def test_add_two_time_seasonality_different_observed(rng): + mod1 = st.TimeSeasonality( + season_length=3, + innovations=True, + name="season1", + state_names=[f"state_{i}" for i in range(3)], + observed_state_names=["data_1"], + remove_first_state=False, + ) + mod2 = st.TimeSeasonality( + season_length=5, + innovations=True, + name="season2", + state_names=[f"state_{i}" for i in range(5)], + observed_state_names=["data_2"], + ) + + mod = (mod1 + mod2).build(verbose=False) + + params = { + "season1_coefs": np.array([1.0, 0.0, 0.0], dtype=config.floatX), + "season2_coefs": np.array([3.0, 0.0, 0.0, 0.0], dtype=config.floatX), + "sigma_season1": np.array(0.0, dtype=config.floatX), + "sigma_season2": np.array(0.0, dtype=config.floatX), + "initial_state_cov": np.eye(mod.k_states, dtype=config.floatX), + } + + x, y = simulate_from_numpy_model(mod, rng, params, steps=3 * 5 * 5) + assert_pattern_repeats(y[:, 0], 3, atol=ATOL, rtol=RTOL) + assert_pattern_repeats(y[:, 1], 5, atol=ATOL, rtol=RTOL) + + assert mod.state_names == [ + "state_0[data_1]", + "state_1[data_1]", + "state_2[data_1]", + "state_1[data_2]", + "state_2[data_2]", + "state_3[data_2]", + "state_4[data_2]", + ] + + assert mod.shock_names == ["season1[data_1]", "season2[data_2]"] + + x0, *_, T = mod._unpack_statespace_with_placeholders()[:5] + input_vars = explicit_graph_inputs([x0, T]) + fn = pytensor.function( + inputs=list(input_vars), + outputs=[x0, T], + mode="FAST_COMPILE", + ) + + x0, T = fn( + season1_coefs=np.array([1.0, 0.0, 0.0], dtype=config.floatX), + season2_coefs=np.array([3.0, 0.0, 0.0, 1.2], dtype=config.floatX), + ) + + np.testing.assert_allclose( + np.array([1.0, 0.0, 0.0, 3.0, 0.0, 0.0, 1.2]), x0, atol=ATOL, rtol=RTOL + ) + + np.testing.assert_allclose( + np.array( + [ + [0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0], + [1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 0.0, -1.0, -1.0, -1.0, -1.0], + [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0], + ] + ), + T, + atol=ATOL, + rtol=RTOL, + ) + + +def get_shift_factor(s): + s_str = str(s) + if "." not in s_str: + return 1 + _, decimal = s_str.split(".") + return 10 ** len(decimal) + + +@pytest.mark.parametrize("n", [*np.arange(1, 6, dtype="int").tolist(), None]) +@pytest.mark.parametrize("s", [5, 10, 25, 25.2]) +def test_frequency_seasonality(n, s, rng): + mod = st.FrequencySeasonality(season_length=s, n=n, name="season") + x0 = rng.normal(size=mod.n_coefs).astype(config.floatX) + params = {"season": x0, "sigma_season": 0.0} + k = get_shift_factor(s) + T = int(s * k) + + x, y = simulate_from_numpy_model(mod, rng, params, steps=2 * T) + assert_pattern_repeats(y, T, atol=ATOL, rtol=RTOL) + + # Check coords + mod = mod.build(verbose=False) + _assert_basic_coords_correct(mod) + if n is None: + n = int(s // 2) + states = [f"season_{f}_{i}" for i in range(n) for f in ["Cos", "Sin"]] + + # Remove the last state when the model is completely saturated + if s / n == 2.0: + states.pop() + assert mod.coords["season_state"] == states + + +def test_frequency_seasonality_multiple_observed(rng): + observed_state_names = ["data_1", "data_2"] + season_length = 4 + mod = st.FrequencySeasonality( + season_length=season_length, + n=None, + name="season", + innovations=True, + observed_state_names=observed_state_names, + ) + expected_state_names = [ + "season_Cos_0[data_1]", + "season_Sin_0[data_1]", + "season_Cos_1[data_1]", + "season_Sin_1[data_1]", + "season_Cos_0[data_2]", + "season_Sin_0[data_2]", + "season_Cos_1[data_2]", + "season_Sin_1[data_2]", + ] + assert mod.state_names == expected_state_names + assert mod.shock_names == [ + "season_Cos_0[data_1]", + "season_Sin_0[data_1]", + "season_Cos_1[data_1]", + "season_Sin_1[data_1]", + "season_Cos_0[data_2]", + "season_Sin_0[data_2]", + "season_Cos_1[data_2]", + "season_Sin_1[data_2]", + ] + + # Simulate + x0 = np.zeros((2, 3), dtype=config.floatX) + x0[0, 0] = 1.0 + x0[1, 0] = 2.0 + params = {"season": x0, "sigma_season": np.zeros(2, dtype=config.floatX)} + x, y = simulate_from_numpy_model(mod, rng, params, steps=12) + + # Check periodicity for each observed series + assert_pattern_repeats(y[:, 0], 4, atol=ATOL, rtol=RTOL) + assert_pattern_repeats(y[:, 1], 4, atol=ATOL, rtol=RTOL) + + mod = mod.build(verbose=False) + assert list(mod.coords["season_state"]) == [ + "season_Cos_0[data_1]", + "season_Sin_0[data_1]", + "season_Cos_1[data_1]", + "season_Cos_0[data_2]", + "season_Sin_0[data_2]", + "season_Cos_1[data_2]", + ] + + x0_sym, *_, T_sym, Z_sym, R_sym, _, Q_sym = mod._unpack_statespace_with_placeholders() + input_vars = explicit_graph_inputs([x0_sym, T_sym, Z_sym, R_sym, Q_sym]) + fn = pytensor.function( + inputs=list(input_vars), + outputs=[x0_sym, T_sym, Z_sym, R_sym, Q_sym], + mode="FAST_COMPILE", + ) + params["sigma_season"] = np.array([0.1, 0.8], dtype=config.floatX) + x0_v, T_v, Z_v, R_v, Q_v = fn(**params) + + # x0 should be raveled into a single vector, with data_1 states first, then data_2 states + np.testing.assert_allclose( + x0_v, np.array([1.0, 0.0, 0.0, 0.0, 2.0, 0.0, 0.0, 0.0]), atol=ATOL, rtol=RTOL + ) + + # T_v shape: (8, 8) (k_endog * k_states) + # The transition matrix is block diagonal, each block is: + # For n=2, season_length=4: + # lambda_1 = 2*pi*1/4 = pi/2, cos(pi/2)=0, sin(pi/2)=1 + # lambda_2 = 2*pi*2/4 = pi, cos(pi)=-1, sin(pi)=0 + # Block 1 (Cos_0, Sin_0): + # [[cos(pi/2), sin(pi/2)], + # [-sin(pi/2), cos(pi/2)]] = [[0, 1], [-1, 0]] + # Block 2 (Cos_1, Sin_1): + # [[-1, 0], [0, -1]] + expected_T_block1 = np.array([[0.0, 1.0], [-1.0, 0.0]]) + expected_T_block2 = np.array([[-1.0, 0.0], [0.0, -1.0]]) + expected_T = np.zeros((8, 8)) + # data_1 + expected_T[0:2, 0:2] = expected_T_block1 + expected_T[2:4, 2:4] = expected_T_block2 + # data_2 + expected_T[4:6, 4:6] = expected_T_block1 + expected_T[6:8, 6:8] = expected_T_block2 + np.testing.assert_allclose(T_v, expected_T, atol=ATOL, rtol=RTOL) + + # Only the first two states (one sin and one cos component) of each observed series are observed + expected_Z = np.zeros((2, 8)) + expected_Z[0, 0] = 1.0 + expected_Z[0, 2] = 1.0 + expected_Z[1, 4] = 1.0 + expected_Z[1, 6] = 1.0 + np.testing.assert_allclose(Z_v, expected_Z, atol=ATOL, rtol=RTOL) + + np.testing.assert_allclose(R_v, np.eye(8), atol=ATOL, rtol=RTOL) + + Q_diag = np.diag(Q_v) + expected_Q_diag = np.r_[np.full(4, 0.1**2), np.full(4, 0.8**2)] + np.testing.assert_allclose(Q_diag, expected_Q_diag, atol=ATOL, rtol=RTOL) + + +def test_add_two_frequency_seasonality_different_observed(rng): + mod1 = st.FrequencySeasonality( + season_length=4, + n=2, # saturated + name="freq1", + innovations=True, + observed_state_names=["data_1"], + ) + mod2 = st.FrequencySeasonality( + season_length=6, + n=1, # unsaturated + name="freq2", + innovations=True, + observed_state_names=["data_2"], + ) + + mod = (mod1 + mod2).build(verbose=False) + + params = { + "freq1": np.array([1.0, 0.0, 0.0], dtype=config.floatX), + "freq2": np.array([3.0, 0.0], dtype=config.floatX), + "sigma_freq1": np.array(0.0, dtype=config.floatX), + "sigma_freq2": np.array(0.0, dtype=config.floatX), + "initial_state_cov": np.eye(mod.k_states, dtype=config.floatX), + } + + x, y = simulate_from_numpy_model(mod, rng, params, steps=4 * 6 * 3) + + assert_pattern_repeats(y[:, 0], 4, atol=ATOL, rtol=RTOL) + assert_pattern_repeats(y[:, 1], 6, atol=ATOL, rtol=RTOL) + + assert mod.state_names == [ + "freq1_Cos_0[data_1]", + "freq1_Sin_0[data_1]", + "freq1_Cos_1[data_1]", + "freq1_Sin_1[data_1]", + "freq2_Cos_0[data_2]", + "freq2_Sin_0[data_2]", + ] + + assert mod.shock_names == [ + "freq1_Cos_0[data_1]", + "freq1_Sin_0[data_1]", + "freq1_Cos_1[data_1]", + "freq1_Sin_1[data_1]", + "freq2_Cos_0[data_2]", + "freq2_Sin_0[data_2]", + ] + + x0, *_, T = mod._unpack_statespace_with_placeholders()[:5] + input_vars = explicit_graph_inputs([x0, T]) + fn = pytensor.function( + inputs=list(input_vars), + outputs=[x0, T], + mode="FAST_COMPILE", + ) + + x0_v, T_v = fn( + freq1=np.array([1.0, 0.0, 1.2], dtype=config.floatX), + freq2=np.array([3.0, 0.0], dtype=config.floatX), + ) + + # Make sure the extra 0 in from the first component (the saturated state) is there! + np.testing.assert_allclose(np.array([1.0, 0.0, 1.2, 0.0, 3.0, 0.0]), x0_v, atol=ATOL, rtol=RTOL) + + # Transition matrix is block diagonal: 4x4 for freq1, 2x2 for freq2 + # freq1: n=4, lambdas = 2*pi*1/6, 2*pi*2/6 + lam1 = 2 * np.pi * 1 / 4 + lam2 = 2 * np.pi * 2 / 4 + freq1_T1 = np.array([[np.cos(lam1), np.sin(lam1)], [-np.sin(lam1), np.cos(lam1)]]) + freq1_T2 = np.array([[np.cos(lam2), np.sin(lam2)], [-np.sin(lam2), np.cos(lam2)]]) + freq1_T = np.zeros((4, 4)) + + # freq2: n=4, lambdas = 2*pi*1/6 + lam3 = 2 * np.pi * 1 / 6 + freq2_T = np.array([[np.cos(lam3), np.sin(lam3)], [-np.sin(lam3), np.cos(lam3)]]) + + freq1_T[0:2, 0:2] = freq1_T1 + freq1_T[2:4, 2:4] = freq1_T2 + + expected_T = np.zeros((6, 6)) + expected_T[0:4, 0:4] = freq1_T + expected_T[4:6, 4:6] = freq2_T + + np.testing.assert_allclose(expected_T, T_v, atol=ATOL, rtol=RTOL) diff --git a/tests/statespace/models/structural/conftest.py b/tests/statespace/models/structural/conftest.py new file mode 100644 index 000000000..b9e58ca68 --- /dev/null +++ b/tests/statespace/models/structural/conftest.py @@ -0,0 +1,29 @@ +import numpy as np +import pytest + +from pymc_extras.statespace.utils.constants import ( + ALL_STATE_AUX_DIM, + ALL_STATE_DIM, + OBS_STATE_AUX_DIM, + OBS_STATE_DIM, + SHOCK_AUX_DIM, + SHOCK_DIM, +) + +TEST_SEED = sum(map(ord, "Structural Statespace")) + + +@pytest.fixture(scope="session") +def rng(): + return np.random.default_rng(TEST_SEED) + + +def _assert_basic_coords_correct(mod): + assert mod.coords[ALL_STATE_DIM] == mod.state_names + assert mod.coords[ALL_STATE_AUX_DIM] == mod.state_names + assert mod.coords[SHOCK_DIM] == mod.shock_names + assert mod.coords[SHOCK_AUX_DIM] == mod.shock_names + expected_obs = mod.observed_state_names if hasattr(mod, "observed_state_names") else ["data"] + + assert mod.coords[OBS_STATE_DIM] == expected_obs + assert mod.coords[OBS_STATE_AUX_DIM] == expected_obs diff --git a/tests/statespace/models/test_structural.py b/tests/statespace/models/structural/test_against_statsmodels.py similarity index 60% rename from tests/statespace/models/test_structural.py rename to tests/statespace/models/structural/test_against_statsmodels.py index 1662e164a..1db4350b5 100644 --- a/tests/statespace/models/test_structural.py +++ b/tests/statespace/models/structural/test_against_statsmodels.py @@ -4,15 +4,11 @@ from collections import defaultdict import numpy as np -import pandas as pd -import pymc as pm import pytensor -import pytensor.tensor as pt import pytest import statsmodels.api as sm from numpy.testing import assert_allclose -from scipy import linalg from pymc_extras.statespace import structural as st from pymc_extras.statespace.utils.constants import ( @@ -29,8 +25,6 @@ rng, ) from tests.statespace.test_utilities import ( - assert_pattern_repeats, - simulate_from_numpy_model, unpack_symbolic_matrices_with_params, ) @@ -106,15 +100,6 @@ def _assert_coord_shapes_match_matrices(mod, params): ), f"Q expected to have shape (n_shocks, n_shocks), found {Q.shape[-2:]}" -def _assert_basic_coords_correct(mod): - assert mod.coords[ALL_STATE_DIM] == mod.state_names - assert mod.coords[ALL_STATE_AUX_DIM] == mod.state_names - assert mod.coords[SHOCK_DIM] == mod.shock_names - assert mod.coords[SHOCK_AUX_DIM] == mod.shock_names - assert mod.coords[OBS_STATE_DIM] == ["data"] - assert mod.coords[OBS_STATE_AUX_DIM] == ["data"] - - def _assert_keys_match(test_dict, expected_dict): expected_keys = list(expected_dict.keys()) param_keys = list(test_dict.keys()) @@ -235,7 +220,7 @@ def create_structural_model_and_equivalent_statsmodel( if level: level_trend_order[0] = 1 - expected_coords["trend_state"] += [ + expected_coords["level_state"] += [ "level", ] expected_coords[ALL_STATE_DIM] += [ @@ -246,7 +231,7 @@ def create_structural_model_and_equivalent_statsmodel( ] if stochastic_level: level_trend_innov_order[0] = 1 - expected_coords["trend_shock"] += ["level"] + expected_coords["level_shock"] += ["level"] expected_coords[SHOCK_DIM] += [ "level", ] @@ -256,7 +241,7 @@ def create_structural_model_and_equivalent_statsmodel( if trend: level_trend_order[1] = 1 - expected_coords["trend_state"] += [ + expected_coords["level_state"] += [ "trend", ] expected_coords[ALL_STATE_DIM] += [ @@ -268,12 +253,12 @@ def create_structural_model_and_equivalent_statsmodel( if stochastic_trend: level_trend_innov_order[1] = 1 - expected_coords["trend_shock"] += ["trend"] + expected_coords["level_shock"] += ["trend"] expected_coords[SHOCK_DIM] += ["trend"] expected_coords[SHOCK_AUX_DIM] += ["trend"] if level or trend: - expected_param_dims["initial_trend"] += ("trend_state",) + expected_param_dims["level_initial"] += ("level_state",) level_value = np.where( level_trend_order, rng.normal( @@ -287,13 +272,13 @@ def create_structural_model_and_equivalent_statsmodel( max_order = np.flatnonzero(level_value)[-1].item() + 1 level_trend_order = level_trend_order[:max_order] - params["initial_trend"] = level_value[:max_order] + params["level_initial"] = level_value[:max_order] sm_init["level"] = level_value[0] sm_init["trend"] = level_value[1] if sum(level_trend_innov_order) > 0: - expected_param_dims["sigma_trend"] += ("trend_shock",) - params["sigma_trend"] = np.sqrt(sigma_level_value2) + expected_param_dims["level_sigma"] += ("level_shock",) + params["level_sigma"] = np.sqrt(sigma_level_value2) sigma_level_value = sigma_level_value2.tolist() if stochastic_level: @@ -419,20 +404,20 @@ def create_structural_model_and_equivalent_statsmodel( components.append(comp) if autoregressive is not None: - ar_names = [f"L{i+1}.data" for i in range(autoregressive)] + ar_names = [f"L{i+1}" for i in range(autoregressive)] ar_params = rng.normal(size=(autoregressive,)).astype(floatX) if autoregressive == 1: ar_params = ar_params.item() sigma2 = np.abs(rng.normal()).astype(floatX) params["ar_params"] = ar_params - params["sigma_ar"] = np.sqrt(sigma2) + params["ar_sigma"] = np.sqrt(sigma2) expected_param_dims["ar_params"] += (AR_PARAM_DIM,) expected_coords[AR_PARAM_DIM] += tuple(list(range(1, autoregressive + 1))) expected_coords[ALL_STATE_DIM] += ar_names expected_coords[ALL_STATE_AUX_DIM] += ar_names - expected_coords[SHOCK_DIM] += ["ar_innovation"] - expected_coords[SHOCK_AUX_DIM] += ["ar_innovation"] + expected_coords[SHOCK_DIM] += ["ar"] + expected_coords[SHOCK_AUX_DIM] += ["ar"] sm_params["sigma2.ar"] = sigma2 for i, rho in enumerate(ar_params): @@ -548,293 +533,3 @@ def test_structural_model_against_statsmodels( _assert_param_dims_correct(built_model.param_dims, expected_dims) _assert_coords_correct(built_model.coords, expected_coords) _assert_params_info_correct(built_model.param_info, built_model.coords, built_model.param_dims) - - -def test_level_trend_model(rng): - mod = st.LevelTrendComponent(order=2, innovations_order=0) - params = {"initial_trend": [0.0, 1.0]} - x, y = simulate_from_numpy_model(mod, rng, params) - - assert_allclose(np.diff(y), 1, atol=ATOL, rtol=RTOL) - - # Check coords - mod = mod.build(verbose=False) - _assert_basic_coords_correct(mod) - assert mod.coords["trend_state"] == ["level", "trend"] - - -def test_measurement_error(rng): - mod = st.MeasurementError("obs") + st.LevelTrendComponent(order=2) - mod = mod.build(verbose=False) - - _assert_basic_coords_correct(mod) - assert "sigma_obs" in mod.param_names - - -@pytest.mark.parametrize("order", [1, 2, [1, 0, 1]], ids=["AR1", "AR2", "AR(1,0,1)"]) -def test_autoregressive_model(order, rng): - ar = st.AutoregressiveComponent(order=order) - params = { - "ar_params": np.full((sum(ar.order),), 0.5, dtype=floatX), - "sigma_ar": 0.0, - } - - x, y = simulate_from_numpy_model(ar, rng, params, steps=100) - - # Check coords - ar.build(verbose=False) - _assert_basic_coords_correct(ar) - lags = np.arange(len(order) if isinstance(order, list) else order, dtype="int") + 1 - if isinstance(order, list): - lags = lags[np.flatnonzero(order)] - assert_allclose(ar.coords["ar_lag"], lags) - - -@pytest.mark.parametrize("s", [10, 25, 50]) -@pytest.mark.parametrize("innovations", [True, False]) -@pytest.mark.parametrize("remove_first_state", [True, False]) -@pytest.mark.filterwarnings( - "ignore:divide by zero encountered in matmul:RuntimeWarning", - "ignore:overflow encountered in matmul:RuntimeWarning", - "ignore:invalid value encountered in matmul:RuntimeWarning", -) -def test_time_seasonality(s, innovations, remove_first_state, rng): - def random_word(rng): - return "".join(rng.choice(list("abcdefghijklmnopqrstuvwxyz")) for _ in range(5)) - - state_names = [random_word(rng) for _ in range(s)] - mod = st.TimeSeasonality( - season_length=s, - innovations=innovations, - name="season", - state_names=state_names, - remove_first_state=remove_first_state, - ) - x0 = np.zeros(mod.k_states, dtype=floatX) - x0[0] = 1 - - params = {"season_coefs": x0} - if mod.innovations: - params["sigma_season"] = 0.0 - - x, y = simulate_from_numpy_model(mod, rng, params) - y = y.ravel() - if not innovations: - assert_pattern_repeats(y, s, atol=ATOL, rtol=RTOL) - - # Check coords - mod.build(verbose=False) - _assert_basic_coords_correct(mod) - test_slice = slice(1, None) if remove_first_state else slice(None) - assert mod.coords["season_state"] == state_names[test_slice] - - -def get_shift_factor(s): - s_str = str(s) - if "." not in s_str: - return 1 - _, decimal = s_str.split(".") - return 10 ** len(decimal) - - -@pytest.mark.parametrize("n", [*np.arange(1, 6, dtype="int").tolist(), None]) -@pytest.mark.parametrize("s", [5, 10, 25, 25.2]) -def test_frequency_seasonality(n, s, rng): - mod = st.FrequencySeasonality(season_length=s, n=n, name="season") - x0 = rng.normal(size=mod.n_coefs).astype(floatX) - params = {"season": x0, "sigma_season": 0.0} - k = get_shift_factor(s) - T = int(s * k) - - x, y = simulate_from_numpy_model(mod, rng, params, steps=2 * T) - assert_pattern_repeats(y, T, atol=ATOL, rtol=RTOL) - - # Check coords - mod.build(verbose=False) - _assert_basic_coords_correct(mod) - if n is None: - n = int(s // 2) - states = [f"season_{f}_{i}" for i in range(n) for f in ["Cos", "Sin"]] - - # Remove the last state when the model is completely saturated - if s / n == 2.0: - states.pop() - assert mod.coords["season_state"] == states - - -cycle_test_vals = zip([None, None, 3, 5, 10], [False, True, True, False, False]) - - -def test_cycle_component_deterministic(rng): - cycle = st.CycleComponent( - name="cycle", cycle_length=12, estimate_cycle_length=False, innovations=False - ) - params = {"cycle": np.array([1.0, 1.0], dtype=floatX)} - x, y = simulate_from_numpy_model(cycle, rng, params, steps=12 * 12) - - assert_pattern_repeats(y, 12, atol=ATOL, rtol=RTOL) - - -def test_cycle_component_with_dampening(rng): - cycle = st.CycleComponent( - name="cycle", cycle_length=12, estimate_cycle_length=False, innovations=False, dampen=True - ) - params = {"cycle": np.array([10.0, 10.0], dtype=floatX), "cycle_dampening_factor": 0.75} - x, y = simulate_from_numpy_model(cycle, rng, params, steps=100) - - # Check that the cycle dampens to zero over time - assert_allclose(y[-1], 0.0, atol=ATOL, rtol=RTOL) - - -def test_cycle_component_with_innovations_and_cycle_length(rng): - cycle = st.CycleComponent( - name="cycle", estimate_cycle_length=True, innovations=True, dampen=True - ) - params = { - "cycle": np.array([1.0, 1.0], dtype=floatX), - "cycle_length": 12.0, - "cycle_dampening_factor": 0.95, - "sigma_cycle": 1.0, - } - - x, y = simulate_from_numpy_model(cycle, rng, params) - - cycle.build(verbose=False) - _assert_basic_coords_correct(cycle) - - -def test_exogenous_component(rng): - data = rng.normal(size=(100, 2)).astype(floatX) - mod = st.RegressionComponent(state_names=["feature_1", "feature_2"], name="exog") - - params = {"beta_exog": np.array([1.0, 2.0], dtype=floatX)} - exog_data = {"data_exog": data} - x, y = simulate_from_numpy_model(mod, rng, params, exog_data) - - # Check that the generated data is just a linear regression - assert_allclose(y, data @ params["beta_exog"], atol=ATOL, rtol=RTOL) - - mod.build(verbose=False) - _assert_basic_coords_correct(mod) - assert mod.coords["exog_state"] == ["feature_1", "feature_2"] - - -def test_adding_exogenous_component(rng): - data = rng.normal(size=(100, 2)).astype(floatX) - reg = st.RegressionComponent(state_names=["a", "b"], name="exog") - ll = st.LevelTrendComponent(name="level") - - seasonal = st.FrequencySeasonality(name="annual", season_length=12, n=4) - mod = reg + ll + seasonal - - assert mod.ssm["design"].eval({"data_exog": data}).shape == (100, 1, 2 + 2 + 8) - assert_allclose(mod.ssm["design", 5, 0, :2].eval({"data_exog": data}), data[5]) - - -def test_add_components(): - ll = st.LevelTrendComponent(order=2) - se = st.TimeSeasonality(name="seasonal", season_length=12) - mod = ll + se - - ll_params = { - "initial_trend": np.zeros(2, dtype=floatX), - "sigma_trend": np.ones(2, dtype=floatX), - } - se_params = { - "seasonal_coefs": np.ones(11, dtype=floatX), - "sigma_seasonal": 1.0, - } - all_params = ll_params.copy() - all_params.update(se_params) - - (ll_x0, ll_P0, ll_c, ll_d, ll_T, ll_Z, ll_R, ll_H, ll_Q) = unpack_symbolic_matrices_with_params( - ll, ll_params - ) - (se_x0, se_P0, se_c, se_d, se_T, se_Z, se_R, se_H, se_Q) = unpack_symbolic_matrices_with_params( - se, se_params - ) - x0, P0, c, d, T, Z, R, H, Q = unpack_symbolic_matrices_with_params(mod, all_params) - - for property in ["param_names", "shock_names", "param_info", "coords", "param_dims"]: - assert [x in getattr(mod, property) for x in getattr(ll, property)] - assert [x in getattr(mod, property) for x in getattr(se, property)] - - ll_mats = [ll_T, ll_R, ll_Q] - se_mats = [se_T, se_R, se_Q] - all_mats = [T, R, Q] - - for ll_mat, se_mat, all_mat in zip(ll_mats, se_mats, all_mats): - assert_allclose(all_mat, linalg.block_diag(ll_mat, se_mat), atol=ATOL, rtol=RTOL) - - ll_mats = [ll_x0, ll_c, ll_Z] - se_mats = [se_x0, se_c, se_Z] - all_mats = [x0, c, Z] - axes = [0, 0, 1] - - for ll_mat, se_mat, all_mat, axis in zip(ll_mats, se_mats, all_mats, axes): - assert_allclose(all_mat, np.concatenate([ll_mat, se_mat], axis=axis), atol=ATOL, rtol=RTOL) - - -def test_filter_scans_time_varying_design_matrix(rng): - time_idx = pd.date_range(start="2000-01-01", freq="D", periods=100) - data = pd.DataFrame(rng.normal(size=(100, 2)), columns=["a", "b"], index=time_idx) - - y = pd.DataFrame(rng.normal(size=(100, 1)), columns=["data"], index=time_idx) - - reg = st.RegressionComponent(state_names=["a", "b"], name="exog") - mod = reg.build(verbose=False) - - with pm.Model(coords=mod.coords) as m: - data_exog = pm.Data("data_exog", data.values) - - x0 = pm.Normal("x0", dims=["state"]) - P0 = pm.Deterministic("P0", pt.eye(mod.k_states), dims=["state", "state_aux"]) - beta_exog = pm.Normal("beta_exog", dims=["exog_state"]) - - mod.build_statespace_graph(y) - x0, P0, c, d, T, Z, R, H, Q = mod.unpack_statespace() - pm.Deterministic("Z", Z) - - prior = pm.sample_prior_predictive(draws=10) - - prior_Z = prior.prior.Z.values - assert prior_Z.shape == (1, 10, 100, 1, 2) - assert_allclose(prior_Z[0, :, :, 0, :], data.values[None].repeat(10, axis=0)) - - -@pytest.mark.skipif(floatX.endswith("32"), reason="Prior covariance not PSD at half-precision") -def test_extract_components_from_idata(rng): - time_idx = pd.date_range(start="2000-01-01", freq="D", periods=100) - data = pd.DataFrame(rng.normal(size=(100, 2)), columns=["a", "b"], index=time_idx) - - y = pd.DataFrame(rng.normal(size=(100, 1)), columns=["data"], index=time_idx) - - ll = st.LevelTrendComponent() - season = st.FrequencySeasonality(name="seasonal", season_length=12, n=2, innovations=False) - reg = st.RegressionComponent(state_names=["a", "b"], name="exog") - me = st.MeasurementError("obs") - mod = (ll + season + reg + me).build(verbose=False) - - with pm.Model(coords=mod.coords) as m: - data_exog = pm.Data("data_exog", data.values) - - x0 = pm.Normal("x0", dims=["state"]) - P0 = pm.Deterministic("P0", pt.eye(mod.k_states), dims=["state", "state_aux"]) - beta_exog = pm.Normal("beta_exog", dims=["exog_state"]) - initial_trend = pm.Normal("initial_trend", dims=["trend_state"]) - sigma_trend = pm.Exponential("sigma_trend", 1, dims=["trend_shock"]) - seasonal_coefs = pm.Normal("seasonal", dims=["seasonal_state"]) - sigma_obs = pm.Exponential("sigma_obs", 1) - - mod.build_statespace_graph(y) - - x0, P0, c, d, T, Z, R, H, Q = mod.unpack_statespace() - prior = pm.sample_prior_predictive(draws=10) - - filter_prior = mod.sample_conditional_prior(prior) - comp_prior = mod.extract_components_from_idata(filter_prior) - comp_states = comp_prior.filtered_prior.coords["state"].values - expected_states = ["LevelTrend[level]", "LevelTrend[trend]", "seasonal", "exog[a]", "exog[b]"] - missing = set(comp_states) - set(expected_states) - - assert len(missing) == 0, missing diff --git a/tests/statespace/models/structural/test_core.py b/tests/statespace/models/structural/test_core.py new file mode 100644 index 000000000..62bd235d4 --- /dev/null +++ b/tests/statespace/models/structural/test_core.py @@ -0,0 +1,112 @@ +import numpy as np +import pandas as pd +import pymc as pm +import pytest + +from numpy.testing import assert_allclose +from pytensor import config +from pytensor import tensor as pt +from scipy import linalg + +from pymc_extras.statespace.models import structural as st +from tests.statespace.test_utilities import unpack_symbolic_matrices_with_params + +floatX = config.floatX +ATOL = 1e-8 if floatX.endswith("64") else 1e-4 +RTOL = 0 if floatX.endswith("64") else 1e-6 + + +def test_add_components(): + ll = st.LevelTrendComponent(order=2) + se = st.TimeSeasonality(name="seasonal", season_length=12) + mod = ll + se + + ll_params = { + "level_trend_initial": np.zeros(2, dtype=floatX), + "level_trend_sigma": np.ones(2, dtype=floatX), + } + se_params = { + "seasonal_coefs": np.ones(11, dtype=floatX), + "sigma_seasonal": 1.0, + } + all_params = ll_params.copy() + all_params.update(se_params) + + (ll_x0, ll_P0, ll_c, ll_d, ll_T, ll_Z, ll_R, ll_H, ll_Q) = unpack_symbolic_matrices_with_params( + ll, ll_params + ) + (se_x0, se_P0, se_c, se_d, se_T, se_Z, se_R, se_H, se_Q) = unpack_symbolic_matrices_with_params( + se, se_params + ) + x0, P0, c, d, T, Z, R, H, Q = unpack_symbolic_matrices_with_params(mod, all_params) + + for property in ["param_names", "shock_names", "param_info", "coords", "param_dims"]: + assert [x in getattr(mod, property) for x in getattr(ll, property)] + assert [x in getattr(mod, property) for x in getattr(se, property)] + + assert (mod.observed_state_names == ll.observed_state_names) and ( + ll.observed_state_names == se.observed_state_names + ) + + ll_mats = [ll_T, ll_R, ll_Q] + se_mats = [se_T, se_R, se_Q] + all_mats = [T, R, Q] + + for ll_mat, se_mat, all_mat in zip(ll_mats, se_mats, all_mats): + assert_allclose(all_mat, linalg.block_diag(ll_mat, se_mat), atol=ATOL, rtol=RTOL) + + ll_mats = [ll_x0, ll_c, ll_Z] + se_mats = [se_x0, se_c, se_Z] + all_mats = [x0, c, Z] + axes = [0, 0, 1] + + for ll_mat, se_mat, all_mat, axis in zip(ll_mats, se_mats, all_mats, axes): + assert_allclose(all_mat, np.concatenate([ll_mat, se_mat], axis=axis), atol=ATOL, rtol=RTOL) + + +def test_add_components_multiple_observed(): + ll = st.LevelTrendComponent(order=2, observed_state_names=["data_1", "data_2"]) + me = st.MeasurementError(name="obs", observed_state_names=["data_1", "data_2"]) + + mod = (ll + me).build() + + for property in ["param_names", "shock_names", "param_info", "coords", "param_dims"]: + assert [x in getattr(mod, property) for x in getattr(ll, property)] + + +@pytest.mark.skipif(floatX.endswith("32"), reason="Prior covariance not PSD at half-precision") +def test_extract_components_from_idata(rng): + time_idx = pd.date_range(start="2000-01-01", freq="D", periods=100) + data = pd.DataFrame(rng.normal(size=(100, 2)), columns=["a", "b"], index=time_idx) + + y = pd.DataFrame(rng.normal(size=(100, 1)), columns=["data"], index=time_idx) + + ll = st.LevelTrendComponent() + season = st.FrequencySeasonality(name="seasonal", season_length=12, n=2, innovations=False) + reg = st.RegressionComponent(state_names=["a", "b"], name="exog") + me = st.MeasurementError("obs") + mod = (ll + season + reg + me).build(verbose=False) + + with pm.Model(coords=mod.coords) as m: + data_exog = pm.Data("data_exog", data.values) + + x0 = pm.Normal("x0", dims=["state"]) + P0 = pm.Deterministic("P0", pt.eye(mod.k_states), dims=["state", "state_aux"]) + beta_exog = pm.Normal("beta_exog", dims=["exog_state"]) + initial_trend = pm.Normal("level_trend_initial", dims=["level_trend_state"]) + sigma_trend = pm.Exponential("level_trend_sigma", 1, dims=["level_trend_shock"]) + seasonal_coefs = pm.Normal("seasonal", dims=["seasonal_state"]) + sigma_obs = pm.Exponential("sigma_obs", 1) + + mod.build_statespace_graph(y) + + x0, P0, c, d, T, Z, R, H, Q = mod.unpack_statespace() + prior = pm.sample_prior_predictive(draws=10) + + filter_prior = mod.sample_conditional_prior(prior) + comp_prior = mod.extract_components_from_idata(filter_prior) + comp_states = comp_prior.filtered_prior.coords["state"].values + expected_states = ["level_trend[level]", "level_trend[trend]", "seasonal", "exog[a]", "exog[b]"] + missing = set(comp_states) - set(expected_states) + + assert len(missing) == 0, missing diff --git a/tests/statespace/models/test_utilities.py b/tests/statespace/models/test_utilities.py new file mode 100644 index 000000000..b667658e4 --- /dev/null +++ b/tests/statespace/models/test_utilities.py @@ -0,0 +1,298 @@ +import numpy as np +import pytest + +from pytensor import function +from pytensor import tensor as pt + +from pymc_extras.statespace.models.utilities import ( + add_tensors_by_dim_labels, + join_tensors_by_dim_labels, + reorder_from_labels, +) + + +def test_reorder_from_labels(): + x = pt.tensor("x", shape=(None, None)) + labels = ["A", "B", "D"] + combined_labels = ["A", "D", "B"] + + x_sorted = reorder_from_labels(x, labels, combined_labels, labeled_axis=0) + fn = function([x], x_sorted) + + test_val = np.eye(3) * np.arange(1, 4) + idx = np.array([0, 2, 1]) + out = fn(test_val) + np.testing.assert_allclose(out, test_val[idx, :]) + + x_sorted = reorder_from_labels(x, labels, combined_labels, labeled_axis=1) + fn = function([x], x_sorted) + + out = fn(test_val) + np.testing.assert_allclose(out, test_val[:, idx]) + + x_sorted = reorder_from_labels(x, labels, combined_labels, labeled_axis=(0, 1)) + fn = function([x], x_sorted) + + out = fn(test_val) + np.testing.assert_allclose(out, test_val[np.ix_(idx, idx)]) + + +def make_zeros(x): + if x.ndim == 1: + zeros = np.zeros( + 1, + ) + else: + zeros = np.zeros((x.shape[0], 1)) + return zeros + + +def add(left, right): + return left + right + + +def same_but_mixed(left, right): + return left + right[..., np.array([1, 2, 0])] + + +def concat(left, right): + return np.concatenate([left, right], axis=-1) + + +def pad_and_add_left(left, right): + left = np.concatenate([left, make_zeros(left)], axis=-1) + return left + right + + +def pad_and_add_right(left, right): + right = np.concatenate([right, make_zeros(right)], axis=-1) + return left + right + + +def mixed_and_padded(left, right): + left = np.concatenate([left, make_zeros(left)], axis=-1) + right = right[..., np.array([2, 1, 0])] + return left + right + + +@pytest.mark.parametrize( + "left_names, right_names, expected_computation", + [ + (["data"], ["data"], add), + (["A", "C", "B"], ["B", "A", "C"], same_but_mixed), + (["data"], ["different_data"], concat), + (["data"], ["data", "different_data"], pad_and_add_left), + (["data", "more_data"], ["data"], pad_and_add_right), + (["A", "B"], ["D", "B", "A"], mixed_and_padded), + ], + ids=[ + "same_names", + "same_but_mixed", + "different_names", + "overlap_right", + "overlap_left", + "pad_and_mix", + ], +) +@pytest.mark.parametrize("ndim", [1, 2], ids=["vector", "matrix"]) +def test_add_matrices_by_observed_state_names(left_names, right_names, expected_computation, ndim): + rng = np.random.default_rng() + n_left = len(left_names) + n_right = len(right_names) + + left = pt.tensor("left", shape=(None,) * ndim) + right = pt.tensor("right", shape=(None,) * ndim) + + result = add_tensors_by_dim_labels(left, right, left_names, right_names) + fn = function([left, right], result) + + left_value = rng.normal(size=(n_left,) if ndim == 1 else (10, n_left)) + right_value = rng.normal(size=(n_right,) if ndim == 1 else (10, n_right)) + + np.testing.assert_allclose( + fn(left_value, right_value), expected_computation(left_value, right_value) + ) + + +class TestAddCovarianceMatrices: + def _setup_H(self, states_1, states_2): + n_1 = len(states_1) + n_2 = len(states_2) + + H_1 = pt.tensor("H_1", shape=(n_1, n_1)) + H_2 = pt.tensor("H_2", shape=(n_2, n_2)) + + return H_1, H_2 + + @pytest.mark.parametrize("n_states", [1, 3], ids=["1x1", "3x3"]) + def test_add_fully_overlapping_covariance_matrices(self, n_states): + rng = np.random.default_rng() + states = list("ABCD") + + observed_states_1 = states[:n_states] + observed_states_2 = states[:n_states] + + H_1, H_2 = self._setup_H(observed_states_1, observed_states_2) + res = add_tensors_by_dim_labels( + H_1, H_2, observed_states_1, observed_states_2, labeled_axis=(0, 1) + ) + + fn = function([H_1, H_2], res) + + H_1_val = rng.normal(size=(n_states, n_states)) + H_2_val = rng.normal(size=(n_states, n_states)) + + np.testing.assert_allclose(fn(H_1_val, H_2_val), H_1_val + H_2_val) + + def test_add_fully_overlapping_mixed_covariance_matrices(self): + rng = np.random.default_rng() + + observed_states_1 = ["A", "B", "C", "D"] + observed_states_2 = ["A", "B", "C", "D"] + rng.shuffle(observed_states_2) + + H_1, H_2 = self._setup_H(observed_states_1, observed_states_2) + + res = add_tensors_by_dim_labels( + H_1, H_2, observed_states_1, observed_states_2, labeled_axis=(0, 1) + ) + + H_1_val = rng.normal(size=(4, 4)) + H_2_val = rng.normal(size=(4, 4)) + + fn = function([H_1, H_2], res) + + state_to_idx = {name: idx for idx, name in enumerate(observed_states_1)} + idx = np.argsort([state_to_idx[state] for state in observed_states_2]) + + np.testing.assert_allclose(fn(H_1_val, H_2_val), H_1_val + H_2_val[np.ix_(idx, idx)]) + + def test_add_non_overlapping_covaraince_matrices(self): + rng = np.random.default_rng() + + observed_states_1 = ["A", "B"] + observed_states_2 = ["C", "D"] + + H_1, H_2 = self._setup_H(observed_states_1, observed_states_2) + + res = add_tensors_by_dim_labels( + H_1, H_2, observed_states_1, observed_states_2, labeled_axis=(0, 1) + ) + + H_1_val = rng.normal(size=(2, 2)) + H_2_val = rng.normal(size=(2, 2)) + zeros = np.zeros_like(H_1_val) + + fn = function([H_1, H_2], res) + + np.testing.assert_allclose( + fn(H_1_val, H_2_val), np.block([[H_1_val, zeros], [zeros, H_2_val]]) + ) + + def test_add_partially_overlapping_covaraince_matrices(self): + rng = np.random.default_rng() + observed_states_1 = ["A", "B"] + observed_states_2 = ["B", "C", "D", "A"] + H_1, H_2 = self._setup_H(observed_states_1, observed_states_2) + + res = add_tensors_by_dim_labels( + H_1, H_2, observed_states_1, observed_states_2, labeled_axis=(-2, -1) + ) + + fn = function([H_1, H_2], res) + H_1_val = rng.normal(size=(2, 2)) + H_2_val = rng.normal(size=(4, 4)) + + upper = np.zeros((4, 4)) + upper_idx = np.ix_([0, 1], [0, 1]) + upper[upper_idx] = H_1_val + expected_value = upper + H_2_val[np.ix_([3, 0, 1, 2], [3, 0, 1, 2])] + + np.testing.assert_allclose(fn(H_1_val, H_2_val), expected_value) + + +class TestJoinDesignMatrices: + def _setup_Z(self, states_1, states_2, k_endog=2): + Z_1 = pt.tensor("Z_1", shape=(len(states_1), k_endog)) + Z_2 = pt.tensor("Z_2", shape=(len(states_2), k_endog)) + + return Z_1, Z_2 + + def test_join_fully_overlapping_design_matrices(self): + observed_states_1 = ["A"] + observed_states_2 = ["A"] + + Z_1, Z_2 = self._setup_Z(observed_states_1, observed_states_2) + res = join_tensors_by_dim_labels( + Z_1, Z_2, observed_states_1, observed_states_2, labeled_axis=0, join_axis=1 + ) + + fn = function([Z_1, Z_2], res) + + Z_1_val = np.array([[1.0, 0.0]]) + Z_2_val = np.array([[0.0, 1.0]]) + + np.testing.assert_allclose(fn(Z_1_val, Z_2_val), np.array([[1.0, 0.0, 0.0, 1.0]])) + + def test_join_fully_overlapping_mixed_design_matrices(self): + observed_states_1 = ["A", "B", "C"] + observed_states_2 = ["C", "B", "A"] + + Z_1, Z_2 = self._setup_Z(observed_states_1, observed_states_2, k_endog=3) + res = join_tensors_by_dim_labels( + Z_1, Z_2, observed_states_1, observed_states_2, labeled_axis=0, join_axis=1 + ) + + fn = function([Z_1, Z_2], res) + + Z_1_val = np.array([[1.0, 0.0, 1.0], [0.0, 1.0, 0.0], [1.0, 0.0, 1.0]]) + Z_2_val = np.array([[0.0, 1.0, 1.0], [1.0, 0.0, 1.0], [1.0, 0.0, 0.0]]) + + # Rows 0 and 2 should be swapped in the output, because the ordering A, B, C becomes canonical as it was passed + # in first, and because we said the labeled dim was axis=0. After reordering, the matrices should be + # concatenated on axis = 1 (again, as requested). + np.testing.assert_allclose( + fn(Z_1_val, Z_2_val), + np.array( + [ + [1.0, 0.0, 1.0, 1.0, 0.0, 0.0], + [0.0, 1.0, 0.0, 1.0, 0.0, 1.0], + [1.0, 0.0, 1.0, 0.0, 1.0, 1.0], + ] + ), + ) + + def test_join_non_overlapping_design_matrices(self): + observed_states_1 = ["A"] + observed_states_2 = ["B"] + + Z_1, Z_2 = self._setup_Z(observed_states_1, observed_states_2) + fn = function( + [Z_1, Z_2], join_tensors_by_dim_labels(Z_1, Z_2, observed_states_1, observed_states_2) + ) + + Z_1_val = np.array([[1.0, 0.0]]) + Z_2_val = np.array([[1.0, 0.0]]) + out = fn(Z_1_val, Z_2_val) + + np.testing.assert_allclose(out, [[1.0, 0.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0]]) + + def test_join_partially_overlapping_design_matrices(self): + observed_states_1 = ["A"] + observed_states_2 = ["A", "B", "C"] + + Z_1, Z_2 = self._setup_Z(observed_states_1, observed_states_2) + res = join_tensors_by_dim_labels( + Z_1, Z_2, observed_states_1, observed_states_2, labeled_axis=0, join_axis=1 + ) + fn = function([Z_1, Z_2], res) + + Z_1_val = np.array([[1.0, 0.0]]) + Z_2_val = np.array([[0.0, 1.0], [1.0, 0.0], [1.0, 0.0]]) + + # Z_1 should be zero padded with the missing observed states, then concatenated along axis = -1 + expected_output = np.array( + [[1.0, 0.0, 0.0, 1.0], [0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 1.0, 0.0]] + ) + + np.testing.assert_allclose(fn(Z_1_val, Z_2_val), expected_output) diff --git a/tests/statespace/test_utilities.py b/tests/statespace/test_utilities.py index 91c8ed513..ab054ba19 100644 --- a/tests/statespace/test_utilities.py +++ b/tests/statespace/test_utilities.py @@ -242,11 +242,12 @@ def simulate_from_numpy_model(mod, rng, param_dict, data_dict=None, steps=100): Helper function to visualize the components outside of a PyMC model context """ x0, P0, c, d, T, Z, R, H, Q = unpack_symbolic_matrices_with_params(mod, param_dict, data_dict) + k_endog = mod.k_endog k_states = mod.k_states k_posdef = mod.k_posdef x = np.zeros((steps, k_states)) - y = np.zeros(steps) + y = np.zeros((steps, k_endog)) x[0] = x0 y[0] = (Z @ x0).squeeze() if Z.ndim == 2 else (Z[0] @ x0).squeeze() @@ -272,7 +273,7 @@ def simulate_from_numpy_model(mod, rng, param_dict, data_dict=None, steps=100): else: y[t] = (d + Z[t] @ x[t] + error).squeeze() - return x, y + return x, y.squeeze() def assert_pattern_repeats(y, T, atol, rtol): diff --git a/tests/statespace/utils/test_coord_assignment.py b/tests/statespace/utils/test_coord_assignment.py index a3b419914..fe846c4fe 100644 --- a/tests/statespace/utils/test_coord_assignment.py +++ b/tests/statespace/utils/test_coord_assignment.py @@ -80,8 +80,8 @@ def _create_model(f): dims="state", ) P0 = pm.Deterministic("P0", pt.diag(P0_diag), dims=("state", "state_aux")) - initial_trend = pm.Normal("initial_trend", dims="trend_state") - sigma_trend = pm.Exponential("sigma_trend", 1, dims="trend_shock") + initial_trend = pm.Normal("level_trend_initial", dims="level_trend_state") + sigma_trend = pm.Exponential("level_trend_sigma", 1, dims="level_trend_shock") ss_mod.build_statespace_graph(data, save_kalman_filter_outputs_in_idata=True) return mod @@ -103,8 +103,8 @@ def test_model_build_without_coords(load_dataset): with pm.Model() as mod: P0_diag = pm.Exponential("P0_diag", 1, shape=(2,)) P0 = pm.Deterministic("P0", pt.diag(P0_diag)) - initial_trend = pm.Normal("initial_trend", shape=(2,)) - sigma_trend = pm.Exponential("sigma_trend", 1, shape=(2,)) + initial_trend = pm.Normal("level_trend_initial", shape=(2,)) + sigma_trend = pm.Exponential("level_trend_sigma", 1, shape=(2,)) ss_mod.build_statespace_graph(data, register_data=False) assert mod.coords == {} @@ -131,8 +131,8 @@ def make_model(index): P0_diag = pm.Gamma("P0_diag", alpha=5, beta=5) P0 = pm.Deterministic("P0", pt.eye(ss_mod.k_states) * P0_diag, dims=P0_dims) - initial_trend = pm.Normal("initial_trend", dims=initial_trend_dims) - sigma_trend = pm.Gamma("sigma_trend", alpha=2, beta=50, dims=sigma_trend_dims) + initial_trend = pm.Normal("level_trend_initial", dims=initial_trend_dims) + sigma_trend = pm.Gamma("level_trend_sigma", alpha=2, beta=50, dims=sigma_trend_dims) with pytest.warns(UserWarning, match="No time index found on the supplied data"): ss_mod.build_statespace_graph(