QuantConnect Community

Peter,

in the attached version I removed the history call from calc_return and added a standard ROC indicator added by OnSecuritiesChanged. This change didn't alter the performance, but I did two other that did:

1. Universe resolution change to minutes to avoid stalled prices. Small performance reduction

2. Universe selection performed every month start. In your orginal version universe is selected one day after rebalance but then is only and the next in signal is triggered which could mean months and the selection becomes to alleatory. This resulted however in some performance degradation.

Question. Is there a way to just limit the results to securities in NDX, SPX, etc.  Basically to only trade the QQQ constituents?

Thank you!

Just seems too good to be true. 50-60% annual compounding rate.. There should be something wrong here, either in the code or there is overfitting. 

Leandro Maia: This is pure coding magic, very nice work there! The changes all make a lot of sense, so this code should definitely be the basis for further work on the Earnings Rockets with In & Out. I reckon the only thing one could check is whether there is any benefit in performing a slower universe update (e.g. bi-monthly or every quarter). I mean, the backtest performance is impressive anyway.

Thunder Chicken: I know that there is a universe called QC-500 that mimics the S&P500 firms (documentation). I am not aware of a QQQ universe, but it might be something that may be coming at some point (?).

UK Bilgi Servisi: Overfitting may always be a concern with an algo that has more than say 3 or 4 parameters. Parameter sensitivity analyses can give an indication. For the 50-60% you refer to, these are algos trading 3 x leveraged ETFs. This is a furious bull ride and when the future does not play out like the past, leverage aggravates the problem. If the model is overfitted, and the kind of overfitting turns out to be a problem, then unleveraged trading is safer.

Peter Guenther - Sorry for an confusion.  What I was saying, in respect to Earnings Rocket with In & Out, is there a way to limit the UniverseCoarseFilter(self, coarse) and only return stocks by sector (technology, healthcare, financials etc.,) or by which Index they are consitituents of, say just constituents which are part of the NASDAQ-100, S & P 500, or Russell 2000.

Thank you!

Attached is a backtest for the Earnings Rockets with The Distilled Bear in & out algo. The total return is below the combo with the In & Out. However, there seems to be an issue of uninvested cash from Jul 2020 to now, looking like 7-10% of the total wealth are not invested which certainly drags on performance. It’s also interesting that the max drawdown (27.5%) is above the In & Out combo's (21.8%), since The Distilled Bear has a smaller drawdown when the SPY or QQQ are traded as the stock selection (compare in the In & Out thread). If you spot a coding-related explanation, give me a shout or post an update; I will also go through it again.
 

SEL[Earnings Rockets] + I/O[The Distilled Bear]
Total return: 2383%
Sharpe ratio: 1.35; Max drawdown: 27.5%; Compounding annual return: 28.0

Thunder Chicken: What you could do is to use the Morningstar sectors, for instance by adding an appropriate condition to the CoarseFilter.
For the sectors, see here:

Ctrl + F for "Asset Classification". For instance, MorningstarSectorCode.Technology can give you the technology sector. For a more fine grained classification, you could drill down to the industry group level or industry level. The latter gives you specific industries such as Semiconductors, Solar, Biotechnology etc., so quite a detailed level for your selection.

Hope this helps / provides you with a starting point!

Peter Guenther - Thank you for sending this over.  I am looking at it now.

-TC

Hi folks!

Here it is my contribution: adjusted CoarseSelection using weekly average volume based sorting (since I think the daily volume doesn't make any sense at all - :P )

16.1% drawdown - 4377% TR
 

Nice work there, Simone Pantaleoni , thanks for sharing! I haven’t had a chance to have a detailed look; anyway, the algo looks very promising. Not sure whether you had a chance to check out Leandro Maia ’s point regarding the universe selection being performed one day after rebalance (= one day too late)? Irrespectively, I think that your algo gives the strategy a nice boost.

Peter Guenther - One thing that would be nice to see is the original Momentum Strategy with the distilled bear.  I say such because the original momentum strategy rebalnced the stock portfolio on a monthly basis. The current version of earnings rockets doesn't seem to do so.

https://www.quantconnect.com/forum/discussion/3377/momentum-strategy-with-market-cap-and-ev-ebitda/p1 . 

I've been working on it for a bit but can't seem to reconcile the logic.

Another way to say it would be, the SEL[Earnings Rockets] + I/O[The Distilled Bear] rebalancing monthly, when in market (i.e. owning stocks), but taking no rebalancing action when the I/O flag indicates bonds (i.e. owning TLT IEF etc)

Thunder Chicken I was working on the monthly rebalacing too....in 2020 the strategy doesn't buy any other stock after April and it sticks to the same ones forever...

In the code I posted above, if you un-comment the lines below, you'll get a rebalance every 20 days, or you can change it to whatever number of days you like.

 Damiano Bolzoni - I am experiencing the same issue and attempting to identify the problem.

Thunder Chicken this is what is causing the issue:

 # Only re-shuffle stock allocation when switching from out to in, not in-between
        if not self.be_in_prior and self.be_in:
            self.flip_flag = 1
            self.rebalance()
            self.flip_flag = 0

and

def UniverseCoarseFilter(self, coarse):
        if (self.rebalance_flag or self.first_month_trade_flag) and (self.be_in or self.flip_flag):

(there is a similar check in the "UniverseFundamentalsFilter" function)

Because rebalance() sets the rebalance_flag back to 1, which in turns allows the filter functions to recalculate, no stock return is ever recalculated. On top of that, rebalance() is only called during the in-out switch...

I'm sure it si possible to clean up and "smil down" all these variables that are used to trigger the filter and the rebalance functions...but for now I just managed to trigger a refresh of the stocks after April 2020...I'm now testing the whole 2008-2020 period...

Sorry Leandro Maia I missed your early post(s). Thanks for fixing the rebalancing and for the clode cleanup :-)

Yes I am sorry I think I may have introduced that self flip_flag code.

Also, there is another version here I have shared here that includes the Momentum + EV/Ebitda version to make sure to do at least one rebalance a month. I think Leandro Maia code does that when you uncomment those lines per my testing.

Additionally, the first ever trade is taking about a month (or in this case 20 days) to initially happen. I think some code has to be added in the beginning of the rebalance logic that if initially - Day 1 not in the market then get into the market! (as long as self.be_in or whatever flag is true or non-zero).

My rebalance when out of the market had this code in there, to initially make it trade and not wait as long as self.be_in was non-zero. I will just include the code snippet to not step on anyone's toes:

    def rebalance_when_out_of_the_market(self):
        if self.be_in == 999:
            self.flip_flag = 1
            self.rebalance()
            self.flip_flag = 0

Goldie Yalamanchi - What was the below regarding?

  def rebalance_when_out_of_the_market(self):
        if self.be_in == 999:
            self.flip_flag = 1
            self.rebalance()
            self.flip_flag = 0

Peter Guenther - Just wondering if you figured out the leverage issue with SEL[Earnings Rockets] + I/O[The Distilled Bear]?

Leandro Maia I ran some backtests with your version and it buys different stocks than the version you "fixed". It will go in and out on the same dates, so you would expect the same stocks are being bought (I disabled the in market rebelancing for your version to run those tests).

I didn't notice any difference in the way you select the universe, but you have this lines of code:

if self.month == self.Time.month:
            return Universe.Unchanged

My undertsanding is that your algo will recalculate the momentum stocks at the beginning of the month, but then if the rebalancing takes place 20 days later (because it depends on when the initial stock purchase is performed), the set of momentum stocks could be different. I will work on making the rebalacing a bit "stronger" and less random.

Of course it's always difficult to compare moomentum strategies, also because of the well knwn phenomenon of the "day of rebalancing". Usually rebalancing at the beginning of the month delivers higher returns with these strategies.

Hello,

I am trying to figure out why the attached back test isn't rebalancing monthly.  I would appreciate any help. 

Thank you!

Thunder Chicken that code was to make sure it entered the market when the algo started as long as be_in is 999 or whatever.  Otherwise it would wait until the wait period to enter.

As far as the monthly re-enter, there are various versions of the algo (and getting very difficult to track), if you follow the last version that Leandro Maia attached and uncomment this code below you can have it rebalance monthly:

#if self.be_in and self.reb_count > 0 and (self.dcount - self.reb_count) == 20:
# self.rebalance()
# self.reb_count = self.dcount

So there is a lot going on with the various versions. The version we are talking about is the Earnings Rockets stocks which was supposed to be always by the definition of the universe selection something that should be re-evalauted every month to make sure the fundamentals are maintained. At least the original value momentum algo had that.  The IN/OUT algo is supposed to pull you in or out of the market based on if the signals are bearish or bullish.

Intersecting these particular in/out + value/momentum monthly rebalancing is a challenge. I think as I said if you use Leandro's last algo with of course the code above commented back in it will rebalance in.  My code will make sure the algo will start you into the market and not wait an initial period of 15 days when the algo first starts that would be annoying.

Here is a version I have used that combines the monthly rebalancing + start off into the market without any wait (as long as out signal isnt out)(hopefully I am not contributing to any confusion to all the versions out there now):

Damiano,

the lines below set the universe selection to happen every month start. But the momentum calculation and ranking is done on each trading day. You can change them to have a selection every week or even every day, but simulation time will increase.  

if self.month == self.Time.month:
            return Universe.Unchanged

Hi Leandro Maia so what do you think it's the reason of the different stock selection when you run the strategy (without rebalacing, which should lead to the same selection on the same date)? Perhaps the other one does not recalculate nor ranks stocks every day? I don't believe the universe should change that often...it's picking among stocks with a $2Bn market cap....

Damiano,

in my opinion the difference is certainly the universe selection. As I wrote before, in the orginal version universe is selected one day after rebalance but then only used when the next in-signal is triggered, which could mean months. So doing the selection once a month will certainly change the selected stocks, mainly due to the coarse filter which is based on daily volumes. The ideal would be to use an avarage dollar volume filter, as it was possible in Quantopian and as proposed by Simone above. I still want to implement Simone's idea, but adding a warmup for the volume indicator, which is currently missing.

Hi Leandro Maia I'm still "warming up" with the QuantConnect platform (I'm one of the "Quantopian orphans") and so this comment/remark might be wrong....I noticed in your code this initialization:

self.formation_days = 70

which seems to have an effect on the number of closing prices used to calculate stock returns. The original code posted in the "Momentum Strategy with Market Cap and EV/EBITDA" discussion has that variable sets at 200...is there a reason I'm missing for that choice?

Thanks!

Damiano,

I inherited self.formation_days = 70 from Peter's original version and he probably inherited it from Goldie. I tested using 200 but it doesn't improve the results.

Ah! I see. So first of all, in the 2008-2020 timeframe, using a value of 200 will actually deliver worse results. But...between 2008 and 2019, it will deliver extra returns (more than 10% additional returns), with a minimal increase in drawdown. Moreover, the 2010-2019 timeframe was the longest bull market ever, and so momentum strategies "suffer" from that.

Typically for momentum strategies, you want a 120 trading-day lookback at a minimum. The best results are achieved with 10 months or even 1 year. I'm going to test a value of 250 now.

Thank you!

Great work here, all, and Happy New Year!

Thunder Chicken , I understand that you are after the SEL[EarningsRockets] + I/O[DistilledBear] combo. Please find an implementation attached.

Leandro Maia , spot on, the 70 days setting is from the Goldie/Vladimir algo in the Quality Companies in an Uptrend thread. Good hint that the original had 200 days here.

@all: I have recoded the algo to make the below settings regarding universe selection and momentum filtering. If you have thoughts on that or would do things differently, let me know, will be interesting to hear!

Rebalance universe (see line 121):
(1) every 20 days, see ((self.DCOUNT-self.reb_count)==self.setrebalancefreq)
(2) one day before the wait_days are up, see (self.DCOUNT == self.OUTDAY + self.wait_days – 1)
Note: I have also set self.OUTDAY to -14 initially (line 69), so that the universe is updated on the first day the algo runs (since according to the formula in (2), 0 == -14 + 15 – 1 is TRUE).

Determine momentum and trade (see line 218):
(1) when we change from 'out' to 'in', see (self.BE_IN and not self.BE_IN_PRIOR)
(2) when we are 'in', every 20 days, see (self.BE_IN and (self.DCOUNT==self.reb_count)). Note that I set self.reb_count=self.DCOUNT at the end of the universe fine filter (line 150) so this condition means that the universe filter was running and then also the momentum filter shall be updated.
Additional note: self.BE_IN_PRIOR is set to 0 initially (line 65) so that we directly begin buying equity according to (1) unless the algo directly says ‘out’ on the first day.

The orders in the backtest show that there is swapping going on 20 days after the last re-shuffle. So that looks good. You can experiment with different re-shuffle frequencies by changing self.setrebalancefreq in line 83 (e.g. to 40 = every two months).
It's interesting that the total performance is lower compared to the prior backtests which, due to an error, had a less frequent re-shuffling. Damiano makes an interesting point here, indicating that a strict beginning of month reshuffling might be a better choice—that will be worth a shot to see how it compares to my current settings.

By the way, the algo creates a log which you can download as a text file after the backtest is complete for manual inspection. It tracks which 100 stocks were fine-filtered and when (when you uncomment line 148), as well as which stocks are the chosen 10 stocks after the momentum filter and which stocks are sold because they dropped out of the universe+momentum selection/filters. Due to log file size constraints, when you save the 100 fine-filtered stocks, it will only give you the first two years of the backtesting period, so I have commented that out but can still be interesting to look at.

An additional note: The SEL[QQQ] + I/O[DistilledBear] combo (1843%; see the In & Out thread) outperforms the attached implementation of the SEL[EarningsRockets] + I/O[DistilledBear] combo (1378%). However, the EarningsRockets may have the advantage that we do not commit to the Tech sector, which may be under pressure going forward (I think Goldie made that point earlier since valuations are high). Instead, we select stocks based on their fundamentals, independent of sector.
I reckon it’s also noteworthy that the performance is so much lower compared with the initial version I have posted which used a ‘dated’ filtered universe. Does this mean that regular updating does not necessarily lead to better results?

One final note: The leverage sometimes goes up to 1.05. At the end, in Nov and Dec 2020, it even goes to 1.10. We might need to set the weight (line 238) to something below 0.99/len(chosen_df), unless someone has another cool move to keep leverage strictly below 1 (?).

Any bugs/unintended outcomes, give me a shout!

Just one follow up regarding additional findings: When I set self.setrebalancefreq = 60, the results are:
Total returns: 1634% (better)
Sharpe ratio: 1.1 (slightly better); Max drawdown: 25.3% (better); Compounding annual return: 24.5% (better)
However, the leverage issue (going above 1 and up to 1.1) seems to get worse.

Peter Guenther I was also looking into "taming" leverage. I found this post on QuantConnect (I knew how to do it on Quantopian :-), but haven't tested it yet.

An additional comment about the day the algorithm trades when it's IN the market. At the moment the trading takes place at 11:30am. The reason why the last day/first day of the month usually deliver more returns could be (nobody really confirmed it over the years :-) that (big) funds are usually rebalancing around those days, so the needle moves more. However, by trading at 11:30am, those entities could have already "dumped" everything they had to. So trading at 11:30am it's sort of trading on the second day of the month, which seems to deliver the best results :-)

Peter Guenther I honestly believe that we shouldn't try to optimize too much the momentum side of the algo. We can only test it over 12 years, which do not include the 2000 meltdown and on the other hand include the longest bull market ever....
The version that never rebalanced in market would deliver astonishing returns because it would hold TSLA from end of April onward...that was just a lucky coincidence... 

Peter and Damiano,

the only way I was able to control the leverage runup was doing, during rebalance, SetHoldings for all the symbols: the ones that will be kept and the new ones. 

Damiano Bolzoni , great stuff, thanks for forwarding the link regarding the leverage control approach. I will have a look and see whether I can get it integrated. Good insights concerning beginning-of-month trading and the impact of TSLA driving returns in the initial algo version; important points, thanks for sharing!

Leandro Maia , nice, I will try that approach. I had exchanged the individual stock loops through dictionary expressions to achieve a reduction in execution time. But I have to check again whether reversing the approach might help regarding the leverage issue.


I also have tried to play around with the self.formation_days, increasing it from 70 to 126 (~ half a year) in the algo version I mentioned above with self.setrebalancefreq = 60. It seems to help performance a little bit. But I reckon I have to fix the leverage issue first to actually be able to compare the returns.
Total returns: 1828% (better)
Sharpe ratio: 1.13 (better); Max drawdown: 22.4% (better); Compounding annual return: 25.5% (better)

Has anyone figured out how to make this last version consume less memory? cc Leandro Maia 

Radu,

I don't have any suggestion at the moment. I guess its a consequence of adding universe selection and simulating from 2008...

Radu Spineanu I noticed that from one versiono onward, the resolution was set to "Minute". The algorithm would take more than 1 hour to complete (and I didn't check, but memory might go up as well), I set it back to "Hour" and now I can complete a run in 10 mins or so. Of course this affects returns, but it's honestly negligible because directionally you will get the same results.

Damiano Bolzoni Leandro Maia   Unfortunately changing the resoution to Hour or simulating from 2020 on didn't do anything. It must be the universe selection.

I tried to understand some of the changes the QuantConnect team did to improve the memory requirements of a previous implementation and got lost. I'll have to try again.

Hi everyone,

To speed up the execution of the algorithm, we can:

• Decrease the resolution of the data to hourly. However, this requires us to change the timing of our first scheduled event. With hourly resolution, there is no bar 120 minutes after the open (11:30AM).
• Remove the `AddEquity` call inside the `rebalance` method. This is redundant as the universe subscriptions are handled by the universe selection model or are completed in the `Initialize` method.
• Reduce the fundamental universe size.
• Simplify the `calc_return` method to sort the `data` dictionary based on the ROC values instead of building a DataFrame.
• Unsubscribe the SymbolData ROC indicator when the security is removed from the universe.

To clean up the OnSecuritiesChanged method, consider moving the warm-up logic to inside the SymbolData class. Lastly, we recommend avoiding try-except blocks as they can make debugging more difficult.

See the attached backtest for reference. It has the changes listed above.

Best,
Derek Melchin

Derek Melchin thank you for this!

My 2 Cents guys! :) 

As starting point I've took the latest release published by Derek Melchin 
Reviewed Coarse Selection of stocks - Improved Total Return, Drawdown and Sharpe

Enjoy it :) 

Great work everyone! I took Simone's and did the following:

• Lowered the volatility timeframe down to 100 from 252.
• Lowered the stocks to trade to 5 from 10.
• Raised the screener from 10 to 20
• Raised coarse filtering to stocks >$5 from >$2

Drawdown is now down to -19% and annual return about double that at 38%.

Mark,

thanks for sharing your results. I just wanted to make a couple of comments.

First the indicator calculating the dollar volume average in the universe selection is not updating daily, but only when the algo is about do the rebalance. The indicator is also not being warmed-up.

Regarding the change in volatility timeframe, the self.lookback variable was supposed to be 126 and not 252. I think this was copy and paste mistake from someone, which used the other I&O algo.

The other place you changed the volatility was in the annualized volatility calculation, where sqrt(252) is used for anualization. To keep to code more understandable I would suggest you to keep 252 and instead apply a factor corresponding to sqrt(100) / sqrt (252) or 0.6. 

Thanks for that Leandro, I didn't know the sqrt 252 was for annualized vol. 

Derek Melchin, Simone Pantaleoni, mark hatlan, and Leandro Maia: Fantastic work there on the algo (SEL[EarningsRockets] + I/O[DistilledBear])!!

To add to our pool of stock selection strategies combined with I/O strategies: An old classic from Quantopian combining the “Quality Companies in an Uptrend” stock selection with the In & Out.

SEL[QualUp] + I/O[In & Out]
Chris Cain posted the original “Quality Companies in an Uptrend” strategy on Nov 22 2019 (Quantopian). It has seen some early tweaks which the attached algo builds on. The idea is to select high-quality stocks based on several fundamentals: (1) cash return, (2) free cash flow yield, (3) return on invested capital (roic), and (4) leverage. Basically, firms are ranked on each of these factors and these ranks are aggregated. There is a certain hierarchy: Factors (1) and (2) are combined first (i.e. sum ranks and calculate a new rank) into a value factor. The final quality factor results from combining the value ranking with the roic and leverage rankings.
Then the quality stocks are ranked according to their momentum and the top 20 stocks are bought.

Backtesting period: Jan 1 2008 to now
Total return: 3,597%
Sharpe: 1.25, Compounding annual return: 31.89%, Max drawdown: 33.00%

Some specifics regarding the selection process:
- start with the top 500 dollar volume stocks
- select the top 250 stocks according to the fundamentals ranking
- select the top 20 stocks based on the momentum ranking

Like SEL[EarningsRockets], SEL[QualUp] has the advantage that we do not need to commit to a certain sector (e.g. Tech) since the selection is based on fundamentals, giving all sectors an equal chance to make it into the final selection. The stock vector changes dynamically over time depending on which sectors/stocks are doing the greatest.

I still have to give Jonathon Tzu ’s modified QualUp a shot.

Follows another version of Distilled Bear with Stock Selection based on the findings of Mark.

Total return: 9532%

Drawdown: 23%

CAGR: 42%

Sharpe: 1.641

Great work there again, Leandro Maia and mark hatlan (and others)!
I performed the 'Damiano Bolzoni test' :) and removed TSLA from the universe (if you want to try yourself, see the attached backtest; lines 39-41 and 145-148). The returns are holding up quite nicely: 6,675.80% total return. Also the reduction to 5 stocks from 10 stocks in the final holdings vector holds up nicely. For 10 stocks the total return would be 3,222.34% i.e. 5 stocks perform better. Great stuff!

Returns also look good from the perspective of the annual saw tooth chart (see In & Out thread; here: versus holding QQQ). Of course, three years substantially contribute to the total return: 2008, 2010 and 2020. Anyway, the strategy (blue line) hardly underperforms QQQ (black line), only in 2009 and 2013. In all the other years you have overperformance. This looks very good!

Thats a cool returns chart, how did you display that?

As for the returns yes 2020 dramatically improves overall profitability. If you remove 2020 then you get around 2100% return, drawdown 20% and CAR 29%. Which still isn't that bad, mind that it still uses TLT instead of TMF.

Only other thought I have is to hedge the stocks with IEF, but in order to preserve profitability it needs to use margin for that hedge.

mark hatlan: Attached is an algo that includes the relevant code to create the chart. Feel free to just copy and paste the relevant code snippets since the algo also includes the TSLA test I preformed earlier:
lines 74-81: initialize a few variables for the chart(s)
line 244: call the chart function as part of the daily in/out signal check
lines 315-324: a few calculations for the saw tooth chart (Portfolio return vs QQQ return)
line 334: a variable that saves the current year. At year change (line 317) the base to calculate the return is reset, creating the saw tooth view.

Great Stuff Peter Guenther  Derek Melchin, mark hatlan, and Leandro Maia: ! This is rocking hard now with the latest changes! :D 

I have another idea to include in the project, so let's keep posted! :D

Here we go again. Is not the last release I've "promised", but I've seen somebody forgot to include the weekly volume based Coarse Selection I've posted out a few comments ago :)
Performance wise it improve Total Return, Sharpe heavily (up to 1.814), and also bring in a slightly lower Drawdown.

 

Simone,

in you implementation the price volume average indicator is being update only when the algo is about to rebalance and the universe selection is executed. So it's not a 5 day average, but the average of the last 5 times when rebalance happend. If you make it update daily you see that there's no almost no change in the results but the backtest takes much longer to run.  

Gotcha! Thanks for spotting it Leandro :) was early morning in my defense :P :) 

Some quick findings to share:
When we have the In & Out underlying, the total return is at ~2,000%, so much lower. A stricter universe updating regime (4th Feb and then every three months) can get us to 3,300%. The universe updating timing appears to play a key role. It seems that updating less often (Distilled Bear) versus more often (In & Out, which is ‘out’ more often and then updates the universe before getting back in) leads to higher total returns. The DistilledBear generally appears to have the better timing in the backtest. I will have a look whether this is specific to the stock selection or can be generalized to other stock selections (e.g. QualUp).

  Peter Guenther is there a way you can share the latest versions of both Distilled Bear and In&Out versions? It's difficul to go back in the thread and find the "right one" :-)

Thanks!

In general, for momentum-based strategies rebalcing once a month is optimal. So I would change the 60-day rebalancing baked in right now. Furthermore, it is well known that the date picked for rebalancing can have huge influence n the returns ("timing luck"). Rebalancing at the very beginning of the month bears higher returns compared to middle of the month. I never found a reliable explenation, I would say it's because the big funds will rebalance around the end or beginning of the month.

Damiano Bolzoni: Thanks for your comments!

Attached is an algo that includes both the In & Out and Distilled Bear algos, with a switch in line 55 (self.go_inout_vs_dbear set to 1 vs 0). The ‘engine rooms’ of the in & out algos are the signal checks which are sitting in the functions def signalcheck_inout(self) and def signalcheck_dbear(self), respectively. This set up may allow to efficiently compare ‘in & out plus stock selection’-combos.

The stock selection strategy is the Valuation Rockets (slightly relabelled compared to earlier since the selection is mainly based on a valuation multiplier plus momentum).

It also includes the saw tooth chart (Portfolio vs QQQ; lines 377-381), which I recoded a bit to make it more compact.

I have replaced the leverage line with a chart showing the cash level (settled and unsettled). We want to avoid going into the negative territory here (for an unleveraged play) and reduce the amount of unused cash.

Regarding the actual results of the previous post’s attached algo: It shows that by merely switching the in & out logic between the two in & out algos which yield similar results when holding the SPY or QQQ (In & Out thread), the total return goes from about 9,000% (Distilled Bear) to 1,500% (In & Out). Open for discussion: This sensitivity may be a warning sign regarding very lucky timing in the Valuation Rockets & Distilled Bear combo (esp. the timing of the universe reshuffle)? I mean, I could still imagine to trade the combo but possibly not with the weight I initially planned to. Any thoughts/something that I am not seeing?

Following up and, again, open for discussion: For the ‘Quality Companies in an Uptrend’ stock selection (QualUp), the results of the in & outs are markedly closer together which is somewhat comparably reassuring?

Additional thought: The ‘annual saw tooth chart’ shows that the in & outs have their excess returns at different points in time. Could this be a rationale for mixing the two logics and trade them 50-50 in terms of being 100%, 50%, or 0% ‘in’/’out’?

SEL[QualUp] + I/O[In & Out]:

SEL[QualUp] + I/O[Distilled Bear]:

Hi Peter,

Yes, that could be a rationale for looking into mixing the strategies together. Consider calculating the correlation of daily returns between the two strategies. Combining non-correlated return streams may increases profits and reduces drawdowns over the backtest period.

Best,
Derek Melchin

hello,

I found something strange in the script.

# Filter the values of the dict: we only want up-trending securities

values = list(filter(lambda sd: sd.smaw.Current.Value > 0, self.averages.values()))

smaw is simplemovingaverage which is showing stock's average price within certain periods.Therefore, to my understanding, this line of code filters every stocks since stock price should be more than 0?

and following line,

values.sort(key=lambda x: (x.smaw.Current.Value), reverse=True)
        #values.sort(key=lambda x: (x.volume_ratiol), reverse=True)

        # we need to return only the symbol objects
        return [ x.symbol for x in values[:self.num_coarse] ]   

These will filter the most expensive stocks in order.

Can please someone answer my question?

Juwan, smaw should be for volume, not for price.

Chak, can you explain more detail why? Sma does not consider volume.

Hi Guys, 

First, let me tell you that you are doing great work here, please keep it up.

As I am based in the EU and have an account with IB here, I am not allowed to trade TLT or any other US ETF. As QuantConnect does not facilitate the trading of European ETFs, I am trying to find a workaround. Here is what I intend to do: 

1. Use this algorithm to generate the stocks universe and trade them automatically on QC(IB).

2. Once the signal switches from be_in to be_out, it should generate an email, notification for me to trade the European equivalent of TLT (IS04.DE). I will do the trading manually.

3. After the signal switches back to be_in then it should liquidate the IS04.DE position. I want to use self.Liquidate() to close all open positions, before the algorithm does the rebalancing and enters into stocks again. 

Can anyone here tell me, if self.Liquidate() will also close out positions that I have opened manually in IB Trader Workstation? 

Anyone here faced the same issues trading from the EU. Maybe there is a more elegant and automated solution? 

Derek Melchin I saw some discussions from 2017, where QC staff were promising to allow trading of Non-US instruments and also IB CFDs. Is this coming anytime soon? 

Many thanks!

Dimitar 

Dimitar Dimitrov, thanks for joining in and I have to say: that would be amazing to develop an equivalent for European shares!
[side note: Regarding trading US shares at IB, couldn't you just exchange USD, sign their declaration to trade US shares (incl. tax residency) and go for it? You might just have to add the US market to your trading permissions. Of course, being located in Europe, you would then have the exchange rate risk, but that might be still OK in the USD/EUR pair.]

Peter Guenther thanks for your reply. Actually, the Issue is not in trading the stocks' selection. I can trade US Stock at IB and this what I intend on doing. The problem is with trading the Bond Leg as TLT is not available for trading in the EU. It is a regulatory restriction due to the KID rules. There is a European ETF that also tracks the performance of the 20+ Year Treasury bonds (IS04.DE), but unfortunately, QC does not support trading for this instrument. 

If someone knows how the self.Liqidate() behaves it will be great. 

In general, I totally agree that this strategy should also be tested on other markets to make sure that there is not overfitting to the US historical data. Therefore, I asked the QC team, when they intend to allow trading for other Non-US markets. 

Alternatively, if someone has data we could try and implement a Custom Data source at least for the backtest.

Got it, that's good to know, Dimitar Dimitrov! Regarding your question, self.liquidate() would sell everything, i.e. also the non-algo holdings you have in the account. I found this thread here: 

I reckon the safest way is to open an additional linked IB account for the algo (via Account Settings). The link enables easy funds transfer between the accounts.

Hello guys, 

Firstly I would like to thank all of you for contributing your knowledge to this community. As a beginner, I have learned a lot reading this topic. 

As I come from Europe I have the same issues as Dimitar. I have found this link: https://logical-invest.com/pripps-and-kid-compliant-etfs-for-european-investors/, which says SPY and GLD are also forbidden for Europeans to trade. Is this correct? 

Thanks for your help once again!


 

Hi Primoz Golle

Yes all of those instruments are not available for trading in Europe. The link that you shared is the regulation that requires KID which the US ETF providers don't support. For all of them you can find equivalents traded on the European exchanges, but QC does not support those yet. However, in this strategy you are not trading the ETFs, you only use them for signal generation. You can trade the stocks using QC, for TLT I am still trying to find a solution. 

I hope this helps. 

Best regards, 

Dimitar 

Hello Dimitar,

may I ask which country you reside in? Generally IB provides access to US exchanges and you can trade TLT, this is not an issue with regulation afaik (for me as a german resident at least). Have you checked your account settings / trading permissions?

Best, Fabmei

Dimitar, thanks for detailed explanation. Fabmei, thanks for remark, i will check with the IB. Probably the same rules should apply to the trading of natural persons of all eu residents, if I'm not mistake?

Hi Fabmei

Thanks a lot for the tip. That is strange! I am based in Germany as well, but IB Support told me that I it is not available for trading in Germany. Do you also have an IB PRO Account?

I'll just try and buy 1 on my live account, to see if they are going to execute it or not.

Best, Dimitar 

Hello everyone!

Since this thread and algorithm are popular, let me make some considerations to help those who are considering putting their money on the line.

Scheduled events work slightly differently in live and backtesting mode. While backtest is purely data-driven, scheduled events are triggered by the clock in live mode. So, if the scheduled event is set to fire at 10 am, it will fire at 10 am o'clock. On the other hand, hourly data will be synchronized into the Time Slice a few milliseconds later, e.g. 10:00:00.0123. Consequently, CurrentSlice might not have the market information and CurrentSlice.ContainsKey(symbol) with return false for most if not all symbols.

In order to address this issue, we can use minute resolution data or set the scheduled event to 10:01. I suggest using minute-resolution data. Please keep in mind that minute-resolution data is L1 so orders will be filled at the bid/ask and backtest will be more realistic.

Additionally, we can remove the CurrentSlice.ContainsKey check, since we are getting the price from Securities[symbol].Price. In principle, this variable is not zero for liquid assets with minute resolution data.

I would recommend adding strategic logging to the algorithm in live trading. When we deploy an algorithm for the first time, it will help us understand why it's not working as expected. Since there is a daily quota limit in backtesting but not in live mode, we can use the following method to only log in live:

Really great pointers. Thanks for sharing these hints with us, Alexandre Catarino!

Thanks for sharing, Strongs. Your post just brought up a thought that I think might be worth re-emphasizing (you also mention aspects of it): The ValuationRockets selection (on EV/EBITDA) means to select stocks that are extremely highly valued against the background of their earnings: The smaller the (positive) earnings a company generates, the higher the EV/EBITDA. Of these firms, we select the ones whose stock prices were increasing the fastest (the momentum logic). Think: we hype the hype. This is a high risk strategy, considering that something that is valued very highly might have a lot of room to drop. In comparison, for example, the QualUp stock selection is lower risk (and probably lower return in the long run). Due to the recent market/tech drawdown, the QualUp selection has performed better year-to-date than the ValuationRockets selection. Of course, this is only a current snap shot and we'll have to see what the year still has in store:

ValuationRockets: -16.2%      <-------->      QualUp: +21.4%

It looks like this isn't doing so well since mid february. Possibly due to meme stocks becoming more popular and thus potentially harder to predict?

Thanks for sharing this insight, Ian McCann. I assume you are referring to the QualUp stock selection (?). I think you are right, the algo picks up certain meme stocks. This is due to the momentum logic. I am trading a QualUp-ish logic manually (will move to auto trading at some point), so had to check here on QC, and to add to your point: The in & out logic also seems to play a major role. Returns for the following combos since mid Feb; they differ vastly:
[Qual Up] + [InOut]: -32.79% <---------> [Qual Up] + [DistilledBear]: -0.69%

As a reference, since the beginning of the year:
[Qual Up] + [InOut]: +28.50% <---------> [Qual Up] + [DistilledBear]: +50.84%

So, I guess you are right, meme stocks are distorting the picture and therefore timing is a key driver of returns. A certain component of the returns is probably not highly predictive for the future and comes with elevated risk/volatility.

It is a beautiful concept this. Do not be disheartened by the recent drawdown, the market as a whole has been flailing without direction in the past few months. My own algorithm that had been effectively infallible through the past few years got battered by a series of unprecedented events we see unfolding right now. My hedges (TLT, SCO *2x inverse oil, GLD *miraculously falling amid inflation panic and a brainless Bitcoin mania, and UVXY *has been inflated for the entire year and has lost some of its inverse correlation with overall market). I am speaking as someone in a similar boat, keep up the good work! 

Hi, sorry for the silly question! I'm new to the platform. Is the source code of the algo, discussed here, uploaded somewhere, where one can see latest version and revisions, or we have only the separate examples kindly shared by people in the thread?

Hi Vasil,

All the public versions of the strategy are attached throughout this thread and a this second thread. To view the source code in the QC IDE, click the Clone Algorithm button in one of the attached backtests above. In this thread, the latest algorithm shared is available here.

Best,
Derek Melchin

Thanks for your words of support and for sharing your insights regarding hedges, Samuel Schoening! Agreed, let’s continue the quest for amazing returns and against drawdowns, return fluctuations, etc.

Welcome to the discussion, Vasil Lazarov! Derek Melchin has provided a cool overview there. One additional thought: There are multiple algos in this thread that do things differently, particularly in terms of how they select stocks and when they are invested in the equity market versus bonds. So, the thread is not necessarily building toward one algo (with a latest version) but instead is a selection of multiple algo ideas that we can develop further (i.e., in the sense of 'a marketplace of ideas'). Feel free to try out things and leave a post if something interesting pops up.

I just quickly wanted to feature a recent algo here that buys call options (instead of the stocks) based on the selection of the DistilledBear + QualUp combo discussed in this thread. So, this could be interesting for folks who are open to trading options.
.ekz has developed the algo and has shared it here: link
Also, see the modifications by Derek Melchin (efficiency gain) and spacetime (error fix).

Hi guys, I have used a Piotrosky F-score as fundemental screener for the stocks 

Very nice work, Strongs! Thanks for sharing. This is quite sophisticated code including the different classes etc., so plenty there to learn from your approach.

It is also a new stock selection strategy, so the combo would be: [F-Score] + [DistilledBear].

I think this gives us the following stock selection strategies in this thread:
[TQQQ], [ValuationRockets], [QualUp], and [F-Score]

which can be combined with the following in & out strategies:
[InOut] and [DistilledBear]

So, eight possible combinations to choose from. Very cool!

How timely! 

I just learned about the Piotrosky F-score recently, and was mulling over how to implement it. 

It's moment like this that make this platform / community so great.  

Fantastic work Strongs  and thanks!