def load_ret(self):
tradingDay = TradingDayService.getTradingDay(self.start, self.end)
end_day = TradingDayService.getRelativeTradingDay(tradingDay[-1], 1)
universe = TradableListService.TradableListSerivce.getUniverse(end_day)
df = TNDataService.TNDataSerivce.getTNData(universe, self.start,
end_day, 'Ret') / 100
self.ret = df
def read(self):
df = FactorService.get_factor(self.factor_name, self.start, self.end,
self.factor_type)
self.factor_data = df
tradingDay = TradingDayService.getTradingDay(self.start, self.end)
end_day = TradingDayService.getRelativeTradingDay(tradingDay[-1], 1)
universe = TradableListSerivce.getUniverse(end_day)
df = TNDataSerivce.getTNData(universe, self.start, end_day,
'Ret') / 100
self.ret = df
def compute(self):
for idx, row in self.factor_data.iterrows():
today = idx.strftime('%Y%m%d')
print(today)
next_day = TradingDayService.getRelativeTradingDay(today, 1)
factor = row.dropna()
tradable = TradableListService.TradableListSerivce.getTradableStock(
today)
ret = self.ret.loc[pd.to_datetime(next_day)].dropna() / 100
if self.exclude_limit:
ret = ret[ret.abs() < 0.095]
if self.exclude_ipo:
ipo_stock = TradableListService.TradableListSerivce.getIpoStock(
TradingDayService.getRelativeTradingDay(today, -60), today)
else:
ipo_stock = []
if self.exclude_st:
st_stock = TradableListService.TradableListSerivce.getStStock(
today)
else:
st_stock = []
if self.universe_code == 'all':
universe = tradable
else:
universe = TradableListService.TradableListSerivce.getIndexComponent(
today, self.universe_code)
valid_symbol = [
s for s in tradable
if (s in universe) and (s in ret.keys()) and (s in factor.keys(
)) and (s not in ipo_stock) and (s not in st_stock)
]
if ret[valid_symbol].isna().all():
t, r_square_adj, factor_ret = None, None, None
else:
ret = ret[valid_symbol].values
factor_value = factor[valid_symbol].values
t, r_square_adj, factor_ret = self.regress(ret, factor_value)
self.t.append(t)
self.r_square_adj.append(r_square_adj)
self.factor_ret.append(factor_ret)
if t:
print('t:%5.2f, r_square_adj:%8.5f, factor_ret:%8.5f' %
(t, r_square_adj, factor_ret))
else:
print('t:%s, r_square_adj:%s, factor_ret:%s' %
(t, r_square_adj, factor_ret))
def report(self):
tradingday = TradingDayService.getTradingDay(self.start, self.end)
t = [
datetime.datetime.strptime(s, '%Y%m%d').strftime('%Y-%m-%d')
for s in tradingday[1:]
]
data = []
for col in self.layer_turnoverRate:
data.append(
go.Scatter(x=t, y=self.layer_turnoverRate[col], name=col))
x = ''.join([
col + ':' + str(self.layer_turnoverRate[col].mean()) + ' '
for col in self.layer_turnoverRate
])
layout = dict(title=('换手率估计 ' + x))
fig = dict(data=data, layout=layout)
store_dir = 'G:\\report\\estimator\\TurnoverRateEstimator\\' + self.universe_code + "\\"
if not os.path.exists(store_dir):
os.mkdir(store_dir)
plotly.offline.plot(fig,
filename=store_dir + self.factor_name +
('-excludelimit-' if self.exclude_limit else '-') +
('-excludeipo-' if self.exclude_ipo else '-') +
('-excludest-' if self.exclude_st else '-') +
self.factor_type + '-' + str(self.layer_num) +
'-layer.html',
auto_open=True)
def report(self):
tradingday = TradingDayService.getTradingDay(self.start, self.end)
t = [
datetime.datetime.strptime(s, '%Y%m%d').strftime('%Y-%m-%d')
for s in tradingday
]
d = pd.DataFrame(
data={
'Date': t,
't': self.t,
'factor_ret': self.factor_ret,
'r_square_adj': self.r_square_adj
})
trace0 = go.Bar(x=d['Date'], y=d['t'], name='t序列')
trace1 = go.Bar(x=d['Date'], y=d['r_square_adj'], name='R2序列')
trace2 = go.Scatter(x=d['Date'],
y=(d['factor_ret'] + 1).cumprod(),
name='因子收益率')
less2ratio = len(d[d['t'].abs() > 2]) / len(d)
fig = plotly.tools.make_subplots(rows=2,
cols=2,
subplot_titles=('t序列', 'R2序列',
'因子收益率', ''))
fig.append_trace(trace0, 1, 1)
fig.append_trace(trace1, 1, 2)
fig.append_trace(trace2, 2, 1)
fig['layout'].update(
title='%s-%s %s 因子均值:%5.2f 因子分析 |t|>2 比例 %5.2f R2平均值 %5.2f%%' %
(self.start, self.end, self.factor_name, d['factor_ret'].mean() *
100, less2ratio, d['r_square_adj'].mean() * 100))
store_dir = 'report\\RegressTest\\' + self.universe_code + "\\"
if not os.path.exists(store_dir):
os.mkdir(store_dir)
plotly.offline.plot(fig,
filename=store_dir + self.factor_name +
('-excludelimit-' if self.exclude_limit else '-') +
('-excludeipo-' if self.exclude_ipo else '-') +
('-excludest-' if self.exclude_st else '-') +
self.factor_type + '.html',
auto_open=False)
print('|t|>2 比例 %5.2f' % less2ratio)
print('R2平均值 %5.2f%%' % (d['r_square_adj'].mean() * 100))
def report(self):
tradingday = TradingDayService.getTradingDay(self.start, self.end)
t = [
datetime.datetime.strptime(s, '%Y%m%d').strftime('%Y-%m-%d')
for s in tradingday
]
d = pd.DataFrame(
data={
'Date': t,
't': self.t,
'beta': self.beta,
'r_square_adj': self.r_square_adj
})
trace0 = go.Bar(x=d['Date'], y=d['t'], name='t序列')
trace1 = go.Bar(x=d['Date'], y=d['r_square_adj'], name='R2序列')
trace2 = go.Bar(x=d['Date'], y=d['beta'], name='回归系数')
less2ratio = len(d[d['t'].abs() > 2]) / len(d)
fig = plotly.tools.make_subplots(rows=2,
cols=2,
subplot_titles=('t序列', 'R2序列', '回归系数',
''))
fig.append_trace(trace0, 1, 1)
fig.append_trace(trace1, 1, 2)
fig.append_trace(trace2, 2, 1)
fig['layout'].update(
title=
'%s-%s %s %s 中性化分析 |t|>2 比例 %5.2f R2平均值 %5.2f%% 回归系数均值: %5.2f%%' %
(self.start, self.end, self.factor_name, self.neutralizer_name,
less2ratio, d['r_square_adj'].mean() * 100,
d['beta'].mean() * 100))
dir = 'report\\' + self.neutralizer_name + 'Neutralized' + (
'Industrized' if self.industry else
'') + ('ExcludeIpo' if self.exclude_ipo else '')
if not os.path.exists(dir):
os.mkdir(dir)
plotly.offline.plot(fig,
filename=dir + "\\" + self.factor_name + '.html',
auto_open=True)
def compute(self):
for idx, row in self.factor_data.iterrows():
today = idx.strftime('%Y%m%d')
print(today)
factor = row.dropna()
tradable = TradableListSerivce.getTradableStock(today)
neutralizer_data = self.neutralizer_data.loc[idx].dropna()
if self.exclude_ipo:
ipo_stock = TradableListSerivce.getIpoStock(
TradingDayService.getRelativeTradingDay(today, -60), today)
else:
ipo_stock = []
valid_symbol = [
s for s in tradable if (s in neutralizer_data.keys()) and (
s in factor.keys()) and (s not in ipo_stock)
]
neutralizer_value = neutralizer_data[valid_symbol].values
if self.industry:
industry_data = IndustryFactorService.get_industry_factor(
today)
valid_symbol = [
s for s in valid_symbol if s in industry_data.index.values
]
neutralizer_value = neutralizer_data[valid_symbol].values
industry_values = industry_data.loc[valid_symbol].values
neutralizer_value = np.hstack(
(industry_values, neutralizer_value[:, np.newaxis]))
factor_value = factor[valid_symbol].values
if factor[valid_symbol].isna().all():
beta, residual, r_square_adj, t = None, None, None, None
else:
beta, residual, r_square_adj, t = self.regress(
factor_value, neutralizer_value)
x = pd.Series(index=valid_symbol, data=residual, name=idx)
self.residual = self.residual.append(x)
self.beta.append(beta)
self.r_square_adj.append(r_square_adj)
self.t.append(t)
def compute(self):
tradingday = TradingDayService.getTradingDay(self.start, self.end)
layer_value = np.zeros((len(tradingday), self.layer_num))
for idx, today in enumerate(tradingday):
print(today)
next_day = TradingDayService.getRelativeTradingDay(today, 1)
factor = self.factor_data.loc[today].dropna()
ret = self.ret.loc[next_day].dropna()
ret_today = self.ret.loc[today].dropna()
if self.exclude_limit:
ret_today = ret_today[ret_today.abs() < 0.095]
tradableList_today = TradableListService.TradableListSerivce.getTradableStock(
today)
if self.exclude_ipo:
ipo_stock = TradableListService.TradableListSerivce.getIpoStock(
TradingDayService.getRelativeTradingDay(today, -60), today)
else:
ipo_stock = []
if self.exclude_st:
st_stock = TradableListService.TradableListSerivce.getStStock(
today)
else:
st_stock = []
if self.universe_code == 'all':
universe = tradableList_today
else:
universe = TradableListService.TradableListSerivce.getIndexComponent(
today, self.universe_code)
valid_symbol = [
s for s in factor.keys()
if (s in universe) and (s in ret.keys()) and (
s in ret_today.keys()) and (s in tradableList_today) and (
s not in ipo_stock) and (s not in st_stock)
]
factor = factor[valid_symbol]
ret = ret[valid_symbol]
df = pd.DataFrame(data={'factor': factor, 'ret': ret})
if self.market_weight:
marketCap = StaticDataService.StaticDataService.getDailyPerformanceByDay(
today, 'MarketCap')
marketCap = marketCap[valid_symbol]
df['marketCap'] = marketCap.loc[today]
df.sort_values(by='factor', ascending=False, inplace=True)
data_num = len(df)
num_per_layer = np.floor(data_num / self.layer_num)
s = 0
for i in range(self.layer_num):
if i == self.layer_num - 1:
if self.market_weight:
layer_value[idx, i] = np.average(
df['ret'].iloc[s:].values,
weights=df['marketCap'].iloc[s:].values)
else:
layer_value[idx,
i] = np.average(df['ret'].iloc[s:].values)
else:
if self.market_weight:
layer_value[idx, i] = np.average(
df['ret'].iloc[s:int(s + num_per_layer)].values,
weights=df['marketCap'].
iloc[s:int(s + num_per_layer)].values)
else:
layer_value[idx, i] = np.average(
df['ret'].iloc[s:int(s + num_per_layer)].values)
s = int(s + num_per_layer)
self.layer_value = pd.DataFrame(
layer_value,
columns=['layer' + str(s + 1) for s in range(self.layer_num)])
tradingday_next = TradingDayService.getTradingDay(
TradingDayService.getRelativeTradingDay(tradingday[0], 1),
TradingDayService.getRelativeTradingDay(tradingday[-1], 1))
self.layer_value.index = pd.to_datetime(tradingday_next)
def report(self):
data = []
tradingday = TradingDayService.getTradingDay(self.start, self.end)
tradingday = TradingDayService.getTradingDay(
TradingDayService.getRelativeTradingDay(tradingday[0], 1),
TradingDayService.getRelativeTradingDay(tradingday[-1], 1))
start_day = tradingday[0]
end_day = tradingday[-1]
dapan = IndexService.getIndexRet('000001', start_day, end_day)
hs300 = IndexService.getIndexRet('000300', start_day, end_day)
sz50 = IndexService.getIndexRet('000016', start_day, end_day)
zz500 = IndexService.getIndexRet('000905', start_day, end_day)
zz1000 = IndexService.getIndexRet('000852', start_day, end_day)
cyb = IndexService.getIndexRet('399006', start_day, end_day)
t = [
datetime.datetime.strptime(s, '%Y%m%d').strftime('%Y-%m-%d')
for s in tradingday
]
for col in self.layer_value:
data.append(
go.Scatter(x=t,
y=(self.layer_value[col] + 1).cumprod(),
name=col))
fig = plotly.tools.make_subplots(rows=1,
cols=2,
subplot_titles=('分层', '多空'))
for trace in data:
fig.append_trace(trace, 1, 1)
relative = []
trace2 = go.Scatter(
x=t,
# y = self.layer_value['layer2'] - self.layer_value['layer4'],
y=((self.layer_value['layer1'] -
self.layer_value['layer' + str(self.layer_num)]) +
1).cumprod(),
name='多空组合')
relative.append(trace2)
trace3 = go.Scatter(x=t,
y=((self.layer_value['layer1'] - dapan) +
1).cumprod(),
name='layer1相对大盘')
relative.append(trace3)
trace4 = go.Scatter(x=t,
y=((self.layer_value['layer1'] - cyb) +
1).cumprod(),
name='layer1相对创业板')
relative.append(trace4)
trace5 = go.Scatter(x=t,
y=((self.layer_value['layer1'] - hs300) +
1).cumprod(),
name='layer1相对沪深300')
relative.append(trace5)
trace6 = go.Scatter(x=t,
y=((self.layer_value['layer1'] - zz500) +
1).cumprod(),
name='layer1相对中证500')
relative.append(trace6)
trace7 = go.Scatter(x=t,
y=((self.layer_value['layer1'] - zz1000) +
1).cumprod(),
name='layer1相对中证1000')
relative.append(trace7)
trace8 = go.Scatter(x=t,
y=((self.layer_value['layer1'] - sz50) +
1).cumprod(),
name='layer1相对上证50')
relative.append(trace8)
layerRelative = []
if self.universe_code == 'all':
relative_index = dapan
layerRelative = self.getLayerRelative(relative_index, t, '大盘')
if self.universe_code == '000852':
relative_index = zz1000
layerRelative = self.getLayerRelative(relative_index, t, '中证1000')
if self.universe_code == '000905':
relative_index = zz500
layerRelative = self.getLayerRelative(relative_index, t, '中证500')
if self.universe_code == '000300':
relative_index = hs300
layerRelative = self.getLayerRelative(relative_index, t, '沪深300')
if self.universe_code == '000016':
relative_index = sz50
layerRelative = self.getLayerRelative(relative_index, t, '上证50')
if self.universe_code == '399006':
relative_index = cyb
layerRelative = self.getLayerRelative(relative_index, t, '创业板')
relative.extend(layerRelative)
for trace in relative:
fig.append_trace(trace, 1, 2)
fig['layout'].update(title='%s-%s %s 因子分层分析' %
(self.start, self.end, self.factor_name))
store_dir = 'report\\LayerTest\\' + self.universe_code + "\\"
if not os.path.exists(store_dir):
os.mkdir(store_dir)
plotly.offline.plot(
fig,
filename=store_dir + self.factor_name +
('-excludelimit-' if self.exclude_limit else '-') +
('-excludeipo-' if self.exclude_ipo else '-') +
('-excludest-' if self.exclude_st else '-') +
('marketweight-' if self.market_weight else 'equalweight-') +
self.factor_type + '-' + str(self.layer_num) + '-layer.html',
auto_open=True)
def compute(self):
tradingday = TradingDayService.getTradingDay(self.start, self.end)
result = {}
for idx, today in enumerate(tradingday):
print(today)
next_day = TradingDayService.getRelativeTradingDay(today, 1)
factor = self.factor_data.loc[today].dropna()
ret = self.ret.loc[next_day].dropna()
ret_today = self.ret.loc[today].dropna()
if self.exclude_limit:
ret_today = ret_today[ret_today.abs() < 0.095]
tradableList_today = TradableListSerivce.getTradableStock(today)
if self.exclude_ipo:
ipo_stock = TradableListSerivce.getIpoStock(
TradingDayService.getRelativeTradingDay(today, -60), today)
else:
ipo_stock = []
if self.exclude_st:
st_stock = TradableListSerivce.getStStock(today)
else:
st_stock = []
if self.universe_code == 'all':
universe = tradableList_today
else:
universe = TradableListSerivce.getIndexComponent(
today, self.universe_code)
valid_symbol = [
s for s in factor.keys()
if (s in universe) and (s in ret.keys()) and (
s in ret_today.keys()) and (s in tradableList_today) and (
s not in ipo_stock) and (s not in st_stock)
]
factor = factor[valid_symbol]
df = pd.DataFrame(data={'factor': factor})
df.sort_values(by='factor', ascending=False, inplace=True)
data_num = len(df)
num_per_layer = np.floor(data_num / self.layer_num)
s = 0
for i in range(self.layer_num):
if i == self.layer_num - 1:
stocks = df['factor'].iloc[s:].index
else:
stocks = df['factor'].iloc[s:int(s + num_per_layer)].index
s = int(s + num_per_layer)
if i == 0:
result[today] = {}
result[today]['layer' + str(i + 1)] = pd.Series(
{symbol: 1
for symbol in stocks})
# s = int(s + num_per_layer)
yesterday = tradingday[0]
layer_turnoverRate = np.zeros((len(tradingday) - 1, self.layer_num))
for idx, today in enumerate(tradingday):
if idx == 0:
continue
else:
for i in range(self.layer_num):
y = result[yesterday]['layer' + str(i + 1)]
x = result[today]['layer' + str(i + 1)]
union_stocks = x.index.tolist()
y_stock = y.index.tolist()
union_stocks.extend(y_stock)
x = x.reindex(union_stocks, fill_value=0)
y = y.reindex(union_stocks, fill_value=0)
x = x / len(x) if len(x) != 0 else x
y = y / len(y) if len(y) != 0 else y
z = (x - y).abs().sum()
layer_turnoverRate[idx - 1, i] = z
yesterday = today
self.layer_turnoverRate = pd.DataFrame(
layer_turnoverRate,
columns=['layer' + str(s + 1) for s in range(self.layer_num)])
# tradingday_next = TradingDayService.getTradingDay(TradingDayService.getRelativeTradingDay(tradingday[0], 1), TradingDayService.getRelativeTradingDay(tradingday[-1], 1))
self.layer_turnoverRate.index = pd.to_datetime(tradingday[1:])