def CDF_c(signal_df, raw_return_df, hold_time, title='CDF Figure', lag=2):
signal_df = signal_df.shift(lag).replace('np.nan')
a = np.argsort(signal_df.values)
return_df = bt.AZ_Rolling_sum(raw_return_df, hold_time).shift(-hold_time + 1)
f_return_m = return_df - np.nanmean(return_df)
plt.figure(figsize=(20, 6))
p1 = plt.subplot(121)
p2 = plt.subplot(122)
p1.plot(signal_df.iloc[a].values, np.cumsum(return_df.iloc[a].values))
# p1.plot(np.cumsum(return_df[a]))
# p1.set_xticklabels(signal_df[a].values)
ticks_list = signal_df.iloc[a].values[[int(len(signal_df[a]) / 14) * i - 1 for i in range(1, 15)]]
print(ticks_list)
p1.set_xticks(ticks_list)
# p1.vlines(x='13:30', ymin=np.inf, ymax=np.inf)
p1.set_title('cumsum return')
p1.grid(1)
p2.plot(signal_df.iloc[a].values, np.cumsum(f_return_m.iloc[a]))
# p2.plot(np.cumsum(f_return_m[a]))
# p2.set_xticklabels(signal_df[a].values)
p2.set_xticks(ticks_list)
p2.set_title('cumsum mean return')
p2.grid(1)
plt.suptitle(title)
savfig_send(subject=title, text='')
def test_fun(fut_name, CCI_window, CCI_limit):
result_list = []
pool = Pool(20)
if fut_name not in ban_name_list:
for con_id, part_info_df in fut_data.act_info_df[[
f'{fut_name}01'
]].groupby(f'{fut_name}01'):
args = [
con_id,
part_info_df.index[0] - timedelta(1),
part_info_df.index[-1] + timedelta(1),
CCI_window,
CCI_limit,
]
result_list.append(pool.apply_async(part_test, args=args))
pool.close()
pool.join()
pnl_df = pd.concat([res.get()[0] for res in result_list], axis=0)
turnover_df = pd.concat([res.get()[1] for res in result_list], axis=0)
data_df = pd.concat([res.get()[2] for res in result_list], axis=0)
pot = pnl_df.sum() / turnover_df.sum() * 10000
sp = bt.AZ_Sharpe_y(pnl_df)
print(fut_name, pot, sp)
plt.figure(figsize=[16, 8])
pnl_df.index = pd.to_datetime(pnl_df.index)
plt.plot(pnl_df.cumsum())
plt.grid()
savfig_send(
f'{fut_name} sp:{sp} pot={pot} CCI_window:{CCI_window}, CCI_limit:{CCI_limit}'
)
return data_df
def test_fun(fut_name, CCI_window, CCI_limit, hold_time):
result_list = []
pool = Pool(20)
for con_id, part_info_df in active_df[[f'{fut_name}01'
]].groupby(f'{fut_name}01'):
active_begin = fut_data.last_trade_date(
part_info_df.index[0]) + timedelta(hours=17)
active_end = part_info_df.index[-1] + timedelta(hours=17)
args = [
con_id, active_begin, active_end, CCI_window, CCI_limit, hold_time
]
# part_test(*args)
# print(part_info_df.index[0], part_info_df.index[-1])
result_list.append(pool.apply_async(part_test, args=args))
pool.close()
pool.join()
pnl_df = pd.concat([res.get()[0] for res in result_list], axis=0)
turnover_df = pd.concat([res.get()[1] for res in result_list], axis=0)
data_df = pd.concat([res.get()[2] for res in result_list], axis=0)
pot = pnl_df.sum() / turnover_df.sum() * 10000
sp = bt.AZ_Sharpe_y(pnl_df)
print(fut_name, sp, pot, CCI_window, CCI_limit)
print(fut_name, pot, sp)
for x, part_data_df in data_df.groupby(['weekday']):
part_pnl = part_data_df['pnl'].fillna(0).values
print(x, part_pnl.sum())
# plt.plot(part_pnl.cumsum())
# savfig_send(subject=f'{x} {bt.AZ_Sharpe_y(part_pnl)}')
for x, part_data_df in data_df.groupby(['month']):
part_pnl = part_data_df['pnl'].fillna(0).values
print(x, part_pnl.sum())
# plt.plot(part_pnl.cumsum())
# savfig_send(subject=f'{x} {bt.AZ_Sharpe_y(part_pnl)}')
# if abs(sp) > 1.5 and abs(pot) > 8:
# for x, part_data_df in data_df.groupby(['weekday']):
# part_pnl = part_data_df['pnl'].fillna(0).values
# print(x, part_pnl.sum())
# plt.plot(part_pnl.cumsum())
# savfig_send(subject=f'{x} {bt.AZ_Sharpe_y(part_pnl)}')
#
# for x, part_data_df in data_df.groupby(['month']):
# part_pnl = part_data_df['pnl'].fillna(0).values
# print(x, part_pnl.sum())
# plt.plot(part_pnl.cumsum())
# savfig_send(subject=f'{x} {bt.AZ_Sharpe_y(part_pnl)}')
plt.figure(figsize=[16, 8])
pnl_df.index = pd.to_datetime(pnl_df.index)
plt.plot(pnl_df.cumsum())
plt.grid()
savfig_send(
f'{fut_name} sp:{sp} pot={pot} CCI_window:{CCI_window}, CCI_limit:{CCI_limit}'
)
return data_df
def generation(index_name):
weight_df_new = AZ_Load_csv(root_path.EM_Funda.IDEX_YS_WEIGHT_A / f'SECINDEXR_{index_name}.csv')
weight_df_old = AZ_Load_csv(root_path.EM_Funda.IDEX_YS_WEIGHT_A / f'SECINDEXR_{index_name}plus.csv')
weight_df = weight_df_old.combine_first(weight_df_new)
stock_return_df = AZ_Load_csv(root_path.EM_Funda.DERIVED_14 / 'aadj_r.csv')
index_count = (weight_df * stock_return_df).sum(1)
print(index_count)
plt.plot(index_count.cumsum(), label='count')
savfig_send()
def test_fun(fut_name, path_name, file_name):
root_path = '/mnt/mfs/DAT_PUBLIC/spot_data'
####################
data_df = pd.read_excel(f'{root_path}/{path_name}/{file_name}',
index_col=0,
skiprows=[0, 1, 3, 4, 5, 6, 7, 8, 9],
parse_dates=True)
####################
# data_df = pd.read_excel(f'{root_path}/{path_name}/{file_name}', index_col=0,
# skiprows=[1, 2], parse_dates=True)
data_df = data_df.dropna(how='all', axis=0)
data_df.index = pd.to_datetime(data_df.index)
data_df = data_df.truncate(begin_time, end_time)
return_df = get_return_df(fut_name)
data_df = data_df.reindex(return_df.index).fillna(method='ffill')
# pos_df = SignalSet().fun_1(data_df)
score_df, _, _ = FutIndex.boll_fun(data_df, 10, return_line=True)
signal_df = Signal.fun_1(score_df, 0)
pos_df = Position.fun_1(signal_df)
pnl_df = pos_df.shift(2).mul(return_df, axis=0)
pnl_df.name = fut_name
# plt.figure(figsize=[16, 10])
# plt.plot(pnl_df.index, pnl_df.cumsum().values)
# plt.legend()
# plt.grid()
# savfig_send(subject=f"{fut_name}|{path_name.encode()}|{file_name.encode()}")
sharpe_sr = bt.AZ_Sharpe_y(pnl_df)
sharpe_sr.name = 'sharpe'
asset_df = pnl_df.sum()
trade_times = pos_df.diff().abs().sum()
pot_sr = (asset_df / trade_times) * 10000
pot_sr.name = 'pot'
result_df = pd.concat([sharpe_sr, pot_sr], axis=1) \
.sort_values(by='sharpe', na_position='last')
result_df = result_df[result_df['sharpe'].abs() > 1]
if len(result_df) != 0:
print(fut_name, path_name, file_name)
print(result_df)
plt.figure(figsize=[16, 10])
plt.plot(pnl_df.index, pnl_df[result_df.index].cumsum().values)
plt.legend()
plt.grid()
savfig_send(
text=f"{fut_name}|{path_name.encode()}|{file_name.encode()}",
subject=f"{fut_name}|{path_name.encode()}|{file_name.encode()}")
return pos_df, pnl_df, data_df, result_df
def part_main(factor_test, industry_df, index_name, q, sector_name, limit,
begin_d_list, end_d_list):
print(1)
plt.figure(figsize=[16, 10])
for begin_d in begin_d_list:
for end_d in end_d_list:
pnl_df, pot = main(factor_test, industry_df, index_name, q,
sector_name, limit, begin_d, end_d)
plt.plot(pnl_df.cumsum().values,
label=f'begin_d={begin_d}, end_d={end_d}, pot={pot}')
plt.legend()
savfig_send(subject=f'sector_name=REM5_scores, index_name={index_name}, '
f'Q={q}, limit={limit}')
def back_test_c(self, data, file_name, add_info):
data_c = data * self.sector_df
a = data_c.rank(axis=1, ascending=False)
signal_df = (a <= 20).astype(int)
print(signal_df.iloc[-10].replace(0, np.nan).dropna())
self.pos_daily_fun(signal_df)
pos_df = self.signal_to_pos_ls(signal_df, 'l')
pnl_df = (pos_df.shift(2) * self.return_df).sum(1)
plt.figure(figsize=[16, 10])
plt.plot(pnl_df.cumsum())
savfig_send(
subject=
f'{add_info}|{file_name[:-4]}|{self.sector_name}|{self.if_only_long}'
f'|{self.hold_time}|{bt.AZ_Sharpe_y(pnl_df)}')
def plot_send(con_id, begin_time, end_time, n=15):
data_df = fut_data.load_intra_data(con_id, ['Close'])['Close']
part_df = data_df.truncate(begin_time, end_time)
plt.figure(figsize=[80, 10])
plt.plot(range(len(part_df)), part_df.values)
plt.xticks([
int(len(part_df.index.strftime('%Y-%m-%d %H:%M')) / (n - 1)) * i
for i in range(n)
],
part_df.index.strftime('%Y-%m-%d %H:%M')[[[
int(len(part_df.index) / (n - 1)) * i for i in range(n)
]]],
rotation=45)
plt.grid()
savfig_send()
def CDF(raw_signal_df, raw_return_df, hold_time, title='CDF Figure', lag=2, zero_drop=False):
raw_signal_df = raw_signal_df.shift(lag).values
if zero_drop:
filter_mask = pd.notna(raw_signal_df) & (raw_signal_df != 0)
else:
filter_mask = pd.notna(raw_signal_df)
signal_df = raw_signal_df[filter_mask]
raw_return_df_sum = bt.AZ_Rolling_sum(raw_return_df, hold_time).shift(-hold_time + 1).values
return_df = raw_return_df_sum[filter_mask]
f_return_m = return_df - np.nanmean(return_df)
a = np.argsort(signal_df)
plt.figure(figsize=(10, 6))
p1 = plt.subplot(221)
p2 = plt.subplot(222)
p3 = plt.subplot(223)
p4 = plt.subplot(224)
p1.plot(np.cumsum(return_df[a]))
p1.set_title('cumsum return')
p1.grid(1)
p2.plot(signal_df[a], np.cumsum(return_df[a]))
p2.set_title('signal and cumsum return')
p2.grid(1)
p3.plot(np.cumsum(f_return_m[a]))
p3.set_title('cumsum mean return')
p3.grid(1)
p4.plot(signal_df[a], np.cumsum(f_return_m[a]))
p4.set_title('signal and cumsum mean return')
p4.grid(1)
plt.suptitle(title)
savfig_send(subject=title, text='')
if __name__ == '__main__':
root_path = '/mnt/mfs/DAT_FUT'
fut_data = FutData(root_path)
fut_name_list = FutClass['黑色']
ban_name_list = [
'WR', 'BB', 'ZC', 'SF', 'SM', 'FU', 'TA', 'SC', 'MA', 'OI', 'RS', 'IC'
]
data_df = main()
for x, part_data_df in data_df.groupby(['weekday']):
part_pnl = part_data_df['pnl'].fillna(0).values
print(x, part_pnl.sum())
plt.plot(part_pnl.cumsum())
savfig_send(subject=f'{x} {bt.AZ_Sharpe_y(part_pnl)}')
for x, part_data_df in data_df.groupby(['month']):
part_pnl = part_data_df['pnl'].fillna(0).values
print(x, part_pnl.sum())
plt.plot(part_pnl.cumsum())
savfig_send(subject=f'{x} {bt.AZ_Sharpe_y(part_pnl)}')
# for x, part_data_df in data_df.groupby(['weekday']):
# part_pnl = part_data_df['pnl'].fillna(0).values
# print(x, part_pnl.sum())
# plt.plot(part_pnl.cumsum())
# savfig_send(subject=f'{x} {bt.AZ_Sharpe_y(part_pnl)}')
#
# for x, part_data_df in data_df.groupby(['month']):
# part_pnl = part_data_df['pnl'].fillna(0).values
# print(x, part_pnl.sum())
window_list = [10, 20, 40, 100]
limit_list = [1, 1.5, 2]
for instrument in instrument_list:
# part_test_fun(instrument)
adj_close_df = FutData().load_act_adj_fut_data(instrument, 'Close', active_df, aadj_factor_df)
adj_high_df = FutData().load_act_adj_fut_data(instrument, 'High', active_df, aadj_factor_df)
adj_low_df = FutData().load_act_adj_fut_data(instrument, 'Low', active_df, aadj_factor_df)
adj_return_df = adj_close_df / adj_close_df.shift(1) - 1
month_signal = pd.DataFrame(adj_return_df.index.strftime('%m'), index=adj_return_df.index, columns=['month'])
for n in window_list:
raw_factor = FutIndex.boll_fun(adj_close_df, n)
for limit in limit_list:
signal = Signal.fun_1(raw_factor, limit)
pos = Position.fun_1(signal)
pnl_df = (pos.shift(2) * adj_return_df).fillna(0)
sp = bt.AZ_Sharpe_y(pnl_df)
pot = bt.AZ_Pot(pos, pnl_df.sum())
print(instrument, sp, pot, n, limit)
if abs(sp) > 1.4:
print('!!!!!!!!!!!!!!!!')
print(f'sum:', sum(pnl_df))
if abs(sp) > 0.7:
for x, y in month_signal.groupby(by=['month']):
print(x, round(sum(pnl_df.loc[y.index]), 5))
plt.plot(pnl_df.cumsum())
savfig_send('{}, {}, {}, {}, {}'.format(instrument, sp, pot, n, limit))
fut_name, path_name, file_name, sp_name, way = res
pos_df, pnl_df, data_df, result_df = test_fun(fut_name, path_name,
file_name)
pnl_sr = pnl_df[sp_name] * way
pos_sr = pos_df[sp_name] * way
pnl_sr.name = fut_name
pos_sr.name = fut_name
pnl_list.append(pnl_sr)
pos_list.append(pos_sr)
# 出厂价: 聚丙烯PP(T30S):齐鲁石化
plt.figure(figsize=[16, 10])
plt.plot(pnl_df.index, pnl_df[sp_name].cumsum())
plt.legend()
plt.grid()
savfig_send(
subject=
f"result {result_df.loc[sp_name]['sharpe']} {result_df.loc[sp_name]['pot']}"
)
pnl_sum = pd.concat(pnl_list, axis=1)
pos_concat = pd.concat(pos_list, axis=1)
pos_concat.index + timedelta(hours=14, minutes=50)
plt.figure(figsize=[16, 10])
pnl_cumsum = pnl_sum.mean(1).cumsum()
pnl_cumsum = pnl_cumsum.replace(0, np.nan).dropna()
print(bt.AZ_Sharpe_y(pnl_sum.mean(1)))
plt.plot(pnl_cumsum.index, pnl_cumsum.values)
plt.legend()
plt.grid()
savfig_send(subject='result')
cond2 = sig_rtn.apply(lambda x: 0 if abs(x) == 0 else (1 if x > 0 else 0))
signal = cond1 * cond2
pnl_df = signal.shift(1) * adj_r_01
asset_df = pnl_df.cumsum()
SignalAnalysis.CDF(sig_rtn * cond1,
adj_r_01,
hold_time=1,
title=f'{fut_name} CDF Figure',
lag=1,
zero_drop=True)
plt.figure(figsize=[16, 10])
plt.plot(asset_df.index, asset_df.values)
plt.legend()
plt.grid()
savfig_send(fut_name)
# Close = fut_data.load_fut_data(fut_name, 'Close')
# OpenInterest = fut_data.load_fut_data(fut_name, 'OpenInterest')
# def part_test_fun(instrument):
# adj_close_df = FutData().load_act_adj_fut_data(instrument, 'Close', active_df, aadj_factor_df)
# adj_high_df = FutData().load_act_adj_fut_data(instrument, 'High', active_df, aadj_factor_df)
# adj_low_df = FutData().load_act_adj_fut_data(instrument, 'Low', active_df, aadj_factor_df)
#
# adj_return_df = adj_close_df/adj_close_df.shift(1) - 1
#
# for n in window_list:
# raw_factor = FutIndex.boll_fun(adj_close_df, n)
# for limit in limit_list:
# signal = Signal.fun_1(raw_factor, limit)
# pos = Position.fun_1(signal)
'return_df'] = part_data['Close'] / part_data['Close'].shift(1) - 1
part_data['tmp_df'] = tmp_df.reindex(index=sorted(list(set(part_data.index) & set(tmp_df.index)))) \
.reindex(index=part_data.index)
part_data['pos_df_raw'] = tmp_df.reindex(index=sorted(list(set(part_data.index) & set(tmp_df.index)))) \
.replace(0, np.nan).reindex(index=part_data.index).fillna(method='ffill').reindex(index=part_data.index)
# part_data['pos_df_raw'] = tmp_df.reindex(index=part_data.index)\
# .replace(0, np.nan).reindex(index=part_data.index).fillna(method='ffill').reindex(index=part_data.index)
# part_data['pos_df_raw'] = part_data['tmp_df'].replace(0, np.nan).fillna(method='ffill')
part_data['pos_df'] = part_data['pos_df_raw'].reindex(
index=part_data.index).fillna(method='ffill')
part_data['pnl_df'] = part_data['pos_df'] * part_data['return_df']
daily_pnl = part_data.groupby(by=['Date'])['pnl_df'].sum()
daily_pnl.index = pd.to_datetime(daily_pnl.index)
sp = bt.AZ_Sharpe_y(daily_pnl)
pot = part_data['pnl_df'].sum() / part_data['pos_df'].diff().abs().sum(
) * 10000
plt.figure(figsize=[16, 10])
plt.plot(daily_pnl.cumsum())
plt.xticks(rotation=45)
plt.grid()
savfig_send()
def test_fun(fut_name, CCI_window, CCI_limit, hold_time, cut_num):
result_list = []
pool = Pool(20)
for con_id, part_info_df in active_df[[f'{fut_name}01'
]].groupby(f'{fut_name}01'):
active_begin = fut_data.last_trade_date(
part_info_df.index[0]) + timedelta(hours=17)
active_end = part_info_df.index[-1] + timedelta(hours=17)
args = [
con_id, active_begin, active_end, CCI_window, CCI_limit, hold_time,
cut_num
]
# part_test(*args)
# print(part_info_df.index[0], part_info_df.index[-1])
result_list.append(pool.apply_async(part_test, args=args))
pool.close()
pool.join()
pnl_df = pd.concat([res.get()[0] for res in result_list], axis=0)
turnover_df = pd.concat([res.get()[1] for res in result_list], axis=0)
data_df = pd.concat([res.get()[2] for res in result_list], axis=0)
pot = pnl_df.sum() / turnover_df.sum() * 10000
sp = bt.AZ_Sharpe_y(pnl_df)
# for x, part_data_df in data_df.groupby(['weekday']):
# part_pnl = part_data_df['pnl'].fillna(0).values
# print(x, part_pnl.sum())
# plt.plot(part_pnl.cumsum())
# savfig_send(subject=f'{x} {bt.AZ_Sharpe_y(part_pnl)}')
#
# for x, part_data_df in data_df.groupby(['month']):
# part_pnl = part_data_df['pnl'].fillna(0).values
# print(x, part_pnl.sum())
# plt.plot(part_pnl.cumsum())
# savfig_send(subject=f'{x} {bt.AZ_Sharpe_y(part_pnl)}')
print(fut_name, sp, pot, CCI_window, CCI_limit, hold_time, cut_num)
if abs(sp) > 1. and abs(pot) > 10:
plt.figure(figsize=[16, 8])
pnl_df.index = pd.to_datetime(pnl_df.index)
plt.plot(pnl_df.cumsum())
plt.grid()
savfig_send(
f'{fut_name} sp:{sp} pot={pot} CCI_window:{CCI_window}, CCI_limit:{CCI_limit}, cut_num={cut_num}'
)
part_data_df = data_df
col_name = 'Time'
raw_return_df = part_data_df['pnl']
signal_df = part_data_df[col_name].shift(2).replace(np.nan, '00:00')
SignalAnalysis.CDF_c(signal_df,
raw_return_df,
hold_time=1,
title=f'{fut_name} {col_name} CDF Figure',
lag=0)
ana_fun(data_df, fut_name, 'test_score')
ana_fun(data_df, fut_name, 'boll_score')
ana_fun(data_df, fut_name, 'CCI_score')
ana_fun(data_df, fut_name, 'OpenInterest_core')
ana_fun(data_df, fut_name, 'Volume_zscore')
ana_fun(data_df, fut_name, 'past_min_pct_change')
ana_fun(data_df, fut_name, 'trend_indicator')
ana_fun(data_df, fut_name, 'macd')
ana_fun(data_df, fut_name, 'RSI')
ana_fun(data_df, fut_name, 'obv')
ana_fun(data_df, fut_name, 'atr')
ana_fun(data_df, fut_name, 'adx')
ana_fun(data_df, fut_name, 'trix')
ana_fun(data_df, fut_name, 'willr')
ana_fun(data_df, fut_name, 'Vol_OI')
return data_df
def part_test(
con_id,
begin_time,
end_time,
# p_window, p_limit,
# v_window, v_limit,
# voli_window, voli_limit,
CCI_window,
CCI_limit,
# hold_time,
cut_num):
# print(con_id, begin_time, end_time)
try:
# print(con_id, begin_time, end_time)
all_min_df = fut_data.load_intra_data(con_id, ['Close'])
data_df = fut_data.load_intra_reshape_data(
con_id, ['High', 'Low', 'Close', 'Volume', 'OpenInterest'],
cut_num=cut_num)
if con_id == 'J1501.DCE':
print(1)
# begin_time = pd.to_datetime('20190101')
# # end_time = begin_time + timedelta(1)
# end_time = pd.to_datetime('20190401')
# p_window = 1
# p_limit = 1
# v_window = 20
# v_limit = 2
# part_data_df = data_df.truncate(before=begin_time-timedelta(20), after=end_time)
part_data_df = data_df.truncate(before=begin_time, after=end_time)
part_data_df['OpenInterest_core'] = FutIndex.boll_fun(
data_df['OpenInterest'], 100)
part_data_df['weekday'] = pd.to_datetime(
part_data_df['Date']).dt.weekday
part_data_df['weekday_pos'] = (
(part_data_df['weekday'] != 3)
# & (part_data_df['weekday'] != 3)
# & (part_data_df['weekday'] != 3)
# (part_data_df['weekday'] != 4)
).astype(int)
part_data_df['month'] = part_data_df['Date'].str.slice(5, 7)
# part_data_df['month_pos'] = ((part_data_df['month'] != '10') & (part_data_df['month'] != '12')).astype(int)
part_data_df['month_pos'] = (part_data_df['month'] != '1').astype(int)
# part_data_df['time_pos_cut'] = part_data_df.apply(lambda x: -1 if (((x['Time'] > '14:51')
# & (x['Time'] <= '15:00')
# # | (x['Time'] > '21:00')
# # & (x['Time'] <= '22:00')
# # | (x['Time'] > '21:00')
# # & (x['Time'] <= '22:00')
# )) else 1, axis=1)
part_data_df[
'Vol_OI'] = part_data_df['Volume'] / part_data_df['OpenInterest']
part_data_df['Vol_OI_pos'] = (part_data_df['Vol_OI'] < 0.4).astype(int)
part_data_df['Volume_boll'] = FutIndex.boll_fun(
part_data_df[['Volume']], CCI_window)
part_data_df['past_roll_Volume'] = bt.AZ_Rolling_mean(
part_data_df[['Volume']], CCI_window)
v_window = 60
part_data_df['Volume_zscore'] = bt.AZ_Col_zscore(
part_data_df[['Volume']], CCI_window)
part_data_df['Volume_signal'] = Signal.fun_1(
part_data_df['Volume_zscore'], 0.01)
# part_data_df['Volume_signal'] = (part_data_df['Volume_zscore'] < 2).astype(int).replace(0, -1)
p_window = 5
# part_data_df['past_min_pct_change'] = (part_data_df['Close'] - part_data_df['Close'].shift(p_window)) \
# / part_data_df['Close'].shift(p_window)
part_data_df['past_min_pct_change'] = (
part_data_df['Close'] / part_data_df['Close'].shift(p_window) - 1)
part_data_df['past_min_pct_signal'] = part_data_df['past_min_pct_change'] \
.apply(lambda x: 0 if abs(x) < 0.004 else (1 if x > 0.004 else -1))
test_window = CCI_window
macd, macdsignal, macdhist = ta.MACD(part_data_df['Close'], 12, 26, 9)
part_data_df['macd'] = macd
part_data_df['macd_pos'] = (macd < 25).astype(int)
RSI = ta.RSI(part_data_df['Close'], test_window)
RSI = RSI - 50
RSI[RSI > 20] = 20
RSI[RSI < -20] = -20
part_data_df['RSI'] = RSI
part_data_df['RSI_signal'] = Signal.fun_1(part_data_df['RSI'], 1)
part_data_df['RSI_pos'] = Position.fun_1(part_data_df['RSI_signal'],
limit=60)
# aroondown, aroonup = ta.AROON(part_data_df['High'], part_data_df['Low'], test_window)
obv = ta.OBV(part_data_df['Close'], part_data_df['Volume'])
part_data_df['obv'] = obv
atr = ta.ATR(part_data_df['High'], part_data_df['Low'],
part_data_df['Close'], test_window)
part_data_df['atr'] = atr
part_data_df['adr_pos'] = (atr < 17).astype(int)
adx = ta.ADX(part_data_df['High'], part_data_df['Low'],
part_data_df['Close'], test_window)
part_data_df['adx'] = adx
trix = ta.TRIX(part_data_df['Close'], 60)
part_data_df['trix'] = trix
willr = ta.WILLR(part_data_df['High'], part_data_df['Low'],
part_data_df['Close'], test_window)
part_data_df['willr'] = willr
part_data_df['CCI_score'] = FutIndex.CCI_fun(part_data_df['High'],
part_data_df['Low'],
part_data_df['Close'],
CCI_window)
part_data_df['CCI_signal'] = Signal.fun_1(part_data_df['CCI_score'],
CCI_limit)
part_data_df['CCI_pos'] = Position.fun_1(part_data_df['CCI_signal'])
part_data_df['boll_score'], ma_n, md_n = FutIndex.boll_fun(
part_data_df['Close'], CCI_window, return_line=True)
part_data_df['boll_signal'] = Signal.fun_1(part_data_df['boll_score'],
CCI_limit)
part_data_df['boll_pos'] = Position.fun_1(part_data_df['boll_signal'])
# part_data_df['boll_pos'] = Position.fun_3(part_data_df['boll_signal'], part_data_df['past_min_pct_signal'])
part_data_df['test_score'] = FutIndex.test_fun(part_data_df['Close'],
CCI_window,
cap=5,
num=3,
return_line=False)
part_data_df['test_signal'] = Signal.fun_1(part_data_df['test_score'],
CCI_limit)
part_data_df['test_pos'] = Position.fun_1(part_data_df['test_signal'])
# part_data_df['trend_signal'] = bt.AZ_Rolling(part_data_df['Close'], 500).std()
# part_data_df['trend_pos'] = (part_data_df['trend_signal'] < 40).astype(int)
part_data_df['trend_indicator'] = bt.AZ_Rolling(part_data_df['Close'], 100). \
apply(lambda x: (x[-1] / x[0] - 1) / (max(x) / min(x) - 1), raw=False)
# part_data_df['trend_pos'] = (part_data_df['trend_indicator'] < 0.5).astype(int)
# part_data_df['trend_pos'] = (part_data_df['trend_indicator'].abs() > 0.25).astype(int)\
# .replace(0, np.nan).fillna(method='ffill', limit=1).fillna(0)
part_data_df['trend_pos'] = (part_data_df['trend_indicator'].abs() >
0.25).astype(int)
# part_data_df['position'] = part_data_df['boll_pos'] * part_data_df['weekday_pos'] * part_data_df['month_pos']
# part_data_df['position'] = part_data_df['CCI_pos']
# mul_fun(part_data_df['boll_pos'], part_data_df['CCI_pos'])
part_data_df['signal'] = part_data_df[
'boll_signal'] # * part_data_df['macd_pos']
part_data_df['position'] = Position.fun_1(part_data_df['signal']) * part_data_df['adr_pos'] \
* part_data_df['trend_pos'] * part_data_df['Vol_OI_pos'] * part_data_df['macd_pos']
part_data_df['position_exe'] = part_data_df['position'].shift(1)
part_data_df['position_sft'] = part_data_df['position'].shift(2)
# part_data_df['price_return'] = part_data_df['Close'] - part_data_df['Close'].shift(1)
next_trade_close = all_min_df['Close'].shift(-2).reindex(
part_data_df.index)
part_data_df['next_trade_close'] = next_trade_close
# next_trade_close.iloc[-1] = all_min_df['Close'].iloc[-1]
part_data_df['next_trade_close'] = next_trade_close
part_data_df['price_return'] = part_data_df['next_trade_close'] - \
part_data_df['next_trade_close'].shift(1)
# part_data_df['price_return_sum'] = bt.AZ_Rolling(part_data_df['price_return'], hold_time).sum() \
# .shift(-hold_time + 1)
# part_data_df['pnl'] = part_data_df['position_sft'] * part_data_df['price_return']
part_data_df['pnl'] = part_data_df['position_exe'] * part_data_df[
'price_return']
# part_data_df['pnl_test'] = part_data_df['signal'] * part_data_df['price_return_sum'].shift(-2)
part_data_df['turnover'] = (part_data_df['position_sft'] - part_data_df['position_sft'].shift(1)) \
* part_data_df['Close']
# part_data_df = part_data_df.truncate(before=begin_time)
part_data_df['asset'] = part_data_df['pnl'].cumsum()
part_data_df['con_id'] = con_id
part_pnl_df = part_data_df.groupby('Date')['pnl'].sum()
part_turnover = part_data_df.groupby('Date')['turnover'].apply(
lambda x: sum(abs(x)))
# 剔除开盘收盘5min的signal
# if '1910' in con_id:
plt.figure(figsize=[64, 64])
ax1 = plt.subplot(4, 1, 1)
ax2 = plt.subplot(4, 1, 2)
ax3 = plt.subplot(4, 1, 3)
ax1.plot(part_data_df['asset'].values)
ax2.plot(part_data_df['Close'].values, '--', color='#75bbfd')
ax2.scatter(np.array(range(len(
part_data_df.index)))[(part_data_df['position_sft'] > 0)],
part_data_df['Close'][part_data_df['position_sft'] > 0],
s=0.5,
color='red')
ax2.scatter(np.array(range(len(
part_data_df.index)))[(part_data_df['position_sft'] == 0)],
part_data_df['Close'][part_data_df['position_sft'] == 0],
s=0.5,
color='black')
ax2.scatter(np.array(range(len(
part_data_df.index)))[(part_data_df['position_sft'] < 0)],
part_data_df['Close'][part_data_df['position_sft'] < 0],
s=0.5,
color='blue')
# ax2.scatter(np.array(range(len(part_data_df.index)))[(part_data_df['past_min_pct_signal'] > 0)],
# part_data_df['Close'][part_data_df['past_min_pct_signal'] > 0], s=20, color='y')
# ax2.scatter(np.array(range(len(part_data_df.index)))[(part_data_df['past_min_pct_signal'] < 0)],
# part_data_df['Close'][part_data_df['past_min_pct_signal'] < 0], s=20, color='#f504c9')
ax3.bar(range(len(part_data_df.index)), part_data_df['Volume'].values)
ax1.grid()
ax2.grid()
ax3.grid()
plt.title(con_id)
savfig_send(con_id)
return part_pnl_df, part_turnover, part_data_df
except Exception as error:
print(error)
return pd.Series(), pd.Series(), pd.Series()
print(b - a)
# target_dict
vol_signal = bt.AZ_Rolling(return_signal, n=20).std()
vol_end_end = bt.AZ_Rolling(return_end_end, n=20).std()
factor_1 = return_signal / vol_signal
factor_1_m = factor_1.sub(factor_1.mean(1), axis=0)
factor_2 = return_end_end / vol_end_end
factor_2_m = factor_2.sub(factor_2.mean(1), axis=0)
weight_pos_df_1 = factor_1_m
weight_pos_df_2 = factor_2_m
pnl_df_1 = (weight_pos_df_1.shift(1) * return_end_end).sum(1)
pnl_df_2 = (weight_pos_df_2.shift(1) * return_end_end).sum(1)
pot_1 = pnl_df_1.sum() / weight_pos_df_1.diff().abs().sum().sum(
) * 10000
pot_2 = pnl_df_2.sum() / weight_pos_df_2.diff().abs().sum().sum(
) * 10000
plt.plot(pnl_df_1.cumsum().values, label=round(pot_1, 4))
plt.plot(pnl_df_2.cumsum().values, label=round(pot_2, 4))
plt.legend()
savfig_send(
subject=
f'test_1 , {begin_p}, {end_p}, {trade_p} pot_1:{pot_1}, pot_2:{pot_2}'
)
def part_test(con_id, begin_time, end_time, CCI_window, CCI_limit):
try:
data_df = fut_data.load_intra_data(con_id,
['High', 'Low', 'Close', 'Volume'])
part_data_df = data_df.truncate(before=begin_time, after=end_time)
part_data_df['weekday'] = pd.to_datetime(
part_data_df['Date']).dt.weekday
part_data_df['weekday_pos'] = (
(part_data_df['weekday'] != 2)
& (part_data_df['weekday'] != 1)
# & (part_data_df['weekday'] != 3)
# (part_data_df['weekday'] != 4)
).astype(int).shift(-2)
part_data_df['boll_score'] = FutIndex.boll_fun(part_data_df['Close'],
CCI_window)
part_data_df['boll_signal'] = Signal.fun_1(part_data_df['boll_score'],
CCI_limit)
part_data_df['boll_pos'] = Position.fun_1(part_data_df['boll_signal'])
part_data_df['trend_signal'] = bt.AZ_Rolling(part_data_df['Close'],
500).std()
part_data_df['trend_pos'] = (part_data_df['trend_signal'] <
20).astype(int)
part_data_df['position'] = part_data_df['boll_pos'] * part_data_df[
'trend_pos'] * part_data_df['weekday_pos']
part_data_df['position_exe'] = part_data_df['position'].shift(
1).fillna(0)
part_data_df['position_sft'] = part_data_df['position'].shift(
2).fillna(0)
part_data_df['price_return'] = part_data_df['Close'] / part_data_df[
'Close'].shift(1) - 1
part_data_df['pnl'] = part_data_df['position_sft'] * part_data_df[
'price_return']
part_data_df['asset'] = part_data_df['pnl'].cumsum()
part_data_df['turnover'] = (part_data_df['position_sft'] -
part_data_df['position_sft'].shift(1))
part_data_df['con_id'] = con_id
part_pnl_df = part_data_df.groupby('Date')['pnl'].sum()
part_turnover = part_data_df.groupby('Date')['turnover'].apply(
lambda x: sum(abs(x)))
# 剔除开盘收盘5min的signal
plt.figure(figsize=[64, 64])
ax1 = plt.subplot(4, 1, 1)
ax2 = plt.subplot(4, 1, 2)
ax3 = plt.subplot(4, 1, 3)
ax1.plot(part_data_df['asset'].values)
# ax2.plot(part_data_df['Close'].values, '--', color='#75bbfd')
ax2.scatter(np.array(range(len(
part_data_df.index)))[(part_data_df['position_sft'] > 0)],
part_data_df['Close'][part_data_df['position_sft'] > 0],
s=0.5,
color='red')
ax2.scatter(np.array(range(len(
part_data_df.index)))[(part_data_df['position_sft'] == 0)],
part_data_df['Close'][part_data_df['position_sft'] == 0],
s=0.5,
color='black')
ax2.scatter(np.array(range(len(
part_data_df.index)))[(part_data_df['position_sft'] < 0)],
part_data_df['Close'][part_data_df['position_sft'] < 0],
s=0.5,
color='blue')
# ax2.scatter(np.array(range(len(part_data_df.index)))[(part_data_df['past_min_pct_signal'] > 0)],
# part_data_df['Close'][part_data_df['past_min_pct_signal'] > 0], s=20, color='black')
# ax2.scatter(np.array(range(len(part_data_df.index)))[(part_data_df['past_min_pct_signal'] < 0)],
# part_data_df['Close'][part_data_df['past_min_pct_signal'] < 0], s=20, color='y')
ax3.bar(range(len(part_data_df.index)), part_data_df['Volume'].values)
ax1.grid()
ax2.grid()
ax3.grid()
plt.title(con_id)
savfig_send(con_id)
return part_pnl_df, part_turnover, part_data_df
except Exception as error:
print(error)
return None
