I think it's awesome you posted this and haven't forgotten, just haven't got to it yet.

Added as an issue in Backtrader2... https://github.com/backtrader2/backtrader/issues/28

OK well see if you can debug it from there. If you get stuck, let us know.

I may be mistaken but my understanding is that the challenge with using the optimizer in backtrader is that it accumulates the results to return in a list. The more items being accumulated means more memory build up until released at the end.

Have a look here at @backtrader comments to try and solve this problem.

You can also consider breaking up your optimization into smaller runs.

Personally I found joy in not using the built in optimizer but using mutliprocessing outside of backtrader and calling each backtest individually as a function. My saving each result to a spreadsheet or postgres table I avoid the built up using memory altogether.

pool = multiprocessing.Pool(processes=multiprocessing.cpu_count() - 1)
            pool.map(st.backtest_controller_multi, scenarios)
            pool.close()
```
where scenarios is a list of dictionaries with all of the possible combinations of parameters.

I thought it might be easier just to generate the code that should be very close to what you are looking for.

I wasn't sure what you were trying to accomplish with the 'recent_highs' and lows so I just took the max/min over get 5 days.

import backtrader as bt

class MAcrossoveer(bt.Strategy):
    # Moving average parameters
    params = (('pfast', 8), ('pslow', 21),)

    def __init__(self):
        # Keeps track of bracket orders.
        self.o_li = list()

        self.ema_fast = bt.ind.EMA(self.data, period=self.p.pfast)
        self.ema_slow = bt.ind.EMA(self.data, period=self.p.pslow)

        self.crossover = bt.ind.CrossUp(self.ema_fast, self.ema_slow)


    def log(self, txt, dt=None):
        """ Logging function fot this strategy"""
        dt = dt or self.data.datetime[0]
        if isinstance(dt, float):
            dt = bt.num2date(dt)
        print("%s, %s" % (dt.date(), txt))

    def print_signal(self):
        """ Prints OHLCV """
        self.log(
            "o {:5.2f}\th {:5.2f}\tl {:5.2f}\tc {:5.2f}\tv {:5.0f}".format(
                self.datas[0].open[0],
                self.datas[0].high[0],
                self.datas[0].low[0],
                self.datas[0].close[0],
                self.datas[0].volume[0],
            )
        )

    def notify_order(self, order):
        """Triggered upon changes to orders. Notifications on order changes are here."""

        # Suppress notification if it is just a submitted order.
        if order.status == order.Submitted:
            return

        # Print out the date, security name, order number and status.
        dt, dn = self.datetime.date(), order.data._name

        self.log(
            "{} Order {} Status {}".format(dn, order.ref, order.getstatusname())
        )

        # Check if an order has been completed
        # Attention: broker could reject order if not enough cash
        if order.status in [order.Completed, order.Margin]:
            if order.isbuy():
                self.log(
                    "BUY EXECUTED for {}, Price: {:.2f}, Cost: {:.2f}, Comm {:.2f}".format(
                        dn,
                        order.executed.price,
                        order.executed.value,
                        order.executed.comm,
                    )
                )
            else:  # Sell
                self.log(
                    "SELL EXECUTED for {}, Price: {:.2f}, Cost: {:.2f}, Comm {:.2f}".format(
                        dn,
                        order.executed.price,
                        order.executed.value,
                        order.executed.comm,
                    )
                )

        # Cleans up the order list.
        if not order.alive() and order in self.o_li:
            self.o_li.remove(order)

    def notify_trade(self, trade):
        if not trade.isclosed:
            return

        self.log("OPERATION PROFIT, GROSS %.2f, NET %.2f" % (trade.pnl, trade.pnlcomm))

    def next(self):
        self.print_signal()

        # pending opening orders do nothing
        if len(self.o_li) > 0:
            return

        if not self.position and self.crossover == 1:
            self.long_buy_order = self.buy_bracket(
                data=self.datas[0],
                size=1,
                exectype=bt.Order.Market,
                stopprice=min(self.data.low.get(size=5)),
                stopexec=bt.Order.Stop,
                limitprice=self.datas[0].close[0] + 200,
                limitexec=bt.Order.Limit,
            )

            self.log(
                "LONG BUY at market {}: Oref {} / Buy at {}".format(
                    self.datetime.date(),
                    self.long_buy_order[0].ref,
                    self.data.close[0],
                )
            )

            # Store orders in a list
            self.o_li = [o for o in self.long_buy_order]

        else:
            pass

        if not self.position and self.crossover == -1:
            self.short_sell_order = self.sell_bracket(
                data=self.datas[0],
                size=1,
                exectype=bt.Order.Market,
                stopprice=max(self.data.high.get(size=5)),
                stopexec=bt.Order.Stop,
                limitprice=self.datas[0].close[0] - 200,
                limitexec=bt.Order.Limit,
            )

            self.log(
                "SHORT SELL at market {}: Oref {} / Sell at {}".format(
                    self.datetime.date(),
                    self.long_buy_order[0].ref,
                    self.data.close[0],
                )
            )

            # Store orders in a list
            self.o_li = [o for o in self.short_sell_order]

        else:
            pass



if __name__ == "__main__":

    cerebro = bt.Cerebro()

    data = bt.feeds.GenericCSVData(
        dataname="data/2006-day-001.txt",
        dtformat=("%Y-%m-%d"),
        timeframe=bt.TimeFrame.Days,
        compression=1,
    )
    cerebro.adddata(data)

    cerebro.addstrategy(MAcrossoveer)

    # Execute
    cerebro.run()

If you are trying to find the max of a 'line', then you need to use bt.Max()

Could you tell me what's different about what you are doing and backtrader's built in indicator? Your formulas look almost the same.

https://www.backtrader.com/docu/indautoref/#heikinashi

@agog said in Dynamic values for strategy:

MACD2 (Dynamic)

    macd2fast = self.p.macdfast * self.bb.upperband-self.bb.lowerband
    macd2slow = self.p.macdslow + self.p.macdslow * self.bb.upperband-self.bb.lowerband
    macd2signal = self.p.macdsignal + self.p.macdsignal * self.bb.upperband-self.bb.lowerband

    talib_macd2 = bt.talib.MACD(self.data, fastperiod=int(macd2fast), slowperiod=int(macd2slow), signalperiod=int(macd2signal), plot=False)

I think all of this needs to be in your init sections.

@Sajil-Thamban
We definitely want to help just show us your code and we'll point you in the right direction.

@cept0r It's never a waste to ask as it lead you to thinking through the solution. Nice!