Fading the Gap Tutorial - Mean Reversion in QuantConnect - YouTube

Hi there, my name is Jared Broad, and in this Boot Camp tutorial we're going to be

looking into the fading the gap strategy. This strategy monitors the market for

gaps that occurred overnight, and then bets in the opposite direction assuming

that the market will mean revert. Here we're going to use scheduled events to

set up the scaffolding for our algorithm, and then we're going to use a rolling

window to calculate the price changes which occurred overnight. We're then

going to use a standard deviation indicator to try and eliminate a

parameter in our algorithm. So let's get started. First we're going to use

scheduled events to save the opening and closing prices for our algorithm. Here

we're going to use some time rules that we haven't previously seen, these are

AfterMarketOpen and BeforeMarketClose. As you'd expect these trigger the

scheduled event after the market opens and a few minutes before the market

closes. If you pass in zero here it will trigger

the scheduled event at exactly four o'clock on a traditional equities day.

So the first thing we need to do is create a scheduled event to run zero

minutes before the market closes or as the market closes at 4:00 p.m. We can

copy this code here and we want to run this every day before the market closes.

Then we need to pass in the event handler that we want to use, and we're

going to call an event handler here, ClosingBar. Let's create that method,

and while we're here let's create the other methods which are right here.

Finally another method here ClosePositions. Okay now we need another

scheduled event to run every day one minute after the market opens. At 9:30

exactly we don't have the full minute bar, so we need to wait for at least one

minute to get that opening price. Let's create a new scheduled event to

run after market open, one minute, and we want to call the opening bar event

handler. Okay, now finally we don't quite have the trading logic yet, but here

we're going to make sure that we close out our positions 45 minutes after the

market opens no matter what. So let's reuse the lot of this code here.

We want to do it 45 minutes later, and we want to call ClosePositions.

And then finally here we need to liquidate our position.

Now we're only trading Tesla, so we don't really need to pass in the symbol

here but it's always good to be safe. So now we're going to call ClosePositions

45 minutes after market open every single day. Okay let's see how we go.

Okay great, on to the next task. Here we're going to

create a rolling window. The rolling window will be used to save the price of

yesterday and the price of today, so that we can calculate price movement

overnight. And this will be the foundation of the gap calculation that

we do later. So a rolling window is kind of the opposite of an array. An array

when you and items get added on to the bottom. The oldest item is at position 0

and then as you add new items they increase in the index. Rolling windows

have an inverted index so the newest item is always at position 0 and the

older items get shuffled back over time. This can help for this sort of situation

where we want to just work with a few values, and we can access those values

easily with our rolling window. So let's first create a rolling window. Rolling

windows can be of any type, they can hold any sort of data that you want

except you just need to remember you need to define the data that you want to

save here. In this case we want a length two rolling window. So remember this is a 0

indexed array so that means that there will be data at position 0 and 1 and

those two numbers will be our window. The next parts says to add the current trade

bar of Tesla to our rolling window. With a scheduled event you don't always

have easy access to price data that occurred in the OnData method. To make

that easier LEAN has created a CurrentSlice property in your algorithm.

So you can see here we've got self.window.add, and we can just add

in the current slice for Tesla to our rolling window. Number 3, let's do exactly

the same thing but for the opening bar.

Okay let's see how it goes.

Okay great. Next we're going to use our rolling

window to get the price movement that happened overnight. So just like an

indicator the rolling window has the IsReady property to tell you when the

window is full. So with our example it's fairly easy because we've only got two

values, but imagine you've got a hundred items in your window you want to make

sure that the window is completely full of data before you start doing any sort

of math on it. So we can use this if not window ready then return to

control when we do our trading. And now we will never reach this part of the

code until we have a full rolling window. So let's calculate the price delta that

happened overnight. If you remember the rolling window position zero has the

most recent trade bar. So this is the bar we've just added up here, and this would

be the opening bar, so we want to make sure we get the opening price for that

bar. Then secondly we want to take the close of yesterday to find our

opening range from the close at 4:00 p.m. to the opening price at 9:30. So now

we have an accurate delta. Let's decide when to trade. So you can see here we're

going to say if the delta is less than -$10 then set holdings to 100% Tesla.

So if delta is -10.

So -10 is a fairly arbitrary number, but for the

sake of this demonstration we're using this to decide when to trade. But of

course in production would never want to use such an arbitrary parameter in your algorithm.

Okay great on to the next task

Okay so now we've got our algorithm trading, but we're using the -10

value as a parameter. One way that we could eliminate this is to look at

the deviation of the gaps to see if they're normal, and if it's within an

expected range. If it goes outside of that expected range that could be a

good signal for us to trade. So to do that we could use the standard deviation

indicator to monitor the volatility and see if our jumps, our overnight gaps, are

outside of that range. To do that we're going to use a manual indicator. Manual

indicators under the hood are very similar to normal indicators except you

need to update them with price data manually. So you can see here there's a

manual indicator for every automatic helper but it's just the full spelling

of the indicators name. It takes the name and the period just like a normal

indicator. So first let's create our standard deviation object for Tesla, and

we want to create it with a 60-minute period. So if you note here this is 60

periods but it doesn't necessarily know the resolution of the

data because we pump it with data, so it has no idea of its resolution. We control

this indicator totally. So next we're going to update that indicator with some

data. The update method takes two arguments, the time and the value you'd

like to update, so in this case we're going to pass in the close of Tesla.

Here we're going to have a standard deviation indicator that represents the

last 60 minutes of the trading day from yesterday. Now point number three. Let's

check if our indicator's ready before we use it. This is always a good thing to do.

So if not ready then let's return

Okay great, so now we're pretty sure that our indicators is created, is being

updated, and now it's ready to use. Now we can use that indicator to figure out how

many standard deviations the overnight gap represents. Standard deviations

typically range from negative 3 to positive 3 and when the standard

deviations are more than negative 3 it has less than 1% chance of occurring. So

we can use this for our trading.

Let's calculate the number of standard

deviations that this price delta represents. We can take the price

delta divided by the standard deviation value.

Okay, and when that is more than negative 3 we trade.

Let's see how we go.

So far so good.

Okay great, congratulations you've passed the Fading the Gap Boot Camp tutorial. In

this tutorial you've learned about manual indicators, scheduling after

market open and before market close, and using the current slice property of your

algorithm. I hope you enjoyed the tutorial. Thank you for watching, and I'll

see you in the next one!