ml-finance-python

python scripts for finance machine learning
git clone https://9o.is/git/ml-finance-python.git
lab_128.ipynb

(87365B)
      1 {
      2  "cells": [
      3   {
      4    "cell_type": "markdown",
      5    "metadata": {},
      6    "source": [
      7     "# Naive Risk Budgeting Strategies between PSP and GHP\n",
      8     "\n",
      9     "We've already seen how we can compute the returns of a portfolio that mixes a PSP with a GHP. In this session we'll build some tools to put a more methodical structure around that process."
     10    ]
     11   },
     12   {
     13    "cell_type": "code",
     14    "execution_count": 1,
     15    "metadata": {},
     16    "outputs": [],
     17    "source": [
     18     "import numpy as np\n",
     19     "import pandas as pd\n",
     20     "import edhec_risk_kit_128 as erk\n",
     21     "%matplotlib inline\n",
     22     "%load_ext autoreload\n",
     23     "%autoreload 2"
     24    ]
     25   },
     26   {
     27    "cell_type": "markdown",
     28    "metadata": {},
     29    "source": [
     30     "```python\n",
     31     "def bt_mix(r1, r2, allocator, **kwargs):\n",
     32     "    \"\"\"\n",
     33     "    Runs a back test (simulation) of allocating between a two sets of returns\n",
     34     "    r1 and r2 are T x N DataFrames or returns where T is the time step index and N is the number of scenarios.\n",
     35     "    allocator is a function that takes two sets of returns and allocator specific parameters, and produces\n",
     36     "    an allocation to the first portfolio (the rest of the money is invested in the GHP) as a T x 1 DataFrame\n",
     37     "    Returns a T x N DataFrame of the resulting N portfolio scenarios\n",
     38     "    \"\"\"\n",
     39     "    if not r1.shape == r2.shape:\n",
     40     "        raise ValueError(\"r1 and r2 should have the same shape\")\n",
     41     "    weights = allocator(r1, r2, **kwargs)\n",
     42     "    if not weights.shape == r1.shape:\n",
     43     "        raise ValueError(\"Allocator returned weights with a different shape than the returns\")\n",
     44     "    r_mix = weights*r1 + (1-weights)*r2\n",
     45     "    return r_mix\n",
     46     "```"
     47    ]
     48   },
     49   {
     50    "cell_type": "markdown",
     51    "metadata": {},
     52    "source": [
     53     "## The Simplest Allocator - Fixed Mix\n",
     54     "\n",
     55     "The allocator's job is to come up with a time series of weights, so let's create the simplest possible allocator - one that puts a fixed fraction in the first portfolio and the remaining in the second\n"
     56    ]
     57   },
     58   {
     59    "cell_type": "markdown",
     60    "metadata": {},
     61    "source": [
     62     "```python\n",
     63     "def fixedmix_allocator(r1, r2, w1, **kwargs):\n",
     64     "    \"\"\"\n",
     65     "    Produces a time series over T steps of allocations between the PSP and GHP across N scenarios\n",
     66     "    PSP and GHP are T x N DataFrames that represent the returns of the PSP and GHP such that:\n",
     67     "     each column is a scenario\n",
     68     "     each row is the price for a timestep\n",
     69     "    Returns an T x N DataFrame of PSP Weights\n",
     70     "    \"\"\"\n",
     71     "    return pd.DataFrame(data = w1, index=r1.index, columns=r1.columns)\n",
     72     "```"
     73    ]
     74   },
     75   {
     76    "cell_type": "markdown",
     77    "metadata": {},
     78    "source": [
     79     "We are now ready to rerun the experiment we ran last time ... a bond portfolio of 60% in the 10 year bond and 40% in the 30 year bond to generate a fixed mix bond portfolio."
     80    ]
     81   },
     82   {
     83    "cell_type": "code",
     84    "execution_count": 3,
     85    "metadata": {},
     86    "outputs": [
     87     {
     88      "data": {
     89       "text/html": [
     90        "<div>\n",
     91        "<style scoped>\n",
     92        "    .dataframe tbody tr th:only-of-type {\n",
     93        "        vertical-align: middle;\n",
     94        "    }\n",
     95        "\n",
     96        "    .dataframe tbody tr th {\n",
     97        "        vertical-align: top;\n",
     98        "    }\n",
     99        "\n",
    100        "    .dataframe thead th {\n",
    101        "        text-align: right;\n",
    102        "    }\n",
    103        "</style>\n",
    104        "<table border=\"1\" class=\"dataframe\">\n",
    105        "  <thead>\n",
    106        "    <tr style=\"text-align: right;\">\n",
    107        "      <th></th>\n",
    108        "      <th>Annualized Return</th>\n",
    109        "      <th>Annualized Vol</th>\n",
    110        "      <th>Skewness</th>\n",
    111        "      <th>Kurtosis</th>\n",
    112        "      <th>Cornish-Fisher VaR (5%)</th>\n",
    113        "      <th>Historic CVaR (5%)</th>\n",
    114        "      <th>Sharpe Ratio</th>\n",
    115        "      <th>Max Drawdown</th>\n",
    116        "    </tr>\n",
    117        "  </thead>\n",
    118        "  <tbody>\n",
    119        "    <tr>\n",
    120        "      <th>0</th>\n",
    121        "      <td>0.035854</td>\n",
    122        "      <td>0.003663</td>\n",
    123        "      <td>0.156305</td>\n",
    124        "      <td>3.772562</td>\n",
    125        "      <td>-0.001272</td>\n",
    126        "      <td>-0.000569</td>\n",
    127        "      <td>1.555316</td>\n",
    128        "      <td>0.0</td>\n",
    129        "    </tr>\n",
    130        "  </tbody>\n",
    131        "</table>\n",
    132        "</div>"
    133       ],
    134       "text/plain": [
    135        "   Annualized Return  Annualized Vol  Skewness  Kurtosis  \\\n",
    136        "0           0.035854        0.003663  0.156305  3.772562   \n",
    137        "\n",
    138        "   Cornish-Fisher VaR (5%)  Historic CVaR (5%)  Sharpe Ratio  Max Drawdown  \n",
    139        "0                -0.001272           -0.000569      1.555316           0.0  "
    140       ]
    141      },
    142      "execution_count": 3,
    143      "metadata": {},
    144      "output_type": "execute_result"
    145     }
    146    ],
    147    "source": [
    148     "rates, zc_prices = erk.cir(10, 500, b=0.03, r_0 = 0.03)\n",
    149     "price_10 = erk.bond_price(10, 100, .05, 12, rates)\n",
    150     "price_30 = erk.bond_price(30, 100, .05, 12, rates)\n",
    151     "rets_30 = erk.bond_total_return(price_30, 100, .05, 12)\n",
    152     "rets_10 = erk.bond_total_return(price_10, 100, .05, 12)\n",
    153     "rets_bonds = erk.bt_mix(rets_10, rets_30, allocator=erk.fixedmix_allocator, w1=.6)\n",
    154     "mean_rets_bonds = rets_bonds.mean(axis='columns')\n",
    155     "erk.summary_stats(pd.DataFrame(mean_rets_bonds))"
    156    ]
    157   },
    158   {
    159    "cell_type": "markdown",
    160    "metadata": {},
    161    "source": [
    162     "Next, we'll use this to create a 70-30 Stock Bond Mix. First, we'll generate stock returns:"
    163    ]
    164   },
    165   {
    166    "cell_type": "code",
    167    "execution_count": 4,
    168    "metadata": {},
    169    "outputs": [],
    170    "source": [
    171     "price_eq = erk.gbm(n_years=10,n_scenarios=500,mu=0.07, sigma=0.15)\n",
    172     "rets_eq = price_eq.pct_change().dropna()\n",
    173     "rets_zc = zc_prices.pct_change().dropna()"
    174    ]
    175   },
    176   {
    177    "cell_type": "markdown",
    178    "metadata": {},
    179    "source": [
    180     "And next, we'll use the mix backtester to build a 70-30 Stock-Bond mix. One way to assess the performance is, as before, to generate a composite and produce summary stats on the composite. We'll also examine a second approach, which is to compute summary stats on each scenario and average the summary stats."
    181    ]
    182   },
    183   {
    184    "cell_type": "code",
    185    "execution_count": 6,
    186    "metadata": {},
    187    "outputs": [
    188     {
    189      "data": {
    190       "text/html": [
    191        "<div>\n",
    192        "<style scoped>\n",
    193        "    .dataframe tbody tr th:only-of-type {\n",
    194        "        vertical-align: middle;\n",
    195        "    }\n",
    196        "\n",
    197        "    .dataframe tbody tr th {\n",
    198        "        vertical-align: top;\n",
    199        "    }\n",
    200        "\n",
    201        "    .dataframe thead th {\n",
    202        "        text-align: right;\n",
    203        "    }\n",
    204        "</style>\n",
    205        "<table border=\"1\" class=\"dataframe\">\n",
    206        "  <thead>\n",
    207        "    <tr style=\"text-align: right;\">\n",
    208        "      <th></th>\n",
    209        "      <th>Annualized Return</th>\n",
    210        "      <th>Annualized Vol</th>\n",
    211        "      <th>Skewness</th>\n",
    212        "      <th>Kurtosis</th>\n",
    213        "      <th>Cornish-Fisher VaR (5%)</th>\n",
    214        "      <th>Historic CVaR (5%)</th>\n",
    215        "      <th>Sharpe Ratio</th>\n",
    216        "      <th>Max Drawdown</th>\n",
    217        "    </tr>\n",
    218        "  </thead>\n",
    219        "  <tbody>\n",
    220        "    <tr>\n",
    221        "      <th>0</th>\n",
    222        "      <td>0.056436</td>\n",
    223        "      <td>0.003949</td>\n",
    224        "      <td>0.060645</td>\n",
    225        "      <td>4.004417</td>\n",
    226        "      <td>-0.002762</td>\n",
    227        "      <td>-0.001989</td>\n",
    228        "      <td>6.51537</td>\n",
    229        "      <td>0.0</td>\n",
    230        "    </tr>\n",
    231        "  </tbody>\n",
    232        "</table>\n",
    233        "</div>"
    234       ],
    235       "text/plain": [
    236        "   Annualized Return  Annualized Vol  Skewness  Kurtosis  \\\n",
    237        "0           0.056436        0.003949  0.060645  4.004417   \n",
    238        "\n",
    239        "   Cornish-Fisher VaR (5%)  Historic CVaR (5%)  Sharpe Ratio  Max Drawdown  \n",
    240        "0                -0.002762           -0.001989       6.51537           0.0  "
    241       ]
    242      },
    243      "execution_count": 6,
    244      "metadata": {},
    245      "output_type": "execute_result"
    246     }
    247    ],
    248    "source": [
    249     "rets_7030b = erk.bt_mix(rets_eq, rets_bonds, allocator=erk.fixedmix_allocator, w1=0.7)\n",
    250     "rets_7030b_mean = rets_7030b.mean(axis='columns')\n",
    251     "erk.summary_stats(pd.DataFrame(rets_7030b_mean))"
    252    ]
    253   },
    254   {
    255    "cell_type": "code",
    256    "execution_count": 7,
    257    "metadata": {},
    258    "outputs": [
    259     {
    260      "data": {
    261       "text/plain": [
    262        "Annualized Return          0.050920\n",
    263        "Annualized Vol             0.107614\n",
    264        "Skewness                  -0.006626\n",
    265        "Kurtosis                   2.973340\n",
    266        "Cornish-Fisher VaR (5%)    0.046342\n",
    267        "Historic CVaR (5%)         0.058854\n",
    268        "Sharpe Ratio               0.188383\n",
    269        "Max Drawdown              -0.213090\n",
    270        "dtype: float64"
    271       ]
    272      },
    273      "execution_count": 7,
    274      "metadata": {},
    275      "output_type": "execute_result"
    276     }
    277    ],
    278    "source": [
    279     "# Approach 2: compute stats on each scenario and then average\n",
    280     "summaries = erk.summary_stats(rets_7030b)\n",
    281     "summaries.mean()"
    282    ]
    283   },
    284   {
    285    "cell_type": "markdown",
    286    "metadata": {},
    287    "source": [
    288     "However, both of these summaries are imperfect, since they aggregate across a wide distribution. In different situations one or the other might make sense, but for most individuals, the range of outcomes are what matters because we observe only one of the different possible scenarios.\n",
    289     "\n",
    290     "Therefore, it make sense to example the range of possible outcomes and look at not just the average but also the less likely but possible outcomes.\n",
    291     "\n",
    292     "## Distribution of Terminal Values and Measuring Risk Budget Efficiency\n",
    293     "\n",
    294     "The basic idea is to measure the distribution of terminal values across all scenarios."
    295    ]
    296   },
    297   {
    298    "cell_type": "markdown",
    299    "metadata": {},
    300    "source": [
    301     "```python\n",
    302     "def terminal_values(rets):\n",
    303     "    \"\"\"\n",
    304     "    Computes the terminal values from a set of returns supplied as a T x N DataFrame\n",
    305     "    Return a Series of length N indexed by the columns of rets\n",
    306     "    \"\"\"\n",
    307     "    return (rets+1).prod()\n",
    308     "\n",
    309     "def terminal_stats(rets, floor = 0.8, cap=np.inf, name=\"Stats\"):\n",
    310     "    \"\"\"\n",
    311     "    Produce Summary Statistics on the terminal values per invested dollar\n",
    312     "    across a range of N scenarios\n",
    313     "    rets is a T x N DataFrame of returns, where T is the time-step (we assume rets is sorted by time)\n",
    314     "    Returns a 1 column DataFrame of Summary Stats indexed by the stat name \n",
    315     "    \"\"\"\n",
    316     "    terminal_wealth = (rets+1).prod()\n",
    317     "    breach = terminal_wealth < floor\n",
    318     "    reach = terminal_wealth >= cap\n",
    319     "    p_breach = breach.mean() if breach.sum() > 0 else np.nan\n",
    320     "    p_reach = breach.mean() if reach.sum() > 0 else np.nan\n",
    321     "    e_short = (floor-terminal_wealth[breach]).mean() if breach.sum() > 0 else np.nan\n",
    322     "    e_surplus = (cap-terminal_wealth[reach]).mean() if reach.sum() > 0 else np.nan\n",
    323     "    sum_stats = pd.DataFrame.from_dict({\n",
    324     "        \"mean\": terminal_wealth.mean(),\n",
    325     "        \"std\" : terminal_wealth.std(),\n",
    326     "        \"p_breach\": p_breach,\n",
    327     "        \"e_short\":e_short,\n",
    328     "        \"p_reach\": p_reach,\n",
    329     "        \"e_surplus\": e_surplus\n",
    330     "    }, orient=\"index\", columns=[name])\n",
    331     "    return sum_stats\n",
    332     "\n",
    333     "```"
    334    ]
    335   },
    336   {
    337    "cell_type": "code",
    338    "execution_count": 8,
    339    "metadata": {},
    340    "outputs": [
    341     {
    342      "data": {
    343       "text/html": [
    344        "<div>\n",
    345        "<style scoped>\n",
    346        "    .dataframe tbody tr th:only-of-type {\n",
    347        "        vertical-align: middle;\n",
    348        "    }\n",
    349        "\n",
    350        "    .dataframe tbody tr th {\n",
    351        "        vertical-align: top;\n",
    352        "    }\n",
    353        "\n",
    354        "    .dataframe thead th {\n",
    355        "        text-align: right;\n",
    356        "    }\n",
    357        "</style>\n",
    358        "<table border=\"1\" class=\"dataframe\">\n",
    359        "  <thead>\n",
    360        "    <tr style=\"text-align: right;\">\n",
    361        "      <th></th>\n",
    362        "      <th>FI</th>\n",
    363        "      <th>Eq</th>\n",
    364        "      <th>70/30</th>\n",
    365        "    </tr>\n",
    366        "  </thead>\n",
    367        "  <tbody>\n",
    368        "    <tr>\n",
    369        "      <th>mean</th>\n",
    370        "      <td>1.383025</td>\n",
    371        "      <td>1.873734</td>\n",
    372        "      <td>1.722892</td>\n",
    373        "    </tr>\n",
    374        "    <tr>\n",
    375        "      <th>std</th>\n",
    376        "      <td>0.107982</td>\n",
    377        "      <td>0.898662</td>\n",
    378        "      <td>0.571827</td>\n",
    379        "    </tr>\n",
    380        "    <tr>\n",
    381        "      <th>p_breach</th>\n",
    382        "      <td>NaN</td>\n",
    383        "      <td>0.052000</td>\n",
    384        "      <td>0.006000</td>\n",
    385        "    </tr>\n",
    386        "    <tr>\n",
    387        "      <th>e_short</th>\n",
    388        "      <td>NaN</td>\n",
    389        "      <td>0.110863</td>\n",
    390        "      <td>0.089708</td>\n",
    391        "    </tr>\n",
    392        "    <tr>\n",
    393        "      <th>p_reach</th>\n",
    394        "      <td>NaN</td>\n",
    395        "      <td>NaN</td>\n",
    396        "      <td>NaN</td>\n",
    397        "    </tr>\n",
    398        "    <tr>\n",
    399        "      <th>e_surplus</th>\n",
    400        "      <td>NaN</td>\n",
    401        "      <td>NaN</td>\n",
    402        "      <td>NaN</td>\n",
    403        "    </tr>\n",
    404        "  </tbody>\n",
    405        "</table>\n",
    406        "</div>"
    407       ],
    408       "text/plain": [
    409        "                 FI        Eq     70/30\n",
    410        "mean       1.383025  1.873734  1.722892\n",
    411        "std        0.107982  0.898662  0.571827\n",
    412        "p_breach        NaN  0.052000  0.006000\n",
    413        "e_short         NaN  0.110863  0.089708\n",
    414        "p_reach         NaN       NaN       NaN\n",
    415        "e_surplus       NaN       NaN       NaN"
    416       ]
    417      },
    418      "execution_count": 8,
    419      "metadata": {},
    420      "output_type": "execute_result"
    421     }
    422    ],
    423    "source": [
    424     "pd.concat([erk.terminal_stats(rets_bonds, name=\"FI\"), \n",
    425     "           erk.terminal_stats(rets_eq, name=\"Eq\"),\n",
    426     "           erk.terminal_stats(rets_7030b, name=\"70/30\")],\n",
    427     "          axis=1)"
    428    ]
    429   },
    430   {
    431    "cell_type": "code",
    432    "execution_count": 9,
    433    "metadata": {},
    434    "outputs": [
    435     {
    436      "name": "stderr",
    437      "output_type": "stream",
    438      "text": [
    439       "/home/vijay/anaconda3/lib/python3.7/site-packages/scipy/stats/stats.py:1713: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n",
    440       "  return np.add.reduce(sorted[indexer] * weights, axis=axis) / sumval\n"
    441      ]
    442     },
    443     {
    444      "data": {
    445       "image/png": "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\n",
    446       "text/plain": [
    447        "<Figure size 864x432 with 1 Axes>"
    448       ]
    449      },
    450      "metadata": {
    451       "needs_background": "light"
    452      },
    453      "output_type": "display_data"
    454     }
    455    ],
    456    "source": [
    457     "import seaborn as sns\n",
    458     "import matplotlib.pyplot as plt\n",
    459     "plt.figure(figsize=(12, 6))\n",
    460     "sns.distplot(erk.terminal_values(rets_eq), color=\"red\", label=\"100% Equities\")\n",
    461     "sns.distplot(erk.terminal_values(rets_bonds), color=\"blue\", label=\"100% Bonds\")\n",
    462     "sns.distplot(erk.terminal_values(rets_7030b), color=\"orange\", label=\"70/30 Equities/Bonds\")\n",
    463     "plt.legend();"
    464    ]
    465   },
    466   {
    467    "cell_type": "markdown",
    468    "metadata": {},
    469    "source": [
    470     "Note how the higher mean return of the equities portfolio is due in part to the large upside spread in equities.\n",
    471     "\n",
    472     "## Risk Budgeting through Glide Path Allocation\n",
    473     "\n",
    474     "A potential improvement over naive fixed mix is to risk budget by making a simplistic assumption that risk = time.\n",
    475     "\n",
    476     "In other words, if you have more time, increase the risk budget. If you have less time, derisk. This is the thinking behind a Target Date Fund.\n",
    477     "\n",
    478     "Let's write an allocator that defines the weights as a glidepath sthat starts at a starting weight and then gradually decreases the weights to equities over time to an ending weight. For example, you can start at 80% stocks at the start of the 10 year period and then gradually move to 20% stocks by the end of the 10 year period.\n",
    479     "\n",
    480     "Let's see how this does:\n",
    481     "\n",
    482     "```python\n",
    483     "def glidepath_allocator(r1, r2, start_glide=1, end_glide=0.0):\n",
    484     "    \"\"\"\n",
    485     "    Allocates weights to r1 starting at start_glide and ends at end_glide\n",
    486     "    by gradually moving from start_glide to end_glide over time\n",
    487     "    \"\"\"\n",
    488     "    n_points = r1.shape[0]\n",
    489     "    n_col = r1.shape[1]\n",
    490     "    path = pd.Series(data=np.linspace(start_glide, end_glide, num=n_points))\n",
    491     "    paths = pd.concat([path]*n_col, axis=1)\n",
    492     "    paths.index = r1.index\n",
    493     "    paths.columns = r1.columns\n",
    494     "    return paths\n",
    495     "```\n"
    496    ]
    497   },
    498   {
    499    "cell_type": "code",
    500    "execution_count": 11,
    501    "metadata": {},
    502    "outputs": [
    503     {
    504      "data": {
    505       "text/html": [
    506        "<div>\n",
    507        "<style scoped>\n",
    508        "    .dataframe tbody tr th:only-of-type {\n",
    509        "        vertical-align: middle;\n",
    510        "    }\n",
    511        "\n",
    512        "    .dataframe tbody tr th {\n",
    513        "        vertical-align: top;\n",
    514        "    }\n",
    515        "\n",
    516        "    .dataframe thead th {\n",
    517        "        text-align: right;\n",
    518        "    }\n",
    519        "</style>\n",
    520        "<table border=\"1\" class=\"dataframe\">\n",
    521        "  <thead>\n",
    522        "    <tr style=\"text-align: right;\">\n",
    523        "      <th></th>\n",
    524        "      <th>FI</th>\n",
    525        "      <th>Eq</th>\n",
    526        "      <th>70/30</th>\n",
    527        "      <th>Glide 80 to 20</th>\n",
    528        "    </tr>\n",
    529        "  </thead>\n",
    530        "  <tbody>\n",
    531        "    <tr>\n",
    532        "      <th>mean</th>\n",
    533        "      <td>1.383025</td>\n",
    534        "      <td>1.873734</td>\n",
    535        "      <td>1.722892</td>\n",
    536        "      <td>1.633690</td>\n",
    537        "    </tr>\n",
    538        "    <tr>\n",
    539        "      <th>std</th>\n",
    540        "      <td>0.107982</td>\n",
    541        "      <td>0.898662</td>\n",
    542        "      <td>0.571827</td>\n",
    543        "      <td>0.427764</td>\n",
    544        "    </tr>\n",
    545        "    <tr>\n",
    546        "      <th>p_breach</th>\n",
    547        "      <td>NaN</td>\n",
    548        "      <td>0.052000</td>\n",
    549        "      <td>0.006000</td>\n",
    550        "      <td>0.002000</td>\n",
    551        "    </tr>\n",
    552        "    <tr>\n",
    553        "      <th>e_short</th>\n",
    554        "      <td>NaN</td>\n",
    555        "      <td>0.110863</td>\n",
    556        "      <td>0.089708</td>\n",
    557        "      <td>0.035501</td>\n",
    558        "    </tr>\n",
    559        "    <tr>\n",
    560        "      <th>p_reach</th>\n",
    561        "      <td>NaN</td>\n",
    562        "      <td>NaN</td>\n",
    563        "      <td>NaN</td>\n",
    564        "      <td>NaN</td>\n",
    565        "    </tr>\n",
    566        "    <tr>\n",
    567        "      <th>e_surplus</th>\n",
    568        "      <td>NaN</td>\n",
    569        "      <td>NaN</td>\n",
    570        "      <td>NaN</td>\n",
    571        "      <td>NaN</td>\n",
    572        "    </tr>\n",
    573        "  </tbody>\n",
    574        "</table>\n",
    575        "</div>"
    576       ],
    577       "text/plain": [
    578        "                 FI        Eq     70/30  Glide 80 to 20\n",
    579        "mean       1.383025  1.873734  1.722892        1.633690\n",
    580        "std        0.107982  0.898662  0.571827        0.427764\n",
    581        "p_breach        NaN  0.052000  0.006000        0.002000\n",
    582        "e_short         NaN  0.110863  0.089708        0.035501\n",
    583        "p_reach         NaN       NaN       NaN             NaN\n",
    584        "e_surplus       NaN       NaN       NaN             NaN"
    585       ]
    586      },
    587      "execution_count": 11,
    588      "metadata": {},
    589      "output_type": "execute_result"
    590     }
    591    ],
    592    "source": [
    593     "\n",
    594     "rets_g8020 = erk.bt_mix(rets_eq, rets_bonds, allocator=erk.glidepath_allocator, start_glide=.8, end_glide=.2)\n",
    595     "pd.concat([erk.terminal_stats(rets_bonds, name=\"FI\"), \n",
    596     "           erk.terminal_stats(rets_eq, name=\"Eq\"),\n",
    597     "           erk.terminal_stats(rets_7030b, name=\"70/30\"),\n",
    598     "           erk.terminal_stats(rets_g8020, name=\"Glide 80 to 20\")],\n",
    599     "          axis=1)"
    600    ]
    601   },
    602   {
    603    "cell_type": "code",
    604    "execution_count": 12,
    605    "metadata": {},
    606    "outputs": [
    607     {
    608      "data": {
    609       "image/png": "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\n",
    610       "text/plain": [
    611        "<Figure size 864x432 with 1 Axes>"
    612       ]
    613      },
    614      "metadata": {
    615       "needs_background": "light"
    616      },
    617      "output_type": "display_data"
    618     }
    619    ],
    620    "source": [
    621     "rets_7030z = erk.bt_mix(rets_eq, rets_zc, allocator=erk.fixedmix_allocator, w1=0.7)\n",
    622     "plt.figure(figsize=(12, 6))\n",
    623     "#sns.distplot(terminal_values(rets_eq), color=\"red\", label=\"100% Equities\")\n",
    624     "#sns.distplot(terminal_values(rets_bonds), color=\"blue\", label=\"100% Bonds\")\n",
    625     "sns.distplot(erk.terminal_values(rets_7030b), color=\"orange\", label=\"70/30 Equities/Bonds\")\n",
    626     "#sns.distplot(terminal_values(rets_g8020), color=\"green\", label=\"Glide 80 to 20\")\n",
    627     "sns.distplot(erk.terminal_values(rets_7030z), color=\"grey\", label=\"70/30 Equities/Zeros\")\n",
    628     "plt.legend();"
    629    ]
    630   },
    631   {
    632    "cell_type": "markdown",
    633    "metadata": {},
    634    "source": [
    635     "### Conclusion\n",
    636     "\n",
    637     "Static or Naive risk budgeting involves allocating between the PSP and GHP using either a simple fixed mix or a blind glidepath. These can reduce the downside risk but come at the cost the expected return, and cannot be used to secure a minimum acceptable level of wealth or liabilities. In the next session, we'll examine dynamic approaches that will address the challenge of meeting a set of future liabilities such as replacement income, or a required level of wealth in the future.\n",
    638     "\n",
    639     "Before that, add the following code to the risk kit:\n",
    640     "\n",
    641     "```python\n",
    642     "def bt_mix(r1, r2, allocator, **kwargs):\n",
    643     "    \"\"\"\n",
    644     "    Runs a back test (simulation) of allocating between a two sets of returns\n",
    645     "    r1 and r2 are T x N DataFrames or returns where T is the time step index and N is the number of scenarios.\n",
    646     "    allocator is a function that takes two sets of returns and allocator specific parameters, and produces\n",
    647     "    an allocation to the first portfolio (the rest of the money is invested in the GHP) as a T x 1 DataFrame\n",
    648     "    Returns a T x N DataFrame of the resulting N portfolio scenarios\n",
    649     "    \"\"\"\n",
    650     "    if not r1.shape == r2.shape:\n",
    651     "        raise ValueError(\"r1 and r2 should have the same shape\")\n",
    652     "    weights = allocator(r1, r2, **kwargs)\n",
    653     "    if not weights.shape == r1.shape:\n",
    654     "        raise ValueError(\"Allocator returned weights with a different shape than the returns\")\n",
    655     "    r_mix = weights*r1 + (1-weights)*r2\n",
    656     "    return r_mix\n",
    657     "\n",
    658     "\n",
    659     "def fixedmix_allocator(r1, r2, w1, **kwargs):\n",
    660     "    \"\"\"\n",
    661     "    Produces a time series over T steps of allocations between the PSP and GHP across N scenarios\n",
    662     "    PSP and GHP are T x N DataFrames that represent the returns of the PSP and GHP such that:\n",
    663     "     each column is a scenario\n",
    664     "     each row is the price for a timestep\n",
    665     "    Returns an T x N DataFrame of PSP Weights\n",
    666     "    \"\"\"\n",
    667     "    return pd.DataFrame(data = w1, index=r1.index, columns=r1.columns)\n",
    668     "\n",
    669     "def terminal_values(rets):\n",
    670     "    \"\"\"\n",
    671     "    Computes the terminal values from a set of returns supplied as a T x N DataFrame\n",
    672     "    Return a Series of length N indexed by the columns of rets\n",
    673     "    \"\"\"\n",
    674     "    return (rets+1).prod()\n",
    675     "\n",
    676     "def terminal_stats(rets, floor = 0.8, cap=np.inf, name=\"Stats\"):\n",
    677     "    \"\"\"\n",
    678     "    Produce Summary Statistics on the terminal values per invested dollar\n",
    679     "    across a range of N scenarios\n",
    680     "    rets is a T x N DataFrame of returns, where T is the time-step (we assume rets is sorted by time)\n",
    681     "    Returns a 1 column DataFrame of Summary Stats indexed by the stat name \n",
    682     "    \"\"\"\n",
    683     "    terminal_wealth = (rets+1).prod()\n",
    684     "    breach = terminal_wealth < floor\n",
    685     "    reach = terminal_wealth >= cap\n",
    686     "    p_breach = breach.mean() if breach.sum() > 0 else np.nan\n",
    687     "    p_reach = breach.mean() if reach.sum() > 0 else np.nan\n",
    688     "    e_short = (floor-terminal_wealth[breach]).mean() if breach.sum() > 0 else np.nan\n",
    689     "    e_surplus = (cap-terminal_wealth[reach]).mean() if reach.sum() > 0 else np.nan\n",
    690     "    sum_stats = pd.DataFrame.from_dict({\n",
    691     "        \"mean\": terminal_wealth.mean(),\n",
    692     "        \"std\" : terminal_wealth.std(),\n",
    693     "        \"p_breach\": p_breach,\n",
    694     "        \"e_short\":e_short,\n",
    695     "        \"p_reach\": p_reach,\n",
    696     "        \"e_surplus\": e_surplus\n",
    697     "    }, orient=\"index\", columns=[name])\n",
    698     "    return sum_stats\n",
    699     "\n",
    700     "def glidepath_allocator(r1, r2, start_glide=1, end_glide=0.0):\n",
    701     "    \"\"\"\n",
    702     "    Allocates weights to r1 starting at start_glide and ends at end_glide\n",
    703     "    by gradually moving from start_glide to end_glide over time\n",
    704     "    \"\"\"\n",
    705     "    n_points = r1.shape[0]\n",
    706     "    n_col = r1.shape[1]\n",
    707     "    path = pd.Series(data=np.linspace(start_glide, end_glide, num=n_points))\n",
    708     "    paths = pd.concat([path]*n_col, axis=1)\n",
    709     "    paths.index = r1.index\n",
    710     "    paths.columns = r1.columns\n",
    711     "    return paths\n",
    712     "\n",
    713     "```\n"
    714    ]
    715   },
    716   {
    717    "cell_type": "code",
    718    "execution_count": null,
    719    "metadata": {},
    720    "outputs": [],
    721    "source": []
    722   }
    723  ],
    724  "metadata": {
    725   "kernelspec": {
    726    "display_name": "Python 3",
    727    "language": "python",
    728    "name": "python3"
    729   },
    730   "language_info": {
    731    "codemirror_mode": {
    732     "name": "ipython",
    733     "version": 3
    734    },
    735    "file_extension": ".py",
    736    "mimetype": "text/x-python",
    737    "name": "python",
    738    "nbconvert_exporter": "python",
    739    "pygments_lexer": "ipython3",
    740    "version": "3.8.8"
    741   }
    742  },
    743  "nbformat": 4,
    744  "nbformat_minor": 2
    745 }