def _create_return_df(self, target_day=None): if self._is_weekly: date_list = cf.create_weekly_datelist(self._start_date, self._end_date) else: date_list = cf.create_monthly_datelist(self._start_date, self._end_date) weekly_price = self._price_df.loc[date_list] if target_day is None: return pd.DataFrame(np.log(np.array(weekly_price.iloc[1:]) \ / np.array(weekly_price.iloc[:-1])), index = weekly_price.index[:-1], columns = ['Return']) else: target_date_list = cf.create_weekly_datelist(self._start_date, self._end_date, weeknum=target_day) target_price = self._price_df.loc[target_date_list] if target_date_list[0] > date_list[0]: if target_price.shape[0] < weekly_price.shape[0]: weekly_price = weekly_price.iloc[:-1] elif target_price.shape[0] == weekly_price.shape[0]: target_price = target_price.iloc[1:] weekly_price = weekly_price.iloc[:-1] elif target_date_list[0] < date_list[0]: if target_price.shape[0] > weekly_price.shape[0]: target_price = target_price.iloc[1:] elif target_price.shape[0] == weekly_price.shape[0]: target_price = target_price.iloc[1:] weekly_price = weekly_price.iloc[:-1] return pd.DataFrame(np.log(np.array(target_price) \ / np.array(weekly_price)), index = weekly_price.index, columns = ['Return'])
def __init__(self, *args, **kwargs): self._logger = logging.getLogger("jpbank.quants") self._logger.info("{0} initializing...".format(self.__class__.__name__)) self._start_date = kwargs.get('start_date', date(2001, 1, 1)) self._end_date = kwargs.get('end_date', date.today()) self._ar_diff = kwargs.get('ar_diff', 3) self._frequency = kwargs.get('frequency', 'weekly') if self._frequency == 'daily': self._date_list = cf.create_daily_datelist(self._start_date, self._end_date) self._term = int(kwargs.get('term_year', 3) * 261) elif self._frequency == 'weekly': self._date_list = cf.create_weekly_datelist(self._start_date, self._end_date) self._term = int(kwargs.get('term_year', 3) * 52) else: self._date_list = cf.create_monthly_datelist(self._start_date, self._end_date) self._term = int(kwargs.get('term_year', 3) * 12) self._ccy_list = kwargs.get('ccy_list', np.sort(['USDJPY Index', 'EURJPY Index', 'AUDJPY Index', 'GBPJPY Index', 'CADJPY Index', 'CHFJPY Index', 'NZDJPY Index']).tolist()) self._order = kwargs.get('order', 0) if self._order == -1: self._reg = 'nc' elif self._order == 0: self._reg = 'c' elif self._oder == 1: self._reg = 'ct' self._fx_rate_df = np.log(self._get_fx_rate()) self._logger.info("{0} initialized.".format(self.__class__.__name__))
def __init__(self, *args, **kwargs): self._start_date = kwargs.get('StartDate', date(2000,1,1)) self._end_date = kwargs.get('EndDate', date(2020, 4 , 17)) self._target_ccy = kwargs.get('TargetCcy', ['ZAR', 'USD']) self._is_weekly = kwargs.get('is_weekly', True) self._label_tickers = kwargs.get('label_tickers', ['NFCIINDX Index', 'GSUSFCI Index']) threshold_list = kwargs.get('threshold', [5, 0.6]) assert len(threshold_list) == len(self._label_tickers) self._threshold_dic = {} for i in range(len(self._label_tickers)): self._threshold_dic[self._label_tickers[i]] = threshold_list[i] self._price_ticker = [self._target_ccy[1] + self._target_ccy[0] + ' Index'] self._price_df = self.create_factor(self._price_ticker) if self._is_weekly: self._date_list = cf.create_weekly_datelist(self._start_date, self._end_date) else: self._date_list = cf.create_monthly_datelist(self._start_date, self._end_date) self._surprise_ticker = 'CESI' + self._target_ccy[0] + ' Index' self._datachange_ticker = 'CECIC' + self._target_ccy[0] + ' Index' self._ctot_ticker = 'CTOT' + self._target_ccy[0] + ' Index' self._value_ticker = ['BISB' + ccy[:2] + 'N Index' for ccy in self._target_ccy] #self._value_ticker = 'CTTWBR' + self._target_ccy[0][:2] + 'N Index' self._carry_ticker_dic = {'USD':'USGG2YR Index', 'ZAR':'GSAB2YR Index', 'MXN':'GMXN02YR Index', 'TRY':'GTRU2YR Index'}
def _create_rsi(self, rsi_param=7, col_name='RSI'): if self._is_weekly: date_list = cf.create_weekly_datelist(self._start_date, self._end_date) else: date_list = cf.create_monthly_datelist(self._start_date, self._end_date) return pd.DataFrame([ta.RSI(np.array(self._price_df.iloc[:, i]), rsi_param) for i in range(self._price_df.shape[1])], index=[col_name], columns=self._price_df.index).T.loc[date_list]
def _create_carry_df(self, col_name='Carry'): if self._is_weekly: date_list = cf.create_weekly_datelist(self._start_date, self._end_date) else: date_list = cf.create_monthly_datelist(self._start_date, self._end_date) carry_df = self.create_factor(self._carry_ticker) carry_df[col_name] = carry_df[self._carry_ticker[0]]\ -carry_df[self._carry_ticker[1]] return carry_df[[col_name]].loc[date_list]
def _create_iv_df(self, vi_type='R', delta=25, vi_term='1W'): if self._is_weekly: date_list = cf.create_weekly_datelist(self._start_date, self._end_date) else: date_list = cf.create_monthly_datelist(self._start_date, self._end_date) target_ticker = self._target_ccy[1] + self._target_ccy[0] \ + str(delta) + vi_type + vi_term + ' BGN Curncy' return self.create_factor([target_ticker]).loc[date_list]
def _create_ctot_df(self, col_name='CTOT'): if self._is_weekly: date_list = cf.create_weekly_datelist(self._start_date, self._end_date) else: date_list = cf.create_monthly_datelist(self._start_date, self._end_date) ctot_df = self.create_factor(self._ctot_ticker) ctot_df[col_name] = ctot_df['CTOT'+self._target_ccy[1]+' Index']\ -ctot_df['CTOT'+self._target_ccy[0]+' Index'] return ctot_df[[col_name]].loc[date_list]
def _create_value_df(self, col_name='Value'): if self._is_weekly: date_list = cf.create_weekly_datelist(self._start_date, self._end_date) else: date_list = cf.create_monthly_datelist(self._start_date, self._end_date) value_df = self.create_factor(self._value_ticker) value_df[col_name] = value_df['BISB'+self._target_ccy[1][:2]+'N Index']\ -value_df['BISB'+self._target_ccy[0][:2]+'N Index'] return value_df[[col_name]].loc[date_list]
def _create_surprise_df(self, col_name='Surprise'): if self._is_weekly: date_list = cf.create_weekly_datelist(self._start_date, self._end_date) else: date_list = cf.create_monthly_datelist(self._start_date, self._end_date) surprise_df = self.create_factor(self._surprise_ticker) surprise_df[col_name] = surprise_df['CESI'+self._target_ccy[1]+' Index'] \ - surprise_df['CESI'+self._target_ccy[0]+' Index'] return surprise_df[[col_name]].loc[date_list]
def __init__(self, *args, **kwargs): self._input_data = cf.convert_date_format( pd.read_csv( os.path.join(os.path.dirname(__file__), '../input', 'all_input_data.csv'))) self._start_date = kwargs.get('StartDate', date(2000, 1, 1)) self._end_date = kwargs.get('EndDate', date(2020, 7, 17)) self._target_ccy = kwargs.get('TargetCcy', ['ZAR', 'MXN']) self._base_ccy = kwargs.get('BaseCcy', 'USD') self._label_tickers = kwargs.get('label_tickers', ['NFCIINDX Index', 'GSUSFCI Index']) self._ticker_threshold = kwargs.get('ticker_threshold', { 'GSUSFCI Index': -0.05, 'NFCIINDX Index': 0 }) self._threshold_dic = {} for i in range(len(self._label_tickers)): if self._label_tickers[i] == 'GSUSFCI Index': self._threshold_dic[self._label_tickers[i]] = { 'Upper': 0.6, 'Lower': -0.6 } else: self._threshold_dic[self._label_tickers[i]] = { 'Upper': 3, 'Lower': -3 } self._price_ticker = [ self._base_ccy + self._target_ccy[0] + ' Index', self._base_ccy + self._target_ccy[1] + ' Index' ] self._price_df = self.create_factor(self._price_ticker) self._date_list = cf.create_weekly_datelist(self._start_date, self._end_date) self._surprise_ticker = 'CESI' + self._target_ccy[0] + ' Index' self._datachange_ticker = 'CECIC' + self._target_ccy[0] + ' Index' self._ctot_ticker = 'CTOT' + self._target_ccy[0] + ' Index' self._value_ticker = [ 'BISB' + ccy[:2] + 'N Index' for ccy in self._target_ccy ] self._fc_tickers = ['NFCIINDX Index', 'GSUSFCI Index'] self._carry_ticker_dic = { 'USD': 'USGG2YR Index', 'ZAR': 'GSAB2YR Index', 'MXN': 'GMXN02YR Index', 'TRY': 'GTRU2YR Index' }
def _create_datachange_df(self, col_name='DataChange'): if self._is_weekly: date_list = cf.create_weekly_datelist(self._start_date, self._end_date) else: date_list = cf.create_monthly_datelist(self._start_date, self._end_date) datachange_df = self.create_factor(self._datachange_ticker) if 'JPY' in self._price_ticker[0]: datachange_df[col_name] = datachange_df['CECIC'+self._target_ccy[1]+' Index'] else: datachange_df[col_name] = datachange_df['CECIC'+self._target_ccy[1]+' Index']\ -datachange_df['CECIC'+self._target_ccy[0]+' Index'] return datachange_df[[col_name]].loc[date_list]
def _calc_aggregated_hitratio(self, return_df, is_monthly=True): if is_monthly: date_list = cf.create_monthly_datelist( start_date=return_df.index[0], end_date=return_df.index[-1]) else: date_list = cf.create_weekly_datelist( start_date=return_df.index[0], end_date=return_df.index[-1]) date_list = np.array(date_list) aggr_return = copy.deepcopy(return_df) aggr_return['AggregateDate'] = [date_list[date_list>=return_df.index[i]][0] if np.any(date_list>=return_df.index[i]) \ else return_df.index[-1]\ for i in range(return_df.shape[0])] grouped_df = aggr_return.groupby(['AggregateDate']).sum() return pd.DataFrame( grouped_df.where(grouped_df > 0).count() / grouped_df.shape[0]).T
def _create_label_df(self): date_list = cf.create_weekly_datelist(self._start_date, self._end_date) sim_return_df = pd.DataFrame() fc_normalized_df = pd.DataFrame() price_return_df = pd.DataFrame() for lable_ticker in self._label_tickers: if lable_ticker == 'NFCIINDX Index': indic_diff = True else: indic_diff = False if sim_return_df.shape[0] == 0: sim_return_df, fc_normalized_df, price_return_df = self._get_sim_return( lable_ticker, indic_diff) else: return_df, fc_df, pr_df = self._get_sim_return( lable_ticker, indic_diff) sim_return_df = pd.merge(sim_return_df, return_df, right_index=True, left_index=True) fc_normalized_df = pd.merge(fc_normalized_df, fc_df, right_index=True, left_index=True) sim_return_df.columns = self._label_tickers modified_return_df = pd.DataFrame([[ sim_return_df[ticker].iloc[i] if fc_normalized_df['GSUSFCI Index'].iloc[i] < self._threshold_dic[ticker]['Upper'] and fc_normalized_df['GSUSFCI Index'].iloc[i] > self._threshold_dic[ticker]['Lower'] else 0 for i in range(sim_return_df.shape[0]) ] for ticker in self._label_tickers], index=self._label_tickers, columns=sim_return_df.index).T modified_return_df.to_csv('mod_return.csv') return pd.DataFrame([0 if modified_return_df.iloc[i][self._label_tickers[0]] >= modified_return_df.iloc[i][self._label_tickers[1]] else 1 for i in range(modified_return_df.shape[0])], index=modified_return_df.index, columns=['Return']),\ fc_normalized_df, price_return_df
def _create_label_df(self): if self._is_weekly: date_list = cf.create_weekly_datelist(self._start_date, self._end_date) else: date_list = cf.create_monthly_datelist(self._start_date, self._end_date) label_query = "SELECT ValueDate, Ticker, Last \ FROM bbg_marketprice \ WHERE ValueDate BETWEEN '{0}' AND '{1}' \ AND Ticker IN ('{2}')".format(self._start_date, self._end_date, "','".join(self._label_tickers)) with util.DBConnector(DBName='marketdb') as db_conn: label_src_df = db_conn.get_data(label_query).pivot(index='ValueDate', columns='Ticker', values='Last').dropna(axis=0) label_src_df['NFCIINDX Index'] = [np.nan] + label_src_df['NFCIINDX Index'].iloc[:-1].tolist() label_src_df.dropna(axis=0, inplace=True) #import pdb;pdb.set_trace() for ticker in self._label_tickers: label_src_df[ticker] = self._normalize_data(label_src_df[[ticker]], term=104) #import pdb;pdb.set_trace() #label_src_df[ticker] = label_src_df[ticker].apply(lambda x: x if abs(x) < self._threshold_dic[ticker] else 0) import pdb;pdb.set_trace() label_src_df.to_csv('fc_label_src.csv') label_list = [] for i in range(label_src_df.shape[0]): if label_src_df.iloc[i].max() < 0: label = [0, 0, 1] elif label_src_df.iloc[i][self._label_tickers[0]] > label_src_df.iloc[i][self._label_tickers[1]]: label = [1, 0, 0] else: label = [0, 1, 0] label_list.append(label) return pd.DataFrame(label_list, index=label_src_df.index, columns=self._label_tickers + ['N/A']).reindex(date_list)
def __init__(self, **kwargs): super().__init__(**kwargs) self._logger.info("{0} initializing...".format( self.__class__.__name__)) self._start_date = kwargs.get('start_date', None) self._end_date = kwargs.get('end_date', None) interval = kwargs.get('interval', 1) frequency = kwargs.get('frequency', 'weekly') if frequency == 'daily': date_list = cf.create_daily_datelist(self._start_date, self._end_date) elif frequency == 'weekly': date_list = cf.create_weekly_datelist(self._start_date, self._end_date) else: date_list = cf.create_monthly_datelist(self._start_date, self._end_date) coint_vec_file = kwargs.get('coint_Vec_file', './input/coint_vec.csv') self._weight_df = cf.convert_date_format(pd.read_csv(coint_vec_file))\ .set_index('ValueDate').loc[date_list] self._fx_rate_df = np.log( cf.get_fx_rate(self._start_date, self._end_date, self._weight_df.columns.tolist())).loc[date_list] #import pdb;pdb.set_trace() self._coint_index_df = pd.DataFrame( (self._fx_rate_df * self._weight_df[self._fx_rate_df.columns]).sum(axis=1), columns=['Price']).loc[date_list] #self._index_return_df = pd.DataFrame(self._coint_index_df[interval:] - self._coint_index_df[:-interval], # index = self._fx_rate_df.index[:-interval], # columns = ['Return'])#.loc[date_list] self._logger.info("{0} initialized.".format(self.__class__.__name__))
def __init__(self, **kwargs): self._logger = logging.getLogger("jpbank.quants") self._logger.info("{0} initializing...".format(self.__class__.__name__)) self._input_data = cf.convert_date_format(pd.read_csv(os.path.join(os.path.dirname(__file__), '../input', 'all_input_data.csv'))) self._fc_threshold = kwargs.get('fc_threshold', 0) self._includes_swap = kwargs.get('includes_swap', True) self._rolls = kwargs.get('rolls', False) self._start_date = kwargs.get('start_date', date(2003, 3, 28)) self._end_date = kwargs.get('end_date', date.today()) self._has_indication_diff = kwargs.get('has_indication_diff', True)#Chicago:True/GS:False self._roll_term = kwargs.get('roll_term', 52) self._date_list = cf.create_weekly_datelist(self._start_date, self._end_date) self._price_tickers = kwargs.get('price_tickers', ['USDZAR Index', 'USDMXN Index']) self._em_rate_tickers = kwargs.get('em_rate_tickers', ['GSAB2YR Index', 'GMXN02YR Index']) self._em_fwd_tickers = kwargs.get('em_fwd_tickers', ['USDZAR1W BGN Curncy', 'USDMXN1W BGN Curncy']) assert len(self._em_fwd_tickers) == len(self._em_rate_tickers) == len(self._price_tickers) self._em_price_rate_dic, self._em_rate_price_dic = self._create_ticker_dic(self._price_tickers, self._em_rate_tickers) self._em_price_fwd_dic, self._em_fwd_price_dic = self._create_ticker_dic(self._price_tickers, self._em_fwd_tickers) self._exp_return_file = kwargs.get('exp_return_file', None) self._base_rate_ticker = kwargs.get('base_rate_ticker', 'USGG2YR Index') self._fc_tickers = kwargs.get('fc_tickers', ['NFCIINDX Index', 'GSUSFCI Index']) self._price_df = self._get_price(self._price_tickers + self._em_rate_tickers + self._em_fwd_tickers + [self._base_rate_ticker] + self._fc_tickers) #calculate rate diff for em_ticker in self._em_rate_tickers: self._price_df[em_ticker] = self._price_df[em_ticker] - self._price_df[self._base_rate_ticker] self._logger.info("{0} initialized.".format(self.__class__.__name__))
def simulate(self): self._logger.info("Simulation Starting...") src_date_list = cf.create_weekly_datelist(self._start_date, self._end_date) rate_return_df = self._calc_return(self._price_df[self._em_rate_tickers].loc[src_date_list]) stock_diff_df = pd.DataFrame(np.array(self._price_df[self._fc_tickers].loc[src_date_list].iloc[1:]) / np.array(self._price_df[self._fc_tickers].loc[src_date_list].iloc[:-1]), index = self._price_df.loc[src_date_list].index[1:], columns = self._fc_tickers) src_return_df = pd.merge(rate_return_df, stock_diff_df, right_index=True, left_index=True) normalized_df = pd.DataFrame([[self._normalize(src_return_df[ticker], value_date) for value_date in self._date_list[1:]] for ticker in self._em_rate_tickers + self._fc_tickers], index = self._em_rate_tickers + self._fc_tickers, columns = self._date_list[1:]).T.dropna(axis=0) if self._exp_return_file is None: self._logger.info("Selecting EM Currency Tickers usgin Rate") em_prior_tickers = pd.DataFrame([(self._em_rate_price_dic[normalized_df[self._em_rate_tickers].iloc[i].idxmax()], self._em_rate_price_dic[normalized_df[self._em_rate_tickers].iloc[i].idxmin()]) for i in range(normalized_df.shape[0])], index = normalized_df.index, columns = ['best', 'worst']) else: self._logger.info("Selecting EM Currency Tickers usgin Expected Return") exp_return_df = pd.read_csv(self._exp_return_file) exp_return_df = cf.convert_date_format(exp_return_df, target_col='ValueDate').set_index('ValueDate') em_prior_tickers = pd.DataFrame([(exp_return_df[self._price_tickers].iloc[i].idxmax(), exp_return_df[self._price_tickers].iloc[i].idxmin()) for i in range(exp_return_df.shape[0])], index = exp_return_df.index, columns = ['best', 'worst']) if self._has_indication_diff:#one week delay, like Chicago FC indict_df = pd.DataFrame([False] + normalized_df[self._fc_tickers[0]].iloc[:-1]\ .apply(lambda x: True if x < self._fc_threshold else False).tolist(), index = normalized_df.index, columns = ['fc_priority']) else: min_ir_return = normalized_df[self._em_rate_tickers].min(axis=1) ir_indication = pd.DataFrame([np.all(min_ir_return.iloc[i:i + self._ir_diff] < 0) for i in range(min_ir_return.shape[0] - (self._ir_diff - 1))], index = min_ir_return.index[(self._ir_diff - 1):], columns = ['ir_priority']) #ir_indication = pd.DataFrame([min_ir_return.iloc[i:i + self._ir_diff].mean() < 0 # for i in range(min_ir_return.shape[0] - (self._ir_diff - 1))], # index = min_ir_return.index[(self._ir_diff - 1):], # columns = ['ir_priority']) stock_indication = pd.DataFrame(stock_diff_df[self._fc_tickers[0]]\ .apply(lambda x: True if x > self._fc_threshold else False).tolist(), index = stock_diff_df.index, columns = ['fc_priority']) #indict_df = stock_indication #indict_df.columns = ['fc_priority'] indict_df = pd.DataFrame(pd.merge(ir_indication, stock_indication, right_index=True, left_index=True)\ .sum(axis=1).apply(lambda x:True if x == 2 else False), columns = ['fc_priority']) sign_df = pd.merge(em_prior_tickers, indict_df, right_index=True, left_index=True) self._logger.info("Building Position...") #Risk On: Long EM Ccy of Worst Score ->Position: -1(USD Short, EM Long) #of Worst #Risk OFF: Short EM Ccy of Best Score ->Position: 1(USD Long, EM Short) #of Best position_df = pd.DataFrame([(sign_df.iloc[i]['worst'], -1) if sign_df.iloc[i]['fc_priority'] else (sign_df.iloc[i]['best'], 1) for i in range(sign_df.shape[0])], index = sign_df.index, columns=['ccy', 'ls']) position_df.index.name = 'ValueDate' #position_df = pd.DataFrame([[-1 / len(self._price_tickers) # for j in range(len(self._price_tickers))] # if sign_df.iloc[i]['fc_priority'] # else [1 / len(self._price_tickers) # for j in range(len(self._price_tickers))] # for i in range(sign_df.shape[0])], # index = sign_df.index) if self._includes_swap: price_return_df = self._calc_return_inc_swap(self._price_df[self._price_tickers + [self._em_price_fwd_dic[k] for k in self._em_price_fwd_dic.keys()]].loc[self._date_list], self._price_tickers, self._em_price_fwd_dic).loc[position_df.index] else: price_return_df = self._calc_return(self._price_df[self._price_tickers].loc[self._date_list], with_log=True).loc[position_df.index] self._logger.info("Calculating Perofrmance...") #import pdb;pdb.set_trace() return_series_df = pd.DataFrame([price_return_df[position_df.iloc[i][0]].iloc[i + 1] * position_df.iloc[i][1] for i in range(position_df.shape[0] - 1)], index = position_df.index[:-1], columns=['return']) #return_series_df = pd.DataFrame((np.array(price_return_df)[1:] * #position_df[:-1]).sum(axis=1), # columns=['return']) return_series_df.index.name = 'ValueDate' return_series_df['cum_return'] = return_series_df['return'].cumsum() #output result output_suffix = datetime.now().strftime('%Y%m%d%H%M%S') self.output_detaild_result(position_df, return_series_df, output_suffix) pd.merge(return_series_df, sign_df, right_index=True, left_index=True)\ .to_csv(os.path.join('output', 'em_reutrn_series_{1}_{0}.csv'.format(output_suffix, self._fc_tickers[0]))) perform_measurer = PerformanceMeasurer() #perform_measurer.create_result_summary(return_series_df['return']).to_csv('em_performance.csv') perform_measurer.create_result_summary(return_series_df)[['return']]\ .to_csv(os.path.join('output','em_performance_{1}_{0}.csv'.format(output_suffix, self._fc_tickers[0]))) self._logger.info("Simulation Complated.")
coint_vec_df.set_index('ValueDate', inplace=True) ccy_list = coint_vec_df.columns.tolist() term_week = 104 fx_rate_df = np.log(cf.get_fx_rate(start_date = coint_vec_df.index[0] - relativedelta(weeks=term_week), end_date = coint_vec_df.index[-1], ccy_list = ccy_list)) output_df = pd.DataFrame() price_list = [] for i in range(coint_vec_df.shape[0]-1): value_date = coint_vec_df.index[i] #value_date = date(2019,2,22) logger.info("Processing in {0}".format(value_date)) start_date = value_date - relativedelta(weeks=term_week) next_date = coint_vec_df.index[i+1] normal_date_list = cf.create_weekly_datelist(start_date, value_date) follow_date_list = cf.create_weekly_datelist(start_date, next_date) weight_df = coint_vec_df.iloc[i] #weight_df = coint_vec_df.loc[value_date] follow_price_df = fx_rate_df.loc[follow_date_list].query("index > @start_date & index <= @next_date")[ccy_list]# normal_price_df = fx_rate_df.loc[normal_date_list].query("index > @start_date & index <= @value_date")[ccy_list]# follow_pvalue = sm.tsa.stattools.adfuller((follow_price_df[ccy_list]*weight_df).sum(axis=1), regression='c')[1] normal_pvalue = sm.tsa.stattools.adfuller((normal_price_df[ccy_list]*weight_df).sum(axis=1), regression='c')[1] price_list.append((normal_price_df[ccy_list]*weight_df).sum(axis=1).tolist()) #import pdb;pdb.set_trace() output_df = output_df.append([[value_date, normal_pvalue, follow_pvalue]]) output_df.columns = ['ValueDate', 'Current', 'Following']
def get_fx_rate(start_date=date(2001,1,1), end_date=date.today(), ccy_list=['USDJPY Index','EURJPY Index']): fx_query = "SELECT ValueDate, Ticker, Last "\ " FROM bbg_marketprice "\ " WHERE ValueDate BETWEEN '{0}' AND '{1}' "\ " AND Ticker IN ('{2}')".format(start_date, end_date, "','".join(ccy_list)) with DBConnector(DBName='marketdb') as db_conn: return db_conn.get_data(fx_query).pivot(index='ValueDate', columns='Ticker', values='Last') if __name__== '__main__': ccy_list = ['USDJPY Index','EURJPY Index', 'AUDJPY Index', 'GBPJPY Index', 'CHFJPY Index', 'NZDJPY Index']#, 'ZARJPY Index', 'TRYJPY Index'] start_date = date(2000,1,1) end_date= date.today() date_list = cf.create_weekly_datelist(start_date, end_date) fx_df = get_fx_rate(ccy_list=ccy_list, start_date=start_date, end_date=end_date).loc[date_list] #fx_df = fx_df.apply(lambda x:np.log(x)) #fx_df['ZARJPY Index'] = fx_df['ZARJPY Index'] * 10 fx_df.to_csv('fx_df.csv') #term = 783 term = 156 ar_diff = 5 coint_df = pd.DataFrame() pvalue_list = [] for i in tqdm(range(term, fx_df.shape[0])): min_pvalue=1.0 target_vec = [] eigen_vec = coint_johansen(endog=fx_df[ccy_list].iloc[i-term:i], det_order=1, k_ar_diff=ar_diff).evec
def __init__(self, **kwargs): self._logger = logging.getLogger("jpbank.quants") self._logger.info("{0} initializing...".format( self.__class__.__name__)) self._fc_threshold = kwargs.get('fc_threshold', 0) self._includes_swap = kwargs.get('includes_swap', True) self._rolls = kwargs.get('rolls', False) self._start_date = kwargs.get('start_date', date(2003, 3, 28)) self._end_date = kwargs.get('end_date', date(2019, 12, 27)) self._has_indication_diff = kwargs.get('has_indication_diff', True) if self._rolls: self._roll_term = kwargs.get('roll_term', 52) self._date_list = cf.create_weekly_datelist( self._start_date + relativedelta(weeks=self._roll_term), self._end_date) else: self._date_list = cf.create_weekly_datelist( self._start_date, self._end_date) self._price_tickers = kwargs.get('price_tickers', ['USDZAR Index', 'USDMXN Index']) self._em_rate_tickers = kwargs.get('em_rate_tickers', ['GSAB2YR Index', 'GMXN02YR Index']) self._em_fwd_tickers = kwargs.get( 'em_fwd_tickers', ['USDZAR1W BGN Curncy', 'USDMXN1W BGN Curncy']) assert len(self._em_fwd_tickers) == len(self._em_rate_tickers) == len( self._price_tickers) self._em_price_rate_dic, self._em_rate_price_dic = self._create_ticker_dic( self._price_tickers, self._em_rate_tickers) self._em_price_fwd_dic, self._em_fwd_price_dic = self._create_ticker_dic( self._price_tickers, self._em_fwd_tickers) self._exp_return_file = kwargs.get('exp_return_file', None) self._base_rate_ticker = kwargs.get('base_rate_ticker', 'USGG2YR Index') self._fc_tickers = kwargs.get('fc_tickers', ['NFCIINDX Index']) self._price_df = self._get_price(self._price_tickers + self._em_rate_tickers + self._em_fwd_tickers + [self._base_rate_ticker] + self._fc_tickers) #if len(self._fc_tickers) > 1: # fc_weight = kwargs.get('fc_weight', [0.5, 0.5]) # import pdb;pdb.set_trace() # self._price_df['MixedFC'] = (self._price_df[self._fc_tickers] * # np.array(fc_weight)).sum(axis=0).tolist() # self._fc_tickers = ['MixedFC'] #calculate rate diff for em_ticker in self._em_rate_tickers: self._price_df[em_ticker] = self._price_df[ em_ticker] - self._price_df[self._base_rate_ticker] self._logger.info("{0} initialized.".format(self.__class__.__name__))