ALPIMA Turbulence Indicator

Published in Research on 16th July 2020

In this notebook we will be using some of the features of ALPIMA's quant API, Tau to explore using the financial turbulence indicator in the design and testing of investment strategies. We will be basing this on the turbulence indicator laid out by Mark Kritzman and Yuanzhen Li in “Skulls, Financial Turbulence, and Risk Management” (2010).

Here the turbulence is defined as:


This will be large when there are:

  1. Shifts in price which are uncharacteristically large.
  2. Price movements that do not behave as expected based on the correlations between assets.

We will use this metric to create an indicator which can be used in a custom allocation engine.

Import Required Libraries and Set Up the Notebook

To start we need to import the libraries we will require, including components from Tau in addition to any standard Python libraries. We'll also use this section to define a few functions which we'll use later.



The Turbulence Indicator

To create our indicator we've calculated the turbulence of the following six indices which we consider to be reasonable proxies for the corresponding markets:

turbulence 0.png

To simplify the calculation we've assumed that the correlation between the returns and the mean returns are approximately time invariant, so can both just be calculated over the entire returns series. We then divide by the number of assets, to allow the value to be more comparable to setups with different numbers of assets.

We've saved the Turbulence Indicator we'll be using to the ALPIMA database. This can then be accessed within this notebook.

turbulence 3.png

Let's see what the turbulence indicator looks like over the last 20 years. Taking a 30 point rolling average to smooth the data, we can plot this using matplotlib.

turbulence 4.pngturbulence 5.png

As might have been expected, both the 2008 financial crash and the current coronavirus pandemic have led to the highest turbulence in the last 20 years. It will be events like this which we'll seek to mitigate against by using the indicator. The aim will be to switch out of a higher risk constituent to a lower risk constituent when we start to enter a period of high turbulence.

Create a Turbulence Indicator Engine

Let's build a very simple engine for testing purposes. Similarly to how B. Skuse used the BDIY Index in the prior piece, we'll use the turbulence indicator instrument to shift our allocation between a base low risk instrument and an high risk instument for high/low turbulence situations.

To start with let's use a simple model - when the ratio of the most recent change in the turbulence to the mean change in turbulence over the window is above 1 we will switch entirely to the low risk component, otherwise we'll fully allocate to our high risk component.

turbulence 6.png

Creating a Strategy

Let's now create a strategy using this new allocation engine. We'll allocate to VTI US Equity in periods of low turbulence, and TLT US Equity in periods of high turbulence. We will want to allocate relatively frequently, so we can successfully respond to spikes in turbulence so we'll use a rebalancing frequencey and window of 30 days.

It is worth noting that TLT is an asset that has become controversial given where US rates are. Those willing to reduce interest rate risk could chose to replace it with shorter-maturity versions, i.e. IEI or IEF.

turbulence 7.png

We can also quickly view this strategy within the ALPIMA platform to check that everything looks as expected.

turbulence 8.png

Exploring the Results

Now we have a strategy built we can use the functionality of both TAU and Python to explore the behaviour of it.

First if we look at the last few weights it looks like the engine is working as expected, with the weights switching to TLT during the recent coronavirus turbulence:

turbulence 9.png

Let's plot the index, using SPX as a benchmark. For this we can just use the inbuilt strategy method:

turbulence 10.png

turbulence 11.png

turbulence 12.png

It seems like even this very simple implimentation with the turbulence indicator performs much better than SPX. It is able to provide better returns while avoiding the substantial drawdowns and volatility which SPX experiences.

We can also look at how the strategy performs explicity over a high turbulence period. One of the powerful aspects of using Tau within a notebook like this is that we can access the underlying data too. Let's do this and just look at the performance from 2008 to 2010.

turbulence 13.png

turbulence 14.png

The turbulence strategy significantly outperforms SPX over this interval. Lets take a closer look at how the allocations of the constituents are behaving over this period.

turbulence 15.png

So it looks like even our very primative use of the indicator has been able to avoid the worst of the drops in VTI, however it potentially reallocates to VTI too soon, which leads to missing a substantial increase in TLT.

Let's also plot the weights against the turbulence to see what this looks like.

turbulence 16.png

So it seems that the strategy successfully allocates to TLT when the turbulence first increases around 2008-09, however the behaviour is perhaps not so sensible when allocating to TLT in 2009-02 when the turbulence is very much decreasing, even if the change in turbulence is less than the average in that window.

An improvement could be made by moving to a better gradient-based approach, such as using linear regression to calculate the gradient within the window, then make weighting decisions based on that.

We could also move from a binary weighting system to something where the high-risk component is de-weighted as the turbulence gradient is increasing, and incrementally re-allocated to when the turbulence gradient is decreasing, this would avoid the high turnover we currently have.


Using an ALPIMA Notebook , we have been able to successfully create a turbulence indicator and use it to drive a custom allocation engine with very promising results, especially during the market turbulence.

More work can be done to further refine the idea and evaluate the predictive power of the turbulence indicator.

For example, one could explore whether a more sophisticated, gradual switching logic, or on-the-fly turbulence calculation might improve results.

This is a good example of how the ALPIMA platform allows practitioners to prototype, explore and deploy investment strategies with ease, enabling more innovation and shortening the “go-to-market” time for new ideas.

Please contact us at to find out more.

Share this article

Copy link
Link copied to clipboard