黄金矿工

1
srb_sharpe = np.full(price.shape[0], np.nan)
2

3
@njit
4
def pre_sim_func_nb(c, every_nth):
5
    # Define rebalancing days
6
    c.segment_mask[:, :] = False
7
    c.segment_mask[every_nth::every_nth, :] = True
8
    return ()
9

10
@njit
11
def find_weights_nb(c, price, num_tests):
12
    # Find optimal weights based on best Sharpe ratio
13
    returns = (price[1:] - price[:-1]) / price[:-1]
14
    returns = returns[1:, :]  # cannot compute np.cov with NaN
15
    mean = nanmean_nb(returns)
16
    cov = np.cov(returns, rowvar=False)  # masked arrays not supported by Numba (yet)
17
    best_sharpe_ratio = -np.inf
18
    weights = np.full(c.group_len, np.nan, dtype=np.float_)
19

20
    for i in range(num_tests):
21
        # Generate weights
22
        w = np.random.random_sample(c.group_len)
23
        w = w / np.sum(w)
24

25
        # Compute annualized mean, covariance, and Sharpe ratio
26
        p_return = np.sum(mean * w) * ann_factor
27
        p_std = np.sqrt(np.dot(w.T, np.dot(cov, w))) * np.sqrt(ann_factor)
28
        sharpe_ratio = p_return / p_std
29
        if sharpe_ratio > best_sharpe_ratio:
30
            best_sharpe_ratio = sharpe_ratio
31
            weights = w
32

33
    return best_sharpe_ratio, weights
34

35
@njit
36
def pre_segment_func_nb(c, find_weights_nb, history_len, ann_factor, num_tests, srb_sharpe):
37
    if history_len == -1:
38
        # Look back at the entire time period
39
        close = c.close[:c.i, c.from_col:c.to_col]
40
    else:
41
        # Look back at a fixed time period
42
        if c.i - history_len <= 0:
43
            return (np.full(c.group_len, np.nan),)  # insufficient data
44
        close = c.close[c.i - history_len:c.i, c.from_col:c.to_col]
45

46
    # Find optimal weights
47
    best_sharpe_ratio, weights = find_weights_nb(c, close, num_tests)
48
    srb_sharpe[c.i] = best_sharpe_ratio
49

50
    # Update valuation price and reorder orders
51
    size_type = SizeType.TargetPercent
52
    direction = Direction.LongOnly
53
    order_value_out = np.empty(c.group_len, dtype=np.float_)
54
    for k in range(c.group_len):
55
        col = c.from_col + k
56
        c.last_val_price[col] = c.close[c.i, col]
57
    sort_call_seq_nb(c, weights, size_type, direction, order_value_out)
58

59
    return (weights,)
60

61
@njit
62
def order_func_nb(c, weights):
63
    col_i = c.call_seq_now[c.call_idx]
64
    return order_nb(
65
        weights[col_i],
66
        c.close[c.i, c.col],
67
        size_type=SizeType.TargetPercent
68
    )
69

70

71
ann_factor = returns.vbt.returns.ann_factor
72

73

74
# Run simulation using a custom order function
75
srb_pf = vbt.Portfolio.from_order_func(
76
    price,
77
    order_func_nb,
78
    pre_sim_func_nb=pre_sim_func_nb,
79
    pre_sim_args=(30,),
80
    pre_segment_func_nb=pre_segment_func_nb,
81
    pre_segment_args=(find_weights_nb, -1, ann_factor, num_tests, srb_sharpe),
82
    cash_sharing=True,
83
    group_by=True
84
)
85

86

87
# Plot best Sharpe ratio at each rebalancing day
88
pd.Series(srb_sharpe, index=price.index).vbt.scatterplot(trace_kwargs=dict(mode='markers')).show_svg()
89

90
print(srb_pf.stats())

1
# Calculate expected returns and sample covariance amtrix
2
avg_returns = expected_returns.mean_historical_return(price)
3
symbol
4
510050.XSHG    0.135305
5
510300.XSHG    0.098036
6
159901.XSHE    0.096895
7
dtype: float64
8

9
cov_mat = risk_models.sample_cov(price) # 协方差矩阵

1
# Get weights maximizing the Sharpe ratio
2
ef = EfficientFrontier(avg_returns, cov_mat)
3
weights = ef.max_sharpe()
4
weights
5
OrderedDict([('510050.XSHG', 1.0), ('510300.XSHG', 0.0), ('159901.XSHE', 0.0)])
6

7
clean_weights = ef.clean_weights()
8
clean_weights
9
OrderedDict([('510050.XSHG', 1.0), ('510300.XSHG', 0.0), ('159901.XSHE', 0.0)])
10

11
pyopt_weights = np.array([clean_weights[symbol] for symbol in symbols])
12
print(pyopt_weights)
13
[1. 0. 0.]

1
pyopt_size = np.full_like(price, np.nan)
2
pyopt_size[0, :] = pyopt_weights  # allocate at first timestamp, do nothing afterwards
3

4
print(pyopt_size[:5])
5
print(pyopt_size.shape)
6
[[ 1.  0.  0.]
7
 [nan nan nan]
8
 [nan nan nan]
9
 [nan nan nan]
10
 [nan nan nan]]
11
(731, 3)

1
# Run simulation with weights from PyPortfolioOpt
2
pyopt_pf = vbt.Portfolio.from_orders(
3
    close=price,
4
    size=pyopt_size,
5
    size_type='targetpercent',
6
    group_by=True,
7
    cash_sharing=True
8
)
9

10
print(len(pyopt_pf.orders))
11
1
12

13
收益统计
14
print(pyopt_pf.stats())
15
Start                         2017-01-03 00:00:00+00:00
16
End                           2019-12-31 00:00:00+00:00
17
Period                                731 days 00:00:00
18
Start Value                                       100.0
19
End Value                                    144.428008
20
Total Return [%]                              44.428008
21
Benchmark Return [%]                           35.42267
22
Max Gross Exposure [%]                            100.0
23
Total Fees Paid                                     0.0
24
Max Drawdown [%]                               29.64467
25
Max Drawdown Duration                 462 days 00:00:00
26
Total Trades                                          1
27
Total Closed Trades                                   0
28
Total Open Trades                                     1
29
Open Trade PnL                                44.428008
30
Win Rate [%]                                        NaN
31
Best Trade [%]                                      NaN
32
Worst Trade [%]                                     NaN
33
Avg Winning Trade [%]                               NaN
34
Avg Losing Trade [%]                                NaN
35
Avg Winning Trade Duration                          NaT
36
Avg Losing Trade Duration                           NaT
37
Profit Factor                                       NaN
38
Expectancy                                          NaN
39
Sharpe Ratio                                   0.735009
40
Calmar Ratio                                   0.455758
41
Omega Ratio                                     1.14102
42
Sortino Ratio                                  1.082667
43
Name: group, dtype: object

1
You can't use third-party optimization packages within Numba (yet). #不确定为啥
2
Here you have two choices:
3
1) Use os.environ['NUMBA_DISABLE_JIT'] = '1' before all imports to disable Numba completely 2) Disable Numba for the function, but also for every other function in the stack that calls it
4
We will demonstrate the second option.

1
def pyopt_find_weights(sc, price, num_tests):  # no @njit decorator = it's a pure Python function
2
    # Calculate expected returns and sample covariance matrix
3
    price = pd.DataFrame(price, columns=symbols)
4
    avg_returns = expected_returns.mean_historical_return(price)
5
    cov_mat = risk_models.sample_cov(price)
6

7
    # Get weights maximizing the Sharpe ratio
8
    ef = EfficientFrontier(avg_returns, cov_mat)
9
    weights = ef.max_sharpe()
10
    clean_weights = ef.clean_weights()
11
    weights = np.array([clean_weights[symbol] for symbol in symbols])
12
    best_sharpe_ratio = base_optimizer.portfolio_performance(weights, avg_returns, cov_mat)[2]
13

14
    return best_sharpe_ratio, weights

1
pyopt_srb_sharpe = np.full(price.shape[0], np.nan)
2

3
# Run simulation with a custom order function
4
pyopt_srb_pf = vbt.Portfolio.from_order_func(
5
    price,
6
    order_func_nb,
7
    pre_sim_func_nb=pre_sim_func_nb,
8
    pre_sim_args=(30,),
9
    pre_segment_func_nb=pre_segment_func_nb.py_func,  # run pre_segment_func_nb as pure Python function
10
    pre_segment_args=(pyopt_find_weights, -1, ann_factor, num_tests, pyopt_srb_sharpe),
11
    cash_sharing=True,
12
    group_by=True,
13
    use_numba=False  # run simulate_nb as pure Python function
14
)

1
pd.Series(pyopt_srb_sharpe, index=price.index).vbt.scatterplot(trace_kwargs=dict(mode='markers')).show_svg()

1
print(pyopt_srb_pf.stats())
2
Start                           2017-01-03 00:00:00+00:00
3
End                             2019-12-31 00:00:00+00:00
4
Period                                  731 days 00:00:00
5
Start Value                                         100.0
6
End Value                                      130.474091
7
Total Return [%]                                30.474091
8
Benchmark Return [%]                             35.42267
9
Max Gross Exposure [%]                              100.0
10
Total Fees Paid                                       0.0
11
Max Drawdown [%]                                  31.0145
12
Max Drawdown Duration                   471 days 00:00:00
13
Total Trades                                           13
14
Total Closed Trades                                    12
15
Total Open Trades                                       1
16
Open Trade PnL                                  26.174785
17
Win Rate [%]                                    58.333333
18
Best Trade [%]                                  23.399167
19
Worst Trade [%]                                -11.947833
20
Avg Winning Trade [%]                            8.563981
21
Avg Losing Trade [%]                            -4.049498
22
Avg Winning Trade Duration    107 days 03:25:42.857142856
23
Avg Losing Trade Duration                78 days 00:00:00
24
Profit Factor                                    1.788768
25
Expectancy                                       0.358275
26
Sharpe Ratio                                     0.563374
27
Calmar Ratio                                     0.309651
28
Omega Ratio                                      1.108617
29
Sortino Ratio                                    0.820358
30
Name: group, dtype: object

1
plot_allocation(pyopt_srb_pf)