In [1]:
import pandas as pd
import numpy as np
import tqdm
import gc
import matplotlib.pyplot as plt
import talib as ta
import datetime as dt
import statsmodels.api as sm
pd.set_option('display.max_rows', 16)
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, f1_score
from sklearn.model_selection import GridSearchCV
In [2]:
plt.rcParams['figure.figsize'] = (16.0, 9.0)
Data¶
In [3]:
START = '20070101'
END = '20241231'
In [4]:
# Security Id
stk_info = DataAPI.SecIDGet(assetClass="E",pandas="1")
cond1 = (stk_info['exchangeCD'] == 'XSHE') | (stk_info['exchangeCD'] == 'XSHG')
cond2 = (stk_info['listStatusCD'] == 'L') | (stk_info['listStatusCD'] == 'DE')
cond3 = stk_info['transCurrCD']=='CNY'
stk_info = stk_info[cond1 & cond2 & cond3].copy()
stk_id = stk_info['secID']
# ST
st_df = DataAPI.SecSTGet(beginDate=START,endDate=END,secID=stk_id,field=['secID','tradeDate','STflg'],pandas="1")
st_df['tradeDate'] = pd.to_datetime(st_df['tradeDate'],format="%Y-%m-%d")
In [5]:
st_df
Out[5]:
In [6]:
# %%time
# # About 8 mins
# # # 从优矿下载股票信息，时间较长。由于优矿的限制，每次下载3年的数据
# stk_dict = {}
# begin_ = dt.datetime.strptime(START, '%Y%m%d').year
# end_ = dt.datetime.strptime(START, '%Y%m%d').year+3
# field = ["secID","tradeDate",'preClosePrice',"closePrice",'openPrice','highestPrice','lowestPrice',"negMarketValue","turnoverValue",'turnoverVol']
# while begin_ <= 2024:
# if begin_ == 2024:
# yesterday = dt.datetime.today() - dt.timedelta(days=1)
# yesterday.strftime('%Y%m%d')
# stk_dict[begin_] = DataAPI.MktEqudAdjAfGet(secID=stk_id,
# beginDate=f'{begin_}0101',
# endDate=yesterday,
# field=field,pandas="1")
# else:
# stk_dict[begin_] = DataAPI.MktEqudAdjAfGet(secID=stk_id,
# beginDate=f'{begin_}0101',
# endDate=f'{end_}1231',
# field=field,pandas="1")
# begin_ = end_ + 1
# end_ = begin_ + 3
# for i in range(len(stk_dict)):
# stk_df = pd.DataFrame(np.vstack([_df for _df in stk_dict.values()]),columns=field)
# stk_df.to_pickle('./data/stk_df.pkl')
In [7]:
# %%time
# stk_df = DataAPI.MktEqudAdjAfGet(secID=stk_id,beginDate=START,endDate=END,isOpen=1,
# field=["secID","tradeDate",
# 'preClosePrice',"closePrice",
# 'openPrice','highestPrice','lowestPrice',
# "negMarketValue",
# "turnoverValue",'turnoverVol'],pandas="1")
# stk_df.to_pickle('./data/stk_df.pkl')
# # Takes about 6 mins
In [8]:
stk_df = pd.read_pickle('./data/stk_df.pkl')
In [9]:
stk_df.info()
In [10]:
for col in stk_df.columns.drop(['secID','tradeDate']).tolist():
stk_df[col] = pd.to_numeric(stk_df[col])
In [11]:
stk_df['tradeDate'] = pd.to_datetime(stk_df['tradeDate'], format='%Y-%m-%d')
stk_df.sort_values(['secID','tradeDate'],inplace=True)
# drop ST stocks
print(stk_df.shape)
stk_df = pd.merge(stk_df, st_df, on=['secID','tradeDate'],how='left')
stk_df = stk_df[stk_df['STflg'].isna()].copy()
stk_df.drop('STflg',axis=1,inplace=True)
print(stk_df.shape)
In [12]:
stk_df.info()
不填充停牌值比较合理，因为技术分析只看量价，直接计算量价关系较为合适
In [13]:
random_stkid = np.random.choice(stk_df['secID'].unique(),1000)
stk_df = stk_df[stk_df['secID'].isin(random_stkid)].copy()
In [14]:
stk_df.drop(stk_df.loc[stk_df['openPrice']==0].index,inplace=True)
In [15]:
stk_df['open_ret'] = stk_df.groupby('secID')['openPrice'].apply(lambda x: x / x.shift() - 1)
stk_df['close_ret'] = stk_df['closePrice']/stk_df['preClosePrice'] - 1
In [16]:
def rule_return(df, demean=True, open_ret=True):
"""
df should contain these columns:
signal: the signal generated by the rule
close_ret: return calculated by close price
open_ret: return calculated by open price
close_ret_demean is demeaned return of close_ret, i.e. close_ret - close_ret.mean.
open_ret_demean is similarly defined. The use of demeaned return series is to adjust the
bias created by bullish or bearish markets.
"""
df['close_ret_demean'] = df['close_ret'] - df['close_ret'].mean()
df['open_ret_demean'] = df['open_ret'] - df['open_ret'].mean()
df['position_close'] = df['signal']
df['position_open'] = df['signal'].shift()
df['position_close_ret'] = df['position_close'].shift() * df['close_ret']
df['position_open_ret'] = df['position_open'].shift() * df['open_ret']
df['position_close_ret_demean'] = df['position_close'].shift() * df['close_ret_demean']
df['position_open_ret_demean'] = df['position_open'].shift() * df['open_ret_demean']
df['close_cumret'] = (df['position_close_ret']+1).cumprod()
df['open_cumret'] = (df['position_open_ret']+1).cumprod()
if open_ret:
if demean:
return pd.DataFrame({'position_open_ret_demean':df['position_open_ret_demean'].values,
'open_cumret':df['open_cumret'].values})
else:
return pd.DataFrame({'position_open_ret':df['position_open_ret'].values,
'open_cumret':df['open_cumret'].values})
else:
if demean:
return pd.DataFrame({'position_close_ret_demean':df['position_close_ret_demean'].values,
'close_cumret':df['close_cumret'].values})
else:
return pd.DataFrame({'position_close_ret':df['position_close_ret'].values,
'close_cumret':df['close_cumret'].values})
A bunch of TA signals¶
In [17]:
# EMA
stk_df['EMA'] = stk_df.groupby('secID')['closePrice'].apply(ta.EMA, 20)
stk_df['EM_signal'] = np.where(stk_df['closePrice']>stk_df['EMA'],1,np.nan)
stk_df.loc[stk_df['closePrice']<=stk_df['EMA'],'EM_signal'] = 0
stk_df['EM_signal'] = stk_df.groupby('secID')['EM_signal'].fillna(method='ffill')
In [18]:
stk_df['EM_signal'].value_counts()
Out[18]:
In [19]:
# MACD
stk_df['MACD'] = stk_df.groupby('secID')['closePrice'].apply(lambda x: ta.MACD(x)[0])
stk_df['MACD_rawsignal'] = stk_df.groupby('secID')['closePrice'].apply(lambda x: ta.MACD(x)[1])
stk_df['MACD_signal'] = np.where(stk_df['MACD']>stk_df['MACD_rawsignal'],1,np.nan)
stk_df.loc[stk_df['MACD']<=stk_df['MACD_rawsignal'],'MACD_signal'] = 0
stk_df['MACD_signal'] = stk_df.groupby('secID')['MACD_signal'].fillna(method='ffill')
In [20]:
stk_df['MACD_signal'].value_counts()
Out[20]:
In [21]:
# # Example
# temp = stk_df[stk_df['secID']=='900957.XSHG'].copy()
# ta.OBV(temp['closePrice'],temp['turnoverValue'])
# stk_df.loc[9968491:]
In [22]:
# OBV
stk_df['OBV'] = stk_df.groupby('secID')[['closePrice','turnoverVol']].apply(lambda x: ta.OBV(real=x['closePrice'],volume=x['turnoverVol']).to_frame('OBV')).values
stk_df.groupby('secID')['OBV'].apply(lambda x: x/x.shift()-1)
stk_df['OBV_change'] = stk_df.groupby('secID')['OBV'].apply(lambda x: x/x.shift()-1)
buy1_OBV = (stk_df['close_ret']<0)&(stk_df['OBV_change']>0)
buy2_OBV = (stk_df['close_ret']>0)&(stk_df['OBV_change']>0)
sell1_OBV = (stk_df['close_ret']>0)&(stk_df['OBV_change']<0)
sell2_OBV = (stk_df['close_ret']<0)&(stk_df['OBV_change']<0)
stk_df['OBV_signal'] = 0
stk_df.loc[buy1_OBV | buy2_OBV,'OBV_signal']=1
In [23]:
stk_df['OBV_signal'].value_counts()
Out[23]:
In [24]:
# AROON
N = 26
high_threshold = 70 # 强趋势
low_threshold = 30 # 弱趋势
stk_df['AROON_up'] = stk_df.groupby('secID')[['highestPrice','lowestPrice']].apply(lambda x:ta.AROON(high=x['highestPrice'],low=x['lowestPrice'])[0].to_frame('AROON_up')).values
stk_df['AROON_down'] = stk_df.groupby('secID')[['highestPrice','lowestPrice']].apply(lambda x:ta.AROON(high=x['highestPrice'],low=x['lowestPrice'])[1].to_frame('AROON_down')).values
buy_AROON = (stk_df['AROON_up']>high_threshold)&(stk_df['AROON_down']<low_threshold)
sell_AROON = (stk_df['AROON_down']>high_threshold)&(stk_df['AROON_up']<low_threshold)
stk_df['AROON_signal'] = np.where(buy_AROON,1,np.nan)
stk_df.loc[sell_AROON,'AROON_signal'] = 0
stk_df['AROON_signal'] = stk_df.groupby('secID')['AROON_signal'].fillna(method='ffill')
In [25]:
stk_df['AROON_signal'].value_counts()
Out[25]:
In [26]:
# BOLL
stk_df['BOLL_up'] = stk_df.groupby('secID')[['closePrice']].apply(lambda x:ta.BBANDS(real=x['closePrice'])[0].to_frame('BOLL_up')).values
stk_df['BOLL_mid'] = stk_df.groupby('secID')[['closePrice']].apply(lambda x:ta.BBANDS(real=x['closePrice'])[1].to_frame('BOLL_mid')).values
stk_df['BOLL_low'] = stk_df.groupby('secID')[['closePrice']].apply(lambda x:ta.BBANDS(real=x['closePrice'])[2].to_frame('BOLL_low')).values
stk_df['BOLL_up_lag'] = stk_df.groupby('secID')['BOLL_up'].shift()
stk_df['BOLL_mid_lag'] = stk_df.groupby('secID')['BOLL_mid'].shift()
stk_df['BOLL_low_lag'] = stk_df.groupby('secID')['BOLL_low'].shift()
buy_BOLL = (stk_df['preClosePrice'] < stk_df['BOLL_up_lag'])&(stk_df['closePrice']>stk_df['BOLL_up'])
sell_BOLL = (stk_df['preClosePrice'] > stk_df['BOLL_mid_lag'])&(stk_df['closePrice']<stk_df['BOLL_mid'])
stk_df['BOLL_signal'] = np.where(buy_BOLL, 1, np.nan)
stk_df.loc[sell_BOLL,'BOLL_signal'] = 0
stk_df['BOLL_signal'] = stk_df.groupby('secID')['BOLL_signal'].fillna(method='ffill')
In [27]:
stk_df['BOLL_signal'].value_counts()
Out[27]:
In [28]:
# CCI
buy_threshold = -100 # 买入阈值
sell_threshold = 100 # 卖出阈值
stk_df['CCI'] = stk_df.groupby('secID')[['highestPrice','lowestPrice','closePrice']].apply(lambda x:ta.CCI(high=x['highestPrice'],low=x['lowestPrice'],close=x['closePrice']).to_frame('CCI')).values
In [29]:
buy_CCI = stk_df['CCI']<buy_threshold
sell_CCI = stk_df['CCI']>sell_threshold
stk_df['CCI_signal'] = np.where(buy_CCI,1,np.nan)
stk_df.loc[sell_CCI,'CCI_signal'] = 0
stk_df['CCI_signal'] = stk_df.groupby('secID')['CCI_signal'].fillna(method='ffill')
In [30]:
stk_df['CCI_signal'].value_counts()
Out[30]:
In [31]:
# CMO
buy_threshold = -50 # 买入阈值
sell_threshold = 50
stk_df['CMO'] = stk_df.groupby('secID')['closePrice'].apply(ta.CMO)
In [32]:
buy_CMO = stk_df['CMO'] < buy_threshold
sell_CMO = stk_df['CMO'] > sell_threshold
stk_df['CMO_signal'] = np.where(buy_CMO, 1, np.nan)
stk_df.loc[sell_CMO,'CMO_signal'] = 0
stk_df['CMO_signal'] = stk_df.groupby('secID')['CMO_signal'].fillna(method='ffill')
In [33]:
stk_df['CMO_signal'].value_counts()
Out[33]:
In [34]:
gc.collect()
Out[34]:
In [35]:
# DMI
stk_df['plus_DI'] = stk_df.groupby('secID')[['highestPrice','lowestPrice','closePrice']].apply(lambda x: ta.PLUS_DI(high=x['highestPrice'], low=x['lowestPrice'], close=x['closePrice']).to_frame()).values
stk_df['minus_DI'] = stk_df.groupby('secID')[['highestPrice','lowestPrice','closePrice']].apply(lambda x: ta.MINUS_DI(high=x['highestPrice'], low=x['lowestPrice'], close=x['closePrice']).to_frame()).values
stk_df['ADX'] = stk_df.groupby('secID')[['highestPrice','lowestPrice','closePrice']].apply(lambda x: ta.ADX(high=x['highestPrice'], low=x['lowestPrice'], close=x['closePrice']).to_frame()).values
In [36]:
buy_threshold = 50
sell_threshold = 20
buy_DMI = (stk_df['ADX']>buy_threshold)&(stk_df['plus_DI']>stk_df['minus_DI'])
sell_DMI = (stk_df['ADX']<sell_threshold)|(stk_df['plus_DI']<stk_df['minus_DI'])
stk_df['DMI_signal'] = np.where(buy_DMI,1,np.nan)
stk_df.loc[sell_DMI,'DMI_signal'] = 0
stk_df['DMI_signal'] = stk_df.groupby('secID')['DMI_signal'].fillna(method='ffill')
In [37]:
stk_df['DMI_signal'].value_counts()
Out[37]:
In [38]:
# MFI
stk_df['MFI'] = stk_df.groupby('secID')[['highestPrice','lowestPrice','closePrice','turnoverVol']].apply(lambda x:ta.MFI(high=x['highestPrice'],low=x['lowestPrice'],close=x['closePrice'],volume=x['turnoverVol']).to_frame()).values
In [39]:
buy_threshold = 20
sell_threshold = 80
buy_MFI = stk_df['MFI']<buy_threshold
sell_MFI = stk_df['MFI']>sell_threshold
stk_df['MFI_signal'] = np.where(buy_MFI,1,np.nan)
stk_df.loc[sell_MFI,'MFI_signal'] = 0
stk_df['MFI_signal'] = stk_df.groupby('secID')['MFI_signal'].fillna(method='ffill')
In [40]:
stk_df['MFI_signal'].value_counts()
Out[40]:
In [41]:
# RSI
stk_df['RSI'] = stk_df.groupby('secID')['closePrice'].apply(ta.RSI)
buy_threshold = 30
sell_threshold = 70
buy_RSI = stk_df['RSI'] < buy_threshold
sell_RSI = stk_df['RSI'] > sell_threshold
stk_df['RSI_signal'] = np.where(buy_RSI,1,np.nan)
stk_df.loc[sell_RSI,'RSI_signal'] = 0
stk_df['RSI_signal'] = stk_df.groupby('secID')['RSI_signal'].fillna(method='ffill')
In [42]:
# %%time
# WVAD
# def wvad(df):
# return sum((df[:,0] - df[:,1]) / (df[:,2] - df[:,3]) * df[:,4])
# stk_df.groupby('secID')[['closePrice','openPrice','highestPrice',
# 'lowestPrice','turnoverVol']].apply(lambda x: x.rolling(24).apply(wvad,raw=False))
####### The above code is not working ##########
# temp = stk_df[stk_df['secID'].isin(np.random.choice(stk_df['secID'].unique(),10))].copy()
# def wvad(closePrice):
# close = closePrice
# open_ = stk_df.loc[closePrice.index, 'openPrice'].to_numpy()
# high = stk_df.loc[closePrice.index, 'highestPrice'].to_numpy()
# low = stk_df.loc[closePrice.index, 'lowestPrice'].to_numpy()
# volume = stk_df.loc[closePrice.index, 'turnoverVol'].to_numpy()
# return sum((closePrice - open_) / (high - low) * volume)
# temp2 = temp.groupby('secID')['closePrice'].rolling(24).apply(wvad, raw=False)
In [43]:
stk_df.reset_index(inplace=True, drop=True)
In [44]:
cols = ['secID','tradeDate','open_ret'] + [col for col in stk_df.columns if col[-6:]=='signal']
ret_df = stk_df[cols].copy()
ret_df['signal_date'] = ret_df['tradeDate']
ret_df[['tradeDate','open_ret']] = ret_df.groupby('secID')[['tradeDate','open_ret']].shift(-2)
ret_df.dropna(inplace=True)
ret_df.drop('MACD_rawsignal',axis=1,inplace=True)
ret_df['ret_sign'] = np.where(ret_df['open_ret']>0,1,-1)
ret_df
Out[44]:
In [45]:
ret_df.sort_values('tradeDate',inplace=True)
ret_df.reset_index(inplace=True,drop=True)
In [46]:
ret_df
Out[46]:
Random Forest¶
Train, test split¶
In [47]:
ret_df['year'] = ret_df['tradeDate'].dt.year
In [48]:
time_idx = [value for (key, value) in sorted(ret_df.groupby('year').groups.items())]
In [54]:
ret_df
Out[54]:
In [49]:
def list_flat(list_):
return [item for sublist in list_ for item in sublist]
# This is the same as:
# def list_flat2(list_):
# result = []
# for sublist in list_:
# for item in sublist:
# result.append(item)
# return result
In [50]:
list_flat([[1,2,3],[3,4,5]])
Out[50]:
In [51]:
np.array([[1,2,3],[3,4,5]]).flatten()
Out[51]:
In [60]:
# training, validation, testing scheme:
# 1. [2007-2010], [2011-2014], [2015]
# 2. [2008-2011], [2012-2015], [2016]
# ...
# last. [2015-2018], [2019-2022], [2023]
fulltrain_idx = []
cv_idx = []
test_idx = []
for i in range(4,len(time_idx)-4):
train_idx = list_flat(time_idx[i-4:i])
val_idx = list_flat(time_idx[i:i+4])
fulltrain_idx.append(train_idx + val_idx)
cv_idx.append((np.where(np.isin(fulltrain_idx[-1], train_idx))[0],
np.where(np.isin(fulltrain_idx[-1], val_idx))[0])) # GridSearchCV 内部用 array 操作，不能带着pandas的index，
# 因此cv_idx需要用fulltrain_idx的编号从0开始
test_idx.append(time_idx[i+4])
In [61]:
len(fulltrain_idx)
Out[61]:
In [62]:
len(fulltrain_idx[0])
Out[62]:
In [63]:
len(fulltrain_idx[1])
Out[63]:
In [64]:
cv_idx
Out[64]:
In [66]:
test_years = list(range(2015, 2025))
test_years
Out[66]:
In [67]:
X_cols = [col for col in ret_df.columns if col[-6:]=='signal']
In [68]:
X_cols
Out[68]:
Evaluation metrics¶
用 accuracy, f1_score 作为好坏评价的标准
- accuracy: 正确数/总数。比如预测了100次，对了99次，则accuracy = 99%. $accuracy = \frac{TP+TN}{TP+TN+FP+FN}$
- $precision = \frac{TP}{TP+FP}$, 在预测为Positive时，预测对的次数
- $recall = \frac{TP}{TP+FN}$，在真实为Positive时，预测对的次数
- $f1 = \frac{2}{\frac{1}{precision}+\frac{1}{recall}} $
Random forest¶
In [69]:
hyperparam_grid = [
{'n_estimators': [50], 'max_depth': [3,5,7],
'max_features': [5,8]}
]
In [70]:
model = RandomForestClassifier()
In [71]:
# Cross validation for period 0, i.e.
# train: [2008-2011], val: [2012-2015], test: [2016]
grid_search = GridSearchCV(model, hyperparam_grid, cv=[cv_idx[0]])
In [72]:
X_fulltrain = ret_df.loc[fulltrain_idx[0], X_cols]
y_fulltrain = ret_df.loc[fulltrain_idx[0], 'ret_sign']
X_test = ret_df.loc[test_idx[0], X_cols]
y_test = ret_df.loc[test_idx[0], 'ret_sign']
In [73]:
ret_df.loc[fulltrain_idx[0]]
Out[73]:
In [74]:
%%time
grid_search.fit(X_fulltrain, y_fulltrain)
Out[74]:
In [75]:
grid_search.best_params_
Out[75]:
In [76]:
pd.DataFrame({"features":X_cols,"feature_importance":grid_search.best_estimator_.feature_importances_}).sort_values('feature_importance',ascending=False)
Out[76]:
In [77]:
y_pred = grid_search.predict(X_test)
print(accuracy_score(y_true=y_test, y_pred=y_pred))
In [78]:
# Benchmark all-positive
all_ones = np.ones_like(y_pred)
accuracy_score(y_true=y_test, y_pred=all_ones)
Out[78]:
In [79]:
y_pred = grid_search.predict(X_test)
print(f1_score(y_true=y_test, y_pred=y_pred))
print(f1_score(y_true=y_test, y_pred=all_ones))
In [80]:
%%time
for i in range(len(fulltrain_idx)):
X_fulltrain = ret_df.loc[fulltrain_idx[i], X_cols]
y_fulltrain = ret_df.loc[fulltrain_idx[i], 'ret_sign']
X_test = ret_df.loc[test_idx[i], X_cols]
y_test = ret_df.loc[test_idx[i], 'ret_sign']
grid_search = GridSearchCV(model, hyperparam_grid, cv=[cv_idx[i]])
grid_search.fit(X_fulltrain, y_fulltrain)
y_pred = grid_search.predict(X=X_test)
all_ones = np.ones_like(y_pred)
print("Test year", test_years[i],"Benchmark","accuracy:",accuracy_score(y_true=y_test, y_pred=all_ones))
print("Test year", test_years[i],"Model","accuracy:",accuracy_score(y_true=y_test, y_pred=y_pred))
print("Test year", test_years[i],"Benchmark","f1:",f1_score(y_true=y_test, y_pred=all_ones))
print("Test year", test_years[i],"Model","f1:",f1_score(y_true=y_test, y_pred=y_pred))
print("====================我是分割线========================")
Return¶
In [82]:
len(test_years)
Out[82]:
In [81]:
i = 8
print(test_years[i])
X_fulltrain = ret_df.loc[fulltrain_idx[i], X_cols]
y_fulltrain = ret_df.loc[fulltrain_idx[i], 'ret_sign']
X_test = ret_df.loc[test_idx[i], X_cols]
grid_search = GridSearchCV(model, hyperparam_grid, cv=[cv_idx[i]])
grid_search.fit(X_fulltrain, y_fulltrain)
rule = grid_search.predict(X=X_test)
In [83]:
rule
Out[83]:
In [84]:
rule[rule==-1] = 0
In [85]:
rule
Out[85]:
In [86]:
len(rule)
Out[86]:
In [87]:
ret_df.loc[test_idx[i],'open_ret']
Out[87]:
In [88]:
rule_ret = ret_df.loc[test_idx[i],'open_ret'].values * rule
In [91]:
ret_df_2023 = ret_df.loc[test_idx[i],['secID','tradeDate','open_ret']].copy()
ret_df_2023['rule_ret'] = rule_ret
In [92]:
ret_df_2023
Out[92]:
In [93]:
ret_df_2023.sort_values(['secID','tradeDate'],inplace=True)
In [94]:
# time-series mean of daily return
rule_tsmean_ret_by_crs = ret_df_2023.groupby('secID')['rule_ret'].mean()
rule_tsmean_ret_by_crs
Out[94]:
In [95]:
rule_tsmean_ret_by_crs.dropna(inplace=True)
y = rule_tsmean_ret_by_crs.values
const = np.full(shape=len(y),fill_value=1)
reg = sm.OLS(y, const).fit().get_robustcov_results(cov_type='HC0')
mean_values = reg.params[0]
t_values = reg.tvalues[0]
In [96]:
pd.DataFrame([mean_values,t_values],index=['ret_mean','t_values'],columns=['rule_daily_ret'])
Out[96]:
In [99]:
ret_df_2023['1+rule_ret'] = ret_df_2023['rule_ret'] + 1
In [100]:
ret_df_2023['cum_rule_ret'] = ret_df_2023.groupby('secID')['1+rule_ret'].cumprod()
In [101]:
ret_df_2023['1+open_ret'] = ret_df_2023['open_ret'] + 1
ret_df_2023['cum_open_ret'] = ret_df_2023.groupby('secID')['1+open_ret'].cumprod()
In [102]:
ret_df_2023
Out[102]:
In [103]:
final_ret_2023 = ret_df_2023.groupby('secID').last()
In [104]:
final_ret_2023.sort_values('cum_rule_ret')
Out[104]:
In [106]:
best_sec = final_ret_2023.sort_values('cum_rule_ret').index[-5:]
In [107]:
ret_df_2023.loc[ret_df_2023['secID'].isin(best_sec)].pivot(index='tradeDate',columns='secID',values='cum_rule_ret').plot()
Out[107]:
In [108]:
ret_df_2023.loc[ret_df_2023['secID'].isin(best_sec)].pivot(index='tradeDate',columns='secID',values='cum_open_ret').plot()
Out[108]:
In [112]:
final_ret_2023.sort_values('cum_rule_ret', inplace=True)
worst_sec = final_ret_2023.loc[final_ret_2023['tradeDate']=='2023-12-29'].index[0:10]
In [113]:
final_ret_2023
Out[113]:
In [114]:
worst_sec
Out[114]:
In [115]:
ret_df_2023.loc[ret_df_2023['secID'].isin(worst_sec)].pivot(index='tradeDate',columns='secID',values='cum_rule_ret').plot()
Out[115]:
In [116]:
ret_df_2023.loc[ret_df_2023['secID'].isin(worst_sec)].pivot(index='tradeDate',columns='secID',values='cum_open_ret').plot()
Out[116]:
In [ ]: