Part 9: All Together (Optimal Pairs Selection Framework + Copula Based Trading Model).ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "c5ea3a95",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import scipy.stats as stats\n",
    "from scipy.stats import pearsonr\n",
    "import yfinance as yf\n",
    "import itertools\n",
    "import math\n",
    "import random\n",
    "\n",
    "\n",
    "import statsmodels\n",
    "import statsmodels.api as sm\n",
    "from statsmodels.tsa.stattools import coint, adfuller\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from co import *\n",
    "import ndtest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "cc1877fc",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Asset list from DBSCAN clusters - utilities\n",
    "lst=('LNT','AEE','AEP','ATO','CNP','CMS','ED','D','DTE','DUK','EIX','ETR','EVRG','ES','EXC','FE')\n",
    "\n",
    "#dates for model calibration\n",
    "start_data='2021-09-01'\n",
    "end_data='2022-09-01'\n",
    "\n",
    "start_trade='2022-09-02'\n",
    "end_trade='2022-12-02'\n",
    "\n",
    "index_comp='SPY'\n",
    "util_index_comp='VPU'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "8e5b0c36",
   "metadata": {},
   "outputs": [],
   "source": [
    "pair_order_list = itertools.combinations(lst,2)\n",
    "pairs=list(pair_order_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "930accbe",
   "metadata": {},
   "outputs": [],
   "source": [
    "ret_df= pd.DataFrame()\n",
    "for j in range(0,len(lst)):\n",
    "    X = yf.download(lst[j], start = start_data, end=end_data)\n",
    "    X.reset_index(inplace=True)\n",
    "    X.tail()\n",
    "    X['Log_Returns'] = np.log(X['Adj Close']) - np.log(X['Adj Close'].shift(1))\n",
    "    x = X['Log_Returns'].drop(labels=0, axis=0)\n",
    "    date=X['Date'].drop(labels=0,axis=0)\n",
    "    date=date.to_frame()\n",
    "\n",
    "    x_df=x.to_frame().dropna()\n",
    "\n",
    "    b=x_df.rename(columns={'Log_Returns': lst[j]})\n",
    "    b=b[lst[j]].values\n",
    "    ret_df[lst[j]]=b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "af2af82a",
   "metadata": {},
   "outputs": [],
   "source": [
    "co_pairs=[]\n",
    "np.random.seed(107)\n",
    "for i in range(0,len(pairs)):\n",
    "    score, pvalue, _ = coint(np.cumsum(ret_df[pairs[i][0]]),np.cumsum(ret_df[pairs[i][1]]))\n",
    "\n",
    "    confidence_level = 0.05\n",
    "\n",
    "    if pvalue < confidence_level:\n",
    "        co_pairs.append(pairs[i])\n",
    "        print (pairs[i],\" are cointegrated\")\n",
    "        print (pvalue)\n",
    "    else:\n",
    "        print (pairs[i],\" are not cointegrated\")\n",
    "        print (pvalue)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "71cc5c71",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cointegrated pairs in the utilities cluster\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[('LNT', 'CNP'),\n",
       " ('LNT', 'ED'),\n",
       " ('LNT', 'D'),\n",
       " ('LNT', 'EIX'),\n",
       " ('LNT', 'ETR'),\n",
       " ('AEE', 'AEP'),\n",
       " ('AEE', 'CNP'),\n",
       " ('AEE', 'CMS'),\n",
       " ('AEE', 'DUK'),\n",
       " ('AEE', 'ETR'),\n",
       " ('AEP', 'CNP'),\n",
       " ('CNP', 'CMS'),\n",
       " ('CNP', 'ED'),\n",
       " ('CNP', 'DUK'),\n",
       " ('CNP', 'ETR'),\n",
       " ('CNP', 'EVRG'),\n",
       " ('CMS', 'ED'),\n",
       " ('CMS', 'D'),\n",
       " ('CMS', 'DTE'),\n",
       " ('CMS', 'DUK'),\n",
       " ('CMS', 'ETR'),\n",
       " ('CMS', 'EXC'),\n",
       " ('D', 'DTE'),\n",
       " ('D', 'EXC'),\n",
       " ('DTE', 'DUK'),\n",
       " ('DUK', 'ETR'),\n",
       " ('DUK', 'EXC'),\n",
       " ('EIX', 'EVRG'),\n",
       " ('EIX', 'ES')]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print('Cointegrated pairs in the utilities cluster')\n",
    "co_pairs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "a4846366",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_hurst_exponent(time_series, max_lag=20):\n",
    "        lags = range(2, max_lag)\n",
    "\n",
    "        # variances of the lagged differences\n",
    "        tau = [np.std(np.subtract(time_series[lag:], time_series[:-lag])) for lag in lags]\n",
    "\n",
    "        # calculate the slope of the log plot -> the Hurst Exponent\n",
    "        reg = np.polyfit(np.log(lags), np.log(tau), 1)\n",
    "\n",
    "        return reg[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "4875e37d",
   "metadata": {},
   "outputs": [],
   "source": [
    "pairs_df=pd.DataFrame(columns=['spread'])\n",
    "hurst_list=[]\n",
    "for i in range(0,len(co_pairs)):\n",
    "    #calculate spread of adjusted close price between asset pair\n",
    "    pairs_df['spread'] = np.abs(ret_df[co_pairs[i][0]] - ret_df[co_pairs[i][1]])\n",
    "\n",
    "    hurst_exp = get_hurst_exponent(pairs_df['spread'].values)\n",
    "    hurst_list.append(hurst_exp)\n",
    "\n",
    "list_zip = zip(co_pairs,hurst_list)\n",
    "zipped_list = list(list_zip)\n",
    "zipped_list.sort(key=lambda a: a[1])\n",
    "\n",
    "selected_stocks = []\n",
    "selected_pairs = []\n",
    "opt_asset1=[]\n",
    "opt_asset2=[]\n",
    "for i in range(0,len(co_pairs)):\n",
    "    s1=co_pairs[i][0]\n",
    "    s2=co_pairs[i][1]\n",
    "\n",
    "    if (s1 not in selected_stocks) and (s2 not in selected_stocks):\n",
    "        selected_stocks.append(s1)\n",
    "        selected_stocks.append(s2)\n",
    "        pair=s1+' and '+s2\n",
    "        selected_pairs.append(pair)\n",
    "\n",
    "    if len(selected_pairs) == math.comb(len(lst),2):\n",
    "        break\n",
    "\n",
    "opt_asset1=selected_stocks[0:len(selected_stocks)-1:2]\n",
    "opt_asset2=selected_stocks[1:len(selected_stocks):2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "8db4deec",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Selected pairs given cointegrated and minimum Hurst Exponent\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "['LNT and CNP',\n",
       " 'AEE and AEP',\n",
       " 'CMS and ED',\n",
       " 'D and DTE',\n",
       " 'DUK and ETR',\n",
       " 'EIX and EVRG']"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print('Selected pairs given cointegrated and minimum Hurst Exponent')\n",
    "selected_pairs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "ca80027a",
   "metadata": {},
   "outputs": [],
   "source": [
    "opt_asset_list=opt_asset1+opt_asset2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "28c9fbb9",
   "metadata": {},
   "outputs": [],
   "source": [
    "opt_ret_df= pd.DataFrame()\n",
    "for j in range(0,len(opt_asset_list)):\n",
    "    X = yf.download(opt_asset_list[j], start = start_trade, end=end_trade)\n",
    "    X.reset_index(inplace=True)\n",
    "    X.tail()\n",
    "    X['Log_Returns'] = np.log(X['Adj Close']) - np.log(X['Adj Close'].shift(1))\n",
    "    x = X['Log_Returns'].drop(labels=0, axis=0)\n",
    "    date=X['Date'].drop(labels=0,axis=0)\n",
    "    date=date.to_frame()\n",
    "    \n",
    "    x_df=x.to_frame().dropna()\n",
    "\n",
    "    b=x_df.rename(columns={'Log_Returns': opt_asset_list[j]})\n",
    "    b=b[opt_asset_list[j]].values\n",
    "    opt_ret_df[opt_asset_list[j]]=b\n",
    "    \n",
    "x=opt_ret_df.join(date)\n",
    "opt_ret_df=x.set_index('Date')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "a2a235b4",
   "metadata": {},
   "outputs": [],
   "source": [
    "returns_trade_period=opt_ret_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1ffabe51",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "df=pd.DataFrame()\n",
    "best_cop_lst=[]\n",
    "for i in range(0,len(opt_asset1)):\n",
    "    #assets (yfinance ticker)\n",
    "    x=ret_df[opt_asset1[i]]\n",
    "    y=ret_df[opt_asset2[i]]\n",
    "    pairs=selected_pairs[i] #insert name of asset 1 and asset 2\n",
    "\n",
    "    #fit distribution to element in pair + probability integral transform to get marginal uniform\n",
    "\n",
    "    param1 = stats.t.fit(x)\n",
    "    dist1=stats.t(*param1)\n",
    "    u=dist1.cdf(x)\n",
    "    param2=stats.t.fit(y)\n",
    "    dist2=stats.t(*param2)\n",
    "    v=dist2.cdf(y)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "    #fit bivariate copula family to data \n",
    "    #calculate Akaike information criterion, Bayesion information criterion and KS value to help determine good fit\n",
    "\n",
    "    pair=[pairs]\n",
    "    copulas_df = pd.DataFrame(index=pair, columns=['copula', 'parameter', 'aic', 'bic', 'KS_pvalue'])\n",
    "\n",
    "\n",
    "    best_aic = np.inf\n",
    "    best_copula= None\n",
    "\n",
    "\n",
    "    copulas=[GaussianCopula(),GumbelCopula(), ClaytonCopula(),FrankCopula()]\n",
    "    for copula in copulas:\n",
    "        copula.fit(u,v)\n",
    "\n",
    "        L = copula.log_likelihood(u,v)\n",
    "        aic = 2 * copula.num_params - 2 * L\n",
    "        if aic < best_aic:\n",
    "            best_aic = aic\n",
    "            best_bic = copula.num_params * np.log(len(u)) - 2 * L\n",
    "            best_copula = copula\n",
    "\n",
    "            # calculate KS-pvalue\n",
    "            smp = copula.sample(size=len(u)) # generate sample from fit copula\n",
    "            s_u = smp[:,0]\n",
    "            s_v = smp[:,1]\n",
    "            ks_pval = ndtest.ks2d2s(u,v,s_u,s_v)\n",
    "\n",
    "            if isinstance(copula, ArchimedeanCopula):\n",
    "                best_param = copula.alpha\n",
    "            else:\n",
    "                best_param = copula.rho\n",
    "\n",
    "    best_cop_lst.append(best_copula)\n",
    "    copulas_df.loc[pair] = [best_copula.name, best_param, best_aic, best_bic, ks_pval]\n",
    "    df=df.append(copulas_df)\n",
    "\n",
    "#dataframe of the returns for the specific trading period for each pair\n",
    "algo_returns = {}\n",
    "cl = 0.85\n",
    "\n",
    "for q in range(0,len(selected_pairs)):\n",
    "    # calculate conditional probabilities\n",
    "    prob1=[]\n",
    "    prob2=[]\n",
    "\n",
    "    for u,v in zip(dist1.cdf(opt_ret_df[opt_asset1[q]]), dist2.cdf(opt_ret_df[opt_asset2[q]])):\n",
    "        prob1.append(best_cop_lst[q].cdf_u_given_v(u,v))\n",
    "        prob2.append(best_cop_lst[q].cdf_v_given_u(u,v))\n",
    "\n",
    "\n",
    "    probs_trade= pd.DataFrame(np.vstack([prob1,prob2]).T,index=opt_ret_df.index, columns=[opt_asset1[q],opt_asset2[q]])\n",
    "\n",
    "\n",
    "\n",
    "    #calculate positions\n",
    "    positions=pd.DataFrame(index=probs_trade.index, columns = probs_trade.columns)\n",
    "    long = False\n",
    "    short = False\n",
    "\n",
    "\n",
    "    for t in positions.index:    \n",
    "        # if long position is open\n",
    "        if long:\n",
    "            if (probs_trade.loc[t][opt_asset1[q]] > 0.5) or (probs_trade.loc[t][opt_asset2[q]] < 0.5):\n",
    "                positions.loc[t] = [0,0]\n",
    "                long = False\n",
    "            else:\n",
    "                positions.loc[t] = [1,-1]\n",
    "\n",
    "        # if short position is open\n",
    "        elif short:\n",
    "            if (probs_trade.loc[t][opt_asset1[q]] < 0.5) or (probs_trade.loc[t][opt_asset2[q]] > 0.5):\n",
    "                positions.loc[t] = [0,0]\n",
    "                short = False\n",
    "            else:\n",
    "                positions.loc[t] = [-1,1]\n",
    "\n",
    "        # if no positions are open\n",
    "        else:\n",
    "            if (probs_trade.loc[t][opt_asset1[q]] < (1-cl)) and (probs_trade.loc[t][opt_asset2[q]] > cl):\n",
    "                # open long position\n",
    "                positions.loc[t] = [1,-1]\n",
    "                long = True\n",
    "            elif (probs_trade.loc[t][opt_asset1[q]] > cl) and (probs_trade.loc[t][opt_asset2[q]] < (1-cl)):\n",
    "                # open short positions\n",
    "                positions.loc[t] = [-1,1]\n",
    "                short = True\n",
    "            else:\n",
    "                positions.loc[t] = [0,0]\n",
    "\n",
    "\n",
    "    # calculate returns\n",
    "    algo_ret = (returns_trade_period * positions.shift()).sum(axis=1)\n",
    "    algo_returns[selected_pairs[q]] = algo_ret\n",
    "\n",
    "rets = pd.DataFrame.from_dict(algo_returns)\n",
    "rets = np.exp(rets) - 1 # convert log-returns to simple returns\n",
    "total_ret = rets.sum(axis=1) / len(rets.columns) * 2 # double capital (from short positions)\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "20b9cd50",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Algorithm returns for trading period:\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Date\n",
       "NaT           0.000000\n",
       "2022-09-06    0.000000\n",
       "2022-09-07    0.000000\n",
       "2022-09-08    0.000000\n",
       "2022-09-09    0.000000\n",
       "                ...   \n",
       "2022-11-23    0.003775\n",
       "2022-11-25    0.000000\n",
       "2022-11-28    0.000000\n",
       "2022-11-29    0.000000\n",
       "2022-11-30    0.000000\n",
       "Length: 62, dtype: float64"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# calculate returns\n",
    "algo_ret = (returns_trade_period * positions.shift()).sum(axis=1)\n",
    "algo_returns[pairs] = algo_ret\n",
    "\n",
    "print('Algorithm returns for trading period:')\n",
    "algo_ret"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "c9173e00",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[*********************100%***********************]  1 of 1 completed\n",
      "[*********************100%***********************]  1 of 1 completed\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x13249cb80>"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Plot of algorithm returns vs. index return\n",
    "#x-axis is # days from start of trading period\n",
    "returns = pd.DataFrame.from_dict(algo_returns)\n",
    "returns = np.exp(returns) - 1 # convert log-returns to simple returns\n",
    "total_ret = returns.sum(axis=1) / len(returns.columns) * 2 # double capital (from short positions)\n",
    "\n",
    "index_price = yf.download(index_comp, start=start_trade, end=end_trade)\n",
    "index_price = index_price['Adj Close']\n",
    "index_ret =index_price.pct_change().dropna()\n",
    "\n",
    "util_index_price = yf.download(util_index_comp, start=start_trade, end=end_trade)\n",
    "util_index_price = util_index_price['Adj Close']\n",
    "util_index_ret =util_index_price.pct_change().dropna()\n",
    "\n",
    "plt.figure(figsize=(18,6))\n",
    "plt.plot(np.nancumprod(total_ret + 1), label='algo')\n",
    "plt.plot(np.nancumprod(index_ret + 1), label=index_comp)\n",
    "plt.plot(np.nancumprod(util_index_ret + 1), label='Vanguard Utilities Index')\n",
    "plt.legend()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "9d60ca7f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_metrics(cumret):\n",
    "    total_return = (cumret[-1] - cumret[0])/cumret[0]\n",
    "    apr = (1+total_return)**(252/len(cumret)) - 1\n",
    "    rets = pd.DataFrame(cumret).pct_change()\n",
    "    sharpe = np.sqrt(252) * np.nanmean(rets) / np.nanstd(rets)\n",
    "    \n",
    "    # maxdd and maxddd\n",
    "    highwatermark=np.zeros(cumret.shape)\n",
    "    drawdown=np.zeros(cumret.shape)\n",
    "    drawdownduration=np.zeros(cumret.shape)\n",
    "    for t in np.arange(1, cumret.shape[0]):\n",
    "        highwatermark[t]=np.maximum(highwatermark[t-1], cumret[t])\n",
    "        drawdown[t]=cumret[t]/highwatermark[t]-1\n",
    "        if drawdown[t]==0:\n",
    "            drawdownduration[t]=0\n",
    "        else:\n",
    "            drawdownduration[t]=drawdownduration[t-1]+1\n",
    "    maxDD=np.min(drawdown)\n",
    "    maxDDD=np.max(drawdownduration)\n",
    "    \n",
    "    return total_return, apr, sharpe, maxDD, maxDDD"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "f75f6c97",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Total return</th>\n",
       "      <th>APR</th>\n",
       "      <th>Sharpe</th>\n",
       "      <th>Max Drawdown</th>\n",
       "      <th>Max Length Drawdown</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Algo</th>\n",
       "      <td>-0.031264</td>\n",
       "      <td>-0.121115</td>\n",
       "      <td>-2.35134</td>\n",
       "      <td>-0.049429</td>\n",
       "      <td>31.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>SPY</th>\n",
       "      <td>0.046815</td>\n",
       "      <td>0.204375</td>\n",
       "      <td>0.835238</td>\n",
       "      <td>-0.12883</td>\n",
       "      <td>57.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     Total return       APR    Sharpe Max Drawdown Max Length Drawdown\n",
       "Algo    -0.031264 -0.121115  -2.35134    -0.049429                31.0\n",
       "SPY      0.046815  0.204375  0.835238     -0.12883                57.0"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#performance metrics\n",
    "metrics = pd.DataFrame(index=['Algo', index_comp], columns=['Total return', 'APR', 'Sharpe', 'Max Drawdown', 'Max Length Drawdown'])\n",
    "metrics.loc['Algo'] = calculate_metrics(np.nancumprod(total_ret + 1))\n",
    "metrics.loc[index_comp] = calculate_metrics(np.nancumprod(index_ret + 1))\n",
    "\n",
    "metrics"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6ce59d6",
   "metadata": {},
   "source": [
    "## Algo performed similarly to benchmark (utility index) and poorly in comparison to broader S&P. Had less drawdown then util benchmark"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}