Micro-Price Reproduction.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import os\n",
    "import matplotlib.pyplot as plt\n",
    "from IPython.core.interactiveshell import InteractiveShell\n",
    "InteractiveShell.ast_node_interactivity = \"all\"\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "from scipy.linalg import block_diag\n",
    "from scipy.linalg import eig\n",
    "\n",
    "\n",
    "os.chdir('/Users/shaileshkakkar/Desktop/CryptoData/LatestData/Data/ETHBTC/')\n",
    "filePath = os.getcwd() + '/PartialBookData.txt'\n",
    "#print filePath\n",
    "data = pd.read_csv(filePath)\n",
    "data['Spread'] = 100*(data['ask1'] - data['bid1'])/data['bid1']\n",
    "data['MidPrice'] = (data['ask1'] + data['bid1'])/2\n",
    "data['CompositePrice'] = (data['ask1'] * data['bidVol1'] + data['bid1']*data['askVol1'])/(data['askVol1'] + data['bidVol1'])\n",
    "data['MidPriceReturn'] = data['MidPrice'].pct_change()\n",
    "#Convert to time stamp specifying that the time is in ms\n",
    "data['LocalTime'] = data['LocalTime'].apply(lambda x : pd.to_datetime(x, unit= 'ms') )\n",
    "data.index = data['LocalTime']\n",
    "#Convert it into snapshot data with 1 second granularity\n",
    "data = data.resample('1000L',closed = 'left', label='right', how = 'last')\n",
    "#Fill all the NA values with the last observed values\n",
    "data = data.ffill()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x109dc3d10>"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5,1,u'Histogram of the observed spread in the pair ETHBTC')"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x10e86d050>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "data['Spread'] = 100*(data['ask1'] - data['bid1'])/data['bid1']\n",
    "data['Spread'].plot(kind = 'hist', bins = 21, xlim = [0.01, 0.3])\n",
    "plt.title('Histogram of the observed spread in the pair ETHBTC')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As seen above, the spread of the currency pair remains less than 10bps most of the times. It is interesting to note, since the exchange fee for the market making( buy + sell cost) is 10 bps on Binance if the market making agent chooses to pay the fee in BNB, is is more otherwise. This points to perhaps rebate being provided to some key market maker players that is not available to others.\n",
    "\n",
    "Also, the % of instances where there is any change in the bid or ask price is 48.41% and bid-ask crossover occurs at 3.39% of the times. \n",
    "\n",
    "Note that the data is sampled here with a 1 second frequency, and ETHBTC being a highly liquid pair, these numbers make sense."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "48.4110462791\n"
     ]
    }
   ],
   "source": [
    "# % of Instances where either the best bid or the best ask has moved\n",
    "print 100.*sum(data['MidPriceReturn'] != 0)/len(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.3942799716972427"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Percentage of events where bid-ask crossover occured\n",
    "100.* sum( (data['ask1'] <= data['bid1'].shift(1)) | (data['bid1'] >= data['ask1'].shift(1)) ) / len(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def prep_data_sym(T,n_imb,dt,n_spread,hist):\n",
    "    data.rename(columns={'bid1': 'bid'}, inplace=True)\n",
    "    data.rename(columns={'ask1': 'ask'}, inplace=True)\n",
    "    data.rename(columns={'askVol1': 'as'}, inplace=True)\n",
    "    data.rename(columns={'bidVol1': 'bs'}, inplace=True)\n",
    "    data.rename(columns={'LocalTime': 'time'}, inplace=True)    \n",
    "    #Removed data(last param) from the original function\n",
    "    spread=T.ask-T.bid\n",
    "    ticksize=np.round(min(spread.loc[spread>0])*1e6)/1e6\n",
    "    T.spread=T.ask-T.bid\n",
    "    # adds the spread and mid prices\n",
    "    T['spread']=np.round((T['ask']-T['bid'])/ticksize)*ticksize\n",
    "    T['mid']=(T['bid']+T['ask'])/2\n",
    "\n",
    "    #filter out spreads >= n_spread\n",
    "    T = T.loc[(T.spread <= n_spread*ticksize) & (T.spread>0)]\n",
    "    T['imb']=T['bs']/(T['bs']+T['as'])\n",
    "    T['wmid']=T['imb']*T['ask']+(1-T['imb'])*T['bid']\n",
    "\n",
    "    #discretize imbalance into percentiles\n",
    "    T['imb_bucket'] = pd.qcut(T['imb'], n_imb, labels=False)\n",
    "    T['next_mid']=T['mid'].shift(-dt)\n",
    "    T['next_wmid']=T['wmid'].shift(-dt)\n",
    "\n",
    "    #step ahead state variables\n",
    "    T['next_spread']=T['spread'].shift(-dt)\n",
    "    T['next_time']=T['time'].shift(-dt)\n",
    "    T['next_imb_bucket']=T['imb_bucket'].shift(-dt)\n",
    "\n",
    "    # step ahead change in price\n",
    "    T['dM']=np.round((T['next_mid']-T['mid'])/ticksize*2)*ticksize/2\n",
    "    T['dW']=T['next_wmid']-T['wmid']\n",
    "    T = T.loc[(T.dM <= ticksize*1.1) & (T.dM>=-ticksize*1.1)]\n",
    "\n",
    "    #Getting the next step done\n",
    "    T2 = T.copy(deep=True)\n",
    "    T2['imb_bucket']=n_imb-1-T2['imb_bucket']\n",
    "    T2['next_imb_bucket']=n_imb-1-T2['next_imb_bucket']\n",
    "    T2['dM']=-T2['dM']\n",
    "    T2['dW']=-T2['dW']\n",
    "    T2['mid']=-T2['mid']\n",
    "    T2['wmid']=-T2['wmid']\n",
    "    T=pd.concat([T,T2])\n",
    "    T.index = pd.RangeIndex(len(T.index))\n",
    "    if hist<>'off':\n",
    "        histogram=pd.DataFrame.hist(T, column='spread')\n",
    "    return T,ticksize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [],
   "source": [
    "def estimate_old(T):\n",
    "    no_move=T[T['dM']==0]\n",
    "    no_move_counts=no_move.pivot_table(index=[ 'next_imb_bucket'], \n",
    "                     columns=['spread', 'imb_bucket'], \n",
    "                     values='time',\n",
    "                     fill_value=0, \n",
    "                     aggfunc='count').unstack()\n",
    "\n",
    "    #print no_move_counts\n",
    "    Q_counts=np.resize(np.array(no_move_counts[0:(n_imb*n_imb)]),(n_imb,n_imb))\n",
    "    # loop over all spreads and add block matrices\n",
    "    for i in range(1,n_spread):\n",
    "        Qi=np.resize(np.array(no_move_counts[(i*n_imb*n_imb):(i+1)*(n_imb*n_imb)]),(n_imb,n_imb))\n",
    "        Q_counts=block_diag(Q_counts,Qi)\n",
    "    #print Q_counts\n",
    "    move_counts=T[(T['dM']<>0)].pivot_table(index=['dM'], \n",
    "                         columns=['spread', 'imb_bucket'], \n",
    "                         values='time',\n",
    "                         fill_value=0, \n",
    "                         aggfunc='count').unstack()\n",
    "\n",
    "    R_counts=np.resize(np.array(move_counts),(n_imb*n_spread,4))\n",
    "    T1=np.concatenate((Q_counts,R_counts),axis=1).astype(float)\n",
    "    for i in range(0,n_imb*n_spread):\n",
    "        T1[i]=T1[i]/T1[i].sum()\n",
    "    Q=T1[:,0:(n_imb*n_spread)]\n",
    "    R1=T1[:,(n_imb*n_spread):]\n",
    "\n",
    "    K=np.array([-0.01, -0.005, 0.005, 0.01])\n",
    "    move_counts=T[(T['dM']<>0)].pivot_table(index=['spread','imb_bucket'], \n",
    "                     columns=['next_spread', 'next_imb_bucket'], \n",
    "                     values='time',\n",
    "                     fill_value=0, \n",
    "                     aggfunc='count') #.unstack()\n",
    "\n",
    "    R2_counts=np.resize(np.array(move_counts),(n_imb*n_spread,n_imb*n_spread))\n",
    "    T2=np.concatenate((Q_counts,R2_counts),axis=1).astype(float)\n",
    "\n",
    "    for i in range(0,n_imb*n_spread):\n",
    "        T2[i]=T2[i]/T2[i].sum()\n",
    "    R2=T2[:,(n_imb*n_spread):]\n",
    "    Q2=T2[:,0:(n_imb*n_spread)]\n",
    "    G1=np.dot(np.dot(np.linalg.inv(np.eye(n_imb*n_spread)-Q),R1),K)\n",
    "    B=np.dot(np.linalg.inv(np.eye(n_imb*n_spread)-Q),R2)\n",
    "    \n",
    "    return G1,B,Q,Q2,R1,R2,K"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_next_price_moves(T):\n",
    "    T['npm']=np.nan\n",
    "    T['npm'].loc[(T['dM'] <>0)]=np.round(T['dM'].loc[(T['dM'] <>0)] /ticksize*2)*ticksize/2\n",
    "    T['npm']=T['npm'].bfill()\n",
    "    T = T.loc[(T.npm <= ticksize*1.1)& (T.npm>=-ticksize*1.1) ]\n",
    "    T['nnpm']=np.nan\n",
    "    T['nnpm'].loc[(T['dM'] <>0)]=T['dM'].loc[(T['dM'] <>0)]+T['npm'].shift(-1).loc[(T['dM'] <>0)]\n",
    "    T['nnpm']=T['nnpm'].bfill()\n",
    "    T = T.loc[(T.nnpm <= ticksize*2.1)& (T.nnpm>=-ticksize*2.1) ]\n",
    "    T['nnnpm']=np.nan\n",
    "    T['nnnpm'].loc[(T['dM'] <>0)]=T['dM'].loc[(T['dM'] <>0)]+T['nnpm'].shift(-1).loc[(T['dM'] <>0)]\n",
    "    T['nnnpm']=T['nnnpm'].bfill()\n",
    "    T = T.loc[(T.nnnpm <= ticksize*3.1)& (T.nnnpm>=-ticksize*3.1) ]\n",
    "    T['nnnnpm']=np.nan\n",
    "    T['nnnnpm'].loc[(T['dM'] <>0)]=T['dM'].loc[(T['dM'] <>0)]+T['nnnpm'].shift(-1).loc[(T['dM'] <>0)]\n",
    "    T['nnnnpm']=T['nnnnpm'].bfill()\n",
    "    T = T.loc[(T.nnnnpm <= ticksize*4.1)& (T.nnnnpm>=-ticksize*4.1) ]\n",
    "    T['nnnnnpm']=np.nan\n",
    "    T['nnnnnpm'].loc[(T['dM'] <>0)]=T['dM'].loc[(T['dM'] <>0)]+T['nnnnpm'].shift(-1).loc[(T['dM'] <>0)]\n",
    "    T['nnnnnpm']=T['nnnnnpm'].bfill()\n",
    "    T = T.loc[(T.nnnnpm <= ticksize*5.1)& (T.nnnnpm>=-ticksize*5.1) ]\n",
    "    T['nnnnnnpm']=np.nan\n",
    "    T['nnnnnnpm'].loc[(T['dM'] <>0)]=T['dM'].loc[(T['dM'] <>0)]+T['nnnnnpm'].shift(-1).loc[(T['dM'] <>0)]\n",
    "    T['nnnnnnpm']=T['nnnnnnpm'].bfill()\n",
    "    T = T.loc[(T.nnnnpm <= ticksize*6.1)& (T.nnnnpm>=-ticksize*6.1) ]\n",
    "    return T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_Gstar(ticker,G1,B,T):\n",
    "    G2=np.dot(B,G1)+G1\n",
    "    G3=G2+np.dot(np.dot(B,B),G1)\n",
    "    G4=G3+np.dot(np.dot(np.dot(B,B),B),G1)\n",
    "    G5=G4+np.dot(np.dot(np.dot(np.dot(B,B),B),B),G1)\n",
    "    G6=G5+np.dot(np.dot(np.dot(np.dot(np.dot(B,B),B),B),B),G1)\n",
    "    for i in range(0,n_spread):\n",
    "        plt.plot(imb,G6[(0+i*n_imb):(n_imb+i*n_imb)],label=\"spread = \"+str(i+1))\n",
    "        \n",
    "    #plt.plot(imb,res6step[(0+i*n_imb):(n_imb+i*n_imb)],label='$E[M_{T6}-M_t]$ ')\n",
    "    plt.ylim(-0.005,0.005)\n",
    "    plt.legend(loc='upper left')\n",
    "    plt.title(ticker+' microprice adjustment')\n",
    "    plt.xlabel('Imbalance')\n",
    "    return G6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_imb=7\n",
    "n_spread=2\n",
    "dt=1\n",
    "data = pd.read_csv(filePath)\n",
    "ticker='ETHBTC'\n",
    "T,ticksize=prep_data_sym(data,n_imb,dt,n_spread,'off')\n",
    "imb=np.linspace(0,1,n_imb)\n",
    "G1,B,Q,Q2,R1,R2,K=estimate_old(T)\n",
    "T=compute_next_price_moves(T)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x10fc73150>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "G6=plot_Gstar(ticker,G1,B,T)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.figure.Figure at 0x10eac2bd0>"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "<Container object of 3 artists>"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "<Container object of 3 artists>"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x10fb80a10>"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5,1,u'ETHBTC microprice vs. empirical,spread=2')"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5,0,u'Imbalance')"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5,1,u'ETHBTC microprice vs. empirical,spread=2')"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x10eac2bd0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "dt = 30\n",
    "test['dM']=test['mid'].shift(dt)-test['mid']\n",
    "test['dW']=test['wmid'].shift(dt)-test['mid']\n",
    "grouped=test.groupby(['spread','imb_bucket'])\n",
    "test['dt']=(test['EventTime'].shift(-dt)-test['EventTime'])\n",
    "\n",
    "grouped=test.groupby(['spread','imb_bucket'])\n",
    "res1min=grouped['dM'].aggregate(np.mean)\n",
    "std1=grouped['dM'].aggregate(np.std)\n",
    "cnt1=grouped.count()['dM']\n",
    "\n",
    "grouped2=test.groupby(['spread','imb_bucket'])\n",
    "res1min2=grouped2['dW'].aggregate(np.mean)\n",
    "std12=grouped2['dW'].aggregate(np.std)\n",
    "cnt12=grouped2.count()['dW']\n",
    "\n",
    "i =1\n",
    "plt.figure()\n",
    "#plt.scatter(imb,g_star[(0+i*n_imb):(n_imb+i*n_imb)],label=\"G_star\",color='r',s=50)\n",
    "plt.errorbar(imb,res1min[(0+i*n_imb):(n_imb+i*n_imb)],yerr=np.sqrt(dt)*std1[(0+i*n_imb):(n_imb+i*n_imb)]/np.sqrt(cnt1[(0+i*n_imb):(n_imb+i*n_imb)]), capthick=5,label='empirical E[M_{t+'+str(dt)+'s}-M_t]')\n",
    "\n",
    "plt.errorbar(imb,res1min2[(0+i*n_imb):(n_imb+i*n_imb)],yerr=np.sqrt(dt)*std12[(0+i*n_imb):(n_imb+i*n_imb)]/np.sqrt(cnt12[(0+i*n_imb):(n_imb+i*n_imb)]), capthick=5,label='empirical E[M_{t+'+str(dt)+'s}-M_t]')\n",
    "plt.legend(loc='upper left')\n",
    "plt.title(ticker+' microprice vs. empirical,spread='+str(i+1))\n",
    "plt.xlabel('Imbalance')\n",
    "plt.title(ticker+' microprice vs. empirical,spread='+str(i+1))\n",
    "\n",
    "\n"
   ]
  }
 ],
 "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.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}