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