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