test_portfolio.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from scipy import io\n",
    "import sys\n",
    "import os\n",
    "from ucrp import UniformConstantRebalancedPortfolio\n",
    "from ubah import UniformBuyAndHoldPortfolio\n",
    "from util import load_matlab_sp500_data\n",
    "from expert_pool import ExpertPool\n",
    "from olmar import OLMAR\n",
    "from rmr import RMR\n",
    "from nonparametric_markowitz import NonParametricMarkowitz\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "mat_dict = io.loadmat('data/test.mat')\n",
    "test_cl = mat_dict['test_cl']\n",
    "test_hi = mat_dict['test_hi']\n",
    "test_lo = mat_dict['test_lo']\n",
    "test_op = mat_dict['test_op']\n",
    "test_vol = mat_dict['test_vol']\n",
    "numDays, numStocks = test_cl.shape\n",
    "test_stocks = []\n",
    "for i in range(numStocks):\n",
    "    test_stocks.append(np.array_str(mat_dict['test_stocks'][0][i])[3:-2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def uniform_rebalance(t, portfolio_t, hi, lo, cl, op, stocks, vol):\n",
    "    \"\"\"% Input: \n",
    "    %%% t: we are at Day t\n",
    "    %%% portfolio_t: current portfolio before open of Day t\n",
    "    %%% hi: highest prices at Day t-1\n",
    "    %%% lo: lowest prices at Day t-1\n",
    "    %%% cl: close prices at Day t-1\n",
    "    %%% op: open prices at Day t\n",
    "    %%% stocks: names of all stocks\n",
    "    %%% vol: volumes at Day t-1\n",
    "\n",
    "    % Output: \n",
    "    %%% portfolio: a column vector, each entry represents the portion of \n",
    "    %%%            the value of the corresponding stock over the total cash \n",
    "    %%%            realizable value [as a result, the value of inactive stocks \n",
    "    %%%            i.e., with open price NaN, cannot be added into the total\n",
    "    %%%            cash realizable value]. Hence, your output must satisfy\n",
    "    %%%            sum(portfolio(isfinite(op))) < 1, and the rest is the \n",
    "    %%%            portion of cash realizable value you hold in cash. \n",
    "    %%% hold_flag: a binary vector representing whether you would like to hold\n",
    "    %%%            (with value 1) each stock or you choose to rebalance it\n",
    "    %%%            (with value 0). \"\"\"\n",
    "    numStocks = len(stocks)\n",
    "    portfolio = np.zeros(numStocks)\n",
    "    numActiveStock = np.sum(np.isfinite(op))\n",
    "    portfolio[np.isfinite(op)] = 1.0/numActiveStock\n",
    "    if np.mod(t,2) == 1:\n",
    "        hold_flag = np.zeros(numStocks,dtype=bool)\n",
    "    else:\n",
    "        hold_flag = np.ones(numStocks,dtype=bool)      \n",
    "    return portfolio, hold_flag"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def rebalance(value_vec, value_realizable, portfolio_dst, cost_rate):\n",
    "    \"\"\" % This function simulates the process of rebalancing. The key difficulty \n",
    "    % here is to compute the transaction cost, i.e., to solve the equation\n",
    "    %\n",
    "    % sum( cost_rate * abs( portfolio_dst .* (value_realizable - C) -\n",
    "    % value_vec) ) = C\n",
    "    % \n",
    "    % where C is the total transcation cost. We use the Banach contraction \n",
    "    % theorem to solve this equation, with convergence rate cost_rate^t for \n",
    "    % t-th iteration. \n",
    "\n",
    "    % Input: \n",
    "    %%% value_vec: current values of each active stock\n",
    "    %%% value_realizable: total cash realizable value\n",
    "    %%% portfolio_dst: the desired portfolio after rebalancing\n",
    "    %%% cost_rate: ratio of transactions cost (0.0005 in our case)\n",
    "\n",
    "    % Output:\n",
    "    %%% new_value_vec: the value vector after rebalancing\n",
    "    %%% trans_cost: the total transaction cost\"\"\"\n",
    "    \n",
    "    if len(portfolio_dst)==0:\n",
    "        new_value_vec = value_vec\n",
    "        trans_cost = 0\n",
    "    else:\n",
    "        len_noHold = value_vec.size\n",
    "        C_candidate = np.append([0], value_realizable - value_vec / portfolio_dst)\n",
    "        x = np.sort(C_candidate)\n",
    "        x[np.logical_or(np.isinf(x),np.isnan(x))] = 1e15\n",
    "        x1 = value_realizable - x\n",
    "        len_x = len(x1)\n",
    "        \n",
    "        y = np.sum(cost_rate * np.abs(np.dot(portfolio_dst.reshape(len_noHold,1),x1.reshape(1,len_x)) \\\n",
    "                  -np.dot(value_vec.reshape(len_noHold,1),np.ones((1,len_x)))), axis=0).squeeze() - x\n",
    "        I = np.where(y<=0)[0]\n",
    "        if (len(I)==0) or I[0]==0:\n",
    "            trans_cost = 0\n",
    "            new_value_vec = value_vec\n",
    "        else: #  the equation is linear in [C_sort(I-1), C_sort(I)]           \n",
    "            I = I[0]\n",
    "            trans_cost = x[I-1] - y[I-1] * (x[I] - x[I-1]) / (y[I] - y[I-1])\n",
    "            if trans_cost > value_realizable:\n",
    "                trans_cost = 0\n",
    "                new_value_vec = value_vec\n",
    "            else:\n",
    "                new_value_vec = portfolio_dst * (value_realizable - trans_cost)\n",
    "    return new_value_vec, trans_cost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "248 497\n"
     ]
    }
   ],
   "source": [
    "value_op_seq = np.zeros(numDays) # total value before open of each day\n",
    "value_cl_seq = np.zeros(numDays) # total value before close of each day \n",
    "portfolio_seq = np.zeros((numStocks, numDays)) # portfolio before open of each day\n",
    "last_close_price = np.NaN * np.ones(numStocks)\n",
    "print numDays, numStocks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Initialization\n",
    "op = test_op[0,:]\n",
    "cl = np.NaN * np.ones(numStocks)\n",
    "hi = np.NaN * np.ones(numStocks)\n",
    "lo = np.NaN * np.ones(numStocks)\n",
    "vol = np.NaN * np.ones(numStocks)\n",
    "value_op_seq[0] = 1 # initially we have one unit of cash"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load Training Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#direcotry = 'data/portfolio_train.mat'\n",
    "#train_start = 760\n",
    "directory = 'data/train.mat'\n",
    "train_start = 0\n",
    "train_data = load_matlab_sp500_data(directory,start=train_start)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Run Portfolio On Training Set (Note to instructors: we've already ran this block and saved parameters to a file. You can skip this block)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "------------------------------\n",
      "Results of expert pooling: \n",
      "------------------------------\n",
      "Weighting strategy:  exp_window\n",
      "Total dollar value of assets over time:\n",
      "[ 1.          0.99950025  0.98453958  0.97936484  0.97668832  0.95646125\n",
      "  0.94628035  0.94944179  0.93775277  0.94004697  0.93470971  0.95159261\n",
      "  0.95962921  0.94589299  0.95598934  0.96858082  0.96955565  0.95231972\n",
      "  0.94768514  0.93960302  0.93740813  0.93348141  0.9146944   0.90069733\n",
      "  0.91440299  0.94803448  0.94318242  0.93464198  0.93252626  0.94465415]\n",
      "Sharpe ratio:\n",
      "0.975762322587\n"
     ]
    }
   ],
   "source": [
    "\"\"\" \n",
    "new_results_dir = 'train_results/'\n",
    "#ucrp = UniformConstantRebalancedPortfolio(market_data=train_data, tune_interval=None, verbose=True, \n",
    "#                                          past_results_dir='train_results/UCRP/')\n",
    "olmar = OLMAR(market_data=train_data, tune_interval=5, verbose=True, new_results_dir=new_results_dir+'OLMAR/') #, past_results_dir='train_results/OLMAR/')\n",
    "rmr = RMR(market_data=train_data, tune_interval=200, verbose=True, new_results_dir=new_results_dir+'RMR/') #, past_results_dir='train_results/RMR/')\n",
    "#npm = NonParametricMarkowitz(market_data=train_data, tune_interval=None, verbose=True, past_results_dir='train_results/NPM/')\n",
    "pool = ExpertPool(market_data=train_data, experts=[olmar, rmr], verbose=True) #, past_results_dir='train_results/EP/')\n",
    "pool.run()\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Run Portfolio on Test (or validation) Set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "------------------------------\n",
      "Results of expert pooling: \n",
      "------------------------------\n",
      "Weighting strategy:  exp_window\n",
      "Total dollar value of assets over time:\n",
      "[ 1.          0.99950234  1.00832552  0.99215845  0.99239368  0.96996557\n",
      "  0.95713764  0.9769959   0.97106873  0.97670573  0.97345436  0.96491695\n",
      "  0.96465193  0.95655708  0.95486017  0.93498609  0.95072224  0.94120656\n",
      "  0.94382753  0.94523871  0.96450083  0.95727814  0.9475982   0.96223146\n",
      "  0.963463    0.94969958  0.94021079  0.94353685  0.94140406  0.9592599 ]\n",
      "Sharpe ratio:\n",
      "0.935311610911\n"
     ]
    }
   ],
   "source": [
    "# Load data\n",
    "directory = 'data/test.mat'\n",
    "past_results_dir = 'train_results/'\n",
    "test_data = load_matlab_sp500_data(directory)\n",
    "numDays, numStocks = test_data.get_cl().shape\n",
    "\n",
    "train_directory = 'data/market_data_train.mat'\n",
    "train_data = load_matlab_sp500_data(train_directory)\n",
    "\n",
    "ucrp = UniformConstantRebalancedPortfolio(market_data=train_data, tune_interval=None, verbose=True, \n",
    "                                         past_results_dir=past_results_dir+'UCRP/')\n",
    "olmar = OLMAR(market_data=test_data, market_data_train=train_data, tune_interval=5, verbose=True, past_results_dir=past_results_dir+'OLMAR/') \n",
    "rmr = RMR(market_data=test_data, market_data_train=train_data, tune_interval=200, verbose=True, past_results_dir=past_results_dir+'RMR/')\n",
    "npm = NonParametricMarkowitz(market_data=train_data, tune_interval=None, verbose=True, past_results_dir=past_results_dir+'NPM/')\n",
    "pool = ExpertPool(market_data=test_data, experts=[olmar, rmr], verbose=True) \n",
    "pool.run()\n",
    "\n",
    "portfolios = pool.b_history\n",
    "portfolios = np.concatenate((portfolios, np.reshape(pool.b, (-1,1))), axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/nicochaves/anaconda/lib/python2.7/site-packages/ipykernel/__main__.py:27: RuntimeWarning: invalid value encountered in divide\n",
      "/Users/nicochaves/anaconda/lib/python2.7/site-packages/ipykernel/__main__.py:27: RuntimeWarning: divide by zero encountered in divide\n"
     ]
    }
   ],
   "source": [
    "for t in range(numDays):\n",
    "    # At the beginning of day t, we use all information up to the open \n",
    "    # price of day t to determine the capital allocation at the end of \n",
    "    # day t.\n",
    "    \n",
    "    # Your function should be placed here. Note that the input vector may\n",
    "    # contain NaNs (at Day 1, or for some inactive stocks). \n",
    "    #new_portfolio, hold_flag = uniform_rebalance(t, portfolio_seq[:,t], hi, lo, cl, op, test_stocks, vol)\n",
    "    new_portfolio = portfolios[:,t+1]\n",
    "    hold_flag = np.zeros(numStocks)\n",
    "    \n",
    "    # Check whether your output is valid\n",
    "    isActive = np.isfinite(op)\n",
    "    noHold = np.logical_and(isActive, np.logical_not(hold_flag))\n",
    "    if np.sum(new_portfolio[noHold]) > 1 + 1e-8:\n",
    "        sys.stderr.write('The output portfolio is not valid!')\n",
    "        \n",
    "    # The value of our portfolio at the end of Day t before paying transaction costs\n",
    "    cl = test_cl[t,:]\n",
    "    value_vec = value_op_seq[t] * portfolio_seq[:,t]\n",
    "    growth = cl[isActive] / last_close_price[isActive]-1\n",
    "    growth[np.isnan(growth)] = 0\n",
    "    revenue_vec = value_vec[isActive] * growth\n",
    "    value_vec[isActive] = value_vec[isActive] + revenue_vec\n",
    "    value_cl_seq[t] = value_op_seq[t] + np.sum(revenue_vec)\n",
    "        \n",
    "\n",
    "    # At the end of Day t, we use the close price of day t to adjust our \n",
    "    # portfolio to the desired percentage.\n",
    "    if t <= numDays-2:\n",
    "        value_realizable = value_cl_seq[t] - np.sum(value_vec[np.logical_not(noHold)])\n",
    "        new_value_vec, trans_cost = rebalance(value_vec[noHold], value_realizable, \\\n",
    "                                              new_portfolio[noHold], 0.0005)\n",
    "        value_op_seq[t+1] = value_cl_seq[t] - trans_cost\n",
    "        if value_op_seq[t+1]<0:\n",
    "            sys.stderr.write('You go bankrupt at Day {}!'.format(t))\n",
    "        value_vec[noHold] = new_value_vec\n",
    "        portfolio_seq[:,t+1] = value_vec / value_op_seq[t+1]\n",
    "        \n",
    "    last_close_price[isActive] = cl[isActive]\n",
    "    \n",
    "    # Update information\n",
    "    if t <= numDays-2:\n",
    "        op = test_op[t+1,:]\n",
    "        hi = test_op[t,:]\n",
    "        lo = test_lo[t,:]\n",
    "        vol = test_vol[t,:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.112475699328 0.935311610911\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYEAAAEACAYAAABVtcpZAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nTIsAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x110688e50>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(value_op_seq)\n",
    "return_seq = np.log(value_op_seq[1:] / value_op_seq[:-1])\n",
    "annual_return = 252 * np.mean(return_seq)\n",
    "sharpe = np.sqrt(252) * np.mean(return_seq) / np.std(return_seq)\n",
    "print annual_return, sharpe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}