{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Time Series Forecasting" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In this tutorial, we will demonstrate how to build a model for time series forecasting in NumPyro. Specifically, we will replicate the **Seasonal, Global Trend (SGT)** model from the [Rlgt: Bayesian Exponential Smoothing Models with Trend Modifications](https://cran.r-project.org/web/packages/Rlgt/index.html) package. The time series data that we will use for this tutorial is the **lynx** dataset, which contains annual numbers of lynx trappings from 1821 to 1934 in Canada." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import os\n", "\n", "from IPython.display import set_matplotlib_formats\n", "import matplotlib.pyplot as plt\n", "import pandas as pd\n", "\n", "import jax.numpy as np\n", "from jax import lax, random, vmap\n", "from jax.nn import softmax\n", "\n", "import numpyro; numpyro.set_host_device_count(4)\n", "import numpyro.distributions as dist\n", "from numpyro.diagnostics import autocorrelation, hpdi\n", "from numpyro import handlers\n", "from numpyro.infer import MCMC, NUTS, Predictive\n", "\n", "if \"NUMPYRO_SPHINXBUILD\" in os.environ:\n", " set_matplotlib_formats('svg')\n", "\n", "assert numpyro.__version__.startswith('0.2.4')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Data" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "First, lets import and take a look at the dataset." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Length of time series: 114\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "URL = \"https://raw.githubusercontent.com/vincentarelbundock/Rdatasets/master/csv/datasets/lynx.csv\"\n", "lynx = pd.read_csv(URL, index_col=0)\n", "data = lynx[\"value\"].values\n", "print(\"Length of time series:\", data.shape[0])\n", "plt.figure(figsize=(8, 4))\n", "plt.plot(lynx[\"time\"], data)\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The time series has a length of 114 (a data point for each year), and by looking at the plot, we can observe [seasonality](https://en.wikipedia.org/wiki/Seasonality) in this dataset, which is the recurrence of similar patterns at specific time periods. e.g. in this dataset, we observe a cyclical pattern every 10 years, but there is also a less obvious but clear spike in the number of trappings every 40 years. Let us see if we can model this effect in NumPyro.\n", "\n", "In this tutorial, we will use the first 80 values for training and the last 34 values for testing." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "y_train, y_test = np.array(data[:80], dtype=np.float32), data[80:]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Model" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The model we are going to use is called **Seasonal, Global Trend**, which when tested on 3003 time series of the [M-3 competition](https://forecasters.org/resources/time-series-data/m3-competition/), has been known to outperform other models originally participating in the competition:\n", "\n", "$$\n", "\\begin{align}\n", "\\text{exp_val}_{t} &= \\text{level}_{t-1} + \\text{coef_trend} \\times \\text{level}_{t-1}^{\\text{pow_trend}} + \\text{s}_t \\times \\text{level}_{t-1}^{\\text{pow_season}}, \\\\\n", "\\sigma_{t} &= \\sigma \\times \\text{exp_val}_{t}^{\\text{powx}} + \\text{offset}, \\\\\n", "y_{t} &\\sim \\text{StudentT}(\\nu, \\text{exp_val}_{t}, \\sigma_{t})\n", "\\end{align}\n", "$$\n", "\n", ", where `level` and `s` follows the following recursion rules:\n", "\n", "$$\n", "\\begin{align}\n", "\\text{level_p} &=\n", "\\begin{cases}\n", "y_t - \\text{s}_t \\times \\text{level}_{t-1}^{\\text{pow_season}} & \\text{if } t \\le \\text{seasonality}, \\\\ \n", "\\text{Average} \\left[y(t - \\text{seasonality} + 1), \\ldots, y(t)\\right] & \\text{otherwise},\n", "\\end{cases} \\\\\n", "\\text{level}_{t} &= \\text{level_sm} \\times \\text{level_p} + (1 - \\text{level_sm}) \\times \\text{level}_{t-1}, \\\\\n", "\\text{s}_{t + \\text{seasonality}} &= \\text{s_sm} \\times \\frac{y_{t} - \\text{level}_{t}}{\\text{level}_{t-1}^{\\text{pow_trend}}}\n", "+ (1 - \\text{s_sm}) \\times \\text{s}_{t}.\n", "\\end{align}\n", "$$" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A more detailed explanation for SGT model can be found in [this vignette](https://cran.r-project.org/web/packages/Rlgt/vignettes/GT_models.html) from the authors of the Rlgt package. Here we summarize the core ideas of this model:\n", "\n", "+ [Student's t-distribution](https://en.wikipedia.org/wiki/Student%27s_t-distribution), which has heavier tails than normal distribution, is used for the likelihood.\n", "+ The expected value `exp_val` consists of a trending component and a seasonal component:\n", " - The trend is governed by the map $x \\mapsto x + ax^b$, where $x$ is `level`, $a$ is `coef_trend`, and $b$ is `pow_trend`. Note that when $b \\sim 0$, the trend is linear with $a$ is the slope, and when $b \\sim 1$, the trend is exponential with $a$ is the rate. So that function can cover a large family of trend.\n", " - When time changes, `level` and `s` are updated to new values. Coefficients `level_sm` and `s_sm` are used to make the transition smoothly.\n", "+ When `powx` is near $0$, the error $\\sigma_t$ will be nearly constant while when `powx` is near $1$, the error will be propotional to the expected value.\n", "+ There are several varieties of SGT. In this tutorial, we use generalized seasonality and seasonal average method." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note that `level` and `s` are updated recursively while we collect the expected value at each time step. NumPyro uses [JAX](https://github.com/google/jax) in the backend to JIT compile many critical parts of the NUTS algorithm, including the verlet integrator and the tree building process. However, doing so using Python's `for` loop in the model will result in a long compilation time for the model, so we use `jax.lax.scan` instead. A detailed explanation for using this utility can be found in [lax.scan documentation](https://jax.readthedocs.io/en/latest/_autosummary/jax.lax.scan.html#jax.lax.scan). Here we use it to collect expected values while the pair `(level, s)` plays the role of carrying state." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "def scan_exp_val(\n", " y, init_s, level_sm, s_sm, coef_trend, pow_trend, pow_season, future=0):\n", " N = y.shape[0]\n", " duration = N + future\n", " seasonality = init_s.shape[0]\n", "\n", " def scan_fn(carry, t):\n", " level, s, moving_sum = carry\n", " season = s[0] * level ** pow_season\n", " exp_val = level + coef_trend * level ** pow_trend + season\n", " exp_val = np.clip(exp_val, a_min=0)\n", " # use exoected vale when forecasting\n", " y_t = np.where(t >= N, exp_val, y[t])\n", "\n", " moving_sum = moving_sum + y[t] - \\\n", " np.where(t >= seasonality, y[t - seasonality], 0.)\n", " level_p = np.where(t >= seasonality, moving_sum / seasonality, y_t - season)\n", " level = level_sm * level_p + (1 - level_sm) * level\n", " level = np.clip(level, a_min=0)\n", "\n", " new_s = (s_sm * (y_t - level) / season + (1 - s_sm)) * s[0]\n", " # repeat s when forecasting\n", " new_s = np.where(t >= N, s[0], new_s)\n", " s = np.concatenate([s[1:], new_s[None]], axis=0)\n", " return (level, s, moving_sum), exp_val\n", "\n", " level_init = y[0]\n", " s_init = np.concatenate([init_s[1:], init_s[:1]], axis=0)\n", " moving_sum = level_init\n", " (last_level, last_s, moving_sum), exp_vals = lax.scan(\n", " scan_fn, (level_init, s_init, moving_sum), np.arange(1, duration))\n", " return exp_vals, last_level, last_s" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "With our utility function defined above, we are ready to specify the model using *NumPyro* primitives. In NumPyro, we use the primitive `sample(name, prior)` to declare a latent random variable with a corresponding `prior`. These primitives can have custom interpretations depending on the effect handlers that are used by NumPyro inference algorithms in the backend. e.g. we can condition on specific values using the `substitute` handler, or record values at these sample sites in the execution trace using the `trace` handler. Note that these details are not important for specifying the model, or running inference, but curious readers are encouraged to read the [tutorial on effect handlers](http://pyro.ai/examples/effect_handlers.html) in Pyro." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "def sgt(y, seasonality, future=0):\n", " # heuristically, standard derivation of Cauchy prior depends on\n", " # the max value of data\n", " cauchy_sd = np.max(y) / 150\n", "\n", " nu = numpyro.sample(\"nu\", dist.Uniform(2, 20))\n", " powx = numpyro.sample(\"powx\", dist.Uniform(0, 1))\n", " sigma = numpyro.sample(\"sigma\", dist.HalfCauchy(cauchy_sd))\n", " offset_sigma = numpyro.sample(\"offset_sigma\", dist.TruncatedCauchy(\n", " low=1e-10, loc=1e-10, scale=cauchy_sd))\n", "\n", " coef_trend = numpyro.sample(\"coef_trend\", dist.Cauchy(0, cauchy_sd))\n", " pow_trend_beta = numpyro.sample(\"pow_trend_beta\", dist.Beta(1, 1))\n", " # pow_trend takes values from -0.5 to 1\n", " pow_trend = 1.5 * pow_trend_beta - 0.5\n", " pow_season = numpyro.sample(\"pow_season\", dist.Beta(1, 1))\n", "\n", " level_sm = numpyro.sample(\"level_sm\", dist.Beta(1, 2))\n", " s_sm = numpyro.sample(\"s_sm\", dist.Uniform(0, 1))\n", " init_s = numpyro.sample(\"init_s\", dist.Cauchy(0, y[:seasonality] * 0.3))\n", "\n", " exp_val, last_level, last_s = scan_exp_val(\n", " y, init_s, level_sm, s_sm, coef_trend, pow_trend, pow_season, future=future)\n", " if future == 0: # training\n", " omega = sigma * exp_val ** powx + offset_sigma\n", " numpyro.sample(\"y\", dist.StudentT(nu, exp_val, omega), obs=y[1:])\n", " # we return last `level` and last `s` for custom forecasting\n", " return last_level, last_s\n", " else: # forecasting\n", " exp_val = exp_val[y.shape[0] - 1:]\n", " assert exp_val.shape[0] == future\n", " omega = sigma * exp_val ** powx + offset_sigma\n", " numpyro.sample(\"y\", dist.StudentT(nu, exp_val, omega))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note that all prior parameters are retrieved from [this file](https://github.com/cbergmeir/Rlgt/blob/master/Rlgt/R/rlgtcontrol.R) in the original source." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Inference" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "First, we want to choose a good value for `seasonality`. Following [the demo in Rlgt](https://github.com/cbergmeir/Rlgt/blob/master/Rlgt/demo/lynx.R), we will set `seasonality=38`. Indeed, this value can be guessed by looking at the plot of the training data, where the second order seasonality effect has a periodicity around $40$ years. Note that $38$ is also one of the highest-autocorrelation lags." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Lag values sorted according to their autocorrelation values:\n", "\n", "[ 0 67 57 38 68 1 29 58 37 56 28 10 19 39 66 78 47 77 9 79 48 76 30 18\n", " 20 11 46 59 69 27 55 36 2 8 40 49 17 21 75 12 65 45 31 26 7 54 35 41\n", " 50 3 22 60 70 16 44 13 6 25 74 53 42 32 23 43 51 4 15 14 34 24 5 52\n", " 73 64 33 71 72 61 63 62]\n" ] } ], "source": [ "print(\"Lag values sorted according to their autocorrelation values:\\n\") \n", "print(np.argsort(autocorrelation(y_train))[::-1])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now, let us run $4$ MCMC chains (using the No-U-Turn Sampler algorithm) with $5000$ warmup steps and $5000$ sampling steps per each chain. The returned value will be a collection of $20000$ samples." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", " mean std median 5.0% 95.0% n_eff r_hat\n", " coef_trend 35.90 141.51 13.49 -89.69 160.01 1253.52 1.00\n", " init_s[0] 93.88 115.72 68.03 -48.20 267.54 563.41 1.01\n", " init_s[1] -20.74 68.27 -22.57 -132.33 86.30 5638.05 1.00\n", " init_s[2] 31.34 91.71 21.30 -109.71 172.00 5751.88 1.00\n", " init_s[3] 126.35 123.06 109.89 -67.25 304.43 5308.82 1.00\n", " init_s[4] 449.81 249.57 407.17 72.60 799.35 3962.26 1.00\n", " init_s[5] 1192.26 459.23 1124.14 481.37 1836.72 2008.70 1.00\n", " init_s[6] 2013.44 656.04 1932.91 967.32 2981.27 2277.62 1.00\n", " init_s[7] 3725.03 1110.80 3613.86 1992.54 5409.12 1860.04 1.00\n", " init_s[8] 2606.46 840.53 2476.63 1328.71 3882.42 1682.46 1.01\n", " init_s[9] 956.78 426.92 899.53 306.73 1601.91 3984.62 1.00\n", " init_s[10] 50.27 105.87 36.33 -106.86 205.88 5185.16 1.00\n", " init_s[11] -0.19 56.79 -2.60 -77.66 75.06 1584.26 1.00\n", " init_s[12] -7.15 67.90 -10.02 -106.90 98.28 708.60 1.00\n", " init_s[13] 66.97 100.33 47.12 -74.98 216.03 5203.29 1.00\n", " init_s[14] 335.98 259.67 276.09 -12.78 709.36 3362.87 1.00\n", " init_s[15] 967.16 400.29 904.31 385.98 1558.11 849.66 1.01\n", " init_s[16] 1271.75 465.74 1209.79 557.99 1961.61 2849.68 1.00\n", " init_s[17] 1386.30 547.93 1284.83 571.16 2217.53 2725.54 1.00\n", " init_s[18] 613.97 307.38 550.73 175.59 1070.71 3319.73 1.00\n", " init_s[19] 16.35 92.00 3.67 -119.55 147.91 1989.23 1.00\n", " init_s[20] -30.11 66.05 -23.57 -144.37 63.33 4514.26 1.00\n", " init_s[21] -16.96 47.14 -6.20 -93.59 42.93 1696.88 1.00\n", " init_s[22] -0.60 43.07 -0.91 -65.73 61.91 3235.73 1.00\n", " init_s[23] 39.57 83.49 24.38 -82.75 165.80 5226.04 1.00\n", " init_s[24] 529.39 330.23 475.21 10.02 986.28 4837.91 1.00\n", " init_s[25] 942.35 457.37 864.48 277.80 1594.75 3319.35 1.00\n", " init_s[26] 1855.40 912.22 1731.51 765.43 2798.29 632.94 1.01\n", " init_s[27] 1308.19 492.55 1231.14 542.53 1982.89 715.91 1.00\n", " init_s[28] 217.56 172.60 181.49 -27.86 469.58 4992.26 1.00\n", " init_s[29] -11.99 82.70 -19.44 -142.68 108.59 2410.68 1.00\n", " init_s[30] -1.89 87.65 -8.74 -136.86 121.59 5177.89 1.00\n", " init_s[31] -39.47 75.38 -37.94 -170.10 70.53 283.89 1.01\n", " init_s[32] -9.67 86.13 -19.10 -141.70 119.14 5254.49 1.00\n", " init_s[33] 120.82 134.18 100.77 -82.96 317.41 4123.89 1.00\n", " init_s[34] 504.63 302.64 451.40 90.37 929.83 1448.21 1.00\n", " init_s[35] 1101.46 463.20 1026.01 443.47 1797.68 725.92 1.01\n", " init_s[36] 1891.59 666.78 1793.22 884.27 2871.91 1886.95 1.00\n", " init_s[37] 1433.02 573.39 1352.83 525.74 2222.67 463.54 1.01\n", " level_sm 0.00 0.00 0.00 0.00 0.00 3763.91 1.00\n", " nu 12.25 4.73 12.72 5.40 20.00 6521.37 1.00\n", " offset_sigma 33.50 30.53 25.27 0.00 72.23 5231.03 1.00\n", " pow_season 0.08 0.04 0.08 0.01 0.14 1244.31 1.01\n", " pow_trend_beta 0.26 0.18 0.24 0.00 0.51 135.08 1.02\n", " powx 0.63 0.14 0.62 0.42 0.86 358.39 1.01\n", " s_sm 0.08 0.09 0.06 0.00 0.20 637.77 1.01\n", " sigma 9.24 9.60 6.29 0.33 20.04 2796.07 1.00\n", "\n", "Number of divergences: 4402\n", "CPU times: user 1min 15s, sys: 219 ms, total: 1min 16s\n", "Wall time: 48.6 s\n" ] } ], "source": [ "%%time\n", "kernel = NUTS(sgt)\n", "mcmc = MCMC(kernel, num_warmup=5000, num_samples=5000, num_chains=4)\n", "mcmc.run(random.PRNGKey(2), y_train, seasonality=38)\n", "mcmc.print_summary()\n", "samples = mcmc.get_samples()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Forecasting" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Given `samples` from `mcmc`, we want to do forecasting for the testing dataset `y_test`. First, we will make some utilities to do forecasting given a sample. Note that to retrieve the last `level` and last `s` value, we run the model forward by constraining the latent sites to a sample from the posterior using the `substitute` handler:\n", "\n", "```python\n", "... level, s = substitute(sgt, sample)(y, seasonality)\n", "```" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "# Ref: https://github.com/cbergmeir/Rlgt/blob/master/Rlgt/R/forecast.rlgtfit.R\n", "def sgt_forecast(future, sample, y, level, s):\n", " seasonality = s.shape[0]\n", " moving_sum = np.sum(y[-seasonality:])\n", " pow_trend = 1.5 * sample[\"pow_trend_beta\"] - 0.5\n", " yfs = [0] * (seasonality + future)\n", " for t in range(future):\n", " season = s[0] * level ** sample[\"pow_season\"]\n", " exp_val = level + sample[\"coef_trend\"] * level ** pow_trend + season\n", " exp_val = np.clip(exp_val, a_min=0)\n", " omega = sample[\"sigma\"] * exp_val ** sample[\"powx\"] + sample[\"offset_sigma\"]\n", " yf = numpyro.sample(\"yf[{}]\".format(t), dist.StudentT(\n", " sample[\"nu\"], exp_val, omega))\n", " yf = np.clip(yf, a_min=1e-30)\n", " yfs[t] = yf\n", "\n", " moving_sum = moving_sum + yf - \\\n", " np.where(t >= seasonality, yfs[t - seasonality], y[-seasonality + t])\n", " level_p = moving_sum / seasonality\n", " level_tmp = sample[\"level_sm\"] * level_p + (1 - sample[\"level_sm\"]) * level\n", " level = np.where(level_tmp > 1e-30, level_tmp, level)\n", " # s is repeated instead of being updated\n", " s = np.concatenate([s[1:], s[:1]], axis=0)\n", "\n", "\n", "def forecast(future, rng_key, sample, y, seasonality):\n", " level, s = handlers.substitute(sgt, sample)(y, seasonality)\n", " forecast_model = handlers.seed(sgt_forecast, rng_key)\n", " forecast_trace = handlers.trace(forecast_model).get_trace(\n", " future, sample, y, level, s)\n", " results = [np.clip(forecast_trace[\"yf[{}]\".format(t)][\"value\"], a_min=1e-30)\n", " for t in range(future)]\n", " return np.stack(results, axis=0)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Then, we can use [jax.vmap](https://jax.readthedocs.io/en/latest/jax.html#jax.vmap) to get prediction given a collection of samples. This allows us to vectorize the computation across the test dataset which can be dramatically faster as compared to using for-loop to collect predictions per test data point." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "rng_keys = random.split(random.PRNGKey(3), samples[\"nu\"].shape[0])\n", "forecast_marginal = vmap(lambda rng_key, sample: forecast(\n", " len(y_test), rng_key, sample, y_train, seasonality=38))(rng_keys, samples)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Finally, let's get sMAPE, root mean square error of the prediction, and visualize the result with the mean prediction and the 90% highest posterior density interval (HPDI)." ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "sMAPE: 62.87, rmse: 1248.86\n" ] } ], "source": [ "y_pred = np.mean(forecast_marginal, axis=0)\n", "sMAPE = np.mean(np.abs(y_pred - y_test) / (y_pred + y_test)) * 200\n", "msqrt = np.sqrt(np.mean((y_pred - y_test) ** 2))\n", "print(\"sMAPE: {:.2f}, rmse: {:.2f}\".format(sMAPE, msqrt))" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plt.figure(figsize=(8, 4))\n", "plt.plot(lynx[\"time\"], data)\n", "t_future = lynx[\"time\"][80:]\n", "hpd_low, hpd_high = hpdi(forecast_marginal)\n", "plt.plot(t_future, y_pred, lw=2)\n", "plt.fill_between(t_future, hpd_low, hpd_high, alpha=0.3)\n", "plt.title(\"Forecasting lynx dataset with SGT model (90% HPDI)\")\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As we can observe, the model has been able to learn both the first and second order seasonality effects, i.e. a cyclical pattern with a periodicity of around 10, as well as spikes that can be seen once every 40 or so years. Moreover, we not only have point estimates for the forecast but can also use the uncertainty estimates from the model to bound our forecasts. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Forecasting using Predictive" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "NumPyro provides a convenient utility [Predictive](http://num.pyro.ai/en/stable/utilities.html#numpyro.infer.util.Predictive) to get predictive distribution. Let's see how to use it to get forecasting values.\n", "\n", "Notice that in the `sgt` model defined above, there is a keyword `future` which controls the execution of the model - depending on whether `future > 0` or `future == 0`. The following code predicts the last 34 values from the original time-series." ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "predictive = Predictive(sgt, samples, return_sites=[\"y\"])\n", "forecast2 = predictive(random.PRNGKey(4), y_train, seasonality=38, future=34)[\"y\"]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's plot the result to verify that we get the expected one." ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plt.figure(figsize=(8, 4))\n", "plt.plot(lynx[\"time\"], data)\n", "t_future = lynx[\"time\"][80:]\n", "hpd_low, hpd_high = hpdi(forecast2)\n", "plt.plot(t_future, np.mean(forecast2, axis=0), lw=2)\n", "plt.fill_between(t_future, hpd_low, hpd_high, alpha=0.3)\n", "plt.title(\"Forecasting lynx dataset with SGT model (90% HPDI)\")\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Acknowledgements\n", "\n", "We would like to thank Slawek Smyl for many helpful resources and suggestions. Fast inference would not have been possible without the support of JAX and the XLA teams, so we would like to thank them for providing such a great open-source platform for us to build on, and for their responsiveness in dealing with our feature requests and bug reports." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## References\n", "\n", "[1] `Rlgt: Bayesian Exponential Smoothing Models with Trend Modifications`,
    \n", "Slawek Smyl, Christoph Bergmeir, Erwin Wibowo, To Wang Ng, Trustees of Columbia University" ] } ], "metadata": { "celltoolbar": "Edit Metadata", "kernelspec": { "display_name": "Python (pydata)", "language": "python", "name": "pydata" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.6.10" } }, "nbformat": 4, "nbformat_minor": 4 }