ml-finance-python

notebook.ipynb

(13993B)

 {
  "cells": [
   {
    "cell_type": "markdown",
    "metadata": {
     "deletable": true,
     "editable": true
    },
    "source": [
     "#Exercise Answer Key: Position Concentration Risk\n",
     "\n",
     "## Lecture Link\n",
     "\n",
     "This exercise notebook refers to this lecture. Please use the lecture for explanations and sample code.\n",
     "\n",
     "https://www.quantopian.com/lectures#Position-Concentration-Risk\n",
     "\n",
     "Part of the Quantopian Lecture Series:\n",
     "\n",
     "* [www.quantopian.com/lectures](https://www.quantopian.com/lectures)\n",
     "* [github.com/quantopian/research_public](https://github.com/quantopian/research_public)"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
     "collapsed": false,
     "deletable": true,
     "editable": true
    },
    "outputs": [],
    "source": [
     "import numpy as np\n",
     "import pandas as pd\n",
     "import scipy.stats as stats\n",
     "import matplotlib.pyplot as plt\n",
     "import math\n",
     "import cvxpy"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
     "deletable": true,
     "editable": true
    },
    "source": [
     "##Helper Functions"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
     "collapsed": true,
     "deletable": true,
     "editable": true
    },
    "outputs": [],
    "source": [
     "def get_markowitz_weights(mu, Sigma, gamma=1, max_position=1.0, max_leverage=1.0, short=False):\n",
     "    w = cvxpy.Variable(len(Sigma))\n",
     "    g = cvxpy.Parameter(sign='positive')\n",
     "    L = cvxpy.Parameter()\n",
     "    g.value = gamma\n",
     "    L.value = max_leverage\n",
     "    try:\n",
     "        ret = mu.T*w\n",
     "    except ValueError:\n",
     "        ret = mu*w\n",
     "    \n",
     "    risk = cvxpy.quad_form(w, Sigma)\n",
     "    \n",
     "    objective = cvxpy.Maximize(ret - g*risk)\n",
     "    constraints = [\n",
     "        cvxpy.abs(w) < max_position,\n",
     "        cvxpy.norm(w, 1) <= L, # Make it so we don't have to invest everything\n",
     "    ]\n",
     "    \n",
     "    if not short:\n",
     "        constraints.append(w >= 0) # Force all positive weights\n",
     "    \n",
     "    prob = cvxpy.Problem(\n",
     "        objective,\n",
     "        constraints\n",
     "    )\n",
     "    \n",
     "    result = prob.solve()\n",
     "    \n",
     "    return w.value"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
     "deletable": true,
     "editable": true
    },
    "source": [
     "#Exercise 1: Roulette Simulation\n",
     "\n",
     "A roulette table has 38 pockets: 1 through 36, 0, and 00. A bet on an even number pays out at a ratio of 1:1. Landing on 0 and 00 count as losing.\n",
     "\n",
     "You have $100 and are betting on an even number.\n",
     "\n",
     "##a. All In\n",
     "\n",
     "By running 1000 simulations, find the mean and standard deviation of the payout if you bet your entire $100 on one round. "
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
     "collapsed": false,
     "deletable": true,
     "editable": true,
     "scrolled": false
    },
    "outputs": [],
    "source": [
     "universes = 1000\n",
     "evens = 19\n",
     "total = 38\n",
     "payout = 100\n",
     "rounds = 1\n",
     "results = np.zeros(universes)\n",
     "\n",
     "#Your code goes here"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
     "deletable": true,
     "editable": true
    },
    "source": [
     "##b. $1 Bets\n",
     "\n",
     "By running 1000 simulations, find the mean and standard deviation of the payout if instead you bet $1 at a time and play 100 rounds."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
     "collapsed": false,
     "deletable": true,
     "editable": true
    },
    "outputs": [],
    "source": [
     "universes = 1000\n",
     "evens = 19\n",
     "total = 38\n",
     "payout = 1\n",
     "rounds = 100\n",
     "results = np.zeros(universes)\n",
     "\n",
     "#Your code goes here"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
     "deletable": true,
     "editable": true
    },
    "source": [
     "#Exercise 2: Portfolio Diversification\n",
     "\n",
     "##a. Single Asset\n",
     "\n",
     "Use the pricing data below to find the standard deviation of the returns of `AMZN` in the second half of the year 2015 and plot the price against time."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
     "collapsed": false,
     "deletable": true,
     "editable": true
    },
    "outputs": [],
    "source": [
     "time_start = '2015-01-01'\n",
     "time_halfway = '2015-07-01'\n",
     "time_end = '2016-01-01'\n",
     "AMZN_r = get_pricing('AMZN', fields='price', start_date=time_start, end_date=time_end).pct_change()[1:]\n",
     "X = np.linspace(0, len(AMZN_r), len(AMZN_r))\n",
     "\n",
     "#Your code goes here"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
     "deletable": true,
     "editable": true
    },
    "source": [
     "##b. Equally Weighted Portfolio\n",
     "\n",
     "Create an equally weighted portfolio of the following 10 stocks, find the standard deviation of the portfolio's returns, and then plot the returns for the second half of 2015 along with the `AMZN` returns from above. Putting AMZN in a portfolio of 19 other securities should diversify the idiosyncratic risk and lower the price variability.\n",
     "\n",
     "Hint: To calculate weighted returns dot the weight matrix `eweights_df` with the splice of the returns matrix containing the `symbol_list` pricing data (`returns_df[symbol_list]`)."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
     "collapsed": false,
     "deletable": true,
     "editable": true
    },
    "outputs": [],
    "source": [
     "symbol_list = ['BEN', 'SYMC', 'IP', 'SWKS', 'IVZ', 'MJN', 'WMB', 'LB', 'TWX', 'NFX', 'PFE', 'LLY', 'HP', 'JPM', 'CXO', 'TJX', 'CAG', 'BBT', 'ATVI', 'NFLX']\n",
     "prices_df = get_pricing(symbol_list, fields=['price']\n",
     "                               , start_date=time_start, end_date=time_end)['price']\n",
     "prices_df.columns = map(lambda x: x.symbol, prices_df.columns)\n",
     "\n",
     "eweights_df = len(symbol_list) * [float(1)/len(symbol_list)]\n",
     "\n",
     "returns_df = prices_df.pct_change(1)[1:]\n",
     "\n",
     "#Your code goes here"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
     "deletable": true,
     "editable": true
    },
    "source": [
     "##c. Market Weighted Portfolio\n",
     "\n",
     "Create a new portfolio of the same assets, this time weighted by market capitalization, find the standard deviation of the portfolio returns, and then plot the portfolio returns along with both results from above. Weighting using market capitalization brings us closer to the theoretical efficient portfolio, a portfolio of investments containing every single asset on the market, each weighted proportionately to its presence in the market. \n",
     "\n",
     "The market cap is found using a pipeline factor, the steps for which are below."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
     "collapsed": false,
     "deletable": true,
     "editable": true
    },
    "outputs": [],
    "source": [
     "#Pipeline Setup\n",
     "from quantopian.research import run_pipeline\n",
     "from quantopian.pipeline import Pipeline\n",
     "from quantopian.pipeline.data import morningstar \n",
     "from quantopian.pipeline.factors import CustomFactor\n",
     "from quantopian.pipeline.classifiers.morningstar import Sector\n",
     "from quantopian.pipeline.filters import QTradableStocksUS\n",
     "from time import time\n",
     "\n",
     "universe = QTradableStocksUS()\n",
     "\n",
     "pipe = Pipeline(columns = {'Market Cap' : morningstar.valuation.market_cap.latest},\n",
     "    screen=universe\n",
     ")\n",
     "\n",
     "start_timer = time()\n",
     "results = run_pipeline(pipe, time_start, time_end)\n",
     "end_timer = time()\n",
     "results.fillna(value=0);\n",
     "\n",
     "print \"Time to run pipeline %.2f secs\" % (end_timer - start_timer)\n",
     "\n",
     "# This is important as sometimes the first data returned won't be on the specified start date\n",
     "first_trading_day = results.index.levels[0][1]\n",
     "\n",
     "market_cap = results.loc[first_trading_day]['Market Cap']\n",
     "\n",
     "market_cap.index = [x.symbol for x in market_cap.index]#pd.MultiIndex.from_tuples([(x[0], x[1].symbol) for x in market_cap.index])\n",
     "\n",
     "mcs = market_cap # pd.DataFrame(market_cap.loc[(first_trading_day,)].loc[symbol_list]).transpose()"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
     "collapsed": false,
     "deletable": true,
     "editable": true,
     "scrolled": false
    },
    "outputs": [],
    "source": [
     "mweights = (mcs[symbol_list]/sum(mcs[symbol_list])).transpose()\n",
     " \n",
     "#Your code goes here"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
     "deletable": true,
     "editable": true
    },
    "source": [
     "##d. Markowitz Portfolio\n",
     "\n",
     "Create a new portfolio of the same assets, this time using the `get_markowitz_weights` helper function to create the Markowitz mean-variance portfolio. Use the pricing data from the first half of 2015 to calibrate the weights, and then plot the portfolio returns for the second half of 2015.\n",
     "\n",
     "### Important Note\n",
     "\n",
     "If the weights from the lookback window (6 prior months), are correlated with the weights of the forward window (6 following months), then this optimization should be helpful in reducing out portfolio volatility going forward. However, this is often not the case in real life. Real markets are complicated, and historical volatility may not be a good predictor of future volatility. Volatility forecasting models are an entire area of research in finance, so don't think that just because historic volatility of your portfolio was low, it will be equally low in the future. This is just one technique that attempts to control portfolio risk, there is a more complete discussion of this in this lecture:\n",
     "\n",
     "https://www.quantopian.com/lectures/risk-constrained-portfolio-optimization"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
     "collapsed": false,
     "deletable": true,
     "editable": true,
     "scrolled": false
    },
    "outputs": [],
    "source": [
     "mu = returns_df[symbol_list].\\\n",
     "        loc[:time_halfway].fillna(0).mean().as_matrix()\n",
     "sigma = returns_df[symbol_list].\\\n",
     "        loc[:time_halfway].fillna(0).cov().as_matrix()\n",
     "\n",
     "mkweights_df = get_markowitz_weights(mu, sigma)\n",
     "\n",
     "#Your code goes here"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
     "deletable": true,
     "editable": true
    },
    "source": [
     "Although the Markowitz portfolio was supposed to produce the portfolio with the least variance for the given returns, it failed to do so in this out-of-sample scenario.\n",
     "\n",
     "As discussed above, covariance matrices are volatile and tend to shift rapidly. When we calibrated the Markowitz weights we used the covariance matrix from the first half of 2015 as our sample and ran it through the second half of 2016, meaning our test was out-of-sample. Due to the volatile nature of covariance matrices, it is likely that the covariance matrix had significantly changed between the sample and out-of-sample time periods, making our Markowitz weights invalid for the out-of-sample period."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
     "deletable": true,
     "editable": true
    },
    "source": [
     "---\n",
     "\n",
     "Congratulations on completing the Position Concentration Risk exercises!\n",
     "\n",
     "As you learn more about writing trading algorithms and the Quantopian platform, be sure to check out the daily [Quantopian Contest](https://www.quantopian.com/contest), in which you can compete for a cash prize every day.\n",
     "\n",
     "Start by going through the [Writing a Contest Algorithm](https://www.quantopian.com/tutorials/contest) tutorial."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
     "deletable": true,
     "editable": true
    },
    "source": [
     "*This presentation is for informational purposes only and does not constitute an offer to sell, a solic\n",
     "itation to buy, or a recommendation for any security; nor does it constitute an offer to provide investment advisory or other services by Quantopian, Inc. (\"Quantopian\"). Nothing contained herein constitutes investment advice or offers any opinion with respect to the suitability of any security, and any views expressed herein should not be taken as advice to buy, sell, or hold any security or as an endorsement of any security or company.  In preparing the information contained herein, Quantopian, Inc. has not taken into account the investment needs, objectives, and financial circumstances of any particular investor. Any views expressed and data illustrated herein were prepared based upon information, believed to be reliable, available to Quantopian, Inc. at the time of publication. Quantopian makes no guarantees as to their accuracy or completeness. All information is subject to change and may quickly become unreliable for various reasons, including changes in market conditions or economic circumstances.*"
    ]
   }
  ],
  "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.12"
   }
  },
  "nbformat": 4,
  "nbformat_minor": 0
 }