Esempio n. 1
0
def test_backtest_2strats(cerebro: bt.Cerebro):
    cerebro.addstrategy(bt.strategies.MA_CrossOver)
    cerebro.addstrategy(ToggleStrategy)
    cerebro.run()

    b = Bokeh(style='bar', output_mode=_output_mode)

    figs = cerebro.plot(b)

    assert len(figs) == 2
    assert_num_tabs(figs, 3, 3)
    assert_num_figures(figs, 4, 3)
def test_std_backtest_volume_subplot(cerebro: bt.Cerebro):
    cerebro.addstrategy(bt.strategies.MA_CrossOver)
    cerebro.run()

    s = backtrader_plotting.schemes.Blackly()
    s.voloverlay = False
    b = Bokeh(style='bar', scheme=s, output_mode=_output_mode)
    figs = cerebro.plot(b)

    assert len(figs) == 1
    assert_num_tabs(figs, 3)
    assert_num_figures(figs, 5)
Esempio n. 3
0
def test_optimize_2strat(cerebro: bt.Cerebro):
    cerebro.optstrategy(bt.strategies.MA_CrossOver,
                        slow=[5, 10, 20],
                        fast=[5, 10, 20])
    cerebro.optstrategy(ToggleStrategy, modbuy=[12, 15], modsell=[17, 19])
    res = cerebro.run()

    b = Bokeh(style='bar', output_mode=_output_mode)

    browser = OptBrowser(b, res)

    with pytest.raises(RuntimeError):
        browser.build_optresult_model()
Esempio n. 4
0
def test_std_backtest_ind_on_line(cerebro: bt.Cerebro):
    '''In the past it crashed when creating indicators with specific lines case LineSeriesStub was not handled correctly'''
    class TestStrategy(bt.Strategy):
        def __init__(self):
            self._sma = bt.indicators.SMA(self.data.close)

    cerebro.addstrategy(TestStrategy)
    cerebro.run()

    s = backtrader_plotting.schemes.Blackly()
    b = Bokeh(style='bar', scheme=s, output_mode=_output_mode)
    figs = cerebro.plot(b)

    assert len(figs) == 1
    assert_num_tabs(figs, 3)
    assert_num_figures(figs, 3)
Esempio n. 5
0
def test_github_issue36():
    cerebro = bt.Cerebro()

    cerebro.addstrategy(MyStrategy)

    filedir = os.path.dirname(os.path.abspath(__file__))

    df = pd.read_csv(os.path.join(filedir, "datas/NQ.csv"), index_col=0)
    df.index = pd.DatetimeIndex(df.index)
    data = bt.feeds.PandasData(dataname=df, name='NQ', timeframe=bt.TimeFrame.Minutes)
    cerebro.adddata(data)
    cerebro.resampledata(data, name='NQ_5min', timeframe=bt.TimeFrame.Minutes, compression=5)
    cerebro.addanalyzer(bt.analyzers.SharpeRatio)
    cerebro.run()

    b = Bokeh(filename='chart.html', style='bar', plot_mode="single", scheme=Tradimo(), output_mode='memory')
    cerebro.plot(b)
Esempio n. 6
0
def test_std_backtest_ind_subplot(cerebro: bt.Cerebro):
    cerebro.addstrategy(bt.strategies.MA_CrossOver)
    cerebro.run()

    plotconfig = {
        '#:i-0': {
            'subplot': True,
        }
    }

    s = backtrader_plotting.schemes.Blackly()
    b = Bokeh(style='bar',
              scheme=s,
              output_mode=_output_mode,
              plotconfig=plotconfig)

    figs = cerebro.plot(b)

    assert_num_tabs(figs, 3)
    assert_num_figures(figs, 5)
Esempio n. 7
0
def trade_run():
    cerebro = bt.Cerebro()
    data = DBDataFeed(
        # 本地postgresql数据库
        db_uri=ConfigUtils.get_mysql('engine'),
        dataname="sh.600004",
        fromdate=datetime.date(2010, 1, 1),
    )
    cerebro.adddata(data)

    cerebro.addstrategy(SMACross)
    cerebro.addsizer(bt.sizers.AllInSizerInt)
    cerebro.broker.set_cash(100000)

    cerebro.addanalyzer(bt.analyzers.AnnualReturn, _name="annual_returns")
    cerebro.addanalyzer(bt.analyzers.DrawDown, _name="draw_down")
    cerebro.addanalyzer(bt.analyzers.Transactions, _name="transactions")

    results = cerebro.run()

    # 打印Analyzer结果到日志
    for result in results:

        annual_returns = result.analyzers.annual_returns.get_analysis()
        log.info("annual returns:")
        for year, ret in annual_returns.items():
            log.info("\t {} {}%, ".format(year, round(ret * 100, 2)))

        draw_down = result.analyzers.draw_down.get_analysis()
        log.info(
            "drawdown={drawdown}%, moneydown={moneydown}, drawdown len={len}, "
            "max.drawdown={max.drawdown}, max.moneydown={max.moneydown}, "
            "max.len={max.len}".format(**draw_down))

        transactions = result.analyzers.transactions.get_analysis()
        log.info("transactions")

    # 运行结果绘图
    # cerebro.plot()
    b = Bokeh(style="bar", tabs="multi", scheme=Tradimo())
    cerebro.plot(b)
Esempio n. 8
0
def test_std_backtest_2datas(cerebro: bt.Cerebro):
    datapath = getdatadir('nvda-1999-2014.txt')
    data = bt.feeds.YahooFinanceCSVData(
        dataname=datapath,
        fromdate=datetime.datetime(1998, 1, 1),
        todate=datetime.datetime(2000, 12, 31),
        reverse=False,
        swapcloses=True,
    )
    cerebro.adddata(data)

    cerebro.addstrategy(bt.strategies.MA_CrossOver)
    cerebro.run()

    s = backtrader_plotting.schemes.Blackly()
    b = Bokeh(style='bar',
              scheme=s,
              output_mode=_output_mode,
              merge_data_hovers=True)
    figs = cerebro.plot(b)

    assert len(figs) == 1
    assert_num_tabs(figs, 3)
    assert_num_figures(figs, 5)
Esempio n. 9
0
def test_optimize(cerebro: bt.Cerebro):
    cerebro.optstrategy(bt.strategies.MA_CrossOver,
                        slow=[5, 10, 20],
                        fast=[5, 10, 20])
    res = cerebro.run(optreturn=True)

    b = Bokeh(style='bar', output_mode=_output_mode)

    browser = OptBrowser(b, res)
    model = browser.build_optresult_model()

    # browser.start()

    def count_children(obj):
        numo = 1
        if hasattr(obj, "children"):
            numo = count_children(obj.children)
        if hasattr(obj, '__len__'):
            numo += len(obj)
        return numo

    num = count_children(model)

    assert num == 3
Esempio n. 10
0
print('最大回撤DW:', results[0].analyzers.DrawDown.get_analysis())

# 选取一只股票进行回测
cerebro2 = bt.Cerebro()
baseline = '000300.SH'
feed = bt.feeds.PandasData(dataname=get_data(baseline))
cerebro2.adddata(feed, name=baseline)
cerebro2.broker.get_notification()
# 回测设置
cerebro2.broker.setcash(startcash)
#  设置佣金为千分之一
cerebro2.broker.setcommission(commission=0.001)
#  添加策略
cerebro2.addstrategy(BaseStrategy, printlog=True)
results2 = cerebro2.run()
# 获取回测结束后的总资金
portvalue2 = cerebro2.broker.getvalue()
pnl2 = portvalue2 - startcash

# 打印结果
print(f'沪深300 总资金: {round(portvalue2, 2)}')
print(f'沪深300 净收益: {round(pnl2, 2)}')
print('沪深300Final Portfolio Value: %.2f' % cerebro2.broker.getvalue())

# 绘制图像
b = Bokeh(style='bar', plot_mode='multi', scheme=Tradimo())

# cerebro.plot(b)
# cerebro.plot()
plot_result(results, results2, s)
import backtrader
from strategies.strategies import TestStrategy
import pandas as pd
from backtrader_plotting import Bokeh
from backtrader_plotting.schemes import Tradimo
#pip3 install backtrader_plotting
#import matplotlib.pyplot as plt

plotconfig = {
    'id:ind#0': dict(subplot=True, ),
}
b = Bokeh(style='bar',
          plot_mode='single',
          scheme=Tradimo(),
          plotconfig=plotconfig)


def create_stock_sp500_ratio_csv(stockName):
    datapath = (rf'Data\{stockName}.csv')
    dataframeStock = pd.read_csv(datapath)
    datapath = (rf'Data\SPY.csv')
    dataframeSPY = pd.read_csv(datapath)
    #crate copy
    df = dataframeSPY.copy()
    for i in range(df.shape[0]):  # gives number of row count
        # df['Date'].iloc[i]-=dataframeStock['Date'].iloc[i]
        df['Open'].iloc[i] -= dataframeStock['Open'].iloc[i]
        df['High'].iloc[i] -= -dataframeStock['High'].iloc[i]
        df['Low'].iloc[i] -= dataframeStock['Low'].iloc[i]
        df['Close'].iloc[i] -= dataframeStock['Close'].iloc[i]
        df['Volume'].iloc[i] -= dataframeStock['Volume'].iloc[i]
def bt_run(strat_p_list,df):
    
    # Create a cerebro entity
    try:
        
        cerebro = bt.Cerebro(tradehistory=True)
        cerebro.addanalyzer(bt.analyzers.cmtrans.cmTrans)
        # cerebro.addwriter(bt.WriterFile, out = 'test.csv', csv=True, rounding=5)
        
        data_table_id = strat_p_list[0]
        scrip_code = strat_p_list[1]
        strategy = strat_p_list[2]
        trade_size = strat_p_list[3]
        start_cash = strat_p_list[4]
        
        ex,m_t,t_f = su.parameters_from_data_table_id(data_table_id)
        
        # Get Class from strategy Name
        module = importlib.import_module('spe.strategies.'+strategy)
        class_name = strategy
        strategy = getattr(module, class_name)
        
        # Add a strategy
        cerebro.addstrategy(strategy,trade_size=trade_size)
        
        # Minimum datalength
        min_data = strategy.candle_lb()
        
        # Add the Data Feed to Cerebro
        # Returns Cerebro riteith datafeed attached
        cerebro_w_data = dh.data_feed(scrip_code,ex,m_t,t_f,cerebro,min_data)
        
        if cerebro_w_data is None:
            print('No Data Available')
            return []
        
        # Set our desired cash start
        cerebro_w_data.broker.setcash(start_cash)     
    
        # Set the commission - 0.1% ... divide by 100 to remove the %
        cerebro_w_data.broker.setcommission(commission=0.000)
        
        # cerebro_w_data.addanalyzer(bt.analyzers.TradeAnalyzer, _name="stats")
        # cerebro_w_data.addanalyzer(bt.analyzers.PositionsValue, _name="an_return")
        cerebro_w_data.addanalyzer(bt.analyzers.Returns)
        # cerebro_w_data.addanalyzer(bt.analyzers.PyFolio)
        
        # Print out the starting conditions
#        print('Starting Portfolio Value: %.2f' % cerebro_w_data.broker.getvalue())
    
        # Run over everything
        strategy = cerebro_w_data.run()
        b = Bokeh(style='bar', plot_mode='single', scheme=Tradimo())
        # cerebro_w_data.plot(b)
        Strat = strategy[0]
        # Print out the final result
#        print('Final Portfolio Value: %.2f' % cerebro_w_data.broker.getvalue())
    
        # Strat.analyzers.stats.print()
        # Strat.analyzers.an_return.print()
#        print(f"Norm. Annual Return: {Strat.analyzers.returns.get_analysis()['rnorm100']:.2f}%")
        # pyfolizer = Strat.analyzers.getbyname('pyfolio')
        # returns, positions, transactions, gross_lev = pyfolizer.get_pf_items()
        # pf.create_returns_tear_sheet(returns)
        
        df = backtest_out(Strat,df)
        
        return Strat,df

    except Exception as e:
        # err.error_log(str(e),bt_run.__name__,'bt_run')
        logging.exception(str(e))
Esempio n. 13
0
def perform_backtest(params, df, strategy, PandasData_Custom, bokeh=False):

    curr_result = {}
    curr_result = params

    data = PandasData_Custom(dataname=df)
    cerebro = bt.Cerebro()

    cerebro.adddata(data)
    cerebro.addstrategy(strategy, parameters=params)

    cerebro.addanalyzer(bt.analyzers.SharpeRatio,
                        riskfreerate=0.0,
                        annualize=True,
                        timeframe=bt.TimeFrame.Days)
    cerebro.addanalyzer(bt.analyzers.Calmar)
    cerebro.addanalyzer(bt.analyzers.DrawDown)
    cerebro.addanalyzer(bt.analyzers.Returns)
    cerebro.addanalyzer(bt.analyzers.TradeAnalyzer)

    initial_cash = 1000
    cerebro.broker = bt.brokers.BackBroker(
        cash=initial_cash,
        slip_perc=0.01 / 100,
        commission=CommInfoFractional(commission=(0.075 * params['mult']) /
                                      100,
                                      mult=params['mult']),
        slip_open=True,
        slip_out=True)  # 0.5%

    run = cerebro.run()

    all_logs = run[0].get_logs()
    portfolio = all_logs[0]
    trades = all_logs[1]
    operations = all_logs[2]

    trades_analysis = trades.merge(operations, on='Date', how='left')
    trades_analysis = trades_analysis.fillna(method='bfill')
    trades_analysis['Date'] = pd.to_datetime(trades_analysis['Date'])
    trades_analysis['Date'] = trades_analysis['Date'] - timedelta(minutes=10)

    analysis = run[0].analyzers.getbyname('tradeanalyzer').get_analysis()

    try:
        curr_result['Total Trades'] = analysis['total']['total']
    except:
        curr_result['Total Trades'] = 0

    try:
        curr_result['Total Profit'] = analysis['won']['total']
        curr_result['Avg Profit'] = analysis['won']['pnl']['average']
    except:
        curr_result['Total Profit'] = 0
        curr_result['Avg Profit'] = 0

    try:
        curr_result['Total Loss'] = analysis['lost']['total']
        curr_result['Average Loss'] = analysis['lost']['pnl']['average']
    except:
        curr_result['Total Loss'] = 0
        curr_result['Average Loss'] = 0

    try:
        curr_result['Total Long'] = analysis['long']['total']
        curr_result['Average Long'] = analysis['long']['pnl']['average']
    except:
        curr_result['Total Long'] = 0
        curr_result['Average Long'] = 0

    try:
        curr_result['Total Short'] = analysis['short']['total']
        curr_result['Average Short'] = analysis['short']['pnl']['average']
    except:
        curr_result['Total Short'] = 0
        curr_result['Average Short'] = 0

    curr_result['Return (%)'] = round(
        ((portfolio['Value'].iloc[-1] - portfolio['Value'].iloc[0]) /
         portfolio['Value'].iloc[0]) * 100, 2)
    curr_result['sharpe'] = run[0].analyzers.getbyname(
        'sharperatio').get_analysis()['sharperatio']

    portfolio['Date'] = pd.to_datetime(portfolio['Date'])
    portfolio = portfolio.set_index('Date')

    daily_portfolio = portfolio.resample('1D').agg(
        {'Value': lambda x: x.iloc[-1]})

    if bokeh == True:
        b = Bokeh(style='bar', plot_mode='single', scheme=Tradimo())
        fig = cerebro.plot(b)

        s_fig = fig[0][0]

        bokeh_html = file_html(s_fig.model, CDN, "Backtest Plot")

        if not os.path.isdir("bokeh/"):
            os.makedirs("bokeh/")

        fname = secrets.token_hex(3) + ".html"

        with open('bokeh/{}'.format(fname), 'w') as file:
            file.write(bokeh_html)

        return fname

    return curr_result

if __name__ == '__main__':
    cerebro = bt.Cerebro(maxcpus=1)

    data = bt.feeds.YahooFinanceCSVData(
        dataname="datas/orcl-1995-2014.txt",
        fromdate=datetime.datetime(2000, 1, 1),
        todate=datetime.datetime(2001, 2, 28),
    )
    cerebro.adddata(data)
    cerebro.addanalyzer(bt.analyzers.TradeAnalyzer)

    cerebro.optstrategy(MyStrategy, buydate=range(40, 180, 30))

    optres = cerebro.run(optreturn=False)

    def benchmark(optresults):
        a = [x.analyzers.tradeanalyzer.get_analysis() for x in optresults]
        return sum([x.pnl.gross.total if 'pnl' in x else 0 for x in a])

    result = [
        OrderedOptResult.BenchmarkedResult(benchmark(x), x) for x in optres
    ]
    ordered_result = sorted(result, key=lambda x: x.benchmark, reverse=True)

    ordered_result = OrderedOptResult("Profit & Losss", ordered_result)

    b = Bokeh(style='bar', plot_mode="single", scheme=Tradimo())
    b.plot_result(ordered_result)
        bt.indicators.RSI()

    def next(self):
        pos = len(self.data)
        if pos == 45 or pos == 145:
            self.buy(self.datas[0], size=None)

        if pos == 116 or pos == 215:
            self.sell(self.datas[0], size=None)


if __name__ == '__main__':
    cerebro = bt.Cerebro()

    cerebro.addstrategy(MyStrategy)

    data = bt.feeds.YahooFinanceCSVData(
        dataname="datas/orcl-1995-2014.txt",
        fromdate=datetime.datetime(2000, 1, 1),
        todate=datetime.datetime(2001, 2, 28),
        reverse=False,
        swapcloses=True,
    )
    cerebro.adddata(data)
    cerebro.addanalyzer(bt.analyzers.SharpeRatio)

    cerebro.run()

    b = Bokeh(style='bar')
    cerebro.plot(b)
        bt.indicators.RSI()

    def next(self):
        pos = len(self.data)
        if pos == 45 or pos == 145:
            self.buy(self.datas[0], size=None)

        if pos == 116 or pos == 215:
            self.sell(self.datas[0], size=None)


if __name__ == '__main__':
    cerebro = bt.Cerebro()

    cerebro.addstrategy(MyStrategy)

    data = bt.feeds.YahooFinanceCSVData(
        dataname="datas/orcl-1995-2014.txt",
        fromdate=datetime.datetime(2000, 1, 1),
        todate=datetime.datetime(2001, 2, 28),
        reverse=False,
        swapcloses=True,
    )
    cerebro.adddata(data)
    cerebro.addanalyzer(bt.analyzers.SharpeRatio)

    cerebro.run()

    b = Bokeh(style='bar', tabs='multi')
    cerebro.plot(b)
Esempio n. 17
0
    cerebro.addstrategy(TestStrategy)

    # Create a data feed
    data = bt.feeds.YahooFinanceData(dataname='MSFT',
                                     fromdate=datetime.datetime(2019, 1, 1),
                                     todate=datetime.datetime(2019, 12, 31))

    # Add the Data Feed to Cerebro
    cerebro.adddata(data)

    # Set our desired cash start
    cerebro.broker.setcash(1000.0)

    # Add a FixedSize sizer according to the stake
    cerebro.addsizer(bt.sizers.FixedSize, stake=10)

    # Set the commission
    cerebro.broker.setcommission(commission=0.0)

    # Print out the starting conditions
    #print('Starting Portfolio Value: %.2f' % cerebro.broker.getvalue())

    # Run over everything
    cerebro.run()

    # Print out the final result
    #print('Final Portfolio Value: %.2f' % cerebro.broker.getvalue())

    # Plot the result
    b = Bokeh(style='bar', tabs='multi', scheme=Tradimo())
    cerebro.plot(b)
Esempio n. 18
0
        sma1 = bt.indicators.SMA(period=11, subplot=True)
        bt.indicators.SMA(period=17, plotmaster=sma1)
        bt.indicators.RSI()

    def next(self):
        pos = len(self.data)
        if pos == 45 or pos == 145:
            self.buy(self.datas[0], size=None)

        if pos == 116 or pos == 215:
            self.sell(self.datas[0], size=None)


if __name__ == '__main__':
    cerebro = bt.Cerebro()

    cerebro.addstrategy(MyStrategy)

    data = bt.feeds.YahooFinanceCSVData(
        dataname="datas/orcl-1995-2014.txt",
        fromdate=datetime.datetime(2000, 1, 1),
        todate=datetime.datetime(2001, 2, 28),
    )
    cerebro.adddata(data)
    cerebro.addanalyzer(bt.analyzers.SharpeRatio)

    cerebro.run()

    b = Bokeh(style='bar', plot_mode="tabs")
    cerebro.plot(b)
Esempio n. 19
0
from datetime import datetime
import backtrader as bt


class SmaCross(bt.SignalStrategy):
    def __init__(self):
        sma1, sma2 = bt.ind.SMA(period=10), bt.ind.SMA(period=30)
        crossover = bt.ind.CrossOver(sma1, sma2)
        self.signal_add(bt.SIGNAL_LONG, crossover)


cerebro = bt.Cerebro()
cerebro.addstrategy(SmaCross)

data0 = bt.feeds.YahooFinanceData(dataname='MSFT',
                                  fromdate=datetime(2011, 1, 1),
                                  todate=datetime(2012, 12, 31))
cerebro.adddata(data0)

cerebro.run()
from backtrader_plotting import Bokeh, OptBrowser

bo = Bokeh()
cerebro.plot(bo)
        bt.indicators.SMA(period=17, plotmaster=sma1)
        bt.indicators.RSI()

    def next(self):
        pos = len(self.data)
        if pos == 45 or pos == 145:
            self.buy(self.datas[0], size=None)

        if pos == 116 or pos == 215:
            self.sell(self.datas[0], size=None)


if __name__ == '__main__':
    cerebro = bt.Cerebro()

    cerebro.addstrategy(MyStrategy)

    data = bt.feeds.YahooFinanceCSVData(
        dataname="datas/orcl-1995-2014.txt",
        fromdate=datetime.datetime(2000, 1, 1),
        todate=datetime.datetime(2001, 2, 28),
        reverse=False,
    )
    cerebro.adddata(data)
    cerebro.addanalyzer(bt.analyzers.SharpeRatio)

    cerebro.run()

    b = Bokeh(style='bar', plot_mode="single", scheme=Tradimo())
    cerebro.plot(b)
        sma1 = bt.indicators.SMA(period=11, subplot=True)
        bt.indicators.SMA(period=17, plotmaster=sma1)
        bt.indicators.RSI()

    def next(self):
        pos = len(self.data)
        if pos == 45 or pos == 145:
            self.buy(self.datas[0], size=None)

        if pos == 116 or pos == 215:
            self.sell(self.datas[0], size=None)


if __name__ == '__main__':
    cerebro = bt.Cerebro()

    cerebro.addstrategy(MyStrategy)

    data = bt.feeds.YahooFinanceCSVData(
        dataname="datas/orcl-1995-2014.txt",
        fromdate=datetime.datetime(2000, 1, 1),
        todate=datetime.datetime(2001, 2, 28),
    )
    cerebro.adddata(data)
    cerebro.addanalyzer(bt.analyzers.SharpeRatio)

    cerebro.run()

    b = Bokeh(style='bar', plot_mode="single")
    cerebro.plot(b)
Esempio n. 22
0
if __name__ == '__main__':
    cerebro = bt.Cerebro()
    data = bt.feeds.YahooFinanceCSVData(
        dataname=getdatadir("20170319-20200319-0388.HK.csv"),
        fromdata=datetime.datetime(
            2020,
            2,
            19,
            0,
            0,
            0,
        ),
        todata=datetime.datetime(2020, 3, 19, 0, 0, 0),
        reverse=False)

    cerebro.addobserver(bt.observers.Benchmark,
                        data=data,
                        timeframe=bt.TimeFrame.NoTimeFrame)
    cerebro.addstrategy(MyStrategy)
    cerebro.adddata(data)
    cerebro.addsizer(bt.sizers.AllInSizer)
    cerebro.broker.setcash(100000)

    print('Starting Portfolio Value: %.2f' % cerebro.broker.getvalue())
    import json
    strats = cerebro.run()[0]
    print('Final Portfolio Value: %.2f' % cerebro.broker.getvalue())

    bo = Bokeh(style='bar', plot_mode='single', output_mode='memory')
    cerebro.plot(bo)
Esempio n. 23
0
        bt.indicators.Ichimoku()

    def next(self):
        pos = len(self.data)
        if pos == 45 or pos == 145:
            self.buy(self.datas[0], size=None)

        if pos == 116 or pos == 215:
            self.sell(self.datas[0], size=None)


if __name__ == '__main__':
    cerebro = bt.Cerebro()

    cerebro.addstrategy(MyStrategy)

    data = bt.feeds.YahooFinanceCSVData(
        dataname="datas/orcl-1995-2014.txt",
        fromdate=datetime.datetime(2000, 1, 1),
        todate=datetime.datetime(2001, 2, 28),
        reverse=False,
        swapcloses=True,
    )
    cerebro.adddata(data)
    cerebro.addanalyzer(bt.analyzers.SharpeRatio)

    cerebro.run()

    b = Bokeh(style='bar', scheme=Tradimo())
    cerebro.plot(b)
Esempio n. 24
0
        if pos == self.p.buydate:
            self.buy(self.datas[0], size=None)

        if pos == self.p.buydate + self.p.holdtime:
            self.sell(self.datas[0], size=None)


if __name__ == '__main__':
    cerebro = bt.Cerebro(maxcpus=1)

    data = bt.feeds.YahooFinanceCSVData(
        dataname="datas/orcl-1995-2014.txt",
        fromdate=datetime.datetime(2000, 1, 1),
        todate=datetime.datetime(2001, 2, 28),
    )
    cerebro.adddata(data)
    cerebro.addanalyzer(bt.analyzers.TradeAnalyzer)

    cerebro.optstrategy(MyStrategy, buydate=range(40, 180, 30))

    result = cerebro.run(optreturn=False)

    def get_pnl_gross(strats):
        a = strats[0].analyzers.tradeanalyzer.get_analysis()
        return a.pnl.gross.total if 'pnl' in a else 0

    columns = dict(pnl=get_pnl_gross)

    b = Bokeh(style='bar', plot_mode="single", scheme=Tradimo())
    b.plot_result(result, columns)
Esempio n. 25
0
        todate=datetime.datetime(2021, 2, 20),
        #todate = datetime.datetime(2018, 1, 15),
        nullvalue=0.0,
        dtformat=('%Y-%m-%d'),
        datetime=0,
        open=1,
        high=2,
        low=3,
        close=4,
        volume=5,
        openinterest=-1,
        predict=16,
        ma5=6)
    cerebro.adddata(data, name='AAPL')
    # set principle
    cerebro.broker.setcash(50000.0)
    # set commission
    cerebro.broker.setcommission(commission=0.00025)
    # set size
    cerebro.addsizer(bt.sizers.FixedSize, stake=1000)
    # print out starting capital
    print('Starting Portfolio Value: %.2f' % cerebro.broker.getvalue())
    # start backtesting
    cerebro.run()

    #plot
    b = Bokeh(style='bar', plot_mode='single')
    cerebro.plot(b)

    # print out final capital
    print('Final Portfolio Value: %.2f' % cerebro.broker.getvalue())
Esempio n. 26
0
def perform_backtest(symbol_par,
                     n_fast_par,
                     n_slow_par,
                     long_macd_threshold_par,
                     long_per_threshold_par,
                     long_close_threshold_par,
                     short_macd_threshold_par,
                     short_per_threshold_par,
                     short_close_threshold_par,
                     initial_cash=10000,
                     comission=0.1,
                     df=None):
    '''
    Parameter:
    __________

    symbol_par (string):
    The symbol to use

    n_fast_par (int):
    Fast EMA line used during MACD calculation

    n_slow_par (int):
    Slower EMA line used during MACD calculation

    long_macd_threshold_par (int):
    The threshold of normalized macd, above which we might open a long position

    long_per_threshold_par (int):
    The value of percentage change over the last 2 hours above which we might open a long position
    #Might make this a parameter too

    long_close_threshold_par (int):
    Threshold of normalized macd, below which we will close the opened long position

    short_macd_threshold_par (int):
    The threshold of normalized macd, below which we might open a short position

    short_per_threshold_par (int):
    The value of percentage change over the last 2 hours below which we might open a short position

    short_close_threshold_par (int):
    Threshold of normalized macd, above which we will close the opened short position

    initial_cash (int) (optional):
    The cash to start from. Initiall 10k

    comission (int) (option):
    int fraction value. Defaults to 0.1%. This is much higher than normal. Staying on the safe side.

    df (Dataframe) (option):
    Uses df as features dataframe if specified. Otherwise reads the coin folder
    
    '''
    global n_fast
    global n_slow

    global long_macd_threshold
    global long_per_threshold
    global long_close_threshold
    global short_macd_threshold
    global short_per_threshold
    global short_close_threshold
    global symbol

    n_fast = n_fast_par
    n_slow = n_slow_par

    long_macd_threshold = long_macd_threshold_par
    long_per_threshold = long_per_threshold_par
    long_close_threshold = long_close_threshold_par
    short_macd_threshold = short_macd_threshold_par
    short_per_threshold = short_per_threshold_par
    short_close_threshold = short_close_threshold_par
    symbol = symbol_par

    json_info = {}
    json_info['n_fast'] = n_fast
    json_info['n_slow'] = n_slow
    json_info['long_macd_threshold'] = long_macd_threshold_par
    json_info['long_per_threshold'] = long_per_threshold_par
    json_info['long_close_threshold'] = long_close_threshold_par
    json_info['short_macd_threshold'] = short_macd_threshold_par
    json_info['short_per_threshold'] = short_per_threshold_par
    json_info['short_close_threshold'] = short_close_threshold_par
    json_info['initial_cash'] = initial_cash
    json_info['comission'] = comission

    with open(get_root_dir() + "/data/parameters.json", 'w') as f:
        json.dump(json_info, f)

    features_file = get_root_dir() + "/data/features/{}.csv".format(symbol)

    if df is None:
        df = pd.read_csv(features_file)

    df['macd'] = ta.trend.macd(df['sentistrength_total'],
                               n_fast=n_fast,
                               n_slow=n_slow,
                               fillna=True)
    df['macd'] = df['macd'].fillna(0)

    df['Time'] = pd.to_datetime(df['Time'])

    json_data = {}

    json_data['mean'] = df['macd'].mean()
    json_data['std'] = df['macd'].std()

    df['macd'] = (df['macd'] - json_data['mean']) / json_data['std']

    df = df.dropna(subset=['Time'])

    curr_dir = get_root_dir() + "/data/backtest/{}".format(symbol)

    if not os.path.exists(curr_dir):
        os.makedirs(curr_dir)

    fig = create_plot(df, 'macd', 'SentiStength')

    plotly_json = fig.to_json()

    html = fig.to_html()

    with open(curr_dir + '/plotly.html', 'w') as file:
        file.write(html)

    with open(curr_dir + '/plotly.json', 'w') as file:
        file.write(plotly_json)

    df = df[['Time', 'Open', 'High', 'Low', 'Close', 'Volume', 'macd']]
    df.to_csv(os.path.join(curr_dir, "data.csv"), index=None)

    data = PandasData_Custom(dataname=df)
    cerebro = bt.Cerebro(cheat_on_open=True, maxcpus=None)
    cerebro.adddata(data)

    cerebro.addstrategy(tradeStrategy)

    cerebro.addanalyzer(bt.analyzers.SharpeRatio_A)
    cerebro.addanalyzer(bt.analyzers.Calmar)
    cerebro.addanalyzer(bt.analyzers.DrawDown)
    cerebro.addanalyzer(bt.analyzers.Returns)
    cerebro.addanalyzer(bt.analyzers.TradeAnalyzer)

    cerebro.broker.setcash(initial_cash)
    cerebro.broker.setcommission(comission / 100)

    run = cerebro.run()

    analysis = run[0].analyzers.getbyname('tradeanalyzer').get_analysis()

    trade_analyzer = {}
    trade_analyzer['total'] = analysis['total']['total']
    trade_analyzer['open'] = analysis['total']['open']
    trade_analyzer['closed'] = analysis['total']['closed']

    with open(curr_dir + "/stats.json", 'w') as f:
        json.dump(trade_analyzer, f)

    portfolioValue, trades, operations = run[0].get_logs()

    # fig = cerebro.plot()
    # figure = fig[0][0]
    # figure.savefig(curr_dir + "/backtest.png")

    output_file(curr_dir + "/backtest.html")
    b = Bokeh(style='bar', plot_mode="tabs", scheme=Tradimo())
    b.plot_result(run)

    df = df.set_index('Time')
    df = df.resample('1D').apply(resampler)
    df = df.reset_index()
    df = df[['Time', 'Open']].merge(portfolioValue,
                                    left_on='Time',
                                    right_on='Date').drop('Time', axis=1)
    df['hodl'] = (initial_cash / df['Open'].iloc[0]) * df['Open']
    df = df.drop('Open', axis=1)

    df.to_csv(curr_dir + '/portfolio.csv', index=None)
    trades.to_csv(curr_dir + '/trades.csv', index=None)
    operations.to_csv(curr_dir + '/operations.csv', index=None)

    with open(os.path.join(curr_dir, "data.json"), 'w') as fp:
        json.dump(json_data, fp)
Esempio n. 27
0
cerebro.broker.setcommission(commission=0.0025)

data = bt.feeds.GenericCSVData(
    dataname=f'./data/{target_stock}.csv',
    nullvalue=0.0,
    dtformat=('%Y-%m-%d'),
    datetime=0,
    open=1,
    high=2,
    low=3,
    close=4,
    volume=6,
)

cerebro.adddata(data)
cerebro.addstrategy(Buy_and_Hold)

cerebro.addanalyzer(bt.analyzers.TradeAnalyzer,
                    _name='TradeAnalyzer')  # 交易分析 (策略勝率)
cerebro.addanalyzer(bt.analyzers.PeriodStats, _name='PeriodStats')  # 交易基本統計分析
cerebro.addanalyzer(bt.analyzers.DrawDown, _name='DrawDown')  # 回落統計
cerebro.addanalyzer(bt.analyzers.SQN,
                    _name='SQN')  # 期望獲利/標準差 System Quality Number
cerebro.addanalyzer(bt.analyzers.SharpeRatio, _name='SharpeRatio')  # 夏普指數

print('投資 > 起始資產 %.2f 💲' % cerebro.broker.getvalue())
cerebro.run()
print('投資 > 結束資產 %.2f 💲' % cerebro.broker.getvalue())

investment_plot = Bokeh(style='bar', plot_mode='single', scheme=Blackly())
cerebro.plot(investment_plot)
 def _create_bokeh(self):
     return Bokeh(
         style=self.p.style, scheme=self.p.scheme, **self._bokeh_kwargs
     )  # get a copy of the scheme so we can modify it per client