Quantopian - Turtle Trading Strategy

Turtle Trading Strategy

Turtle trading is a well known trend following strategy that was originally taught by Richard Dennis. The basic strategy is to buy futures on a 20-day high (breakout) and sell on a 20-day low, although the full set of rules is more intricate. I've modeled the meat of the strategy in Quantopian and used it to trade exchange-traded funds (ETFs), in this case just some silver and copper securities.

I used rules from here. From what I have seen, the rules of turtle trading slightly vary from source to source, however what's outlined in that PDF seems well-guided and reliable. If you want to adjust the rules you can clone this and it should be fairly straightforward from there. I've also added an option in the code if you only want to long and not short. To trigger buys and sells, the code calculates the goal amount of shares then works from there to determine how many to buy or sell. This method for determining order amount works well for things like risk-adjusted portfolio sizes.

This is a pretty fundamental strategy and it seems to work well. There are a few different parameters to play with, so clone this and see if you can get some good results or even add to the code in any way.

If you want to experiment with adding different ETFs, you can get ideas from a list of futures like this one. From there just Google for whatever ETFs, like "corn etfs", and add the respective symbols to the code.

Clone Algorithm

377

Backtest from to with initial capital ( data)

Cumulative performance:

Custom data:

Week

Month

All

Total Returns

Alpha

Beta

Sharpe

Sortino

Information Ratio

Benchmark Returns

Volatility

Max Drawdown

Returns	1 Month	3 Month	6 Month	12 Month

Alpha	1 Month	3 Month	6 Month	12 Month

Beta	1 Month	3 Month	6 Month	12 Month

Sharpe	1 Month	3 Month	6 Month	12 Month

Sortino	1 Month	3 Month	6 Month	12 Month

Information Ratio	1 Month	3 Month	6 Month	12 Month

Volatility	1 Month	3 Month	6 Month	12 Month

Max Drawdown	1 Month	3 Month	6 Month	12 Month

# based off of rules from
# http://bigpicture.typepad.com/comments/files/turtlerules.pdf

# uses ETFs:
# http://etfdb.com/type/commodity/exposure/futures-based/no-leveraged/

# this is just a start, there additional rules that haven't yet been implemented

from collections import deque
import math

atr = ta.ATR(timeperiod=20) # used to calculate 20-day ATR

def initialize(context):
    
    # you can find other tickers at that ETF page above
    context.securities = [
                              sid(37732), # euro
                              sid(40365), # uranium
                              sid(36468), # coffee
                              sid(41309), # ..
                              sid(35691), # ethanol
                         ]
    
    # set to True if only longs are wanted, not shorts
    context.long_only = False
    
    # define dicts for deques to contain past prices
    context.past_highs = dict()
    context.past_lows = dict()

def handle_data(context, data):
    total_price = 0 # to be used later as a sort of benchmark
    
    # for each security in the list
    for security in context.securities:
        total_price += data[security].price
        try:
	        # wait for warmup
            if len(context.past_highs[security]) < 20:
                context.past_highs[security].append(data[security].high)
                context.past_lows[security].append(data[security].low)
                N = atr(data)[security]
                continue
        except:
            # define deques
            context.past_highs[security] = deque([], maxlen=20)
            context.past_lows[security] = deque([], maxlen=20)
            continue
            
        # count how many shares we have in open orders and own
        shares = 0
        for o in get_open_orders(security):
            shares += o.amount
        shares += context.portfolio.positions[security].amount
        
        # determine account size
        current_value = context.portfolio.cash + context.portfolio.positions_value
        if current_value < context.portfolio.starting_cash:
            account_size = -context.portfolio.starting_cash + 2*current_value
        else:
            account_size = current_value
        
        # get 20 day ATR
        N = atr(data)[security]
        
        # compute how many units to buy or sell
        trade_amt = math.floor(account_size*.01/N)
        
        # 20-day high?
        h_20 = True if data[security].price > max(context.past_highs[security]) else False
        
        # 20-day low?
        l_20 = True if data[security].price < min(context.past_lows[security]) else False
        
        goal_shares = shares
        if h_20:
            # long
            goal_shares = trade_amt
        elif l_20:
            # sell or short
            if context.long_only:
                goal_shares = 0
            else:
                goal_shares = -trade_amt
            
        # goal_shares = shares + (amount to buy or sell)
        amt_to_buy = goal_shares - shares
        if amt_to_buy != 0:
            if amt_to_buy > 0:
                log.info("buying %s shares of %s" % (amt_to_buy, security.symbol))
            if amt_to_buy < 0:
                log.info("selling %s shares of %s" % (-amt_to_buy, security.symbol))
            order(security, amt_to_buy)
        
        # keep deques updated
        context.past_highs[security].append(data[security].high)
        context.past_lows[security].append(data[security].low)
        
    # record the total price of all stocks. just a sort of benchmark.
    record(total_price=total_price)

This backtest was created using an older version of the backtester. Please re-run this backtest to see results using the latest backtester. Learn more about the recent changes.

Leigh Drogen

Great work Gus, thanks for forwarding this my way. I used to run a strategy that was very similar to the Turtle Trading strategy. The most important part of the strategy though is the pyramiding of the position coupled with the matrix of which assets you could hold together and in what size. The money management aspect of the strategy was almost more important than the basic momentum algo. I'm wondering when Quantopian will allow that kind of detailed money management. Either way, this is a great start, and I'm sure others will build on it in the future, that's the value of this platform, people working together to build interesting stuff. Thanks!

Gus Gordon

Sure, no problem. Unfortunately that stuff you mentioned is difficult to implement in a dynamic way. I think there would have to be a categorization of securities/futures/ETFs, which I suppose is actually possible with fetcher or extra code.

Aaron Smith

IMO the order of importance of designing this system is 1) the markets you will trade, 2) position sizing, 3) exit strategy, 4) entry strategy. It needs to be well diversified to work well across stock markets, commodities, currencies and bonds. You'd also probably want to keep each category from taking up more than 25 percent of the portfolio. Keep the position size no more than 1-2 percent of equity. The problem I've run into using the turtle strategy on ETFs is leverage. You may not be able to take all the signals because of margin requirements, which you don't have with futures.

In any case, thanks a lot for the algo. I'll have fun playing with it.

Mason Tomahawk

Hi Gus,

This is great and I have tried to work with your sample as a way to learn how to use the interface and Quantopian.

I've adapted parts to make a modified strategy with an EMA requirement and also a trailing stop loss. Somewhere in my modification it went wrong and I get a run time error. Runtime exception: ValueError: max() arg is an empty sequence - it appears my sequence is not inserting the price highs....any ideas what is going on with my backtester and why its failing? Your help would be greatly appreciated.

Where do I post my code without taking up so much space on your page?

thanks

Dan Dunn

Mason, you should just go ahead and put up a new thread post. Or, you can email [email protected].

FYI, if you ran a "full backtest" on a previous working version, that backtest includes a copy of the code as it was then. It might help to decipher what went wrong.

Gus Gordon

Hey Mason, glad to hear you like this. I'm not sure where that error is coming from. You can do as Dan suggested and I'll try to help.

SJ Park

Hi Gus,

Thanks for sharing this Turtle strategy. I am quite new to coding and having trouble implementing a few more rules --- specifically with regards to placing sell stop orders when a trade is triggered and placed.
For example, if a security triggers a new long entry, I would like a sell stop order to be placed, with the stop at (entry price - 2*N) and vice versa for shorts.

Thanks in advance!

Dan Dunn

SJ - I suggest that you attempt to make the code, and then make a new post that explains what is working and what isn't working. You'll get more help that way. Asking a question on an old thread, unfortunately, doesn't work very well.

SJ Park

Thanks Dan -- will do.

Gus Gordon

Edited

Thanks SJ! I'll look out for your thread, Dan is right, making a new one is good.

I'll try to get you started though in case you just need a bump to get going. You can call your stop order by doing something like:

order(security, amt_to_buy, stop_price=entry_price-2*N)

(see here for more: https://www.quantopian.com/help#ide-ordering)

So if you just want that to trigger when something happens (when some random variable a is greater than 3, for example):
if a > 3: order(security, amt_to_buy, stop_price=entry_price-2*N)

For shorts, you should just be able to use a negative amt_to_buy, if I'm understanding correctly.

SJ Park

Great -- thanks so much Gus! Will certainly post the code on a new thread when it is complete.

Not a member? Sign up!

Turtle Trading Strategy

Attach a backtest to this reply

Error

Send Feedback

Join Quantopian. It's free!