{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# 贝叶斯向量自回归\n", "\n", "**发布日期**: 2019年10月15日\n", "\n", "**文章作者**: Xinyu Chen (陈新宇) [[GitHub主页](https://github.com/xinychen)]\n", "\n", "**下载**: 本Jupyter Notebook可在GitHub仓库[GraphicalML](https://github.com/mobility-computing/GrapicalML/blob/master/content/bvar.ipynb)中下载和使用。\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 0 关于本文\n", "\n", "- 讨论贝叶斯向量自回归模型的形式\n", "- 介绍如何实现贝叶斯向量自回归\n", "- 分析贝叶斯向量自回归的应用" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 1 向量自回归模型\n", "\n", "向量自回归模型的英文名称为Vector Autoregressive model,常被简写成VAR。向量自回归的出现由来已久,可以追溯到上个世纪80年代,人们构建向量自回归模型主要出于以下考虑:\n", "\n", "- 时间序列分析从单一时间序列 (time series data) 拓展到了多元时间序列 (multivariate time series),在任意第$t$个时间间隔 (time interval),观测样本从1变成了$N$,其中,$N$表示多元时间序列中时间序列的数量。\n", "- 标准的自回归模型 (Autoregressive model, 简称AR) 其表达式过于简单,无法很好地在多元时间序列分析中发挥作用。\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 1.1 标准的自回归模型\n", "\n", "在统计学、经济学乃至信号处理等领域,自回归模型被广泛应用于描述随时间变化的过程 (简称时变过程),其中,最为经典的应用当属时间序列分析,在这里,自回归模型假设变量之间存在一个线性的依赖关系,即输出变量 (output variables) 如$y_t$与输入的历史变量 (previous variables) 如$y_{t-1},y_{t-2},...$存在一个线性表达式。\n", "\n", "不妨先看一下标准的自回归模型:给定单一时间序列$\\boldsymbol{y}\\in\\mathbb{R}^{T}$,其时间间隔的数量为$T$,则对于任意第$t$个时间间隔,存在如下的线性表达式:\n", "\\begin{equation}\n", "y_{t}=\\sum_{k=1}^{d}a_ky_{t-k}+\\epsilon_t,~t=d+1,...,T,\n", "\\end{equation}\n", "其中,$a_k,k=1,2,...,d$表示回归系数;常数$d$表示自回归模型的阶数 (order),也可以将$d$简单地理解成当前时间点关联过去时间点的数量。\n", "\n", "在自回归模型中,我们的目标是从观测数据中学习出参数$a_k,k=1,...,d$。现假设观测数据为$\\boldsymbol{y}\\in\\mathbb{R}^{T}$,首先,我们需要对自回归模型的线性表达式进行改写:\n", "\\begin{equation}\n", "\\begin{aligned}\n", "&y_{t}\\approx\\boldsymbol{a}^\\top{\\boldsymbol{v}}_{t},~t=d+1,...,T, \\\\\n", "\\Rightarrow&\\boldsymbol{z}\\approx Q\\boldsymbol{a},\n", "\\end{aligned}\n", "\\end{equation}\n", "其中,${\\boldsymbol{v}}_{t}=\\left(y_{t-1},y_{t-2},...,y_{t-d}\\right)\\in\\mathbb{R}^{d}$;$\\boldsymbol{z}=\\left(y_{d+1},y_{d+2},...,y_{T}\\right)\\in\\mathbb{R}^{T-d}$;$Q=\\left[\\begin{array}{c}{\\boldsymbol{v}_{d+1}^{\\top}} \\\\ {\\vdots} \\\\ {\\boldsymbol{v}_{T}^{\\top}}\\end{array}\\right] \\in \\mathbb{R}^{(T-d) \\times d}$. 在这里,写成这种形式完全是为了简化后续的推导。\n", "\n", "如果进一步将$\\epsilon_t$作为高斯噪声,采用最小二乘法,则回归系数$\\boldsymbol{a}$的最优解为\n", "\\begin{equation}\n", "\\begin{aligned}\n", "\\boldsymbol{a}&=\\text{arg}\\min_{\\boldsymbol{x}}~\\frac{1}{2}\\sum_{t=d+1}^{T}\\left(y_{t}-\\boldsymbol{x}^\\top{\\boldsymbol{v}}_{t}\\right)^2 \\\\\n", "&=\\text{arg}\\min_{\\boldsymbol{x}}~\\frac{1}{2}\\left(\\boldsymbol{z}-Q\\boldsymbol{x}\\right)^\\top\\left(\\boldsymbol{z}-Q\\boldsymbol{x}\\right) \\\\\n", "&=\\text{arg}\\min_{\\boldsymbol{x}}~\\frac{1}{2}\\left(\\boldsymbol{x}^\\top Q^\\top Q\\boldsymbol{x}-\\boldsymbol{z}^\\top Q\\boldsymbol{x}-\\boldsymbol{x}^\\top Q^\\top\\boldsymbol{z}\\right) \\\\\n", "&=\\left(Q^\\top Q\\right)^{-1}Q^\\top\\boldsymbol{z}. \\\\\n", "\\end{aligned}\n", "\\end{equation}\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "这里采用最小二乘法实际上能极大程度上简化算法的实现过程,无需迭代,只需要输入相应的变量$\\boldsymbol{y}$和阶数$d$就可以根据回归系数$\\boldsymbol{a}$的最优解进行计算。" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "\n", "def ar_model(vec_y, order_d):\n", " \"\"\"\n", " 用Numpy实现自回归模型AR(d).\n", " 输入变量1:时间序列向量vec_y;\n", " 输入变量2:自回归模型阶数order_d,取正整数,如1, 2, 3, ..., n.\n", " 输出变量:自回归模型的系数vec_a.\n", " \"\"\"\n", " \n", " T = vec_y.shape[0]\n", " time_lags = np.array(list(range(1, order_d + 1)))\n", " vec_z = vec_y[order_d :] # 定义向量z\n", " mat_Q = np.zeros((T - order_d, order_d)) # 定义矩阵Q\n", " for t in range(T - order_d):\n", " mat_Q[t, :] = vec_y[t + order_d - time_lags]\n", " \n", " return np.matmul(np.matmul(np.linalg.inv(np.matmul(mat_Q.T, mat_Q)), mat_Q.T), vec_z)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 1.2 多元时间序列\n", "\n", "实际上,相比单一的时间序列数据,多元时间序列数据反而更为常见,是由单一的时间序列构成,如下面的矩阵\n", "\\begin{equation}\n", "Y=\\left[\\begin{array}{ccccc}\n", "y_{11} & \\cdots & y_{1t} & \\cdots & y_{1T} \\\\\n", "y_{21} & \\cdots & y_{2t} & \\cdots & y_{2T} \\\\\n", "\\vdots & \\ddots & \\vdots & \\ddots & \\vdots \\\\\n", "y_{N1} & \\cdots & y_{Nt} & \\cdots & y_{NT} \\\\\n", "\\end{array}\n", "\\right]\\in\\mathbb{R}^{N\\times T}\n", "\\end{equation}\n", "就是一般形式的多元时间序列数据。在矩阵$Y$中,任意第$t$个时间间隔下,观测值为\n", "\\begin{equation}\n", "\\boldsymbol{y}_{t}=\\left(y_{1t},y_{2t},...,y_{Nt}\\right)^\\top\\in\\mathbb{R}^{N},\n", "\\end{equation}\n", "观测值的数量为$N$." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 1.3 向量自回归模型\n", "\n", "针对多元时间序列数据,向量自回归模型采用了一种更为灵活的时序建模策略:给定多元时间序列数据为$Y\\in\\mathbb{R}^{N\\times T}$,则对于任意第$t$个时间间隔,存在如下的线性表达式:\n", "\\begin{equation}\n", "\\boldsymbol{y}_{t}=\\sum_{k=1}^{d}A_k\\boldsymbol{y}_{t-k}+\\boldsymbol{\\epsilon}_{t},~t=d+1,...,T,\n", "\\end{equation}\n", "其中,$A_k\\in\\mathbb{R}^{N\\times N},k=1,2,...,d$表示向量自回归模型的系数矩阵;$\\boldsymbol{\\epsilon}_t$可视为高斯噪声。\n", "\n", "为方便后续推导,与自回归模型类似,令\n", "\\begin{equation}\n", "A=\\left[A_{1}, \\ldots, A_{d}\\right]^{\\top} \\in \\mathbb{R}^{(N d) \\times N}, \\quad \\boldsymbol{v}_{t}=\\left[\\begin{array}{c}{\\boldsymbol{y}_{t-{1}}} \\\\ {\\vdots} \\\\ {\\boldsymbol{y}_{t-{d}}}\\end{array}\\right] \\in \\mathbb{R}^{(N d)},\n", "\\end{equation}\n", "将向量自回归模型进行改写:\n", "\\begin{equation}\n", "\\begin{aligned}\n", "\\boldsymbol{y}_{t}&\\approx \\sum_{k=1}^{d}A_k\\boldsymbol{y}_{t-k}, \\\\\n", "&=A^\\top\\boldsymbol{v}_{t},~t=d+1,...,T, \\\\\n", "\\Rightarrow Z&\\approx QA, \\\\\n", "\\end{aligned}\n", "\\end{equation}\n", "其中,公式中的矩阵$Z$和$Q$定义如下:\n", "\\begin{equation}\n", "Z=\\left[\\begin{array}{c}{\\boldsymbol{y}_{{d}+1}^{\\top}} \\\\ {\\vdots} \\\\ {\\boldsymbol{y}_{T}^{\\top}}\\end{array}\\right] \\in \\mathbb{R}^{\\left(T-{d}\\right) \\times N}, \\quad Q=\\left[\\begin{array}{c}{\\boldsymbol{v}_{{d}+1}^{\\top}} \\\\ {\\vdots} \\\\ {\\boldsymbol{v}_{T}^{\\top}}\\end{array}\\right] \\in \\mathbb{R}^{(T-d) \\times(N d)}.\n", "\\end{equation}\n", "\n", "由此,采用最小二乘法,系数矩阵$A$的最优解为\n", "\\begin{equation}\n", "\\begin{aligned}\n", "A&=\\text{arg}\\min_{X}~\\frac{1}{2}\\left\\|Z-QX\\right\\|_{F}^{2} \\\\\n", "&=\\text{arg}\\min_{X}~\\frac{1}{2}\\text{tr}\\left(\\left(Z-QX\\right)^\\top\\left(Z-QX\\right)\\right) \\\\\n", "&=\\text{arg}\\min_{X}~\\frac{1}{2}\\text{tr}\\left(X^\\top Q^\\top QX-Z^\\top QX-X^\\top Q^\\top Z\\right) \\\\\n", "&=\\left(Q^\\top Q\\right)^{-1}Q^\\top Z. \\\\\n", "\\end{aligned}\n", "\\end{equation}\n", "\n", "> 在这里,我们用到了F-范数与矩阵迹 (trace) 之间的等价变换,它的意义是为了方便推导,如何简单理解这种等价变换呢?举一个例子:给定任意大小为$2\\times 2$的矩阵$$A=\\left[\\begin{array}{cc} a_{11} & a_{12} \\\\ a_{21} & a_{22} \\\\ \\end{array}\\right]\\in\\mathbb{R}^{2\\times 2},$$由于F-范数是矩阵所有元素的平方和开根号,即$$\\|A\\|_{F}=\\left(a_{11}^{2}+a_{12}^{2}+a_{21}^{2}+a_{22}^{2}\\right)^{\\frac{1}{2}},$$另外,$$A^\\top A=\\left[\\begin{array}{cc} a_{11}^2+a_{21}^2 & a_{11}a_{12}+a_{21}a_{22} \\\\ a_{12}a_{11}+a_{22}a_{21} & a_{12}^{2}+a_{22}^{2} \\\\ \\end{array}\\right],$$因此,根据矩阵迹的定义,有$$\\text{tr}\\left(A^\\top A\\right)=a_{11}^{2}+a_{12}^{2}+a_{21}^{2}+a_{22}^{2}=\\|A\\|_{F}^2.$$\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "与自回归模型的求解过程类似,这里采用最小二乘法也能极大程度上简化算法的实现过程,无需迭代,只需要输入相应的变量$Y$和阶数$d$就可以根据系数矩阵$A$的最优解进行计算。" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "\n", "def var_model(mat_Y, order_d, num_pred):\n", " \"\"\"\n", " 用Numpy实现向量自回归模型VAR(d).\n", " 输入变量1:多元时间序列矩阵mat_Y;\n", " 输入变量2:自回归模型阶数order_d,取正整数,如1, 2, 3, ..., n;\n", " 输入变量3:自回归模型的预测长度num_pred.\n", " 输出变量1:自回归模型的系数mat_A;\n", " 输出变量2:自回归模型的预测值mat_Y_new[:, T:].\n", " \"\"\"\n", " \n", " N, T = mat_Y.shape\n", " time_lags = np.array(list(range(1, order_d + 1)))\n", " mat_Z = mat_Y[:, order_d :].T # 定义矩阵Z\n", " mat_Q = np.zeros((T - order_d, N * order_d)) # 定义矩阵Q\n", " for t in range(T - order_d):\n", " mat_Q[t, :] = mat_Y[:, t + order_d - time_lags].reshape([N * order_d])\n", " mat_A = np.matmul(np.matmul(np.linalg.inv(np.matmul(mat_Q.T, mat_Q)), mat_Q.T), mat_Z) # 计算系数矩阵A\n", " mat_Y_new = np.zeros((N, T + num_pred))\n", " mat_Y_new[:, : T] = mat_Y\n", " for t in range(num_pred):\n", " mat_Y_new[:, t + T] = np.matmul(mat_A.T, mat_Y_new[:, t + T - time_lags].reshape([N * order_d]))\n", " \n", " return mat_A, mat_Y_new[:, T :]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 1.4 多元时间序列预测\n", "\n", "当存在多个时间序列,且它们之间相互影响时,则向量自回归模型就可以作为分析这类数据的有效模型。\n", "\n", "不过使用向量自回归模型时,我们还需要对参数数量有一个大概的了解。当多元时间序列数据是由$N$个单一时间序列构成时,若采用阶数为$d$的向量自回归模型,则参数数量为$N^2d$,或者写成$N\\times (Nd)$;当用作训练的时间序列长度为$T$时,我们相当于拥有$N\\times T$的观测样本用作参数估计 (学习)。在这里,如果采用最小二乘法对$N\\times (Nd)$的参数进行估计,为了保证参数学习的有效性,在设置阶数$d$时需要满足:\n", "$$Nd\\ll T,$$\n", "即观测样本数量要远大于模型参数数量。" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\"drawing\"\n", "\n", "> 时间序列预测问题(图片来源:https://multithreaded.stitchfix.com/blog/2017/02/28/whats-wrong-with-my-time-series/)。" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### 1) 广州城市路网车速数据集\n", "\n", "**关于数据集**\n", "\n", "- 由214条路段车速时间序列构成;\n", "- 时间间隔共计$61\\times 144=8784$.\n", "\n", "**预测任务**\n", "\n", "- 滚动预测最后5天$5\\times 144=720$个时间间隔的时间序列;\n", "- 单步滚动预测 (single-step rolling prediction),每次滚动用到历史8周数据;\n", "- 多步滚动预测 (multi-step rolling prediction),每次滚动用到历史8周数据.\n", "\n", "**参数设置**\n", "\n", "- 对于单步滚动预测,阶数为$d=1,2,3,4,5$;\n", "- 对于多步滚动预测,预测时间间隔为$2,3,4,5$,阶数为$d=1,2,3,4,5$.\n", "\n", "**模型设置**\n", "\n", "- 系数矩阵动态更新,即每次滚动重新估计系数矩阵,并计算相应的时间序列预测值。\n", "\n", "**性能评估**\n", "\n", "- MAPE (%),\n", "- RMSE." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "import scipy.io\n", "\n", "tensor = scipy.io.loadmat('../datasets/Guangzhou-data-set/tensor.mat')\n", "tensor = tensor['tensor']\n", "dense_mat = tensor.reshape([tensor.shape[0], tensor.shape[1] * tensor.shape[2]])\n", "X = dense_mat # 大小为214-by-8784,数据集存在缺失数据,此处不作处理。" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "plt.style.use('ggplot')\n", "## 绘制前三条时间序列最后5天的时间序列数据:\n", "for i in range(3):\n", " fig = plt.figure(figsize = (8, 1.5))\n", " ax = fig.add_axes([0.10, 0.22, 0.85, 0.75])\n", " plt.plot(X[i, 56 * 144 :], color = \"black\", linewidth = 0.5)\n", " plt.show()" ] }, { "cell_type": "code", "execution_count": 76, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Running time: 43 seconds\n" ] } ], "source": [ "import time\n", "start = time.time()\n", "\n", "order_d = 20\n", "N = X.shape[0]\n", "pred_steps = 144 * 5\n", "back_steps = 144 * 7 * 8\n", "num_pred = 144\n", "start_step = X.shape[1] - pred_steps\n", "mat_hat = np.zeros((N, pred_steps))\n", "for t in range(int(pred_steps / num_pred)):\n", " if t == 0:\n", " A, vec = var_model(X[:, 0 : t * num_pred + start_step], order_d, num_pred)\n", " else:\n", " A, vec = var_model(X[:, t * num_pred + start_step - back_steps \n", " : t * num_pred + start_step], order_d, num_pred)\n", " if num_pred == 1:\n", " mat_hat[:, t] = vec.reshape(N)\n", " else:\n", " mat_hat[:, t * num_pred : (t + 1) * num_pred] = vec\n", " if (t + 1) % 40 == 0:\n", " print('The current prediction step is {}.'.format(t + 1))\n", "\n", "end = time.time()\n", "print('Running time: %d seconds'%(end - start))" ] }, { "cell_type": "code", "execution_count": 77, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "MAPE: 0.16948262957368235\n", "RMSE: 6.195235305226982\n" ] } ], "source": [ "mat = X[:, start_step : X.shape[1]]\n", "mat0 = X[:, X.shape[0] - pred_steps - 1 : X.shape[0] - 1]\n", "pos = np.where(mat != 0)\n", "print('MAPE: {}'.format(np.sum(np.abs(mat[pos] - mat_hat[pos])/mat[pos])/mat[pos].shape[0]))\n", "print('RMSE: {}'.format(np.sqrt(np.sum((mat[pos] - mat_hat[pos]) ** 2)/mat[pos].shape[0])))" ] }, { "cell_type": "code", "execution_count": 78, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "plt.style.use('ggplot')\n", "for i in range(3):\n", " fig = plt.figure(figsize = (10, 2))\n", " ax = fig.add_axes([0.13, 0.28, 0.85, 0.68])\n", " plt.plot(X[i, 54 * 144 :], color = \"black\", linewidth = 0.5)\n", " plt.plot(list(range(X.shape[1] - pred_steps - 54 * 144, X.shape[1] - 54 * 144)), \n", " mat_hat[i, :], color = \"#e3120b\", linewidth = 1.0)\n", " ax.set_ylim([0, 65])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**单步滚动预测结果** (MAPE/RMSE)\n", "\n", "| 阶数 | $d=1$ | $d=2$ | $d=3$ | $d=4$ | $d=5$ |\n", "|:-----------|------------:|------------:|------------:|------------:|------------:|\n", "|`num_pred`=1| 7.22/3.10 | 7.30/3.14 | 7.41/3.17 | 7.52/3.21 | 7.65/3.25 |\n", "\n", "结果分析:对于单步滚动预测,当阶数$d$增大时,预测效果会逐渐变差,最佳的阶数为$d=1$。\n", "\n", "**多步滚动预测结果** (MAPE/RMSE)\n", "\n", "| 阶数 | $d=1$ | $d=2$ | $d=3$ | $d=4$ | $d=5$ |\n", "|:-------------|------------:|------------:|------------:|------------:|------------:|\n", "|`num_pred`=2 | 8.27/3.54 | 8.36/3.61 | 8.46/3.65 | 8.57/3.67 | 8.71/3.71 |\n", "|`num_pred`=3 | 9.05/3.88 | 9.14/3.98 | 9.21/4.01 | 9.33/4.04 | 9.45/4.07 |\n", "|`num_pred`=4 | 9.51/3.96 | 9.53/3.94 | 9.60/3.98 | 9.70/4.01 | 9.84/4.06 |\n", "|`num_pred`=5 | 10.06/4.18 | 10.06/4.15 | 10.08/4.16 | 10.16/4.18 | 10.29/4.24 |\n", "|`num_pred`=144| 23.77/8.32 | 22.61/7.96 | 21.40/7.57 | 20.67/7.34 | 20.24/7.21 |\n", "\n", "结果分析:当预测的时间间隔很小时,VAR(1)便能取得最佳的预测结果;随着预测的时间间隔增大,最佳的阶数也会随之增大,例如,预测未来5个时间间隔的时间序列时,VAR(2)取得最佳的预测结果,效果优于VAR(1)。" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### 2) 杭州地铁客流量数据集\n", "\n", "**关于数据集**\n", "\n", "- 由80个地铁站的入站客流量时间序列构成;\n", "- 时间间隔为10分钟,共计$25\\times 108=2700$个 (24:00至6:00之间不在服务时间,已经剔除25天中的该时段数据,因此,每天的时间间隔个数为108)。\n", "\n", "**预测任务**\n", "\n", "- 滚动预测最后5天$5\\times 108=540$个时间间隔的时间序列;\n", "- 单步滚动预测 (single-step rolling prediction),每次滚动用到历史2周数据;\n", "- 多步滚动预测 (multi-step rolling prediction),每次滚动用到历史2周数据.\n", "\n", "**参数设置**\n", "\n", "- 对于单步滚动预测,阶数为$d=1,2,3,4,5$;\n", "- 对于多步滚动预测,预测时间间隔为$2,3,4,5$,阶数为$d=1,2,3,4,5$.\n", "\n", "**模型设置**\n", "\n", "- 系数矩阵动态更新,即每次滚动重新估计系数矩阵,并计算相应的时间序列预测值。\n", "\n", "**性能评估**\n", "\n", "- MAPE (%),\n", "- RMSE." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "import scipy.io\n", "\n", "tensor = scipy.io.loadmat('../datasets/Hangzhou-data-set/tensor.mat')\n", "tensor = tensor['tensor']\n", "dense_mat = tensor.reshape([tensor.shape[0], tensor.shape[1] * tensor.shape[2]])\n", "X = dense_mat # 大小为80-by-2700,数据集不存在缺失数据" ] }, { "cell_type": "code", "execution_count": 69, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The current prediction step is 40.\n", "The current prediction step is 80.\n", "Running time: 1 seconds\n" ] } ], "source": [ "import time\n", "start = time.time()\n", "\n", "order_d = 3\n", "N = X.shape[0]\n", "pred_steps = 108 * 5\n", "back_steps = 108 * 7 * 2\n", "num_pred = 5\n", "start_step = X.shape[1] - pred_steps\n", "mat_hat = np.zeros((N, pred_steps))\n", "for t in range(int(pred_steps/num_pred)):\n", " if t == 0:\n", " A, vec = var_model(X[:, 0 : t * num_pred + start_step], order_d, num_pred)\n", " else:\n", " A, vec = var_model(X[:, t * num_pred + start_step - back_steps \n", " : t * num_pred + start_step], order_d, num_pred)\n", " if num_pred == 1:\n", " mat_hat[:, t] = vec.reshape(N)\n", " else:\n", " mat_hat[:, t * num_pred : (t + 1) * num_pred] = vec\n", " if (t + 1) % 40 == 0:\n", " print('The current prediction step is {}.'.format(t + 1))\n", "\n", "end = time.time()\n", "print('Running time: %d seconds'%(end - start))" ] }, { "cell_type": "code", "execution_count": 70, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "MAPE: 0.33951430128760296\n", "RMSE: 39.68455364476149\n" ] } ], "source": [ "mat = X[:, start_step : X.shape[1]]\n", "mat0 = X[:, X.shape[1] - pred_steps - 1 : X.shape[1] - 1]\n", "pos = np.where(mat != 0)\n", "print('MAPE: {}'.format(np.sum(np.abs(mat[pos] - mat_hat[pos])/mat[pos])/mat[pos].shape[0]))\n", "print('RMSE: {}'.format(np.sqrt(np.sum((mat[pos] - mat_hat[pos]) ** 2)/mat[pos].shape[0])))" ] }, { "cell_type": "code", "execution_count": 72, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "plt.style.use('ggplot')\n", "for i in range(5):\n", " fig = plt.figure(figsize = (8, 2))\n", " ax = fig.add_axes([0.13, 0.28, 0.85, 0.68])\n", " plt.plot(X[i, 18 * 108 :], color = \"black\", linewidth = 0.5)\n", " plt.plot(list(range(X.shape[1] - pred_steps - 18 * 108, X.shape[1] - 18 * 108)), \n", " mat_hat[i, :], color = \"#e3120b\", linewidth = 1.0)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**单步滚动预测结果** (MAPE/RMSE)\n", "\n", "| 阶数 | $d=1$ | $d=2$ | $d=3$ | $d=4$ | $d=5$ |\n", "|:-----------|------------:|------------:|------------:|------------:|------------:|\n", "|`num_pred`=1| 23.55/33.98 | 24.26/32.56 | 24.49/32.12 | 25.62/32.64 | 27.68/33.39 |\n", "\n", "结果分析:对于单步滚动预测,当阶数$d$增大时,预测效果会逐渐变差,从MAPE指标来看,最佳的阶数为$d=1$;从RMSE指标来看,最佳的阶数为$d=3$。\n", "\n", "**多步滚动预测结果** (MAPE/RMSE)\n", "\n", "| 阶数 | $d=1$ | $d=2$ | $d=3$ | $d=4$ | $d=5$ |\n", "|:-------------|------------:|------------:|------------:|------------:|------------:|\n", "|`num_pred`=2 | 26.26/37.09 | 26.26/35.10 | 26.47/34.27 | 27.73/34.56 | 29.80/35.14 |\n", "|`num_pred`=3 | 29.22/39.19 | 28.48/36.41 | 28.66/35.76 | 29.45/36.11 | 31.89/36.70 |\n", "|`num_pred`=4 | 34.09/42.71 | 33.01/39.65 | 31.77/38.36 | 32.15/38.40 | 35.49/38.88 |\n", "|`num_pred`=5 | 36.86/44.32 | 34.85/40.19 | 33.95/39.68 | 34.31/39.71 | 37.02/40.34 |\n", "\n", "结果分析:预测的时间间隔越长,需要的阶数则往往越大,但阶数并非越大越好,过大会进一步导致预测效果变差。" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 2 贝叶斯向量自回归\n", "\n", "对于向量自回归模型而言,不管采用怎样的求解方法,其求解过程中都会伴随着一定数量的待估计参数,因此,将向量自回归模型用于大规模多元时间序列数据时,为避免参数估计出现过拟合现象,对参数设置先验分布不失为一种有效的策略。除此之外,包括Gibbs采样在内的众多贝叶斯推断算法既能提供有效的参数估计,同时又能刻画参数估计值的不确定性 (uncertainty)。" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 2.1 回顾向量自回归模型\n", "\n", "针对多元时间序列数据,向量自回归模型采用了一种灵活的时序建模策略:给定多元时间序列数据为$Y\\in\\mathbb{R}^{N\\times T}$,则对于任意第$t$个时间间隔,存在如下的线性表达式:\n", "\\begin{equation}\n", "\\boldsymbol{y}_{t}=\\sum_{k=1}^{d}A_k\\boldsymbol{y}_{t-k}+\\boldsymbol{\\epsilon}_{t},~t=d+1,...,T,\n", "\\end{equation}\n", "其中,$A_k\\in\\mathbb{R}^{N\\times N},k=1,2,...,d$表示向量自回归模型的系数矩阵;$\\boldsymbol{\\epsilon}_t$可视为高斯噪声。\n", "\n", "令\n", "\\begin{equation}\n", "A=\\left[A_{1}, \\ldots, A_{d}\\right]^{\\top} \\in \\mathbb{R}^{(N d) \\times N}, \\quad \\boldsymbol{v}_{t}=\\left[\\begin{array}{c}{\\boldsymbol{y}_{t-{1}}} \\\\ {\\vdots} \\\\ {\\boldsymbol{y}_{t-{d}}}\\end{array}\\right] \\in \\mathbb{R}^{(N d)},\n", "\\end{equation}\n", "将向量自回归模型进行改写:\n", "\\begin{equation}\n", "\\begin{aligned}\n", "\\boldsymbol{y}_{t}&\\approx \\sum_{k=1}^{d}A_k\\boldsymbol{y}_{t-k}, \\\\\n", "&=A^\\top\\boldsymbol{v}_{t},~t=d+1,...,T, \\\\\n", "\\Rightarrow Z&\\approx QA, \\\\\n", "\\end{aligned}\n", "\\end{equation}\n", "其中,公式中的矩阵$Z$和$Q$定义如下:\n", "\\begin{equation}\n", "Z=\\left[\\begin{array}{c}{\\boldsymbol{y}_{{d}+1}^{\\top}} \\\\ {\\vdots} \\\\ {\\boldsymbol{y}_{T}^{\\top}}\\end{array}\\right] \\in \\mathbb{R}^{\\left(T-{d}\\right) \\times N}, \\quad Q=\\left[\\begin{array}{c}{\\boldsymbol{v}_{{d}+1}^{\\top}} \\\\ {\\vdots} \\\\ {\\boldsymbol{v}_{T}^{\\top}}\\end{array}\\right] \\in \\mathbb{R}^{(T-d) \\times(N d)}.\n", "\\end{equation}\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 2.2 矩阵正态分布\n", "\n", "在众多统计分布中,正态分布 (高斯分布) 是我们的很早就接触到的概率分布,将其形式用于以向量为随机变量$\\boldsymbol{x} \\in \\mathbb{R}^{m}$,便形成了我们在线性代数、概率论等相关课程中学到的多元正态分布 (multivariate normal distribution),其概率密度函数为\n", "\n", "\\begin{equation}\n", "\\begin{aligned}\n", "&\\mathcal{N}(\\boldsymbol{x} | \\boldsymbol{\\mu}, \\Sigma)=(2 \\pi)^{-m / 2}|\\Sigma|^{-1 / 2} \\exp \\left(-\\frac{1}{2}(\\boldsymbol{x}-\\boldsymbol{\\mu})^{\\top} \\Sigma^{-1}(\\boldsymbol{x}-\\boldsymbol{\\mu})\\right) \\\\ =&(2 \\pi)^{-m / 2}|\\Sigma|^{-1 / 2} \\exp \\left(-\\frac{1}{2} \\operatorname{tr}\\left[(\\boldsymbol{x}-\\boldsymbol{\\mu})(\\boldsymbol{x}-\\boldsymbol{\\mu})^{\\top} \\Sigma^{-1}\\right]\\right) \\\\\n", "\\end{aligned}\n", "\\end{equation}\n", "其中,$\\boldsymbol{\\mu} \\in \\mathbb{R}^{m}$表示多元正态分布的均值向量;$\\Sigma$则表示协方差矩阵。\n", "\n", "需要说明的是,这里将多元正态分布的指数项写成矩阵迹 (trace) 的形式是为了方面后续认识矩阵正态分布,其中,在多元正态分布的写法中,$(\\boldsymbol{x}-\\boldsymbol{\\mu})^{\\top} \\Sigma^{-1}(\\boldsymbol{x}-\\boldsymbol{\\mu})=\\operatorname{tr}\\left[(\\boldsymbol{x}-\\boldsymbol{\\mu})(\\boldsymbol{x}-\\boldsymbol{\\mu})^{\\top} \\Sigma^{-1}\\right]$是恒成立的。\n", "\n", "在多元正态分布的基础上,实际上还存在一种正态分布,它是以矩阵为随机变量,若随机矩阵$X\\in\\mathbb{R}^{m\\times n}$服从矩阵正态分布,则其概率密度函数为\n", "\n", "\\begin{equation}\n", "\\begin{aligned}\n", "&\\mathcal{M} \\mathcal{N}_{m \\times n}(X | M, U, V) \\\\ =&(2 \\pi)^{-m n / 2}|V|^{-m / 2}|U|^{-n / 2} \\exp \\left(-\\frac{1}{2} \\operatorname{tr}\\left[V^{-1}(X-M)^{\\top} U^{-1}(X-M)\\right]\\right)\n", "\\end{aligned}\n", "\\end{equation}\n", "其中,符号$\\mathcal{M N}_{m \\times n}(\\cdot)$来自于矩阵正态分布 (matrix normal distribution) 英文首字母的简写,下标指代随机矩阵的大小;矩阵$M \\in \\mathbb{R}^{m \\times n}$,与随机矩阵$X$大小相同,对应于均值项;矩阵$U \\in \\mathbb{R}^{m \\times m}$、$V \\in \\mathbb{R}^{n \\times n}$对应于协方差矩阵。\n", "\n", "> 注:关于矩阵正态分布更为详细的介绍可参考[统计学习 | 矩阵正态分布 (matrix normal distribution)\n", "](https://zhuanlan.zhihu.com/p/73585133)。" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 2.3 贝叶斯向量自回归模型" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 2.4 参数的后验分布与Gibbs采样" ] }, { "cell_type": "code", "execution_count": 164, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "from numpy.linalg import inv as inv\n", "from scipy.stats import invwishart\n", "from scipy.stats import wishart\n", "from numpy.random import multivariate_normal as mvnrnd" ] }, { "cell_type": "code", "execution_count": 165, "metadata": {}, "outputs": [], "source": [ "def mnrnd(M, U, V):\n", " \"\"\"\n", " Generate matrix normal distributed random matrix.\n", " M is a m-by-n matrix, U is a m-by-m matrix, and V is a n-by-n matrix.\n", " \"\"\"\n", " dim1, dim2 = M.shape\n", " X0 = np.random.rand(dim1, dim2)\n", " P = np.linalg.cholesky(U)\n", " Q = np.linalg.cholesky(V)\n", " return M + np.matmul(np.matmul(P, X0), Q.T)" ] }, { "cell_type": "code", "execution_count": 166, "metadata": {}, "outputs": [], "source": [ "def sampling_MNIW(mat_Z, mat_Q, M0, Psi0, S0, nu0):\n", " \n", " var_Psi = inv(inv(Psi0) + np.matmul(mat_Q.T, mat_Q)) # 后验参数Psi\n", " var_M = np.matmul(var_Psi, np.matmul(inv(Psi0), M0) + np.matmul(mat_Q.T, mat_Z)) # 后验参数M\n", " var_S = (S0 + np.matmul(mat_Z.T, mat_Z)# + np.matmul(np.matmul(M0.T, inv(Psi0)), M0)\n", " - np.matmul(np.matmul(var_M.T, inv(var_Psi)), var_M)) # 后验参数S\n", " var_nu = nu0 + mat_Z.shape[0] # 后验参数nu\n", " Sigma = invwishart(df = var_nu, scale = var_S, seed = None).rvs() # 用inv-Wishart后验分布对Sigma采样\n", " mat_A = mnrnd(var_M, var_Psi, Sigma) # 用matrix norm distribution后验分布对系数矩阵A采样\n", " return Sigma, mat_A" ] }, { "cell_type": "code", "execution_count": 229, "metadata": {}, "outputs": [], "source": [ "def bvar_model(mat_Y, mat_Y_new, order_d, num_pred, num_rolling, burn_iter, gibbs_iter):\n", " \"\"\"\n", " 用Numpy实现贝叶斯向量自回归模型BVAR(d).\n", " 输入变量1:多元时间序列矩阵mat_Y;\n", " 输入变量2:滚动预测输入矩阵mat_Y_new;\n", " 输入变量3:自回归模型阶数order_d,取正整数,如1, 2, 3, ..., n;\n", " 输入变量4:自回归模型的预测长度num_pred;\n", " 输入变量5:自回归模型的滚动预测次数num_rolling;\n", " 输入变量6:Gibbs采样的燃烧期迭代次数burn_iter;\n", " 输入变量7:Gibbs采样的采样迭代次数gibbs_iter.\n", " 输出变量1:自回归模型的系数mat_A;\n", " 输出变量2:自回归模型的预测值mat_Y_new[:, T:].\n", " \"\"\"\n", " \n", " N, T = mat_Y.shape\n", " time_lags = np.array(list(range(1, order_d + 1)))\n", " mat_Z = mat_Y[:, order_d :].T # 定义矩阵Z\n", " mat_Q = np.zeros((T - order_d, N * order_d)) # 定义矩阵Q\n", " for t in range(T - order_d):\n", " mat_Q[t, :] = mat_Z[t - time_lags, :].reshape([N * order_d])\n", "\n", " M0 = np.zeros((N * order_d, N))\n", " Psi0 = np.eye(N * order_d)\n", " S0 = np.eye(N)\n", " nu0 = N\n", " result = [] # 保存各变量在各代中的Gibbs采样值\n", " result.append(np.zeros((N, num_rolling * num_pred, gibbs_iter))) # 保存多元时间序列的预测值\n", " result.append(np.zeros((N * order_d, N, gibbs_iter))) # 保存系数矩阵A的采样值\n", " \n", " for it in range(burn_iter + gibbs_iter):\n", " Sigma, mat_A = sampling_MNIW(mat_Z, mat_Q, M0, Psi0, S0, nu0)\n", " if it >= burn_iter:\n", " for t0 in range(num_rolling):\n", " if t0 >= 1:\n", " mat_Z_new = np.append(mat_Z, mat_Y_new[:, (t0 - 1) * num_pred : t0 * num_pred].T, axis = 0)\n", " mat_Q_new = np.append(mat_Q, np.zeros((num_pred, N * order_d)), axis = 0)\n", " for tt in range(num_pred):\n", " mat_Q_new[tt - num_pred, :] = mat_Z_new[tt - num_pred - time_lags].reshape([N * order_d])\n", " mat_Z = mat_Z_new.copy()\n", " mat_Q = mat_Q_new.copy()\n", " result[1][:, :, it - burn_iter] = mat_A\n", " for t in range(num_pred):\n", " if t == 0:\n", " mat_Q_sample = mat_Q.copy()\n", " else:\n", " mat_Q_sample = np.append(mat_Q_sample, vec.reshape([1, N * order_d]), axis = 0)\n", " vec0 = mvnrnd(np.matmul(mat_A.T, mat_Q_sample[t0 * num_pred + t + T - order_d - 1, :]), Sigma)\n", " result[0][:, t0 * num_pred + t, it - burn_iter] = vec0\n", " vec = np.append(vec0, mat_Q_sample[-1, N :])\n", " if (it + 1) % 100 == 0:\n", " print(it + 1)\n", " \n", " return result" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 2.5 多元时间序列预测" ] }, { "cell_type": "code", "execution_count": 230, "metadata": {}, "outputs": [], "source": [ "import scipy.io\n", "\n", "tensor = scipy.io.loadmat('../datasets/Hangzhou-data-set/tensor.mat')\n", "tensor = tensor['tensor']\n", "dense_mat = tensor.reshape([tensor.shape[0], tensor.shape[1] * tensor.shape[2]])\n", "max_const = np.max(dense_mat)\n", "X = dense_mat / max_const # 大小为80-by-2700,数据集不存在缺失数据" ] }, { "cell_type": "code", "execution_count": 232, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "100\n", "200\n", "300\n", "400\n", "500\n", "600\n", "700\n", "800\n", "900\n", "1000\n", "1100\n", "Running time: 4263 seconds\n" ] } ], "source": [ "import time\n", "start = time.time()\n", "\n", "order_d = 2\n", "pred_steps = 108 * 5\n", "back_steps = 108 * 7 * 2\n", "num_pred = 5\n", "num_rolling = int(pred_steps / num_pred)\n", "burn_iter = 1000\n", "gibbs_iter = 100\n", "\n", "start_step = X.shape[1] - pred_steps\n", "mat_Y = X[:, 0 : start_step]\n", "mat_Y_new = X[:, start_step : start_step + pred_steps - num_pred]\n", "result = bvar_model(mat_Y, mat_Y_new, order_d, num_pred, num_rolling, burn_iter, gibbs_iter)\n", "\n", "end = time.time()\n", "print('Running time: %d seconds'%(end - start))" ] }, { "cell_type": "code", "execution_count": 233, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "MAPE: 0.371662520311232\n", "RMSE: 44.300409121588196\n" ] } ], "source": [ "mat = X[:, start_step : X.shape[1]] * max_const\n", "pos = np.where(mat != 0)\n", "mat_hat = np.mean(result[0], axis = 2) * max_const\n", "print('MAPE: {}'.format(np.sum(np.abs(mat[pos] - mat_hat[pos])/mat[pos])/mat[pos].shape[0]))\n", "print('RMSE: {}'.format(np.sqrt(np.sum((mat[pos] - mat_hat[pos]) ** 2)/mat[pos].shape[0])))" ] }, { "cell_type": "code", "execution_count": 234, "metadata": {}, "outputs": [], "source": [ "mat_hat90 = np.percentile(result[0], 90, axis = 2)" ] }, { "cell_type": "code", "execution_count": 237, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "100\n", "200\n", "300\n", "400\n", "500\n", "600\n", "700\n", "800\n", "900\n", "1000\n", "1100\n", "1200\n", "1300\n", "1400\n", "1500\n", "1600\n", "1700\n", "1800\n", "1900\n", "2000\n", "2100\n", "2200\n", "2300\n", "2400\n", "2500\n", "2600\n", "2700\n", "2800\n", "2900\n", "3000\n", "3100\n", "3200\n", "3300\n", "3400\n", "3500\n", "3600\n", "3700\n", "3800\n", "3900\n", "4000\n", "4100\n", "4200\n", "4300\n", "4400\n", "4500\n", "4600\n", "4700\n", "4800\n", "4900\n", "5000\n", "5100\n", "Running time: 2057 seconds\n" ] } ], "source": [ "import time\n", "start = time.time()\n", "\n", "order_d = 2\n", "pred_steps = 108 * 5\n", "back_steps = 108 * 7 * 2\n", "num_pred = 5\n", "num_rolling = int(pred_steps / num_pred)\n", "burn_iter = 5000\n", "gibbs_iter = 100\n", "\n", "start_step = X.shape[1] - pred_steps\n", "mat_Y = X[:, 0 : start_step]\n", "mat_Y_new = X[:, start_step : start_step + pred_steps - num_pred]\n", "result = bvar_model(mat_Y, mat_Y_new, order_d, num_pred, num_rolling, burn_iter, gibbs_iter)\n", "\n", "end = time.time()\n", "print('Running time: %d seconds'%(end - start))" ] }, { "cell_type": "code", "execution_count": 239, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "MAPE: 0.37405811145984663\n", "RMSE: 44.15142376552828\n" ] } ], "source": [ "mat = X[:, start_step : X.shape[1]] * max_const\n", "pos = np.where(mat != 0)\n", "mat_hat = np.mean(result[0], axis = 2) * max_const\n", "print('MAPE: {}'.format(np.sum(np.abs(mat[pos] - mat_hat[pos])/mat[pos])/mat[pos].shape[0]))\n", "print('RMSE: {}'.format(np.sqrt(np.sum((mat[pos] - mat_hat[pos]) ** 2)/mat[pos].shape[0])))" ] }, { "cell_type": "code", "execution_count": 240, "metadata": {}, "outputs": [], "source": [ "mat_hat10 = np.percentile(result[0], 10, axis = 2)\n", "mat_hat90 = np.percentile(result[0], 90, axis = 2)" ] }, { "cell_type": "code", "execution_count": 241, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "plt.style.use('ggplot')\n", "figsize = 2\n", "for i in range(1):\n", " fig = plt.figure(figsize = (8 * figsize, 2 * figsize))\n", " ax = fig.add_axes([0.13, 0.28, 0.85, 0.68])\n", " plt.plot(X[i, 18 * 108 :] * max_const, color = \"black\", linewidth = 1)\n", " plt.plot(list(range(X.shape[1] - pred_steps - 18 * 108, X.shape[1] - 18 * 108)), \n", " mat_hat[i, :], color = \"#e3120b\", linewidth = 2.0)\n", " plt.plot(list(range(X.shape[1] - pred_steps - 18 * 108, X.shape[1] - 18 * 108)), \n", " mat_hat10[i, :] * max_const, color = \"blue\", linewidth = 2.0)\n", " plt.plot(list(range(X.shape[1] - pred_steps - 18 * 108, X.shape[1] - 18 * 108)), \n", " mat_hat90[i, :] * max_const, color = \"green\", linewidth = 2.0)" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.7.3" } }, "nbformat": 4, "nbformat_minor": 2 }