Posts made by run-out

Perhaps I posted this on the wrong question. @chewbacca I would take the advice of @ab_trader @vladisld.

@vladisld I'm not sure. No one has answered the op question yet. Perhaps there's no advantage to mine?

I can share the code I use for this. I have not attempted to generalize my code examples but I hope this helps. I have two modes for running backtest using parameters as per your question.

1. Run individual backtest one at a time and
2. Multi processing.

At the heart of each is a dictionary of dictionaries of parameters for each test. So let's say you have ten test, then you would have ten dictionaries with your parameters that you will pass to runstrat, the function that will build cerebro.

Then it's just a matter of iterating through the dictionary and building each run strat, run your back test, and wait for the results. When you have your results, save these however you like.

Here is example code for sequentially running one backtest at a time. 'scenarios' is a dictionary of 'scenes' which are dictionaries holding one set of parameters for one backtest.

def backtest_controller(scenarios):
    """ Runs multiple backtests """

    # Loop though the combinations.
    loop = 1
    for scene in scenarios:
        print("Starting loop {}".format(loop))
        loop += 1
        scene["test_number"] = str(uuid.uuid4()).replace("-", "")[:10]

        # Run the main strategy
        res, final_value = run_strat(scene)
        # If there are transactions, save results spreadsheet.
        if scene["save_agg"]:
            ra.result(res, scene, scene["test_number"])

        if scene["save_result"]:
            if len(res[0].analyzers.getbyname("transactions").get_analysis()) > 0:
                agg_dict = result(res, scene, scene["test_number"])
                if scene["save_db"]:
                    df_to_db(agg_dict)
        print(f"Final value {final_value:.2f}")

    return None

Note a few things. I create a test number to help track results later between multiple tables in the results spreadsheet.

I have three different functions for saving data, an aggregate spreadsheet with test totals, and detailed spreadsheet with multiple spreadsheets per test, and postgres db. These are ra.result, result, and df_to_db

If you wish to use parallel processing, you need to pass a function to multiprocessing. So there's an extra function step.

So the same code above would be converted to just running once.

def backtest_controller_multi(scene):
    """ Runs a single backtest. """
    scene["test_number"] = str(uuid.uuid4()).replace("-", "")[:10]

    # Run the main strategy
    res, final_value = run_strat(scene)

    # If there are transactions, save results spreadsheet.
    if scene["save_agg"]:
        ra.result(res, scene, scene["test_number"])

    if scene["save_result"]:
        agg_dict = result(res, scene, scene["test_number"])
        return agg_dict

Note the input is only one dictionary, not a dictionary of dictionaries.
You call backtest_controller_multi using the muliprocessor as follows.

# multiprocessing.freeze_support()
                start_test = time.time()
                pool = multiprocessing.Pool(processes=multiprocessing.cpu_count() - 2)
                cum_backtest = 0
                backtest_with_trades = 0
                for agg_dict in pool.imap_unordered(
                    st.backtest_controller_multi, scenarios
                ):
                    if (
                        change_params["save_result"]
                        and change_params["save_db"]
                        and agg_dict is not None
                    ):
                        df_to_db(agg_dict)
                        backtest_with_trades += 1
                    cum_backtest += 1
                    print(
                        f"Backtests: {cum_backtest:3.0f} / {total_backtests:3.0f} "
                        f"backtests with trades {cum_backtest:3.0f} -- Elapsed: {(time.time() - start_test):.2f}"
                    )
                pool.close()
                print(f"\nThere were {backtest_with_trades} successful trades.")

Note a few things.

• multiprocessing.freeze_support() is commented out. This line is for windows machines and allows this to run. (i'm on linux)
• By using pool.imap_unordered in a for loop, you are able to start processing results while further threads are running backtest, saving in ram memory and speeding up the process.

In all instances you are now passing a dictionary to runstrat instead of using argparse. You can pass in the scene as kwargs to your strategy. Of course, you MUST have all of your parameters established in your strategy or backtrader will rightfully throw an error.

def run_strat(scene):
    """
    Sets up and runs a back test for a basic moving average strategy.
    :param scene: Dictionary containing all parameters.
    :return: Cerebro strategy object and total value.
    """

    # Cerebro create
    cerebro = bt.Cerebro()

    # Set Dates
    date_start = scene["from_date"]
    date_end = scene["to_date"]

    if scene["printon"]:
        print(
            "Running back test: loading data from {} with trading starts on {} to {}.\nLoading data...".format(
                scene["from_date"], scene["trade_start"], scene["to_date"]
            )
        )
    else:
        pass

    cerebro.addstrategy(Strategy, **scene)

    # Broker
    cerebro.broker = bt.brokers.BackBroker(        

    # Cash
    cerebro.broker.setcash(scene["initinvestment"])
    cerebro.broker.setcommission(commission=scene["brokerage_fee"])

    ...

    # Cerebro run
    strat = cerebro.run(tradehistory=True)
    
    return strat, cerebro.broker.getvalue()
    

You can use the parameters in the dictionary 'scene' to both set up the cerebro run and feed into your strategy.

Try this post. The op had a reasonably good example. You would need to subtract commission manually.

Also take a look at the code base to see what's going on under the hood.

I would also suggest you thoroughly study the docs here.

Excecution of one of the stop loss or the take profit will cancel the other.

Try iterating through the list self.so. Something like:

for s in self.so:
    self.cancel(s)

@Adham-Suliman said in Why won't order.Accept? Is it because I need volume?:

Is there a way to delete this topic? I was able to resolve the problem.

No, this is not an editable forum.

I"m having a bit of a hard time following you. But try this format out.

import backtrader as bt

class CustomPandasLoader(bt.feeds.PandasData):
    lines = (
        'quote_asset_volume',
        'number_of_trades',
        'taker_buy_base_asset_volume',
        'taker_buy_quote_asset_volume',
        'p0',
        'p1',
        'p2',
    )
    params = (
        ('quote_asset_volume', -1),
        ('number_of_trades', -1),
        ('taker_buy_base_asset_volume', -1),
        ('taker_buy_quote_asset_volume', -1),
        ('p0', -1),
        ('p1', -1),
        ('p2', -1)
    )
    datafields = bt.feeds.PandasData.datafields + (
        [
            'quote_asset_volume',
            'number_of_trades',
            'taker_buy_base_asset_volume',
            'taker_buy_quote_asset_volume',
            'p0',
            'p1',
            'p2',
        ]
    )
    
data = CustomPandasLoader(
        dataname=yourdataframe
    )
cerebro.adddata(data)

Data gets resampled when adding to cerebro, then you can access this in init or other places.

It is helpful if you include all of the code, the output you are getting, and where you think that output is wrong. Thanks

@ayush-somani See if this post helps

I'm curious what you would propose as a solution that would allow for knowledge of the intrabar price movement? How can you know if the entry is filled before the tp or stop? And in what order is the tp or stop if after the entry bar?

Each bar is a black box. We cannot know what is going on inside between open and close. Any assumptions you make inside that bar will not neccessarily get you closer to reality.

@ayush-somani said in Indicator that checks if the current candle high (as soon as a condition is met) breaks the previous days high (over a specific period ) or not:

if self.datas[0].high[0] < self.datas[0].high[-int(self.l.firsthighindex[0])]:

Using MaxN might be more straight forward.

@ayush-somani said in Indicator that checks if the current candle high (as soon as a condition is met) breaks the previous days high (over a specific period ) or not:

What does exactly FindFirstIndexHighest does (if I use it calculating count of those bars)?

This will return the index location of the first highest value looking back. See docs.

That's going to be a bit tricky, since you can't calculate the average price until after close.

@magwal76 said in Elders Force Index:

Elders Force Index

I found this definition on tradingview.

(CurrentPeriodClose - PreviousPeriod Close) X Volume

So the indicator could be created in __init__:

self.elder = (self.datas[0].close(0)- self.datas[0].close(-1)) * self.datas[0].volume(0)

@André-Tavares said in Execute Market order on average price on BT:

average price of the next day

I'm not sure I'm following you. Do you want to execute your order on the average price of the current bar and previous?

@Akhil-Juluru said in bt.If Help:

self.datas[0].close(-2) > self.datas[0].open(-2) and self.datas[0].close(-1) > self.datas[0].open(-1) and self.datas[0].close(0) > self.datas[0].open(0)

I'm not sure what your goal is with the date component, but you could tackle the last n periods with close over open as follows:

def __init__(self):
      self.close_over_open = self.datas[0].close > self.datas[0].open
      self.close_over_open_over_nper = bt.ind.SumN(self.close_over_open, period=3) == 3

@da-zhang said in find bugs when using the DemarkPivotPoint indicator:

DemarkPivotPoint

Please include the error message/faulty pic or chart so we can help you.

Can you include the errors you are getting here so that I or others can help you? Thanks.