AFML 15.1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Strategy Risk\n",
    "\n",
    "Most of the functions below can be found under:\n",
    "\n",
    "* Backtest/stats_measure\n",
    "* Sample_data/make_data\n",
    "\n",
    "> Strategy risk is different from portfolio risk.\n",
    ">\n",
    "> Advance in Financial Machine Learning [2018], Marcos Lopez De Prado.\n",
    "\n",
    "Strategy risk is inherent within investment management style, method and technique, reflected as a mismatch between expectation and eventual outcome.\n",
    "\n",
    "While portfolio risk is directly derived from underlying assets itself.\n",
    "\n",
    "If you are keen on generating synthetic data for your research, copy the code snippets [Generate synthetic raw data](https://gist.github.com/boyboi86/5e00faf48f60abfdbe838fbdee269471) in my gist.\n",
    "\n",
    "Contact: boyboi86@gmail.com"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Num of CPU core:  4\n",
      "Machine info:  Windows-10-10.0.18362-SP0\n",
      "Python 3.7.4 (default, Aug  9 2019, 18:34:13) [MSC v.1915 64 bit (AMD64)]\n",
      "Numpy 1.18.5\n",
      "Pandas 1.0.4\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import research as rs\n",
    "from scipy.stats import norm, kurtosis\n",
    "from scipy.stats import skew as Skew\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def _target_sr(p: float = 0.5, freq: int = 52, ptsl: list = [0.02,-0.02], seed: int = None):\n",
    "    if seed is not None:\n",
    "        np.random.seed(seed)\n",
    "    rnd=np.random.binomial(n=1,p=p, size = freq)\n",
    "    x = [ptsl[0] if i == 1 else ptsl[1] for i in rnd]\n",
    "    mean = np.mean(x)\n",
    "    std = np.std(x)\n",
    "    return (mean, std, mean/std)\n",
    "\n",
    "def target_sr(p: float = 0.5, freq: int = 52, ptsl: list = [0.02,-0.02], n_run: int = 1000000, seed: int = None):\n",
    "    mean, std, sr = 0, 0, []\n",
    "    for n in np.arange(n_run):\n",
    "        _mean, _std, _sr = _target_sr(p = p, freq = freq, ptsl = ptsl, seed = seed)\n",
    "        mean += _mean\n",
    "        std += _std # std is only 0.1, because variance root\n",
    "        if _sr <= .2: sr.append(_sr)\n",
    "    mean = mean/n_run # var = 0.01 but std = 0.1\n",
    "    std = std/n_run\n",
    "    im_sr = mean/std\n",
    "    print(\"Mean: {0:.6f}\\nStd: {1:.6f}\\nSharpe Ratio: {2:.6f}\".format(mean, std, im_sr))\n",
    "    if len(sr) >0:\n",
    "        p =len(sr)/n_run\n",
    "        print(\"Probability of getting SR < 2.: {0}%\".format(100 * p))\n",
    "        return (mean, std, im_sr, sr)\n",
    "    else:\n",
    "        print(\"All SR >= 2\")\n",
    "        return (mean, std, im_sr)\n",
    "\n",
    "    \n",
    "def im_p(freq: int = 52, trgt_sr: int = 2., ptsl: list = [0.02, -0.02]):\n",
    "    pt, sl = ptsl[0], ptsl[1]\n",
    "    a = (freq + trgt_sr ** 2) * (pt - sl) ** 2\n",
    "    b = (2 * freq * sl - trgt_sr ** 2 * (pt-sl)) * (pt-sl)\n",
    "    c = freq * sl ** 2\n",
    "    p = (-b+(b ** 2 - 4*a*c) ** .5)/ (2*a)\n",
    "    print(\"\\nImplied Precision Rate Required: {0:.6f}\".format(p))\n",
    "    return p\n",
    "\n",
    "def im_freq(p: float = 0.6, trgt_sr: int = 2., ptsl: list = [0.02, -0.02]):\n",
    "    pt, sl = ptsl[0], ptsl[1]\n",
    "    freq = (trgt_sr * (pt - sl)) ** 2*p*(1-p)/((pt-sl)*p+sl)**2\n",
    "    print(\"\\nImplied Frequency Required: {0:.6f}\".format(freq))\n",
    "    return int(freq)\n",
    "\n",
    "def im_pt(freq: int, trgt_sr: float, p: float, sl: float):\n",
    "    pt = (sl * freq**(1/2)) / (trgt_sr * (p*(1-p))**(1/2) - p * freq**(1/2)) + sl\n",
    "    print(\"\\nImplied Profit-taking level: {0:.6f}\".format(pt))\n",
    "    return pt\n",
    "\n",
    "def im_sl(freq: int, p: float, pt: float, trgt_sr: float):\n",
    "    sl = (pt * (trgt_sr * (p*(1-p))**(1/2) - p * freq**(1/2))) / \\\n",
    "    (trgt_sr * (p*(1-p))**(1/2) - p * freq**(1/2) + freq**(1/2))\n",
    "    print(\"\\nImplied Stop-loss limit: {0:.6f}\".format(sl))\n",
    "    return sl"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note**\n",
    "\n",
    "According to the book, it was using random without a seed. \n",
    "\n",
    "Hence Monte-Carlos seems appropriate, but if you notice without a seed, it's impossible to get a consistant result.\n",
    "\n",
    "In order to see if the outcome is reliable, I included a probability measure to see if the return sharpe ratio is reliable.\n",
    "\n",
    "At least one of the criteria has to be fulfilled:\n",
    "\n",
    "* As long as Probability of getting SR below 2. is less than 50%.\n",
    "* All SR >= 2.\n",
    "\n",
    "The idea is simple, if we manage to reduce the probability of not attaining SR > 2, it would reflect in our probability.\n",
    "\n",
    "Likewise, if we were to improve SR, the probability of not getting SR < 2 will decrease (Since we manage to pull SR from origin).\n",
    "\n",
    "Hence, we can safely assume the SR is somewhat reliable (At least 2 >=).\n",
    "\n",
    "**Note**\n",
    "\n",
    "Before you intend to \"Annualize\" the return.\n",
    "\n",
    "Kindly refer to this [Stackoverflow](https://quant.stackexchange.com/questions/2260/how-to-annualize-sharpe-ratio)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean: 0.004003\n",
      "Std: 0.019395\n",
      "Sharpe Ratio: 0.206385\n",
      "Probability of getting SR < 2.: 52.896%\n"
     ]
    }
   ],
   "source": [
    "trgt_sr = 2.\n",
    "n_run = 100000\n",
    "p = 0.6\n",
    "freq = 52\n",
    "ptsl = [.02,-.02]\n",
    "\n",
    "\n",
    "trgt = target_sr(p = p, \n",
    "                 freq = freq, \n",
    "                 ptsl  = ptsl, \n",
    "                 n_run = n_run, \n",
    "                 seed = None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Implied Precision Rate Required: 0.633631\n",
      "Mean: 0.005347\n",
      "Std: 0.019068\n",
      "Sharpe Ratio: 0.280401\n",
      "Probability of getting SR < 2.: 33.526%\n"
     ]
    }
   ],
   "source": [
    "_p = im_p(freq = freq, trgt_sr = trgt_sr, ptsl = ptsl)\n",
    "\n",
    "p_trgt = target_sr(p = _p, #use implied precision\n",
    "                   freq = freq,\n",
    "                   ptsl  = ptsl,\n",
    "                   n_run = n_run,\n",
    "                   seed = None)\n",
    "\n",
    "chg_p = (_p - 0.6)/ 0.6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Implied Frequency Required: 96.000000\n",
      "Mean: 0.004006\n",
      "Std: 0.019487\n",
      "Sharpe Ratio: 0.205592\n",
      "Probability of getting SR < 2.: 48.728%\n"
     ]
    }
   ],
   "source": [
    "_freq = im_freq(p = p, trgt_sr = trgt_sr, ptsl = ptsl)\n",
    "\n",
    "f_trgt = target_sr(p = p,\n",
    "                   freq = _freq, #use implied freq\n",
    "                   ptsl  = ptsl,\n",
    "                   n_run = n_run,\n",
    "                   seed = None)\n",
    "\n",
    "chg_f = (_freq - 52)/52"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Implied Profit-taking level: 0.023092\n",
      "Mean: 0.005846\n",
      "Std: 0.020895\n",
      "Sharpe Ratio: 0.279754\n",
      "Probability of getting SR < 2.: 31.278%\n"
     ]
    }
   ],
   "source": [
    "_pt = im_pt(freq = freq, trgt_sr = trgt_sr, p = p, sl = ptsl[1])\n",
    "\n",
    "pt_trgt = target_sr(p = p,\n",
    "                    freq = freq,\n",
    "                    ptsl  = [_pt, ptsl[1]], #use implied profit taking\n",
    "                    n_run = n_run,\n",
    "                    seed = None)\n",
    "\n",
    "chg_pt = (_pt - 0.02)/0.02"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Implied Stop-loss limit: -0.017322\n",
      "Mean: 0.005062\n",
      "Std: 0.018101\n",
      "Sharpe Ratio: 0.279653\n",
      "Probability of getting SR < 2.: 31.444%\n"
     ]
    }
   ],
   "source": [
    "_sl = im_sl(freq = freq, p = p, pt = ptsl[0], trgt_sr = trgt_sr)\n",
    "\n",
    "sl_trgt = target_sr(p = p,\n",
    "                    freq = freq,\n",
    "                    ptsl  = [ptsl[0], _sl], #use implied stop loss\n",
    "                    n_run = n_run,\n",
    "                    seed = None)\n",
    "\n",
    "chg_sl = (_sl + 0.02)/ 0.02"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note**\n",
    "\n",
    "SR required is 0.2 (Equal to SR 2 in the book)\n",
    "\n",
    "It is not possible to achieve a SR 2, after running Monte-Carlos 100,000 times for theoriginal input.\n",
    "\n",
    "The Average Sharpe Ratio was around 2.\n",
    "\n",
    "On top of that it has a high risk of not achieve the intended amount with a low precision rate 0.6.\n",
    "\n",
    "We can assume that Sharpe Ratio of 2 not possible, probably below 2 with the given parameter. (Not viable Strategy)\n",
    "\n",
    "**Note**\n",
    "\n",
    "Minimal precision required: 0.6336306209562121\n",
    "\n",
    "Otherwise, our we will have high probability SR < 2.\n",
    "\n",
    "**Note**\n",
    "\n",
    "If the strategy was run on a daily basis. Trading days = 252.\n",
    "\n",
    "Min Bets Frequency Required: 96.0\n",
    "\n",
    "**Note**\n",
    "\n",
    "Profit-taking level should be around 2.4% at least.\n",
    "\n",
    "Optimal Profit-taking level: 0.023092\n",
    "\n",
    "**Note**\n",
    "\n",
    "Alternate Stop loss level should be around 1.8% at least to attain sharpe ratio 2.\n",
    "\n",
    "optimal stop loss limit: -0.017322"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "1 % change in precision will result in 14.344% change in SR\n",
      "\n",
      "1 % change in frequency will result in 0.066% change in SR\n",
      "\n",
      "1 % change in profit-taking will result in 5.159% change in SR\n",
      "\n",
      "1 % change in stop-loss will result in 5.949% change in SR\n",
      "\n"
     ]
    }
   ],
   "source": [
    "p_sr, f_sr = (p_trgt[2] * 10 - trgt_sr), (f_trgt[2] * 10 - trgt_sr)\n",
    "\n",
    "pt_sr, sl_sr = (pt_trgt[2] * 10 - trgt_sr), (sl_trgt[2] * 10 - trgt_sr)\n",
    "\n",
    "print(\"\\n1 % change in precision will result in {0:.3f}% change in SR\\n\".format(p_sr/ chg_p))\n",
    "print(\"1 % change in frequency will result in {0:.3f}% change in SR\\n\".format(f_sr/ chg_f))\n",
    "print(\"1 % change in profit-taking will result in {0:.3f}% change in SR\\n\".format(pt_sr/ chg_pt))\n",
    "print(\"1 % change in stop-loss will result in {0:.3f}% change in SR\\n\".format(sl_sr/ chg_sl))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conclusion\n",
    "\n",
    "Precision rate will result in the most change for SR in all 4 factors.\n",
    "\n",
    "Lowest hang fruit is practically the precision rate.\n",
    "\n",
    "       Precision Rate> Stop Loss> Profit Taking > Frequency\n",
    "\n",
    "Precision and Frequency will definitely affect the profit-taking and stop-loss.\n",
    "\n",
    "Ultimately based on the algorithm:\n",
    "\n",
    "* Low precision rate with high frequency = frequent stop-loss\n",
    "* High Precision rate with high frequency = frquenct profit-taking\n",
    "* Low precision with low frequency = less stop-loss triggered\n",
    "* High precision with low frequency = less profit-taking triggered\n",
    "\n",
    "With SR in mind, precision rate along with frequency play a major role, profit-taking and stop-loss limit is more \"reactive\" to the former 2.\n",
    "\n",
    "If you have low precision rate, having higher stop-loss and lower profit-taking limits might be a good idea.\n",
    "\n",
    "However, there is some trade-off between frequency and precision rate. But the changes might not be significant unless frequency is really large.\n",
    "\n",
    "**Note**\n",
    "\n",
    "If you are still not convinced, kindly refer to the mathematical formula above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mix_gauss(mu1: float, mu2: float, sig1: float, sig2: float, p: float, n_obs: int):\n",
    "    rtn1 = np.random.normal(mu1, sig1, size=int(n_obs * p))\n",
    "    rtn2 = np.random.normal(mu2,sig2, size=int(n_obs) - rtn1.shape[0])\n",
    "    rtn = np.append(rtn1,rtn2, axis = 0)\n",
    "    np.random.shuffle(rtn)\n",
    "    return rtn\n",
    "\n",
    "def prob_failure(rtn: float, freq: int, trgt_sr: float):\n",
    "    pos_rtn, neg_rtn = rtn[rtn>0].mean(), rtn[rtn<=0].mean()\n",
    "    p = rtn[rtn>0].shape[0]/ float(rtn.shape[0])\n",
    "    ptsl = [pos_rtn, neg_rtn]\n",
    "    threshold = im_p(freq = freq, trgt_sr = trgt_sr, ptsl = ptsl)\n",
    "    risk = norm.cdf(threshold, p, p * (1 - p))\n",
    "    print(\"Predicted Precision Pate: {0:.6f}\\n\".format(p))\n",
    "    return risk\n",
    "\n",
    "def strategy_failure(mu1: float, mu2: float, sig1: float, sig2: float, p: float, n_obs: int, freq: int, trgt_sr: float):\n",
    "    rtn = mix_gauss(mu1 = mu1,\n",
    "                    mu2 = mu2,\n",
    "                    sig1 = sig1,\n",
    "                    sig2 = sig2,\n",
    "                    p = p,\n",
    "                    n_obs = n_obs)\n",
    "    \n",
    "    _proba_failure = prob_failure(rtn = rtn,\n",
    "                                  freq = freq,\n",
    "                                  trgt_sr = trgt_sr)\n",
    "    \n",
    "    print(\"Strategy Failure Probability: {0:.5f}\".format(_proba_failure))\n",
    "    if _proba_failure> 0.05:\n",
    "        print(\"Discard Strategy; High risk indicated\")\n",
    "    else:\n",
    "        print(\"Accept Strategy; Moderate risk indicated\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note**\n",
    "\n",
    "The first 4 moments can be calculated:\n",
    "    \n",
    "1. Mean\n",
    "2. Variance\n",
    "3. Skewness\n",
    "4. Kurtosis\n",
    "\n",
    "**Note**\n",
    "\n",
    "Please learn to differentiate between raw moments and central moments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "1st mts: 0.051935647397381136\n",
      "2nd mts: 0.0640552864484995\n",
      "3rd mts: -3.073240499764973\n",
      "4th mts: 10.730370000180923\n",
      "\n",
      "Annualized Sharpe Ratio: 3.972064\n",
      "Benchmark: 0.165503\n",
      "\n",
      "At 5% significance level, Sharpe Ratio: 3.972064\n",
      "Accept Strategy, as indicated by PSR\n"
     ]
    }
   ],
   "source": [
    "mu1, mu2, sig1, sig2, p, n_obs = -.1, 0.06, 0.12, .03, .15, 12 * 2\n",
    "\n",
    "rtn = mix_gauss(mu1 = mu1,\n",
    "                mu2 = mu2,\n",
    "                sig1 = sig1,\n",
    "                sig2 = sig2,\n",
    "                p = p,\n",
    "                n_obs = n_obs)\n",
    "\n",
    "mean, std, skew, kurt = np.mean(rtn), np.std(rtn), Skew(rtn), kurtosis(rtn)\n",
    "\n",
    "print(\"\\n1st mts: {0}\\n2nd mts: {1}\\n3rd mts: {2}\\n4th mts: {3}\\n\".format(mean, std, skew, kurt))\n",
    "\n",
    "sr1 = rs.sharpe_ratio(rtn = rtn, rf_param = .0, t_days = 12 * 2)\n",
    "benchmark = mean/ (std * (12 * 2) ** 0.5)\n",
    "\n",
    "print(\"Annualized Sharpe Ratio: {0:.6f}\\nBenchmark: {1:.6f}\\n\".format(sr1, benchmark))\n",
    "\n",
    "proba = rs.proba_sr(obs_sr = sr1,\n",
    "                     benchmark_sr = benchmark,\n",
    "                     num_returns = 12 * 2,\n",
    "                     skew_returns = skew,\n",
    "                     kurt_returns = kurt)\n",
    "\n",
    "if proba > 0.95:\n",
    "    print(\"At 5% significance level, Sharpe Ratio: {0:.6f}\".format(sr1))\n",
    "    print(\"Accept Strategy, as indicated by PSR\")\n",
    "    trgt_sr = sr1\n",
    "else:\n",
    "    print(\"At 5% significance level, Sharpe Ratio: {0:.6f}\".format(sr1))\n",
    "    print(\"Discard Strategy, as indicated by PSR\")\n",
    "    trgt_sr = 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Implied Precision Rate Required: 0.872079\n",
      "Predicted Precision Pate: 0.791667\n",
      "\n",
      "Strategy Failure Probability: 0.68707\n",
      "Discard Strategy; High risk indicated\n"
     ]
    }
   ],
   "source": [
    "strategy_failure(mu1 = mu1,\n",
    "                 mu2 = mu2,\n",
    "                 sig1 = sig1,\n",
    "                 sig2 = sig2,\n",
    "                 p = p,\n",
    "                 n_obs = n_obs,\n",
    "                 freq = n_obs,\n",
    "                 trgt_sr= trgt_sr) # depends if they pass first test"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note**\n",
    "\n",
    "Because the data is randomly generated, hence the conclusion may not always be in line with learning outcome.\n",
    "\n",
    "But the \"correct\" answer seems to be accept strategy for PSR and discard strategy for Strat-Risk Metric."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Probabilistic SR vs Strategy Risk Metrics\n",
    "\n",
    "Which method is better? It depends.\n",
    "\n",
    "As demostrated in [AFML 14.1](https://github.com/boyboi86/AFML/blob/master/AFML%2014.1.ipynb)\n",
    "\n",
    "PSR tends to favor \"normal\" distributed returns.\n",
    "\n",
    "As a result, it will reject \"Too good or too bad to be true returns\". Hence it follows a gaussian shape as a measure based on benchmark provided.\n",
    "\n",
    "Strategy risk metric focus on key factor which determined the risk/ return that intended strategy might faced.\n",
    "\n",
    "As demostrated earlier in this exercise, key factor is precision rate which will impact around 14% SR per 1% PR change.\n",
    "\n",
    "Return distribution would most likely display asymmetrical returns and tends to be bias. (SR-maximization/ Return-driven)\n",
    "\n",
    "**Consider the below graph**\n",
    "\n",
    "The two graphs are generated with different properties:\n",
    "\n",
    "* Asymmetrical return with higher bias (Higher frequency/ lower variance)\n",
    "* Symmetrical return with higher variance (Lower Frequency/ lower bias)\n",
    "\n",
    "Notice there is an overlapping area between these 2 distributions, therefore there is a mutually inclusive area which both can agreed upon.\n",
    "\n",
    "As long as the back-test return distribution can fall within the overlapped region (The sweet spot between SR-maximization and realistic outcome).\n",
    "\n",
    "It will be favored and endorsed by both metrics. \n",
    "\n",
    "As such, these 2 methods can and are considered complementary to each other."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "psr_favor = np.random.normal(0, 2, 10000)\n",
    "strat_risk_favor = np.random.normal(2,1.5,10000)\n",
    "df = pd.DataFrame({'PSR Favor': psr_favor, 'SRM Favor': strat_risk_favor})\n",
    "df.plot(kind='kde', figsize=(12,8), grid=True)\n",
    "plt.axvline(x=0,ls='--',c='r')\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}