At this point, we have looked at different components of the Quantopian API individually. Now it's
time to put them all together in a basic trading algorithm. In this lesson, we're going to
use the functions that we've seen so far to construct a simple
mean reversion strategy.
To start out, let's plan a strategy to implement.
Hypothesis: If the 10-day simple moving average (short SMA) of a security is higher than its
30-day simple moving average (long SMA), the price of the security will drop. Conversely, if
its short SMA is lower than its long SMA, the price will go up. This is referred to as mean
reversion.
This type of strategy is usually implemented using a dynamic set of securities selected by
pipeline, but since we haven't covered that yet, we're
going to hand-pick a list of securities to trade:
# MSFT, UNH, CTAS, JNS, COG
context.security_list = [sid(5061), sid(7792), sid(1941), sid(24556), sid(1746)]
Note: The securities selected have no significance to the strategy. They were chosen arbitrarily.
In this implementation, we will rebalance once at the start of each week at market open. To do this,
we can schedule a rebalance function in initialize().
schedule_function(rebalance,
date_rules.week_start(days_offset=0),
time_rules.market_open())
Next, we want to decide how much of our portfolio we want to allocate to each security in our
list and whether we want to open long or short positions for each of them. In this example,
determining whether we want to open a long or short position is simple. If the 10-day SMA is
below the 30-day SMA, we take a long position, predicting that the price will go back up.
If the 10-day SMA is above the 30-day SMA, we take a short position, predicting the price will
drop.
Let's also assume that the greater the relative difference between a security's 10-day and 30-day SMA, the more likely it is to revert. Under this hypothesis, we want to take a bigger
position in securities that have a greater relative difference between their short and long
SMAs.
Let's define this in a function:
def compute_weights(context, data):
# Get the 30-day price history for each security in our list.
hist = data.history(context.security_list, 'price', 30, '1d')
# Create 10-day and 30-day trailing windows.
prices_10 = hist[-10:]
prices_30 = hist
# 10-day and 30-day simple moving average (SMA)
sma_10 = prices_10.mean()
sma_30 = prices_30.mean()
# Weights are based on the relative difference between the short and long SMAs
raw_weights = (sma_30 - sma_10) / sma_30
# Normalize our weights
normalized_weights = raw_weights / raw_weights.abs().sum()
# Return our normalized weights. These will be used when placing orders later.
return normalized_weights
Note that we also normalized our weights to ensure that they add up to 100%. We then
return normalized_weights which is a Series indexed by our securities.
The next step is to define how we want to order our securities. Earlier, we decided to rebalance once per week at market open using a function called
rebalance(). Now, let's define
rebalance() to place an order for each of our securities to
the target weight that we calculated in compute_weights():
def rebalance(context, data):
# Calculate our target weights.
weights = compute_weights(context, data)
# Place orders for each of our securities.
for security in context.security_list:
if data.can_trade(security):
order_target_percent(security, weights[security])
Note that we use order_target_percent() to order to our
target weights. We also use data.can_trade() to guard against
ordering delisted securities since we hard-coded a static list of securities.
To learn more about what our algorithm is actually doing, let's track some variables that we
might be interested in.
Let's first schedule another function in initialize() called
record_vars() to run at the end of each day:
schedule_function(record_vars,
date_rules.every_day(),
time_rules.market_close())
And then we'll define
record_vars() to track our
leverage, as well as the number of long and short positions
we are holding. We can count the number of long and short positions each day using the
context.portfolio.positions object:
def record_vars(context, data):
# Check how many long and short positions we have.
longs = shorts = 0
for position in context.portfolio.positions.itervalues():
if position.amount > 0:
longs += 1
elif position.amount < 0:
shorts += 1
# Record our variables.
record(leverage=context.account.leverage, long_count=longs, short_count=shorts)
Since there's nothing that we want to do every minute, nor anything that we want to do before the market opens, we don't need to implement either handle_data() or before_trading_start(). The final algorithm looks like this
(note that some comments, as well as two print statements in compute_weights() were added):
Clone
def initialize(context):
"""
initialize() is called once at the start of the program. Any one-time
startup logic goes here.
"""
# An assortment of securities from different sectors:
# MSFT, UNH, CTAS, JNS, COG
context.security_list = [sid(5061), sid(7792), sid(1941), sid(24556), sid(1746)]
# Rebalance every Monday (or the first trading day if it's a holiday)
# at market open.
schedule_function(rebalance,
date_rules.week_start(days_offset=0),
time_rules.market_open())
# Record variables at the end of each day.
schedule_function(record_vars,
date_rules.every_day(),
time_rules.market_close())
def compute_weights(context, data):
"""
Compute weights for each security that we want to order.
"""
# Get the 30-day price history for each security in our list.
hist = data.history(context.security_list, 'price', 30, '1d')
# Create 10-day and 30-day trailing windows.
prices_10 = hist[-10:]
prices_30 = hist
# 10-day and 30-day simple moving average (SMA)
sma_10 = prices_10.mean()
sma_30 = prices_30.mean()
# Weights are based on the relative difference between the short and long SMAs
raw_weights = (sma_30 - sma_10) / sma_30
# Normalize our weights
normalized_weights = raw_weights / raw_weights.abs().sum()
# Determine and log our long and short positions.
short_secs = normalized_weights.index[normalized_weights < 0]
long_secs = normalized_weights.index[normalized_weights > 0]
log.info("This week's longs: " + ", ".join([long_.symbol for long_ in long_secs]))
log.info("This week's shorts: " + ", ".join([short_.symbol for short_ in short_secs]))
# Return our normalized weights. These will be used when placing orders later.
return normalized_weights
def rebalance(context, data):
"""
This function is called according to our schedule_function settings and calls
order_target_percent() on every security in weights.
"""
# Calculate our target weights.
weights = compute_weights(context, data)
# Place orders for each of our securities.
for security in context.security_list:
if data.can_trade(security):
order_target_percent(security, weights[security])
def record_vars(context, data):
"""
This function is called at the end of each day and plots our leverage as well
as the number of long and short positions we are holding.
"""
# Check how many long and short positions we have.
longs = shorts = 0
for position in context.portfolio.positions.itervalues():
if position.amount > 0:
longs += 1
elif position.amount < 0:
shorts += 1
# Record our variables.
record(leverage=context.account.leverage, long_count=longs, short_count=shorts)
Congratulations on completing the first Quantopian tutorial! Try coming up with your own
strategy and implementing it yourself.
The next tutorial will cover the Pipeline API and teach you how to select securities dynamically.
