Seems like the code thinks your date is a string. Maybe try explicitely putting it to datetime.

df.index = pd.to_datetime(df.index)

@chewbacca said in Running multiple instances:

Not sure if this helps, but in my method I add the analyzer to cerebro before running. I run one backtest, then extract the analyzer data after cerebro and the backtest are finished. Each backtest is set up and run once by the multiprocessing.

If you are saving the results of each spreadsheet to a separate file, then the code above should be no problem memory wise.

Let me know if you have any questions.

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)