Please accept my apology for bad formatting.

Hi, Very frequently I struggled with float division by zero error. It goes away only after removing multiple tickers data. I went thru existing threads and suggested solutions to supply ```
safediv or safezero

however this parameter is not valid for all indicators. Appreciate any help! Attached is the code 

class Strategy(bt.Strategy):
params = dict(
selcperc=0.15, # percentage of stocks to select from the universe
rperiod=1, # period for the returns calculation, default 1 period
vperiod=252, # lookback period for volatility - default 36 periods
mperiod=126, # lookback period for momentum - default 12 periods
reserve=0.05, # 5% reserve capital
when=bt.timer.SESSION_START,
timer=True,
monthdays=[1],
monthcarry=True
)

def log(self, arg):
        print('{} {}'.format(self.datetime.date(), arg))   

def __init__(self):

bt.indicators.Stochastic(self.datas[0], safediv=True)

    # calculate 1st the amount of stocks that will be selected
    self.selnum = int(len(self.datas) * self.p.selcperc)

    # allocation perc per stock
    # reserve kept to make sure orders are not rejected due to
    # margin. Prices are calculated when known (close), but orders can only
    # be executed next day (opening price). Price can gap upwards
    self.perctarget = (1.0 - self.p.reserve) / self.selnum

    # returns, volatilities and momentums
    rs = [bt.ind.PctChange(d, period=self.p.rperiod) for d in self.datas] # safediv safezero
    vs = [bt.ind.StdDev(ret, period=self.p.vperiod) for ret in rs]
    ms = [bt.ind.ROC(d, period=self.p.mperiod) for d in self.datas]

    # simple rank formula: (momentum * net payout) / volatility
    # the highest ranked: low vol, large momentum, large payout

self.ranks = {d: d.npy * m / v for d, v, m in zip(self.datas, vs, ms)}

    self.ranks = {d: m / v for d, v, m in zip(self.datas, vs, ms)}

    self.add_timer(
        when=self.p.when,
        monthdays=self.p.monthdays,
        monthcarry=self.p.monthcarry
    )

def notify_timer(self, timer, when, *args, **kwargs):
    if self._getminperstatus() < 0:
        self.rebalance()

def rebalance(self):
    # sort data and current rank
    ranks = sorted(
        self.ranks.items(),  # get the (d, rank), pair
        key=lambda x: x[1][0],  # use rank (elem 1) and current time "0"
        reverse=True,  # highest ranked 1st ... please
    )

    # put top ranked in dict with data as key to test for presence
    rtop = dict(ranks[:self.selnum])


    # For logging purposes of stocks leaving the portfolio
    rbot = dict(ranks[self.selnum:])

    # prepare quick lookup list of stocks currently holding a position
    posdata = [d for d, pos in self.getpositions().items() if pos]

    # remove those no longer top ranked
    # do this first to issue sell orders and free cash
    for d in (d for d in posdata if d not in rtop):
        self.log('Leave {} - Rank {:.2f}'.format(d._name, rbot[d][0]))
        self.order_target_percent(d, target=0.0)

    # rebalance those already top ranked and still there
    for d in (d for d in posdata if d in rtop):
        self.log('Rebal {} - Rank {:.2f}'.format(d._name, rtop[d][0]))
        self.order_target_percent(d, target=self.perctarget)
        del rtop[d]  # remove it, to simplify next iteration

    # issue a target order for the newly top ranked stocks
    # do this last, as this will generate buy orders consuming cash
    for d in rtop:
        self.log('Enter {} - Rank {:.2f}'.format(d._name, rtop[d][0]))
        self.order_target_percent(d, target=self.perctarget) 
        
def next(self):
    self.notify_timer(self, self.p.timer, self.p.when)

Error

C:\ProgramData\Anaconda3\lib\site-packages\backtrader\cerebro.py in run(self, **kwargs)
   1125             # let's skip process "spawning"
   1126             for iterstrat in iterstrats:
-> 1127                 runstrat = self.runstrategies(iterstrat)
   1128                 self.runstrats.append(runstrat)
   1129                 if self._dooptimize:

C:\ProgramData\Anaconda3\lib\site-packages\backtrader\cerebro.py in runstrategies(self, iterstrat, predata)
   1291                     self._runonce_old(runstrats)
   1292                 else:
-> 1293                     self._runonce(runstrats)
   1294             else:
   1295                 if self.p.oldsync:

C:\ProgramData\Anaconda3\lib\site-packages\backtrader\cerebro.py in _runonce(self, runstrats)
   1650         '''
   1651         for strat in runstrats:
-> 1652             strat._once()
   1653             strat.reset()  # strat called next by next - reset lines
   1654 

C:\ProgramData\Anaconda3\lib\site-packages\backtrader\lineiterator.py in _once(self)
    295 
    296         for indicator in self._lineiterators[LineIterator.IndType]:
--> 297             indicator._once()
    298 
    299         for observer in self._lineiterators[LineIterator.ObsType]:

C:\ProgramData\Anaconda3\lib\site-packages\backtrader\linebuffer.py in _once(self)
    629         self.preonce(0, self._minperiod - 1)
    630         self.oncestart(self._minperiod - 1, self._minperiod)
--> 631         self.once(self._minperiod, self.buflen())
    632 
    633         self.oncebinding()

C:\ProgramData\Anaconda3\lib\site-packages\backtrader\linebuffer.py in once(self, start, end)
    753     def once(self, start, end):
    754         if self.bline:
--> 755             self._once_op(start, end)
    756         elif not self.r:
    757             if not self.btime:

C:\ProgramData\Anaconda3\lib\site-packages\backtrader\linebuffer.py in _once_op(self, start, end)
    770 
    771         for i in range(start, end):
--> 772             dst[i] = op(srca[i], srcb[i])
    773 
    774     def _once_time_op(self, start, end):

ZeroDivisionError: float division by zero

There is no issue with the code. Data wasn't clean hence causing the issue. Once I run the code with clean data, it worked.
Thanks

It looks like a data issue, I get this when I change the frequency from daily to monthly.

Hi,
I am trying to replicate the strategy published in the article - 'Rebalancing - Conservative Formula' with my own data. However, ranks and final portfolio values are coming as nan . Appreciate any help!! below is the code for your reference

class Strategy(bt.Strategy):
    params = dict(
        selcperc=0.10,  # percentage of stocks to select from the universe
        rperiod=1,  # period for the returns calculation, default 1 period
        vperiod=36,  # lookback period for volatility - default 36 periods
        mperiod=12,  # lookback period for momentum - default 12 periods
        reserve=0.05  # 5% reserve capital
    )
    
    def log(self, arg):
            print('{} {}'.format(self.datetime.date(), arg))   
            
    def __init__(self):
        # calculate 1st the amount of stocks that will be selected
        self.selnum = int(len(self.datas) * self.p.selcperc)

        # allocation perc per stock
        # reserve kept to make sure orders are not rejected due to
        # margin. Prices are calculated when known (close), but orders can only
        # be executed next day (opening price). Price can gap upwards
        self.perctarget = (1.0 - self.p.reserve) / self.selnum

        # returns, volatilities and momentums
        rs = [bt.ind.PctChange(d, period=self.p.rperiod) for d in self.datas]
        vs = [bt.ind.StdDev(ret, period=self.p.vperiod) for ret in rs]
        ms = [bt.ind.ROC(d, period=self.p.mperiod) for d in self.datas]

        # simple rank formula: (momentum * net payout) / volatility
        # the highest ranked: low vol, large momentum, large payout
#         self.ranks = {d: d.npy * m / v for d, v, m in zip(self.datas, vs, ms)}
        self.ranks = {d: m / v for d, v, m in zip(self.datas, vs, ms)}

        
        
    def next(self):
        # sort data and current rank
        ranks = sorted(
            self.ranks.items(),  # get the (d, rank), pair
            key=lambda x: x[1][0],  # use rank (elem 1) and current time "0"
            reverse=True,  # highest ranked 1st ... please
        )

        # put top ranked in dict with data as key to test for presence
        rtop = dict(ranks[:self.selnum])

        # For logging purposes of stocks leaving the portfolio
        rbot = dict(ranks[self.selnum:])

        # prepare quick lookup list of stocks currently holding a position
        posdata = [d for d, pos in self.getpositions().items() if pos]

        # remove those no longer top ranked
        # do this first to issue sell orders and free cash
        for d in (d for d in posdata if d not in rtop):
            self.log('Leave {} - Rank {:.2f}'.format(d._name, rbot[d][0]))
            self.order_target_percent(d, target=0.0)

        # rebalance those already top ranked and still there
        for d in (d for d in posdata if d in rtop):
            self.log('Rebal {} - Rank {:.2f}'.format(d._name, rtop[d][0]))
            self.order_target_percent(d, target=self.perctarget)
            del rtop[d]  # remove it, to simplify next iteration

        # issue a target order for the newly top ranked stocks
        # do this last, as this will generate buy orders consuming cash
        for d in rtop:
            self.log('Enter {} - Rank {:.2f}'.format(d._name, rtop[d][0]))
            self.order_target_percent(d, target=self.perctarget)

cerebro = bt.Cerebro()
cerebro.broker.setcash(300000.0)
cerebro.broker.setcommission(commission=0.001)

# Add securities as datas:
for ticker, data in prices.groupby(level=0):
    if ticker in TICKERS:
        print(f"Adding ticker: {ticker}")
        data = bt.feeds.PandasData(dataname=data.droplevel(level=0),
                                   name=ticker,
                                   plot=False)
        cerebro.adddata(data)

Adding ticker: ACC.NS
Adding ticker: ADANIPORTS.NS
Adding ticker: AMBUJACEM.NS
Adding ticker: ASHOKLEY.NS
Adding ticker: ASIANPAINT.NS
Adding ticker: AUROPHARMA.NS
Adding ticker: AXISBANK.NS
Adding ticker: BAJAJ-AUTO.NS
Adding ticker: BAJAJFINSV.NS
.....

cerebro.addstrategy(Strategy,
                    selcperc=0.20,
                    vperiod=36,
                    mperiod=6)
cerebro.addobserver(bt.observers.BuySell)
cerebro.addobserver(bt.observers.Value)
cerebro.addanalyzer(bt.analyzers.Returns, _name='returns')
cerebro.addanalyzer(bt.analyzers.TimeReturn, _name='time_return')
cerebro.addanalyzer(bt.analyzers.PyFolio, _name='pyfolio')
print('Starting Portfolio Value: %.2f' % cerebro.broker.getvalue())
# Run the strategy. Results will be output from stop.
results = cerebro.run(stdstats=True, tradehistory=False)

# # Run over everything
# results = cerebro.run(maxcpus=1)

# Print out the final result
print('Final Portfolio Value: %.2f' % cerebro.broker.getvalue())

Starting Portfolio Value: 300000.00
2017-01-31 Enter ACC.NS - Rank nan
2017-01-31 Enter ADANIPORTS.NS - Rank nan
2017-01-31 Enter AMBUJACEM.NS - Rank nan
2017-01-31 Enter ASHOKLEY.NS - Rank nan
2017-01-31 Enter ASIANPAINT.NS - Rank nan
2017-01-31 Enter AUROPHARMA.NS - Rank nan
2017-01-31 Enter AXISBANK.NS - Rank nan
2017-01-31 Enter BAJAJ-AUTO.NS - Rank nan
2017-01-31 Enter BAJAJFINSV.NS - Rank nan
2017-01-31 Enter BAJAJHLDNG.NS - Rank nan
2017-01-31 Enter BAJFINANCE.NS - Rank nan
2017-01-31 Enter BANKBARODA.NS - Rank nan
2017-01-31 Enter BERGEPAINT.NS - Rank nan
2017-01-31 Enter BHARTIARTL.NS - Rank nan
2017-01-31 Enter BIOCON.NS - Rank nan
2017-01-31 Enter BOSCHLTD.NS - Rank nan
2017-01-31 Enter BPCL.NS - Rank nan
2017-01-31 Enter BRITANNIA.NS - Rank nan
2017-02-28 Rebal ACC.NS - Rank nan
2017-02-28 Rebal ADANIPORTS.NS - Rank nan
2017-02-28 Rebal AMBUJACEM.NS - Rank nan
2017-02-28 Rebal ASHOKLEY.NS - Rank nan
2017-02-28 Rebal ASIANPAINT.NS - Rank nan
......
Final Portfolio Value: nan

Hello,
Thanks for the great project!
I have optimized weights for multiple assets and would like to backtest with monthly rebalancing. Any suggestions on how to proceed with backtesting with bt? Let me give an example on how to do this using zipline

def initialize(context):
    context.securities = {
                        'AAPL': 0.25, 
                        'ABBV': 0.3, 
                        'ABC': 0.3, 
                        'CAT': 0.075, 
                        'CSCO': 0.075
    }
    schedule_function(rebalance, date_rules.month_start(), time_rules.market_open())

def rebalance(context, data):
    # Loop through the securities
    for sec, weight in context.securities.items():
        sym = symbol(sec)
        if data.can_trade(sym):
            # Reset the weight
            order_target_percent(sym, weight)

Appreciate any help!!