Exponential Kernels with Latency in Hawkes Processes: Applications in Finance

As explained in [Toke 2011], a Hawkes process with an exponential kernel has its intensity described by:

For $P=1$ and $\lambda_{0}\left(t\right)=\lambda_{0}$ :

With stationarity condition:

And unconditional expected value of intensity:

Following [Toke 2011]:

Which is computed as:

Defining the function:

The recursion observed by [Ogata et al 1981] is:

And therefore the log-likelihood is:

For $P=1$ and $\lambda_{0}\left(t\right)=\lambda_{0}$ :

And:

Using tick we simulate 100 paths for different end times (100, 1000, 10000) for both the builtin ExpKernel and for a user-defined Time Function that mirrors an ExpKernel:

We use minimize from [scipy] with method ’SLSQP’; as pointed out in [Kisel 2017], it can handle both bounds (ensuring positivity of parameters) and constraints (ensuring the stationarity condition). The differences should be calculated at the start of the optimization process and passed to the likelihood function instead of being calculated inside the likelihood function.

For $P=1$ and $\lambda_{0}\left(t\right)=\lambda_{0}$ , with latency τ:

We can use the same (exponential) function and shift it to the right by the latency:

The new likelihoods are defined (for $P=1$ and $\lambda_{0}\left(t\right)=\lambda_{0}$) as:

With $R_{\tau}\left(1\right)=0$, and:

Even with the latency $\tau=0$, for each $t_{i}$ we pass $t_{i-1}$. But this enough to slow down the optimization, as observed while testing that the algorithm returns the same results as the previous one for latency zero and seen in Table 1.

We obtain the following results for 100 paths (parameters $\lambda_{0}=1.20$ , $\alpha=0.60$ and $\beta=0.80$) with the total running times in seconds (on a MacBook Pro 16-inch 2019, 2.4 GHz 8-core Intel Core i9, 64 GB 2667 MHz DDR4 RAM):

With latency $\tau=2$, we find that we can still recover the parameters of the kernel quite well (still 100 paths):

For $P=1$ and $\lambda_{0}\left(t\right)=\lambda_{0}$ :

With the recursion now:

And log-likelihood for each node m:

For $P=1$ and $\lambda_{0}\left(t\right)=\lambda_{0}$ :

With the recursion now:

And log-likelihood for each node m:

Now there is a choice on how to efficiently select $t_{k}^{n}$ on the recursion: either find the corresponding arrays (which could be empty) for each $\left\{t_{i-1}^{m},t_{i}^{m}\right\}$ pair with numpy.extract or find the appropriate $t_{i}^{m}$ for each $t_{k}^{n}$ using numpy.searchsorted and building a dictionary; we chose the latter.

To optimize it further all the arrays are padded so all accesses are on numpy.ndarrays (more details on the code - also see [numpy]).

A slower optimization can be done for more than one time series in parallel, with the advantage of enforcing symmetries on coefficients by re-defining the input $\theta$ with the same decays for blocks (e.g. on [Bacry et al 2016] instead of 16 different decays we can use 4 decays, as described further down the paper); the algorithm below shows the case where we optimize it for all the time series, but we can modify it to run on bid-ask pairs of time series.

With latency $\tau=2$ and two kernels we get good results (100 paths, method ’SLSQP’):

Here one must consider the latency of $250\mu s$ (as informed in [Eurex 2017]):

We have available data for 20 days (Apr-2014) on events P and T, from 8h to 22h (14 hours on each day), as described in https://github.com/X-DataInitiative/tick-datasets/tree/master/hawkes/bund. Because in some days we have late starts, and because liquidity late at night is not better, we consider events only from 10h to 18h, which represent more than 75% of all events (daily counts available on GitHub).

To get a better idea of the time scales involved, we calculate the descriptive statistics of each time series:

And we can see that between 10% and 15% of events within each time series happen less than $250\mu s$ after the previous event, and therefore should not be considered as being caused by that previous event. We can also see that the average time interval is considerably higher than the median time interval, which means that this distribution is more fat-tailed than an exponential distribution.

We run optimizations for the sum of (Bid+Ask) log-likelihoods where the kernel intensities are the same within diagonals: $\alpha\left(T_{a}\rightarrow P_{u}\right)=\alpha\left(T_{b}\rightarrow P_{d}\right)$ and $\alpha\left(T_{b}\rightarrow P_{u}\right)=\alpha\left(T_{a}\rightarrow P_{d}\right)$ and the kernel decays are the same within blocks $\beta\left(T_{a}\rightarrow P_{u}\right)=\beta\left(T_{b}\rightarrow P_{d}\right)=\beta\left(T_{b}\rightarrow P_{u}\right)=\beta\left(T_{a}\rightarrow P_{d}\right)$; so the total LL is optimized individually as $LL^{opt}=LL_{P_{a}+P_{b}}^{opt}+LL_{T_{a}+T_{b}}^{opt}$. We also run exploratory optimizations with completely independent intensities and decays, and tested different optimizer algorithms, in order to reduce the bounds for the parameters. The code (including initial values and bounds) is at the GitHub page, together with the spreadsheet with the results of the optimization (using the Differential Evolution, Powell and L-BFGS-B methods from [scipy]; Powell was the best-performing method). The parameters for $T\rightarrow T$ were the most unstable (charts in the Appendix).

We calculate the exogeneity ratio R between the number of exogenous events and the total number of events n for each event type i and day d as:

And these ratios are much higher than those found in [Bacry et al 2016], which can be explained as the reassignment of the events within the latency. Even then we find that it is reasonable to expect that a good part of the trades are exogenous (ie caused by reasons other than short-term dynamics of the order book). Most interestingly, events that change the mid-price (trades, cancels and replenishments) are (i) faster and (ii) more endogenous than trades that do not change the mid-price. Please note how the first chart of Figure 2 is similar to the first chart of Figure 7 in [Bacry et al 2016] after approximately $250\mu s$.

It’s not by chance that the decay on $T\rightarrow P$ and $P\rightarrow P$ kernels is about 3000; we can plot the first chart again but changing the x-axis to units of latency:

It’s expected that fast participants will act quickly on: (i) sharp imbalances by either canceling or consuming the remaining queue $\left(T_{a}\rightarrow P_{u}\right)$ (ii) filling in recent gaps $\left(P\rightarrow P\right)$ and that they will be able to react to the reactions as quickly as before, so the influence of the first event decays fast. We expect that Figure 3 will be found in different markets and different years (e.g. BUND futures in 2012, which had a latency of $1250\mu s$ instead of $250\mu s$).

The main differences found with [Bacry et al 2016] are on the anti-diagonals. For $P\rightarrow P$ we find that diagonals are stronger than anti-diagonals (even on a large tick asset such as the BUND future); to investigate this further a better breakdown of P into Cancels and Trades would help. For $P\rightarrow T$ our method is not able to learn negative intensities because of the log-likelihood, but none of the values reached the lower bound; average intensity was about 2%; although a change in mid-price will make limit orders with the same sign miss the fill and become diagonals in the sub-matrix $P\rightarrow P$ market orders would not be affected; but more importantly the speed and intensity of the $P\rightarrow P$ kernels ensure that gaps close quickly; we think that the introduction of the latency is enough to simplify the model such that negative intensities would not be necessary.

We have not tested a Sum of Exponentials model, but it might be interesting to fix the decays for the first exponential kernel at “known” values and see what we can find.