Machine Learning Crypto Algo

Hi Sheikh,

Thank you for sharing the above algorithm with the community. Moving forward, we performed hyper-parameter tuning on the last hidden layer to maximize the Sharpe ratio. We can see the results in the following image. The Optimizer tool can be extensively used to develop ML algorithms and even help in creating different types of ensemble models. Refer to the attached backtest.

Best,

Varad Kabade

Sheikh Pancham

Thanks for sharing. 

Can someone explain why I get different results for the 

same algorithm three times in a row?

1

2

3

Hi Vladimir - Neural Network algorithms are stochastic. This means they make use of randomness, such as initializing to random weights, and in turn the same network trained on the same data can produce different results. You can seed the random number generator so that you get the same results from the same neural network on the same data, every time using the following statement in GetMLModel():

self.MLModel = MLPClassifier(random state = 123, hidden_layer_sizes = (100, 166, 100), max_iter = 1000)

More on sklearn models can be found here if you would like to experiment with a few: 

https://scikit-learn.org/stable/supervised_learning.html 

Hi Varade - Thanks very much for extending the research on this ML algo with your optimization exercise. I'm taking a look and will get back shortly.

correction: random_state 

I know that if I set the random seed to a specific number, 

I can reproduce the backtest results. 

self.MLModel = MLPClassifier(random_state = 123, hidden_layer_sizes = (100, 166, 100), max_iter = 1000)

Backtested 3 times with the same results.

Thank you Sheikh Pancham

(You're welcome, Vladimir. Thanks Spacetime)

Hi Varade, thanks again. I tried to follow what you did but instead on the hidden layer. The optimization has been hanging for hours so no results yet. I submitted a support ticket. Basically, I'm trying to optimize the scaling parameter, nn_scale, to calculate the optimal number of neurons in the hidden layer in the following calculation.:

# The upper bound on the number of hidden neurons that will not result in over-fitting is:
# hidden_layer = number_of training_samples * (nn_scale ∗ (number of input neurons + number of output neurons))
# nn_scale = an arbitrary scaling factor usually 2-10.

Below is the code, maybe someone else will have better luck with the optimizer and also try it on two parameters.

import numpy as np
import pandas as pd
from sklearn.neural_network import MLPClassifier
from AlgorithmImports import *

class MachineLearningAlgo(QCAlgorithm):
    
    def Initialize(self):
        
        self.SetStartDate(2016, 5, 2)  
        self.SetEndDate(2021, 7, 13)  
        self.SetCash(1000000)  
        self.AddEquity("SPY", Resolution.Daily)  
        self.SetBenchmark("SPY")
        self.SetBrokerageModel(BrokerageName.AlphaStreams)
        self.SetExecution(ImmediateExecutionModel())
        self.SetPortfolioConstruction(EqualWeightingPortfolioConstructionModel())
        
        self.ticker = self.AddCrypto("BTCUSD", Resolution.Daily).Symbol
        self.lookback = 30
        self.inputLayer = 100
        self.outputLayer = 100
        
        # The upper bound on the number of hidden neurons that will not result in over-fitting is:
        # hidden_layer = number_of training_samples * (nn_scale ∗ (number of input neurons + number of output neurons))
        # nn_scale = an arbitrary scaling factor usually 2-10.
        
        self.NN_scale = int(self.GetParameter("NN-scale"))
        # self.NN_scale = 3
        self.hiddenLayer = self.lookback * (self.NN_scale * (self.inputLayer + self.outputLayer))
        
        self.AddUniverseSelection(ManualUniverseSelectionModel(self.ticker))
        
        self.SetWarmup(self.lookback)

        self.AddAlpha(MachineLearningAlphaModel(self, self.ticker,
                                                self.inputLayer,self.hiddenLayer, self.outputLayer,
                                                self.lookback))
                        
class MachineLearningAlphaModel(AlphaModel):
                        
    def __init__(self, algo, symbol, 
                    inputLayer, hiddenLayer, outputLayer,
                    lookback):
        self.inputLayer = inputLayer
        self.hiddenLayer = hiddenLayer
        self.outputLayer = outputLayer
        self.algo = algo
        self.ticker = symbol
        self.dataBySymbol = {}
        self.lookback = lookback
        self.dataBySymbol[self.ticker] = SymbolData(self.algo,symbol,self.lookback)
            
    def GetMLModel(self):
        self.MLModel = 0
        self.MLModel = MLPClassifier(random_state=123, 
                                        hidden_layer_sizes = (self.inputLayer, self.hiddenLayer, self.outputLayer ), 
                                        max_iter = 1000)
        
    def Update(self, algorithm, data):
        insights = []
        
        if data.Bars.ContainsKey(self.ticker) and not algorithm.IsWarmingUp and self.dataBySymbol[ self.ticker ].IsReady():
            self.dataBySymbol[ self.ticker ].Update(data)
            
            if self.dataBySymbol[ self.ticker ].Close_rolling.IsReady \
                and self.dataBySymbol[ self.ticker ].Volume_rolling.IsReady \
                and self.dataBySymbol[ self.ticker ].RSI_rolling.IsReady \
                and self.dataBySymbol[ self.ticker ].Trend_rolling.IsReady \
                and self.dataBySymbol[ self.ticker ].AD_rolling.IsReady\
                and self.dataBySymbol[ self.ticker ].STOK_rolling.IsReady \
                and self.dataBySymbol[ self.ticker ].STOD_rolling.IsReady \
                and self.dataBySymbol[ self.ticker ].KAMA_rolling.IsReady:
                
                df1 = pd.DataFrame(self.dataBySymbol[ self.ticker ].Close_rolling, columns=["Close"]).reset_index(drop=True)
                df2 = pd.DataFrame(self.dataBySymbol[ self.ticker ].Volume_rolling, columns=["Volume"]).reset_index(drop=True)
                df3 = pd.DataFrame(self.dataBySymbol[ self.ticker ].RSI_rolling, columns=["RSI"]).reset_index(drop=True)
                df4 = pd.DataFrame(self.dataBySymbol[ self.ticker ].Trend_rolling, columns=["Trend"]).reset_index(drop=True)
                df5 = pd.DataFrame(self.dataBySymbol[ self.ticker ].AD_rolling, columns=["AD"]).reset_index(drop=True)
                df6 = pd.DataFrame(self.dataBySymbol[ self.ticker ].STOK_rolling, columns=["STOK"]).reset_index(drop=True)
                df7 = pd.DataFrame(self.dataBySymbol[ self.ticker ].STOD_rolling, columns=["STOD"]).reset_index(drop=True)
                df8 = pd.DataFrame(self.dataBySymbol[ self.ticker ].KAMA_rolling, columns=["KAMA"]).reset_index(drop=True)
                
                self.df = pd.concat([df1, df2, df3, df4, df5, df6, df7, df8], axis=1)
                
                # calculate daily forward returns to be used to set Target / Signal
                self.df['Return'] = np.log(self.df["Close"].shift(-1)/self.df["Close"]) 
                self.df = self.df.dropna()
                
                # set Signal / Target
                self.df["Signal"] = 0
                self.df.loc[self.df["Return"] > 0, "Signal"] = 1
                self.df.loc[self.df["Return"] < 0, "Signal"] = -1
                
                # set training data
                self.X = self.df.drop(["Close", "Return", "Signal"], axis=1)
                self.Y = self.df['Signal']
                
                # align feature set & signal 
                self.Y, self.X = self.Y.align(self.X, axis=0, join='inner')
                
                self.X_train = self.X[:-1]
                self.Y_train = self.Y[:-1]
                self.X_train.replace([np.inf, -np.inf], np.nan, inplace=True)
                self.Y_train.replace([np.inf, -np.inf], np.nan, inplace=True)
                
                drops = []
                [drops.append(i) for i in range(self.X_train.shape[0]) if self.X_train.iloc[i].isnull().any()]
                [drops.append(i) for i in range(self.Y_train.shape[0]) if self.Y_train.iloc[i] == np.nan and i not in drops]
                self.X_train.drop(index=self.X_train.index[drops], inplace=True)
                self.Y_train.drop(index=self.Y_train.index[drops], inplace=True)
                if self.X_train.empty or self.Y_train.empty: return []
                
                # fit / train ML model
                self.GetMLModel()
                self.MLModel.fit(self.X_train, self.Y_train)
                
                # predict next day signal using today's values of feature set
                self.X_today = self.X.iloc[-1]
                # self.X_today is Series, so convert to numpy array
                self.X_today = self.X_today.to_numpy()
                # reshape self.X_today because it only has 1 day's sample
                self.X_today = self.X_today.reshape(1,-1)
                
                # Y_predict will take predicted signal
                self.Y_predict = self.Y.iloc[-1]
                try:
                    self.Y_predict = self.MLModel.predict(self.X_today)
                except: return []
                
                # set insight based on predicted signal
                if self.Y_predict == 1:
                    insights.append(Insight(self.ticker, timedelta(days=30), InsightType.Price, InsightDirection.Up))
                elif self.Y_predict == -1:
                    insights.append(Insight(self.ticker, timedelta(days=30), InsightType.Price, InsightDirection.Down))
                else:
                    insights.append(Insight(self.ticker, timedelta(days=30), InsightType.Price, InsightDirection.Flat))
                    
        return insights
    
    def OnSecuritiesChanged(self, algorithm, changes):
        self.changes = changes 
        
class SymbolData:
    def __init__(self, algo, symbol,lookback):
        self.lookback = lookback
        self.algo = algo
        self.ticker = symbol
        self.Close_rolling = RollingWindow[float](self.lookback)
        
        self.Volume_rolling = RollingWindow[float](self.lookback)
        self.fast_volume_LWMA_indicator = self.algo.LWMA(self.ticker, 5, Resolution.Daily, Field.Volume)
        self.slow_volume_LWMA_indicator = self.algo.LWMA(self.ticker, 20, Resolution.Daily, Field.Volume)
        
        self.RSI_rolling = RollingWindow[float](self.lookback)
        self.RSI_indicator = self.algo.RSI(self.ticker, 25, Resolution.Daily)
        
        self.Trend_rolling = RollingWindow[float](self.lookback)
        self.trLWMA_indicator = self.algo.LWMA(self.ticker, 15, Resolution.Daily)
        self.ROC_indicator =  IndicatorExtensions.Of(RateOfChange(1), self.trLWMA_indicator)
        
        self.AD_rolling = RollingWindow[float](self.lookback)
        self.AD_indicator = self.algo.AD(self.ticker, Resolution.Daily)
        
        self.STOK_rolling = RollingWindow[float](self.lookback)
        self.STOD_rolling = RollingWindow[float](self.lookback)
        self.STO_indicator =  self.algo.STO(self.ticker, 14, 14, 3, Resolution.Daily)
        
        self.KAMA_rolling = RollingWindow[float](self.lookback)
        self.KAMA_indicator = self.algo.KAMA(self.ticker, 25, Resolution.Daily)
        
    def Update(self,data):
            self.Close_rolling.Add(data[self.ticker].Close)
            
            self.Volume_rolling.Add(self.fast_volume_LWMA_indicator.Current.Value / self.slow_volume_LWMA_indicator.Current.Value)
            
            self.RSI_rolling.Add(self.RSI_indicator.Current.Value)
            
            self.Trend_rolling.Add(self.ROC_indicator.Current.Value)
            
            self.AD_rolling.Add(self.AD_indicator.Current.Value)
            
            self.STOK_rolling.Add(self.STO_indicator.StochK.Current.Value)
            self.STOD_rolling.Add(self.STO_indicator.StochD.Current.Value)
            
            self.KAMA_rolling.Add(self.KAMA_indicator.Current.Value)
            
    def IsReady(self):
        return self.RSI_indicator.IsReady \
                    and self.fast_volume_LWMA_indicator.IsReady and self.slow_volume_LWMA_indicator.IsReady \
                    and self.trLWMA_indicator.IsReady and self.AD_indicator.IsReady \
                    and self.STO_indicator.IsReady and self.KAMA_indicator.IsReady

Thanks!

Hi Sheikh,
We have used the above logic to optimize using the parameters:lookback period. We recommend using the O8-16 node for the optimation of algorithms involving ML models. You can find the results in the following image. Note that the optimation time is heavily dependent on the individual backtest time. Making the model lighter can speed things greatly. We used ten in the attached backtest instead of 100 neurons in the input and output layer. The average time for running a backtest was 13 minutes, and we ran a total of 4 backtests. Refer to the attached backtest.
Best,
Varad Kabade

Thanks Varade, very helpful as always, will take a look.

First, just want to say thanks for posting this algo Sheikh. Its quite a bit more indepth than the first random forest algo I worked with.  Been watching this thread with interest.

I am trying to make this be able to trade multiple tickers. This is what I got so far:

import numpy as np
import pandas as pd
from sklearn.linear_model import RidgeClassifier
from sklearn.neural_network import MLPClassifier
from sklearn.decomposition import PCA
from AlgorithmImports import *
from itertools import groupby

class MachineLearningAlgo(QCAlgorithm):
   
   def Initialize(self):
       
       self.SetStartDate(2020, 5, 2)  
       self.SetEndDate(2021, 7, 2)  
       self.SetCash(100000)  
       self.AddEquity("SPY", Resolution.Daily)  
       self.SetBenchmark("SPY")
       self.SetBrokerageModel(BrokerageName.AlphaStreams)
       self.SetExecution(ImmediateExecutionModel())
       self.SetPortfolioConstruction(EqualWeightingPortfolioConstructionModel())
       
       #self.ticker = self.AddEquity("SPY", Resolution.Daily).Symbol
       #self.equity = self.AddEquity("SPY", Resolution.Daily).Symbol
       
       self.equity = ["QQQ","IWM","MDY","TLT"]
       
       
       self.symbols = {}
       for i in range(len(self.symbols)):
           self.symbols[self.symbols[i]] = self.AddEquity(self.symbols[i],Resolution.Minute).Symbol 
       
       self.AddUniverseSelection(ManualUniverseSelectionModel(self.symbols))
       
       self.SetWarmup(300)
       self.AddAlpha(MachineLearningAlphaModel(self,self.symbols))
       
       self.TD = (int(self.GetParameter("TimeDelta")))
       
                       
class MachineLearningAlphaModel(AlphaModel):
                       
   def __init__(self, algo, symbol):
       self.algo = algo
       self.symbols = symbol
       self.dataBySymbol = {}
       self.dataBySymbol[self.symbols] = SymbolData(self.algo,symbol)
       self.period = 30
           
   def GetMLModel(self):
       self.MLModel = 0
       # self.MLModel = RidgeClassifier(random_state=18)   
       self.MLModel = MLPClassifier(hidden_layer_sizes = (100, 100, 100), max_iter = 1000)
       
   def Update(self, algorithm, data):
       insights = []
       
       
       if data.Bars.ContainsKey(self.symbols) and not algorithm.IsWarmingUp and self.dataBySymbol[ self.symbols ].IsReady():
           self.dataBySymbol[ self.symbols ].Update(data)
           
           if self.dataBySymbol[ self.symbols ].Close_rolling.IsReady \
               and self.dataBySymbol[ self.symbols ].Volume_rolling.IsReady \
               and self.dataBySymbol[ self.symbols ].RSI_rolling.IsReady \
               and self.dataBySymbol[ self.symbols ].Trend_rolling.IsReady \
               and self.dataBySymbol[ self.symbols ].AD_rolling.IsReady\
               and self.dataBySymbol[ self.symbols ].STOK_rolling.IsReady \
               and self.dataBySymbol[ self.symbols ].STOD_rolling.IsReady \
               and self.dataBySymbol[ self.symbols ].KAMA_rolling.IsReady:
               
               df1 = pd.DataFrame(self.dataBySymbol[ self.symbols ].Close_rolling, columns=["Close"]).reset_index(drop=True)
               df2 = pd.DataFrame(self.dataBySymbol[ self.symbols ].Volume_rolling, columns=["Volume"]).reset_index(drop=True)
               df3 = pd.DataFrame(self.dataBySymbol[ self.symbols ].RSI_rolling, columns=["RSI"]).reset_index(drop=True)
               df4 = pd.DataFrame(self.dataBySymbol[ self.symbols ].Trend_rolling, columns=["Trend"]).reset_index(drop=True)
               df5 = pd.DataFrame(self.dataBySymbol[ self.symbols ].AD_rolling, columns=["AD"]).reset_index(drop=True)
               df6 = pd.DataFrame(self.dataBySymbol[ self.symbols ].STOK_rolling, columns=["STOK"]).reset_index(drop=True)
               df7 = pd.DataFrame(self.dataBySymbol[ self.symbols ].STOD_rolling, columns=["STOD"]).reset_index(drop=True)
               df8 = pd.DataFrame(self.dataBySymbol[ self.symbols ].KAMA_rolling, columns=["KAMA"]).reset_index(drop=True)
               
               self.df = pd.concat([df1, df2, df3, df4, df5, df6, df7, df8], axis=1)
               
               # calculate daily forward returns to be used to set Target / Signal
               self.df['Return'] = np.log(self.df["Close"].shift(-1)/self.df["Close"]) 
               self.df = self.df.dropna()
               
               # set Signal / Target
               self.df["Signal"] = 0
               self.df.loc[self.df["Return"] > 0, "Signal"] = 1
               self.df.loc[self.df["Return"] < 0, "Signal"] = -1
               
               # set training data
               self.X = self.df.drop(["Close", "Return", "Signal"], axis=1)
               self.Y = self.df['Signal']
               
               # align feature set & signal 
               self.Y, self.X = self.Y.align(self.X, axis=0, join='inner')
               
               self.X_train = self.X[:-1]
               self.Y_train = self.Y[:-1]
               self.X_train.replace([np.inf, -np.inf], np.nan, inplace=True)
               self.Y_train.replace([np.inf, -np.inf], np.nan, inplace=True)
               
               drops = []
               [drops.append(i) for i in range(self.X_train.shape[0]) if self.X_train.iloc[i].isnull().any()]
               [drops.append(i) for i in range(self.Y_train.shape[0]) if self.Y_train.iloc[i] == np.nan and i not in drops]
               self.X_train.drop(index=self.X_train.index[drops], inplace=True)
               self.Y_train.drop(index=self.Y_train.index[drops], inplace=True)
               if self.X_train.empty or self.Y_train.empty: return []
               
               # fit / train ML model
               self.GetMLModel()
               self.MLModel.fit(self.X_train, self.Y_train)
               
               # predict next day signal using today's values of feature set
               self.X_today = self.X.iloc[-1]
               # self.X_today is Series, so convert to numpy array
               self.X_today = self.X_today.to_numpy()
               # reshape self.X_today because it only has 1 day's sample
               self.X_today = self.X_today.reshape(1,-1)
               
               # Y_predict will take predicted signal
               self.Y_predict = self.Y.iloc[-1]
               try:
                   self.Y_predict = self.MLModel.predict(self.X_today)
               except: return []
               
               # set insight based on predicted signal
               if self.Y_predict == 1:
                   insights.append(Insight(self.symbols, timedelta(days=10), InsightType.Price, InsightDirection.Up))
               elif self.Y_predict == -1:
                   insights.append(Insight(self.symbols, timedelta(days=10), InsightType.Price, InsightDirection.Down))
               else:
                   insights.append(Insight(self.symbols, timedelta(days=10), InsightType.Price, InsightDirection.Flat))
                   
       return insights
   
   def OnSecuritiesChanged(self, algorithm, changes):
       self.changes = changes 
       
class SymbolData:
   def __init__(self, algo, symbol):
       self.lookback = 30
       self.algo = algo
       self.symbols = symbol
       self.Close_rolling = RollingWindow[float](self.lookback)
       
       self.Volume_rolling = RollingWindow[float](self.lookback)
       self.fast_volume_LWMA_indicator = self.algo.LWMA(self.symbols, 20, Resolution.Daily, Field.Volume)
       self.slow_volume_LWMA_indicator = self.algo.LWMA(self.symbols, 50, Resolution.Daily, Field.Volume)
       
       self.RSI_rolling = RollingWindow[float](self.lookback)
       self.RSI_indicator = self.algo.RSI(self.symbols, 25, Resolution.Daily)
       
       self.Trend_rolling = RollingWindow[float](self.lookback)
       self.trLWMA_indicator = self.algo.LWMA(self.symbols, 15, Resolution.Daily)
       self.ROC_indicator =  IndicatorExtensions.Of(RateOfChange(1), self.trLWMA_indicator)
       
       self.AD_rolling = RollingWindow[float](self.lookback)
       self.AD_indicator = self.algo.AD(self.symbols, Resolution.Daily)
       
       self.STOK_rolling = RollingWindow[float](self.lookback)
       self.STOD_rolling = RollingWindow[float](self.lookback)
       self.STO_indicator =  self.algo.STO(self.symbols, 14, 14, 3, Resolution.Daily)
       
       self.KAMA_rolling = RollingWindow[float](self.lookback)
       self.KAMA_indicator = self.algo.KAMA(self.symbols, 25, Resolution.Daily)
       
   def Update(self,data):
           self.Close_rolling.Add(data[self.symbols].Close)
           
           self.Volume_rolling.Add(self.fast_volume_LWMA_indicator.Current.Value / self.slow_volume_LWMA_indicator.Current.Value)
           
           self.RSI_rolling.Add(self.RSI_indicator.Current.Value)
           
           self.Trend_rolling.Add(self.ROC_indicator.Current.Value)
           
           self.AD_rolling.Add(self.AD_indicator.Current.Value)
           
           self.STOK_rolling.Add(self.STO_indicator.StochK.Current.Value)
           self.STOD_rolling.Add(self.STO_indicator.StochD.Current.Value)
           
           self.KAMA_rolling.Add(self.KAMA_indicator.Current.Value)
           
   def IsReady(self):
       return self.RSI_indicator.IsReady \
                   and self.fast_volume_LWMA_indicator.IsReady and self.slow_volume_LWMA_indicator.IsReady \
                   and self.trLWMA_indicator.IsReady and self.AD_indicator.IsReady \
                   and self.STO_indicator.IsReady and self.KAMA_indicator.IsReady

The error I am getting:

During the algorithm initialization, the following exception has occurred: Trying to dynamically access a method that does not exist throws a TypeError exception. To prevent the exception, ensure each parameter type matches those required by the PublicKeyToken=7cec85d7bea7198e]]'>) method. Please checkout the API documentation.
  at __init__
    self.fast_volume_LWMA_indicator = self.algo.LWMA(self.symbols in main.py:line 150
 TypeError : No method matches given arguments for LWMA: (<class 'dict'>, <class 'int'>, <class 'int'>, <class 'System.0, Culture=neutral, PublicKeyToken=7cec85d7bea7198e]]'>)

 I feel like I got the part in the initialize correct, but I feel like I might need to do a for loop when it gets to this part: 

df1 = pd.DataFrame(self.dataBySymbol[ self.ticker ].Close_rolling, columns=["Close"]).reset_index(drop=True)
                df2 = pd.DataFrame(self.dataBySymbol[ self.ticker ].Volume_rolling, columns=["Volume"]).reset_index(drop=True)
                df3 = pd.DataFrame(self.dataBySymbol[ self.ticker ].RSI_rolling, columns=["RSI"]).reset_index(drop=True)
                df4 = pd.DataFrame(self.dataBySymbol[ self.ticker ].Trend_rolling, columns=["Trend"]).reset_index(drop=True)
                df5 = pd.DataFrame(self.dataBySymbol[ self.ticker ].AD_rolling, columns=["AD"]).reset_index(drop=True)
                df6 = pd.DataFrame(self.dataBySymbol[ self.ticker ].STOK_rolling, columns=["STOK"]).reset_index(drop=True)
                df7 = pd.DataFrame(self.dataBySymbol[ self.ticker ].STOD_rolling, columns=["STOD"]).reset_index(drop=True)
                df8 = pd.DataFrame(self.dataBySymbol[ self.ticker ].KAMA_rolling, columns=["KAMA"]).reset_index(drop=True)
                
                self.df = pd.concat([df1, df2, df3, df4, df5, df6, df7, df8], axis=1)

I haven't looked at code at all, but would like for one explanation. In the backtest results, we can see the cumulative return is cca 9x. But in the same period BTC increases by 50x. If the algo only invests in BTC, than the benchmark should be BTC, and than the results are not that great. Just the opposite, the algo is underperforming buy and hold in BTC?

Hi Axist, you're welcome, glad you found the algo useful. You can just plug in the ML model you'd like to use such as Random Forest with the appropriate hyper-parameters. The algo is a work-in-progress and QC Support (Varad Kabade, Louis Szeto) have been generously giving their time to improve it. 

The next steps for enhancement would definitely be what you are attempting: 1) adapt it to handle multiple symbols, 2) use daily data consolidated from minute data. I'm sure QC Support will get to it. In the meantime, you can look at what Louis Szeto did in the example here to handle multiple symbols.

Hi Mislav, yes you are correct. According to the Alpha Streams submission rules, the benchmark should be relevant to the asset type being traded. The algo though is just an ML template that is being updated for members to easily plug in their research ideas. Hopefully, it will become as general as possible. As is, it is not a winning algo. Community members are free to apply their own ML model, assets and indicators. 

Sheikh

Hi, many thanks for sharing the code! Great idea to put a kind of general ML approach. 
Just wondering:

• Is there a reason for putting the training part not in the “train” method to have more time for traning?Also is it possible with sklearn to save the train models in objectstore?
• Also great to have more inputs to the NN then just the closing price! Do you think it could make sense to have kind of graded classification meaning in case of positive e.g. very small, small, medium increase of signal in future
• most important: did you try to run the network on faster resolutions as e.g. resolution.minute? would be highly appreciated to learn something about it…

best wishes and many thanks!

Hi Carpediem911

Is there a reason for putting the training part not in the “train” method to have more time for traning?Also is it possible with sklearn to save the train models in objectstore?

Yes, you can save/read any data including sklearn models into/from objectstore by using JSON format (docs). For getting the model to be converted into a JSON file, you can find this stack overflow's thread as example. Basically you will need a dictionary to save 2 key-value pairs within it: 

• 1 is the model's initial parameters 

yourTrainedModel.get_params(), 

• 1 is another dictionary holding the model's trained parameter like 

{'attr1': getattr(yourTrainedModel, 'attr1'), 'attr2': getattr(yourTrainedModel, 'attr2'), ...}. 

Then save it using our inbuilt self.ObjectStore.SaveJson method. To load it, after self.ObjectStore.ReadJson, you will need to call the model class and set its initial parameters and trained parameters.

# let's use a logistic regression as example

from sklearn.linear_model import LogisticRegression
import numpy as np

myLRModel = LogisticRegression()
myLRModel.fit(x, y)

# save
modelData = {}
modelData['init_params'] = myLRModel.get_params()
modelData['model_params'] = {}
modelParams = {}
for paramsName in ('coef_', 'intercept_','classes_', 'n_iter_'):    # other models might have other parameters
    modelParams[paramsName] = getattr(myLRModel, paramsName).tolist()
self.ObjectStore.SaveJson("myModel", modelData)

# read
modelJSON = self.ObjectStore.ReadJson("myModel")
LRModel = LogisticRegression(**modelJSON['init_params'])
for paramsName, params in modelJSON['model_params'].items():
    setattr(LRModel, paramsName, np.array(params))
	# you have retrieve your logistic regression model as LRModel

Best,
Louis Szeto

Hi Varade,

Updated ML algo code below. 1) Uses Ridge Classifier instead of Neural Network model, 2) Uses reversed order for feature set dataframe, and 3) Uses daily data consolidated from minute resolution data. When you have a moment can you pls check that I am updating the rolling windows and indicators (and indicator extended from indicator) correctly in this “daily consolidated” format.

Thanks / Sheikh

import numpy as np
import pandas as pd
from sklearn.linear_model import RidgeClassifier
from AlgorithmImports import *

class RidgeClassifierIndicatorCryptoAlgo(QCAlgorithm):
    
    def Initialize(self):
        
        self.SetStartDate(2016, 6, 1)  
        self.SetEndDate(2021, 7, 21)  
        self.SetCash(1000000)  
        self.SetBrokerageModel(BrokerageName.AlphaStreams)
        self.SetExecution(ImmediateExecutionModel())
        self.SetPortfolioConstruction(EqualWeightingPortfolioConstructionModel())
        
        symbol_list = ["BTCUSD","ETHUSD","LTCUSD","BALUSD","DAIUSD","KNCUSD",
                        "OXTUSD","RENUSD","UMAUSD","XRPUSD","ZRXUSD"]
        self.symbols = [self.AddCrypto(symbol, Resolution.Minute, Market.GDAX).Symbol for symbol in symbol_list]
        self.SetBenchmark("BTCUSD")
        
        self.lookback = 30
        self.SetWarmup(self.lookback)
        self.AddAlpha(RidgeClassifierIndicatorCryptoAlphaModel(self.Time, self.lookback))

                        
class RidgeClassifierIndicatorCryptoAlphaModel(AlphaModel):
                        
    def __init__(self, Time, lookback):
        self.dataBySymbol = {}
        self.rebalanceTime = Time
        self.lookback = lookback
            
    def GetMLModel(self):
        self.MLModel = 0
        self.MLModel = RidgeClassifier(random_state=18)
        
    def Update(self, algorithm, data):
        insights = []
        
        if algorithm.Time < self.rebalanceTime: return []
        
        for symbol, symbolData in self.dataBySymbol.items():
            if data.Bars.ContainsKey(symbol) and not algorithm.IsWarmingUp and symbolData.IsReady():
                symbolData.Update(data, symbol)
            
                if symbolData.Close_rolling.IsReady \
                    and symbolData.RSI_rolling.IsReady \
                    and symbolData.Trend_rolling.IsReady \
                    and symbolData.fast_SMA_rolling.IsReady \
                    and symbolData.slow_SMA_rolling.IsReady:
                       
                    df1 = pd.DataFrame(symbolData.Close_rolling, columns=["Close"])[::-1].reset_index(drop=True)
                    df2 = pd.DataFrame(symbolData.RSI_rolling, columns=["RSI"])[::-1].reset_index(drop=True)
                    df3 = pd.DataFrame(symbolData.Trend_rolling, columns=["Trend"])[::-1].reset_index(drop=True)
                    df4 = pd.DataFrame(symbolData.fast_SMA_rolling, columns=["fSMA"])[::-1].reset_index(drop=True)
                    df5 = pd.DataFrame(symbolData.slow_SMA_rolling, columns=["sSMA"])[::-1].reset_index(drop=True)
                
                    self.df = pd.concat([df1, df2, df3, df4, df5], axis=1)
                    
                    # calculate daily forward returns to be used to set Target / Signal
                    self.df['FwdReturn'] = np.log(self.df["Close"].shift(-1)/self.df["Close"]) 
                    self.df = self.df.dropna()
                    
                    # set Signal / Target
                    self.df["Signal"] = 0
                    self.df['Signal'][self.df["FwdReturn"] > 0] = 1
                    self.df['Signal'][self.df["FwdReturn"] < 0] = -1
                    
                    # set training data
                    self.X = self.df.drop(["Close", "FwdReturn", "Signal"], axis=1)
                    self.Y = self.df['Signal']
                    
                    # align feature set & signal 
                    self.Y, self.X = self.Y.align(self.X, axis=0, join='inner')
                    
                    self.X_train = self.X[:-1]
                    self.Y_train = self.Y[:-1]
                    if self.X_train.empty or self.Y_train.empty: return []
                    
                    # fit / train ML model
                    self.GetMLModel()
                    self.MLModel.fit(self.X_train, self.Y_train)
                    
                    # predict next day signal using today's values of feature set
                    self.X_today = self.X.iloc[-1]
                    # self.X_today is Series, so convert to numpy array
                    self.X_today = self.X_today.to_numpy()
                    # reshape self.X_today because it only has 1 day's sample
                    self.X_today = self.X_today.reshape(1,-1)
                    
                    # Y_predict will take predicted signal
                    self.Y_predict = self.MLModel.predict(self.X_today)
                    
                    # set insight based on predicted signal
                    # cannot short crypto in GDAX
                    direction = InsightDirection.Up if self.Y_predict == 1 else InsightDirection.Flat
                    insights.append(Insight(symbol, timedelta(days=30), InsightType.Price, direction))
                    
        self.rebalanceTime = Expiry.EndOfDay(algorithm.Time)
                    
        return insights
    
    def OnSecuritiesChanged(self, algorithm, changes):
        for change in changes.AddedSecurities:
            self.dataBySymbol[change.Symbol] = SymbolData(algorithm, change.Symbol, self.lookback)
            
        for change in changes.RemovedSecurities:
            if change.Symbol in self.dataBySymbol:
                del self.dataBySymbol[change.Symbol]
                
class SymbolData:
    def __init__(self, algorithm, symbol, lookback):
        
        self.lookback = lookback
        
        algorithm.Consolidate(symbol, Resolution.Daily, self.DailyBarHandler)
        # algorithm.Consolidate(symbol, Resolution.Daily, lambda x: None)
        
        self.Close_rolling = RollingWindow[float](self.lookback)
        
        self.RSI_rolling = RollingWindow[float](self.lookback)
        self.RSI_indicator = algorithm.RSI(symbol, 25, Resolution.Daily)
        
        self.Trend_rolling = RollingWindow[float](self.lookback)
        self.trLWMA_indicator = algorithm.LWMA(symbol, 15, Resolution.Daily)
        self.ROC_indicator =  IndicatorExtensions.Of(RateOfChange(1), self.trLWMA_indicator)
        
        self.fast_SMA_rolling = RollingWindow[float](self.lookback)
        self.fast_SMA_indicator = algorithm.SMA(symbol, 5, Resolution.Daily, Field.Low)
        
        self.slow_SMA_rolling = RollingWindow[float](self.lookback)
        self.slow_SMA_indicator = algorithm.SMA(symbol, 60, Resolution.Daily, Field.High)
        
        history = algorithm.History(symbol, lookback, Resolution.Daily)
        if not history.empty:
            for index, tradebar in history.loc[symbol].iterrows():
                self.RSI_indicator.Update(index, tradebar.close)
                self.trLWMA_indicator.Update(index, tradebar.close)
                self.ROC_indicator.Update(index, tradebar.close)
                self.fast_SMA_indicator.Update(index, tradebar.low)
                self.slow_SMA_indicator.Update(index, tradebar.high)
                self.Close_rolling.Add(tradebar.close)
                
            last_row = history.loc[symbol].iloc[-1]
            self.open = last_row.open
            self.close = last_row.close
            self.high = last_row.high
            self.low = last_row.low
        
    def DailyBarHandler(self, consolidated):
        self.open = consolidated.Open
        self.close = consolidated.Close
        self.high = consolidated.High
        self.low = consolidated.Low
        self.volume = consolidated.Volume
        
    def Update(self, data, symbol):
        self.RSI_rolling.Add(self.RSI_indicator.Current.Value)
        self.Trend_rolling.Add(self.ROC_indicator.Current.Value)
        self.fast_SMA_rolling.Add(self.fast_SMA_indicator.Current.Value)
        self.slow_SMA_rolling.Add(self.slow_SMA_indicator.Current.Value)
            
    def IsReady(self):
        return self.RSI_indicator.IsReady \
                    and self.trLWMA_indicator.IsReady \
                    and self.fast_SMA_indicator.IsReady and self.slow_SMA_indicator.IsReady
              

Hi Sheikh,
Thank you for sharing the above algorithm with the community. The algorithm doesn't fully warm up all of the indicators. For instance, slow_SMA_indicator has a Period of 60 days, but only lookback (30) days of history is used to warm up the indicators. The Update method should check if the indicator IsReady before adding it's value to the RollingWindows.
Best,
Varad Kabade

(Thanks Varad)

Hello QC Support,

With respect to saving & retrieving an ML model: 

I trained an ML model locally in a Jupyter notebook and I want to be able to use it in a QC algo. I don't want to do any training in the QC algo. Also, I don't want to use object store as I hope to submit the algo to the Alpha marketplace so no importing. I want to extract the hyperparameters and fitted parameters from the fitted ML model and to just put that data in the algo itself and set that data in the ML model in the algo.

I tried the getting & setting steps from above (as stated by Louis Szeto) but am running into an error on the setting part:. Here is the code, please have a look when you get a moment:

MlModel = 0
mlModel = svrModel # <--- copy from fitted SVR model

modelData = {}
modelData['hyper_params'] = mlModel.get_params()     <===== THIS WORKS.
print(modelData['hyper_params'])                     <===== THIS WORKS.

modelData['fitted_params'] = {}
fittedParams = {}

for fittedParamsName in ('class_weight_','coef_','dual_coef_', 'fit_status_', 'intercept_', 
                           'n_support_', 'shape_fit_','support_', 'support_vectors_'):
    fittedParams[fittedParamsName] = getattr(mlModel, fittedParamsName)
    print(fittedParamsName, fittedParams[fittedParamsName])     <===== THIS WORKS.
    
modelData['fitted_params'] = fittedParams

print(modelData['hyper_params'])          <===== THIS WORKS.
print(modelData['fitted_params'])         <===== THIS WORKS.


mlModel2 = 0
mlModel2 = SVR(**modelData['hyper_params']) # <===== THIS WORKS. Success setting hyperparameters.
print(mlModel2.get_params())                  <===== THIS WORKS.

###### EVERYTHING ABOVE HERE WORKS ######

for fittedParamsName, fittedParams in modelData['fitted_params'].items():
    print(fittedParamsName, fittedParams)
    setattr(mlModel2, fittedParamsName, np.array(fittedParams))  # <===== UNFORTUNATELY, THIS DOES NOT WORK 
    

###### ERROR OCCURS WHEN TRYING TO SET FITTED ATTRIBUTE ######    

-------------------------------------------------------------------------------------------------------------------------
Output from Jupyter notebook

AttributeError                            Traceback (most recent call last)
<ipython-input-76-7890e1ca4e3a> in <module>
    104 for fittedParamsName, fittedParams in modelData['fitted_params'].items():
    105     print(fittedParamsName, fittedParams)
--> 106     setattr(mlModel2, fittedParamsName, np.array(fittedParams)) 

AttributeError: can't set attribute

Kindly have a look when you have a moment.

Thanks / Sheikh

Hi Sheikh,
Although it is possible to store ML models in JSON format sometimes, it can get very messy depending on the ML model used. An alternative and the easier way would be to use pickle or JobLib as both libraries are supported in QC. Please refer to this page for detailed information.
To save an ML model :
 

self.model = RandomForestRegressor()
self.model.fit(X, y)
self.ObjectStore.SaveBytes(self.model_key, pickle.dumps(self.model))

To load a saved ml model:
 

self.model_key = 'model'
if self.ObjectStore.ContainsKey(self.model_key):
            model_bytes = self.ObjectStore.ReadBytes(self.model_key)
            model_bytes = bytearray(model_bytes)
            self.model = pickle.loads(model_bytes)

Best,
Varad Kabade