Backtesting.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#daily volatility estimates\n",
    "#computed at intraday estimation points, with exponentially weighted moving standard deviation\n",
    "\n",
    "def getDailyVol(close, span0=100):\n",
    "    #daily vol, reindexed to close\n",
    "    df0 = close.index.searchsorted(close.index-pd.Timedelta(days=1))\n",
    "    df0 = df0[df0>0]\n",
    "    df0 = pd.Series(close.index[df0-1], index=close.index[close.shape[0]-df0.shape[0]:])\n",
    "    df0 = close.loc[df0.index]/close.loc[df0.values].values-1 #daily returns\n",
    "    df0 = df0.ewm(span=span0).std()\n",
    "    return df0    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#triple barrier method \n",
    "#args = close: series of prices \n",
    "#events: df with columns: t1: timestamp of vertical barrier, trgt: unit width of horizontal bars, \n",
    "#ptSl: a list of two non-negative float values: ptSl[0]: the factor that multiplies trgt to set the width of the upper barrier, ptSl[1]: the factor that multiples trgt to set the width of the lower barrier\n",
    "#molecule: a list with the subset of event indices that will be processed by a single thread.\n",
    "\n",
    "def applyPtSlOnT1(close, events, ptSl, molecule):\n",
    "    #apply stop loss/profit taking, if it takes place before end of t1(end of event)\n",
    "    events_ = events.loc[molecule]\n",
    "    out = events_[['t1']].copy(deep=True)\n",
    "    if ptSl[0]>0:\n",
    "        pt=ptSl[0]*events_['trgt']\n",
    "    else:\n",
    "        pt = pd.series(index=events.index) #NaNs\n",
    "    if ptSl[1]>0:\n",
    "        sl=-ptSl[1]*events_['trgt']\n",
    "    else: \n",
    "        sl = pd.series(index=events.index) #NaNs\n",
    "    for loc, t1 in events_['t1'].fillna(close.index[-1]).iteritems():\n",
    "        df0 = close[loc:t1] #path prices\n",
    "        df0 = (df0/close[loc]-1)*events_.at[loc,'side'] #path returns\n",
    "        out.loc[loc, 'sl'] = df0[df0<sl[loc]].index.min() #earliest stop loss\n",
    "        out.loc[loc, 'pt'] = df0[df0>pt[loc]].index.min() #earliest profit taking\n",
    "    return out \n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#learning side and size of bet\n",
    "\n",
    "#function get events takes args\n",
    "#close: series of prices\n",
    "#tEvents: timeindex containing the time series that will see every triple barrier, selected by event sampling(potentially CUSUM filter)\n",
    "#ptSl: same as above\n",
    "#t1: series with timestamps of vertical barriers\n",
    "#trgt: series of targets, expressed in absolute returns\n",
    "#minRet: the minimum target return return required for running a triple barrier search\n",
    "#numThreads: the number of threads concurrently used by the function\n",
    "\n",
    "def getEvents(close, tEvents, ptSl, trgt, minRet, numthreads, t1=False):\n",
    "    #1) get target\n",
    "    trgt = trgt.loc[tEvents]\n",
    "    trgt = trgt[trgt>minRet]\n",
    "    #2) get t1 (max holding period)\n",
    "    if t1 is False:\n",
    "        t1 = pd.Series(pd.NaT, index=tEvents)\n",
    "    #form events object, apply stop loss on t1\n",
    "    side_ = pd.Series(1.,index=trgt.index)\n",
    "    events = pd.concat({'t1':t1, 'trgt':trgt, 'side': side_}, axis=1).dropna(subset=['trgt'])\n",
    "    df0 = mpPandasObj(func=applyPtSlOnT1,pdObj=('molecule',events.index),numThreads=numThreads, close=close, events=events, ptSl=[ptSl,ptSl])\n",
    "    events['t1']=df0.dropna(how='all').min(axis=1) #pd.min ignores NaN\n",
    "    events = events.drop('side',axis=1)\n",
    "    return events"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#define vertical barrier, to be (optionally) passed as t1 in getEvents\n",
    "def defineT1(close, tEvents):\n",
    "    t1 = close.index.searchSorted(tEvents+pd.Timedelta(days=numDays))\n",
    "    t1 = t1[t1<close.shape[0]]\n",
    "    t1 = pd.Series(close.index[t1],index=tEvents[:t1.shape[0]]) #Nans at end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#labeling for side and size\n",
    "def getBins(event,close):\n",
    "    #1) prices aligned with events\n",
    "    events_ = events.dropna(subset=['t1'])\n",
    "    px = events_.index.union(events_['t1'].values).drop_duplicates()\n",
    "    px = close.reindex(px, method='bfill')\n",
    "    #create out object\n",
    "    out = pd.DataFrame(index=events_.index)\n",
    "    out['ret'] = px.loc[events_['t1'].values].values/px.loc[events_.index]-1\n",
    "    out['bin'] = np.sign(out['ret'])\n",
    "    return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#meta labeling for bet sizing \n",
    "#want to build a secondary ml model that learns how to use a primary exogenous model \n",
    "#modify getEvents to include a side arg\n",
    "#ptSl[0] : upper barrier, ptSl[1] : lower barrier\n",
    "def getEvents(close, tEvents, ptSl, trgt, minRet, numThreads, t1=False, side=None):\n",
    "    # 1) get target\n",
    "    trgt = trgt.loc[tEvents]\n",
    "    trgt = trgt[trgt>minRet]\n",
    "    # 2) get max holding peried \n",
    "    if t1 is False:\n",
    "        t1 = pd.Series(pd.NaT,index=tEvents)\n",
    "    # form event object, apply stop loss on t1\n",
    "    if side is None:\n",
    "        side_, ptSl_ = pd.Series(1.,index=trgt.index), [ptSl[0],ptSl[0]]\n",
    "    else:\n",
    "        side_,ptSl_ = side.loc[trgt.index], ptS1[:2]\n",
    "    events = pd.concat({'t1':t1, 'trgt':trgt, 'side':side_}, axis=1).dropna(subset=['trgt'])\n",
    "    df0 = mpPandasObj(func=applyPtSlOnT1, pdObj=('molecule', events.index), numThreads=numThreads, close=inst['Close'],events=events,ptSl=ptSl_)\n",
    "    events['t1']=df0.dropna(how='all').min(axis=1)\n",
    "    if side is None:\n",
    "        events=events.drop('side', axis=1)\n",
    "    return events"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "#expand get bins to incorporate meta labeling \n",
    "def getBins(events, close):\n",
    "    '''\n",
    "    Compute events outcome (including side information if applicable)\n",
    "    -events.index is events starttime\n",
    "    -events['t1'] is events endtime\n",
    "    -events['trgt'] is events target\n",
    "    -events['side'] (optional) implies the algos position side \n",
    "    Case 1: ('side' not in events): bin in (-1, 1) <- label by price action\n",
    "    Case 2: (side in events): bin in (0,1) <- label by Pnl'''\n",
    "    #1) prices aligned with events\n",
    "    events_ = events.dropna(subset=['t1'])\n",
    "    px = events_.index.union(events_['t1'].values).drop_duplicates()\n",
    "    px = close.redindex(px, method='bfill')\n",
    "    #create an out object\n",
    "    out = pd.DataFrame(index=events_.index)\n",
    "    out['ret']=px.loc[events_['t1'].values].values/px.loc[events_.index]-1\n",
    "    if 'side' in events_:\n",
    "        out['ret']*=events_['side'] #meta labeling\n",
    "    out['bin']=np.sign(out['ret'])\n",
    "    if 'side' in events_:\n",
    "        out.loc[out['ret']<=0,'bin']=0 #meta labeling\n",
    "    return out \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "#possible output values are now just 1,0... making this a binary classification problem, take the bet or pass. \n",
    "#with this in mind we can determine the size of the bet by the classification confidence of the model when output is 1\n",
    "\n",
    "#drop underused labels to improve accuracy of model\n",
    "def dropLabels(events, minPtc=.05):\n",
    "    #apply weights, drop labels with insufficient examples\n",
    "    while True: \n",
    "        df0 = event['bin'].value_counts(normalize=True)\n",
    "        if dfo.min()>minPct or df0.shape[0]<3:\n",
    "            break\n",
    "        print('dropped label', df0.argmin(), df0.min())\n",
    "        events = events[events['bin']!=df0.argmin()]\n",
    "    return events"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}