Hello Josh,
very interesting! Though it is not clear to me where I can find the actual code for the backtests?

Thanks!
Fabian

@Josh P., Thanks for the effort and the insight it affords.

Here's a quick interview "Toby" gave on this topic: http://fivegoodquestions.co/season-1/s1e5
And this one was handy too: http://acquirersmultiple.com/faq/

So, I looked, I didn't see where your backtests were hiding. I'm not familiar with your Research Studio so I probably just missed it. What's the fundy code you used for each variety?

In the end, how many securities did your strats trade in and out of?

Fabian, great point.

I ran the backtests separately and then analyzed the results in the notebook shared above (with the get_backtest() method). Here's the algo.

You can find these context variables in the code which are the main ways to modify the behavior of the algo:

    #: Choices are mf -> Magic Formula and am -> Acquirer's Multiple  
    context.ranker_type = 'am'  
    #: Time period in days  
    days = 365  
    quarters = 4  
    context.time_periods = [(days/quarters)*i for i in range(0,quarters + 1)]  
    # Total number of stocks to hold at any given time  
    context.max_positions = 30  
    # Number of positions to accumulate each month  
    context.positions_per_month = 3  
    context.minimum_market_cap = 500e6  
    # Used to track the purchase dates of each security  
    context.entry_dates = {}  
    # In order to maximize post tax returns, losing positions should be sold before  
    # the 1 year mark and winning positions should be held longer than one year  
    context.hold_days = {  
        'win': timedelta(days=375),  
        'loss': timedelta(days=345)  
    }  

@Market Tech,

Generally, the algo kept a portfolio of 30 securities (though I experimented with other sizes). Similarly, it rebalances monthly. The best Acquirer's Multiple variant rebalanced about 3 stocks monthly. It probably turns over the portfolio annually.

Hello Josh,
thank you.
Best Regards
Fabian

Hi Josh,

Thank you for all your hard work that stuff is brilliant!
On a side note I went through your code and noticed this:

 #: On the first of every month  
    if get_datetime().day == 1:  

Running a few of my back tests and noticed that this doesn't get fired if it isn't a trading day, I have used the following instead:

from zipline.utils import tradingcalendar as tcal  
def last_day_of_month(date):  
    if date.month == 12:  
        return date.replace(day=31)  
    return date.replace(month=date.month+1, day=1) - timedelta(days=1)

def before_trading_start(context):  
    today = get_datetime().date()  
    trading_days = tcal.get_trading_days(tcal.canonicalize_datetime(today.replace(day=1)),  
                                         tcal.canonicalize_datetime(last_day_of_month(today)))  

    if today == trading_days[0].date():  
        log.debug("First trading day of the month")  

Cheers,
Moloth.

Great point Moloth. A nice improvement in the reliability of the algo. Alternatively, you could use the schedule_function() method that was subsequently introduced.

I am mystified by how well this algorithm performs. 25% return on an annualized basis is extraordinary. So why is it that more investors don't use this formula? What is the catch here?

Hi Josh..
Ive notice... your using... get_backtest('54d52277b211f64fbe08dd42') does research also allow quandl data/multiple stocks to be implemented? or other csv source with a say... 250mb size...historical datas. tnxs ;)

Azad, that's a good question, it is a fairly genuine curve because the code doesn't venture very far into negative cash, although on the surface, of course alpha is low, beta high and drawdown could be improved. (284% profit/returns based on amount spent, that's nearby.)

Returns 305.6%  
Alpha     0.17  
Beta      0.64  
Sharpe    1.28  
Drawdown 44.7%  

One tiny little thing is that it tries/fails repeatedly to sell off remaining portions of several, these are some of them: AIRN AWE COX DRYR HUGH IGEN KYPH NEON OPSW PAR REM TKS TLEO. I guess one is stuck with them for some reason that I don't understand.

More significantly, all balancing/rebalancing algorithms inherently suffer from sometimes selling at a loss, just the name of the game. For example, of the 741 securities that the algo encountered, it lost money on quite a few, $75k on MCP, $58k on ZOLT, $55k on IMPV and $52k on WPRT et. al. for many that lost per-share value. There might be some way to ameliorate that, with history, excluding stocks in a downward trend, or stoploss with a particular drop in value. One of those dropped to 1/3 its original price and maybe could have been sold/excluded when it hit 95% or along that line instead (if the downward movement was not sudden), in a context.excludes list.

The losers were made up for by the big winners, QIHU went from $30 to $114 per share and raked in $281k with one buy and one sell of 3460 shares. PANW made $143k, thanks to a near doubling in price. PAR is up $172k, tripled. There were at least 105 winners (I'm not seeing everything b/c I didn't spend time to maneuver around the logging limits).

There are those like WPZ with two purchases, spending $268k for 5263 shares total, while the price has gone down, so at the end those shares are sitting there at $223k (83%), sort of an as-yet unrealized loss I suppose. Those are a few things to think about, as to the catch, on why folks don't just run with it, I think, maybe. Good luck.

Are these..being one.. at research?? coz Ive tried... replicating it too many errors... and there isnt a pdf print out.. if they are more or less.. betting on the same stocks... that way... we can check..to achieve same performance more or less... cheers ;)

John, for your previous question, you can load quandl data in Research. Give it a shot. There is a sample notebook in the tutorials section that outlines the process.

Gary, I'm with you. That said, I'm sure there are people who do pursue this strategy (automated or otherwise), just based on Tobias Carlisle's and Joel Greenblatt's books sales numbers.

Can we clone your notes... id like to expand on it since O'Shaughnessy says.. his formula is way... better than ev to evida... copy paste doesnt cut it too many errors... which bothers me same codes but does work.

Sure thing. I'll need to start a new thread for you to be able to clone the notebook.

Edit: Here's the link: https://www.quantopian.com/posts/clone-able-research-notebook-comparing-acquirers-multiple-and-magic-formula

Why do you use arithmetic mean and not geometric mean in calculation of annual returns?

I think it should be geometric since its derived from cumulative performance.

It probably wasn't a conscious decision. You're welcome to clone the notebook yourself and change things up :)

Quantopian has minutely pricing data, dating back to 2002. So the earliest you can run a backtest on Quantopian is to 2002. Similarly, we have fundamental data exposed back to 2002. We start trading in 2003 in this particular backtest because we need 4 quarters worth of fundamental data to build the rankings.

Note, this algo was written prior to the creation of the Pipeline API on Quantopian. It's likely much easier to implement this strategy using the Pipeline API instead.

I am new to Quantopian but very interested in the Magic Formula.

I cloned your notebook above and I can't run it. I get errors that it can't load algorithms, etc.

Is this no longer available/functional?

Hi, I think the notebook has lots of backtests that aren't shared publicly so the notebook itself will fail when you try to re-execute those cells. Only the backtests that were shared publicly will work with get_backtest()

You can clone the algorithm in a later response and use that to run your own backtests and analyze the results yourself using get_backtest() in your own copy of the notebook.

Thanks
Josh

hey Josh... how to eliminate... the 1st one year... and a half... wherein... the algorithm don't start trading... or no activity ? its annoying... thanks...

I agree it's annoying. I would suggest re-implementing the strategy using the Pipeline API which did not exist when this algo was first written. Ranking stocks is much easier with Pipeline.

Hey Josh... how come... aquarers multiple... perform badly during 2011 to 2015 when it suppose to re balance quarterly ?thanks...

Per Josh's algo above, I am not sure what is disadvantage of using "fundamental_df = get_fundamentals". I thought Pipeline is supposed to be superior due to its ability to scan thousands of securities. But based on Josh's algo, the old style fundamental method also scans thousands of securities. Has performance issue changed for the old style fundamental method? In summary what is pros and cons of using "get_fundamentals" vs "Pipeline"? for fundamental based trading (except for getting historical from the pipeline)?

I cloned Josh's algo and when I try to run it it doesn't execute any buy or sell orders whether I am using 'am' or 'mf'. Am I missing something?

quite interesting.

@josh
I would make a magic formula program using pipeline, but I am not that comfortable with pipeline. I feel that the documentation is hard to navigate and a bit confusing. (This is probably just be. Evrything else here is great!) Do you know which pipeline documentation on ranking would be useful to me?

@Ujae,
There is significant advantage of pipeline in this strategy:

get_fundamentals() on any particular simulation day only provides access to the latest known value for a metric on that date. Pipeline provides access those values for potentially large windows of time backwards. This helps avoid the "annoying" problem in the original algo where we don't have access to multiple quarters' worth of data for the important metrics. The backtest, as a result, has to warm up for 15 months building up enough data history. With pipeline, that's not required.

@Zachary,
I would walk through this portion of the docs: https://www.quantopian.com/help/#pipeline-title
And also check out the sample algos using pipeline from the docs: https://www.quantopian.com/help/#sample-pipeline-api

Thanks Josh!

Hey @Josh Payne

I've amended this model based on some code written in here. It will not make purchases when the market is highly priced (shiller CAPE). This reduces quite a lot of losses. This and reducing the portfolio size down to only 3, not a typo, 3. Seem to have created an unbelievable result. Around 1,388% over the last 14 years (21% annualised return). The sharpe is now 3.26 and sortino is 4.5.

I tried this with max portfolio of 4,5,6,7,8 etc - after around 8 the returns drop quite a lot and the model becomes much more sticky to the SPY price trend.

Question - would this actually work in real life? Have I made a mistake/missing something? (This seems to good to be true)

Please let me know your thoughts when you can!

Nice putting in the CAPE check, Value Investor. I Have you looked at how the model performs at different starting times, i.e. top of 2003, 2007, 2011 and bottom of 2009?

On a similar note, I am much more confident in my model if "X" percentage of the market is trading at cheap EV/EBIT prices. What that X% cut off is, like the CAPE ratio indicator, would be interesting to look into.

An article that caught my eye:
Check out the "Percentage of Non-Financial, US Companies Trading at "Deep Value" prices" graph under the "What Is A Cheap EV/EBITDA Multiple?" subtitle.
https://hurricanecapital.wordpress.com/2014/12/05/the-acquirers-multiple-fair-companies-at-wonderful-prices/

The good thing about CAPE is it's basically a macro indicator that prices (in general) of the market should drop at some point in the future. Through all of history this has been repeated. I tried many different averages but I found 26.4 (as the maximum CAPE ratio to allow purchasing) to produce the best results.

I've just run the code and here's the results:

Highest price of :
- 2003 until now: 500% (SPY is 119%)
- 2007 until now: 284% (SPY is 47%)
- 2011 until now: 103% (SPY is 55%)

Lowest price of 2009 until now: 359% (SPY is 218%). Worth noting that from lowest of 2009, the model actually underperforms the market for the first 2.5 years. Around 3 year mark it starts to pull away from the SPY.

Also worth noting if you run the model with 20/30 max positions from highs over 2009/11 etc the result are much much worse. It actually underperforms the market quite significantly. It seems the first quartile of the first 20 results perform with the lowest drawdowns. But the best results is with just 3 positions only. Obviously this okay for small investors but not anything over 1M.

BTW, while testing this model I did try to filter based on EV/EBIT below 3 and it actually didn't perform as well. I think in some years the meaning of this metric changes. As we are dealing with good prices rather than good companies the model seems to have a high sensitivity to the entire market/index/ SPY price.

Great idea - what do you think is the best way to calculate the % of market trading at cheap EV/EBIT? Get total number of stocks in market, then number of stocks trading at AM of 3 or less, then divide one off the other?

@Josh
Hi Josh,

What is the difference between calculating EV/EBITDA and using the ev_to_ebitda ratio provided directly by Morningstar when calculating the Acquirer's Multiple?

Regards,
Mark

My guess (and this is only a guess without spending an hour or two digging back into things) is that calculating EV/ETBITDA ourselves maintains consistency of time period for data in the calculations. EV and EBITDA in the get_fundamentals() data from Morningstar are for the most recent quarter as are the other metrics. It could be that the ev_to_ebitda is based on a different time frame. Or it could be that we didn't realize the ev_to_ebitda field was there when we wrote the algo.

@Josh P.
When you built the filter for the magic formula, did you compare the programs out puts to the stock picks on Joel Greenblatt's site? Where the stock's selected by your program and the site totaly identical for the same date?

I have been working on the pipeline version of these strategies, but for some reason my top 30 stocks and the sites top 30 stocks for the same date don't totaly match--I have a separate ost about this, but I have not gotten any helpful feedback.

We did not explicitly check the matching of the chosen stocks. IIRC, there were enough subtle differences in implementation that I assumed there would be differences. Our objective wasn't to replicate exactly the published results but to attempt to implement the strategies on Quantopian as best we could with the tools at hand.

So this might be more a general question on the Acquirer's Multiple. But I would assume you want a low rank for AM, but not a negative rank for AM. Because Acquirers are unlikely to want to buy out a company with negative earnings. The logic being, you want high operating earnings but low EV. Does this sound right? Because if you simply just sort the list in ascending order, all the negative numbers, from either negative EBITDA or massive Capex, dominate the top of the list. This is probably my novice eyes, but I didn't see anything in the AM code to accommodate for negative numbers, or am I just way off track?

And a question on the Magic Formula: Earnings yield comes in a percentage but ROIC can be a number bigger than 1 in certain circumstances. I notice you just rank descending for both inputs and then add them, but they're not entirely like-for-like comparisons and you would probably have a bigger weighting to ROIC. Given this, do you think it would be better to give more weight in the ranking to earnings yield?

Thanks!

Value Investor

What is the reason behind excluding Real Estate, Financials, and Utilities? I included them and re-ran the backtest. The return was ~600% as opposed to the ~1400% achieved with those excluded. I could argue that the code suffers from recency bias if you exclude those sectors. What do you think?

Thanks for putting this together. Really good idea

Here is an updated version of the value algorithm originally published in this post. It fixes a couple of issues that I found, namely,

1) The algorithm updates fundamental data and executes buys once a month instead of once a week. Which I believe was the original intent of the algorithm
2) Also the original version was hardcoded to check if the day is the first of the month. Which means if the first of the month is a holiday or a weekend fundamental data will not get updated. The updated version simply schedules a check on the first trading day of the month.

Also, since the get_fundamentals query is only executed once a month the algorithm runs much faster in Q2.

regards,
Mark

Financials, and Utilities are excluded in the original Magic Formula (and a lot of other quantitative stock screens) because the financial structure of those companies is different, and it isn't an apples to apples comparison with the rest of the stock universe.

Has anyone implemented a pipeline version of the original algo which doe not need a long time warmup?

Thanks Tar -- good to know

Just a minor tweak to the Magic Formula, putting a 0.7 weighting on earnings yield and 0.3 weighting on ROIC improves the returns considerably. Acquirer's Multiple still outperforms it, but it is still a perfectly reasonable value screen. The 50-50 weighting lets too many "frothy" stocks in that have high ROIC but it is already largely factored into the price and more.

@Angus. I really like the algo updates. That said, I am working on putting on a VIX limiter for risk mitigation, limiting shorts and potentially leverage, and changing over things to utilize pipeline. Just want to make sure I don't kill this upside. Still debugging while trying to marry all of these. Was thinking of tweaking this for VIX https://www.quantopian.com/posts/poor-mans-vix-slash-vvix. Thoughts?

I wrote the version that first utilised Shiller CAPE. I've seen all the recent updates and would say it makes complete sense to port to the new API, but the returns should be the same.

Which regards to using the VIX, this is very different metric - this is really the fear index rather than current pricing multiples. Barr in the mind the whole purpose of this screen is to find deep value stocks when th market is not overpriced. But like anything you cannot really draw a conclusion without proof so I suggest trying to see the results.

You may out perform the original 1,388% return.

The first thing to achieve is matching/coming close to 1,388% with the new API - I haven't seen that in any posts since I submitted my version.

Thanks. I'll look over your version as well, but agree theoretically it should run the same, just trying to update and clean to be more efficient.

From a theory standpoint, yes the model should take a look and screen for super deep value which should protect against the downside, but sometimes the markets are irrational and for some reason, people are just dumping, it adds a little layer of protection from catching falling knives.

Thanks. Great to see how the algo has evolved over time. Definitely a robust methodology with promising results. Quick question - Is anyone looking to implement a Pipeline API so you don't have to wait a whole year before the algo starts trading?

@Lucas Lee

I am near the end in the implementation of the magic formula using pipeline. However I am having some buying/selling issues that I need to fix.

Here is a pipeline version of the algorithm that I have been working on. The last change I made was to work the trailing twelve month calculation into the Acquirer's Multiple class when I ran into timeout errors. But I probably won't be able to work on it again until next week.

For the others in the thread who were looking for a pipeline version, you're welcome to take a crack at fixing the timeout. I'm not sure if the timeout is coming from the data collection or from the calculations and ranks. My plan of attack is going to be to break out all of the calculations and move them to the rebalance function so that the pipeline is only responsible for providing the data. That will also make sure that the calculations are only performed once a month. If that doesn't work some additional pre-screening will be required for the value factor masks.

Hi everyone,

I've been trying to switch the ROIC in the Magic Formula to 6 month price momentum. My code buys the 3 stocks in the first month, but when it's supposed to buy the next 3 stocks, it crashes. Can someone please help? I've backtested this change using Bloomberg and found it to return around 1% better CAGR over 20 years compared to the magic formula.

Thank you very much

Hey guys,

I tried converting the acquirers multiple into a pipeline algorithm and i'm unable to generate similar backtests to above. There are two algorithms: the first one uses enterprise_value/(ebitda+capital_expenditure) similar to the algorithm above the other uses enterprise_value/(total_revenue - (cost_of_revenue - selling_general_and_administration) which I found on the acquirers multiple website here. Any ideas on how to improve these algorithms to get closer to replicating the actual acquirers multiple are welcome!

Thanks,
Stefan

Here is the second algorithm.

Stefan,
You're using the latest values to calculate the acquirer's multiple. The original algorithm and description call for the trailing twelve month (ttm) values. This class with build the ttm value in pipeline.

class AcquirersMultiple_ttm(CustomFactor):  
    """Calculates the Acquirere's Multiple using quarterly values  
    Because this data is typically quarterly, splits the window into 4 periods and takes  
    a value from each period. This allows recently released data to be weighed equally with  
    previous quarters.  
    """

    inputs = [Fundamentals.enterprise_value,  
              Fundamentals.ebitda,  
              Fundamentals.capital_expenditure]  
    window_length = 252class AcquirersMultiple_ttm(CustomFactor):  
    """Calculates the Acquirere's Multiple using quarterly values  
    Because this data is typically quarterly, splits the window into 4 periods and takes  
    a value from each period. This allows recently released data to be weighed equally with  
    previous quarters.  
    """

    inputs = [Fundamentals.enterprise_value,  
              Fundamentals.ebitda,  
              Fundamentals.capital_expenditure]  
    window_length = 252  
    def compute(self, today, assets, out, enterprise_value, ebitda, capital_expenditure):  
        time_periods = np.linspace(0,len(enterprise_value)-1, 4, dtype=int)  
        q_ev = np.take(enterprise_value, time_periods, axis=0)  
        q_ebitda = np.take(ebitda, time_periods, axis=0)  
        q_capex = np.take(capital_expenditure, time_periods, axis=0)  
        np.mean(q_ev / (q_ebitda + q_capex), axis=0, out=out)  

Attached is a notebook comparing the correlation between the single and ttm values. There may be other tweaks needed in the algorithm, but this is a good place to start.

Regarding TTM, be aware that picking four evenly spaced dates over the past 252 trading days assumes quarterly reporting dates are evenly spaced, which is not always a valid assumption. A more accurate approach is provided here, https://www.quantopian.com/posts/trailing-twelve-months-ttm-with-as-of-date

Thanks for the help Shaun!

I'm still having trouble getting the backtest I expect given the success above. Attached is my most recent backtest with TTM AM. Any suggestions are welcome!