diff --git a/EPAT.ipynb b/EPAT.ipynb new file mode 100644 index 00000000..9c858ad2 --- /dev/null +++ b/EPAT.ipynb @@ -0,0 +1,645 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "EPAT.ipynb", + "version": "0.3.2", + "provenance": [], + "collapsed_sections": [], + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "[View in Colaboratory](https://colab.research.google.com/github/anilsrik/Python-for-Algorithms--Data-Structures--and-Interviews/blob/master/EPAT.ipynb)" + ] + }, + { + "metadata": { + "id": "mvQLQMXtzCdq", + "colab_type": "code", + "colab": {} + }, + "cell_type": "code", + "source": [ + "from google.colab import drive\n", + "drive.mount('/content/gdrive')" + ], + "execution_count": 0, + "outputs": [] + }, + { + "metadata": { + "id": "NvFwp1fyxkVr", + "colab_type": "code", + "colab": {} + }, + "cell_type": "code", + "source": [ + "import numpy as np\n", + "from statsmodels.tsa.tsatools import lagmat\n", + "from numpy.linalg import inv\n", + "from statsmodels.tsa.coint_tables import c_sja, c_sjt\n", + "\n", + "def coint_johansen_1(endog, det_order, k_ar_diff):\n", + " \"\"\"\n", + " Perform the Johansen cointegration test for determining the cointegration\n", + " rank of a VECM.\n", + " Parameters\n", + " ----------\n", + " endog : array-like (nobs_tot x neqs)\n", + " The data with presample.\n", + " det_order : int\n", + " * -1 - no deterministic terms\n", + " * 0 - constant term\n", + " * 1 - linear trend\n", + " k_ar_diff : int, nonnegative\n", + " Number of lagged differences in the model.\n", + " Returns\n", + " -------\n", + " result : Holder\n", + " An object containing the results which can be accessed using\n", + " dot-notation. The object's attributes are\n", + " * eig: (neqs)\n", + " Eigenvalues.\n", + " * evec: (neqs x neqs)\n", + " Eigenvectors.\n", + " * lr1: (neqs)\n", + " Trace statistic.\n", + " * lr2: (neqs)\n", + " Maximum eigenvalue statistic.\n", + " * cvt: (neqs x 3)\n", + " Critical values (90%, 95%, 99%) for trace statistic.\n", + " * cvm: (neqs x 3)\n", + " Critical values (90%, 95%, 99%) for maximum eigenvalue\n", + " statistic.\n", + " * method: str\n", + " \"johansen\"\n", + " * r0t: (nobs x neqs)\n", + " Residuals for :math:`\\\\Delta Y`. See p. 292 in [1]_.\n", + " * rkt: (nobs x neqs)\n", + " Residuals for :math:`Y_{-1}`. See p. 292 in [1]_.\n", + " * ind: (neqs)\n", + " Order of eigenvalues.\n", + " Notes\n", + " -----\n", + " The implementation might change to make more use of the existing VECM\n", + " framework.\n", + " References\n", + " ----------\n", + " .. [1] Lütkepohl, H. 2005. *New Introduction to Multiple Time Series Analysis*. Springer.\n", + " \"\"\"\n", + " import warnings\n", + " if det_order not in [-1, 0, 1]:\n", + " warnings.warn(\"Critical values are only available for a det_order of \"\n", + " \"-1, 0, or 1.\", category=HypothesisTestWarning)\n", + " if endog.shape[1] > 12: # todo: test with a time series of 13 variables\n", + " warnings.warn(\"Critical values are only available for time series \"\n", + " \"with 12 variables at most.\",\n", + " category=HypothesisTestWarning)\n", + "\n", + " from statsmodels.regression.linear_model import OLS\n", + "\n", + " class Holder(object):\n", + " pass\n", + "\n", + " def detrend(y, order):\n", + " if order == -1:\n", + " return y\n", + " return OLS(y, np.vander(np.linspace(-1, 1, len(y)),\n", + " order+1)).fit().resid\n", + "\n", + " def resid(y, x):\n", + " if x.size == 0:\n", + " return y\n", + " r = y - np.dot(x, np.dot(np.linalg.pinv(x), y))\n", + " return r\n", + "\n", + " nobs, neqs = endog.shape\n", + "\n", + " # why this? f is detrend transformed series, det_order is detrend data\n", + " if det_order > -1:\n", + " f = 0\n", + " else:\n", + " f = det_order\n", + "\n", + " endog = detrend(endog, det_order)\n", + " dx = np.diff(endog, 1, axis=0)\n", + " z = lagmat(dx, k_ar_diff)\n", + " z = z[k_ar_diff:]\n", + " z = detrend(z, f)\n", + "\n", + " dx = dx[k_ar_diff:]\n", + "\n", + " dx = detrend(dx, f)\n", + " r0t = resid(dx, z)\n", + " lx = endog[:-k_ar_diff]\n", + " lx = lx[1:]\n", + " dx = detrend(lx, f)\n", + " rkt = resid(dx, z) # level on lagged diffs\n", + " skk = np.dot(rkt.T, rkt) / rkt.shape[0]\n", + " sk0 = np.dot(rkt.T, r0t) / rkt.shape[0]\n", + " s00 = np.dot(r0t.T, r0t) / r0t.shape[0]\n", + " sig = np.dot(sk0, np.dot(inv(s00), sk0.T))\n", + " tmp = inv(skk)\n", + " au, du = np.linalg.eig(np.dot(tmp, sig)) # au is eval, du is evec\n", + "\n", + " temp = inv(np.linalg.cholesky(np.dot(du.T, np.dot(skk, du))))\n", + " dt = np.dot(du, temp)\n", + "\n", + " # JP: the next part can be done much easier\n", + " auind = np.argsort(au)\n", + " aind = np.flipud(auind)\n", + " a = au[aind]\n", + " d = dt[:, aind]\n", + "\n", + " # Compute the trace and max eigenvalue statistics\n", + " lr1 = np.zeros(neqs)\n", + " lr2 = np.zeros(neqs)\n", + " cvm = np.zeros((neqs, 3))\n", + " cvt = np.zeros((neqs, 3))\n", + " iota = np.ones(neqs)\n", + " t, junk = rkt.shape\n", + " for i in range(0, neqs):\n", + " tmp = np.log(iota - a)[i:]\n", + " lr1[i] = -t * np.sum(tmp, 0)\n", + " lr2[i] = -t * np.log(1-a[i])\n", + " cvm[i, :] = c_sja(neqs - i, det_order)\n", + " cvt[i, :] = c_sjt(neqs - i, det_order)\n", + " aind[i] = i\n", + "\n", + " result = Holder()\n", + " # estimation results, residuals\n", + " result.rkt = rkt\n", + " result.r0t = r0t\n", + " result.eig = a\n", + " result.evec = d\n", + " result.lr1 = lr1\n", + " result.lr2 = lr2\n", + " result.cvt = cvt\n", + " result.cvm = cvm\n", + " result.ind = aind\n", + " result.meth = 'johansen'\n", + "\n", + " return result\n" + ], + "execution_count": 0, + "outputs": [] + }, + { + "metadata": { + "id": "BTQJJZXF2-AR", + "colab_type": "code", + "colab": {} + }, + "cell_type": "code", + "source": [ + "import statsmodels as sm\n", + "import statsmodels.api as smapi\n", + "from numpy import zeros, ones, flipud, log\n", + "from numpy.linalg import inv, eig, cholesky as chol\n", + "from statsmodels.regression.linear_model import OLS\n", + "tdiff = np.diff\n", + "\n", + "ss_ejcp0 = '''\\\n", + " 2.9762 4.1296 6.9406\n", + " 9.4748 11.2246 15.0923\n", + " 15.7175 17.7961 22.2519\n", + " 21.8370 24.1592 29.0609\n", + " 27.9160 30.4428 35.7359\n", + " 33.9271 36.6301 42.2333\n", + " 39.9085 42.7679 48.6606\n", + " 45.8930 48.8795 55.0335\n", + " 51.8528 54.9629 61.3449\n", + " 57.7954 61.0404 67.6415\n", + " 63.7248 67.0756 73.8856\n", + " 69.6513 73.0946 80.0937'''\n", + "\n", + "ss_ejcp1 = '''\\\n", + " 2.7055 3.8415 6.6349\n", + " 12.2971 14.2639 18.5200\n", + " 18.8928 21.1314 25.8650\n", + " 25.1236 27.5858 32.7172\n", + " 31.2379 33.8777 39.3693\n", + " 37.2786 40.0763 45.8662\n", + " 43.2947 46.2299 52.3069\n", + " 49.2855 52.3622 58.6634\n", + " 55.2412 58.4332 64.9960\n", + " 61.2041 64.5040 71.2525\n", + " 67.1307 70.5392 77.4877\n", + " 73.0563 76.5734 83.7105'''\n", + "\n", + "ss_ejcp2 = '''\\\n", + " 2.7055 3.8415 6.6349\n", + " 15.0006 17.1481 21.7465\n", + " 21.8731 24.2522 29.2631\n", + " 28.2398 30.8151 36.1930\n", + " 34.4202 37.1646 42.8612\n", + " 40.5244 43.4183 49.4095\n", + " 46.5583 49.5875 55.8171\n", + " 52.5858 55.7302 62.1741\n", + " 58.5316 61.8051 68.5030\n", + " 64.5292 67.9040 74.7434\n", + " 70.4630 73.9355 81.0678\n", + " 76.4081 79.9878 87.2395'''\n", + "\n", + "ejcp0 = np.array(ss_ejcp0.split(),float).reshape(-1,3)\n", + "ejcp1 = np.array(ss_ejcp1.split(),float).reshape(-1,3)\n", + "ejcp2 = np.array(ss_ejcp2.split(),float).reshape(-1,3)\n", + "\n", + "def c_sja(n, p):\n", + " if ((p > 1) or (p < -1)):\n", + " jc = np.zeros(3)\n", + " elif ((n > 12) or (n < 1)):\n", + " jc = np.zeros(3)\n", + " elif p == -1:\n", + " jc = ejcp0[n-1,:]\n", + " elif p == 0:\n", + " jc = ejcp1[n-1,:]\n", + " elif p == 1:\n", + " jc = ejcp2[n-1,:]\n", + "\n", + " return jc\n", + "\n", + "ss_tjcp0 = '''\\\n", + " 2.9762 4.1296 6.9406\n", + " 10.4741 12.3212 16.3640\n", + " 21.7781 24.2761 29.5147\n", + " 37.0339 40.1749 46.5716\n", + " 56.2839 60.0627 67.6367\n", + " 79.5329 83.9383 92.7136\n", + " 106.7351 111.7797 121.7375\n", + " 137.9954 143.6691 154.7977\n", + " 173.2292 179.5199 191.8122\n", + " 212.4721 219.4051 232.8291\n", + " 255.6732 263.2603 277.9962\n", + " 302.9054 311.1288 326.9716'''\n", + "\n", + "\n", + "ss_tjcp1 = '''\\\n", + " 2.7055 3.8415 6.6349\n", + " 13.4294 15.4943 19.9349\n", + " 27.0669 29.7961 35.4628\n", + " 44.4929 47.8545 54.6815\n", + " 65.8202 69.8189 77.8202\n", + " 91.1090 95.7542 104.9637\n", + " 120.3673 125.6185 135.9825\n", + " 153.6341 159.5290 171.0905\n", + " 190.8714 197.3772 210.0366\n", + " 232.1030 239.2468 253.2526\n", + " 277.3740 285.1402 300.2821\n", + " 326.5354 334.9795 351.2150'''\n", + "\n", + "ss_tjcp2 = '''\\\n", + " 2.7055 3.8415 6.6349\n", + " 16.1619 18.3985 23.1485\n", + " 32.0645 35.0116 41.0815\n", + " 51.6492 55.2459 62.5202\n", + " 75.1027 79.3422 87.7748\n", + " 102.4674 107.3429 116.9829\n", + " 133.7852 139.2780 150.0778\n", + " 169.0618 175.1584 187.1891\n", + " 208.3582 215.1268 228.2226\n", + " 251.6293 259.0267 273.3838\n", + " 298.8836 306.8988 322.4264\n", + " 350.1125 358.7190 375.3203'''\n", + "\n", + "tjcp0 = np.array(ss_tjcp0.split(),float).reshape(-1,3)\n", + "tjcp1 = np.array(ss_tjcp1.split(),float).reshape(-1,3)\n", + "tjcp2 = np.array(ss_tjcp2.split(),float).reshape(-1,3)\n", + "\n", + "def c_sjt(n, p):\n", + " if ((p > 1) or (p < -1)):\n", + " jc = np.zeros(3)\n", + " elif ((n > 12) or (n < 1)):\n", + " jc = np.zeros(3)\n", + " elif p == -1:\n", + " jc = tjcp0[n-1,:]\n", + " elif p == 0:\n", + " jc = tjcp1[n-1,:]\n", + " elif p == 1:\n", + " jc = tjcp2[n-1,:]\n", + " else:\n", + " raise ValueError('invalid p')\n", + "\n", + " return jc\n", + "\n", + "\n", + "class Holder(object):\n", + " pass\n", + "\n", + "def rows(x):\n", + " return x.shape[0]\n", + "\n", + "def trimr(x, front, end):\n", + " if end > 0:\n", + " return x[front:-end]\n", + " else:\n", + " return x[front:]\n", + "\n", + "import statsmodels.tsa.tsatools as tsat\n", + "mlag = tsat.lagmat\n", + "\n", + "def mlag_(x, maxlag):\n", + " '''return all lags up to maxlag\n", + " '''\n", + " return x[:-lag]\n", + "\n", + "def lag(x, lag):\n", + " return x[:-lag]\n", + "\n", + "def detrend(y, order):\n", + " if order == -1:\n", + " return y\n", + " return OLS(y, np.vander(np.linspace(-1,1,len(y)), order+1)).fit().resid\n", + "\n", + "def resid(y, x):\n", + " if x.size == 0:\n", + " return y\n", + " try:\n", + " r = y - np.dot(x, np.dot(np.linalg.pinv(x), y))\n", + " except:\n", + " return None\n", + " return r\n", + "\n", + "\n", + "def coint_johansen(x, p, k, coint_trend=None):\n", + "\n", + " # % error checking on inputs\n", + " # if (nargin ~= 3)\n", + " # error('Wrong # of inputs to johansen')\n", + " # end\n", + " nobs, m = x.shape\n", + "\n", + " #why this? f is detrend transformed series, p is detrend data\n", + " if (p > -1):\n", + " f = 0\n", + " else:\n", + " f = p\n", + "\n", + " if coint_trend is not None:\n", + " f = coint_trend #matlab has separate options\n", + "\n", + " x = detrend(x,p)\n", + " dx = tdiff(x,1, axis=0)\n", + " #dx = trimr(dx,1,0)\n", + " z = mlag(dx,k)#[k-1:]\n", + " z = trimr(z,k,0)\n", + " z = detrend(z,f)\n", + " dx = trimr(dx,k,0)\n", + "\n", + " dx = detrend(dx,f)\n", + " #r0t = dx - z*(z\\dx)\n", + " r0t = resid(dx, z) #diff on lagged diffs\n", + " #lx = trimr(lag(x,k),k,0)\n", + " lx = lag(x,k)\n", + " lx = trimr(lx, 1, 0)\n", + " dx = detrend(lx,f)\n", + " #rkt = dx - z*(z\\dx)\n", + " rkt = resid(dx, z) #level on lagged diffs\n", + " if rkt is None:\n", + " return None\n", + " skk = np.dot(rkt.T, rkt) / rows(rkt)\n", + " sk0 = np.dot(rkt.T, r0t) / rows(rkt)\n", + " s00 = np.dot(r0t.T, r0t) / rows(r0t)\n", + " try:\n", + " sig = np.dot(sk0, np.dot(inv(s00), (sk0.T)))\n", + " except:\n", + " return None\n", + "\n", + " try:\n", + " tmp = inv(skk)\n", + " except:\n", + " return None\n", + " \n", + " #du, au = eig(np.dot(tmp, sig))\n", + " au, du = eig(np.dot(tmp, sig)) #au is eval, du is evec\n", + " #orig = np.dot(tmp, sig)\n", + " try:\n", + " #% Normalize the eigen vectors such that (du'skk*du) = I\n", + " temp = inv(chol(np.dot(du.T, np.dot(skk, du))))\n", + " except:\n", + " return None\n", + " dt = np.dot(du, temp)\n", + "\n", + "\n", + " #JP: the next part can be done much easier\n", + "\n", + " #% NOTE: At this point, the eigenvectors are aligned by column. To\n", + " #% physically move the column elements using the MATLAB sort,\n", + " #% take the transpose to put the eigenvectors across the row\n", + "\n", + " #dt = transpose(dt)\n", + "\n", + " #% sort eigenvalues and vectors\n", + "\n", + " #au, auind = np.sort(diag(au))\n", + " auind = np.argsort(au)\n", + " #a = flipud(au)\n", + " aind = flipud(auind)\n", + " a = au[aind]\n", + " #d = dt[aind,:]\n", + " d = dt[:,aind]\n", + "\n", + " #%NOTE: The eigenvectors have been sorted by row based on auind and moved to array \"d\".\n", + " #% Put the eigenvectors back in column format after the sort by taking the\n", + " #% transpose of \"d\". Since the eigenvectors have been physically moved, there is\n", + " #% no need for aind at all. To preserve existing programming, aind is reset back to\n", + " #% 1, 2, 3, ....\n", + "\n", + " #d = transpose(d)\n", + " #test = np.dot(transpose(d), np.dot(skk, d))\n", + "\n", + " #%EXPLANATION: The MATLAB sort function sorts from low to high. The flip realigns\n", + " #%auind to go from the largest to the smallest eigenvalue (now aind). The original procedure\n", + " #%physically moved the rows of dt (to d) based on the alignment in aind and then used\n", + " #%aind as a column index to address the eigenvectors from high to low. This is a double\n", + " #%sort. If you wanted to extract the eigenvector corresponding to the largest eigenvalue by,\n", + " #%using aind as a reference, you would get the correct eigenvector, but with sorted\n", + " #%coefficients and, therefore, any follow-on calculation would seem to be in error.\n", + " #%If alternative programming methods are used to evaluate the eigenvalues, e.g. Frame method\n", + " #%followed by a root extraction on the characteristic equation, then the roots can be\n", + " #%quickly sorted. One by one, the corresponding eigenvectors can be generated. The resultant\n", + " #%array can be operated on using the Cholesky transformation, which enables a unit\n", + " #%diagonalization of skk. But nowhere along the way are the coefficients within the\n", + " #%eigenvector array ever changed. The final value of the \"beta\" array using either method\n", + " #%should be the same.\n", + "\n", + "\n", + " #% Compute the trace and max eigenvalue statistics */\n", + " lr1 = zeros(m)\n", + " lr2 = zeros(m)\n", + " cvm = zeros((m,3))\n", + " cvt = zeros((m,3))\n", + " iota = ones(m)\n", + " t, junk = rkt.shape\n", + " for i in range(0, m):\n", + " tmp = trimr(np.log(iota-a), i ,0)\n", + " lr1[i] = -t * np.sum(tmp, 0) #columnsum ?\n", + " #tmp = np.log(1-a)\n", + " #lr1[i] = -t * np.sum(tmp[i:])\n", + " lr2[i] = -t * np.log(1-a[i])\n", + " cvm[i,:] = c_sja(m-i,p)\n", + " cvt[i,:] = c_sjt(m-i,p)\n", + " aind[i] = i\n", + " #end\n", + "\n", + " result = Holder()\n", + " #% set up results structure\n", + " #estimation results, residuals\n", + " result.rkt = rkt\n", + " result.r0t = r0t\n", + " result.eig = a\n", + " result.evec = d #transposed compared to matlab ?\n", + " result.lr1 = lr1\n", + " result.lr2 = lr2\n", + " result.cvt = cvt\n", + " result.cvm = cvm\n", + " result.ind = aind\n", + " result.meth = 'johansen'\n", + "\n", + " return result\n", + "\n" + ], + "execution_count": 0, + "outputs": [] + }, + { + "metadata": { + "id": "SNM-rIMVydgk", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 365 + }, + "outputId": "9f3bb035-907c-4c84-b42e-6f5d27c53514" + }, + "cell_type": "code", + "source": [ + "import pandas as pd\n", + "xlf = pd.read_csv(\"/content/gdrive/My Drive/EPAT/Data/XLF.csv\", parse_dates=True, index_col=\"Date\")\n", + "jpm = pd.read_csv(\"/content/gdrive/My Drive/EPAT/Data/JPM.csv\", parse_dates=True, index_col=\"Date\")\n", + "bac = pd.read_csv(\"/content/gdrive/My Drive/EPAT/Data/BAC.csv\", parse_dates=True, index_col=\"Date\")\n", + "c = pd.read_csv(\"/content/gdrive/My Drive/EPAT/Data/C.csv\", parse_dates=True, index_col=\"Date\")\n", + "#Merge to remove any missing data elements from each data frame. A data quality check.\n", + "df = xlf.merge(jpm, left_index=True, right_index=True, suffixes=('', \"_jpm\")).merge(bac,left_index=True,right_index=True,suffixes=(\"\",\"_bac\")).merge(c,left_index=True,right_index=True,suffixes=(\"\",\"_c\"))\n", + "series_df = df[[\"Open\", \"Open_jpm\", \"Open_bac\", \"Open_c\"]].copy().rename(columns={\"Open\":\"XLF\", \"Open_jpm\":\"JPM\", \"Open_bac\":\"BAC\", \"Open_c\":\"C\"})\n", + "series_df.plot()" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 34 + }, + { + "output_type": "display_data", + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAeQAAAFLCAYAAAAH5P/CAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "tags": [] + } + } + ] + }, + { + "metadata": { + "id": "Z_B_Otn8yrVv", + "colab_type": "code", + "colab": {} + }, + "cell_type": "code", + "source": [ + "def get_johansen(y, p):\n", + " \"\"\"\n", + " Get the cointegration vectors at 95% level of significance\n", + " given by the trace statistic test.\n", + " \"\"\"\n", + "\n", + " N, l = y.shape\n", + " jres = coint_johansen(y, 0, p)\n", + " r = 0\n", + " trstat = jres.lr1 # trace statistic\n", + " tsignf = jres.cvt # critical values\n", + "\n", + " for i in range(l):\n", + " if trstat[i] > tsignf[i, 1]: # 0: 90% 1:95% 2: 99%\n", + " r = i + 1\n", + " jres.r = r\n", + " jres.evecr = jres.evec[:, :r]\n", + "\n", + " return jres\n", + " \n", + "coint_res = get_johansen(series_df,1)" + ], + "execution_count": 0, + "outputs": [] + }, + { + "metadata": { + "id": "QjgRQE80ywyC", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "outputId": "86a02930-8c5c-4117-8954-fc4ad4201017" + }, + "cell_type": "code", + "source": [ + "coint_res.r" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "0" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 38 + } + ] + }, + { + "metadata": { + "id": "5iz3TB0jzVy2", + "colab_type": "code", + "colab": {} + }, + "cell_type": "code", + "source": [ + "" + ], + "execution_count": 0, + "outputs": [] + } + ] +} \ No newline at end of file