Discussion Forum - QuantConnect.com

Sheikh Pancham INVESTOR

| Reward Discussion

Hi QC Support:

I'm trying to use the AD indicator and am getting the error below.

# initialize

self.ADW = RollingWindow[float](self.lookback)

self.AD_indicator = self.AD(self.ticker, Resolution.Daily)



# update

self.AD_indicator.Update(data.Bars[self.ticker].EndTime, data.Bars[self.ticker].Close)

self.ADW.Add(self.AD_indicator.Current.Value)



Getting this error:

AccumulationDistribution does not support the `Update(DateTime, decimal)` method.

Use one of the following methods instead: Update(TradeBar), Update(QuoteBar)

Please advise what should be the code.

Thanks / Sheikh

Update Backtest

Sheikh Pancham

Accepted Answer

Update Backtest

Notebook

The material on this website is provided for informational purposes only and does not constitute an offer to sell, a solicitation to buy, or a recommendation or endorsement for any security or strategy, nor does it constitute an offer to provide investment advisory services by QuantConnect. In addition, the material offers no opinion with respect to the suitability of any security or specific investment. QuantConnect makes no guarantees as to the accuracy or completeness of the views expressed in the website. The views are subject to change, and may have become unreliable for various reasons, including changes in market conditions or economic circumstances. All investments involve risk, including loss of principal. You should consult with an investment professional before making any investment decisions.

Vladimir

94.7k Pro ,

Sheikh Pancham

I don't think

self.AD_indicator = self.AD(self.ticker, Resolution.Daily)

needs to be updated.

Try this

Sheikh Pancham

4.2k Pro ,

Thanks Vladimir, that works in the Algorithm Framework also. Makes things easier. Code attached.

I'm trying to add the KAMA indicator and get this error:

Runtime Error: TypeError : '0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e]]' object is not callable

  at Update

    self.KAMA_rolling(self.KAMA_indicator.Current.Value)

Can you look into when you have a moment.

Thanks / Sheikh

Louis Szeto

STAFF Pro ,

Hi Sheikh

Did you set warmup on KAMA? And did you set condition:

if not self.IsWarmingUp & self.KAMA_indicator.IsReady:

Cheers
Louis

Sheikh Pancham

4.2k Pro ,

Hi Louis (how's it going?),

Code attached & below. I'm just checking if the rolling window is ready, not the indicator. Seems to be working for the other windows & indicator.

import numpy as np

import pandas as pd

from sklearn.linear_model import RidgeClassifier

from AlgorithmImports import *



class MachineLearningAlgo(QCAlgorithm):

    

    def Initialize(self):

        

        self.SetStartDate(2016, 5, 2)  

        self.SetEndDate(2021, 6, 30)  

        self.SetCash(1000000)  

        self.AddEquity("SPY", Resolution.Daily)  

        self.SetBenchmark("SPY")

        self.SetBrokerageModel(BrokerageName.AlphaStreams)

        self.SetExecution(ImmediateExecutionModel())

        self.SetPortfolioConstruction(EqualWeightingPortfolioConstructionModel())

        

        self.AddCrypto("BTCUSD", Resolution.Daily)  

        self.ticker = "BTCUSD"

        

        self.AddUniverseSelection(ManualUniverseSelectionModel(self.ticker))

        

        self.lookback = 30

        self.SetWarmup(self.lookback)

    

        self.Close_rolling = RollingWindow[float](self.lookback)

        

        self.Volume_rolling = RollingWindow[float](self.lookback)

        self.fast_volume_LWMA_indicator = self.LWMA(self.ticker, 5, Resolution.Daily)

        self.slow_volume_LWMA_indicator = self.LWMA(self.ticker, 20, Resolution.Daily)

        

        self.RSI_rolling = RollingWindow[float](self.lookback)

        self.RSI_indicator = self.RSI(self.ticker, 25, Resolution.Daily)

        

        self.Trend_rolling = RollingWindow[float](self.lookback)

        self.trLWMA_indicator = self.LWMA(self.ticker, 15, Resolution.Daily)

        self.ROC_indicator = self.ROC(self.ticker, 1, Resolution.Daily)

        

        self.AD_rolling = RollingWindow[float](self.lookback)

        self.AD_indicator = self.AD(self.ticker, Resolution.Daily)

        

        self.STO_rolling = RollingWindow[float](self.lookback)

        self.STO_indicator = self.STO(self.ticker, 14, 14, 3, Resolution.Daily)

        

        self.KAMA_rolling = RollingWindow[float](self.lookback)

        self.KAMA_indicator = self.KAMA(self.ticker, 25, Resolution.Daily)



        self.AddAlpha(MachineLearningAlphaModel(self.ticker, 

                        self.Close_rolling, self.Volume_rolling, 

                        self.fast_volume_LWMA_indicator, self.slow_volume_LWMA_indicator,

                        self.RSI_rolling, self.RSI_indicator, 

                        self.Trend_rolling, self.trLWMA_indicator, self.ROC_indicator,

                        self.AD_rolling, self.AD_indicator,

                        self.STO_rolling, self.STO_indicator,

                        self.KAMA_rolling, self.KAMA_indicator))

                        

class MachineLearningAlphaModel:

                        

    def __init__(self, ticker, closew, volumew,

                    fast_volume_lwmai, slow_volume_lwmai,

                    rsiw, rsii, trendw, trlwmai, roci,

                    adw, adi, stow, stoi, kamaw, kamai):

       

        self.period = timedelta(30)

        self.ticker = ticker

        

        self.Close_rolling = closew

        

        self.Volume_rolling= volumew

        self.fast_volume_LWMA_indicator = fast_volume_lwmai

        self.slow_volume_LWMA_indicator = slow_volume_lwmai

        

        self.RSI_rolling = rsiw

        self.RSI_indicator = rsii

        

        self.Trend_rolling = trendw

        self.trLWMA_indicator = trlwmai

        self.ROC_indicator = roci

        

        self.AD_rolling = adw

        self.AD_indicator = adi

        

        self.STO_rolling = stow

        self.STO_indicator = stoi

        

        self.KAMA_rolling = kamaw

        self.KAMA_indicator = kamai

            

    def GetMLModel(self):

        self.MLModel = 0

        self.MLModel = RidgeClassifier(random_state=18)   



    def Update(self, algorithm, data):

        insights = []

        

        if data.Bars.ContainsKey(self.ticker):

            

            self.Close_rolling.Add(data[self.ticker].Close)

            

            self.fast_volume_LWMA_indicator.Update(data.Bars[self.ticker].EndTime, data.Bars[self.ticker].Volume)

            self.slow_volume_LWMA_indicator.Update(data.Bars[self.ticker].EndTime, data.Bars[self.ticker].Volume)

            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.ROC_indicator.Update(data[self.ticker].EndTime, self.trLWMA_indicator.Current.Value)

            self.Trend_rolling.Add(self.ROC_indicator.Current.Value)

            

            self.AD_rolling.Add(self.AD_indicator.Current.Value)

            

            self.STO_rolling.Add(self.STO_indicator.Current.Value)

            

            self.KAMA_rolling(self.KAMA_indicator.Current.Value)

            

            if not algorithm.IsWarmingUp and self.Close_rolling.IsReady \

                    and self.Volume_rolling.IsReady and self.RSI_rolling.IsReady \

                    and self.Trend_rolling.IsReady and self.AD_rolling.IsReady\

                    and self.STO_rolling.IsReady and self.KAMA_rolling.IsReady:

                

                df1 = pd.DataFrame(self.Close_rolling, columns=["Close"]).reset_index(drop=True)

                df2 = pd.DataFrame(self.Volume_rolling, columns=["Volume"]).reset_index(drop=True)

                df3 = pd.DataFrame(self.RSI_rolling, columns=["RSI"]).reset_index(drop=True)

                df4 = pd.DataFrame(self.Trend_rolling, columns=["Trend"]).reset_index(drop=True)

                df5 = pd.DataFrame(self.AD_rolling, columns=["AD"]).reset_index(drop=True)

                df6 = pd.DataFrame(self.STO_rolling, columns=["STO"]).reset_index(drop=True)

                df7 = pd.DataFrame(self.KAMA_rolling, columns=["KAMA"]).reset_index(drop=True)

                

                self.df = pd.concat([df1, df2, df3, df4, df5, df6, df7], 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, self.period, InsightType.Price, InsightDirection.Up, 1, None))

                elif self.Y_predict == -1:

                    insights.append(Insight(self.ticker, self.period, InsightType.Price, InsightDirection.Down, 1, None))

                else:

                    insights.append(Insight(self.ticker, self.period, InsightType.Price, InsightDirection.Flat, 1, None))

                    

        return insights

    

    def OnSecuritiesChanged(self, algorithm, changes):

        self.changes = changes

Louis Szeto

STAFF Pro ,

Hi Sheikh

You forgot to use the method .Add

btw you can init you rolling window in alpha model class's init to save memory and time. I didnt include tho

Cheers
Louis

Sheikh Pancham

4.2k Pro ,

ha ha thanks Louis. I guess I missed that.

Ok, I'll try what you're saying about the initializing the rolling window in the alpha model class.

Sheikh Pancham

4.2k Pro ,

Thanks guys!

Varad Kabade

31.1k Pro ,

Hi Sheikh,
Thank you, Louis, for your response. The above algorithm has many issues. We have made the following changes:

fast_volume_LWMA_indicator, slow_volume_LWMA_indicator, ROC_indicator are hooked for automatic update and are also updated manually. We removed the manual update part.

fast_volume_LWMA_indicator, slow_volume_LWMA_indicator require Field as Volume, but the algorithm had created with the default field(Close) we changed the Field to Volume

ROC_indicator takes the output of trLWMA_indicator as its input, so we need to use the IndicatorExtension property to refer to the following code snippet.

self.ROC_indicator = IndicatorExtensions.Of(RateOfChange(1),self.trLWMA_indicator)

We shifted the whole indicator logic and all the rolling windows to SymbolData class and replaced the whole rolling window logic with a method in SymbolData class.

Refer to the attached backtest.
Best,
Varad Kabade

Sheikh Pancham

4.2k Pro ,

Thanks Varad, nicely done!

Sheikh Pancham INVESTOR

Update Backtest

Notebook

To unlock posting to the community forums please complete at least 30% of Boot Camp.
You can continue your Boot Camp training progress from the terminal. We hope to see you in the community soon!

Platform

QuantConnect Community

Alpha League Competition: $1,000 Weekly Prize Pool

Filter Discussion by Tags

240900 Quants.

Online Now

Stay Connected

AccumulationDistribution does not support the `Update(DateTime, decimal)` method

Started By:

Join QuantConnect for Free Sign Up

Platform

SIGN IN

QuantConnect Community

Alpha League Competition: $1,000 Weekly Prize Pool

Filter Discussion by Tags

240900 Quants.

Online Now

Stay Connected

AccumulationDistribution does not support the `Update(DateTime, decimal)` method

Started By:

Join QuantConnect for Free Sign Up