Hi All,

I am trying to do a Multi-Year Backtest (MYB) - using minutely resolution time series data. I have a set of bespoke indicators whose behaviour triggers trading. These indicators are arranged as a 3d grid of shape (a x b x len(prices) stored as a dictionary: The indicators are based solely on autoregressive style maths - they only take into account the time-series data of the instrument.

{ ( a1 , b1 ) : vals@len(prices) , ( a1 , b2 ) : vals@len(prices) , ... }.

I preload these indicators as usual and then feed the (a,b) hyperparameter grid into the backtest optimiser as:

bt.optimize(
 a = range(1,10),
 b = range(1,10),
 maximize=maximiser,
 method="grid"
)

Within the strategy object I access the values but passing the (a,b) parameters as keys to the dictionary and use self.I to create the indicator(s). There is an eventuality where I will look at indicators crossing so in the example below I have included 2 for clarity. All of this is standard stuff.

HOWEVER - I need to add a layer of complexity to this which I can't figure out. In real life, I will be re-optimising my strategy parameters based on the current equity performance of the model. So midway through the MYB, I will need to make use of different (a,b) parameters, and not just find out which (a,b) parameters worked over that full-term period. This will happen at undetermined intervals based on the nature of the times-series data and the performance of the model. I need to nest backtests.

Again - in real-life - the MYB occurs over multiple years, but the strategy parameter selection done at outset (and at any point mid-way through) will occur over only a few days, maybe less - that's user defined. As far as I can see - at the outset I could bt.optimize on prices.iloc[:5000] and then bt.run on prices.iloc[5000:] using the results from the optimisation. But this does not allow for any mid-MYB re-optimisation.

MY THINKING SO FAR:

I can access the current equity of the model during 'run-time' via the protected broker._equity object (I patiently await your scorn), I can use that to assess whether or not to perform a re-optimisation, so the condition for mid-MYB re-optimisation is easy. However, I am stumped at how I go about actually re-optimising mid-way through. And then equally, after doing this how I pass the new (a,b) results from the mid-MYB bt.optimize back into the higher-leverl MYB strategy object.

class MyStrategy(Strategy):
 # precompute full indicator grid and initialise hyper-params
 inds: dict = CustomIndicator().indicators
 a1: int = 1
 b1: int = 10
 a2: int = 10
 b2: int = 1
 def init(self,):
 
 self.ind1 = self.I(lambda x: x, self.inds[(self.a1,self.b1)])
 self.ind2 = self.I(lambda x: x, self.inds[(self.a2,self.b2)])
 
 def next(self):
 if broker._equity < broker._cash_initial * (some_max_allowable_loss):
 inner_cash = self._cash
 # do I have to recreate a Strategy Class here?
 innerbt = Backtest(
 self._data[-5000:],
 ["WHAT GOES HERE AND HOW?"], # Should be a Strategy Object I think?
 cash=inner_cash,
 )
 new_result = bt.optimize(
 a = range(1,10),
 b = range(1,10),
 maximize=maximiser,
 method="grid"
 )
 # Can I update the currently working indicators of the MYB?
 self.ind1 = self.I(lambda x: x, self.inds[(new_result._strategy.a1,new_result._strategy.b1)]
 self.ind2 = self.I(lambda x: x, self.inds[(new_result._strategy.a2,new_result._strategy.b2)]
 if crossover(self.ind1 ,self.ind2):
 if not self.position:
 self.buy()
 elif self.position.is_short:
 self.position.close()
 self.buy()
 
 elif crossover(self.ind2 ,self.ind1):
 if not self.position:
 self.sell()
 elif self.position.is_long:
 self.position.close()
 self.sell()
 else:
 pass

MY QUESTION:

Is any of this possible? Am I looking at this in the right way? How would you go about this? How do I define an inner-strategy which draws some of its information from an outer-strategy? Do I need to define a new strategy class within the conditional?

Any pointer here would be very helpful!

Thanks in advance,

K