Long/Short strategy in framework using SuperTrend

Anyone?

hi Johan,

I'm routinely using symbols that I don't intend to actually trade (e.g. benchmarks or as in your case to determine the current market regime).
In such a case I would just create an array of excluded symbols during Initialize and check against those symbols before creating orders/emitting insights.
There might be a more elegant way of doing this, but it works.

I can have a look later on and post some snippets, but it's really quite straightforward.

Let's say in Initialize I have created a symbols for SPY, I don't want the algo to trade. I would add the ticker in an array of exclusions:

class MyAlgo(QCAlgorithm):
	def Initialize(self):
		...
		self.spy = self.AddEquity('SPY', Resolution.Daily).Symbol
		...
		self.exclusions = ['SPY']

As I normally maintain an array with all symbols in my universe (to train models etc.),  I'd make sure the excluded symbols are not added in OnSecuritiesChanged:

class MyAlgo(QCAlgorithm):
	...
	def OnSecuritiesChanged(self, changes):
		...
		for security in changes.AddedSecurities:
    		if security.Symbol.Value not in self.exclusions:
        		self.symbols.append(security.Symbol)

If using the algorithm Framework, Insights would be generated in the Alpha Model's Update Method. So this is where I'd also check for the symbol to be excluded (if using the classic algorithm this would obviously be somewhere in OnData):

class MyAlpha(AlphaModel):
	...
	def Update(self, algo, data):
		...
		for symbol in self.algo.symbols:
    		symbol = SymbolCache.GetSymbol(symbol)
        	if symbol.Value not in self.algo.exclusions:
        		# dummy trading logic...:
        		if signal:
            		insights.append(Insight.Price(symbol, ...))

That way I'll have SPY in my universe and can use it to extract information, but I can make sure it won't get traded.

Does that make sense?

Hey Johan Ekh,

updated post:

adding some links that might help building your algo:

• Selection of stocks
  • Morningstar(with examples)

Thanks alot! I will read this carefully and see if I can make it work as intended. If not, I will report back and add my code. 

Thank you!

Hi again

I'm still struggling to get it to work as I want. Basically, I want to convert a long only strategy from the community to a long/short strategy based on the SPY trend. The main.py and the AlphaModel.py are included below in the long only versions. Could anyone indicate how to achive this in a simple way?

Main.py:

from AlphaModel import *
class VerticalTachyonRegulators(QCAlgorithm):
   def Initialize(self):
       self.SetStartDate(2020, 1, 1)
       self.SetEndDate(2021, 1, 1)
       self.SetCash(100000)
       # Universe selection
       self.month = 0
       self.num_coarse = 500
       self.UniverseSettings.Resolution = Resolution.Daily
       self.AddUniverse(self.CoarseSelectionFunction, self.FineSelectionFunction)
       
       # Alpha Model
       self.AddAlpha(FundamentalFactorAlphaModel())
       # Portfolio construction model
       self.SetPortfolioConstruction(EqualWeightingPortfolioConstructionModel(self.IsRebalanceDue))
       
       # Risk model
       self.SetRiskManagement(NullRiskManagementModel())
       # Execution model
       self.SetExecution(ImmediateExecutionModel())
   # Share the same rebalance function for Universe and PCM for clarity
   def IsRebalanceDue(self, time):
       # Rebalance on the first day of the Quarter
       if time.month == self.month or time.month not in [1, 4, 7, 10]:
           return None
           
       self.month = time.month
       return time
   def CoarseSelectionFunction(self, coarse):
       # If not time to rebalance, keep the same universe
       if not self.IsRebalanceDue(self.Time): 
           return Universe.Unchanged
       # Select only those with fundamental data and a sufficiently large price
       # Sort by top dollar volume: most liquid to least liquid
       selected = sorted([x for x in coarse if x.HasFundamentalData and x.Price > 5],
                           key = lambda x: x.DollarVolume, reverse=True)
       return [x.Symbol for x in selected[:self.num_coarse]]

   def FineSelectionFunction(self, fine):
       # Filter the fine data for equities that IPO'd more than 5 years ago in selected sectors
       
       sectors = [
           MorningstarSectorCode.FinancialServices,
           MorningstarSectorCode.RealEstate,
           MorningstarSectorCode.Healthcare,
           MorningstarSectorCode.Utilities,
           MorningstarSectorCode.Technology]
       
       filtered_fine = [x.Symbol for x in fine if x.SecurityReference.IPODate + timedelta(365*5) < self.Time
                                   and x.AssetClassification.MorningstarSectorCode in sectors
                                   and x.OperationRatios.ROE.Value > 0
                                   and x.OperationRatios.NetMargin.Value > 0
                                   and x.ValuationRatios.PERatio > 0]
               
       return filtered_fine

AlphaModel.py:

class FundamentalFactorAlphaModel(AlphaModel):
   
   def __init__(self):
       self.rebalanceTime = datetime.min
       # Dictionary containing set of securities in each sector
       # e.g. {technology: set(AAPL, TSLA, ...), healthcare: set(XYZ, ABC, ...), ... }
       self.sectors = {}
   def Update(self, algorithm, data):
       '''Updates this alpha model with the latest data from the algorithm.
       This is called each time the algorithm receives data for subscribed securities
       Args:
           algorithm: The algorithm instance
           data: The new data available
       Returns:
           New insights'''
       if algorithm.Time <= self.rebalanceTime:
           return []
       
       # Set the rebalance time to match the insight expiry
       self.rebalanceTime = Expiry.EndOfQuarter(algorithm.Time)
       
       insights = []
       
       for sector in self.sectors:
           securities = self.sectors[sector]
           sortedByROE = sorted(securities, key=lambda x: x.Fundamentals.OperationRatios.ROE.Value, reverse=True)
           sortedByPM = sorted(securities, key=lambda x: x.Fundamentals.OperationRatios.NetMargin.Value, reverse=True)
           sortedByPE = sorted(securities, key=lambda x: x.Fundamentals.ValuationRatios.PERatio, reverse=False)
           # Dictionary holding a dictionary of scores for each security in the sector
           scores = {}
           for security in securities:
               score = sum([sortedByROE.index(security), sortedByPM.index(security), sortedByPE.index(security)])
               scores[security] = score
               
           # Add best 20% of each sector to longs set (minimum 1)
           length = max(int(len(scores)/5), 1)
           for security in sorted(scores.items(), key=lambda x: x[1], reverse=False)[:length]:
               symbol = security[0].Symbol
               # Use Expiry.EndOfQuarter in this case to match Universe, Alpha and PCM
               insights.append(Insight.Price(symbol, Expiry.EndOfQuarter, InsightDirection.Up))
       
       return insights
   def OnSecuritiesChanged(self, algorithm, changes):
       '''Event fired each time the we add/remove securities from the data feed
       Args:
           algorithm: The algorithm instance that experienced the change in securities
           changes: The security additions and removals from the algorithm'''
       
       # Remove security from sector set
       for security in changes.RemovedSecurities:
           for sector in self.sectors:
               if security in self.sectors[sector]:
                   self.sectors[sector].remove(security)
       
       # Add security to corresponding sector set
       for security in changes.AddedSecurities:
           sector = security.Fundamentals.AssetClassification.MorningstarSectorCode
           if sector not in self.sectors:
               self.sectors[sector] = set()
           self.sectors[sector].add(security)

Hey Johan Ekh,

I will provide a possible way, it is not said that this will fit you and you're free to change it however you like.

In the FineSelectionFunction(main.py) we filter for equities with values in ROE, NetMargin and EPSRATIO that are higher than 0 because of the “long” strategy. What we could do is delete those so that we also have negative ones that we will short.

filtered_fine = [x.Symbol for x in fine if x.SecurityReference.IPODate + timedelta(365*5) < self.Time
                                   and x.AssetClassification.MorningstarSectorCode in sectors]

After that we will have to rewrite the Update function (AlphaModel.py) to also give Insights into the down direction:

def Update(self, algorithm, data):
        '''Updates this alpha model with the latest data from the algorithm.
        This is called each time the algorithm receives data for subscribed securities
        Args:
            algorithm: The algorithm instance
            data: The new data available
        Returns:
            New insights'''
        if algorithm.Time <= self.rebalanceTime:
            return []
        
        # Set the rebalance time to match the insight expiry
        self.rebalanceTime = Expiry.EndOfQuarter(algorithm.Time)
        
        insights = []
        
        for sector in self.sectors:
            securities = self.sectors[sector]
            sortedByROE_pos = sorted(securities, key=lambda x: x.Fundamentals.OperationRatios.ROE.Value, reverse=True)
            sortedByPM_pos = sorted(securities, key=lambda x: x.Fundamentals.OperationRatios.NetMargin.Value, reverse=True)
            sortedByPE_pos = sorted(securities, key=lambda x: x.Fundamentals.ValuationRatios.PERatio, reverse=True)
            sortedByROE_neg = sorted(securities, key=lambda x: x.Fundamentals.OperationRatios.ROE.Value, reverse=False)
            sortedByPM_neg = sorted(securities, key=lambda x: x.Fundamentals.OperationRatios.NetMargin.Value, reverse=False)
            sortedByPE_neg = sorted(securities, key=lambda x: x.Fundamentals.ValuationRatios.PERatio, reverse=False)
            # Dictionary holding a dictionary of scores for each security in the sector
            scores_pos = {}
            for security in securities:
                score = sum([sortedByROE_pos.index(security), sortedByPM_pos.index(security), sortedByPE_pos.index(security)])
                scores_pos[security] = score

            scores_neg = {}
            for security in securities:
                score = sum([sortedByROE_neg.index(security), sortedByPM_neg.index(security), sortedByPE_neg.index(security)])
                scores_neg[security] = score
                
            # Add best 20% of each sector to longs set (minimum 1)
            length = max(int(len(scores_pos)/5), 1)
            for security in sorted(scores_pos.items(), key=lambda x: x[1], reverse=False)[:length]:
                symbol = security[0].Symbol
                # Use Expiry.EndOfQuarter in this case to match Universe, Alpha and PCM
                insights.append(Insight.Price(symbol, Expiry.EndOfQuarter, InsightDirection.Up))

            length = max(int(len(scores_neg)/5), 1)
            for security in sorted(scores_neg.items(), key=lambda x: x[1], reverse=False)[:length]:
                symbol = security[0].Symbol
                # Use Expiry.EndOfQuarter in this case to match Universe, Alpha and PCM
                insights.append(Insight.Price(symbol, Expiry.EndOfQuarter, InsightDirection.Down))

So what is done here is that we take the best ones on the positive side and the worst ones on the negative site:

sortedByROE_pos = sorted(securities, key=lambda x: x.Fundamentals.OperationRatios.ROE.Value, reverse=True)
sortedByPM_pos = sorted(securities, key=lambda x: x.Fundamentals.OperationRatios.NetMargin.Value, reverse=True)
sortedByPE_pos = sorted(securities, key=lambda x: x.Fundamentals.ValuationRatios.PERatio, reverse=True)
sortedByROE_neg = sorted(securities, key=lambda x: x.Fundamentals.OperationRatios.ROE.Value, reverse=False)
sortedByPM_neg = sorted(securities, key=lambda x: x.Fundamentals.OperationRatios.NetMargin.Value, reverse=False)
sortedByPE_neg = sorted(securities, key=lambda x: x.Fundamentals.ValuationRatios.PERatio, reverse=False)

Hope it helps ;)

Thank you very much Nico!

This was very helpful! One last thing that I struggle with is to generate the insights, long or short, depending on the current market trend. I want to go either long OR short depending on the trend but I fail to understand the best way to use  an indicator when using the framework. Could you indicate the simplest way to check the trend using SPY and Supertrend?

BR / Johan

Hey Johan Ekh,

you could use the SUPER-TREND indicator provided by QC. Then use something like a symbol class to feed the indicator, check if it is ready and update it. After that you will be able to sort the symbols depending on the trend they are in and then use the code that I provided to construct negative and positive insights.

You might want to take a look at the posts in the forum, there are countless examples of this.

Best,

Nico

Thank you! I´m trying it and will report back!

Johan