Part 1: Pairs Trading with Copulas.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 715,
   "id": "63c93c29",
   "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",
    "import yfinance as yf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 716,
   "id": "e718d4f1",
   "metadata": {},
   "outputs": [],
   "source": [
    "#inputs\n",
    "\n",
    "#assets (yfinance ticker)\n",
    "asset1='AAPL'\n",
    "asset2='MSFT'\n",
    "pairs='AAPL-MSFT' #insert name of asset 1 and asset 2\n",
    "\n",
    "# trading period\n",
    "start_trade='2022-01-10'\n",
    "end_trade='2022-02-10'\n",
    "\n",
    "#period of data collection\n",
    "start_data='2017-11-19'\n",
    "end_data='2020-11-19'\n",
    "\n",
    "# comparison data\n",
    "# compare with index \n",
    "#for tech stocks consider using QQQ or Nasdaq 100 or any other relevant index\n",
    "#for crypto perhaps use bitcoin as index, cmc200, or QQQ (up to user judgement)\n",
    "index_comp='QQQ'\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 717,
   "id": "66617c5f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[*********************100%***********************]  1 of 1 completed\n",
      "[*********************100%***********************]  1 of 1 completed\n",
      "Log returns for entire calibration period:\n"
     ]
    },
    {
     "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>MSFT</th>\n",
       "      <th>AAPL</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Date</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2017-11-21</th>\n",
       "      <td>0.014316</td>\n",
       "      <td>0.018420</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2017-11-22</th>\n",
       "      <td>-0.007313</td>\n",
       "      <td>0.010457</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2017-11-24</th>\n",
       "      <td>0.001804</td>\n",
       "      <td>0.000057</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2017-11-27</th>\n",
       "      <td>0.007300</td>\n",
       "      <td>-0.005042</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2017-11-28</th>\n",
       "      <td>0.011970</td>\n",
       "      <td>-0.005876</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-11-12</th>\n",
       "      <td>-0.005139</td>\n",
       "      <td>-0.002346</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-11-13</th>\n",
       "      <td>0.004954</td>\n",
       "      <td>0.000419</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-11-16</th>\n",
       "      <td>0.003320</td>\n",
       "      <td>0.008682</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-11-17</th>\n",
       "      <td>-0.012833</td>\n",
       "      <td>-0.007593</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-11-18</th>\n",
       "      <td>-0.013271</td>\n",
       "      <td>-0.011457</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>754 rows × 2 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                MSFT      AAPL\n",
       "Date                          \n",
       "2017-11-21  0.014316  0.018420\n",
       "2017-11-22 -0.007313  0.010457\n",
       "2017-11-24  0.001804  0.000057\n",
       "2017-11-27  0.007300 -0.005042\n",
       "2017-11-28  0.011970 -0.005876\n",
       "...              ...       ...\n",
       "2020-11-12 -0.005139 -0.002346\n",
       "2020-11-13  0.004954  0.000419\n",
       "2020-11-16  0.003320  0.008682\n",
       "2020-11-17 -0.012833 -0.007593\n",
       "2020-11-18 -0.013271 -0.011457\n",
       "\n",
       "[754 rows x 2 columns]"
      ]
     },
     "execution_count": 717,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#fetch log returns of pair (to model calibration)\n",
    "\n",
    "X = yf.download(asset1, 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",
    "\n",
    "\n",
    "\n",
    "Y = yf.download(asset2, start = start_data, end=end_data)\n",
    "Y.reset_index(inplace=True)\n",
    "Y.tail()\n",
    "Y['Log_Returns'] = np.log(Y['Adj Close']) - np.log(Y['Adj Close'].shift(1))\n",
    "y = Y['Log_Returns'].drop(labels=0, axis=0)\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",
    "#put returns in a data frame with corresponding dates\n",
    "x_df=x.to_frame()\n",
    "y_df=y.to_frame()\n",
    "\n",
    "a=y_df.rename(columns={'Log_Returns': asset2})\n",
    "b=x_df.rename(columns={'Log_Returns': asset1})\n",
    "\n",
    "p =a.join(b)\n",
    "x=p.join(date)\n",
    "\n",
    "returns_df=x.set_index('Date')\n",
    "\n",
    "print('Log returns for entire calibration period:')\n",
    "returns_df\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 718,
   "id": "618cba1c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[*********************100%***********************]  1 of 1 completed\n",
      "[*********************100%***********************]  1 of 1 completed\n",
      "Log returns for trading period:\n"
     ]
    },
    {
     "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>MSFT</th>\n",
       "      <th>AAPL</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Date</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2022-01-11</th>\n",
       "      <td>0.002257</td>\n",
       "      <td>0.016645</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2022-01-12</th>\n",
       "      <td>0.010391</td>\n",
       "      <td>0.002567</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2022-01-13</th>\n",
       "      <td>-0.043244</td>\n",
       "      <td>-0.019211</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2022-01-14</th>\n",
       "      <td>0.017561</td>\n",
       "      <td>0.005098</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2022-01-18</th>\n",
       "      <td>-0.024640</td>\n",
       "      <td>-0.019075</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2022-01-19</th>\n",
       "      <td>0.002244</td>\n",
       "      <td>-0.021249</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2022-01-20</th>\n",
       "      <td>-0.005720</td>\n",
       "      <td>-0.010401</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2022-01-21</th>\n",
       "      <td>-0.018641</td>\n",
       "      <td>-0.012847</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2022-01-24</th>\n",
       "      <td>0.001148</td>\n",
       "      <td>-0.004876</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2022-01-25</th>\n",
       "      <td>-0.026948</td>\n",
       "      <td>-0.011450</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2022-01-26</th>\n",
       "      <td>0.028095</td>\n",
       "      <td>-0.000563</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2022-01-27</th>\n",
       "      <td>0.010494</td>\n",
       "      <td>-0.002947</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2022-01-28</th>\n",
       "      <td>0.027695</td>\n",
       "      <td>0.067451</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2022-01-31</th>\n",
       "      <td>0.008785</td>\n",
       "      <td>0.025790</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2022-02-01</th>\n",
       "      <td>-0.007164</td>\n",
       "      <td>-0.000973</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2022-02-02</th>\n",
       "      <td>0.015107</td>\n",
       "      <td>0.007020</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2022-02-03</th>\n",
       "      <td>-0.039731</td>\n",
       "      <td>-0.016861</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2022-02-04</th>\n",
       "      <td>0.015449</td>\n",
       "      <td>-0.001681</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2022-02-07</th>\n",
       "      <td>-0.016445</td>\n",
       "      <td>-0.004244</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2022-02-08</th>\n",
       "      <td>0.011924</td>\n",
       "      <td>0.018298</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2022-02-09</th>\n",
       "      <td>0.021600</td>\n",
       "      <td>0.008260</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                MSFT      AAPL\n",
       "Date                          \n",
       "2022-01-11  0.002257  0.016645\n",
       "2022-01-12  0.010391  0.002567\n",
       "2022-01-13 -0.043244 -0.019211\n",
       "2022-01-14  0.017561  0.005098\n",
       "2022-01-18 -0.024640 -0.019075\n",
       "2022-01-19  0.002244 -0.021249\n",
       "2022-01-20 -0.005720 -0.010401\n",
       "2022-01-21 -0.018641 -0.012847\n",
       "2022-01-24  0.001148 -0.004876\n",
       "2022-01-25 -0.026948 -0.011450\n",
       "2022-01-26  0.028095 -0.000563\n",
       "2022-01-27  0.010494 -0.002947\n",
       "2022-01-28  0.027695  0.067451\n",
       "2022-01-31  0.008785  0.025790\n",
       "2022-02-01 -0.007164 -0.000973\n",
       "2022-02-02  0.015107  0.007020\n",
       "2022-02-03 -0.039731 -0.016861\n",
       "2022-02-04  0.015449 -0.001681\n",
       "2022-02-07 -0.016445 -0.004244\n",
       "2022-02-08  0.011924  0.018298\n",
       "2022-02-09  0.021600  0.008260"
      ]
     },
     "execution_count": 718,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#dataframe of the returns for the specific trading period \n",
    "\n",
    "X_trade = yf.download(asset1, start =start_trade, end=end_trade)\n",
    "\n",
    "X_trade.reset_index(inplace=True)\n",
    "X_trade.tail()\n",
    "X_trade['Log_Returns'] = np.log(X_trade['Adj Close']) - np.log(X_trade['Adj Close'].shift(1))\n",
    "x_trade = X_trade['Log_Returns'].drop(labels=0, axis=0)\n",
    "date=X_trade['Date'].drop(labels=0,axis=0)\n",
    "date=date.to_frame()\n",
    "\n",
    "\n",
    "\n",
    "Y_trade = yf.download(asset2, start = start_trade, end=end_trade)\n",
    "Y_trade.reset_index(inplace=True)\n",
    "Y_trade.tail()\n",
    "Y_trade['Log_Returns'] = np.log(Y_trade['Adj Close']) - np.log(Y_trade['Adj Close'].shift(1))\n",
    "y_trade = Y_trade['Log_Returns'].drop(labels=0, axis=0)\n",
    "\n",
    "\n",
    "#put returns in a data frame with corresponding dates\n",
    "x2_df=x_trade.to_frame()\n",
    "y2_df=y_trade.to_frame()\n",
    "\n",
    "m=y2_df.rename(columns={'Log_Returns': asset2})\n",
    "a=x2_df.rename(columns={'Log_Returns': asset1})\n",
    "\n",
    "p =m.join(a)\n",
    "x=p.join(date)\n",
    "\n",
    "returns_trade_period=x.set_index('Date')\n",
    "print('Log returns for trading period:')\n",
    "returns_trade_period\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 719,
   "id": "02adf0a4",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/SophiaZorek/Desktop/coding projects/Pairs Trading/co.py:28: RuntimeWarning: invalid value encountered in log\n",
      "  return np.log(self.pdf(u,v)).sum()\n"
     ]
    },
    {
     "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>copula</th>\n",
       "      <th>parameter</th>\n",
       "      <th>aic</th>\n",
       "      <th>bic</th>\n",
       "      <th>KS_pvalue</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>AAPL-MSFT</th>\n",
       "      <td>Gaussian</td>\n",
       "      <td>0.72336</td>\n",
       "      <td>-700.34892</td>\n",
       "      <td>-695.723528</td>\n",
       "      <td>0.146775</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             copula parameter        aic         bic KS_pvalue\n",
       "AAPL-MSFT  Gaussian   0.72336 -700.34892 -695.723528  0.146775"
      ]
     },
     "execution_count": 719,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#fit bivariate copula family to data \n",
    "#calculate Akaike information criterion, Bayesion information criterion and KS value to help determine good fit\n",
    "\n",
    "from co import *\n",
    "import ndtest\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",
    "copulas_df.loc[pair] = [best_copula.name, best_param, best_aic, best_bic, ks_pval]\n",
    "copulas_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 720,
   "id": "0fabd666",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Algorithm returns for trading period:\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Date\n",
       "2022-01-11    0.000000\n",
       "2022-01-12    0.007824\n",
       "2022-01-13   -0.000000\n",
       "2022-01-14    0.000000\n",
       "2022-01-18   -0.000000\n",
       "2022-01-19    0.000000\n",
       "2022-01-20   -0.004681\n",
       "2022-01-21    0.005794\n",
       "2022-01-24    0.000000\n",
       "2022-01-25   -0.000000\n",
       "2022-01-26    0.000000\n",
       "2022-01-27   -0.013441\n",
       "2022-01-28    0.039756\n",
       "2022-01-31    0.000000\n",
       "2022-02-01   -0.000000\n",
       "2022-02-02    0.000000\n",
       "2022-02-03   -0.000000\n",
       "2022-02-04    0.000000\n",
       "2022-02-07    0.012201\n",
       "2022-02-08    0.000000\n",
       "2022-02-09    0.000000\n",
       "dtype: float64"
      ]
     },
     "execution_count": 720,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# exit trade when pair reverts to historical relationship\n",
    "# close position using criteria from'Pairs trading: A copula approach' - Liew, Wu, 2013\n",
    "# paper link: https://link.springer.com/content/pdf/10.1057/jdhf.2013.1.pdf\n",
    "# close positions when conditional probabilies cross boundery of 0.5\n",
    "\n",
    "# rules for opening positions\n",
    "# short position -> P(U<= u | V=v) >=c *A overpriced* AND P(V<= v | U=u) <=(1-c) *B underpriced*\n",
    "# long position -> P(U<= u | V=v) <=(1-c) *A underpriced* AND P(V<= v | U=u) >=(c) *B overpriced*\n",
    "\n",
    "from co import *\n",
    "import ndtest\n",
    "# calculate conditional probabilities\n",
    "prob1=[]\n",
    "prob2=[]\n",
    "x=GaussianCopula()\n",
    "algo_returns = {}\n",
    "cl = 0.80\n",
    "\n",
    "for u,v in zip(dist1.cdf(returns_trade_period[asset1]), dist2.cdf(returns_trade_period[asset2])):\n",
    "    prob1.append(best_copula.cdf_u_given_v(u,v))\n",
    "    prob2.append(best_copula.cdf_v_given_u(u,v))\n",
    "\n",
    "\n",
    "probs_trade= pd.DataFrame(np.vstack([prob1,prob2]).T,index=returns_trade_period.index, columns=[asset1,asset2])\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][asset1] > 0.5) or (probs_trade.loc[t][asset2] < 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][asset1] < 0.5) or (probs_trade.loc[t][asset2] > 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][asset1] < (1-cl)) and (probs_trade.loc[t][asset2] > cl):\n",
    "            # open long position\n",
    "            positions.loc[t] = [1,-1]\n",
    "            long = True\n",
    "        elif (probs_trade.loc[t][asset1] > cl) and (probs_trade.loc[t][asset2] < (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[pairs] = algo_ret\n",
    "\n",
    "print('Algorithm returns for trading period:')\n",
    "algo_ret\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 721,
   "id": "dceb487e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[*********************100%***********************]  1 of 1 completed\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x129f943a0>"
      ]
     },
     "execution_count": 721,
     "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",
    "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.legend()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 722,
   "id": "2e427290",
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_metrics(cumret):\n",
    "    '''\n",
    "    calculate performance metrics from cumulative returns (thank you to @financialnoob for this method (https://github.com/financialnoob/pairs_trading)\n",
    "    '''\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": 723,
   "id": "89d494be",
   "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.097394</td>\n",
       "      <td>2.05035</td>\n",
       "      <td>3.873347</td>\n",
       "      <td>-0.026702</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>QQQ</th>\n",
       "      <td>-0.049479</td>\n",
       "      <td>-0.456073</td>\n",
       "      <td>-1.927251</td>\n",
       "      <td>-0.119401</td>\n",
       "      <td>19.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     Total return       APR    Sharpe Max Drawdown Max Length Drawdown\n",
       "Algo     0.097394   2.05035  3.873347    -0.026702                 1.0\n",
       "QQQ     -0.049479 -0.456073 -1.927251    -0.119401                19.0"
      ]
     },
     "execution_count": 723,
     "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[short_asset] = calculate_metrics(np.nancumprod(app_ret + 1))\n",
    "metrics.loc[index_comp] = calculate_metrics(np.nancumprod(index_ret + 1))\n",
    "\n",
    "metrics"
   ]
  }
 ],
 "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
}