Are there any threads where with the best strategies by annual return that people find?
If not you can use this thread to share some strategies that you like. I'll be posting mine when I find a strategy that goes above the average 7% annual return of the market.
To check if my strategy was correct I tried to replicate the results from the following website:
Golden Cross – Which is the best?
I'm making the calculations for 6 indexes instead of 16 like that website because it takes a long time to finish. And I don't know if I'm using the same beginning and end dates as the website. I'm using 1994-01-01 to 2019-12-31.
But even with this differences I would expect the return to be more similar to the one from the website. For the 13-48 EMA crossover I get a 4.23% total return and the website for the 13-48.5 gets a 10.16% on the long side.
I was thinking maybe if I only execute long orders I get a higher return? But even though the return on the short side is lower it is not negative so it shouldn't decrease the total return.
Other thing that might be happening is that I can't compare the results from the TimeReturn analyzer that I'm using with the annual return from the website but I've used that beggining and end date to be 25 years exactly.
What might be making my results to be lower than those from the website?
In my table I'm using TimeReturn and the one below uses Annualized Return During Exposure so I'm not expecting them to be the same. I just expect the maximum from my table to be close to 10.16%.
Thanks. Here it is:
optimize_all.py
from __future__ import (absolute_import, division, print_function,
unicode_literals)
import os.path
import sys
import argparse
import datetime
from os import listdir
import numpy as np
import backtrader as bt
from backtrader.analyzers import (SQN, AnnualReturn, TimeReturn, SharpeRatio,
TradeAnalyzer)
from strategies.strategies import *
from sizers import MaxRiskSizer
from commissions import DegiroCommission
from heatmap import my_heatmap
def runstrategy():
args = parse_args()
# Get the dates from the args
fromdate = datetime.datetime.strptime(args.fromdate, '%Y-%m-%d')
todate = datetime.datetime.strptime(args.todate, '%Y-%m-%d')
modpath = os.path.dirname(os.path.abspath(sys.argv[0]))
datapath = os.path.join(modpath, args.data)
final_results_list = []
for file in listdir(datapath):
path = os.path.join(datapath, f'{file}')
data = bt.feeds.YahooFinanceCSVData(
dataname=path,
name=file,
fromdate=fromdate,
todate=todate
)
cerebro = bt.Cerebro(optreturn=False)
cerebro.adddata(data)
cerebro.optstrategy(
EmaCrossLongShort,
#fast=args.fast_period,
#slow=args.slow_period,
fast=range(12,14),
slow=range(47,49),
longonly=args.longonly
)
cerebro.broker.set_coc(True)
cerebro.broker.setcash(args.cash)
cerebro.addsizer(MaxRiskSizer)
comminfo = DegiroCommission()
cerebro.broker.addcommissioninfo(comminfo)
tframes = dict(
days=bt.TimeFrame.Days,
weeks=bt.TimeFrame.Weeks,
months=bt.TimeFrame.Months,
years=bt.TimeFrame.Years)
# Add the Analyzers
cerebro.addanalyzer(SQN)
if args.legacyannual:
cerebro.addanalyzer(AnnualReturn, _name='time_return')
cerebro.addanalyzer(SharpeRatio, legacyannual=True)
else:
cerebro.addanalyzer(TimeReturn, _name='time_return', timeframe=tframes[args.tframe])
cerebro.addanalyzer(SharpeRatio, timeframe=tframes[args.tframe])
cerebro.addanalyzer(TradeAnalyzer)
optimized_runs = cerebro.run()
results_list = []
for run in optimized_runs:
for strategy in run:
PnL = round(strategy.broker.get_value() - args.cash, 2)
my_dict = strategy.analyzers.time_return.get_analysis()
annual_returns = [v for _, v in my_dict.items()]
average_annual_return = sum(annual_returns) / len(annual_returns)
results_list.append([
strategy.params.fast,
strategy.params.slow,
PnL,
round(average_annual_return*100, 2)
])
final_results_list.append(results_list)
# Average results for the different data feeds
arr = np.array(final_results_list)
final_results_list = [[int(val) if val.is_integer() else round(val, 2) for val in i] for i in arr.mean(0)]
if args.plot:
my_heatmap(final_results_list)
def parse_args():
parser = argparse.ArgumentParser(description='TimeReturn')
parser.add_argument('--data', '-d',
default='data/indexes/',
help='data to add to the system')
parser.add_argument('--fromdate', '-f',
default='2005-01-01',
help='Starting date in YYYY-MM-DD format')
parser.add_argument('--todate', '-t',
default='2006-12-31',
help='Starting date in YYYY-MM-DD format')
parser.add_argument('--fast_period', default=13, type=int,
help='Period to apply to the Exponential Moving Average')
parser.add_argument('--slow_period', default=48, type=int,
help='Period to apply to the Exponential Moving Average')
parser.add_argument('--longonly', '-lo', action='store_true',
help='Do only long operations')
group = parser.add_mutually_exclusive_group()
group.add_argument('--tframe', default='years', required=False,
choices=['days', 'weeks', 'months', 'years'],
help='TimeFrame for the returns/Sharpe calculations')
group.add_argument('--legacyannual', action='store_true',
help='Use legacy annual return analyzer')
parser.add_argument('--cash', default=1500, type=int,
help='Starting Cash')
parser.add_argument('--plot', '-p', action='store_true',
help='Plot the read data')
parser.add_argument('--numfigs', '-n', default=1,
help='Plot using numfigs figures')
parser.add_argument('--optimize', '-opt', default=1,
help='Plot using numfigs figures')
return parser.parse_args()
if __name__ == '__main__':
runstrategy()
strategies.py
import backtrader as bt
import backtrader.indicators as btind
class TestStrategy(bt.Strategy):
'''
Buy when there are two consecutive red bars and sell five bars later
'''
def log(self, txt, dt=None):
''' Logging function for this strategy'''
dt = dt or self.datas[0].datetime.date(0)
print('%s, %s' % (dt.isoformat(), txt))
def __init__(self):
# Keep a reference to the "close" line in the data[0] dataseries
self.dataclose = self.datas[0].close
# Keep track of pending orders
self.order = None
self.buyprice = None
self.buycomm = None
def notify_order(self, order):
if order.status in [order.Submitted, order.Accepted]:
# Buy/Sell order submitted/accepted to/by broker - Nothing to do
return
# Check if an order has been completed
# Attention: broker could reject order if not enough cash
if order.status in [order.Completed]:
if order.isbuy():
self.log('BUY EXECUTED, Price: %.2f, Cost: %.2f, Commission: %.2f' %
(order.executed.price,
order.executed.value,
order.executed.comm))
self.buyprice = order.executed.price
self.buycomm = order.executed.comm
elif order.issell():
self.log('SELL EXECUTED, Price: %.2f, Cost: %.2f, Commission: %.2f' %
(order.executed.price,
order.executed.value,
order.executed.comm))
self.bar_executed = len(self)
elif order.status in [order.Canceled, order.Margin, order.Rejected]:
self.log('Order Canceled/Margin/Rejected')
self.order = None
def notify_trade(self, trade):
if not trade.isclosed:
return
self.log('OPERATION PROFIT, GROSS %.2f, NET %.2f' %
(trade.pnl, trade.pnlcomm))
def next(self):
if self.order:
return
if not self.position:
# Not yet in the market... we MIGHT BUY if...
if self.dataclose[0] < self.dataclose[-1]:
if self.dataclose[-1] < self.dataclose[-2]:
self.log('BUY CREATE, %.2f' % self.dataclose[0])
self.order = self.buy()
else:
# Already in the market... we might sell
if len(self) >= (self.bar_executed + 5):
self.log('SELL CREATE, %.2f' % self.dataclose[0])
# Keep track of the created order to avoid a 2nd order
self.order = self.sell()
class SMAcrossover(bt.Strategy):
params = (('fast', 20), ('slow', 50),)
def log(self, txt, dt=None):
dt = dt or self.datas[0].datetime.date(0)
#print(f'{dt.isoformat()} {txt}') # Comment this line when running optimization
def __init__(self):
self.dataclose = self.datas[0].close
self.order = None
fast_sma, slow_sma = bt.ind.SMA(period=self.p.fast), bt.ind.SMA(period=self.p.slow)
self.crossover = bt.indicators.CrossOver(fast_sma, slow_sma)
#self.signal_add(bt.SIGNAL_LONGSHORT, bt.ind.CrossOver(sma1, sma2))
def notify_trade(self, trade):
if not trade.isclosed:
return
self.log(f'GROSS {trade.pnl:.2f}, NET {trade.pnlcomm:.2f}')
def notify_order(self, order):
if order.status in [order.Submitted, order.Accepted]:
# An active Buy/Sell order has been submitted/accepted - Nothing to do
return
# Check if an order has been completed
# Attention: broker could reject order if not enough cash
if order.status in [order.Completed]:
if order.isbuy():
self.log(f'BUY EXECUTED, {order.executed.price:.2f}')
elif order.issell():
self.log(f'SELL EXECUTED, {order.executed.price:.2f}')
self.bar_executed = len(self)
elif order.status in [order.Canceled, order.Margin, order.Rejected]:
self.log('Order Canceled/Margin/Rejected')
# Reset orders
self.order = None
def next(self):
# Check for open orders
if self.order:
return
if self.crossover > 0:
self.log(f'BUY CREATE {self.dataclose[0]:.2f}')
self.order = self.buy()
elif self.crossover < 0:
self.log(f'SELL CREATE {self.dataclose[0]:.2f}')
self.order = self.sell()
class EmaCrossLongShort(bt.Strategy):
'''This strategy buys/sells upong the close price crossing
upwards/downwards an Exponential Moving Average.
It can be a long-only strategy by setting the param "longonly" to True
'''
params = dict(
fast=13,
slow=48,
printout=True,
longonly=False,
)
def log(self, txt, dt=None):
if self.p.printout:
dt = dt or self.data.datetime[0]
dt = bt.num2date(dt)
print(f'{dt.isoformat()}, {txt}')
def __init__(self):
self.orderid = None # to control operation entries
fast_ema, slow_ema = btind.MovAv.EMA(period=self.p.fast), btind.MovAv.EMA(period=self.p.slow)
self.signal = btind.CrossOver(fast_ema, slow_ema)
self.log(f'Initial portfolio value of {self.broker.get_value():.2f}\n')
def start(self):
pass
def next(self):
if self.orderid:
return # if an order is active, no new orders are allowed
if self.signal > 0.0: # cross upwards
if self.position:
self.log(f'CLOSE SHORT position of {abs(self.position.size)} shares '
f'at {self.data.close[0]:.2f}')
self.close()
self.log(f'BUY {self.getsizing()} shares at {self.data.close[0]}')
self.buy()
elif self.signal < 0.0:
if self.position:
self.log(f'CLOSE LONG position of {self.position.size} shares '
f'at {self.data.close[0]:.2f}')
self.close()
if not self.p.longonly:
self.log(f'SELL {abs(self.getsizing())} shares at '
f'{self.data.close[0]}')
self.sell()
def notify_order(self, order):
if order.status in [bt.Order.Submitted, bt.Order.Accepted]:
return # Await further notifications
if order.status == order.Completed:
if order.isbuy():
buytxt = f'BUY COMPLETED. ' \
f'Size: {order.executed.size}, ' \
f'Price: {order.executed.price:.2f}, ' \
f'Commission: {order.executed.comm:.2f}'
self.log(buytxt, order.executed.dt)
else:
selltxt = 'SELL COMPLETED. ' \
f'Size: {abs(order.executed.size)}, ' \
f'Price: {order.executed.price:.2f}, ' \
f'Commission: {order.executed.comm:.2f}'
self.log(selltxt, order.executed.dt)
elif order.status in [order.Expired, order.Canceled, order.Margin]:
self.log(f'{order.Status[order.status]}')
pass # Simply log
# Allow new orders
self.orderid = None
def notify_trade(self, trade):
if trade.isclosed:
self.log(f'TRADE COMPLETED, '
f'Portfolio: {self.broker.get_value():.2f}, '
f'Gross: {trade.pnl:.2f}, '
f'Net: {trade.pnlcomm:.2f}')
elif trade.justopened:
#self.log('TRADE OPENED, SIZE %2d' % trade.size)
pass
sizers.py
import backtrader as bt
class MaxRiskSizer(bt.Sizer):
params = (('risk', 0.95),)
def __init__(self):
if self.p.risk > 1 or self.p.risk < 0:
raise ValueError('The risk parameter is a percentage which must be'
'entered as a float. e.g. 0.5')
def _getsizing(self, comminfo, cash, data, isbuy):
#return comminfo.getsize(data.close[0], self.broker.get_value())
return round(self.broker.get_value() * self.p.risk / data.close[0])
class MaxRiskSizer2(bt.Sizer):
params = (('risk', 0.98),)
def __init__(self):
if self.p.risk > 1 or self.p.risk < 0:
raise ValueError('The risk parameter is a percentage which must be'
'entered as a float. e.g. 0.5')
def _getsizing(self, comminfo, cash, data, isbuy):
position = self.broker.getposition(data)
if not position:
size = comminfo.getsize(data.close[0], cash * self.p.risk)
else:
size = position.size
return size
class FixedRerverser(bt.Sizer):
'''This would remove the burden from the Strategy to decide if a position
has to be reversed or opened, the Sizer is in control and can at any time
be replaced without affecting the logic.
'''
def _getsizing(self, comminfo, cash, data, isbuy):
position = self.broker.getposition(data)
size = self.p.stake * (1 + (position.size != 0))
return size
class LongOnly(bt.Sizer):
params = (('stake', 1),)
def _getsizing(self, comminfo, cash, data, isbuy):
if isbuy:
return self.p.stake
# Sell situation
position = self.broker.getposition(data)
if not position.size:
return 0 # do not sell if nothing is open
return self.p.stake
commissions.py
import backtrader as bt
class DegiroCommission(bt.CommInfoBase):
params = (('per_share', 0.004), ('flat', 0.5),)
def _getcommission(self, size, price, pseudoexec):
return self.p.flat + abs(size) * self.p.per_share
heatmap.py
import datetime
import os.path
import sys
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np
from matplotlib.colors import LinearSegmentedColormap
from matplotlib.patches import Rectangle
def my_heatmap(data):
data = np.array(data)
xs = np.unique(data[:, 1].astype(int))
ys = np.unique(data[:, 0].astype(int))
vals = data[:, 3].reshape(len(ys), len(xs))
min_val_ndx = np.unravel_index(np.argmin(vals, axis=None), vals.shape)
max_val_ndx = np.unravel_index(np.argmax(vals, axis=None), vals.shape)
cmap = LinearSegmentedColormap.from_list('', ['red', 'orange', 'yellow', 'chartreuse', 'limegreen'])
ax = sns.heatmap(vals, xticklabels=xs, yticklabels=ys, cmap=cmap, annot=True, fmt='.2f')
ax.add_patch(Rectangle(min_val_ndx[::-1], 1, 1, fill=False, edgecolor='blue', lw=3, clip_on=False))
ax.add_patch(Rectangle(max_val_ndx[::-1], 1, 1, fill=False, edgecolor='blue', lw=3, clip_on=False))
plt.tight_layout()
plt.show()
That's right thanks. I've also seen the commission for long and short positions where different. I had to change commissions.py:
return self.p.flat + abs(size) * self.p.per_share
I'm testing a strategy that buys a correct number of shares, and closes the position fine with the same number of shares but when it sells short it does it with very few shares as if there was not enough money left. I understand it's because as the two operations are done at the same point the broker hasn't yet updated the amount of cash from closing the previous operation. How can I fix this?
2020-10-14T23:59:59.999989, Initial portfolio value of 1700.00
1991-04-12T23:59:59.999989, BUY 56 shares at 28.87
1991-04-12T23:59:59.999989, BUY COMPLETED. Size: 56, Price: 28.87, Commission: 0.72
1991-06-19T23:59:59.999989, CLOSE Long Position of 56 shares at 25.54
1991-06-19T23:59:59.999989, SELL 3 shares at 25.54
1991-06-19T23:59:59.999989, SELL COMPLETED. Size: 56, Price: 25.54, Commission: 0.28
1991-06-19T23:59:59.999989, SELL COMPLETED. Size: 3, Price: 25.54, Commission: 0.49
1991-06-20T23:59:59.999989, TRADE COMPLETED, Portfolio: 1512.03, Gross: -186.48, Net: -187.48
from __future__ import (absolute_import, division, print_function,
unicode_literals)
import sys
import os.path
import datetime
import argparse
import backtrader as bt
from strategies.strategies import *
from sizers import MaxRiskSizer
from commissions import DegiroCommission
def runstrategy():
cerebro = bt.Cerebro()
comminfo = DegiroCommission()
cerebro.addstrategy(EmaCrossLongShort, fast=13, slow=49)
cerebro.broker.set_cash(1700)
cerebro.broker.set_coc(True)
cerebro.addsizer(MaxRiskSizer)
cerebro.broker.addcommissioninfo(comminfo)
modpath = os.path.dirname(os.path.abspath(sys.argv[0]))
datapath = os.path.join(modpath, 'data/CPE.csv')
data = bt.feeds.YahooFinanceCSVData(
dataname=datapath,
# Do not pass values before this date
#fromdate=datetime.datetime(1990, 10, 1),
# Do not pass values after this date
#todate=datetime.datetime(2020, 10, 15),
reverse=False
)
cerebro.adddata(data)
start_portfolio_value = cerebro.broker.getvalue()
cerebro.run()
end_portfolio_value = cerebro.broker.getvalue()
pnl = end_portfolio_value - start_portfolio_value
print(f'Starting Portfolio Value: {start_portfolio_value:.2f}')
print(f'Final Portfolio Value: {end_portfolio_value:.2f}')
print(f'PnL: {pnl:.2f}')
cerebro.plot()
if __name__ == '__main__':
runstrategy()
import backtrader as bt
import backtrader.indicators as btind
class EmaCrossLongShort(bt.Strategy):
'''This strategy buys/sells upong the close price crossing
upwards/downwards an Exponential Moving Average.
It can be a long-only strategy by setting the param "longonly" to True
'''
params = dict(
fast=13,
slow=48,
printout=True,
longonly=False,
)
def log(self, txt, dt=None):
if self.p.printout:
dt = dt or self.data.datetime[0]
dt = bt.num2date(dt)
print(f'{dt.isoformat()}, {txt}')
def __init__(self):
self.orderid = None # to control operation entries
fast_ema, slow_ema = btind.MovAv.EMA(period=self.p.fast), btind.MovAv.EMA(period=self.p.slow)
self.signal = btind.CrossOver(fast_ema, slow_ema)
self.log(f'Initial portfolio value of {self.broker.get_value():.2f}')
def start(self):
pass
def next(self):
if self.orderid:
return # if an order is active, no new orders are allowed
if self.signal > 0.0: # cross upwards
if self.position:
self.log(f'COVER Short Position of {abs(self.position.size)} shares '
f'at {self.data.close[0]:.2f}')
self.close()
self.log(f'BUY {self.getsizing()} shares at {self.data.close[0]}')
self.buy()
elif self.signal < 0.0:
if self.position:
self.log(f'CLOSE Long Position of {self.position.size} shares '
f'at {self.data.close[0]:.2f}')
self.close()
if not self.p.longonly:
self.log(f'SELL {abs(self.getsizing())} shares at '
f'{self.data.close[0]}')
self.sell()
def notify_order(self, order):
if order.status in [bt.Order.Submitted, bt.Order.Accepted]:
return # Await further notifications
if order.status == order.Completed:
if order.isbuy():
buytxt = f'BUY COMPLETED. ' \
f'Size: {order.executed.size}, ' \
f'Price: {order.executed.price:.2f}, ' \
f'Commission: {order.executed.comm:.2f}'
self.log(buytxt, order.executed.dt)
else:
selltxt = 'SELL COMPLETED. ' \
f'Size: {abs(order.executed.size)}, ' \
f'Price: {order.executed.price:.2f}, ' \
f'Commission: {order.executed.comm:.2f}'
self.log(selltxt, order.executed.dt)
elif order.status in [order.Expired, order.Canceled, order.Margin]:
self.log(f'{order.Status[order.status]}')
pass # Simply log
# Allow new orders
self.orderid = None
def notify_trade(self, trade):
if trade.isclosed:
self.log(f'TRADE COMPLETED, '
f'Portfolio: {self.broker.get_value():.2f}, '
f'Gross: {trade.pnl:.2f}, '
f'Net: {trade.pnlcomm:.2f}')
elif trade.justopened:
#self.log('TRADE OPENED, SIZE %2d' % trade.size)
pass
import backtrader as bt
class MaxRiskSizer(bt.Sizer):
params = (('risk', 0.95),)
def __init__(self):
if self.p.risk > 1 or self.p.risk < 0:
raise ValueError('The risk parameter is a percentage which must be'
'entered as a float. e.g. 0.5')
def _getsizing(self, comminfo, cash, data, isbuy):
#return comminfo.getsize(data.close[0], cash * self.p.risk)
return round(cash * self.p.risk / data.close[0])
import backtrader as bt
class DegiroCommission(bt.CommInfoBase):
params = (('per_share', 0.004), ('flat', 0.5),)
def _getcommission(self, size, price, pseudoexec):
return self.p.flat + size * self.p.per_share
Looking at the code I've linked above. Now I see it's actually making movements in the two data feeds at the same time while what I want is to do it one at a time and then average the results.
class multTestStrategy(bt.Strategy):
def next(self):
for i, d in enumerate(self.datas):
pos = self.broker.getposition(d).size
if not pos:
if self.data_dict[d]['rsi'] < 30:
self.buy(d,size=10)
else:
if self.data_dict[d]['rsi'] > 70:
self.sell(d,size=10)
I finally found an example on how to do an optimization with multiple data feeds. Hopefully now I'll be able to make it work.
I want to know whyyy do I have to modify the strategy to work for multiple data feeds. And why this isn't mentioned in the documentation. It seems as if the real purpose of backtrader was to run the strategies on a single data feed which would be useless because it would produce curve fitting. If it were meant to work on multiple data feeds it wouldn't be necessary to modify the strategies to work on multiple data feeds.
I forgot to copy the code:
main.py
from __future__ import (absolute_import, division, print_function,
unicode_literals)
import datetime
import os.path
import sys
import backtrader as bt
from strategies.strategies import *
from sizers import MaxRiskSizer
from commissions import DegiroCommission
from heatmap import my_heatmap
STARTING_CASH = 1700
if __name__ == '__main__':
cerebro = bt.Cerebro(optreturn=False)
cerebro.addanalyzer(bt.analyzers.AnnualReturn, _name='annual_return')
#cerebro.optstrategy(EMAcrossover, fast=range(5, 7), slow=range(10,12))
#cerebro.optstrategy(EMAcrossover, fast=range(5, 55, 5), slow=range(60, 300, 10))
cerebro.optstrategy(EMAcrossover, fast=range(8, 26), slow=range(38, 51))
cerebro.broker.set_cash(STARTING_CASH)
cerebro.broker.set_coc(True)
modpath = os.path.dirname(os.path.abspath(sys.argv[0]))
datapath = os.path.join(modpath, 'data/SPY.csv')
data = bt.feeds.YahooFinanceCSVData(
dataname=datapath,
reverse=False
)
cerebro.adddata(data)
cerebro.addsizer(MaxRiskSizer)
comminfo = DegiroCommission()
cerebro.broker.addcommissioninfo(comminfo)
optimized_runs = cerebro.run()
final_results_list = []
for run in optimized_runs:
for strategy in run:
PnL = round(strategy.broker.get_value() - STARTING_CASH, 2)
my_dict = strategy.analyzers.annual_return.get_analysis()
annual_returns = [v for _, v in my_dict.items() if v != 0]
average_annual_return = sum(annual_returns) / len(annual_returns)
final_results_list.append([strategy.params.fast,
strategy.params.slow, PnL, round(average_annual_return*100, 2)])
my_heatmap(final_results_list)
import backtrader as bt
class DegiroCommission(bt.CommInfoBase):
params = (('per_share', 0.004), ('flat', 0.5),)
def _getcommission(self, size, price, pseudoexec):
return self.p.flat + size * self.p.per_share
import backtrader as bt
class MaxRiskSizer(bt.Sizer):
params = (('risk', 0.98),)
def __init__(self):
if self.p.risk > 1 or self.p.risk < 0:
raise ValueError('The risk parameter is a percentage which must be'
'entered as a float. e.g. 0.5')
def _getsizing(self, comminfo, cash, data, isbuy):
position = self.broker.getposition(data)
if not position:
size = comminfo.getsize(data.close[0], cash * self.p.risk)
else:
size = position.size
return size
import backtrader as bt
class EMAcrossover(bt.Strategy):
params = (('fast', 20), ('slow', 50),)
def log(self, txt, dt=None):
dt = dt or self.datas[0].datetime.date(0)
print(f'{dt.isoformat()} {txt}') # Comment this line when running optimization
def __init__(self):
self.dataclose = self.datas[0].close
fast_ema, slow_ema = bt.ind.EMA(period=self.p.fast), bt.ind.EMA(period=self.p.slow)
self.crossover = bt.indicators.CrossOver(fast_ema, slow_ema)
#self.signal_add(bt.SIGNAL_LONGSHORT, bt.ind.CrossOver(ema1, ema2))
self.order = None
self.buyprice = None
self.buycomm = None
def notify_trade(self, trade):
if not trade.isclosed:
return
self.log(f'OPERATION GROSS {trade.pnl:.2f}, NET {trade.pnlcomm:.2f}')
def notify_order(self, order):
if order.status in [order.Submitted, order.Accepted]:
# An active Buy/Sell order has been submitted/accepted - Nothing to do
return
# Check if an order has been completed
# Attention: broker could reject order if not enough cash
if order.status in [order.Completed]:
if order.isbuy():
self.log(f'BUY EXECUTED, '
f'Price: {order.executed.price:.2f}, '
f'Cost: {order.executed.value:.2f}, '
f'Commission: {order.executed.comm:.2f}')
self.buyprice = order.executed.price
self.buycomm = order.executed.comm
elif order.issell():
self.log(f'SELL EXECUTED, '
f'Price: {order.executed.price:.2f}, '
f'Cost: {order.executed.value:.2f}, '
f'Commission: {order.executed.comm:.2f}')
self.bar_executed = len(self)
elif order.status in [order.Canceled, order.Margin, order.Rejected]:
self.log('Order Canceled/Margin/Rejected')
self.order = None
def next(self):
if self.order:
return
if self.crossover > 0:
self.log(f'BUY CREATE {self.dataclose[0]:.2f}')
self.order = self.buy()
elif self.crossover < 0:
self.log(f'SELL CREATE {self.dataclose[0]:.2f}')
import datetime
import os.path
import sys
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np
from matplotlib.colors import LinearSegmentedColormap
from matplotlib.patches import Rectangle
def my_heatmap(data):
data = np.array(data)
xs = np.unique(data[:, 1].astype(int))
ys = np.unique(data[:, 0].astype(int))
vals = data[:, 3].reshape(len(ys), len(xs))
min_val_ndx = np.unravel_index(np.argmin(vals, axis=None), vals.shape)
max_val_ndx = np.unravel_index(np.argmax(vals, axis=None), vals.shape)
cmap = LinearSegmentedColormap.from_list('', ['red', 'orange', 'yellow', 'chartreuse', 'limegreen'])
ax = sns.heatmap(vals, xticklabels=xs, yticklabels=ys, cmap=cmap, annot=True, fmt='.2f')
ax.add_patch(Rectangle(min_val_ndx[::-1], 1, 1, fill=False, edgecolor='blue', lw=3, clip_on=False))
ax.add_patch(Rectangle(max_val_ndx[::-1], 1, 1, fill=False, edgecolor='blue', lw=3, clip_on=False))
plt.tight_layout()
plt.show()
When executing an optimization I'm getting many 'Canceled/Margin/Rejected' orders. There must be something wrong with my strategy but I can't figure out what it is.
Also the output that I'm expecting is around 10% and it should look like this:
But right now I'm getting a maximum of 7.7% and the output looks too uniform which makes me think something is wrong:
The strategy was missing.
class EMAcrossover(bt.Strategy):
params = (('fast', 20), ('slow', 50),)
def log(self, txt, dt=None):
dt = dt or self.datas[0].datetime.date(0)
#print(f'{dt.isoformat()} {txt}') # Comment this line when running optimization
def __init__(self):
self.dataclose = self.datas[0].close
self.order = None
fast_ema, slow_ema = bt.ind.EMA(period=self.p.fast), bt.ind.EMA(period=self.p.slow)
self.crossover = bt.indicators.CrossOver(fast_ema, slow_ema)
#self.signal_add(bt.SIGNAL_LONGSHORT, bt.ind.CrossOver(ema1, ema2))
def notify_trade(self, trade):
if not trade.isclosed:
return
self.log(f'GROSS {trade.pnl:.2f}, NET {trade.pnlcomm:.2f}')
def notify_order(self, order):
if order.status in [order.Submitted, order.Accepted]:
# An active Buy/Sell order has been submitted/accepted - Nothing to do
return
# Check if an order has been completed
# Attention: broker could reject order if not enough cash
if order.status in [order.Completed]:
if order.isbuy():
self.log(f'BUY EXECUTED, {order.executed.price:.2f}')
elif order.issell():
self.log(f'SELL EXECUTED, {order.executed.price:.2f}')
self.bar_executed = len(self)
elif order.status in [order.Canceled, order.Margin, order.Rejected]:
self.log('Order Canceled/Margin/Rejected')
self.order = None
def next(self):
if self.order:
return
if self.crossover > 0:
self.log(f'BUY CREATE {self.dataclose[0]:.2f}')
self.order = self.buy()
elif self.crossover < 0:
self.log(f'SELL CREATE {self.dataclose[0]:.2f}')
self.order = self.sell()