def fc_low_test(ctx, optid):
lookback_days = 365 * 15
factor_ids_1 = ['120000013', '120000020', '120000014', '120000015']
factor_ids_2 = ['120000010', '120000011', '120000039']
factor_ids_3 = [
'120000053',
'120000056',
'120000058',
'120000073',
'MZ.F00010',
'MZ.F00050',
'MZ.F00060',
'MZ.F00070',
'MZ.F10010',
]
factor_ids = factor_ids_1 + factor_ids_2 + factor_ids_3
trade_dates = ATradeDate.month_trade_date(begin_date='2018-01-01')
for date in trade_dates:
start_date = (date -
datetime.timedelta(lookback_days)).strftime('%Y-%m-%d')
end_date = date.strftime('%Y-%m-%d')
print(start_date, end_date)
df_std_dist = load_mv(factor_ids, start_date, end_date)
df_std_dist = df_std_dist / 10
_, asset_cluster, _ = clusterKMeansLow(df_std_dist, n_init=10)
asset_cluster = dict(
list(zip(sorted(asset_cluster), sorted(asset_cluster.values()))))
for k, v in asset_cluster.items():
print(v)
print()
def __init__(self, index_ids, reindex, look_back, is_rolling, **kwargs):
self._index_ids = pd.Index(index_ids, name='index_id')
self._reindex = reindex
self._look_back = look_back
self._reindex_total = ATradeDate.trade_date(begin_date=self.reindex[0],
end_date=self.reindex[-1],
lookback=self.look_back +
1).rename('trade_date')
self._is_rolling = is_rolling
self._df_index_nav = caihui_tq_qt_index.load_index_nav(
self.index_ids,
begin_date=self.reindex_total[0].strftime('%Y%m%d'),
end_date=self.reindex_total[-1].strftime('%Y%m%d'),
fill_method=None)
# self._df_index_inc = self.df_index_nav.fillna(method='pad').pct_change().iloc[1:]
self._df_index_inc = self.df_index_nav.pct_change(
fill_method='pad').iloc[1:]
self._df_index_inc[self.df_index_nav.isna().iloc[1:]] = np.nan
self._reindex_total = self.df_index_nav.index
self._df_asset_cov_estimate = None
def pool_by_single_factor(pool, day, lookback, limit, ffr, ffe):
index = ATradeDate.week_trade_date(begin_date = day, end_date = day, lookback = lookback)
sdate = index.min()
edate = index.max()
ffe = ffe[(ffe.trade_date >= sdate) & (ffe.trade_date <= edate)]
ffe = ffe[['fund_id', 'ff_id', 'exposure']].groupby(['fund_id', 'ff_id']).last().unstack()
ffe.columns = ffe.columns.levels[1]
ffe = ffe.dropna()
vf = np.zeros(ffe.shape[1])
# pos = int(pool.ra_index_id[-2:])-1
pos = ffe.columns.values.tolist().index(pool.ra_index_id)
pool_type = pool.ra_fund_type // 100
if pool_type == 114:
vf[pos] = -1
elif pool_type == 115:
vf[pos] = 1
elif pool_type == 113:
vf[pos] = 1
all_fund_scale = StockFundAsset.all_fund_scale()
df_valid = all_fund_scale.loc[day].dropna()
df_valid = df_valid[df_valid > 2e8].index
df_valid = df_valid.intersection(ffe.index)
score = np.dot(ffe, vf)
df_score = pd.Series(score, index = ffe.index)
df_score = df_score.loc[df_valid]
df_score = df_score.sort_values(ascending = False)
final_codes = df_score.index[:limit]
final_codes_large = df_score.index[:5*limit]
return final_codes, final_codes_large
def fc_high(ctx, optid):
years = 5
lookback_days = 365 * years
factor_ids_1 = [
'120000013', '120000015', '120000020', '120000014', '120000028'
]
factor_ids_2 = [
'120000016', '120000051', '120000056', '120000073', 'MZ.FA0010',
'MZ.FA0050', 'MZ.FA0070', 'MZ.FA1010'
]
factor_ids = factor_ids_1 + factor_ids_2
trade_dates = ATradeDate.month_trade_date(begin_date='2017-01-01')
for date in trade_dates:
start_date = (date -
datetime.timedelta(lookback_days)).strftime('%Y-%m-%d')
end_date = date.strftime('%Y-%m-%d')
print(start_date, end_date)
corr0 = load_corr(factor_ids, start_date, end_date)
std0 = load_std(factor_ids, start_date, end_date)
asset_cluster = clusterSimple(corr0, std0**3, years)
asset_cluster = dict(
list(zip(sorted(asset_cluster), sorted(asset_cluster.values()))))
for k, v in asset_cluster.items():
print(v)
print()
def load_allocate_data(self, day, asset_ids, data_period='week'):
bound = []
allocate_asset_ids = []
for asset_id in asset_ids:
asset_bound = AssetBound.get_asset_day_bound(asset_id, day, self.bound).to_dict()
if asset_bound['upper'] > 0:
bound.append(asset_bound)
allocate_asset_ids.append(asset_id)
reindex = self.index[self.index <= day][-self.lookback-1:]
if data_period == 'week':
pass
elif data_period == 'day':
reindex = ATradeDate.trade_date(begin_date=reindex[0], end_date=day)
else:
raise ValueError
data = {}
for asset_id in allocate_asset_ids:
data[asset_id] = self.assets[asset_id].nav(reindex=reindex)
df_nav = pd.DataFrame(data).fillna(method='pad')
df_inc = df_nav.pct_change().iloc[1:]
return df_nav, df_inc, bound
def fc_low(ctx, optid):
years = 15
lookback_days = 365 * years
factor_ids_1 = [
'120000013', '120000014', '120000015', '120000028', '120000029'
]
factor_ids_2 = ['120000010', '120000011', '120000039']
factor_ids_3 = ['120000053', '120000056', '120000058', '120000073']
factor_ids = factor_ids_1 + factor_ids_2 + factor_ids_3
trade_dates = ATradeDate.month_trade_date(begin_date='2017-01-01')
for date in trade_dates:
start_date = (date -
datetime.timedelta(lookback_days)).strftime('%Y-%m-%d')
end_date = date.strftime('%Y-%m-%d')
print(start_date, end_date)
corr0 = load_corr(factor_ids, start_date, end_date)
std0 = load_std(factor_ids, start_date, end_date)
# asset_cluster = clusterSpectral(corr0*std0)
# _, asset_cluster, _ = clusterKMeansHigh(corr0*std0, n_init=10)
asset_cluster = clusterSimple(corr0, std0, years)
asset_cluster = dict(
list(zip(sorted(asset_cluster), sorted(asset_cluster.values()))))
for k, v in asset_cluster.items():
print(v)
print()
def cal_asset_ret(self, assets, start_date, end_date):
trade_dates = ATradeDate.trade_date()
df_assets = pd.DataFrame(assets)
df_assets = df_assets[df_assets.index >= start_date]
df_assets = df_assets[df_assets.index <= end_date]
df_assets = df_assets.reindex(trade_dates).dropna()
if self.bf_ids is not None:
df_assets = df_assets.loc[:, self.bf_ids]
df_ret = df_assets.pct_change().dropna()
return df_ret
def trade_date_not_later_than(date):
trade_dates = ATradeDate.trade_date()
try:
date = trade_dates[trade_dates.get_loc(date, method='pad')]
except KeyError:
return np.nan
return date
def allocate_algo(self, day, df_inc, bound):
df_inc[df_inc >= 0] = 0.0
risk, returns, ws, sharpe = self.markowitz_bootstrap(df_inc, bound, cpu_count = self._cpu_count, bootstrap_count = self._bootstrap_count)
tdate = ATradeDate.trade_date()
var = np.array([self.assets[code].origin_nav_sr.reindex(tdate).pct_change().loc[df_inc.index[-13]:df_inc.index[-1]].var() for code in df_inc.columns])
ws = np.array(ws).ravel()
ws = ws/var
ws = ws/ws.sum()
ws = dict(zip(df_inc.columns.ravel(), ws))
return ws
def obj_date(datestr=None):
'''
目标日期生成: 如，输入‘2019-04-12’
'''
if datestr is not None:
startDate = datestr
else:
startDate = (date.today() + timedelta(weeks=-2)).strftime('%Y-%m-%d')
targetDate = ATradeDate.week_trade_date(begin_date=startDate)[-1]
return targetDate
def wavelet(ctx, startdate, enddate, viewid, idx, wavenum, max_wave_num,
wave_name):
if idx is None:
#idx = ['120000001', '120000002', '120000013', '120000014', '120000015', '120000080' ,'ERI000001', 'ERI000002']
idx = ['120000001']
for _id in idx:
trade_dates = ATradeDate.trade_date()
nav = Asset(_id).nav(reindex=trade_dates).fillna(method='pad').dropna()
dates = nav.index[1000:]
views = []
for d in dates:
_tmp_nav = nav[nav.index <= d]
wave_nav = wavefilter(_tmp_nav,
wavenum,
wname=wave_name,
maxlevel=max_wave_num)
inc = wave_nav.pct_change().fillna(0.0).iloc[-120:]
wave_diff_rolling = wave_nav.diff().rolling(5).mean()
views.append(wave_diff_rolling[-1])
#print(d, views[-1])
print(_id, d, inc.mean(), inc.std())
view_df = pd.DataFrame(views, index=dates, columns=['bl_view'])
view_df[view_df > 0] = 1.0
view_df[view_df < 0] = 0
view_df.index.name = 'bl_date'
view_df['globalid'] = viewid
view_df['bl_index_id'] = _id
view_df['created_at'] = datetime.now()
view_df['updated_at'] = datetime.now()
df_new = view_df.reset_index().set_index(
['globalid', 'bl_date', 'bl_index_id'])
#print(df_new.head())
db = database.connection('asset')
metadata = MetaData(bind=db)
t = Table('ra_bl_view', metadata, autoload=True)
columns = [
t.c.globalid,
t.c.bl_date,
t.c.bl_view,
t.c.bl_index_id,
t.c.created_at,
t.c.updated_at,
]
s = select(columns).where(t.c.globalid == viewid).where(
t.c.bl_index_id == _id)
df_old = pd.read_sql(s,
db,
index_col=['globalid', 'bl_date', 'bl_index_id'],
parse_dates=['bl_date'])
database.batch(db, t, df_new, df_old, timestamp=False)
def load_corr(factor_ids, start_date, end_date):
trade_dates = ATradeDate.trade_date(start_date, end_date)
asset_navs = {}
for factor_id in factor_ids:
# asset_navs[factor_id] = CommandMarkowitz.load_nav_series(factor_id, reindex = trade_dates)
asset_navs[factor_id] = Asset.load_nav_series(factor_id,
reindex=trade_dates)
df_asset_navs = pd.DataFrame(asset_navs)
# df_asset_incs = df_asset_navs.pct_change().dropna()
# corr = df_asset_incs.corr()
corr = df_asset_navs.corr()
return corr
def get_week_adjust_point(startdate = '2010-01-08', enddate=None, label_period=1):
# 加载时间轴数据
if not enddate:
yesterday = (datetime.now() - timedelta(days=1));
enddate = yesterday.strftime("%Y-%m-%d")
index = ATradeDate.week_trade_date(startdate, enddate)
if label_period > 1:
label_index = index[::label_period]
if index.max() not in label_index:
label_index = label_index.insert(len(label_index), index.max())
else:
label_index = index
return label_index
def fund_update_monetary_pool(pool, adjust_points, optlimit, optcalc):
''' re calc fund for single fund pool
'''
lookback = pool.ra_lookback
limit = optlimit
if optcalc:
#
# 计算每个调仓点的最新配置
#
data = []
with click.progressbar(length=len(adjust_points), label='calc pool %s' % (pool.id)) as bar:
for day in adjust_points:
bar.update(1)
mnf = MonetaryFundFilter()
mnf.handle()
asset_ids = MonetaryAllocate.all_monetary_fund_globalid()
trade_dates = ATradeDate.week_trade_date()
dict_nav = {}
for asset_id in asset_ids:
dict_nav[asset_id] = Asset.load_nav_series(asset_id, reindex=trade_dates)
df_nav = pd.DataFrame(dict_nav).fillna(method='pad')
df_inc = df_nav.pct_change().fillna(0.0)
codes = pool_by_scale_return(pool, day, lookback, limit, mnf, df_inc)
print(day, len(codes), codes)
if codes is None or len(codes) == 0:
continue
ra_fund = base_ra_fund.load(globalids=codes)
ra_fund = ra_fund.set_index(['ra_code'])
ra_pool = pool['id']
for code in ra_fund.index:
ra_fund_id = ra_fund.loc[code, 'globalid']
data.append([ra_pool, day, ra_fund_id, code])
fund_df = pd.DataFrame(data, columns = ['ra_pool', 'ra_date', 'ra_fund_id', 'ra_fund_code'])
fund_df = fund_df.set_index(['ra_pool', 'ra_date', 'ra_fund_id'])
df_new = fund_df
columns = [literal_column(c) for c in (df_new.index.names + list(df_new.columns))]
s = select(columns)
db = database.connection('asset')
ra_pool_fund_t = Table('ra_pool_fund', MetaData(bind=db), autoload=True)
s = s.where(ra_pool_fund_t.c.ra_pool.in_(df_new.index.get_level_values(0).tolist()))
df_old = pd.read_sql(s, db, index_col = df_new.index.names)
database.batch(db, ra_pool_fund_t, df_new, df_old)
def fc_update_nav(ctx, optid):
lookback_days = 365
blacklist = [24, 32, 40]
factor_ids = [
'1200000%02d' % i for i in range(1, 40) if i not in blacklist
]
trade_dates = ATradeDate.month_trade_date(begin_date='2018-01-01')
date = trade_dates[-1]
start_date = (date -
datetime.timedelta(lookback_days)).strftime('%Y-%m-%d')
end_date = date.strftime('%Y-%m-%d')
corr0 = load_ind(factor_ids, start_date, end_date)
res = clusterKMeansBase(corr0, maxNumClusters=10, n_init=100)
asset_cluster = res[1]
asset_cluster = dict(
zip(sorted(asset_cluster), sorted(asset_cluster.values())))
factor_name = base_ra_index.load()
for k, v in asset_cluster.iteritems():
v = np.array(v).astype('int')
print factor_name.loc[v]
assets = {}
for factor_id in factor_ids:
assets[factor_id] = Asset.load_nav_series(factor_id)
df_assets = pd.DataFrame(assets)
db = database.connection('asset')
metadata = MetaData(bind=db)
t = Table('ra_composite_asset_nav', metadata, autoload=True)
for layer in asset_cluster.keys():
layer_id = 'FC.000001.%d' % (layer + 1)
layer_assets = asset_cluster[layer]
layer_nav = df_assets.loc[:, layer_assets]
layer_ret = layer_nav.pct_change().dropna()
layer_ret = layer_ret.mean(1)
layer_ret = layer_ret.reset_index()
layer_ret.columns = ['ra_date', 'ra_inc']
layer_ret['ra_nav'] = (1 + layer_ret['ra_inc']).cumprod()
layer_ret['ra_asset_id'] = layer_id
df_new = layer_ret.set_index(['ra_asset_id', 'ra_date'])
df_old = asset_ra_composite_asset_nav.load_nav(layer_id)
df_new = df_new.reindex(columns=['ra_nav', 'ra_inc'])
database.batch(db, t, df_new, df_old, timestamp=False)
def load_mv(factor_ids, start_date, end_date):
trade_dates = ATradeDate.trade_date(start_date, end_date)
asset_navs = {}
for factor_id in factor_ids:
asset_navs[factor_id] = Asset.load_nav_series(factor_id,
reindex=trade_dates)
df_asset_navs = pd.DataFrame(asset_navs)
df_asset_incs = df_asset_navs.pct_change().dropna()
df_mv = df_asset_incs.mean() / df_asset_incs.std()
df_mv = df_mv.to_frame('mv')
mv_dist = distance_matrix(df_mv, df_mv)
df_dist = pd.DataFrame(data=mv_dist,
columns=df_asset_navs.columns,
index=df_asset_navs.columns)
return df_dist
def __init__(self,
reindex,
look_back=300,
percentage=1.0,
calc_method='z_score'):
self.reindex = reindex
self.look_back = look_back # > 256 + 21
self.percentage = percentage
if (calc_method != 'z_score') and (calc_method != 'raw'):
raise ValueError
self.calc_method = calc_method
self.reindex_total = ATradeDate.trade_date(begin_date=self.reindex[0],
end_date=self.reindex[-1],
lookback=self.look_back + 2)
self.df_index_historical_constituents = wind_aindexmembers.load_a_index_historical_constituents(
index_id='000985.CSI')
self.stock_ids_total = pd.Index(
self.df_index_historical_constituents.stock_id.unique())
self.df_financial_descriptor = calc_stock_financial_descriptor(
stock_ids=self.stock_ids_total)
self.df_derivative_indicator = wind_ashareeodderivativeindicator.load_a_stock_derivative_indicator(
stock_ids=self.stock_ids_total, reindex=self.reindex_total)
self.df_price = wind_ashareeodprices.load_a_stock_adj_price(
stock_ids=self.stock_ids_total, reindex=self.reindex_total)
self.df_price.loc[:,
'benchmark'] = wind_aindexeodprices.load_a_index_nav(
index_ids='000985.CSI',
reindex=self.reindex_total)
self.df_return = self.df_price.pct_change().iloc[1:]
del self.df_price
self.df_sw = wind_ashareswindustriesclass.load_a_stock_historical_sw_industry(
stock_ids=self.stock_ids_total)
def load_ret(factor_ids, start_date, end_date):
trade_dates = ATradeDate.trade_date(start_date, end_date)
asset_navs = {}
for factor_id in factor_ids:
asset_navs[factor_id] = Asset.load_nav_series(factor_id,
reindex=trade_dates)
df_asset_navs = pd.DataFrame(asset_navs)
df_asset_incs = df_asset_navs.pct_change().dropna()
df_std = df_asset_incs.mean()
values = np.zeros((len(df_std), len(df_std)))
for i in range(len(df_std)):
for j in range(len(df_std)):
tmp_value = df_std.iloc[i] / df_std.iloc[j]
if tmp_value > 1:
tmp_value = 1 / tmp_value
values[i, j] = tmp_value
df_dist = pd.DataFrame(data=values,
columns=df_asset_navs.columns,
index=df_asset_navs.columns)
return df_dist
def fc_rolling(ctx, optid):
lookback_days = 365
blacklist = [24, 32, 40]
factor_ids = [
'1200000%02d' % i for i in range(1, 40) if i not in blacklist
]
trade_dates = ATradeDate.month_trade_date(begin_date='2018-01-01')
for date in trade_dates:
start_date = (date -
datetime.timedelta(lookback_days)).strftime('%Y-%m-%d')
end_date = date.strftime('%Y-%m-%d')
print start_date, end_date
corr0 = load_ind(factor_ids, start_date, end_date)
factor_name = base_ra_index.load()
res = clusterKMeansBase(corr0, maxNumClusters=10, n_init=100)
asset_cluster = res[1]
asset_cluster = dict(
zip(sorted(asset_cluster), sorted(asset_cluster.values())))
for k, v in asset_cluster.iteritems():
v = np.array(v).astype('int')
print factor_name.loc[v]
print
def fc_rolling(ctx, optid):
engine = database.connection('asset')
Session = sessionmaker(bind=engine)
session = Session()
blacklist = [24, 40]
asset_ids = ['1200000%02d' % i for i in range(1, 40) if i not in blacklist]
assets = {}
for asset_id in asset_ids:
# assets[asset_id] = load_nav_series(asset_id)
assets[asset_id] = Asset.load_nav_series(asset_id)
layer_result = {}
layer_result['date'] = []
layer_result['layer'] = []
layer_result['factor'] = []
lookback_days = 365
forecast_days = 90
df_result = pd.DataFrame(columns=['date', 'factor_id', 'layer'])
start_date = '2017-01-01'
trade_dates = ATradeDate.month_trade_date(begin_date=start_date)
for date in trade_dates:
print date
sdate = (date - datetime.timedelta(lookback_days)).strftime('%Y-%m-%d')
edate = date.strftime('%Y-%m-%d')
fdate = (date + datetime.timedelta(forecast_days)).strftime('%Y-%m-%d')
'''
init_num = 5
fc = FactorCluster(assets, init_num, sdate, edate, fdate)
fc.handle()
while fc.inner_score < 0.88:
init_num += 1
fc = FactorCluster(assets, init_num, sdate, edate, fdate)
fc.handle()
'''
method = 'beta'
scores = {}
models = {}
for i in range(7, 12):
fc = FactorCluster(assets,
i,
sdate,
edate,
fdate,
method=method,
bf_ids=None)
fc.handle()
print i, 'silhouette_samples_value:', fc.silhouette_samples_value
score = fc.silhouette_samples_value
scores[score] = i
models[score] = fc
best_score = np.max(scores.keys())
best_model = models[best_score]
fc = best_model
print 'best cluster num:', fc.n_clusters
factor_name = base_ra_index.load()
for k, v in fc.asset_cluster.iteritems():
v = np.array(v).astype('int')
print factor_name.loc[v]
for vv in v:
df_result.loc[len(df_result)] = [date, vv, k]
print
session.commit()
session.close()
if __name__ == '__main__':
index_ids = [
'2070000060', # 000300
'2070000187', # 000905
'2070000076', # HSI
'2070006545', # S&P 500
'2070006599' # NASDAQ 100
]
begin_date = '2010-01-01'
end_date = '2019-02-28'
look_back = 1000
is_rolling = False
trade_dates = ATradeDate.week_trade_date(
begin_date=begin_date, end_date=end_date).rename('trade_date')
dict_cov = {}
df_norm = pd.DataFrame()
dict_cov['Last'] = AssetCovarianceLast(index_ids, trade_dates, look_back,
is_rolling)
dict_cov['Last'].estimate_asset_cov_days()
df_norm['Last'] = dict_cov['Last'].covariance_analysis()
dict_cov['Empirical'] = AssetCovarianceEmpirical(index_ids, trade_dates,
look_back, is_rolling)
dict_cov['Empirical'].estimate_asset_cov_days()
df_norm['Empirical'] = dict_cov['Empirical'].covariance_analysis()
dict_cov['LedoitWolf'] = AssetCovarianceLedoitWolf(index_ids, trade_dates,
def pos_n_nav_update(stock_portfolio_info, begin_date, end_date):
stock_portfolio_id = stock_portfolio_info.name
stock_portfolio_type = stock_portfolio_info.loc['sp_type']
algo = stock_portfolio_info.loc['sp_algo']
df_argv = asset_sp_stock_portfolio_argv.load(
portfolio_id=stock_portfolio_id)
kwargs = df_argv.loc[stock_portfolio_id].sp_value.to_dict()
list_int_arg = ['look_back', 'exclusion']
list_float_arg = [
'percentage', 'percentage_low_beta', 'percentage_low_volatility',
'percentage_high_dividend'
]
list_pd_index_arg = ['stock_portfolio_ids']
for arg in list_int_arg:
if kwargs.get(arg) is not None:
kwargs[arg] = int(kwargs.get(arg))
for arg in list_float_arg:
if kwargs.get(arg) is not None:
kwargs[arg] = float(kwargs.get(arg))
for arg in list_pd_index_arg:
if kwargs.get(arg) is not None:
kwargs[arg] = pd.Index(
[s.strip() for s in kwargs.get(arg).split(',')])
period = kwargs.get('period', 'day')
if period == 'day':
kwargs['reindex'] = ATradeDate.trade_date(
begin_date=begin_date, end_date=end_date).rename('trade_date')
elif period == 'week':
kwargs['reindex'] = ATradeDate.week_trade_date(
begin_date=begin_date, end_date=end_date).rename('trade_date')
elif period == 'month':
kwargs['reindex'] = ATradeDate.month_trade_date(
begin_date=begin_date, end_date=end_date).rename('trade_date')
else:
click.echo(
click.style(
f'\n Period {period} is unknown for stock portfolio {stock_portfolio_id}.',
fg='red'))
return
if kwargs['reindex'].size == 0:
click.echo(
click.style(
f'\n Trade date index for stock portfolio {stock_portfolio_id} is empty.',
fg='red'))
return
if stock_portfolio_id[:3] != 'CS.' and stock_portfolio_id[-2:] != '00':
algo = f'Industry{algo}'
# kwargs['sw_industry_code'] = f'{stock_portfolio_id[-2:]}0000'
try:
if stock_portfolio_id[:3] == 'SP.' or stock_portfolio_id[:3] == 'CS.':
class_name = f'StockPortfolio{algo}'
elif stock_portfolio_id[:3] == 'FP.':
class_name = f'FactorPortfolio{algo}'
else:
class_name = algo
cls = getattr(stock_portfolio, class_name)
except AttributeError:
click.echo(
click.style(
f'\n Algo {algo} is unknown for stock portfolio {stock_portfolio_id}.',
fg='red'))
return
class_stock_portfolio = cls(**kwargs)
click.echo(
click.style(
f'\n Stock data for stock portfolio {stock_portfolio_id} loaded.',
fg='yellow'))
if stock_portfolio_type == 0:
class_stock_portfolio.calc_portfolio_nav(considering_status=False,
considering_fee=False)
elif stock_portfolio_type == 1:
class_stock_portfolio.calc_portfolio_nav(considering_status=True,
considering_fee=False)
elif stock_portfolio_type == 2:
class_stock_portfolio.calc_portfolio_nav(considering_status=True,
considering_fee=True)
else:
click.echo(
click.style(
f'\n Type {stock_portfolio_type} is unknown for stock portfolio {stock_portfolio_id}.',
fg='red'))
df_pos = deepcopy(class_stock_portfolio.df_stock_pos_adjusted)
df_nav = pd.DataFrame({
'nav': class_stock_portfolio.ser_portfolio_nav,
'inc': class_stock_portfolio.ser_portfolio_inc
})
click.echo(
click.style(
f'\n Nav of stock portfolio {stock_portfolio_id} calculated.',
fg='yellow'))
class_stock_portfolio.portfolio_analysis()
if stock_portfolio_type == 1:
dict_benchmark = {
'000016.SH': 'h00016.SH',
'000300.SH': 'h00300.CSI',
'000905.SH': 'h00905.CSI',
'000906.SH': 'h00906.CSI'
}
benchmark_id = dict_benchmark[kwargs.get('index_id', '000906.SH')]
try:
class_stock_portfolio.portfolio_statistic(benchmark_id)
except np.linalg.LinAlgError:
print('numpy.linalg.LinAlgError: Matrix is not positive definite')
engine = database.connection('asset')
metadata = MetaData(bind=engine)
table_sp_pos = Table('sp_stock_portfolio_pos', metadata, autoload=True)
table_sp_nav = Table('sp_stock_portfolio_nav', metadata, autoload=True)
table_sp_pos.delete(
table_sp_pos.c.globalid == stock_portfolio_id).execute()
table_sp_nav.delete(
table_sp_nav.c.globalid == stock_portfolio_id).execute()
df_pos = df_pos.stack().rename('sp_sk_pos').reset_index().rename(
columns={
'trade_date': 'sp_date',
'stock_id': 'sp_sk_id'
})
df_pos['globalid'] = stock_portfolio_id
df_pos = df_pos.loc[df_pos.sp_sk_pos > 0.0].set_index(
['globalid', 'sp_date', 'sp_sk_id'])
df_nav = df_nav.reset_index().rename(columns={
'trade_date': 'sp_date',
'nav': 'sp_nav',
'inc': 'sp_inc'
})
df_nav['globalid'] = stock_portfolio_id
df_nav = df_nav.set_index(['globalid', 'sp_date'])
asset_sp_stock_portfolio_pos.save(stock_portfolio_id, df_pos)
asset_sp_stock_portfolio_nav.save(stock_portfolio_id, df_nav)
click.echo(
click.style(
f'\n Successfully updated pos and nav of stock portfolio {stock_portfolio_info.name}!',
fg='green'))
fp = fund_pos.loc[[fund_id]]
fp = fp.sort_values(['publishdate'])
fp = fp.fillna(0.0)
pub_ratio = fp['navrto'].groupby(fp.publishdate).sum()
valid_date = pub_ratio[pub_ratio > 30].index
fp = fp.set_index('publishdate').loc[valid_date].set_index(
'skcode', append=True)
StockFundAsset.__all_fund_pos[fund_id] = fp
return StockFundAsset.__all_fund_pos
if __name__ == '__main__':
asset = Asset('120000001')
nav = asset.nav(reindex=ATradeDate.week_trade_date())
inc = nav.pct_change().dropna()
print(inc.std())
print(np.mean(inc**2)**0.5)
#print asset.origin_nav_sr.head()
# asset = WaveletAsset('120000013', 2)
#print asset.nav('2010-01-01', datetime.now()).tail()
#print asset.origin_nav_sr.tail()
# asset = StockAsset('SK.601318')
# print asset.nav()
# print asset.name
#StockAsset.all_stock_fdmt()
#for globalid in StockAsset.all_stock_info().index:
# asset = StockAsset('SK.601318')
for i in clstrs2.keys()
])
if newTstatMean <= meanRedoTstat:
return corr1, clstrs, silh
else:
return corrNew, clstrsNew, silhNew
if __name__ == '__main__':
lookback_days = 365
blacklist = [24, 32, 40]
factor_ids = [
'1200000%02d' % i for i in range(1, 40) if i not in blacklist
]
trade_dates = ATradeDate.month_trade_date(begin_date='2018-01-01')
for date in trade_dates:
# start_date = '%d-%02d-01'%(year, month)
# end_date = '%d-%02d-01'%(year+1, month)
start_date = (date -
datetime.timedelta(lookback_days)).strftime('%Y-%m-%d')
end_date = date.strftime('%Y-%m-%d')
print start_date, end_date
# corr0 = load_fund(start_date, end_date)
corr0 = load_ind(factor_ids, start_date, end_date)
# corr1, clstrs, silh = clusterKMeansBase(corr0,maxNumClusters=10,n_init=1)
factor_name = base_ra_index.load()
# df_fund = base_ra_fund.load()
# df_fund.index = df_fund.ra_code.astype('int')
# df_fund = df_fund.set_index('ra_code')
# factor_name = df_fund.ra_name
df_inc_resample = pd.DataFrame(arr_inc_resample)
ev_ret = self.calc_ev_ret(df_inc_resample, ev_cov, P, eta, alpha)
ws = self.markowitz_bl_fixrisk(ev_cov, ev_ret, bound, target_risk)
return ws
if __name__ == '__main__':
print(MonetaryAllocate.all_monetary_fund_globalid())
asset = Asset('120000001')
asset = WaveletAsset('120000013', 2)
trade_date = ATradeDate.week_trade_date(begin_date = '2012-01-01')
asset_globalids = ['120000001', '120000002', '120000013', '120000014', '120000015']
assets = {}
for asset_id in asset_globalids:
assets[asset_id] = Asset(asset_id)
#assets[asset_id] = WaveletAsset(asset_id, 2)
allocate = AvgAllocate('ALC.000001', assets, trade_date, 14)
#print allocate.allocate().tail()
allocate = MzAllocate('ALC.000002', assets, trade_date, 14)
#print allocate.allocate().tail()
allocate = MzBootAllocate('ALC.000002', assets, trade_date, 14)
#print allocate.allocate().tail()