It seems Backtrader is not compatible with Dask.
Dask version not working:
with ProgressBar(): # Backtrader is not compatible with Dask
stats = db.from_sequence(params_list).map(run_strategy).compute()
Plain multiprocessing version works:
with multiprocessing.Pool(os.cpu_count()) as p:
stats = p.map(run_strategy, params_list)
I guess the issue is in the Donchian channel indicator:
class DonchianChannelsIndicator(bt.Indicator):
'''Donchian channel.'''
alias = ('DCH', 'DonchianChannel',)
lines = ('dcm', 'dch', 'dcl',) # dc middle, dc high, dc low
params = (
('period', 20), # lookback period
)
plotinfo = dict(subplot=False) # plot along with data
plotlines = dict(
dcm=dict(ls='--'), # dashed line
dch=dict(_samecolor=True), # use same color as prev line (dcm)
dcl=dict(_samecolor=True), # use same color as prev line (dch)
)
def __init__(self):
super().__init__()
self.addminperiod(self.params.period + 1)
self.lines.dch = bt.indicators.Highest(self.data.high(-1), period=self.params.period)
self.lines.dcl = bt.indicators.Lowest(self.data.low(-1), period=self.params.period)
self.lines.dcm = (self.lines.dch + self.lines.dcl) / 2.0 # avg of the above
In sequential mode the indicator has 3 lines, while in parallel mode the indicator has 0 lines, why? This is so weird.
Probably Backtrader is not compatible with Dask?
@ab_trader Good idea, I'll try it, thanks!
I write a strategy in this Jupyter notebook: Clenow trend following strategy - Github
I try to run a grid search to find out the optimal parameters combination. If I run sequentially as the following, no problem at all:
stats = []
for params in tqdm(params_list):
result = run_strategy(params)
stats.append(result)
If I run in parallel as the following:
stats = db.from_sequence(params_list).map(run_strategy).compute()
It always throw out an exception:
~/anaconda3/lib/python3.7/site-packages/backtrader/lineiterator.py in dopostinit()
133
134 # my minperiod is as large as the minperiod of my lines
--> 135 _obj._minperiod = max([x._minperiod for x in _obj.lines])
136
137 # Recalc the period
ValueError: max() arg is an empty sequence
Full stack trace is in the Jupyter notebook.
Any ideas? Thanks!
I want to optimize my strategy with customized parameters, for example:
cerebro.optstrategy(bt.strategies.MA_CrossOver, fast=range(2,8), slow=range(4, 16))
The above configuration generates a lot of parameters that I don't want.
Instead, I want to specify parameters manually as the following:
cerebro.optstrategy(bt.strategies.MA_CrossOver, myparams=[
{'fast': 2, 'slow': 4},
{'fast': 4, 'slow': 8},
{'fast': 3, 'slow': 7},
])
How can I achieve this? Thanks
Typo: alias = ('ClenowTrendFollowing',)
I implemented the trend following strategy in the book "Following the trend" by Andreas Clenow. The following is the core logic:
class ClenowTrendFollowingStrategy(bt.Strategy):
"""The trend following strategy from the book "Following the trend" by Andreas Clenow."""
alias = ('MeanReversion',)
params = (
('trend_filter_fast_period', 50),
('trend_filter_slow_period', 100),
('fast_donchian_channel_period', 25),
('slow_donchian_channel_period', 50),
('trailing_stop_atr_period', 100),
('trailing_stop_atr_count', 3),
('risk_factor', 0.002)
)
def __init__(self):
self.trend_filter_fast = bt.indicators.EMA(period=self.params.trend_filter_fast_period)
self.trend_filter_slow = bt.indicators.EMA(period=self.params.trend_filter_slow_period)
self.dc_fast = DonchianChannelsIndicator(period=self.params.fast_donchian_channel_period)
self.dc_slow = DonchianChannelsIndicator(period=self.params.slow_donchian_channel_period)
self.atr = bt.indicators.ATR(period=self.params.trailing_stop_atr_period)
# For trailing stop
self.max_price = self.data.close[0] # track the highest price after opening long positions
self.min_price = self.data.close[0] # track the lowest price after opening short positions
def next(self):
is_long = self.trend_filter_fast > self.trend_filter_slow # trend filter
# Position size rule
max_loss = self.broker.getvalue() * self.p.risk_factor # cash you afford to loss
position_size = max_loss / self.atr
# self.dc_slow.low <= self.dc_fast.low <= self.dc_fast.high <= self.dc_slow.high
assert self.dc_slow.low <= self.dc_fast.low
assert self.dc_fast.low <= self.dc_fast.high
assert self.dc_fast.high <= self.dc_slow.high
if self.data.close > self.dc_slow.high:
if is_long and self.position.size == 0:
self.long_order = self.buy(size=position_size) # Entry rule 1
print(f'Long {position_size}')
self.max_price = self.data.close[0]
return
elif self.data.close > self.dc_fast.high:
if self.position.size < 0:
print(f'Close {self.position.size} by exit rule 2')
self.close() # Exit rule 2
return
elif self.data.close > self.dc_fast.low:
pass
elif self.data.close > self.dc_slow.low:
if self.position.size > 0:
print(f'Close {self.position.size} by exit rule 1')
self.close() # Exit rule 1
return
else:
if (not is_long) and self.position.size == 0:
self.short_order = self.sell(size=position_size) # Entry rule 2
print(f'Short {position_size}')
self.min_price = self.data.close[0]
return
# Trailing stop
if self.position.size > 0:
self.max_price = max(self.max_price, self.data.close[0])
if self.data.close[0] < (self.max_price-self.atr[0]*3):
print(f'Close {self.position.size} by trailing stop rule')
self.close()
return
if self.position.size < 0:
self.min_price = min(self.max_price, self.data.close[0])
if self.data.close[0] > (self.min_price+self.atr[0]*3):
print(f'Close {self.position.size} by trailing stop rule')
self.close()
return
Jupyter notebook: https://github.com/soulmachine/crypto-notebooks/blob/master/backtest/Clenow-trend-following.ipynb
Any improvement suggestions? Thanks.
After reading the source code I think I've figured out.
timeframe and compression are used at analyzers/sharpe.py#L153:
returns = list(itervalues(self.timereturn.get_analysis()))
timeframe=bt.TimeFrame.Days, compression=1, means TimeReturn will take a snapshot on the equity curve per daytimeframe=bt.TimeFrame.Minutes, compression=24*60, means TimeReturn will take a snapshot on the equity curve per 24*60 minutes, which is the same as a dayreturns is a list of (timestamp, percentage), sharpe ratio is calculated on top of this list.
timeframe, compression --> TimeReturn -->returns --> sharpe_ratio
The factor is used to convert riskfreerate to rate, which used at analyzers/sharpe.py#L186:
ret_free = [r - rate for r in returns]
Since I snapshot on the equity curve per day, and one year contains 365 trading days(crypto exchanges never stop on weekends, which is different with stocks).
Recommended configurations:
Noneannualize =True, because sharpe ratio is usually in annual form.riskfreerate=0.01 and convertrate=True, Backtrader already sets them defaulttimeframe and compression to make TimeReturn take a snapshot on equity curve per day, if the timeframe of your data feed is equal or less than 1 day, set timeframe=bt.TimeFrame.Days, compression=1, otherwise set timeframe=bt.TimeFrame.Days, compression=data_feedfactor to 252 for stocks and 365 for cryptocurrencies.Examples:
timeframe=bt.TimeFrame.Days, compression=1, factor=252,annualize =Truetimeframe=bt.TimeFrame.Days, compression=3, factor=252,annualize =Truetimeframe=bt.TimeFrame.Days, compression=1, factor=365,annualize =Truetimeframe=bt.TimeFrame.Days, compression=3, factor=365,annualize =Truetimeframe=bt.TimeFrame.Days, compression=1, factor=365,annualize =TrueAfter reading some source code and several experiments, my guess is that the timeframe in SharpeRatio has no relation to the timeframe of the data feed. The timeframe in SharpeRatio means how frequent you want to snapshot the equity curve.