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 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 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)
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')
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()