Best posts made by vladisld

Short:

In your class methods you may use self.p and self.params interchangeably - they are actually the same object.
(see the 'Parameters' section in the docs: https://www.backtrader.com/docu/concepts/)

Longer:

One need to distinguish between the params class variable and the self.params (or self.p for that matter) instance variable.

params class variable (list of tuples or dict) defines the custom parameters and their default values that will be later used to "magically" create and populate the self.params (or self.p) instance variable

This self.params (or self.p) instance variable will have members for each tuple originally present in params class variable but their value could be different depending of which parameters where passed during class instantiation ( or have their default values if no matching parameters were passed )

TLDR:

The params class variable may be defined in classes that use MetaParams metaclass (or its derivatives) during their instantiation sequences (like Cerebro, Strategy, Analyzer, BrokerBase, Filter, Indicator, an so on and all their inherited classes ).

During the instantiation the meta-class "hijack" the instantiation sequence and creates additional instance variables (self.p and self.params in particular, but also many others like 'datas', 'data0' and other aliazes for LineSeries inherited classes for example), intializing them in various ways. You may take a look at the with_metaclass method in utils\py3.py for technical details of how this is implemented.

For example one of such meta-classes is MetaParams class which is particularly responsible for creating the self.p and self.params instance variables ( see its donew method )

During your strategy (derived from Strategy class which uses MetaParams meta-class) instantiation process a new auto-generated class (let's call it X) will be used to hold the parameter values. For each tuple in the 'params' class variable there will be a member in X class. The instance of this X class will be created, where each member will get its value either from the parameters passed during the Cerebro.addstrategy call or from the default value in the params class variable tuples.

For example let's assume your strategy params variable defined as:

class SMACrossOver(bt.Strategy):
    params = (
        ('stake', 1),
        ('period', 30),
    )

and you add this strategy to Cerebro using:

cerebro.addstrategy(SMACrossOver, period=15)

The values for 'self.p' members inside your strategy will be:

self.p.stake == 1  # from default value in `params` class variable
self.p.period == 15 # from parameters to cerebro.addstrategy

@yacc2000 said in Multicore optimization cause performance degradation.:

Is preload=False and Runonce=False cause multicore optimization not working?

It will work, just much slower. Preloading the data is one of the technics to allow running the optimization at full speed. Technically it means that pre-loaded data's memory is shared between multiple working processes instead of being reloaded to the internal buffers for each run of the engine (for each permutation of optimized parameters).

As in my answer to your previous post - the framework wasn't designed to dynamically change the data feeds during the backtest and/or optimization. You may fight against the framework ( wish you luck), change your design ( by preloading all your data feeds once) or just try a different framework

External blog:

https://backtest-rookies.com/2017/08/22/backtrader-multiple-data-feeds-indicators/

Internal blog:
https://www.backtrader.com/blog/posts/2017-04-09-multi-example/multi-example/

Community post(s):
https://community.backtrader.com/topic/2032/manage-multiple-assets/8

This is just one sample, but there are multiple others - try to search.

It seems the link in the original topic is no longer valid. Here is the updated link: https://www.backtrader.com/blog/2019-05-20-momentum-strategy/momentum-strategy/

Probably the same issue as in the following post:

https://community.backtrader.com/topic/3306/signals-stop-showing-after-a-certain-date/2

Note: Please do not post your code as image. See the top of the page for the instructions for posting code in the text form.

@André-Tavares said in How can I inherit params from a parent class and append on the child class?:

params.update({

No need to update the params dict. The parameters from the base classes are fused automagically by metaclass during the instantiation. You may take a look at the following post as well: https://community.backtrader.com/topic/2379/difference-between-params-and-p/2

Ok, so the following was done:

• Created the org: https://github.com/backtrader2
• Created two teams within the org: admins, contributors
  • admins: has Admins permissions (all possible permissions)
  • contributors: has Write permissions (read, clone, push, manage issues and pull requests)
• Forked the original mementum/backtrader repository under org: https://github.com/backtrader2/backtrader
• Invited both @ab_trader and @run-out to the admin team ( those who provided their github ids)
• Enabled the Issues tab.

Questions:

• Any others want-to-be admins ? Please either apply directly in github or provide your github id in this thread

• Any suggestions/todos that I've missed ?

Notes:

• There are a 'GitHub Discussions' forum for each team - so some admin related topics could possibly be discussed there instead of polluting this community forum ( other suggestions are welcome as always )

Thanks all for the support and interest in maintaining this wonderful project.

Few things:

• Positions are maintained by the broker per data.

• position property of the Strategy class just returns the position of the data[0]. If you need to get the position for the different data, the getposition(data=...) could be used.

Now the problem in the above code seems to be related to the following logic in the next method:

        if not self.position:
            self.log('Buy Created, %.2f ' % (self.dataCloseLong[0]))
            self.order = self.buy(data = self.datas[0],size=1)
        else:
            self.log('Sell Created, %.2f' % self.dataCloseShort[0])
            self.order = self.sell(data = self.datas[1],size=1) 

If we have no position in data[0] then the 'buy' will be issued. Once this 'buy' is completed - the position will be established in data[0].

The next time the next will be called, the position in data[0] is present - so the 'sell' is issued for data[1] ( different data, right ). So the position in data[0] will never be changed from now on.

Please correct me if I'm wrong.

@elektor said in Passing Timeframe to Rolling Return Analyzer:

timeframe=52

timeframe should have values from the following list:

 TimeFrame.Ticks
 TimeFrame.MicroSeconds
 TimeFrame.Seconds
 TimeFrame.Minutes
 TimeFrame.Days
 TimeFrame.Weeks
 TimeFrame.Months
 TimeFrame.Years
 TimeFrame.NoTimeFrame

so in your case:

timeframe=TimeFrame.Weeks, compression=52

@backtrader said in Backtrader's Future:

I am adding a few bug fixes to the main repository and release a new version with them.

God bless you Daniel, you are back. Thanks a lot. So what do you say about the initiative to continue the maintenance for bug fixing ?

Should we continue with the fork, or there is a way to continue on the official repo?

Yes sir. This is Backtrader framework support forum.

There are other general algo and non-algo trading forums out there:

https://www.reddit.com/r/algotrading/
https://www.elitetrader.com/et/

and many others - just google it.

@hoflz5 try to use 'size' parameter instead of 'amount'. Docs here:https://www.backtrader.com/docu/strategy/

You are very welcome. Currently we have a bunch of issues open in backtrader2 repository. Please take a look. Right now we are concentrating on bug fixes only - no new features. But even this goes pretty slowly to tell you the truth ☺️.

In this case, I'd just run the whole Cerebro logic for each stock separately ( in a loop) - at least that's what I'm doing in my project.

Probably others may have better advice.

Short:
I'm not sure the IBData datafeed is supported for optimization with multiple CPUs (it may work on single CPU though).

Detail:

During the optimization with multiple CPU involved, Backtrader will use the process pool to run the optimization for each parameter permutation in parallel.
For this to work the Cerebro instance will need to be copied to each worker process (it is not done if only single CPU is used).
This is implemented by using pickle mechanism, which is used to serialize the Cerebro instance (together with all the objects connected to it - like data feeds, analyzers ... ).
The problem with IBData data feed is that it is using some objects that can't be serialized (ex. locks, sockets, ...).
Usually, for optimization purposes one may use the data feeds that support preloading of data bars without keeping any sync/connection objects alive (ex. CSV or Database based datafeeds)

it seems that you are using the same bought_bar and bars_since_purchase variables for all data feeds instead of keeping those attributes per data feed.

Something like:

class FixedExitStrategy(bt.Strategy):

    def __init__(self):
        pass

    def start(self):
        self.bought_bars={d:0 for d in self.getdatanames()}
        self.bought_sizes={d:0 for d in self.getdatanames()}

    def next(self):

        for i, d in enumerate(self.getdatanames()):
            data = self.getdatabyname(d)
            pos = self.getposition(data=data)

            if not pos.size:
                if data.signal[0] != data.signal[-1]:
                    if data.signal[0] == 1:
                        self.bought_sizes[d] = data.position_size[0]
                        self.buy(data=data, size=self.bought_sizes[d])
                        self.bought_bars[d] = len(self)

            if pos.size:
                if (len(self) - self.bought_bars[d]) == 10:
                    self.close(data=data, size=self.bought_sizes[d])

And I'm not sure where the self.getdatabyname(d).position_size is coming from - sorry.

Please take a look at the following post: https://backtest-rookies.com/2017/08/22/backtrader-multiple-data-feeds-indicators/

Is it what you was looking for?

Most probably this is because of the available cash that you set for the broker - actually you didn't so the default (10000$) is used instead. The problem is that the price of the asset you are working with grows beyond that limit - the price is already around 11000$ after July. So your orders are simply rejected from that point on.

Try to set the available cash to something larger:

cerebro.broker.setcash(1000000)

It would be helpful if you could share your full code ( yes I understand this is the quickstart tutorial, but nevertheless ). A wild guess is that adddata call is missing somewhere but without actually seeing the code it is hard to tell for sure.

@marketwizard said in Test a strategy over a list of stocks (50+):

cerebro.addstrategy(EMAStack)

    # Run over everything
    strategies = cerebro.run()
    EMAStack = strategies[0]

You are overriding the EMAStack name - which should be a class of your strategy with the strategy instance returned from the Cerebro.run() method. So the next iteration in the cerebro.addstrategy(EMAStack) the strategy instance is passed instead of strategy class.