黄金矿工

1
class FullMoney(PercentSizer):
2
    params = (
3
        ('percents', 100 - fees),
4
    )
5

6
data_bt = bt.feeds.PandasData(
7
    dataname=ohlcv_wbuf,
8
    openinterest=-1,
9
    datetime=None,
10
    timeframe=bt.TimeFrame.Minutes,
11
    compression=1
12
 )
13

14
cerebro = bt.Cerebro(quicknotify=True)
15
cerebro.adddata(data_bt)
16
broker = cerebro.getbroker()
17
broker.set_coc(True) # cheat-on-close
18
broker.setcommission(commission=fees/100)#, name=coin_target)
19
broker.setcash(init_cash)
20
cerebro.addsizer(FullMoney)
21
cerebro.addanalyzer(bt.analyzers.TradeAnalyzer, _name="ta")
22
cerebro.addanalyzer(bt.analyzers.SQN, _name="sqn")
23
cerebro.addanalyzer(bt.analyzers.Transactions, _name="transactions")

1
class StrategyBase(bt.Strategy):
2
    def __init__(self):
3
        self.order = None
4
        self.last_operation = "SELL"
5
        self.status = "DISCONNECTED"
6
        self.buy_price_close = None
7
        self.pending_order = False
8
        self.commissions = []
9

10
    def notify_data(self, data, status, *args, **kwargs):
11
        self.status = data._getstatusname(status)
12

13
    def short(self):
14
        self.sell()
15

16
    def long(self):
17
        self.buy_price_close = self.data0.close[0]
18
        self.buy()
19

20
    def notify_order(self, order):
21
        self.pending_order = False
22
        if order.status in [order.Submitted, order.Accepted]:
23
            self.order = order
24
            return
25

26
        elif order.status in [order.Completed]:
27
            self.commissions.append(order.executed.comm)
28

29
            if order.isbuy():
30
                self.last_operation = "BUY"
31

32
            else:  # Sell
33
                self.buy_price_close = None
34
                self.last_operation = "SELL"
35

36
        self.order = None
37

38
class BasicRSI(StrategyBase):
39
    params = dict(    #入参申明
40
        period_ema_fast=fast_window,
41
        period_ema_slow=slow_window,
42
        rsi_bottom_threshold=rsi_bottom,
43
        rsi_top_threshold=rsi_top
44
    )
45

46
    def __init__(self):
47
        StrategyBase.__init__(self)
48

49
        self.ema_fast = bt.indicators.EMA(period=self.p.period_ema_fast)
50
        self.ema_slow = bt.indicators.EMA(period=self.p.period_ema_slow)
51
        self.rsi = bt.talib.RSI(self.data, timeperiod=14) #指标计算
52
        #self.rsi = bt.indicators.RelativeStrengthIndex()
53

54
        self.profit = 0
55
        self.stop_loss_flag = True
56

57
    def update_indicators(self): #指标更新
58
        self.profit = 0
59
        if self.buy_price_close and self.buy_price_close > 0:
60
            self.profit = float(
61
                self.data0.close[0] - self.buy_price_close) / self.buy_price_close
62

63
    def next(self):
64
        self.update_indicators()
65

66
        if self.order:  # waiting for pending order
67
            return
68

69
        # stop Loss
70
        ''' if self.profit < -0.03:
71
            self.short() '''
72

73
        # take Profit
74
        ''' if self.profit > 0.03:
75
            self.short() '''
76

77
        # reset stop loss flag
78
        if self.rsi > self.p.rsi_bottom_threshold:
79
            self.stop_loss_flag = False
80

81
        if self.last_operation != "BUY": # 这里需要注意，由于rsi可能持续小于阈值，需避免持续的下单
82
            # if self.rsi < 30 and self.ema_fast > self.ema_slow:
83
            if self.rsi < self.p.rsi_bottom_threshold:  # and not self.stop_loss_flag:
84
                self.long()
85

86
        if self.last_operation != "SELL":
87
            if self.rsi > self.p.rsi_top_threshold:
88
                self.short()

1
cerebro.addstrategy(BasicRSI)
2
initial_value = cerebro.broker.getvalue()
3
print('Starting Portfolio Value: %.2f' % initial_value)
4
result = cerebro.run()
5

6
Starting Portfolio Value: 100.62  #期末终值，比最初100多了0.62

1
def print_trade_analysis(analyzer): # 将analyzer的一部分信息按照特定格式打印出来
2
    # Get the results we are interested in
3
    if not analyzer.get("total"):
4
        return
5

6
    total_open = analyzer.total.open
7
    total_closed = analyzer.total.closed
8
    total_won = analyzer.won.total
9
    total_lost = analyzer.lost.total
10
    win_streak = analyzer.streak.won.longest
11
    lose_streak = analyzer.streak.lost.longest
12
    pnl_net = round(analyzer.pnl.net.total, 2)
13
    strike_rate = round((total_won / total_closed) * 2)
14

15
    # Designate the rows
16
    h1 = ['Total Open', 'Total Closed', 'Total Won', 'Total Lost']
17
    h2 = ['Strike Rate', 'Win Streak', 'Losing Streak', 'PnL Net']
18
    r1 = [total_open, total_closed, total_won, total_lost]
19
    r2 = [strike_rate, win_streak, lose_streak, pnl_net]
20

21
    # Check which set of headers is the longest.
22
    if len(h1) > len(h2):
23
        header_length = len(h1)
24
    else:
25
        header_length = len(h2)
26

27
    # Print the rows
28
    print_list = [h1, r1, h2, r2]
29
    row_format = "{:<15}" * (header_length + 1)
30
    print("Trade Analysis Results:")
31
    for row in print_list:
32
        print(row_format.format('', *row))
33

34

35
def print_sqn(analyzer):
36
    sqn = round(analyzer.sqn, 2)
37
    print('SQN: {}'.format(sqn))
38

39
# Print analyzers - results
40
final_value = cerebro.broker.getvalue()
41
print('Final Portfolio Value: %.2f' % final_value)
42
print('Profit %.3f%%' % ((final_value - initial_value) / initial_value * 100))
43
print_trade_analysis(result[0].analyzers.ta.get_analysis())
44
print_sqn(result[0].analyzers.sqn.get_analysis())
45

46

47
Final Portfolio Value: 100.62
48
Profit 0.618%
49
Trade Analysis Results:
50
               Total Open     Total Closed   Total Won      Total Lost
51
               0              2              1              1
52
               Strike Rate    Win Streak     Losing Streak  PnL Net
53
               1              1              1              0.62
54
SQN: 0.06

1
data = result[0].analyzers.transactions.get_analysis()
2
df = pd.DataFrame.from_dict(data, orient='index', columns=['data'])
3
bt_transactions = pd.DataFrame(df.data.values.tolist(), df.index.tz_localize(tz='UTC'), columns=[
4
                               'amount', 'price', 'sid', 'symbol', 'value'])
5
bt_transactions
6

7
  amount  price  sid  symbol  value
8
2018-02-12 00:00:00+00:00  38.760667  2.578  0    -99.925000
9
2018-09-25 00:00:00+00:00  -38.760667  2.407  0    93.296926
10
2018-12-24 00:00:00+00:00  43.818010  2.126  0    -93.157089
11
2019-02-01 00:00:00+00:00  -43.818010  2.298  0    100.693787

1
%matplotlib inline
2
import matplotlib.pyplot as plt
3

4

5
plt.rcParams["figure.figsize"] = (13, 8)
6
cerebro.plot(style='bar', iplot=False)

1
bt_entries_mask = bt_transactions[bt_transactions.amount > 0]
2
bt_entries_mask.index = bt_entries_mask.index
3
bt_exits_mask = bt_transactions[bt_transactions.amount < 0]
4
bt_exits_mask.index = bt_exits_mask.index
5

6
bt_entries = pd.Series.vbt.signals.empty_like(ohlcv['Close'])
7
bt_entries.loc[bt_entries_mask.index] = True
8
bt_exits = pd.Series.vbt.signals.empty_like(ohlcv['Close'])
9
bt_exits.loc[bt_exits_mask.index] = True

1
vbt.settings.portfolio['fees'] = 0.075 / 100 #0.0025 # in %
2
bt_pf = vbt.Portfolio.from_signals(ohlcv['Close'], bt_entries, bt_exits, price=ohlcv['Close'].vbt.fshift(1))
3

4
bt_pf.trades.plot().show_svg()

1
bt_commissions = pd.Series(result[0].commissions, index=bt_transactions.index)
2

3
vbt_commissions = bt_pf.orders.records_readable.Fees
4
vbt_commissions.index = bt_pf.orders.records_readable.Timestamp
5

6
commissions_delta = bt_commissions - vbt_commissions
7
print(commissions_delta.head())
8

9
2018-02-12 00:00:00+00:00   -4.215589e-08
10
2018-09-25 00:00:00+00:00   -3.935966e-08
11
2018-12-24 00:00:00+00:00   -3.644546e-08
12
2019-02-01 00:00:00+00:00   -3.939400e-08
13
dtype: float64
14

15
commissions_delta.rename('Commissions (Delta)').vbt.plot().show_svg()

1
print('Final Portfolio Value: %.5f' % final_value)
2
print('Profit %.3f%%' % ((final_value - initial_value) / initial_value * 100))
3
print_trade_analysis(result[0].analyzers.ta.get_analysis())
4
print(bt_pf.stats())
5

6
Final Portfolio Value: 100.61832
7
Profit 0.618%
8
Trade Analysis Results:
9
               Total Open     Total Closed   Total Won      Total Lost
10
               0              2              1              1
11
               Strike Rate    Win Streak     Losing Streak  PnL Net
12
               1              1              1              0.62
13
Start                         2017-03-06 00:00:00+00:00
14
End                           2019-03-11 00:00:00+00:00
15
Period                                  0 days 08:12:00
16
Start Value                                       100.0
17
End Value                                    100.618319 #和bt基本相等
18
Total Return [%]                               0.618319
19
Benchmark Return [%]                          21.449275
20
Max Gross Exposure [%]                            100.0
21
Total Fees Paid                                0.290305
22
Max Drawdown [%]                              20.985401
23
Max Drawdown Duration                   0 days 04:12:00
24
Total Trades                                          2 #交易2次，和bt相等
25
Total Closed Trades                                   2
26
Total Open Trades                                     0
27
Open Trade PnL                                      0.0
28
Win Rate [%]                                       50.0
29
Best Trade [%]                                 7.934243
30
Worst Trade [%]                               -6.778074
31
Avg Winning Trade [%]                          7.934243
32
Avg Losing Trade [%]                          -6.778074
33
Avg Winning Trade Duration              0 days 00:27:00
34
Avg Losing Trade Duration               0 days 02:30:00
35
Profit Factor                                  1.091292
36
Expectancy                                      0.30916
37
Sharpe Ratio                                   4.058997
38
Calmar Ratio                                3446.385338
39
Omega Ratio                                    1.024452
40
Sortino Ratio                                  5.961637
41
Name: Close, dtype: object

1
fig = vbt.make_subplots(specs=[[{"secondary_y": True}]])
2
fig = ohlcv['Close'].vbt.plot(trace_kwargs=dict(name='Price'), fig=fig)
3

4
fig = bt_entries.vbt.signals.plot_as_entry_markers(ohlcv['Close'], fig=fig)
5
fig = bt_exits.vbt.signals.plot_as_exit_markers(ohlcv['Close'], fig=fig)
6

7
fig.show_svg()

1
# 计算指标
2
RSI = vbt.IndicatorFactory.from_talib('RSI')
3
rsi = RSI.run(ohlcv_wbuf['Open'], timeperiod=[14])
4

5
print(rsi.real.shape)
6
(492,)
7

8
# 指标转买卖信号
9
vbt_entries = rsi.real_crossed_below(rsi_bottom)
10
vbt_exits = rsi.real_crossed_above(rsi_top)
11
vbt_entries, vbt_exits = pd.DataFrame.vbt.signals.clean(vbt_entries, vbt_exits)
12

13
# 买卖信号绘制到价格图中
14
fig = vbt.make_subplots(specs=[[{"secondary_y": True}]])
15
fig = ohlcv['Open'].vbt.plot(trace_kwargs=dict(name='Price'), fig=fig)
16
fig = vbt_entries.vbt.signals.plot_as_entry_markers(ohlcv['Open'], fig=fig)
17
fig = vbt_exits.vbt.signals.plot_as_exit_markers(ohlcv['Open'], fig=fig)
18

19
fig.show_svg()

1
SignalsAccessor.clean(
2
    *args,
3
    entry_first=True,
4
    broadcast_kwargs=None,
5
    wrap_kwargs=None
6
)
7
Clean signals.
8

9
If one array passed, see SignalsAccessor.first(). If two arrays passed, entries and exits, see clean_enex_nb().
10

11
SignalsAccessor.first() #下面解释没看懂，但之前代码运行结果为，保留第一个为true的记录，后续置为false
12
first method¶
13
SignalsAccessor.first(
14
    wrap_kwargs=None,
15
    **kwargs
16
)
17
Select signals that satisfy the condition pos_rank == 0.
18

19

20
clean_enex_nb function¶ #clean_enex_1d_nb()的二维版本，顾名思义应该是多组买卖信号，买在卖前，可能还兼顾将连续的true或false改为单次触发信号
21
clean_enex_nb(
22
    entries,
23
    exits,
24
    entry_first
25
)
26
2-dim version of clean_enex_1d_nb().
27

28
clean_enex_1d_nb(). #从信号中取得第一个买卖信号，其中买在卖前，假如2个信号完全相同，则为None
29
clean_enex_1d_nb function¶
30
clean_enex_1d_nb(
31
    entries,
32
    exits,
33
    entry_first
34
)
35
Clean entry and exit arrays by picking the first signal out of each.
36
Entry signal must be picked first. If both signals are present, selects none.

1
vbt_pf = vbt.Portfolio.from_signals(ohlcv['Close'], vbt_entries, vbt_exits, price=ohlcv['Close'].vbt.fshift(1))
2
print('Final Portfolio Value   (Vectorbt): %.5f' % vbt_pf.final_value())
3
print('Final Portfolio Value (Backtrader): %.5f' % final_value)
4

5
Final Portfolio Value   (Vectorbt): 98.55972
6
Final Portfolio Value (Backtrader): 100.61832

1
(vbt_entries ^ bt_entries).rename('Entries (Delta)').vbt.signals.plot().show_svg()
2
(vbt_exits ^ bt_exits).rename('Exits (Delta)').vbt.signals.plot().show_svg()

1
# create a selection mask for showing values which are different
2
mask = vbt_exits ^ bt_exits
3
print(vbt_exits[mask]) # show the different ones in vbt_exits
4
print(bt_exits[mask]) # show the different ones in bt_exits
5
print(rsi.real[mask]) # show the RSI value

1
date
2
2017-05-24 00:00:00+00:00     True
3
2018-09-25 00:00:00+00:00    False
4
2018-09-27 00:00:00+00:00     True
5
Name: (14, Open), dtype: bool
6
date
7
2017-05-24 00:00:00+00:00    False
8
2018-09-25 00:00:00+00:00     True
9
2018-09-27 00:00:00+00:00    False
10
Name: Close, dtype: bool
11
date
12
2017-05-24 00:00:00+00:00    66.448255
13
2018-09-25 00:00:00+00:00    63.782884
14
2018-09-27 00:00:00+00:00    66.771968
15
Name: (14, Open), dtype: float64

1
# backtrader计算的rsi指标
2
rsi_bt_df = pd.DataFrame({
3
    'rsi': result[0].rsi.get(size=len(result[0]))
4
  }, index=[result[0].datas[0].num2date(x) for x in result[0].data.datetime.get(size=len(result[0]))])
5
rsi_bt_df.index = rsi_bt_df.index.tz_localize(tz='UTC')
6
rsi_bt_df.rsi = rsi_bt_df.rsi.shift(1)
7

8
# vectorbt计算的rsi指标
9
rsi_vbt_df = pd.DataFrame({
10
  'rsi': rsi.real.values
11
}, index=rsi.real.index)
12
rsi_vbt_df_mask = (rsi_vbt_df.index >= start_date) & (rsi_vbt_df.index <= end_date) # mask without buffer
13
rsi_vbt_df = rsi_vbt_df.loc[rsi_vbt_df_mask, :]
14

15
print(rsi_bt_df.shape)
16
print(rsi_vbt_df.shape)
17
#rsi_bt_df.head(20)
18
#rsi_vbt_df.head(20)
19
(492, 1)
20
(492, 1)

1
rsi_delta = rsi_bt_df - rsi_vbt_df
2
#rsi_delta.head(20)
3
rsi_delta.rsi.rename('RSI (Delta)').vbt.plot().show_svg()

1
# Overlapped
2
pd.DataFrame({'RSI (VBT)': rsi_vbt_df['rsi'], 'RSI (BT)': rsi_bt_df['rsi']}).vbt.plot().show_svg()
3
# RSI signal from Backtrader
4
rsi_bt_df.rsi.rename('RSI (BT)').vbt.plot().show_svg()
5
# RSI signal from Vectorbt
6
rsi_vbt_df.rsi.rename('RSI (VBT)').vbt.plot().show_svg()

1
# 使用bt的指标计算信号
2
vbt_bt_entries = rsi_bt_df.rsi < rsi_bottom
3
vbt_bt_exits = rsi_bt_df.rsi > rsi_top
4
vbt_bt_entries, vbt_bt_exits = pd.DataFrame.vbt.signals.clean(vbt_bt_entries, vbt_bt_exits)
5

6
# 信号的可视化
7
fig = vbt.make_subplots(specs=[[{"secondary_y": True}]])
8
fig = ohlcv['Open'].vbt.plot(trace_kwargs=dict(name='Price'), fig=fig)
9
fig = vbt_bt_entries.vbt.signals.plot_as_entry_markers(ohlcv['Open'], fig=fig)
10
fig = vbt_bt_exits.vbt.signals.plot_as_exit_markers(ohlcv['Open'], fig=fig)
11

12
fig.show_svg()

1
(vbt_bt_entries ^ bt_entries).rename('Entries (Delta)').vbt.signals.plot().show_svg()
2
(vbt_bt_exits ^ bt_exits).rename('Exits (Delta)').vbt.signals.plot().show_svg()

1
# 差异部分的print
2
# create a selection mask for showing values which are different
3
mask = vbt_bt_exits ^ bt_exits
4
print(vbt_bt_exits[mask]) # show the different ones in vbt_bt_exits
5
print(bt_exits[mask]) # show the different ones in bt_exits
6
print(rsi_bt_df.rsi[mask]) # show the RSI value
7

8
# 买卖信号可视化
9
fig = vbt_bt_entries.vbt.signals.plot(trace_kwargs=dict(name='Entries'))
10
vbt_bt_exits.vbt.signals.plot(trace_kwargs=dict(name='Exits'), fig=fig).show_svg()
11

12
# vectorbt和backtrader回测方法的终值差异
13
vbt_bt_pf = vbt.Portfolio.from_signals(ohlcv['Close'], vbt_bt_entries, vbt_bt_exits, price=ohlcv['Close'].vbt.fshift(1))
14
print('Final Portfolio Value   (Vectorbt): %.5f' % vbt_bt_pf.final_value())
15
print('Final Portfolio Value (Backtrader): %.5f' % final_value)
16

17
# vectorbt的交易可视化
18
#print(vbt_bt_pf.trades.records)
19
vbt_bt_pf.trades.plot().show_svg()