How To Be a Quant Trader – Experiments with QuantConnect

This post presents an analysis of the SPY returns process using the QuantConnect research platform.

QuantConnect is a strategy development platform that lets you research ideas, import data, create algorithms, and trade in the cloud, all in one place.  For this research, I’ve used their online research notebook, and it came preinstalled with all the libraries and data (intraday) I needed to complete the analysis at no cost. It’s very impressive indeed.

I love those predictions of the future from the past. It’s funny how the people viewed the future back then. You can see how their preconceived notions on the world were simply extrapolated forward into the future.

Consider a flying wooden car. They guessed that cars would have to be flying by then (Elon, do it already!) but they missed the fact that wood will no longer be the preferred material for building cars. Take look at this excellent article from the Independent.

The tale of beginner traders can be similar. They are deeply entrenched in their beliefs of how the market works, and they try to extrapolate based on those beliefs, never once questioning if they were right in the first place.

• Noob trader: I need to find the optimal ATR levels to place my trailing stop losses
• Quant trader: I need to research if the assumptions of a stop loss make sense in my trading strategy

Let’s see how a quant might approach starting to analyse a returns process…

The Backtest Cycle of Doom

When you’re doing research in financial data, you shouldn’t start from the perspective of trying to find a tradable strategy. Not right away, anyway. That can quickly lead you into what we call “The Backtest Cycle of Doom”.

You’ll eventually find a set of rules that made pretend money in your pretend trading, but almost certainly it won’t be anything but an overfit strategy. That’s not how a quant would approach the research phase.

A quant trader would start researching just for the sake of understanding, not goal seeking. They are trying to understanding what drives the returns process, and they’re fully aware that they’ll never completely understand it.

The Holy Grail Delusion

Beginner traders often think that the big banks the top hedge funds, the Illuminati, etc are hiding some sort of hidden algorithm that predicts the markets at will and prints money on demand.

A good quant trader knows that any edge they might have in the market is very noisy and will only manifest itself after a long period of time, so they stop chasing the holy grail, and they diversify sensibly across many different edges.

What follows is an example of basic analysis of the SPY returns process…

Example Research With QuantConnect Code

Using the Quantconnect ecosystem in a typical quant workflow.

We will be looking at:

1. Distribution of returns
2. Comparing SPY returns to a normal distribution
3. Researching possible seasonal patters in SPY returns
4. Auto-correlation of returns

Note: This code is meant to be used within QuantConnect research environment

# Import dependecies
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
plt.style.use('ggplot') #There is a positive correlation between chart pretiness and risk-adjusted returns
plt.rcParams['figure.figsize'] = [10, 7]

# QuantBook Analysis Tool 
# Load SPY historical data
qb = QuantBook()
spy = qb.AddEquity("SPY")
history = qb.History(qb.Securities.Keys, 5000, Resolution.Daily) #5000 days of SPY daily data

# Drop pandas level
history = history.reset_index().drop('symbol',axis=1)

# Calculate SPY returns and fillna 
history['returns'] = (history['close'].pct_change() * 100).fillna(0)

1. Analysing the return distribution

Now that we have SPY daily returns let’s quickly see what we’re dealing with.

history['returns'].describe()

count    5000.000000
mean        0.030071
std         1.235997
min       -11.638806
25%        -0.443536
50%         0.061797
75%         0.573180
max        11.360371
Name: returns, dtype: float64

Let’s look at the extreme values of returns ie max and min

history[history['returns'] == min(history['returns'])]

history[history['returns'] == max(history['returns'])]

The recent corona drawdown is the biggest single-day market drop in history, and we have the biggest up move in 2008.

Let’s look at the distribution of daily returns for the SPY

sns.distplot(history['returns'],label='Distribution of SPY returns')
plt.legend()

One thing that really stands out in financial assets returns distributions is the tails (read high kurtosis if you are a nerd). This will become more evident once we compare it to a true normal distribution.

2. Comparing to a normal distribution

Let’s first create some random data  and plot their distribution

random = np.random.normal(scale=1.23,size=500000)
sns.distplot(random,label='Returns sampled from normal distribution',color='blue')
plt.legend()
random_series = pd.Series(random)

There it is, a beautiful well behaved normal distribution, Let’s see how this compares to our SPY returns distribution.

sns.distplot(history['returns'],label='Distribution of SPY returns')
sns.distplot(random,label='Returns sampled from normal distribution')
plt.legend()

Now the high kurtosis of the SPY returns becomes even more apparent.

So far we’ve learned that:

• SPY returns do resemble random returns
• but they have big tails in their distribution
• which means we can expect outsized moves to the upside and downside, more so than a normal distribution would suggest.

Now let’s look at a simple workflow for researching, seasonal patterns in our financial data.

3. Researching possible seasonal patterns

So far we’ve looked at daily resolution returns data.

Now let’s look at hourly resolution data. Usually, this would cost you a bit of time and effort to get hold of, but it’s not a problem if you’re using QuantConnect.

spy_hour = qb.History(qb.Securities.Keys, timedelta(days=5000), Resolution.Hour) #5000 days of SPY hourly data
spy_hour = spy_hour.reset_index().drop('symbol',axis=1)
#Explode datetime into hours
spy_hour['hour'] = spy_hour['time'].apply(lambda x: x.hour)
#Calculate Hourly returns
spy_hour['returns'] = (spy_hour['close'].pct_change() * 100).fillna(0)
spy_hour.head()

sns.barplot(x='hour',y='returns',data=spy_hour)

Looking at Close to Close returns it seems to be a good idea to go long overnight, there are a few research papers that go into this effect in-depth.

Here is one that we’ve looked at https://papers.ssrn.com/sol3/papers.cfm?abstract_id=3546173 in our Trading Through Armageddon Bootcamp

If we use Open to Close returns the overnight effect from the hour 10 bar should not be there anymore

spy_hour['OC'] = (spy_hour['close']-spy_hour['open'])/spy_hour['open'] * 100
sns.barplot(x='hour',y='OC',data=spy_hour)

spy_hour.query("hour == 10")['returns'].cumsum().plot(label='Overnight Returns')
spy_hour.query("hour != 10")['returns'].cumsum().plot(label='Intraday Returns')
plt.legend()

#Remember our Daily dataset 
history['DOM'] = history['time'].apply(lambda x:x.day)
sns.barplot(x='DOM',y='returns',data=history)

from statsmodels.graphics.tsaplots import plot_acf
from statsmodels.tsa.stattools import acf
acf_plot = plot_acf(history['returns'])

history['rolling_lag_1'] = history['returns'].rolling(window=100).apply(lambda x:acf(x)[1],raw=True)
history['rolling_lag_1'].plot(label='Rolling 100 window ACF lag 1')
plt.axhline(history['rolling_lag_1'].mean(),label='Mean',linestyle='--',color='green')
plt.legend()

history['annVol'] = history['returns'].rolling(window=100).std() * np.sqrt(252)
history['annVol'].plot()

sns.regplot(x='annVol',y='rolling_lag_1',data=history)

sns.regplot(x='annVol',y='rolling_lag_1',data=history.loc['2000-01-01':'2005-01-01'],label='2000-2005')
plt.legend()

sns.regplot(x='annVol',y='rolling_lag_1',data=history.loc['2005-01-01':'2010-01-01'],label='2005-2010')
plt.legend()

sns.regplot(x='annVol',y='rolling_lag_1',data=history.loc['2010-01-01':'2015-01-01'],label='2010-2015')
plt.legend()

sns.regplot(x='annVol',y='rolling_lag_1',data=history.loc['2015-01-01':'2021-01-01'],label='2015-Now')
plt.legend()