Multi-Portfolio Implementation

[Sean-Ker]

Hello everyone,

Firstly, please let me thank you for such an amazing package and its great developers!

With reference to issues #20 and #104, how would you go about implementing a multi-portfolio back tester?
What are the key ideas, external classes, and/or changes that would need to take place to make it work with the current API?

Some Background

My (mostly-implemented) system is training a DL model on the features of historical data using Meta-Labelling. So, I am training it on an individual instrument which returns pretty good backtest stats. I repeat this procedure on about 12 different data frames (each in 15 minutes timeframe).

However, the next step is rebalancing/ optimizing the portfolio among multiple instruments (fx currencies in Oanda in my case).
I thought of doing so with RL which I have some experience with. For each step, the RL would properly size a buy, sell or even close a position of any of the symbols. The data it receives is the combined signals and %confidence from all of the individual ml models described above. But then, I am unable to backtest the whole system😢.

Even if I somehow discard the RL and hard-code the logic behind the money management system (which I consider to be the most essential pillar of trading), I still need a way of backtesting multi-symbols.

Falling in love with the flexibility, plotting, statistics, and the API, I am trying to make it work with backtesting.py. Even if it means changing some of the source code. Any help is appreciated. Thanks in advance!

[Sean-Ker]

What are the key ideas, external classes, and/or changes that would need to take place to make it work with the current API?

@kernc Any idea how to handle this?

[kernc]

If Backtest.run() method got a new parameter yielding=False (TBD), and this main backtest loop:

backtesting.py/backtesting/backtesting.py

Lines 1151 to 1165 in 73e1534

	for i in range(start, len(self._data)):
	# Prepare data and indicators for `next` call
	data._set_length(i + 1)
	for attr, indicator in indicator_attrs:
	# Slice indicator on the last dimension (case of 2d indicator)
	setattr(strategy, attr, indicator[..., :i + 1])
	# Handle orders processing and broker stuff
	try:
	broker.next()
	except _OutOfMoneyError:
	break
	# Next tick, a moment before bar close
	strategy.next()

were on line 1166 continued with:

if yielding:
    yield strategy

then you could provide a manager such as the following:

class MetaManager:
    model: RLModel  # Size/direction model

    def __init__(self, backtests):
        self.backtests = backtests

    def run(self):
        # List of generators/"coroutines"
        running_backtests = [bt.run(yielding=True, manager=self)
                             for bt in self.backtests]
        while True:
            try:
                strategy_instances = [next(bt) for bt in running_backtests]
            except StopIteration:
                # shortest backtest finished
                ...
                break
            else:
                # Collect signals and confidences, re-fit model
                self.update_model(strategy_instances)

    def get_signal(self, strategy):
        X = self.get_params(strategy)
        direction, size = self.model.predict(X)
        return direction, size


class PortfolioStrategy(Strategy):
    manager = None  # Passed in .run()

    def next(self):
        direction, size = self.manager.get_signal(self)
        ...


individual_backtests: List[Backtest] = ...

manager = MetaManager(individual_backtests)
manager.run()

That if yielding: yield ... will need some hacking to overcome run() method thus becoming a generator function.

But above should be the gist of it, and it seems a fairly good idea. Probably can be simplified some more.

Let me know how it works for you.

[Sean-Ker]

Thanks for the reply, greatly appreciated.
I will look into it tomorrow morning and let you know!

[Sean-Ker]

kernc,

Thank you for the time putting into coding this gist. I really liked your implementation!

To be quite honest, I already started spending the past week implementing my own backtester, ridiculous, huh?😆
But I think I'm gonna keep it simple and give a shot to your solution!

I realized that with that, there are a few more points to consider.

1. backtesting.py assumes that _Broker._cash is in the same currency of the instrument which you are trading.
   However, if you have multiple currencies and only one dominating "Home" currency, you need to account for exchanging funds to different currencies at a specific time and rate. (e.g. your account is based in USD and you want to trade CAD/HKD, at that time you need to convert USD to CAD, realize P&L, and exchange it back to USD.
2. Manage the total funds across investments and remove the _OutOfMoneyError Exception for individual instruments.
   Probably a good solution would be to remove the cash parameter altogether and pass it inside the Order class.
3. Total account stats across all instruments.
4. Write a new _plotting function that plots the total equity across currencies + individual P&L of each instrument (Not equity as that would get all messed up with the MoneyManagment system).

There is much work to be done. Better start coding👍

P.S. I looked at the way the package calculates P&L (Which surprisingly, is the first thing I looked into instead of the outstanding plotting😆). How did you manage to calculate P&L without a [standard/ mini/ micro] lot parameter (1 s. lot = 100,000 units)?