Risk management doesn't seem to be limiting drawdown to specified max percentage.

Hi James

I have been dealing with this issue before. 

The thing is that the portfolio rebalances the day after the flat signal has been produced by the risk management model. To stop this from happening, the best thing is to import the logic of the “MaximumDrawdownPercentPortfolio” to the alpha model. I suggest you go over this thread: 

Thanks for the help Lucas ! Unfortunately, that specific solution is quite above my skill level 😬. I'm trying to implement a simple tradeLock instead, which is enabled on each insight and not disabled until 2359 EOD. However, the tradeLock function is in the AlphaModel class and I am not quite sure how to call that function via a schedule from the Initialize class. Basically, cross-class function calling. What are your thoughts?

class PriceActionTQQQ(QCAlgorithm):
    
    def Initialize(self):
        
        self.SetStartDate(2017, 1, 1)  
        self.SetCash(100000)  
        self.TQQQ = self.AddEquity("QQQ", Resolution.Minute).Symbol  
        self.SetBenchmark("QQQ")
        self.SetBrokerageModel(BrokerageName.InteractiveBrokersBrokerage)
        self.SetExecution(ImmediateExecutionModel())
        self.SetPortfolioConstruction(EqualWeightingPortfolioConstructionModel())
        
        symbol = [Symbol.Create(self.TQQQ, SecurityType.Equity, Market.USA)]
        self.AddUniverseSelection(ManualUniverseSelectionModel(symbol))
        
        self.AddAlpha(PriceActionTQQQAlphaModel(self, self.TQQQ))
        
        self.SetRiskManagement(MaximumDrawdownPercentPortfolio(0.045))
        
        self.Schedule.On(self.DateRules.EveryDay(self.TQQQ), self.TimeRules.At(23, 59), PriceActionTQQQAlphaModel(self, self.tradeLockReset))
        
class PriceActionTQQQAlphaModel(AlphaModel):
    
    tradeLock = False

    def __init__(self, algorithm, tkr):
        self.period = timedelta(days=1)
        self.symbol = tkr
        self.symbolData = SymbolData(algorithm)
    
    def Update(self, algorithm, data):
        insights = []
        
        HO = 0.0
        OL = 0.0
        
        if self.symbolData.Updated:
            Open  = self.symbolData.open
            High  = self.symbolData.high
            Low   = self.symbolData.low
            Close = self.symbolData.close
            
            HO = High -  Open
            OL = Open - Low
            HC = High - Close
            CL = Close - Low
            
            if Close > Open:
                if HO > OL and self.tradeLock == False:
                    insights.append(Insight(self.symbol, self.period, InsightType.Price, InsightDirection.Up, 1, None))
                    self.tradeLock = True
                
            if Close < Open:
                if HO < OL and self.tradeLock == False:
                    insights.append(Insight(self.symbol, self.period, InsightType.Price, InsightDirection.Up, 1, None))
                    self.tradeLock = True
                if HO > OL and self.tradeLock == False:
                    insights.append(Insight(self.symbol, self.period, InsightType.Price, InsightDirection.Down, 1, None))
                    self.tradeLock = True
                if HO == OL and self.tradeLock == False:
                    insights.append(Insight(self.symbol, self.period, InsightType.Price, InsightDirection.Up, 1, None))
                    self.tradeLock = True
                    
            if Close == Open:
                if HO < OL and self.tradeLock == False:
                    insights.append(Insight(self.symbol, self.period, InsightType.Price, InsightDirection.Up, 1, None))
                    self.tradeLock = True
                if HO > OL and self.tradeLock == False:
                    insights.append(Insight(self.symbol, self.period, InsightType.Price, InsightDirection.Down, 1, None))
                    self.tradeLock = True
                if HO == OL and self.tradeLock == False:
                    insights.append(Insight(self.symbol, self.period, InsightType.Price, InsightDirection.Flat, 1, None))
                    self.tradeLock = True
                    
            self.symbolData.Updated = False
                
        return insights
    
    def tradeLockReset(self, algorithm):
        self.tradeLock = False
        
    def OnSecuritiesChanged(self, algorithm, changes):
        self.changes =  changes
        
    
class SymbolData:
    
    def __init__(self, algorithm):
        algorithm.Consolidate("QQQ", Resolution.Daily, self.DailyBarHandler)
        
        self.open = 0
        self.close = 0
        self.high = 0
        self.low = 0
        self.Updated = False
        
        
    def DailyBarHandler(self, consolidated):
        self.open = consolidated.Open
        self.close = consolidated.Close
        self.high = consolidated.High
        self.low = consolidated.Low
        self.Updated = True
        

Hi James

Could you elaborate a little bit more about the tradelock function and what it is supposed to do? I would be happy to see if I could make it for you 😊 

Furthermore, it should be noted, that we should try to abstain from cross-class as much as possible. It breaks the seperation of concern principle, which makes the QC framework less flexable. 

Lucas

Lucas absolutely! The tradeLock is a simple boolean True/False object that is initially defined within the class as False. Special criteria is then added to the insight trade logic so that the insights will only be produced/returned if the tradeLock is False ("Off"). Once the insight is produced/returned, then the tradeLock is set to True ("On"). This way, going forward, if the trade produced by the insight is stopped out by MaxDrawDown, Alpha will not re-enter it because the tradeLock criteria is not met in the trade logic. Finally, to reset the tradeLock, we call the tradeLockReset function at 2359 of each day when markets are close which resets it for the next day where the process repeats itsself. 

The challenge faced here is that I am using the Alpha Model versus typically placing everything in the Initialize function. I tried placing the tradeLockReset function in the AlphaModel, but to no avail. 

Hi James

I've imported the “MaximumDrawdownPercentPortfolio" to the alpha model. It should do as you have asked. It only gets one update pr day (as it is set to daily resolution, if you want to change this to something like hour, a simple statement like):

        if algorithm.Time.day == self.lastDay:
            return drawdowns
        self.lastDay = algorithm.Time.day

with self.lastDay being set to -1 in the init method of the alpha model. 

Furthermore, it is reset everday, so the drawdown insight is only valid for a single day, and after this, the normal alpha can kick in. The overall drawdown is still bigger than 0.05 percent, as the drawdown is being reset everyday, and is theirfore not protected from a “lower low”. 

I have actually imported 2 max drawdown approach, the first one is commented out, but as I like the second way better. It is possible to modify the code, so a lower low is not possible, but I did not have the time ;(

Have a good day

Lucas