Backtest Optimiser Constraint Function - syntax & structure query

[KitHaywood]

Hi,

I'm trying to backtest some OCHLV data with a minimisation constraint on the total number of trades, and for the basic example of SMA Cross - also n1 and n2 attributes of _strategy. I think I need to make max_trades a class variable of the SMACross class but cannot see how I factor that into the calculations that occur there.

I suspect that I need to call something like this in the SMACross init method.

def num_trades(values):
    return np.ndarray(max([x for x in range(len(values))])

self.I(num_trades, self.data.Close)

Is this remotely in the right ballpark?

Thanks,

Kit

[kernc]

With constraint= parameter, you merely constrain the input variables' value search space. You don't know anything about the number of trades in advance.

What you're looking for is a customized maximize= function. To optimize the strategy in such a way that only between three and ten trades are made, something like this:

def maximize_func(stats):
    return stats['Equity Final [$]'] if 3 <= stats['# Trades'] <= 10 else 0

bt = Backtest(...)
bt.optimize(..., maximize=maximize_func)

[KitHaywood]

Thanks a bunch! Works a charm

[kiann00]

sorry, if I seem to hijack this thread,... I have a similar query but not exactly the same.
What if I wish to maximize and minimize certain of the stats? Specifically,

I would like to (a) maximize the Equity Final, (b) minimize the Max. Drawdown [%], and (c) maximize the Expectancy [%]
How might I do this?

[kernc]

Simply make it a formula that has what you maximize in the numerator and what you minimize in the denominator:

def maximize_func(stats):
    return stats['Equity Final [$]'] / stats['Max. Drawdown [%]'] * stats['Expectancy [%]']

bt = Backtest(...)
bt.optimize(..., maximize=maximize_func)

For best results, you might need to apply additional conversion functions (np.sqrt, np.log, ...) and/or coefficients.

[kiann00]

thanks! @kernc 😁

[kiann00]

hi @kernc , sorry I have to come back. I am trying to use the same maximize function, but within the backtesting.optimize().

I am getting an error message. Is it that a 'maximize' function only works within bt.optimize(), but not method = 'skopt'?
Full-code, followed by error message.

# testing of custom indicators within

def fitcurve(x_pts):
    poly = np.polyfit(np.arange(len(x_pts)), x_pts, 1)
    return np.poly1d(poly)[1]

def regress(data, window_):
    return data.rolling(window_).apply(lambda x: fitcurve(x)).to_numpy()

def maximize_func(stats):
    return stats['Equity Final [$]'] / stats['Max. Drawdown [%]'] * stats['Expectancy [%]']

class Signal_Test(Strategy):
    # lets do a sweep of multiple technical indicators and try to do backtesting optimization using backtesting.py
    rsi_upper = 70
    rsi_lower = 30
    rsi_window = 14
    rsi_close = 60
    macd_fast = 12
    macd_slow = 26
    macd_sig = 9
    macd_upper = +2.5
    macd_lower = -2.5
    macd_close = 2
    obv_window = 30
    
    
    # Do as much initial computation as possible
    def init(self):
        self.rsi = self.I(ta_.momentum.rsi, pd.Series(self.data.Close), self.rsi_window)
        self.macd = self.I(ta_.trend.macd_diff, self.data.Close.to_series(), self.macd_fast, self.macd_slow, self.macd_sig)
        self.Regress = self.I(regress, self.data.Close.to_series(), self.obv_window)
        
    # Step through bars one by one
    # Note that multiple buys are a thing here
    def next(self):
        # print(len(self.rsi), len(self.macd), len(self.Regress))
        display_ = False
        # first set the buy signal
        if (self.rsi < self.rsi_lower) & (self.Regress > 0):
            # print ((self.rsi < self.rsi_lower) & (self.macd > self.macd_upper))
            if self.position.size < 0:
                self.position.close()
                self.buy(size = 1)
            else:
                self.buy(size = 1)
            if display_:
                print('BUY', self.position.size, self.equity, self.rsi[-1], self.data.Close[-1])
        # second set the sell signal
        elif (self.rsi > self.rsi_upper) & (self.Regress < 0):
            # print ((self.rsi < self.rsi_lower) & (self.macd > self.macd_upper))
            if self.position.size > 0:
                self.position.close()
                self.sell(size = 1)
            else:
                self.sell(size = 1)
            if display_:
                print('SELL', self.position.size, self.equity, self.rsi[-1], self.data.Close[-1])
        # third what we do if we are long and we should close
        elif self.position.size > 0:
            if (self.rsi > self.rsi_close):
                self.position.close()
                if display_:
                    print('CLOSE', self.position.size, self.equity, self.rsi[-1], self.data.Close[-1])
        elif self.position.size < 0:
            if (self.rsi > -self.rsi_close):
                self.position.close()
                if display_:
                    print('CLOSE', self.position.size, self.equity, self.rsi[-1], self.data.Close[-1])
        
        else:
            if display_:
                print('HOLD', self.position.size, self.equity, self.rsi[-1], self.data.Close[-1])
                
s_time = time.time()
bt = Backtest(data_[0:200], Signal_Test, cash=10_000, commission=.002)
stats = bt.run()
display(stats['_strategy'])
print('time taken is', time.time() - s_time)

# testing brute-force optimize
s_time = time.time()
stats1 = bt.optimize(
        rsi_upper = range(50,90,5),
        rsi_lower = range(15,40,5),
        rsi_window = range(10,25,2),
        rsi_close = range(30, 70, 5),
        obv_window = range(20, 40, 2),
        maximize= maximize_func)
display(stats1['_strategy'])
print('time taken for brute force optimization is', time.time() - s_time)

s_time = time.time()
stats2, heatmap, optimize_result = bt.optimize(
    rsi_upper = [50,90],
    rsi_lower = [10,40],
    rsi_window = [10,25],
    rsi_close = range(30, 70, 5),
    obv_window = [20, 40],
    maximize= maximize_func,
    constraint = lambda p: (p.rsi_lower < p.rsi_upper),
    method='skopt',
    max_tries=1000,
    random_state=0,
    return_heatmap=True,
    return_optimization=True)


display(stats['_strategy'])
print('time taken for grid optimization is', time.time() - s_time)

Below is the error message, when I try to use grid-based 'skopt' for backtesting optimization

Cell In [23], line 11, in maximize_func(stats)
10 def maximize_func(stats):
---> 11 return stats['Equity Final [$]'] / stats['Max. Drawdown [%]'] * stats['Expectancy [%]']

ZeroDivisionError: float division by zero