Wealth_Management_GIRL_v2.1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "Vc1tLT83PQMd"
   },
   "outputs": [],
   "source": [
    "# ML_in_Finance-GIRL-wealth-management\n",
    "# Author: Igor Halperin and Matthew Dixon\n",
    "# Version: 1.0 (12.8.2019)\n",
    "# License: MIT\n",
    "# Email: ighalp@gmail.com\n",
    "# Notes: tested on Mac OS X with Python 3.6 and PyTorch 1.3.0\n",
    "# Citation: Please cite the following reference if this notebook is used for research purposes:\n",
    "# Dixon M.F., I. Halperin and P. Bilokon, Machine Learning in Finance: From Theory to Practice, Springer Graduate textbook Series, 2020. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "uXdeHDmEPQM6"
   },
   "source": [
    "## Overview \n",
    "\n",
    "This notebook demonstrates the application of G-learning and GIRL for optimization of a defined contribution retirement plan. The notebook extends the G-learning notebook in Chapter 10 with an example of applying GIRL to infer the parameters of the G-learner used to generate the trajectories."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "id": "vOoE16hWPQNC"
   },
   "outputs": [],
   "source": [
    "import time\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib\n",
    "matplotlib.use('Agg')\n",
    "import matplotlib.pyplot as plt \n",
    "%matplotlib inline\n",
    "import torch\n",
    "import torch.optim as optim\n",
    "import pandas as pd\n",
    "import scipy \n",
    "from scipy.optimize import minimize\n",
    "from scipy.stats import linregress\n",
    "from pandas_datareader import data\n",
    "from G_learning_portfolio_opt import G_learning_portfolio_opt\n",
    "from get_loss_function import *\n",
    "import gc\n",
    "%load_ext autoreload\n",
    "\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "id": "M-6MadDnPQNO",
    "outputId": "3beace7c-5af9-41db-c360-65bc53aa23c0"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1.3.1'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.__version__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "PHyhUTpJ4nl1",
    "outputId": "55fa7fe3-28dd-4a1e-8686-b3a366652e14"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "env: KMP_DUPLICATE_LIB_OK=TRUE\n"
     ]
    }
   ],
   "source": [
    "%env KMP_DUPLICATE_LIB_OK=TRUE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "id": "S0yKeMU9PQNa"
   },
   "outputs": [],
   "source": [
    "# set the device\n",
    "device = 'cuda' if torch.cuda.is_available() else 'cpu'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "N_8XeDlpPQOV"
   },
   "source": [
    "## Simulate portfolio data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "DNFzG5dgPQPB"
   },
   "source": [
    "### Extract market and stock data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "start_year= 2011 # For CAPM regression\n",
    "end_year=2020\n",
    "R = 0.01/4  # quarterly risk free rate\n",
    "N=252\n",
    "dt = 1\n",
    "num_risky_assets = 99 \n",
    "quarters=['01-01', '03-31', '06-30', '09-30','12-31']\n",
    "start_date=quarters[0] +'-'+str(start_year)\n",
    "end_date=quarters[4] +'-'+str(end_year)\n",
    "periods=[]\n",
    "for year in range(start_year, end_year):\n",
    "    for j in range(0,4):\n",
    "        periods.append(str(year)+'Q'+str(j+1))\n",
    "        \n",
    "bAcquire = False # toggle to True to acquire data        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "tickers=['AAPL', 'ACLS', 'ADBE', 'ALLT', 'ALOT', 'AMAT', 'AMKR', 'ANSS', 'ASML',\n",
    "       'AVGO', 'AVID', 'AWRE', 'AXTI', 'AZPN', 'BBSI', 'BIDU', 'BLKB', 'BRKS',\n",
    "       'CAMP', 'CCMP', 'CCRN', 'CERN', 'CHKP', 'CPSI', 'CREE', 'CRUS', 'CSCO',\n",
    "       'CSGS', 'CSIQ', 'CSPI', 'CTSH', 'CTXS', 'CVLT', 'DGII', 'DSPG', 'EGAN',\n",
    "       'ELTK', 'EMKR', 'EPAY', 'ERII', 'EVOL', 'EXTR', 'FFIV', 'FISV', 'FLEX',\n",
    "       'FORM', 'FSLR', 'FTNT', 'GLUU', 'GOOG', 'GSIT', 'HIMX', 'HLIT', 'HSII',\n",
    "       'HSTM', 'IDN', 'IMMR', 'INOD', 'INTU', 'IPGP', 'ISSC', 'ITRN', 'IVAC',\n",
    "       'JCOM', 'JKHY', 'JOBS', 'KFRC', 'KOPN', 'KTCC', 'KVHI', 'LOGI', 'LPSN',\n",
    "       'LPTH', 'LRCX', 'LTRX', 'MANH', 'MCHP', 'MGIC', 'MGRC', 'MOSY', 'MPWR',\n",
    "       'MRVL', 'MSFT', 'MSTR', 'MXIM', 'NATI', 'NTAP', 'NTCT', 'NVDA', 'OMCL',\n",
    "       'OSIS', 'OTEX', 'PCTI', 'PDFS', 'PEGA', 'PLAB', 'PLUS', 'PRFT', 'PXLW'] ## 99 symbols"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "if bAcquire:\n",
    "    stock_data = data.DataReader(tickers, 'yahoo', start_date, end_date)['Adj Close']\n",
    "    stock_data.to_csv('stockdata2011-2021.csv', header=tickers)\n",
    "else:\n",
    "    stock_data=pd.read_csv('stockdata2011-2021.csv')\n",
    "    stock_data= stock_data.set_index('Date')\n",
    "    stock_data.index=pd.to_datetime(stock_data.index) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "if bAcquire:\n",
    "    market_data= data.DataReader('^GSPC', 'yahoo', start_date, end_date)['Adj Close']\n",
    "    market_data.to_csv('marketdata2011-2021.csv', header=['^GSPC'])\n",
    "else:    \n",
    "    market_data=pd.read_csv('marketdata2011-2021.csv')\n",
    "    market_data=market_data.set_index('Date')\n",
    "    market_data.index=pd.to_datetime(market_data.index) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "risky_asset_returns=stock_data[tickers].pct_change(periods=1)\n",
    "market_returns=market_data.pct_change(periods=1)\n",
    "\n",
    "risky_asset_returns=risky_asset_returns.dropna()\n",
    "market_returns=market_returns.dropna()\n",
    "risky_asset_returns.index=pd.to_datetime(risky_asset_returns.index)  \n",
    "market_returns.index=pd.to_datetime(market_returns.index)  \n",
    "\n",
    "risky_asset_vol = risky_asset_returns.std()\n",
    "market_vol = market_returns.std()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use CAPM to estimate the expected risky asset returns\n",
    "def get_expected_R_CAPM():\n",
    "    expected_R = pd.DataFrame(index = tickers,columns = periods)\n",
    "    \n",
    "    print(\"Period, R^2, slope, intercept\")\n",
    "    for year in range(start_year+1,end_year):\n",
    "      for j in range(0,4): \n",
    "       \n",
    "        if (j==0): #always fit CAPM from the previous period\n",
    "            mask = (risky_asset_returns.index > str(year-1)+'-'+quarters[2]) & (risky_asset_returns.index < str(year-1)+'-'+quarters[3])\n",
    "        else:    \n",
    "            mask = (risky_asset_returns.index > str(year)+'-'+quarters[j-1]) & (risky_asset_returns.index < str(year)+'-'+quarters[j])\n",
    "        \n",
    "        x = market_returns.loc[mask].values \n",
    "        xs_rets=[]\n",
    "        xs_rets_M=[]\n",
    "        xs_ret_M = (1+np.mean(x))**252/4 -1-R # quarterly excess expected market returns\n",
    "          \n",
    "        for ticker in tickers:\n",
    "           #print(str(year)+'-'+quarters[j])\n",
    "           \n",
    "           if (j==0): #always fit CAPM from the previous period\n",
    "                mask = (stock_data[ticker].index > str(year-1)+'-'+quarters[2]) & (stock_data[ticker].index < str(year-1)+'-'+quarters[3])\n",
    "           else:    \n",
    "                mask = (stock_data[ticker].index > str(year)+'-'+quarters[j-1]) & (stock_data[ticker].index < str(year)+'-'+quarters[j])\n",
    "       \n",
    "           prices = stock_data.loc[mask][ticker].values \n",
    "          \n",
    "           xs_ret= (prices[-1] - prices[0])/prices[0] -R # quarterly excess risky asset returns\n",
    "           \n",
    "           xs_rets.append(xs_ret)\n",
    "            \n",
    "           if (j==0): #always fit CAPM from the previous period\n",
    "             mask = (risky_asset_returns.index > str(year-1)+'-'+quarters[2]) & (risky_asset_returns.index < str(year-1)+'-'+quarters[3])\n",
    "           else:    \n",
    "             mask = (risky_asset_returns.index > str(year)+'-'+quarters[j-1]) & (risky_asset_returns.index < str(year)+'-'+quarters[j])\n",
    "        \n",
    "           y = risky_asset_returns.loc[mask][ticker].values.flatten() # extract all dates in each year      \n",
    "           x = market_returns.loc[mask].values.flatten() \n",
    "           \n",
    "           beta = np.cov(x,y)[0,1]/np.var(x)\n",
    "           xs_rets_M.append(beta*xs_ret_M)\n",
    "            \n",
    "        model=linregress(xs_rets_M,xs_rets) # fit CAPM model\n",
    "        print(str(year)+'-'+str(quarters[j]), model.rvalue, model.intercept, model.slope)\n",
    "        \n",
    "        mask = (risky_asset_returns.index > str(year)+'-'+quarters[j]) & (risky_asset_returns.index < str(year)+'-'+quarters[j+1])\n",
    "        x = market_returns.loc[mask].values.flatten()    \n",
    "        for ticker in tickers:\n",
    "            y = risky_asset_returns.loc[mask][ticker].values.flatten() # extract all dates in each year      \n",
    "            if len(x)==len(y):\n",
    "                beta = np.cov(x,y)[0,1]/np.var(x)\n",
    "                expected_R.loc[ticker,str(year)+'Q'+str(j+1)] = R+ model.intercept + model.slope*beta*((1+np.mean(x))**252/4 -1-R)    \n",
    "            else:\n",
    "                print('Error in ' + ticker + \",\" + str(len(x)) + \",\" + str(len(y)))\n",
    "     \n",
    "    return expected_R"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use OLS on historical training data for each each ticker \n",
    "def get_expected_R_OLS():\n",
    "    expected_R = pd.DataFrame(index = tickers,columns = periods)\n",
    "    \n",
    "    \n",
    "    for ticker in tickers:\n",
    "        print(\"Period, R^2, slope, intercept\")\n",
    "        ys_rets=[]\n",
    "        xs_rets_M=[]\n",
    "        for year in range(start_year+1,end_year-2):\n",
    "              for j in range(0,4): \n",
    "                 if (j==0): #always fit CAPM from the previous period\n",
    "                    mask = (stock_data[ticker].index > str(year-1)+'-'+quarters[2]) & (stock_data[ticker].index < str(year-1)+'-'+quarters[3])\n",
    "                 else:    \n",
    "                    mask = (stock_data[ticker].index > str(year)+'-'+quarters[j-1]) & (stock_data[ticker].index < str(year)+'-'+quarters[j])\n",
    "          \n",
    "                      \n",
    "                 prices = stock_data.loc[mask][ticker].values \n",
    "          \n",
    "                 ys_ret= (prices[-1] - prices[0])/prices[0] -R # quarterly excess risky asset returns\n",
    "           \n",
    "                 ys_rets.append(ys_ret)\n",
    "                  \n",
    "                 if (j==0): #always fit CAPM from the previous period\n",
    "                    mask = (risky_asset_returns.index > str(year-1)+'-'+quarters[2]) & (risky_asset_returns.index < str(year-1)+'-'+quarters[3])\n",
    "                 else:    \n",
    "                    mask = (risky_asset_returns.index > str(year)+'-'+quarters[j-1]) & (risky_asset_returns.index < str(year)+'-'+quarters[j])\n",
    "          \n",
    "                \n",
    "                 x = market_returns.loc[mask].values.flatten() \n",
    "                 xs_ret_M = (1+np.mean(x))**252/4 -1-R # quarterly excess expected market returns\n",
    "                 y = risky_asset_returns.loc[mask][ticker].values.flatten() # extract all dates in each year\n",
    "                \n",
    "                 if len(x)==len(y):\n",
    "                     beta = np.cov(x,y)[0,1]/np.var(x)\n",
    "                     xs_rets_M.append(beta*xs_ret_M)\n",
    "                 else:\n",
    "                     print('Error in ' + ticker + \",\" + str(len(x)) + \",\" + str(len(y)))\n",
    "        model=linregress(xs_rets_M,ys_rets) \n",
    "        \n",
    "        print(ticker, model.rvalue, model.intercept, model.slope)\n",
    "        for year in range(end_year-2,end_year):\n",
    "              for j in range(0,4): \n",
    "                 if (j==0): #always fit CAPM from the previous period\n",
    "                    mask = (risky_asset_returns.index > str(year-1)+'-'+quarters[2]) & (risky_asset_returns.index < str(year-1)+'-'+quarters[3])\n",
    "                 else:    \n",
    "                    mask = (risky_asset_returns.index > str(year)+'-'+quarters[j-1]) & (risky_asset_returns.index < str(year)+'-'+quarters[j])\n",
    "          \n",
    "                 x = market_returns.loc[mask].values.flatten()    \n",
    "                 y = risky_asset_returns.loc[mask][ticker].values.flatten() # extract all dates in each year\n",
    "                 \n",
    "                 if len(x)==len(y):\n",
    "                    beta = np.cov(x,y)[0,1]/np.var(x)\n",
    "                    expected_R.loc[ticker,str(year)+'Q'+str(j+1)] = R+ model.intercept + model.slope*beta*((1+np.mean(x))**252/4 -1-R)    \n",
    "                 else:\n",
    "                    print('Error in ' + ticker + \",\" + str(len(x)) + \",\" + str(len(y)))\n",
    "\n",
    "    return expected_R"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use OLS on historical training data for each each ticker \n",
    "def get_expected_R_Oracle(c):\n",
    "    expected_R = pd.DataFrame(index = tickers,columns = periods)\n",
    "    \n",
    "    \n",
    "    for ticker in tickers:\n",
    "        print(\"Period, R^2, slope, intercept\")\n",
    "        ys_rets=[]\n",
    "        xs_rets_M=[]\n",
    "        \n",
    "        \n",
    "        xs_rets = []\n",
    "        ys_rets = []\n",
    "        for year in range(start_year+1,end_year):\n",
    "              for j in range(0,4): \n",
    "                 if (j==0): #always fit CAPM from the previous period\n",
    "                    mask = (stock_data[ticker].index > str(year-1)+'-'+quarters[2]) & (stock_data[ticker].index < str(year-1)+'-'+quarters[3])\n",
    "                 else:    \n",
    "                    mask = (stock_data[ticker].index > str(year)+'-'+quarters[j-1]) & (stock_data[ticker].index < str(year)+'-'+quarters[j])\n",
    "          \n",
    "                      \n",
    "                 prices = stock_data.loc[mask][ticker].values \n",
    "          \n",
    "                 if (j==0): #always fit CAPM from the previous period\n",
    "                    mask = (risky_asset_returns.index > str(year-1)+'-'+quarters[2]) & (risky_asset_returns.index < str(year-1)+'-'+quarters[3])\n",
    "                 else:    \n",
    "                    mask = (risky_asset_returns.index > str(year)+'-'+quarters[j-1]) & (risky_asset_returns.index < str(year)+'-'+quarters[j])\n",
    "          \n",
    "                    \n",
    "                 y = risky_asset_returns.loc[mask][ticker].values # extract all dates in each year  \n",
    "                 x = market_returns.loc[mask].values \n",
    "                   \n",
    "                 mu = (1+np.mean(x))**252/4 -1-R # quarterly excess expected market returns\n",
    "                 sigma= np.std(x)*2 # scale by sqrt(4)\n",
    "                 if len(x)==len(y):\n",
    "                     \n",
    "                     beta = np.cov(x.flatten(),y.flatten())[0,1]/np.var(x.flatten())\n",
    "                     ret= (prices[-1] - prices[0])/prices[0]# quarterly excess risky asset returns\n",
    "                     xs_rets.append(c*ret + (1-c)*beta*(sigma*np.random.randn() +mu) -R)\n",
    "                     expected_R.loc[ticker,str(year)+'Q'+str(j+1)] = R+xs_rets[-1]    \n",
    "                     ys_rets.append(ret)\n",
    "                 else:\n",
    "                     print('Error in ' + ticker + \",\" + str(len(x)) + \",\" + str(len(y)))\n",
    "        model=linregress(xs_rets,ys_rets) \n",
    "        \n",
    "        print(ticker, model.rvalue, model.intercept, model.slope)\n",
    "                \n",
    "    return expected_R"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Period, R^2, slope, intercept\n",
      "AAPL 0.41285767099921095 0.2297547105496882 0.2292179030542845\n",
      "Period, R^2, slope, intercept\n",
      "ACLS -0.20330992712538257 -0.09583206645220471 -0.1023391859899275\n",
      "Period, R^2, slope, intercept\n",
      "ADBE 0.08655997087655036 0.09686865774988071 0.0510001712753753\n",
      "Period, R^2, slope, intercept\n",
      "ALLT -0.23745969963539307 -0.1478460532694365 -0.07812773283811175\n",
      "Period, R^2, slope, intercept\n",
      "ALOT 0.44902253210223075 0.04176381981802112 0.15449920547518203\n",
      "Period, R^2, slope, intercept\n",
      "AMAT -0.17389830024350006 -0.04639333044121132 -0.10119068987517803\n",
      "Period, R^2, slope, intercept\n",
      "AMKR -0.07180193240015519 -0.02952414948029965 -0.043227417686834205\n",
      "Period, R^2, slope, intercept\n",
      "ANSS 0.10161491936575741 0.070723141499682 0.046516774315761227\n",
      "Period, R^2, slope, intercept\n",
      "ASML 0.07654213625457018 0.09768914489634017 0.041429617176533005\n",
      "Period, R^2, slope, intercept\n",
      "AVGO 0.45062840684470346 0.3413616188123618 0.2305347148296311\n",
      "Period, R^2, slope, intercept\n",
      "AVID -0.06774607252665346 -0.04410299279285372 -0.030653358983145893\n",
      "Period, R^2, slope, intercept\n",
      "AWRE -0.003992436717676107 0.03533595454240217 -0.005185845531322812\n",
      "Period, R^2, slope, intercept\n",
      "AXTI -0.24587516037701992 -0.0653940165147656 -0.09931100177257389\n",
      "Period, R^2, slope, intercept\n",
      "AZPN 0.11358411687319812 0.09483959057031005 0.05752130831961666\n",
      "Period, R^2, slope, intercept\n",
      "BBSI 0.24140481109494133 0.17890011626051347 0.14064679107992156\n",
      "Period, R^2, slope, intercept\n",
      "BIDU -0.15695375398156958 -0.09983780669591408 -0.15115353769888198\n",
      "Period, R^2, slope, intercept\n",
      "BLKB 0.1997450727963609 0.09942374365516386 0.07637628817654031\n",
      "Period, R^2, slope, intercept\n",
      "BRKS -0.2733446855048963 -0.09765131417946876 -0.10605111610265391\n",
      "Period, R^2, slope, intercept\n",
      "CAMP 0.228324753946427 0.1042536931405979 0.08156045932815775\n",
      "Period, R^2, slope, intercept\n",
      "CCMP -0.015531511026249131 0.005164736095204227 -0.008170633573277002\n",
      "Period, R^2, slope, intercept\n",
      "CCRN 0.26538729896415836 0.09893048233632071 0.1089348170560525\n",
      "Period, R^2, slope, intercept\n",
      "CERN 0.019939922331428994 0.05218776821457609 0.00968129774097921\n",
      "Period, R^2, slope, intercept\n",
      "CHKP 0.11062823813985481 0.043414491421270955 0.037284408656611034\n",
      "Period, R^2, slope, intercept\n",
      "CPSI -0.6590967051126143 -0.20108137834431108 -0.3004051322263426\n",
      "Period, R^2, slope, intercept\n",
      "CREE -0.12625173781469465 -0.08144495527289843 -0.06469175855324555\n",
      "Period, R^2, slope, intercept\n",
      "CRUS 0.08084649938880555 0.16080935221624254 0.044225205397556894\n",
      "Period, R^2, slope, intercept\n",
      "CSCO 0.1274064830089932 0.06709696098608861 0.04971186509567972\n",
      "Period, R^2, slope, intercept\n",
      "CSGS 0.4614767934622058 0.271502024316427 0.32106798033069023\n",
      "Period, R^2, slope, intercept\n",
      "CSIQ -0.24298409825675132 -0.3210348591510893 -0.24205399591997964\n",
      "Period, R^2, slope, intercept\n",
      "CSPI 0.09375469990914544 0.060046185908554206 0.06766353832827053\n",
      "Period, R^2, slope, intercept\n",
      "CTSH 0.08180856129138517 0.08313631494875388 0.0627635637240571\n",
      "Period, R^2, slope, intercept\n",
      "CTXS 0.2213364520545 0.12248381540570594 0.0985195087329485\n",
      "Period, R^2, slope, intercept\n",
      "CVLT 0.08166749765087124 0.05337475152196211 0.029384197779188354\n",
      "Period, R^2, slope, intercept\n",
      "DGII 0.22554340089772493 0.03617476627235243 0.0690426329646724\n",
      "Period, R^2, slope, intercept\n",
      "DSPG 0.14871904757991594 0.06232470331028332 0.06471239719268161\n",
      "Period, R^2, slope, intercept\n",
      "EGAN -0.06982179200154245 0.02422236591634959 -0.0595234204025193\n",
      "Period, R^2, slope, intercept\n",
      "ELTK 0.0827876481381756 0.003494243679129346 0.03088183289597161\n",
      "Period, R^2, slope, intercept\n",
      "EMKR 0.3531857374023038 0.21369040129562072 0.1530370751468592\n",
      "Period, R^2, slope, intercept\n",
      "EPAY -0.10466418638584768 -0.0645168838373143 -0.07624632985779864\n",
      "Period, R^2, slope, intercept\n",
      "ERII -0.190544244647976 -0.06330133999572311 -0.10839864864356755\n",
      "Period, R^2, slope, intercept\n",
      "EVOL 0.08481160790472882 0.027022985433706837 0.05455436253333791\n",
      "Period, R^2, slope, intercept\n",
      "EXTR -0.07049227844148472 0.05330507399874231 -0.03648943255751052\n",
      "Period, R^2, slope, intercept\n",
      "FFIV -0.1977236328777922 -0.08625521553996458 -0.0963656984022729\n",
      "Period, R^2, slope, intercept\n",
      "FISV 0.2835622826898557 0.16957513576238728 0.1837782280651281\n",
      "Period, R^2, slope, intercept\n",
      "FLEX 0.31600418750247544 0.21221760112181154 0.18314831295127096\n",
      "Period, R^2, slope, intercept\n",
      "FORM -0.40848639050709185 -0.1604793232659203 -0.17619113670641295\n",
      "Period, R^2, slope, intercept\n",
      "FSLR 0.052565633675652854 0.05208187872424741 0.050864239807675155\n",
      "Period, R^2, slope, intercept\n",
      "FTNT 0.1674285881383868 0.12849748595294933 0.07901042412612584\n",
      "Period, R^2, slope, intercept\n",
      "GLUU 0.07834387059973778 0.06526461906312694 0.030702719808883856\n",
      "Period, R^2, slope, intercept\n",
      "GOOG 0.20597785889253545 0.12129004626018439 0.08623912312042244\n",
      "Period, R^2, slope, intercept\n",
      "GSIT 0.047476666128325185 0.0028483896548092413 0.019878882685385874\n",
      "Period, R^2, slope, intercept\n",
      "HIMX -0.41043839089390505 -0.2336161363077107 -0.3396795585602949\n",
      "Period, R^2, slope, intercept\n",
      "HLIT -0.5938908355461994 -0.40062402056831764 -0.3722407553901601\n",
      "Period, R^2, slope, intercept\n",
      "HSII -0.23784828978502867 -0.16472628743770937 -0.12235523579298586\n",
      "Period, R^2, slope, intercept\n",
      "HSTM 0.2240830484863252 0.12422746442289868 0.1021642917327008\n",
      "Period, R^2, slope, intercept\n",
      "IDN -0.08813053203947219 -0.0024317130877324344 -0.07329499954457551\n",
      "Period, R^2, slope, intercept\n",
      "IMMR 0.22833928888488936 0.07474535477613387 0.09658233256035381\n",
      "Period, R^2, slope, intercept\n",
      "INOD -0.5593299900126257 -0.09218122959574268 -0.1795452664877993\n",
      "Period, R^2, slope, intercept\n",
      "INTU 0.3923923865209492 0.15809274749266292 0.17609437170923128\n",
      "Period, R^2, slope, intercept\n",
      "IPGP -0.02922320925619931 0.01403451575620097 -0.01644151454874332\n",
      "Period, R^2, slope, intercept\n",
      "ISSC -0.2014341837927121 -0.017148730275170505 -0.10262083349214597\n",
      "Period, R^2, slope, intercept\n",
      "ITRN 0.9983579359030765 0.3233475052114807 0.7161839553682979\n",
      "Period, R^2, slope, intercept\n",
      "IVAC -0.00460540905934847 -0.05040056875706198 -0.0015165768315674817\n",
      "Period, R^2, slope, intercept\n",
      "JCOM 0.4752666038013291 0.20658441561866162 0.20297154309098583\n",
      "Period, R^2, slope, intercept\n",
      "JKHY 0.38353455792185964 0.14666986211458946 0.17283789156070475\n",
      "Period, R^2, slope, intercept\n",
      "JOBS 0.5973248407080917 0.20165991191310384 0.30925878605042617\n",
      "Period, R^2, slope, intercept\n",
      "KFRC 0.34472599790411956 0.12466620416313186 0.13240137669588412\n",
      "Period, R^2, slope, intercept\n",
      "KOPN -0.09269168367915982 -0.058664477132250495 -0.03168827021258363\n",
      "Period, R^2, slope, intercept\n",
      "KTCC -0.03387047886744067 0.018561424278402506 -0.021490833679786728\n",
      "Period, R^2, slope, intercept\n",
      "KVHI 0.03248871782746981 0.004238631297487276 0.012183165611593617\n",
      "Period, R^2, slope, intercept\n",
      "LOGI 0.033874390765690605 0.07794437008788405 0.019578184269247397\n",
      "Period, R^2, slope, intercept\n",
      "LPSN 0.028855952320840664 0.02909813780121484 0.012214084470699589\n",
      "Period, R^2, slope, intercept\n",
      "LPTH 0.36127558715099994 0.12458294554729459 0.20201866981523517\n",
      "Period, R^2, slope, intercept\n",
      "LRCX -0.31154049480887297 -0.13765220051728805 -0.17569107538136242\n",
      "Period, R^2, slope, intercept\n",
      "LTRX -0.03993750275120503 -0.018248446277967595 -0.01724560153853316\n",
      "Period, R^2, slope, intercept\n",
      "MANH 0.23454132243945053 0.17517956503179535 0.12589340932018875\n",
      "Period, R^2, slope, intercept\n",
      "MCHP -0.27765267293670054 -0.1025618608738681 -0.15976349897053727\n",
      "Period, R^2, slope, intercept\n",
      "MGIC 0.2486122442660457 0.09389357042860526 0.13020941114263274\n",
      "Period, R^2, slope, intercept\n",
      "MGRC 0.05416014103376795 0.013733878881301599 0.02798844681253915\n",
      "Period, R^2, slope, intercept\n",
      "MOSY 0.19451708872507298 -0.0023924668385842396 0.0575110771165868\n",
      "Period, R^2, slope, intercept\n",
      "MPWR 0.35982170552313375 0.21577140380936233 0.15620552068907326\n",
      "Period, R^2, slope, intercept\n",
      "MRVL -0.0905405371999885 -0.046622727698427305 -0.06887241370590595\n",
      "Period, R^2, slope, intercept\n",
      "MSFT 0.4871096610491325 0.2178652302666513 0.22385523751973452\n",
      "Period, R^2, slope, intercept\n",
      "MSTR -0.0572902094898765 -0.03843371467070573 -0.04146386500266596\n",
      "Period, R^2, slope, intercept\n",
      "MXIM 0.09786712086915475 0.061281790855610654 0.04797858190511516\n",
      "Period, R^2, slope, intercept\n",
      "NATI 0.03856306591353606 0.025144539975481623 0.024496690262733628\n",
      "Period, R^2, slope, intercept\n",
      "NTAP -0.1251819863422017 -0.03553619556775076 -0.08328907799816589\n",
      "Period, R^2, slope, intercept\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NTCT 0.11625550080131666 0.12010700316444711 0.08106735883885338\n",
      "Period, R^2, slope, intercept\n",
      "NVDA -0.3693508651753194 -0.02605324047744642 -0.1370764591579872\n",
      "Period, R^2, slope, intercept\n",
      "OMCL -0.036044197826456764 0.008757402243829343 -0.025428090215868483\n",
      "Period, R^2, slope, intercept\n",
      "OSIS 0.27447401172395863 0.20954017371336917 0.20738408993999594\n",
      "Period, R^2, slope, intercept\n",
      "OTEX 0.07963965926404021 0.050818577162157576 0.018508435232432247\n",
      "Period, R^2, slope, intercept\n",
      "PCTI -0.17368971361408717 -0.03825867278407992 -0.05921721108960573\n",
      "Period, R^2, slope, intercept\n",
      "PDFS -0.2338632168739176 -0.25403191776871886 -0.23955386308340068\n",
      "Period, R^2, slope, intercept\n",
      "PEGA 0.14998802813172216 0.12479458946982463 0.07474553297801449\n",
      "Period, R^2, slope, intercept\n",
      "PLAB 0.3305068009142212 0.04695160413882266 0.08794006883945969\n",
      "Period, R^2, slope, intercept\n",
      "PLUS -0.17881591442818343 -0.029362003106742106 -0.10406155925671956\n",
      "Period, R^2, slope, intercept\n",
      "PRFT 0.17404380756005372 0.10498677646384075 0.11155456306552174\n",
      "Period, R^2, slope, intercept\n",
      "PXLW -0.11167094120826426 0.042047050717064736 -0.04646368136450433\n"
     ]
    }
   ],
   "source": [
    "write_data_to_csv = True\n",
    "if write_data_to_csv == True: \n",
    "    #expected_risky_returns=get_expected_R_CAPM()\n",
    "    #expected_risky_returns=get_expected_R_Oracle(0.2)\n",
    "    expected_risky_returns=get_expected_R_OLS()\n",
    "    expected_risky_returns.to_csv('expected_R.csv', sep=',', header=True, index=True)\n",
    "else:\n",
    "    expected_risky_returns= pd.read_csv('expected_R.csv', index_col = 0).dropna()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "investment_periods=[]\n",
    "for year in range(end_year-2, end_year):\n",
    "    for j in range(0,4):\n",
    "        investment_periods.append(str(year)+'Q'+str(j+1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Extract the risky quarterly returns\n",
    "risky_asset_R = pd.DataFrame(index = tickers,columns = investment_periods)\n",
    "expected_asset_R = pd.DataFrame(index = tickers,columns = investment_periods) \n",
    "for year in range(end_year-2,end_year):\n",
    "      for j in range(0,4): \n",
    "            #stock_data['AAPL'].groupby(pd.Grouper(freq='Q'))\n",
    "            mask = (stock_data.index > str(year)+'-'+quarters[j]) & (stock_data.index < str(year)+'-'+quarters[j+1])\n",
    "            quarterly_returns=((stock_data[mask].iloc[-1]- stock_data[mask].iloc[0])/stock_data[mask].iloc[0]).values\n",
    "            #annualized_quarterly_returns=(1+quarterly_returns)**4-1\n",
    "            risky_asset_R.loc[:,str(year)+'Q'+str(j+1)] =quarterly_returns\n",
    "            expected_asset_R.loc[:,str(year)+'Q'+str(j+1)]= expected_risky_returns.loc[:,str(year)+'Q'+str(j+1)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "risky_asset_returns=risky_asset_R\n",
    "expected_risky_returns=expected_asset_R"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 295
    },
    "id": "YvHvV7B6PQPh",
    "outputId": "3421ed28-a65f-4362-d166-990d22dbf1fd"
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYAAAAEWCAYAAABv+EDhAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOydd5iU1dXAf4ddlt57XxBEitSlKc1dEIxG1FgwFsQo1hg1GiXFoDGx4BcrUbFALKjBRCVWzC69KKCACEhdmiC7S13qlvP9cd9ZhmUrM7szs3N+zzPPzFvm3jPv+849955z7zmiqhiGYRjRR6VQC2AYhmGEBlMAhmEYUYopAMMwjCjFFIBhGEaUYgrAMAwjSjEFYBiGEaWYAggzRGSoiGz32/5eRIYGuY6pIvJoMMssoq4JIvKW97m1iGSKSEyQ60gVkWHBLNMIX/L/R4zTJ+oVgIjMFpG9IlIl1LIUhKp2UdXZoZYjGKjqVlWtqao5oZalMKxxKXvKswNSEsJNnvIkqhWAiMQDgwAFLg6pMGGKiMSGWoZgEuzRRwHlV6jrFemUx/2I5Hse1QoAuB5YDEwFxvgf8HoFk0TkExE5KCJficgZfsdVRG4VkfUiss87V7xjeWYPbzveOz/W2x4rImu8cjeJyC2FCehv3vDqyfReh7wy471jF4nIcu+chSLSza+MniLyjVffe0DVIuq7QUQWiMjTIpIBTPD23+jJvFdEvhCRNn7feVZEtonIARFZJiKDCik77zqIyAC/35IpIkdFJNU7r5KIPCgiG0UkQ0T+JSL1/cq5TkS2eMf+UNhv8c6dKiIvisinInIIOE9EqojIUyKyVUR+EpGXRKSaiNQAPgOa+8nVPH8PsQAzXaqIPCAiK4FD3u9LFZH7RGSliOwXkfdEpKp3fkMR+di7V3tEZJ6InPJf9OR+Kt++j0TkXu/zAyKyw7uvP4hIUiHXoMDf61fGV37P5m3izI5V/e7XOBH5UUR2ish9fuUWd58Ges/iPu/5uEFExgHXAL/zru9/vXObi8i/RSRNRDaLyF1+5VTz7sFeEVkN9CnmnquI3CEi64H13r6zRORL73r/ICJXevsLk0dFpL1fmXnPgO/+e9duFzDFb99vRWS3d63G+n3/ZyKy2rtXO/yvY0hR1ah9ARuA24HeQBbQxO/YVCAD6AvEAm8D7/odV+BjoC7QGkgDRnrHJgBv+Z0b750f621fCJwBCDAEOAz08o4NBbb7fTcVGFaA7H8D5gKVgZ7AbqAfEINTZqlAFSAO2ALc4517ufdbHy3kmtwAZAO/9n53NWCUd606efv+CCz0+861QAPv2G+BXUDV/Nci/3Xw+35lYA7wmLf9G5xibun9hpeBd7xjnYFMYLB37O+evKdcI7/7uB84F9fhqQo8DcwA6gO1gP/61X3S9fcr41G/7YLu0XKgFVDNb9/XQHOvnjXArd6xx4CXvN9dGTcKlQJkHwxs8x0D6gFHvDI7esea+13bMwq5BkX93kq452gC0AHYC/TMd7/eAWoAZ+Oe82EluE9tgIPA1d5vbAD0KOR6VgKWAQ/hntd2wCZghHf8cWCeJ38rYFX+e5Tv9yrwpXd+NU/2bcBY3DPaE0gHOhckj18Z7Qt6Brz7nw084f3uan77HvF+789w/+t63nd2AoP87mOvULd/qhq9CgAYiGsIG3rba4F78t3wV/22fwaszfeADPTb/hfwoPd5AkUogAJk+RD4jd/DVaQCAK7y9jfytl8E/pLvnB9wymUw8CN+DQywMP8D73fsBmBrvn2fAb/y267kPdxtCiljL9A9/7Uo7Dp48n8MVPK21wBJfsebefcqFtdI+CviGsDx/Nco3318w29bgEP4NZbAAGBzQdffr4ziFMCN+b6TClzrt/0k8JL3+RHgI/wamEJkF2ArMNjbvhlI8T63xyn9YUDlYsoo9Pf63Zc93nUfX8Bze1a+3/FaCe7TeOCDIu6J//XsV8AzNx6Y4n3ehNe58rbH5b9H+b6rQGK+/8u8fOe8DPy5IHn8yihKARzH6+T47TuC37Pt3Z/+3uetwC1A7aLueXm/otkENAaYqarp3vY08pmBcD1ZH4eBmqU8XiAicoGILPaGo/twyqVhCb/bE3gBuFRV07zdbYDfekPtfV6ZrXA9xebADvWeQo8txVSzLd92G+BZv7L34BqWFp5M94kzD+33jtcpxe+5Bffn+aWq5vrV94FffWuAHKCJ93vy5FPVQ7iRWkl/TyOgOrDMr/zPvf2BkP+aQeHPx0TciGqmOBPggwUV6N2zd3G9aIBf4kaiqOoG4G6cgt0tIu+KSPMCiin296pqKjAL1+BPKua3bcHdAyj6PrUCNhb0uwqgDc7s5v/8/t4rB/Ldc4p/fvPL3Abol6/8a4CmJZSvINJU9Wi+fRmqmu237X/Pf4H7n28RkTkiMiCAuoNGVCoAz/55JTBERHZ5drx7gO4i0j0IVRzC/el85D1o4mYb/Rt4Cmdyqgt8imtQi5O7MW60cIeqfut3aBvwV1Wt6/eqrqrv4IaeLUTEv/zWxVSl+ba3AbfkK7+aqi4UZ+//He561vN+z/4S/p5BwF+AUap6IF99F+Srr6qq7vB+Tyu/MqrjzAsl/T3puJ5aF7+y66hqzQLO9VHo/SykjqKFUT2oqr9V1Xa4yQf3Fma/x5lfLhfnc+mHe3Z85UxT1YG4Bk5xJon8FPd7EZELcaOCZJxyyk8rv8+tcSNKKPo+bcOZOQu8BPm2t+FGJP7l1FLVn3nHT7rnFP/85q9jGzAnX/k1VfW2QuQB13gXdc9LfL8BVHWJqo4CfP/hf5Xm+2VFVCoA4BJcT6Uz0MN7dcLZGa8PQvnLgcHi5r3XwQ1nfcTh7IZpQLaIXACcX1yBnpPufZw5Jf/D8wpwq4j0E0cNEblQRGoBi3C2ybtEpLKIXIbza5SGl4DxItLFk6WOiFzhHavllZ8GxIrIQ0DtEvyeVrg/wfWquq6A+v7qNXqISCMRGeUdex+4yHMwxuHMKSV+jr1RxivA055CRURaiMgI75SfgAbeffOxHPiZiNQXkaa4nvdpI85h395Tyvtxz2JuQed6ij4deBX4QlX3eWV0FJFEr0NxFNfIn1JGcb9XRBp6Zd+EGwH/XER+lq+YP4lIde/+jwXe8/YXdZ/eBoaJyJXinOINRKSHd+wnnJ3fx9fAQc+pWk1EYkSkq4j4nL3/wj1/9USkJc4/VRo+Bs4UN3mgsvfqIyKdCpEH3D3/pSfLSJw59bQQkTgRuUZE6qhqFnCAQu53eROtCmAMzr64VVV3+V4408o1EuC0LlX9EvcnWYlzbn3sd+wgcBfuod6LG9bPKEGxLXHOwrvl5NkzrVV1Kc4+/IJX5gacLR9VPQ5c5m3vwdlD/1PK3/MBrnf5rogcwDnhLvAOf4EzKazDDc2PUrA5JD9JuCH++36/5Xvv2LO4azJTRA7iHI39PFm+B+7Amex2er+3tPP2H8Bdo8Xe7/kfzqmKqq7F9bo3eeaC5sCbwAqcXX8mJxrA06WDV2cmTkH/Q1VnFXH+NJytf5rfvio452g6ztTUmJM7Gv4U+nuBycBHqvqpqmYAvwJeFRH/UdUc7/vJwFOqOtPbX9R92oozefwW99wtB3yj69eAzt71/VDdupCLcB2xzZxQeD4l/DDu2dqMu/5vFnGtTsH7z50PjMaNXnZxwoF7ijzevt8APwd85qIPCYzrgFTv+t/qlRlyfLMLDMMwTkLcFOPNOCdzdtFnG5FItI4ADMMwoh5TAIZhGFGKmYAMwzCiFBsBGIZhRClhG8SoYcOGGh8fH2oxDMMwIoply5alq2qJFjaGrQKIj49n6dKloRbDMAwjohCRkqyUBswEZBiGEbWYAjAMw4hSTAEYhmFEKaYADMMwohRTAIZhGFGKKQDDMIwoJSgKQERGisuzuaGg5Bbicud+Jy5n7XwR6RyMeg3DMIzTJ2AFICIxuCxCF+Di619dQAM/TVXPVtUeuJRyfw+0XsMwjArJO+/AtGlQDmF6gjEC6AtsUNVNXuz5d3FJxPPIl+2pBqXMpmMYhhEV7NoFt98OL79cLgogGCuBW3ByApDteEkh/BGRO4B7cRmxEgsqSETG4RI+07p1SbK+GYZhVCDuvhuOHIHJk6FS2btoy80JrKqTVPUMXHaiPxZyzmRVTVDVhEaNAs3RbRiGEUF88gm89x788Y/QsWPx5weBYCiAHZycsLmlt68w3sXl5DUMwzAAMjPhttugSxf43e/KrdpgmICWAB1EpC2u4R+Ny3Obh4h0UNX13uaFwHoMwzAMxx//CNu3w4IFEBdXbtUGrABUNVtE7sQlB48BXlfV70XkEWCpqs4A7hSRYUAWLon3mEDrNQzDqBB8/TU895wbAQwYUK5Vh21GsISEBLVw0IZhVGiysiAhATIyYPVqqF074CJFZJmqJpTk3LDNB2AYhlHh+fvfYeVK+OCDoDT+pcVCQRiGYYSCDRtgwgS47DK4JDTzYkwBGIZhlDeqcOutzuH7/PMhE8NMQIZhGOXNG29AcjK8+CI0bx4yMWwEYBiGUZ6kpcG998K558K4cSEVxRSAYRhGeXLPPXDwYLmFeygKUwCGYRjlxRdfwNtvw/jx0Dn0UfFNARiGYZQHhw45x2/HjvD734daGsCcwIZhGOXDhAmQmgpz50KVKqGWBrARgGEYRtnzzTdu0de4cTBoUKilycMUgGEYRlmSnQ033wyNG8MTT4RampMwE5BhGEZZ8uyzbgQwfTrUrRtqaU7CRgCGYRhlxebN8NBD8POfwy9+EWppTsEUgGEYRlmg6kI8V6oEkyaBSKglOgUzARmGYZQF77zj5v0/9xy0alX8+SHARgCGYRjBJiPDJXjv1w9uvz3U0hSKKQDDMIxgc999sHcvvPIKxMSEWppCMQVgGIYRTJKTYepUl9z97LNDLU2RmAIwDMMIFkeOwC23QPv2LtF7mGNOYMMwjGDxyCOwcSOkpEC1aqGWplhsBGAYhhEMVq6EiRNh7Fg477xQS1MiTAEYhmEESk4O3HQT1K8PTz0VamlKjCkAo+R88YWb1rZkSaglqZikpYVaAuN0mTTJ/S+efdYpgQghKApAREaKyA8iskFEHizg+L0islpEVopIsoi0CUa9Rjlx9Cj85jcwciR8/TW8+WaoJap4rFsHTZvCo4+GWhKjtGzd6uL7X3ABjB4damlKRcAKQERigEnABUBn4GoRyZ/q5lsgQVW7Ae8DTwZar1FOfPcd9OnjVjPedRcMHeocXEZw+fxzyM11cWM++STU0hglRdUt9FKFf/wjLMM9FEUwRgB9gQ2quklVjwPvAqP8T1DVWap62NtcDLQMQr1GWZKbC08/DQkJzjTx2WdueHvBBfD99/DTT6GWsGKRkgJt2kCPHnDNNbB+faglMkrC9OlOYT/6KMTHh1qaUhMMBdAC2Oa3vd3bVxi/Aj4r6ICIjBORpSKyNM3soaHjxx+duefee937d9+5d4DERPduo4DgkZ0Ns2fD8OHwn/9AbCxccolLHG6EL3v3ulFx797w61+HWprTolydwCJyLZAATCzouKpOVtUEVU1o1KhReYpm+PjgA+jWDebPh5degg8/BP970bMn1KljCiCYfPst7N8PSUmuF/nuu7B2Ldx4ozMtGOHJ734H6eku3ENsZC6pCoYC2AH4h7pr6e07CREZBvwBuFhVjwWhXiOYZGa6rEWXXeYaoW+/dSsa89s0Y2LMDxBskpPdu2/u+LBhLnPU++/Dk+YuC0vmzIFXX3Wj5J49Qy3NaRMMBbAE6CAibUUkDhgNzPA/QUR6Ai/jGv/dQajTCCZLlriH+LXXYPx4WLgQOnYs/PykJNi0ySW4NgInJQW6doUmTU7s++1v4aqr3P344ovQyWacytGjLrdv27Yu0XsEE7ACUNVs4E7gC2AN8C9V/V5EHhGRi73TJgI1gekislxEZhRSnFGe5OTAX/8K55wDx47BrFnwt79BXFzR3zM/QPA4dsyZ25KSTt4v4hRy165w9dVO4Rrhwd/+5qbtvvwyVK8eamkCQ1XD8tW7d281ypDNm1UHDlQF1auuUt2zp+Tfzc1VbdxY9Zpryky8qGH2bHcPPvqo4OMbNqjWq6farZtqZmb5ymacyqpVqpUrq153XaglKRRgqZawnbWVwNHI229D9+6wYgW88YbLXFSvXsm/L+JGASkp5qQMlORklzJwyJCCj59xhrs/333nQg3Y9Q4dubnOT1a7Nvzf/4VamqBgCiCa2LfPzTG/9loXp3zFCrjuutNbvJKUBDt3wg8/BF/OaCIlxa21qFOn8HNGjHBmh3ffhb//vfxkM07mpZdg0SK3PqaCzFI0BRAtzJ3rev3vvedC1s6e7ZxYp4v5AQInMxO++upU+39BPPAA/OIXbuqhb9aQUX7s2AEPPujWalx7bailCRqmACo6WVnwhz+4qZuVK8OCBfCnPwU+b7ltW7dy1Rqj02fePLcIzKdMi0IEpkyBs85ys4O2bCl7+YwT3Hmnu1cvvRRx4R6KwhRARWbdOjfD529/c4uKli930TyDgc8PMGuWs40apSc52c24Ovfckp1fq5ZbmJedDZde6rJPGWXPBx+46z5hArRrF2ppgoopgIqIqlud2LOny070/vtu0UrNmsGtJynJLYdfsSK45UYLKSlOQZcmc1SHDs6Jv3y5m4tuTuGyZf9+uOMOF6Pp3ntDLU3QMQVQ0UhPd73DceNgwAA3e+QXvyibunwrV80PUHoyMlwjXhL7f34uvBAefhjeeguefz74shknGD/eBT6M4HAPRWEKoCLxxRduds9nn7lpajNnQoui4vIFSPPmziZtfoDSM3u2672XxP5fEH/4A4wa5Xqlc+YEVTTDY8ECePFFlwsjISHU0pQJpgAqAkePwt13u4id9eu7pC333uvml5c1iYluhlFWVtnXVZFITnYmuT59Tu/7lSq5NRzt28MVV8C2bcV/xyg5x465Of9t2rhZcxUUUwCRji9hy7PPupC0S5e66Z7lRWIiHDpkaSJLS0oKDB7sZmadLrVrO+fk0aMuiN/Ro8GTL9p54glYs8YleQm27yyMMAUQqeTmwjPPuMY/LQ0+/dRl7SqNQzEYDB3qZgSZH6Dk7NjhFtCdjv0/P2ed5UYCS5eeyExlBMaaNS5G1ujR8LOfhVqaMsUUQCTiS9hyzz1w/vmwcqXL1BUKGjRwMyTMD1ByfMrydO3/+bnkEre2Y8oUN0/dOH1yc10Y9Bo1XAergmMKINL48MMTCVtefBE++ggaNw6tTImJLoS0zUsvGcnJTnF26xa8MidMcL3Vu+5yz4Zxerz6qlug99RTJ4fnrqCYAogUDh1yUzsvvdQ5pr75Bm69NTxWJSYmwvHjTgkYRaPqRgDnnRdcJ32lSm59QHw8XH65MzMZpWPnThdqY+hQGDs21NKUC6YAIgFfwpZXX3UxYRYtcrbfcGHQIDdH2vwAxbNhg5uxEwz7f37q1nUjxMxMpwSOWeK9UnHXXc6RPnlyeHSsygFTAOFMTo4L43DOOc68kpICjz9efMKW8qZWLejb1xRASQi2/T8/XbrAP/8Jixe7Bs0oGTNmuBXzDz3kVltHCaYAwpUtW5yZ4A9/cCt5V650Q9NwJTHRjVQOHAi1JOFNcjK0bFm2jcwvfuEiV06e7FawGkVz4IAL99C1K9x3X6ilKVdMAYQj06Y5B+Hy5aeXsCUUJCa6EcvcuaGWJHzJzXUjgMTEsjcxPPqomyF2551uNGAUzh//6Hwmr7wSfqPrMsYUQDixf79L2HLNNa43EkjClvJmwACoWtXMQEXx3XcuBlBZ2P/zExPjOg4tWrgRwa5dZV9nJLJ4MbzwghsB9O8famnKHVMA4cK8eScStjz8sIvvEkjClvKmalUX1tgUQOH41kqUlf0/P/XrO6fwvn0uXMTx4+VTb6SQleXCPbRo4XxtUYgpgFDjn7AlNtbN4X7oociMPJiY6EYtaWmhliQ8SUmBM890PoDyols3eO0191xVwHDGATFxIqxaBZMmuYkMUYgpgFBy9ChcdJHrfYwZA99+G9nDUF/PdvbskIoRlmRluVFdefX+/Rk92jk3J01yq4UNWL/eBXm7/HK4+OJQSxMyTAGEimPH3KKumTOd8+n11yO/F5KQ4H6DmYFOZelSNz+/POz/BfHYY67u226zwH2qLtxD1aouflYUExQFICIjReQHEdkgIg8WcHywiHwjItkicnkw6oxojh93jrnPP3dT9W66KdQSBYfYWBgyxBRAQfjs/6GayhsbC+++C02busihu3eHRo5wYOpUl8r0ySehWbNQSxNSAlYAIhIDTAIuADoDV4tI53ynbQVuAKYFWl/Ek5UFV14Jn3ziYvncfHOoJQouiYkuF/H27aGWJLxISXFB8xo2DJ0MDRvCf/7jssZdeWV05nD46Sf47W/d6vWK0vEKgGCMAPoCG1R1k6oeB94FRvmfoKqpqroSiO7s4VlZcPXVLoDb88+7WD4VDZ+N20YBJzhyxMVJCoX9Pz+9erlR55w5Lu5NtHHPPS6u1ssvl0/CpDAnGFegBeCfjmi7t6/UiMg4EVkqIkvTKtpMkuxsuPZa+Pe/4emn3QKdisjZZ7uepimAEyxc6Hw+obL/5+e661yaw2eecXmFo4XPPnNrI37/e+jUKdTShAVhpQJVdbKqJqhqQqNGjUItTvDIyXGzfP71Lzf17O67Qy1R2VGpkgthkZJiyUl8JCc7G/ygQaGW5AQTJzp/zc03u9lnFZ3MTOcA79TJhckwgOAogB1AK7/tlt4+A1zjP3asC+/w2GPREWskMdFFvNy4MdSShAcpKS5YXjjN8qpc2XVIGjZ0s9HS00MtUdny0EMuvtbkyVClSqilCRuCoQCWAB1EpK2IxAGjgRlBKDfyyc11Paw334S//CV6eh4+W7dlCXPhPZYsCQ/7f34aN3ZO4V273FqB7OxQSxRcsrNdqtQrrnA5s2+9FQYODLVUYUXACkBVs4E7gS+ANcC/VPV7EXlERC4GEJE+IrIduAJ4WUS+D7TesMeXWm7KFPjzn13AqWihQwe3vN78AC44Xm5u+Nj/89Onj5uNlpwM48eHWprgsHat62y1bg0XXuimfN51lzN7GScRlHgDqvop8Gm+fQ/5fV6CMw1FB6rOyfvqq87h9Oc/h1qi8kXE9Xg//9w1ftE82yI52S04GjAg1JIUztixbqHaU0+5xXxXXRVqiUrP/v0ujtaUKS7AW0yMy5M9dqxbbR9lUT5LShT/M8sIVTfD4sUX3TS7Rx+NjGiewSYpycUE+r7iD/aKJCXFmR3C3e789NMumN+NN7rcE5FAbi78738uem7Tpm7EfeCA6+lv3w7//a9b9GaNf6GYAggmqi7g1vPPu/fHH69Qjf/RrBy+2bqXvYdKEFXyvPPcezSbgXbvdiGgw9X8409cnMuIVbeucwrv2RNqiQpn0ybn1G3bFoYPd3b+sWPhq69ccLf77nMKwSiWCAw5Gaaouh7/M884e+NTT0V845+bq6zeeYD5G9KZvz6dJal7OJadiwh0bV6HgR0aMqh9Q3rH16NKbMzJX27dGtq3dyaQ3/wmND8g1Mya5d7D0QFcEE2bunUqgwfDL3/pVqvHxBT/vfIgM9MpqClTnF9FxDX+TzwBl1zizGxGqTEFEAxUXUjnp56C2293SiBCG/8f9x1h/vp05m1IZ+GGdDK83v6ZTWpyTb82JMTXY8PuTOavT+eVuZt4cfZGqlauRN+2DRjUviEDOzTkrKa1EJ8f4N133WyMSAxvHSjJyVCnjlt9Gyn07++iho4bB3/6U2jj5Ku6MNZTprgpq4cOuU7FX//qFrO1alV8GUaRROG/sgyYMMHN8R83zpl/IqjxP3g0i8Wb9jB/fRrzNqSzKe0QAI1qVWHwmY0Y6DXqTWqf3MO6K6kDmcey+WpTBvPWpzN/Qzp//XQNAA1rVmFg+waMbtuD/gcmwzffuHnw0UZKiltsFWnK7+abnVP4scec8rq8nOM3btvmEttPnerWktSs6RzTY8c6P0UE/b/CnQh7MsOQRx5xrxtvdI7fMJ/xkp2Ty4rt+1yjvT6db7ftIydXqVY5hn7t6vPLvq0Z1KERZzap6XrxRVCzSixJnZqQ1KkJADv3H8krd976dObtrs0y4LVHXmXHLTUZ1KEh/drVp3pcFDx2W7a4xuuuu0Ityenx3HPOGXzDDW71bJcuZVvfkSMue9mUKc6xq+oipz70kIucW6NG2dYfpYiG6XL9hIQEXbp0aajFKJq//c2ZfsaMcfH8w7DxV1U2px9i/gbXKC/emMHBY9mIQLcWzo4/sH0jerWpe6odPwByc5U1uw7QdFA/dlapzS8ue5hj2blUjhF6ta7HoA4NGdihEWe3qENMpQrYo5syxXUKvvvO5XeORHbsgN69oXZt+Ppr5yAOJqqu3ClTnKlw/35o08b9n8aMgXbtgltflCAiy1Q1oUTnmgI4TSZOdE7fa65xw9VwcZYBew4dZ4HnuJ2/IZ0d+44A0Kp+NQa2b8SgDg0554wG1K1eDtPj7r4bXn6Zo2kZLN15mHkb0pi/Pp3vfzwAQJ1qlTnnjAaeQ7kRrRtUL3uZyoNrr4Uvv3SrbCPZZDF/vpvRNWIEzJgRnE7Ozp1udfzUqbBmDVSr5nr5Y8e6Xn8YdqQiCVMAZc3TT7tpnqNHuwc5xDbeo1k5LNuy17PFp/H9jwdQhdpVYznnDGfDH9ShIW0ahGAYPWMGjBrl0kQOGZK3OyPzGAs2ZjB/vVMIP+4/CkDr+tXzZhedc0ZD6lSvXP4yB4qqWwk9ZIiLPhnp/OMfcMcdzhzz8MOnV8axY/Dxx663//nnLkbWOee4Rv+KK5yz3AgKpVEAUWCMDTK+Of6XXx6yxt9nXlngmXW+3rwnz7zSs3U97h12JgM7NKRby7qhN68MGeJ6dD6HqEeDmlW4uHtzLu7eHFVlU/qhPN/BjOU/Mu2rrVQSOLtl3bzZRb1a1yMuNgJ6h2vXul5uJMz/Lwm33eacwo884pzCo0YV/x0f337rGv1p0yAjA5o3h/vvd76Fjh3LTGSjZNgIoDT4ekKXXuqWnVcuv1MpQ3AAACAASURBVN6pv4N14cZ00jPd9MwOjWvm9fD7tW1AjSphqNP79XPXav78Ep2elZPL8m0+R3UaK7bvJydXqR4XQ7+29RnYwZmxOjQu3lEdEl54AX79a+cErih27KNHXTjrH35wdvuzzir83LQ01+BPmQIrVrhFZpdc4hr9888PK3NpRcRMQGXB5MluqfnPf+4WpJTx8vLMY9ks3pjhOW/T2OhNz/RNsRzYwU3RbFonAhbAjB/v1kjs3eum9JWSA0ezWLQxI8+nsTndXYsmtavk+TTObd+QRrXCJNzCZZe5nu/mzaGWJLhs2+acwvXrOyVQu/aJY9nZLuHKlCnO1JOV5c4dO9ZlwatfP3RyRxmmAILN66/Dr34FP/uZC59bBnFd3PTM/V4jl8a3W/eRnauFL7KKJL780vX8PvsMRo4MuLjtew+ftFht72GX2/asprXyZhf1ja9PtbgQ9DRzclyM/csug9deK//6y5o5c5xp66KL3H9h7VrX6L/5psu327ixc4DfcIPLDmeUO6YAgskbb5wYun74YVCXnB/LzuHzVbv4ZOVOFm3K4OBRNz3z7BZ18hZg9W5TQJiFSOPwYahXz4WEePLJoBadm6t8/+OBvNlFS1P3cjwnl7iYSiTE16Nzs9pUKkc/SNP133Pj3Vfw4f1PsnroRaX6bkwlYWSXpnRvFeTplsHm2Wfd7K527VxcnthYpxBuuMF1ksrRNGqciimAYPH2227JeVKSm81SrVpQit2+9zDTvtrKe0u2kXHoOC3qVmPwmW4+/jlnNKBejQoYvXDoUBfPpYzv6ZHjOXyd6q1sXp/OlozDZVpffn61cDr3pbzO4N+8TVqt0pk9snJyyc5V+rerzy2Dz2Box0bhOdpTdb6wr75yvf1rrnE9fyMsMAUQDN57zwXEGjzYBcWqHtj89NxcZd6GdN5ctIWUtT8BMKxTE64b0IZzz2hYrr3UkPDIIy5kRnp6xbYHjxzpbOWnEQb74NEs3v16G68v2MzO/Uc5s0lNbh7UjlE9WkTG7CcjLDAFECj//reLPXLOOc5uHcAy9H2Hj/P+su28tXgLqRmHaVgzjtF9WnN1v9a0qBucEUVEMH++m0Xyn/+4WVQVkePHnanrxhvddOHTLSY7l49X/sjkuZtYu+sgTWtXZey58VzdrzW1q5p5xSgaWwcQCB9+6BZ49e/vev6n2fh/t30/by5O5aPlP3IsO5c+8fW4Z/iZjOzaNPJt+qdD377uWqakVFwF8NVXzt8R4Pz/uNhKXNarJZf2bMGcdWlMnruJxz5by/MpG/hlv9aMPTeeZnWiqPNglBmmAPz573/hyitdWrxPP4VatUr19aNZOXyycidvLN7Cim37qB4Xwy96t+Tafm3o3Lx28QVUZOLi3AigIieISU52i978FrwFgogwtGNjhnZszHfb9zN53iZenbeJKQs2c3H3Fowb3I6OTUv3jBqGP2YC8vHZZ26xSvfubtpiKZamb9tzmLe+2sK/lmxj7+EszmhUg+v6t+Gy3i1tyO6PL37Sjz9Cs2ahlib4DB7solouWVJmVWzbc5jX5m/mvSXbOJKVw9COjRg3uB0D2jUIT4exUe6YCai0zJzpzBJdu8IXX5So8c/JVeauS+ONRanMXpdGJRHO79yE6/q3YcAZ9mcsEF9mrFmznIO9InHokEtGfs89ZVpNq/rVmXBxF36T1IG3Fm9h6sJUfvnKV3RrWYdxg9sxsktTYmPMYWyUDFMAyckutkmnTq7nX69ekafvOXSc6Uu38dZXW9i25wiNalXh14kduLpvK7PLFkePHi6kcEpKxVMA8+e71a/lFP+nXo04fp3UgZsHt+Pf32zn1XmbuXPat7SqX42bBrbjioSW0ZF3wQiI6DYBzZ7tFq60b+8apYYNCzxNVVmxfT9vLErl45U7OZ6dS7+29bl+QDznd2lCZetxlZzLLoPly90CooqELx/03r0hSV6Sk6t8ufonJs/dyDdb91GvemWuGxDPmAFtaFAzTEJkGOWCTQMtCfPmuTnb8fHOJFHAQpYjx3P474ofeXPxFr7bsZ8aPqdu/zac2cScb6eFL1Dapk3Qtm2opQkeCQmu4Z8zJ9SSsDR1Dy/N2cT/1vxEldhKXN67JTcPakd8Q8uqFQ2Uuw9AREYCzwIxwKuq+ni+41WAN4DeQAZwlaqmBqPu02LhQtfzb93a9fzzNf6p6Yd4a/EWpi/bzv4jWZzZpCZ/uaQrl/ZsQc1wjLYZSfj8ACkpLr5SRWDPHpf3+M9/DrUkACTE1+fV+Pps2J3Jq/M2MX3pdqZ9vZWRXZoybnA7erYu2sxpRA8Bt2YiEgNMAoYD24ElIjJDVVf7nfYrYK+qtheR0cATwFWB1n1afPWV6/k3b+4aoSYun21OrpKydjdvLt7C3HVpxFYSRnZtynX929C3bX1z6gaLTp2gadOKpQDmzHHhEcIs/n/7xjV5/BfduHf4mUxdmMpbi7fw2apd9I2vz7jB7Ug8q3HFX4FuFEkwurN9gQ2quglARN4FRgH+CmAUMMH7/D7wgoiIlrf9ackSF9StcWPXADVrRnrmMd5bso1pX21lx74jNK1dlXuHn8noPq1oXDsCQi1HGiJuFJCS4hrNiqBYk5NdqJC+fUMtSYE0rl2V3408i9vPa897S7bx+vzN3PTGUto3rsm4Qe0Y1bN5dC5ONIKiAFoA2/y2twP9CjtHVbNFZD/QAEj3P0lExgHjAFq3bh0E0fz45hvX+DdogKak8E12Nd5891s+/W4Xx3NyObd9A/50USeGdWpi0+jKmsRElzBk7Vo3Ioh0UlLcGoAyzhERKDWrxPKrgW25fkAbPlm5k5fnbuJ3/17JUzN/4IZz47mmXxvqVLN1K9FEWBm0VXUyMBmcEzhoBa9YAcOHk1unDv99+i1e/mALq3ceoFaVWH7ZrzXX9m9D+8alT1RinCY+P0BycuQrgB9/dInNx44NtSQlpnJMJS7p2YJRPZozf0M6k+du4snPf2BSygau7tuaGwe2pXk0xamKYoKhAHYArfy2W3r7Cjpnu4jEAnVwzuCy57vvyElMJLNSHKNHTWDNor2c1bQWf7v0bEb1aB6eKRQrOm3butlXKSlw552hliYwZs1y72Fm/y8JIsKgDo0Y1KERq3bs55V5m5iyMJWpC1P5effmjBvcjk7NIieEiapy6HgOaQePkZ55jPSDx0jz3vcdyaJGlVga1IijXvU46tc48apXI44acTFR6ecLRuu3BOggIm1xDf1oIP8qnxnAGGARcDmQUtb2/+ycXBZ9PI9u113KYa3Etdf+ha4DuvOX/m3o3aZeVN7ssCIxET74wGXQiuQcscnJbvFgjx6hliQguraow7Oje3L/iI68Pj+Vd5ds5YNvdzCoQ0NuHXIG54RwdfuhY9l5jXree+bxEw293/6jWbmnfF8EaletzKFj2WTnFtzsxMVWon51pwwaeEqhfvXK+bbjqF/TvdetHlchQnQHZR2AiPwMeAY3DfR1Vf2riDwCLFXVGSJSFXgT6AnsAUb7nMaFcbrrAPYfyeKNhaks+Hg+z79yL1SK4YsX3mHEpYPDJ2es4XwA11wDy5ZBr16hlub0UHUjmYQEF0K8ArH/cBZvfbWFKQtSSc88RpfmtRk3uB0Xnt0sKD6yQ8eyC2/QfT33zGOkHzzOkaycU74vAvWrx9GoVhUa1qxCw5r+n6uc+FzLNdixMZVQVQ4ey2ZP5nH2HD7O3kPH2eN75dveeziLjMxjHDiaXehvqFU11o0g8o8oqvspjRqVqV+jCvWrx1Gramy5zLqK6oVgew4dZ/T9b/DetPFUjxVi584hpnOE25krIjt3uqm4Tz4J998famlOj40b3SrySZPg9ttDLU2ZcDQrhw+/3cHkeZvYlHaIFnWrcdOgtlyZ0OoU8+nh49mkHzxOWuZR0g4eP7mBz+utu4a+qEbd13A3qulrxKu4z7VONPS+Rr2sycrJZd/hLD/F4Kc08m3vPXScjEPHOZZ96igEXMrPetUrF640ap7Y36hWFZqc5izEqFYAbNlCzjnnEpN13IV66Nw56LIZQaJzZ2jTxkVijUReeQXGjXNO4LPOCrU0ZUpurpK8djeT525kSepe6lSrTJ/4+uw9fKKhP3z81EYdoH6NuMJ76N7+RjWrUL9G+TTqZYmqciQr5xQlkZHpUxZZJ0Ya3qhj7+Hj5LdMdWtZhxl3DjwtGaI7GmjjxsQMGQzjx1vjH+4kJsLUqS6TVphPoSyQ5GQ3iunYMdSSlDmVKgnDOzdheOcmLNuyl1fnbWJjWiYNa1ahe8u6BZpiGtVyjXo0xcoSEarHxVI9LpaW9UqWRjYnVzlwJIs9fqOJKuXkX6h4IwAjcvjgAxccbv58OPfcUEtTOlTdKvIRI+DNN0MtjWHkUZoRQPSoZiP8GDLEGX4jMUvYqlWQlhaR0z8Nw4cpACN01K8PPXs6U0qk4ZPZt6jNMCIQUwBGaElMhEWLXDL1SCIlxc0ACnbIEsMoR0wBGKElKck5gRcuDLUkJSc720UAtd6/EeGYAjBCy8CBEBsbWX6AZcvgwAGz/xsRjykAI7TUrAn9+kWWH8An63nnhVYOwwgQUwBG6ElMhKVLYf/+UEtSMlJSoFs3aNQo1JIYRkCYAjBCT2Ii5ObC3LmhlqR4jh6FBQvM/m9UCEwBGKFnwACoWjUy/ACLFjklYPZ/owJgCsAIPVWqOGdwJCiA5GQXvnrw4FBLYhgBYwrACA8SE2HlSti9O9SSFE1KCvTpA7UjJ1GKYRSGKQAjPPDZ1GfPDqkYRXLgAHz9tdn/jQqDKQAjPOjd2/Wqw9kMNG+ey2Bm9n+jgmAKwAgPYmNdcLhwVgDJyc5fMWBAqCUxjKBgCsAIHxITYf162LYt1JIUTEqKC1tdrVqoJTGMoGAKwAgffLb1cBwFpKXBihVm/zcqFKYAjPCha1do2DA8FYDPOW32f6MCYQrACB8qVXI97JQUl3ErnEhOhlq1IKFEiZYMIyIwBWCEF4mJsH278wWEEykpzkkdW/HSaBvRiykAI7wIRz/Atm1OIZn936hgBKQARKS+iHwpIuu993qFnPe5iOwTkY8Dqc+IAtq3h5Ytw0sB+GQx+79RwQh0BPAgkKyqHYBkb7sgJgLXBViXEQ2IuIZ21iwXITQcSE52zumuXUMtiWEElUAVwCjgn97nfwKXFHSSqiYDBwOsy4gWEhMhPR1WrQq1JM4ZnZLiZKpkFlOjYhHoE91EVXd6n3cBTQIpTETGichSEVmalpYWoGhGxOLLtBUOWcLWrYMdO8z+b1RIilUAIvI/EVlVwGuU/3mqqkBAc/dUdbKqJqhqQiPLthS9tGoFHTqEhx/A7P9GBabYOW2qOqywYyLyk4g0U9WdItIMCPNYvkbEkJQEb78N2dmhnXqZnOwU0hlnhE4GwygjAjUBzQDGeJ/HAB8FWJ5hOBIT4eBBWLYsdDLk5jpndFKSc04bRgUjUAXwODBcRNYDw7xtRCRBRF71nSQi84DpQJKIbBeREQHWa1R0hg5176H0A6xYAXv2mPnHqLAENLZW1QzglH+Hqi4FbvLbHhRIPUYU0qgRdOvmbPC//31oZPApH3MAGxUUm9dmhC+JibBggUvCHgpSUuCss6B589DUbxhljCkAI3xJSnKN/+LF5V/38eMwd671/o0KjSkAI3wZPBhiYkIzHXTJEjh0yOz/RoXGFIARvtSu7cIvh8IRnJzsZv74nNGGUQExBWCEN4mJ8PXXbkpoeZKSAj17Qv365VuvYZQjpgCM8CYpyS0Gmz+//Oo8fBgWLTL7v1HhMQVghDfnnANxceXrB1iwwDmBzf5vVHBMARjhTbVqTgmUpx8gOdmFnxg4sPzqNIwQYArACH8SE2H5csjIKJ/6UlKgf3+oWbN86jOMEGEKwAh/EhNdXP45c8q+rn37XPwhs/8bUYApACP86dsXatQoHz/AnDkuCJzZ/40owBSAEf5UruwWhZWHHyA52fkd+vUr+7oMI8SYAjAig8REWLsWfvyxbOtJSYFBg6BKlbKtxzDCAFMARmTgs8nPmlV2dezaBd9/b/Z/I2owBWBEBj16QL16ZesH8CkXs/8bUYIpACMyqFTJJYsvSwWQnAx167oQEIYRBZgCMCKHxERITYVNm8qm/JQUF/wtJqZsyjeMMMMUgBE5+GzzZTEK2LzZvcz+b0QRpgCMyOGss6BZs7JRAL4yzf5vRBGmAIzIQcT10FNS3MrgYJKcDE2bQqdOwS3XMMIYUwBGZJGYCD/9BKtXB69MVadUEhOdkjGMKMEUgBFZlIUfYPVqp1TM/m9EGaYAjMgiPh7atg2uAjD7vxGlBKQARKS+iHwpIuu993oFnNNDRBaJyPcislJErgqkTsMgKQlmz4acnOCUl5zslEp8fHDKM4wIIdARwINAsqp2AJK97fwcBq5X1S7ASOAZEakbYL1GNJOY6MI2L18eeFnZ2U6ZWO/fiEICVQCjgH96n/8JXJL/BFVdp6rrvc8/AruBRgHWa0Qz553n3oMRHfTbb2H/frP/G1FJoAqgiaru9D7vApoUdbKI9AXigI2FHB8nIktFZGlaWlqAohkVlqZNoXPn4PgBfErEFIARhRSrAETkfyKyqoDXKP/zVFWBQidni0gz4E1grKrmFnSOqk5W1QRVTWjUyAYJRhEkJcG8eS55eyCkpECXLtCkyL6LYVRIilUAqjpMVbsW8PoI+Mlr2H0N/O6CyhCR2sAnwB9UdXEwf4ARpSQmwuHD8PXXp1/GsWMwf77Z/42oJVAT0AxgjPd5DPBR/hNEJA74AHhDVd8PsD7DcAwZ4hZtBeIHWLwYjhwx848RtQSqAB4HhovIemCYt42IJIjIq945VwKDgRtEZLn36hFgvUa0U68e9OoVmB8gOdmFmR4yJHhyGUYEERvIl1U1Azhl/KyqS4GbvM9vAW8FUo9hFEhiIjzzjDMFVa9e+u+npEBCgssBYBhRSEAKoLzJyspi+/btHD16NNSiGEGkatWqtGzZksqVK5fui0lJMHEiLFgAw4eX7ruZmfDVV3DffaX7nmFUICJKAWzfvp1atWoRHx+PWNCuCoGqkpGRwfbt22nbtm3pvjxwIMTGup58aRXAvHluEZg5gI0oJqJiAR09epQGDRpY41+BEBEaNGhweqO6GjWgf//TcwQnJ0NcHJxzTum/axgVhIhSAIA1/hWQgO5pYiIsW+ZCQ5SGlBTX+J+O78AwKggRpwAM4ySSkiA3F+bOLfl3MjJcHCGb/mlEOaYAjMimXz+oVq1000Fnz3ZJYMz+b0Q5pgAigNTUVKZNm1bq791www28/37ga+8+/PBDVgczA1cwqVLFOYNL4wdIToaaNaFPn7KTyzAigIiaBeTPw//9ntU/HghqmZ2b1+bPP+8S1DKDgU8B/PKXvyyzOnJycoiJiSnw2IcffshFF11E586dS1xednY2sbHl9HglJsL48S6rV0li+qSkwODBUNppp4ZRwbARwGnw1ltv0bdvX3r06MEtt9zCli1b6NChA+np6eTm5jJo0CBmzpxJamoqZ511Ftdccw2dOnXi8ssv5/DhwwAsW7aMIUOG0Lt3b0aMGMHOnS6o6oYNGxg2bBjdu3enV69ebNy4kQcffJB58+bRo0cPnn76aXJycrj//vvp06cP3bp14+WXXwbclMo777yTjh07MmzYMHbvLjA0Ux7x8fE88MAD9OrVi+nTp7Nx40ZGjhxJ7969GTRoEGvXrmXhwoXMmDGD+++/nx49erBx40aGDh3K0qVLAUhPTyfeS6QydepULr74YhITE0lKSmL27NkMHTqUyy+/PO86aLCTucMJU87s2cWfu2MH/PCD2f8NA1yjEY6v3r17a35Wr159yr7yZvXq1XrRRRfp8ePHVVX1tttu03/+85/6yiuv6OWXX65PPvmkjhs3TlVVN2/erIDOnz9fVVXHjh2rEydO1OPHj+uAAQN09+7dqqr67rvv6tixY1VVtW/fvvqf//xHVVWPHDmihw4d0lmzZumFF16YJ8PLL7+sf/nLX1RV9ejRo9q7d2/dtGmT/vvf/9Zhw4Zpdna27tixQ+vUqaPTp08v9Le0adNGn3jiibztxMREXbdunaqqLl68WM877zxVVR0zZsxJ5QwZMkSXLFmiqqppaWnapk0bVVWdMmWKtmjRQjMyMlRVddasWVq7dm3dtm2b5uTkaP/+/XXevHmFXtfTJitLtU4dVe+6F8kbb6iC6rffnn59hhHGAEu1hO1sxJqAQkVycjLLli2jj2c/PnLkCI0bN2bChAlMnz6dl156ieV+mapatWrFueeeC8C1117Lc889x8iRI1m1ahXDvcVLOTk5NGvWjIMHD7Jjxw4uvfRSwK2QLYiZM2eycuXKPPv+/v37Wb9+PXPnzuXqq68mJiaG5s2bk1iCXu5VV7kMnZmZmSxcuJArrrgi79ixY8dKe3kYPnw49evXz9vu27cvLVu2BKBHjx6kpqYycODAUpdbJLGxLp5PSfwAycnQoAF06xZcGQwjAjEFUEpUlTFjxvDYY4+dtP/w4cNs374dcI1prVq1gFPnuIsIqkqXLl1YtGjRSccOHjxYYhmef/55RowYcdL+Tz/9tFS/BaBGjRoA5ObmUrdu3ZOUV2HExsaSm+tSOuRfwOUrz0eVKlXyPsfExJCdnV1qGUtEYiLMmAFbtkCbNgWfo+rs/+ed54LAGUaUY/+CUpKUlMT777+fZ1/fs2cPW7Zs4YEHHuCaa67hkUce4eabb847f+vWrXkN/bRp0xg4cCAdO3YkLS0tb39WVhbff/89tWrVomXLlnz44YeA64EfPnyYWrVqnaQcRowYwYsvvkhWVhYA69at49ChQwwePJj33nuPnJwcdu7cyaxZs0r8u2rXrk3btm2ZPn064JTMihUrAE6pPz4+nmXLlgEEZZZRUPCNdor6zRs2wLZtZv83DA9TAKWkc+fOPProo5x//vl069aN4cOHk5qaypIlS/KUQFxcHFOmTAGgY8eOTJo0iU6dOrF3715uu+024uLieP/993nggQfo3r07PXr0YOHChQC8+eabPPfcc3Tr1o1zzjmHXbt20a1bN2JiYujevTtPP/00N910E507d6ZXr1507dqVW265hezsbC699FI6dOhA586duf766xkwYECpftvbb7/Na6+9Rvfu3enSpQsffeTSO4wePZqJEyfSs2dPNm7cyH333ceLL75Iz549SU9PD+4FPl26doVGjYpeD+A7ZvP/DQMA0bKYlREEEhIS1DfTxMeaNWvo1KlTiCQqPampqVx00UWsWrUq1KKEPUG5t6NHuwxf27a5ZDH5ufJKWLiw8OOGUQEQkWWqmlCSc20EYFQcEhPdNM916049lpvrzENJSdb4G4aHOYHLkPj4+LDo/V966aVs3rz5pH1PPPHEKU7kiMdn209JgY4dTz723XeQnm72f8PwwxRAFPDBBx+EWoTy4YwzoHVrpwBuu+3kY74poqYADCMPMwEZFQcR18DPmuVMPv6kpECHDtCqVWhkM4wwxBSAUbFITHThnleuPLEvKwvmzLHZP4aRD1MARsXivPPcu/900KVLXQ5gM/8YxkmYAjAqFi1bwplnnqwAfPZ/n3IwDAMwBVDu+Mfov+mmmwKOs5+amkrXrl0Dlmvfvn384x//CLicsCApyZl8vJXSpKRA9+7QsGFo5TKMMCOgWUAiUh94D4gHUoErVXVvvnPaAB/glE1l4HlVfSmQegG4+26X1i+Y9OgBzzxT4tN9EfUqnWZcmVdfffW0vne6FBWj36cAbr/99lKVWVQegZCRmAgvvuhyBXfv7hZ/3XFHqKUyjLAj0BHAg0CyqnYAkr3t/OwEBqhqD6Af8KCINA+w3pCRmppKx44duf766+natStvvvkmAwYMoFevXlxxxRVkZmYC8Mgjj9CnTx+6du3KuHHjCoyD74urP2PGDHr06EGPHj3o2LEjbdu2BQrPGbBs2TK6d+9O9+7dmTRpUpHy5o/RDzBx4sS8XAJ//vOfAXjwwQfZuHEjPXr04P7772f27NlcdNFFeeXceeedTJ06FTg1j8DQoUN54IEH6Nu3L2eeeSbz5s0L7CIHytCh7j052TX+x46Z/d8wCqKkcaMLegE/AM28z82AH4o5vwGwFWheXNnhmg9g8+bNKiK6aNEiTUtL00GDBmlmZqaqqj7++OP68MMPq6rmxcRXVb322mt1xowZqnpybH3/uPo+rrjiCn3hhReKzBlw9tln65w5c1RV9b777tMuXboUKm/+GP1ffPGF3nzzzZqbm6s5OTl64YUX6pw5c3Tz5s0nlZM/B8Edd9yhU6ZMUdVT8wgMGTJE7733XlVV/eSTTzQpKalE19KfoN/b7t1VExNVx49XjYlRPXAguOUbRphCOeYDaKKqO73Pu4AC8/GJSCvgE6A9cL+q/hhgvSGlTZs29O/fn48//pjVq1fnxfs/fvx4XgC2WbNm8eSTT3L48GH27NlDly5d+PnPf15kuU8++STVqlXjjjvuYNWqVQXmDNi3bx/79u1j8ODBAFx33XV89tlnRZbrH6N/5syZzJw5k549ewIudPX69etp3bp1qa6BL4+Aj8suuwyA3r17k5qaWqqyyoSkJJg0yU0J7dsXvPDchmGcoFgFICL/A5oWcOgP/huqqiJSYGQ5Vd0GdPNMPx+KyPuq+lMBdY0DxgGlbpDKE1/Me1Vl+PDhvPPOOycdP3r0KLfffjtLly6lVatWTJgw4ZS4+fn53//+x/Tp05k7d25e2QXlDNi3b99py+srd/z48dxyyy0nnZO/0faP+e/7TYWVCSfi/pdpzP/SkJgIf/87rFgBf/xjqKUxjLCkWB+Aqg5T1a4FvD4CfhKRZgDee5FJaL2e/ypgUCHHJ6tqgqomNGrUqPS/ppzp378/CxYsYMOGLxABeQAACV5JREFUDQAcOnSIdevW5TWWDRs2JDMzs9iY+Vu2bOGOO+5g+vTpVKtWDaDQnAF169albt26zJ8/H3AhnEvDiBEjeP311/N8FTt27GD37t2nxPxv06YNq1ev5tixY+zbt4/kkmTbCicGDQKfc9rs/4ZRIIGagGYAY4DHvfeP8p8gIi2BDFU9IiL1gIHA0wHWGxY0atSIqVOncvXVV+elT3z00Uc588wzufnmm+natStNmzbNSx9ZGFOnTiUjI4NLLrkEgObNm/Ppp5/y/vvvc9ddd7F//36ys7O5++676dKlC1OmTOHGG29ERDj//PNLJfP555/PmjVr8kxVNWvW5K233uKMM87g3HPPpWvXrlxwwQVMnDiRK6+8kq5du9K2bds8k1HEULs29OnjZoqVMi+CYUQLAeUDEJEGwL+A1sAW3DTQPSKSANyqqjeJyHDg/wAFBHhBVScXV3ZFyAdglJwyubdffgmbNkE+c5dhVGRKkw8goBGAqmYApwRYUdWlwE3e5y8By8BtlD+eA90wjIKxcNAVhC+++IIHHnjgpH1t27aNnlDQhmGUmohTAKqKWEanUxgxYkTEJngJxAxpGMbpE1GxgKpWrUpGRoY1GBUIVSUjI4OqVauGWhTDiDoiagTQsmVLtm/fTlpaWqhFMYJI1apVadmyZajFMIyoI6IUQOXKlfPi5BiGYRiBEVEmIMMwDCN4mAIwDMOIUkwBGIZhRCkBrQQuS0QkDbe6+HRpCKQHSZyyJpJkhciSN5JkhciSN5JkhciSNxBZ26hqiYKpha0CCBQRWVrS5dChJpJkhciSN5JkhciSN5JkhciSt7xkNROQYRhGlGIKwDAMI0qpyAqg2IijYUQkyQqRJW8kyQqRJW8kyQqRJW+5yFphfQCGYRhG0VTkEYBhGIZRBKYADMMwohVVDZsX0AqYBawGvgd+4+2vD3wJrPfe63n7zwIWAceA+/KVdY9XxirgHaCqtz8OeAbY4L0+Blr7fe91XG7jVeEsa2H1h7G8VYGvgRXedx8OV1n9vhsDfAt8XI7X9jeerN8Dd/vtF+CPXlnrgDlAN7/jfwW2AZnhLCtQHfgEWOt97/Fwltc7/jknntuXgJhwldXvvBkU04apatgpgGZAL+9zLe8HdgaeBB709j8IPOF9bgz08R7++/zKaQFsBqp52/8CbvA+PwW85ruJwFjcn7yStz0Y6FXcxQu1rIXVH8byClDT218Z+AroH46y+n3/XmAaxSuAYMnbFfenr44L1Pg/oL137E7gU6C6t30+kArU8Lb7e3IUpwBCKqt3/nne/jhgHnBBuMrrbdf23gX4NzA6XGX19l2Ge24jSwEUcEE/AoYDPwDN/C7yD/nOm8Cpf/xtOM0bi+vdne9d0AzfDfU7fx5wvt92fEkuXjjImr/+SJDXO/cboF+4ygq0BJKBRIpRAEGU9wrgNb/tPwG/8z5vA9rl+/6bwLh8+4pUAOEkq7f/WeDmSJAX13H5L3BVuMoK1ATm4xRPsW1Y2PoARCQe6InrKTZR1Z3eoV1Ak6K+q6o7cD28rcBOYL+qzgTaA1tV9UC+ryzFXbCIlDVf/WErr4jEiMhynIntS1UtVt4QXttngN8BucXJGCx5cb2+QSLSQESqAz8DWolIbVwPb1MR8paaUMsqInWBn+MUbVjLKyJf4J7bg8D7YSzrX4D/Aw4XJyOEqRNYRGrihlp35/+TqlNzWsz36wGjgLZAc6CGiFxbEWUtqv5wk1dVc1S1B6533VdEuoajrCJyEbBbVZcVd24w5VXVNcATwEyc3Xk5kFMaGSJFVhGJxflkniugQQs7eVV1BK73XgU3Kgw7WUWkB3CGqpY4EXjYKQARqYy7eG+r6n+83T+JSDPveDOcJi6KYcBmVU1T1SzgP8A5wEagtYjUynd+b5wWjShZC6k/bOX1oar7cM6ykWEq67nAxSKSCrwLJIrIW0VVFCR5UdXXVLW3qg4G9gLrvEbkkIi0K0TeUhEmsk4G1qvqMxEiL6p6FGfWGRWmsg4AErzndj5wpojMLqqesFIA4rK9vwasUdW/+x2aAYzxPo/B3YSi2Ar0F5HqXplJXpmHgH8CfxeRGK/O64GjwIJIkrWI+sNV3kbekB8RqYazja4NR1lVdbyqtlTVeGA0kKKqhY4cgigvItLYe2/NCWcewETgOe/aISLDgC6UwBwRbrKKyKNAHeDucJdXRGr6Nd6xwIWU/XN7WrKq6ouq2tx7bgfilMbQIisqykFQ3i9PaAVW4oY9y3H2rwY4O+F6nEe8vnd+U2A7cADY5332eewfxt2oVTgnSRVvfxXgOdzUvx1eHdX8ZHgHZy/O8sr7VTjKWlj94XptgW64WTYrve89FK6y5pNlKMXPAgqmvPNw0whXAEl+dQjwkFdWKvCjrzzv+JNeObne+4RwlBVn/lNgjV/9N4XrtcXZ65dw4rl9HogNR1nzyRJPCZzAUR0KQkSaAp8BL6pqWMcJiSRZIbLkjSRZIc/G/AGwRFV/H2p5iiKSZIXIkjcYska1AjAMw4hmwsoHYBiGYZQfpgAMwzCiFFMAhmEYUYopAMMwjCjFFIARtYhIjogsF5FVIjJd3LL70nz/VREpcSgGEblBRF4ovaSGUTaYAjCimSOq2kNVuwLHgVtL+kURiVHVm1R1ddmJZxhliykAw3DMwwWJQ0SuFZGvvdHBy36rhTNF5P9EZAUwQERmi0iCd+xqEfnOG0084StURMaKyDoR+f/27pAlgigKoPC5YllsarLYBJMWk4JgsxkUEbvFP6Bg0B9iMBiMBosgGCy7RsFuMlhsWuQa3qDrIorKssI7XxzmwWzZOzPLntehJCakf8MBoOo1f/FfBm4iYhpYB+azhOtegM3m1BGgnZkzmXnVtX6CEu9aAmaBuYhYaRICB5Qv/gX+UO6U+mF40BcgDVArSp4ayhPAIbBFiWtdl7QLLd7jXS+U0FevOeAyMx8AIuKYsrEQPcdPgKk+fA7pVxwAqtlTc5f/pgl6HWXm7ifnP2dmX/LM0iD4Ckj66AJY7aoxjkbE5DdrOsBiRIw3vxdsUPZqbTfHx5pM8Fo/L1z6KZ8ApC6ZeRsRe8B5RAxRqrDbwN0Xa+4jYoeyx0EAZ5l5ChAR+5SNvx8pdUjp3zAGJ0mV8hWQJFXKASBJlXIASFKlHACSVCkHgCRVygEgSZVyAEhSpV4B0QO1A/lVbUoAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Compare the realized and expected returns\n",
    "# Note that they should appear correlated.\n",
    "\n",
    "# pick a random asset ID to show\n",
    "asset_idx =  tickers[0]\n",
    "\n",
    "plt.plot(investment_periods, expected_risky_returns.loc[asset_idx,:].values,label='expected_return')\n",
    "plt.plot(investment_periods,risky_asset_returns.loc[asset_idx,:].values,label='realized_return',color='r')\n",
    "plt.legend()\n",
    "plt.xlabel('Period')\n",
    "plt.title('Annualized realized returns vs expected returns')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "risky_asset_returns=risky_asset_returns.T\n",
    "expected_risky_returns=expected_risky_returns.T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_steps=np.shape(expected_risky_returns)[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num_steps"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "WqAdjcoFPQPp"
   },
   "source": [
    "### Compute the empirical correlation matrix using realized returns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "sl5JQ3_8PQPs",
    "outputId": "5f93d784-2e83-4a2c-bf2e-23bd42eb5fb8"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(99, 99)\n"
     ]
    }
   ],
   "source": [
    "cov_mat_r = np.cov(risky_asset_returns.T)  # correlation matrix\n",
    "print(cov_mat_r.shape)\n",
    "D,v = np.linalg.eigh(cov_mat_r)\n",
    "eigenvals = D[::-1]  # put them in a descended order"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 69
    },
    "id": "H-HzoeHOPQP0",
    "outputId": "96c11580-037d-430d-fe77-5e54635ea519"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.44142932e+00, 9.32583487e-01, 6.05832266e-01, 4.48157769e-01,\n",
       "       3.15410819e-01, 2.61472712e-01, 2.14440432e-01, 2.56085606e-16,\n",
       "       1.32758295e-16, 1.06307364e-16])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# eigenvalues: the largest eigenvalue is the market factor \n",
    "eigenvals[0:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 156
    },
    "id": "hFC61Ci94nnd",
    "outputId": "fc1d8cde-9ada-4e39-f6e6-3fe3b55559e0"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[ 0.0828,  0.0510,  0.0315,  ...,  0.0124,  0.0335,  0.0513],\n",
       "        [ 0.0510,  0.1789,  0.0310,  ...,  0.0070,  0.0272, -0.0620],\n",
       "        [ 0.0315,  0.0310,  0.1144,  ..., -0.0406,  0.0398, -0.1759],\n",
       "        ...,\n",
       "        [ 0.0124,  0.0070, -0.0406,  ...,  0.0528, -0.0039,  0.1020],\n",
       "        [ 0.0335,  0.0272,  0.0398,  ..., -0.0039,  0.0476, -0.0602],\n",
       "        [ 0.0513, -0.0620, -0.1759,  ...,  0.1020, -0.0602,  0.5031]],\n",
       "       dtype=torch.float64)"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cov_mat_torch = torch.tensor(cov_mat_r)\n",
    "torch.pinverse(cov_mat_torch)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ohSC6oDePQP5"
   },
   "source": [
    "### Add a riskless bond as one more asset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "id": "F7nwaM28PQP9"
   },
   "outputs": [],
   "source": [
    "num_assets = num_risky_assets + 1\n",
    "bond_val = 100.0\n",
    "init_asset_vals = np.hstack((np.array([bond_val]), stock_data.iloc[0,:].values)) # add the bond to initial assets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "hZQgn_CTPQQE"
   },
   "source": [
    "### Make the initial portfolio "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "id": "PyMLBotBPQQH"
   },
   "outputs": [],
   "source": [
    "# consider here two choices: equal or equally-weighted \n",
    "init_port_choice =  'equal' \n",
    "init_cash = 1000.0\n",
    "init_total_asset = np.sum(init_asset_vals)\n",
    "x_vals_init = np.zeros(num_assets)\n",
    "\n",
    "if init_port_choice == 'equal': \n",
    "    # hold equal amounts of cash in each asset\n",
    "    amount_per_asset = init_cash/num_assets\n",
    "    x_vals_init = amount_per_asset * np.ones(num_assets)\n",
    "elif init_port_choice == 'equally_weighted':\n",
    "    amount_per_asset = init_cash/init_total_asset\n",
    "    x_vals_init = amount_per_asset * init_asset_vals "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Zkj8GdPDPQQP"
   },
   "source": [
    "### Make the target portfolio"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "LyyKCaPGPQQS",
    "outputId": "bda0d8d5-b848-4c2b-c36b-3f2ac1a1bf78"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1100.0 3143.416229869479\n"
     ]
    }
   ],
   "source": [
    "# make a target portfolio term structure by defining it as the initial portfolio growing at some fixed and high rate\n",
    "target_portfolio = [init_cash]\n",
    "target_return = 0.15 \n",
    "coeff_target = 1.1 \n",
    "\n",
    "for i in range(1, num_steps):\n",
    "    target_portfolio.append(target_portfolio[i-1]*np.exp(dt * target_return) )\n",
    "    \n",
    "target_portfolio = coeff_target*np.array(target_portfolio)    \n",
    "print(target_portfolio[0], target_portfolio[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "2UMA8UwlPQQc"
   },
   "source": [
    "### Define model parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "5G_Y87m2PQQe",
    "outputId": "0cf27618-1f16-4676-9741-4e2c3ce8d466"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1648.7212707001281 54598.15003314424\n"
     ]
    }
   ],
   "source": [
    "fee_bond = 0.05 \n",
    "fee_stock = 0.015 \n",
    "gamma = 0.95 \n",
    "all_fees = np.zeros(num_risky_assets + 1)\n",
    "all_fees[0] = fee_bond\n",
    "all_fees[1:] = fee_stock\n",
    "Omega_mat = np.diag(all_fees)\n",
    "exp_returns = expected_risky_returns\n",
    "Sigma_r = cov_mat_r\n",
    "\n",
    "# Generate the benchmark target portfolio by growing the initial portfolio value at rate eta\n",
    "target_return =  0.5 \n",
    "benchmark_portf = [init_cash * np.exp(dt * target_return)]\n",
    "\n",
    "for i in range(1,num_steps):\n",
    "    benchmark_portf.append(benchmark_portf[i-1]*np.exp(dt * target_return))   \n",
    "print(benchmark_portf[0], benchmark_portf[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "YT6003xKPQQm"
   },
   "source": [
    "## G-learning\n",
    "\n",
    "Produce a list of trajectories, where each trajectory is a list made of state-action pairs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "lambd = 0.001 # keep fixed\n",
    "#omega = 1.81\n",
    "beta = 1000.0 # fixed fixed\n",
    "#eta = 1.82\n",
    "#rho = 0.9"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Parameter search for highest sharpe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "SR_G_max=-10\n",
    "bTune = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "id": "lCzgn95o8wUD"
   },
   "outputs": [],
   "source": [
    "if bTune:\n",
    " # There is a memory leak in the G_learning_portfolio_opt due to copy() and this may crash\n",
    " for omega in np.arange(1.6,2.5,0.2):\n",
    "  for eta in np.arange(1.6,2.5,0.2):\n",
    "   for rho in np.arange(0.0,1.0,0.2):      \n",
    "\n",
    "    reward_params=[lambd, omega, eta, rho]\n",
    "    print(reward_params)\n",
    "    # Create a G-learner\n",
    "    G_learner = G_learning_portfolio_opt(num_steps,\n",
    "                     reward_params,  \n",
    "                     beta,                \n",
    "                     benchmark_portf,\n",
    "                     gamma, \n",
    "                     num_risky_assets,\n",
    "                     R,\n",
    "                     np.array(expected_risky_returns, dtype='float64'), # array of shape num_steps x num_stocks\n",
    "                     Sigma_r,     # covariance matrix of returns of risky matrix                    \n",
    "                     x_vals_init, # array of initial values of len (num_stocks+1)\n",
    "                     use_for_WM = True) # use for wealth management tasks\n",
    "\n",
    "    G_learner.reset_prior_policy()\n",
    "    error_tol=1.e-8\n",
    "    max_iter_RL = 200\n",
    "    G_learner.G_learning(error_tol, max_iter_RL)\n",
    "\n",
    "    num_sim = 100\n",
    "    #trajs = []\n",
    "    np.random.seed(0)\n",
    "    torch.manual_seed(0)\n",
    "    t_0 = time.time()\n",
    "    x_vals = [x_vals_init]\n",
    "    returns_all = []\n",
    "    consumption=np.array([0]*num_steps, dtype='float64')\n",
    "\n",
    "    for n in range(num_sim):\n",
    "        #this_traj = []\n",
    "        x_t = x_vals_init[:]\n",
    "        returns_array = []\n",
    "        for t in range(0,num_steps):       \n",
    "            mu_t = G_learner.u_bar_prior[t,:] + G_learner.v_bar_prior[t,:].mv(torch.tensor(x_t))\n",
    "            u_t = np.random.multivariate_normal(mu_t.detach().numpy(), G_learner.Sigma_prior[t,:].detach().numpy())\n",
    "            # compute new values of x_t\n",
    "            x_next = x_t + u_t\n",
    "            risky_asset_return = risky_asset_returns.iloc[t,:]\n",
    "            returns = np.hstack((R*dt, risky_asset_return))\n",
    "            x_next = (1+returns)*x_next\n",
    "            port_returns=(x_next.sum() - x_t.sum() - np.sum(u_t) -fee_stock*np.abs(u_t).sum())/x_t.sum()\n",
    "            consumption[t] += np.sum(u_t)\n",
    "            #this_traj.append((x_t, u_t))\n",
    "            x_t = x_next  # rename\n",
    "            returns_array.append(port_returns) \n",
    "        # end the loop over time steps\n",
    "        #trajs.append(this_traj)\n",
    "        returns_all.append(returns_array)\n",
    "\n",
    "    print('Done simulating trajectories in %f sec'% (time.time() - t_0))        \n",
    "   \n",
    "    returns_all_G = returns_all\n",
    "    \n",
    "    SR_G = 0\n",
    "    for i in range(num_sim):\n",
    "      SR_G += (np.mean(returns_all_G[i])-R*dt)/np.std(returns_all_G[i])\n",
    "    \n",
    "    del G_learner, returns_all,port_returns, returns, returns_array\n",
    "    gc.collect()\n",
    "    SR_G/=num_sim\n",
    "    print(SR_G)\n",
    "    if (SR_G> SR_G_max):\n",
    "        SR_G_max=SR_G\n",
    "        best_params=reward_params\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "lambd = 0.001 # keep fixed\n",
    "omega = 1.8\n",
    "beta = 1000.0 # fixed fixed\n",
    "eta = 2.0\n",
    "rho = 0.8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.001, 1.8, 2.0, 0.8]\n",
      "Doing G-learning, it may take a few seconds...\n",
      "Done simulating trajectories in 16.525012 sec\n"
     ]
    }
   ],
   "source": [
    "reward_params=[lambd, omega, eta, rho]\n",
    "print(reward_params)\n",
    "# Create a G-learner\n",
    "G_learner = G_learning_portfolio_opt(num_steps,\n",
    "                 reward_params,  \n",
    "                 beta,                \n",
    "                 benchmark_portf,\n",
    "                 gamma, \n",
    "                 num_risky_assets,\n",
    "                 R,\n",
    "                 np.array(expected_risky_returns, dtype='float64'), # array of shape num_steps x num_stocks\n",
    "                 Sigma_r,     # covariance matrix of returns of risky matrix                    \n",
    "                 x_vals_init, # array of initial values of len (num_stocks+1)\n",
    "                 use_for_WM = True) # use for wealth management tasks\n",
    "\n",
    "G_learner.reset_prior_policy()\n",
    "error_tol=1.e-8\n",
    "max_iter_RL = 200\n",
    "G_learner.G_learning(error_tol, max_iter_RL)\n",
    "\n",
    "num_sim = 500\n",
    "trajs = []\n",
    "np.random.seed(0)\n",
    "torch.manual_seed(0)\n",
    "t_0 = time.time()\n",
    "x_vals = [x_vals_init]\n",
    "returns_all = []\n",
    "consumption=np.array([0]*num_steps, dtype='float64')\n",
    "\n",
    "for n in range(num_sim):\n",
    "    this_traj = []\n",
    "    x_t = x_vals_init[:]\n",
    "    returns_array = []\n",
    "    for t in range(0,num_steps):       \n",
    "        mu_t = G_learner.u_bar_prior[t,:] + G_learner.v_bar_prior[t,:].mv(torch.tensor(x_t))\n",
    "        u_t = np.random.multivariate_normal(mu_t.detach().numpy(), G_learner.Sigma_prior[t,:].detach().numpy())\n",
    "        # compute new values of x_t\n",
    "        x_next = x_t + u_t\n",
    "        risky_asset_return = risky_asset_returns.iloc[t,:]\n",
    "        returns = np.hstack((R*dt, risky_asset_return))\n",
    "        x_next = (1+returns)*x_next\n",
    "        port_returns=(x_next.sum() - x_t.sum() - np.sum(u_t) -fee_stock*np.abs(u_t).sum())/x_t.sum()\n",
    "        consumption[t] += np.sum(u_t)\n",
    "        this_traj.append((x_t, u_t))\n",
    "        x_t = x_next  # rename\n",
    "        returns_array.append(port_returns) \n",
    "    # end the loop over time steps\n",
    "    trajs.append(this_traj)\n",
    "    returns_all.append(returns_array)\n",
    "\n",
    "print('Done simulating trajectories in %f sec'% (time.time() - t_0))        \n",
    "\n",
    "returns_all_G = returns_all"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#from __future__ import print_function  # for Python2\n",
    "#import sys\n",
    "#max_mem=0\n",
    "#local_vars = list(locals().items())\n",
    "#for var, obj in local_vars:\n",
    "#    mem= sys.getsizeof(obj)\n",
    "#    if mem>max_mem:\n",
    "#        max_mem=mem\n",
    "#        max_var=var\n",
    "#    print(var, mem)   \n",
    "#print(\"---------\")    \n",
    "#print (max_var, max_mem)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "aTWkeFsDPQQu"
   },
   "outputs": [],
   "source": [
    "np.save('State_act_trajs.npy', trajs)  # save trajectories "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "SNtCvuFMPQQ0"
   },
   "outputs": [],
   "source": [
    "trajs = np.load('State_act_trajs.npy')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bpnem5H5vZ5H"
   },
   "source": [
    "### Calculate performance of G-learner (Diagnostics only)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "SR_G = 0\n",
    "for i in range(num_sim):\n",
    "  SR_G += (np.mean(returns_all_G[i])-R*dt)/np.std(returns_all_G[i])\n",
    "SR_G/=num_sim    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "id": "TT9dIJP_t0K_"
   },
   "outputs": [],
   "source": [
    "r_G=np.array([0]*num_steps, dtype='float64')\n",
    "for n in range(num_steps):\n",
    "  for i in range(num_sim):\n",
    "    r_G[n]+=returns_all_G[i][n]\n",
    "  r_G[n]/=num_sim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Sample Mean Returns')"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(r_G, label='G-learning (' + str(np.round(SR_G, 3)) + ')', color='red')\n",
    "#plt.plot(r_fixed, label='Equi-weighted (' + str(np.round(SR_fixed,3)) + ')', color='black')\n",
    "#plt.plot(r_GIRL, label='GIRL (' + str(np.round(SR_GIRL,3)) + ')', color='blue')\n",
    "\n",
    "plt.legend()\n",
    "plt.xlabel('time (quarters)')\n",
    "plt.ylabel('Sample Mean Returns')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Benchmark against the equal weighted portfolio"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Done simulating trajectories in 1.044344 sec\n"
     ]
    }
   ],
   "source": [
    "num_sim = 500\n",
    "t_0 = time.time()\n",
    "x_vals = [x_vals_init]\n",
    "returns_all = []\n",
    "\n",
    "for n in range(num_sim):\n",
    "    \n",
    "    x_t = x_vals_init[:]\n",
    "    returns_array = []\n",
    "    for t in range(0,num_steps): \n",
    "        u_t=0  # don't rebalance\n",
    "        # compute new values of x_t\n",
    "        x_next = x_t + u_t\n",
    "        risky_asset_return = risky_asset_returns.iloc[t,:]\n",
    "        returns = np.hstack((R*dt, risky_asset_return))\n",
    "        #print(returns)\n",
    "        x_next = (1+returns)*x_next\n",
    "        port_returns=(x_next.sum() - x_t.sum() - np.sum(u_t) - fee_stock*np.abs(u_t).sum())/x_t.sum()\n",
    "        \n",
    "        x_t = x_next # rename\n",
    "        returns_array.append(port_returns) \n",
    "    # end the loop over time steps\n",
    "   \n",
    "    returns_all.append(returns_array)\n",
    "\n",
    "print('Done simulating trajectories in %f sec'% (time.time() - t_0))   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "returns_all_fixed = returns_all"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.292899296347987\n"
     ]
    }
   ],
   "source": [
    "SR_fixed=0\n",
    "for i in range(num_sim):\n",
    "  SR_fixed+=(np.mean(returns_all_fixed[i])-R*dt)/np.std(returns_all_fixed[i])\n",
    "\n",
    "SR_fixed/=num_sim\n",
    "print(SR_fixed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "r_fixed=np.array([0]*num_steps, dtype='float64')\n",
    "for n in range(num_steps):\n",
    "  for i in range(num_sim):\n",
    "    r_fixed[n]+=returns_all_fixed[i][n]\n",
    "  r_fixed[n]/=num_sim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Sample Mean Returns')"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(r_G, label='G-learning (' + str(np.round(SR_G,3)) + ')', color='red')\n",
    "plt.plot(r_fixed, label='Equi-weighted (' + str(np.round(SR_fixed,3)) + ')', color='black')\n",
    "#plt.plot(r_GIRL, label='GIRL (' + str(np.round(SR_GIRL,3)) + ')', color='blue')\n",
    "\n",
    "plt.legend()\n",
    "plt.xlabel('time (quarters)')\n",
    "plt.ylabel('Sample Mean Returns')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4Wdu1t058d7a"
   },
   "source": [
    "## GIRL\n",
    "Implement the optimizer for finding the optimal G-learning parameters by MLE."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "id": "Z2cYmHjoTZKM"
   },
   "outputs": [],
   "source": [
    "def fun(x, grad_=False, rescale=1.0, constraint=False):\n",
    "    y=np.array([0]*4, dtype='float32')\n",
    "    z=x.copy()\n",
    "    y[0] =lambd\n",
    "    #y[0]/=sc[0]\n",
    "    y[1]=z[0]/sc[0]\n",
    "    y[2]=z[1]/sc[1]\n",
    "    y[3]=z[2]/sc[2]\n",
    "    \n",
    "    with torch.no_grad():\n",
    "       if grad_==False:\n",
    "           if constraint:\n",
    "            #y[0] = y[0]**2\n",
    "            #y[0] = lambd\n",
    "            y[1] = 1+y[1]**2\n",
    "            y[2] = 1+y[2]**2\n",
    "            y[3] = 1.0/(1.0+np.exp(-y[3]))\n",
    "           print(y) \n",
    "           ret = rescale*get_loss(trajs,\n",
    "                                 num_steps, \n",
    "                                 benchmark_portf, \n",
    "                                 gamma, \n",
    "                                 num_risky_assets, \n",
    "                                 R, \n",
    "                                 np.array(expected_risky_returns, dtype='float32'),\n",
    "                                 Sigma_r, \n",
    "                                 x_vals_init, \n",
    "                                 max_iter_RL, \n",
    "                                 y,\n",
    "                                 beta,\n",
    "                                 len(trajs), \n",
    "                                 grad=grad_, \n",
    "                                 eps=1e-7).detach().numpy()\n",
    "\n",
    "           print(ret)\n",
    "           return ret\n",
    "       else:\n",
    "            f, df = get_loss(trajs,\n",
    "                                 num_steps, \n",
    "                                 benchmark_portf, \n",
    "                                 gamma, \n",
    "                                 num_risky_assets,\n",
    "                                 R, \n",
    "                                 np.array(expected_risky_returns, dtype='float32'),\n",
    "                                 Sigma_r, \n",
    "                                 x_vals_init, \n",
    "                                 max_iter_RL, \n",
    "                                 y, \n",
    "                                 beta,\n",
    "                                 len(trajs), \n",
    "                                 grad=grad_, \n",
    "                                 eps=1e-7)\n",
    "            return f.detach().numpy()*rescale, df*rescale/sc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "JQXvu1HqPQRc"
   },
   "source": [
    "### GIRL (G-learning IRL)\n",
    "Two different optimizers are used to demonstrate the implementation of GIRL. The first approach is gradient free and the second approach uses the gradient of the loss function. \n",
    "#### Gradient free (ignore this)\n",
    "Initialize the parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# lambd_0 = 0.002\n",
    "omega_0 = 2.5\n",
    "eta_0 = 1.3 \n",
    "beta_0 = beta \n",
    "rho_0 = 0.8\n",
    "beta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sc=np.array([1,1,1]) # optional re-scaling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x0=np.array([omega_0, eta_0, rho_0])\n",
    "x0=[np.sqrt(x0[0]-1), np.sqrt(x0[1]-1), np.log(x0[2]/(1-x0[2]))]\n",
    "#x0=np.array([lambd_0, omega_0, eta_0, rho_0])\n",
    "#x0=[np.sqrt(x0[0]-0.001), np.sqrt(x0[1]-1), np.sqrt(x0[2]-1), np.log(x0[3]/(1-x0[3]))]\n",
    "x0*=sc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# test evaluate the loss function\n",
    "fun(x0, False, 1e-12, constraint=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_ask=np.array([omega, eta, rho])\n",
    "x_ask=[np.sqrt(x_ask[0]-1), np.sqrt(x_ask[1]-1), np.log(x_ask[2]/(1-x_ask[2]))]\n",
    "fun(x_ask, False, 1e-12, constraint=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Optimize with the Nelder-Mead method\n",
    "res = minimize(fun, x0, method='Nelder-Mead', args=(False, 1e-12, True), \n",
    "               options={'disp': True, 'maxiter':50}, tol=0.01)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#(0.001 +res.x[0]**2)/sc[0], (1+res.x[1]**2)/sc[1], (1+res.x[2]**2)/sc[2], 1.0/(1+np.exp(-res.x[3]))/sc[3]\n",
    "results=lambd, (1+res.x[0]**2)/sc[0], (1+res.x[1]**2)/sc[1], 1.0/(1+np.exp(-res.x[2]))/sc[2]\n",
    "print(results)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1TpYxXmq89QD"
   },
   "source": [
    "#### GIRL (Gradient based) <= use this one\n",
    "Now separately perform GIRL using a gradient based optimizer. This has the advantage of being more accurate but can be less stable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "id": "VPZgTZ789R_H"
   },
   "outputs": [],
   "source": [
    "# initialize the parameters\n",
    "#lambd_0 = 0.001 # lambd is kept fixed\n",
    "omega_0 = 2.3\n",
    "eta_0 = 1.7\n",
    "#beta_0 = beta \n",
    "rho_0 = 0.8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "id": "Z9nO_7hHBGai"
   },
   "outputs": [],
   "source": [
    "#x0=np.array([lambd_0, omega_0, eta_0, rho_0])\n",
    "x0=np.array([omega_0, eta_0, rho_0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "id": "MLHLm-uU9XSu"
   },
   "outputs": [],
   "source": [
    "# rescaling\n",
    "sc=np.array([1,1,1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 69
    },
    "id": "yEO1I-P2DpLp",
    "outputId": "17c8508d-1071-40fe-9735-2a6d37ae705c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.0e-03 1.8e+00 2.0e+00 8.0e-01]\n",
      "Doing G-learning, it may take a few seconds...\n",
      "0.20595579561948776\n"
     ]
    }
   ],
   "source": [
    "# test evaluation of the loss function with the true parameters\n",
    "x_ask=np.array([omega, eta, rho])*sc\n",
    "f_ask=fun(x_ask*sc, False, 1e-9, constraint=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.0e-03 2.3e+00 1.7e+00 8.0e-01]\n",
      "Doing G-learning, it may take a few seconds...\n",
      "-4.232095618311167\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "-4.232095618311167"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# test evaluation of the loss function with the initial parameters\n",
    "fun(x0*sc, False, 1e-9, constraint=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [],
   "source": [
    "# choose bounds for parameters\n",
    "bnds=((1.5*sc[0], 2.5*sc[0]), (1.0*sc[1], 2.5*sc[1]), (0.0*sc[2],1.0*sc[2]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.0e-03 2.3e+00 1.7e+00 8.0e-01]\n",
      "Doing G-learning, it may take a few seconds...\n",
      "4.232095618311167\n",
      "[1.000e-03 2.301e+00 1.700e+00 8.000e-01]\n",
      "Doing G-learning, it may take a few seconds...\n",
      "4.236697410002113\n",
      "[1.000e-03 2.300e+00 1.701e+00 8.000e-01]\n",
      "Doing G-learning, it may take a few seconds...\n",
      "4.214609028226852\n",
      "[1.00e-03 2.30e+00 1.70e+00 8.01e-01]\n",
      "Doing G-learning, it may take a few seconds...\n",
      "4.22753005763805\n",
      "[1.0e-03 1.5e+00 2.5e+00 1.0e+00]\n",
      "Doing G-learning, it may take a few seconds...\n",
      "9.475242491276921\n",
      "[1.000e-03 1.501e+00 2.500e+00 1.000e+00]\n",
      "Doing G-learning, it may take a few seconds...\n",
      "9.480851385080861\n",
      "[1.000e-03 1.500e+00 2.501e+00 1.000e+00]\n",
      "Doing G-learning, it may take a few seconds...\n",
      "9.475821069774497\n",
      "[1.000e-03 1.500e+00 2.500e+00 1.001e+00]\n",
      "Doing G-learning, it may take a few seconds...\n",
      "9.65938458205582\n",
      "[1.0000000e-03 1.9781928e+00 2.0218072e+00 8.8045180e-01]\n",
      "Doing G-learning, it may take a few seconds...\n",
      "1.7776593237351777\n",
      "[1.0000000e-03 1.9791929e+00 2.0218072e+00 8.8045180e-01]\n",
      "Doing G-learning, it may take a few seconds...\n",
      "1.7808825004253985\n",
      "[1.0000000e-03 1.9781928e+00 2.0228071e+00 8.8045180e-01]\n",
      "Doing G-learning, it may take a few seconds...\n",
      "1.774173063653052\n",
      "[1.0000000e-03 1.9781928e+00 2.0218072e+00 8.8145179e-01]\n",
      "Doing G-learning, it may take a few seconds...\n",
      "1.8128917003669145\n",
      "[1.0000000e-03 1.7726259e+00 2.2333617e+00 7.8193933e-01]\n",
      "Doing G-learning, it may take a few seconds...\n",
      "1.4899373193689585\n",
      "[1.0000000e-03 1.7736259e+00 2.2333617e+00 7.8193933e-01]\n",
      "Doing G-learning, it may take a few seconds...\n",
      "1.4865357248258593\n",
      "[1.0000000e-03 1.7726259e+00 2.2343616e+00 7.8193933e-01]\n",
      "Doing G-learning, it may take a few seconds...\n",
      "1.499326139682889\n",
      "[1.0000000e-03 1.7726259e+00 2.2333617e+00 7.8293931e-01]\n",
      "Doing G-learning, it may take a few seconds...\n",
      "1.4770679706701042\n",
      "[1.0000000e-03 1.9305055e+00 2.0730639e+00 7.9947573e-01]\n",
      "Doing G-learning, it may take a few seconds...\n",
      "0.2745036571631432\n",
      "[1.0000000e-03 1.9315056e+00 2.0730639e+00 7.9947573e-01]\n",
      "Doing G-learning, it may take a few seconds...\n",
      "0.27449853993940354\n",
      "[1.0000000e-03 1.9305055e+00 2.0740640e+00 7.9947573e-01]\n",
      "Doing G-learning, it may take a few seconds...\n",
      "0.27574736455965043\n",
      "[1.0000000e-03 1.9305055e+00 2.0730639e+00 8.0047572e-01]\n",
      "Doing G-learning, it may take a few seconds...\n",
      "0.2762520456619263\n",
      "[1.0000000e-03 1.9508841e+00 2.0499134e+00 7.9343724e-01]\n",
      "Doing G-learning, it may take a few seconds...\n",
      "0.24589644224798682\n",
      "[1.0000000e-03 1.9518842e+00 2.0499134e+00 7.9343724e-01]\n",
      "Doing G-learning, it may take a few seconds...\n",
      "0.24609995020854475\n",
      "[1.0000000e-03 1.9508841e+00 2.0509133e+00 7.9343724e-01]\n",
      "Doing G-learning, it may take a few seconds...\n",
      "0.2462452715727091\n",
      "[1.0000000e-03 1.9508841e+00 2.0499134e+00 7.9443723e-01]\n",
      "Doing G-learning, it may take a few seconds...\n",
      "0.24820469613826276\n",
      "[1.0000000e-03 1.9694551e+00 2.0256894e+00 7.7971065e-01]\n",
      "Doing G-learning, it may take a few seconds...\n",
      "0.2414711222535372\n",
      "[1.0000000e-03 1.9704552e+00 2.0256894e+00 7.7971065e-01]\n",
      "Doing G-learning, it may take a few seconds...\n",
      "0.2417412321419716\n",
      "[1.0000000e-03 1.9694551e+00 2.0266895e+00 7.7971065e-01]\n",
      "Doing G-learning, it may take a few seconds...\n",
      "0.24077540679824352\n",
      "[1.0000000e-03 1.9694551e+00 2.0256894e+00 7.8071064e-01]\n",
      "Doing G-learning, it may take a few seconds...\n",
      "0.24105632371735575\n"
     ]
    }
   ],
   "source": [
    "# L-BFGS-B for gradient solver with bounds\n",
    "res = minimize(fun, x0, method='L-BFGS-B', bounds=bnds, args=(False, 1e-9, False), \n",
    "               options={'disp': True, 'iprint':1, 'maxiter':10, 'eps':1e-3,'gtol':1e-6, 'ftol':0.1*abs(f_ask)}, tol=1e-3) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [],
   "source": [
    "res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "9TcGgfihDQG1",
    "outputId": "16c1069e-f90d-443f-f897-87c7d9ea3892"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.001, 1.9694551, 2.0256894, 0.78071064]\n"
     ]
    }
   ],
   "source": [
    "#print results. Note that these may differ from the actual G-learner parameters depending on the optimizer. \n",
    "# The optimizer will attempt to find the closest set of parameters.\n",
    "results=list(res.x/sc)\n",
    "results.insert(0, lambd)\n",
    "print(results)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Evaluate the performance of GIRL"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a G-learner\n",
    "G_learner = G_learning_portfolio_opt(num_steps,\n",
    "                 results,  \n",
    "                 beta,                \n",
    "                 benchmark_portf,\n",
    "                 gamma, \n",
    "                 num_risky_assets,\n",
    "                 R,\n",
    "                 np.array(expected_risky_returns, dtype='float64'), # array of shape num_steps x num_stocks\n",
    "                 Sigma_r,     # covariance matrix of returns of risky matrix                    \n",
    "                 x_vals_init, # array of initial values of len (num_stocks+1)\n",
    "                 use_for_WM = True) # use for wealth management tasks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Doing G-learning, it may take a few seconds...\n"
     ]
    }
   ],
   "source": [
    "G_learner.reset_prior_policy()\n",
    "G_learner.G_learning(error_tol, max_iter_RL)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Done simulating trajectories in 16.721985 sec\n"
     ]
    }
   ],
   "source": [
    "num_sim = 500\n",
    "\n",
    "np.random.seed(44)\n",
    "torch.manual_seed(44)\n",
    "t_0 = time.time()\n",
    "x_vals = [x_vals_init]\n",
    "returns_all = []\n",
    "consumption_GIRL=np.array([0]*num_steps, dtype='float64')\n",
    "\n",
    "for n in range(num_sim):\n",
    "    \n",
    "    x_t = x_vals_init[:]\n",
    "    returns_array = []\n",
    "    for t in range(0,num_steps):      \n",
    "        mu_t = G_learner.u_bar_prior[t,:] + G_learner.v_bar_prior[t,:].mv(torch.tensor(x_t))\n",
    "        u_t = np.random.multivariate_normal(mu_t.detach().numpy(), G_learner.Sigma_prior[t,:].detach().numpy())\n",
    "        # compute new values of x_t\n",
    "        x_next = x_t +u_t\n",
    "        risky_asset_return = risky_asset_returns.iloc[t,:]\n",
    "        returns = np.hstack((R*dt, risky_asset_return))\n",
    "        x_next = (1+returns)*x_next\n",
    "        port_returns=(x_next.sum() -x_t.sum() -np.sum(u_t) - fee_stock*np.abs(u_t).sum())/x_t.sum()\n",
    "        consumption_GIRL[t] += np.sum(u_t)\n",
    "        x_t = x_next # rename\n",
    "        returns_array.append(port_returns) \n",
    "    # end the loop over time steps\n",
    "    returns_all.append(returns_array)\n",
    "\n",
    "print('Done simulating trajectories in %f sec'% (time.time() - t_0))        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Consumption')"
      ]
     },
     "execution_count": 168,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(investment_periods,consumption/num_sim, label='G-learning (' + str(np.round(np.sum(consumption/num_sim),3)) + ')', color='red')\n",
    "plt.plot(investment_periods,consumption_GIRL/num_sim, label='GIRL (' + str(np.round(np.sum(consumption_GIRL/num_sim),3)) + ')', color='blue')\n",
    "plt.legend()\n",
    "plt.xlabel('Period')\n",
    "plt.ylabel('Consumption')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.593074527877653\n"
     ]
    }
   ],
   "source": [
    "returns_all_GIRL=returns_all\n",
    "\n",
    "SR_GIRL=0\n",
    "for i in range(num_sim):\n",
    "  SR_GIRL+=(np.mean(returns_all_GIRL[i])-R*dt)/np.std(returns_all_GIRL[i])\n",
    "\n",
    "SR_GIRL/=num_sim\n",
    "print(SR_GIRL)\n",
    "\n",
    "r_GIRL=np.array([0]*num_steps, dtype='float64')\n",
    "for n in range(num_steps):\n",
    "  for i in range(num_sim):\n",
    "    r_GIRL[n]+=returns_all_GIRL[i][n]\n",
    "  r_GIRL[n]/=num_sim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Sample Mean Returns')"
      ]
     },
     "execution_count": 170,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(investment_periods, r_G, label='G-learning (' + str(np.round(SR_G,3)) + ')', color='red')\n",
    "plt.plot(investment_periods,r_fixed, label='Equi-weighted (' + str(np.round(SR_fixed,3)) + ')', color='black')\n",
    "plt.plot(investment_periods,r_GIRL, label='GIRL (' + str(np.round(SR_GIRL,3)) + ')', color='blue')\n",
    "\n",
    "plt.legend()\n",
    "plt.xlabel('time (quarters)')\n",
    "plt.ylabel('Sample Mean Returns')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "machine_shape": "hm",
   "name": "Wealth_Management_GIRL.ipynb",
   "provenance": []
  },
  "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": 1
}