예제 #1
0
def corr_update_fund(corr, fund, df_inc_index):
    yesterday = (datetime.now() - timedelta(days=1)); 
    enddate = yesterday.strftime("%Y-%m-%d")        
    #
    # 加载基金数据
    #
    if corr['ra_date_type'] == 1:
        # df_nav_fund = DBData.db_fund_value_daily('2015-10-08', enddate, codes=[fund['ra_code']])
        df_nav_fund = base_ra_fund_nav.load_daily('2015-10-08', enddate, codes=[fund['ra_code']])
    else:
        # df_nav_fund = DBData.db_fund_value('2015-10-08', enddate, codes=[fund['ra_code']])
        df_nav_fund = base_ra_fund_nav.load_weekly('2015-10-08', enddate, codes=[fund['ra_code']])
    if df_nav_fund.empty:
        logger.warn("missing nav for fund [id: %d, code:%s]", fund['globalid'], fund['ra_code'])
        return None
    
    df_inc_fund = df_nav_fund.pct_change().fillna(0.0)
    
    # print df_inc_index.head()
    # print fund, df_inc_fund.head()
    df_inc = pd.DataFrame({'ra_index':df_inc_index.iloc[:, 0], 'ra_fund':df_inc_fund.ix[df_inc_index.index, 0]})
    df_inc.fillna(0.0, inplace=True)
    df_corr = df_inc.corr()
    df_corr.fillna(0.0, inplace=True)

    if df_corr.empty:
        corr = 0.0
    else:
        corr = df_corr.loc['ra_index', 'ra_fund']

    return corr
예제 #2
0
def pool_by_corr_jensen(pool, day, lookback, limit):

    index = base_trade_dates.trade_date_lookback_index(end_date=day, lookback=lookback)

    start_date = index.min().strftime("%Y-%m-%d")
    end_date = day.strftime("%Y-%m-%d")


    ra_index_id = pool['ra_index_id']
    pool_id     = pool['id']
    df_nav_index = base_ra_index_nav.index_value(start_date, end_date, ra_index_id)
    #df_nav_index.index.name = str(df_nav_index.index.name)
    df_nav_index.columns = df_nav_index.columns.astype(str)
    if len(df_nav_index.index) == 0:
        return []
    pool_codes   = asset_ra_pool_sample.load(pool_id)['ra_fund_code'].values

    df_nav_fund  = base_ra_fund_nav.load_daily(start_date, end_date, codes = pool_codes)
    if len(df_nav_fund) == 0:
        return []

    df_nav_fund  = df_nav_fund.reindex(pd.date_range(df_nav_index.index[0], df_nav_index.index[-1]))
    df_nav_fund  = df_nav_fund.fillna(method = 'pad')
    df_nav_fund  = df_nav_fund.dropna(axis = 1)
    df_nav_fund  = df_nav_fund.loc[df_nav_index.index]
    fund_index_df = pd.concat([df_nav_index, df_nav_fund], axis = 1, join_axes = [df_nav_index.index])


    fund_index_corr_df = fund_index_df.pct_change().fillna(0.0).corr().fillna(0.0)

    corr = fund_index_corr_df[ra_index_id][1:]
    corr = corr.sort_values(ascending = False)

    code_jensen = {}
    for code in df_nav_fund.columns:
        jensen = fin.jensen(df_nav_fund[code].pct_change().fillna(0.0), df_nav_index[ra_index_id].pct_change().fillna(0.0) ,Const.rf)
        code_jensen.setdefault(code, jensen)


    if len(code_jensen) == 0:
        logger.info('No FUND')
        return None
    else:
        final_codes = []
        x = code_jensen
        sorted_x = sorted(iter(x.items()), key=lambda x : x[1], reverse=True)
        corr_threshold = np.percentile(corr.values, 80)
        corr_threshold = 0.7 if corr_threshold <= 0.7 else corr_threshold
        corr_threshold = 0.9 if corr_threshold >= 0.9 else corr_threshold
        for i in range(0, len(sorted_x)):
            code, jensen = sorted_x[i]
            if corr[code] >= corr_threshold:
                final_codes.append(code)

        final_codes = final_codes[0 : limit]
        return final_codes
def cal_fund_inc_estimate_error():

    df_fund_inc_est = asset_fund_inc_estimate.load_fund_inc_estimate()
    df_fiesp = df_fund_inc_est.sk_pos.unstack()
    df_fieip = df_fund_inc_est.ix_pos.unstack()
    df_fiem = df_fund_inc_est.mix.unstack()

    df_fn = base_ra_fund_nav.load_daily(
            begin_date=trade_date_before(df_fiem.index[0]).strftime('%Y%m%d'),
            end_date=df_fiem.index[-1].strftime('%Y%m%d'),
            codes=df_fiesp.columns
    )
    df_fi = df_fn.pct_change().iloc[1:]

    df_fiesp_error = df_fiesp - df_fi
    df_fieip_error = df_fieip - df_fi
    df_fiem_error = df_fiem - df_fi

    set_trace()
    def __cal_mix_pos_days(self):

        begin_date_cal = self.begin_date + relativedelta(months=-1, day=1)
        dates = pd.Series(index=[begin_date_cal, self.end_date])
        dates = dates.resample('MS').first().index

        df_fund_nav = base_ra_fund_nav.load_daily(
                begin_date=trade_date_before(dates[0]).strftime('%Y%m%d'),
                end_date=trade_date_before(dates[-1]).strftime('%Y%m%d'),
                codes=self.fund_pool.fund_code
        )
        df_fund_inc = df_fund_nav.pct_change().iloc[1:]

        df_fund_inc_estimated = asset_fund_inc_estimate.load_fund_inc_estimate(
                begin_date=dates[0].strftime('%Y%m%d'),
                end_date=trade_date_before(dates[-1]).strftime('%Y%m%d'),
                fund_codes=self.fund_pool.fund_code,
                methods=['sk_pos', 'ix_pos']
        )

        lookback = 1
        df_fund_mix_pos = pd.DataFrame()
        for date, next_date in zip(dates[:-lookback], dates[lookback:]):

            # print('cal_mix_pos_days', next_date)
            next_date += relativedelta(days=-1)

            fund_inc = df_fund_inc.loc[date:next_date]
            fund_inc_estimated = df_fund_inc_estimated.loc[date:next_date]
            fund_inc_estimated = fund_inc_estimated.unstack().stack(level=0, dropna=False).dropna(axis='columns').unstack()

            fund_mix_pos = pd.DataFrame(columns=['sk_pos', 'ix_pos'])
            fund_mix_pos.index.name = 'fund_code'
            for fund_code in fund_inc.columns.intersection(fund_inc_estimated.columns.levels[0]):
                fund_mix_pos.loc[fund_code] = self.__cal_mix_pos(fund_inc_estimated[fund_code], fund_inc[fund_code])
            fund_mix_pos['date'] = next_date + relativedelta(days=+1)
            fund_mix_pos = fund_mix_pos.reset_index().set_index(['date', 'fund_code'])

            df_fund_mix_pos = pd.concat([df_fund_mix_pos, fund_mix_pos])

        return df_fund_mix_pos
    def __cal_ix_pos_days(self):

        begin_date_cal = self.begin_date + relativedelta(months=-3, day=1)
        dates = pd.Series(index=[begin_date_cal, self.end_date])
        dates = dates.resample('MS').first().index

        df_fund_nav = base_ra_fund_nav.load_daily(
                begin_date=trade_date_before(dates[0]).strftime('%Y%m%d'),
                end_date=trade_date_before(dates[-1]).strftime('%Y%m%d'),
                codes=self.fund_pool.fund_code
        )
        df_fund_inc = df_fund_nav.pct_change().iloc[1:]

        df_index_nav = caihui_tq_qt_index.load_index_nav(
                begin_date=trade_date_before(dates[0]).strftime('%Y%m%d'),
                end_date=trade_date_before(dates[-1]).strftime('%Y%m%d'),
                index_ids=self.index_ids
        )
        df_index_inc = df_index_nav.pct_change().iloc[1:]

        lookback = 3
        df_fund_index_pos = pd.DataFrame()
        for date, next_date in zip(dates[:-lookback], dates[lookback:]):

            # print('cal_ix_pos_days', next_date)
            next_date += relativedelta(days=-1)

            fund_inc = df_fund_inc.loc[date:next_date].dropna(how='any', axis='columns')
            index_inc = df_index_inc.loc[date:next_date]

            fund_index_pos = pd.DataFrame(columns=self.index_ids)
            fund_index_pos.index.name = 'fund_code'
            for fund_code in fund_inc.columns:
                fund_index_pos.loc[fund_code] = self.__cal_ix_pos(index_inc, fund_inc[fund_code])
            fund_index_pos['date'] = next_date + relativedelta(days=+1)
            fund_index_pos = fund_index_pos.reset_index().set_index(['date', 'fund_code'])

            df_fund_index_pos = pd.concat([df_fund_index_pos, fund_index_pos])

        return df_fund_index_pos